	THIS UIC CONTAINS ALL THE MACRO AND FORTRAN SOURCES TO BUILD THE
CETUS LIBRARY, A LIBRARY OF FORTRAN CALLABLE ROUTINES TO DO MANY USEFULL
THINGS.  THERE ARE *.RNO FILES TO DOCUMENT EACH ROUTINE, AND AN ATTEPMT AT
A LARGE DOCUMENT FOR THE WHOLE LIBRARY.  UNFORTUNATELY, WE HAVE NOT HAD THE
TIME TO CLEAN UP THIS DOCUMENTATION, AND IT IS VERY MUCH IN NEED OF IT.
THE LARGE FILE, CETUS.RNO, IS IN FAIRLY GOOD SHAPE, BUT IT DOES NOT CONTAIN
ALL OF THE ROUTINES THAT ARE AVAILABLE.  THE INDIVIDUAL *.RNO FILES FOR EACH
ROUTINE ARE NOT NECESSARILY AS UP TO DATE AS THE VERSIONS IN THE CETUS.RNO
FILE, BUT THERE ARE DOCUMENT FILES FOR (ALMOST) ALL OF THE ROUTINES.
MY RECOMENDATION IS THAT YOU TAKE THE TIME TO PRINT THE CETUS.DOC OUTPUT,
AND REFER TO THE INDIVIDUAL FILES IF YOU SEE AN INTERESTING SUBROUTINE THAT
IS NOT MENTIONED.

	THERE ARE SEVERAL CATEGORIES OF ROUTINES IN THIS LIBRARY, AND THE CETUS
DOC FILE LISTS THEM IN ABOUT THE SAME ORDER AS THIS OVERVIEW HERE DOES:

	ARITHMETIC PARSER ROUTINES:  A SET OF ROUTINES FOR PARSING ARITHMETIC
	EXPRESSIONS AT RUN TIME FROM FORTRAN.  ALL OF THE FORTRAN BINARY AND
	UNARY OPERATIONS ARE SUPPORTED, AND SEVERAL FUNCTIONS.  IN ADDITION,
	GENERALIZED ARITHMETIC EXPRESSIONS ARE ALSO SUPPORTED (A LA C), AND
	SYMBOLIC LOGIC OPERATIONS AS WELL.  THE ARITHMETIC PACKAGE WORKS
	ENTIRELY IN REAL NUMBERS, SO THE LOGIC OPERATIONS CANNOT BE USED TO
	DO BIT MANIPULATION, BUT THE PACKAGE HAS PROOVED TO BE EXTREEMLY
	USEFULL IN WRITING FLEXIBLE STATISICAL END-USER TYPE PROGRAMS.

	DATABASE ROUTINES: THIS IS A SET OF FILE MANAGEMENT ROUTINES FOR
	STORING DATA IN A TREE STRUCTURED DATA FILE.  IT HAS BEEN USED FOR
	OVER A YEAR TO STORE DATA AND INFORMATION ABOUT MILLIONS OF INDUSTRIAL
	MICRO-ORGANISMS, WITH VIRTUALLY NO PROBLEMS.

	FILES-11 MANIPULATION ROUTINES: A COLLECTION OF SUBROUTINES WHICH
	ALLOW FORTRAN TO DELETE, RENAME, TURN OFF FORTRAN CARRAGE CONTROL,
	ATTACH, DETACH, AND IN GENERAL DO THINGS WHICH PREVIOUSLY COULD
	ONLY BE DONE FROM MACRO11

	SORT ROUTINES:  A VERY EASY-TO-USE PACKAGE OF ROUTINES FOR SORTING
	LARGE AMOUNTS OF DATA WITH A KEYED QUICKSORT.  IF YOU USE ONLY THE
	SETSRT/PUTSRT/GETSRT ROUTINES, DATA IS SORTED IN CORE WHENEVER POSSIBLE,
	AND IS MERGED ONTO DISK FILES IF THE AMOUNT OF DATA WARRENTS IT.

	STRING FUNCTIONS:  SUBROUTINES FOR MANIPULATING STRINGS FROM FORTRAN.
	INCLUDED ARE ROUTINES FOR COMPARING STRINGS, CONVERTING STRINGS TO
	BINARY NUMBERS (FLOATING, INTEGER, OCTAL, HEX) AND BACK AGAIN, ALSO
	A SNOBOL-LIKE PATTERN MATCH ROUTINE.

	ALL OF THE ROUTINES HAVE BEEN USED FOR QUITE SOME TIME HERE AT CETUS,
BUT BUGS WILL ALWAYS CROP UP.  IF YOU FIND ANY, OR IF YOU WISH HELP IN HOW TO
USE THE SUBROUTINES, PLEASE CALL OR WRITE:

	MIKE HIGGINS
	CETUS CORPORATION
	600 BANCROFT WAY
	BERSERKELEY CA 94710
	(415) 549-3300 X218

			SUPER MAC
	MOST OF THE MACRO ROUTINES IN THIS UIC WERE WRITTEN WITH OUR OWN
TAYLORED VERSION OF SUPER MAC, SO A COPY IS INCLUDED IN A FILE NAMED SUPER.MAC.
THIS SUPERMAC IS DESIGNED TO BE ADDED TO RSXMAC.SML AND CALLED WITH AN .MCALL
DIRECTIVE, AS FOLLOWS:
	.MCALL SUPER
	SUPER
OR, IF YOU DO NOT WISH TO ADD IT TO YOUR MACRO LIBRARY, YOU CAN ADD IT TO ANY
SINGLE ROUTINE BY TYPING:
	>MAC YOURFILE=SUPER/PA:1,YOURFILE
ANY ROUTINE ASSEMBLED IN THIS MANNER MUST STILL INVOKE THE MACRO "SUPER" BEFORE
INVOKING ANY SUPERMAC STATEMENTS.

	THERE ARE ONLY A FEW DIFERENCES BETWEEN THIS SUPERMAC AND THE ONE WE
RECEIVED AFTER THE FALL 1975 DECUS SYMPOSIUM.  WE HAVE BEEN SO HAPPY WITH
THIS VERSION THAT WE HAVE NOT INVESTIGATED DIFFERENCES BETWEEN OUR VERSION
AND THE ONE ON THE FALL 1978 SF DECUS TAPE.  FOLLWOING IS A LIST OF THE CHANGES
WE HAVE MADE:

		THE $CALL MACRO HAS BEEN RE-NAMED SCALL FOR SUPERMAC CALL.

		THE RETURN STATEMENT WAS FOUND TO HAVE A BUG WHICH WE WERE ABLE
	TO FIX.

		THE LET STATEMENT HAS BEEN MODIFIED TO UNDERSTAND . (POINT) 
	FOLLOWING AN ARITHMETIC REPLACEMENT SYMBOL.  THIS ALLOWS COMPLEX
	DESTINATION FIELDS TO BE MODIFIED WHITHOUT HAVING TO TYPE THEM TWICE.
	FOR EXAMPLE:
		LET RT.SIZE(ROOT) := . + #RECSIZ
	IS MUCH EASIER TO TYPE THAN THE OLD STATEMENT:
		LET RT.SIZE(ROOT) := RT.SIZE(ROOT) + #RECSIZ
	NOTE THAT THE . IN THE FIRST STATEMENT MUST BE PRECEEDED AND FOLLOWED
	BY A SPACE OR OTHER DELIMITER.

	ONE BUG WHICH WE NEVER BOTHERED TO TRACK DOWN IS A PROBLEM WITH
COMPOUND IF STATEMENTS.  THESE STATEMENTS DO NOT MIX WELL WITH GOTO STATEMENTS
ON THE SAME LINE.  A STATEMENT LIKE:
	IF X GT 5 AND Y LE 0 THEN GOTO DONE
WILL NOT PRODUCE CORRECT CODE.  THE BLOCK OF CODE BELOW WILL WORK CORRECTLY:
	IF X GT 5 AND Y LE 0
		GOTO DONE
	END
ALSO, IF STATEMENTS THAT TO NOT DO COMPOUND TESTINGS CAN BE SAFELY USED WITH
GOTOS, AS IN THE FOLLOWING EXAMPLE:
	IF X GT 5 THEN GOTO DONE

THIS PROBLEM SEEMS TO STEM FROM SUPERMAC'S ATTEMPT TO DO SOME OPTIMIZATION
FOR YOU.  WHEN A GOTO IS USED IN AN IF STATEMENT, SUPERMAC REVERSES ITS NORMAL
COMPARING LOGIC, AND BRANCHES CONDITIONALLY TO YOUR ADDRESS.  IN A COMPOUND
IF STATEMENT, THE NTH COMPARE IS PROPERLY REVERSED, BUT THE FIRST N-1 COMPARES
ARE NOT.
