*DECK IOTEXT
          IDENT     IOTEXT
          LIST      C,X 
          TITLE     IOTEXT
          STEXT 
*TEXT 
*#
*1S   14
*[            +---------------------------------------------+ 
*                   INTERNAL MAINTENANCE SPECIFICATION
*0                            CRM VERSION 1.5 
*                  SEQUENTIAL AND WORD ADDRESSABLE ONLY 
*                      PRODUCT NO. I003*1.0-E013*3.4
*0                                 ****** 
*0                         CYBER RECORD MANAGER 
*0                  COPYRIGHT CONTROL DATA SYSTEMS, INC. 1994 
*[            +---------------------------------------------+ 
*1
**    CRM 1.5 IMS   COPYRIGHT CONTROL DATA SYSTEMS, INC. 1994 
**    CHAPTER 1     INTRODUCTION
**    SECTION 1     PREFACE 
*XD   CHAPTER 1  INTRODUCTION 
*0CD  IMS ORGANIZATION
*0        THE IMS IS AN INTEGRAL PART OF CRM. IT CONSISTS OF
*         DESCRIPTIVE DOCUMENTATION HEADERS PRECEDING EACH CRM
*         NARRATIVES WHICH ARE USUALLY EMBEDDED IN THE CODE.
*0S   2 
*CD   IMS PRODUCTION (FOR CDC INTERNAL USE ONLY)
*0        TO OBTAIN A COPY OF THE CRM 1.5 IMS (BAM) 
*         (PROVIDED YOU HAVE A COPY OF THE JOVEC PROGRAM) ONE 
*         NEED ONLY DO THE FOLLOWING. 
*0                  JOB 
*                   UPDATE(F) 
*                   JOVEC(COMPILE,OUTPUT)  EDIT DOCUMENTATION 
*                   7-8-9 
*                   *DEFINE IMS 
*                   6-7-8-9 
*0        JOVEC IS A CONTROL DATA TEXT EDITING PROGRAM
*         WHICH CALLS CERTAIN COMPASS COMMENT CARDS FROM A COMPILE
*         FILE AND EDITS THEM INTO THE DOCUMENTATION FORMAT 
*         YOU SEE HERE. THIS PROGRAM, WHEN MAKING A PASS
*         OVER THE COMPILE FILE PRODUCED BY A FULL UPDATE OF
*         THE CRM OLDPL, PRODUCES A COMPLETE IMS. THEREFORE,
*         DOCUMENTATION UPDATES SHOULD ALWAYS ACCOMPANY CODE
*         UPDATES WHEN APPROPRIATE. 
*0S   2 
*CD   IMS EDITING (FOR CDC INTERNAL USE ONLY) 
*0        FOR SMALL CHANGES, UPDATE CORRECTIONS CAN BE USED;
*         FOR LARGE OR WIDESPREAD ONES, THE INTERCOM EDITOR IS
*         MORE USEFUL. TO USE EDITOR, THE DOCUMENTATION TO BE 
*         MODIFIED MUST BE ACQUIRED IN SOURCE FORMAT. WHEN
*         EDITING IS COMPLETE, THE ENTIRE BODY OF THE 
*         DOCUMENTAION EDITED IS REPLACED ON THE OLDPL WITH A 
*         SINGLE UPDATE RUN.
*#
*#
**    CRM 1.5 IMS   COPYRIGHT CONTROL DATA SYSTEMS INC.  1994 
**    CHAPTER 1     INTRODUCTION
**    SECTION 2     GENERAL DESIGN                       DATE 
*X               GENERAL DESIGN 
*1CD  GENERAL DESIGN
*0        CYBER RECORD MANAGER (OR CRM) IS DESIGNED TO OPERATE ON THE 
*         CONTROL DATA  CYBER 70 / MODELS 72,73,74,  6000 
*         SERIES COMPUTERS AND CYBER 170 SERIES COMPUTERS 
*         UNDER NOS/BE 1, NOS 1 AND NOS 2 OPERATING SYSTEMS.
*         A SIMILAR PACKAGE (7000 RECORD MANAGER OR 7RM) IS DESIGNED
*         TO OPERATE ON THE CONTROL DATA CYBER 70/ MODEL 76  AND 7600 
*         COMPUTERS UNDER THE SCOPE 2 OPERATING SYSTEM. FACILITIES
*         OFFERED BY 7RM ARE SUBSTANTIALLY DIFFERENT FROM THOSE OF CRM. 
*0        CRM PROVIDES CONSISTENT ERROR PROCESSING, ACCOMODATION FOR
*         VARIOUS LABELING CONVENTIONS, AND PERMITS FILE AND RECORD 
*         FLEXIBILITY IN BOTH READING AND WRITING SO THAT FILES MAY BE
*         PROCESSED BY ANOTHER SOURCE LANGUAGE OR MACHINE. THIS IS
*         POSSIBLE BECAUSE RECORD MANAGER PROVIDES AN INTERFACE BETWEEN 
*         USER PROGRAMS AND SYSTEM ROUTINES THAT READ AND WRITE ON
*         HARDWARE DEVICES. THIS INTERFACE CONSISTS OF RECONCILING
*         USER-SPECIFIED LOGICAL RECORDS WITH THEIR PHYSICAL REPRE- 
*         SENTATION ON A PARTICULAR DEVICE AND MAY INCLUDE ADDING 
*         SPECIAL TERMINATORS OR CONTROL WORDS TO RECORDS AND/OR
*         JOINING USER RECORDS BEFORE ACTUALLY WRITING. THIS PROCESS
*         IS TRANSPARENT TO THE USER HOWEVER AND HE MAY CONCERN HIMSELF 
*         SOLELY WITH HIS LOGICAL RECORD DEFINITION AND IGNORE ITS
*         PHYSICAL REPRESENTATION.
*         RECORD MANAGER IS DESIGNED AROUND FILE ORGANIZATION (FO), 
*         BLOCK TYPE (BT), AND RECORD TYPE (RT). ONLY THOSE ROUTINES
*         NECESSARY TO PROCESS THE FO/BT/RT COMBINATION(S) SPECIFIED
*         BY THE USER ARE LOADED, I.E. WORD-ADDRESSABLE I/O ROUTINES
*         ARE NOT LOADED UNLESS THE USER HAS DECLARED ONE OF HIS FILES
*         AS WA NOR ARE THE BLOCK-TYPE AND RECORD-TYPE ROUTINES 
*         (GET$W, PUT$K, ETC) FOR UNSPECIFIED BLOCK AND RECORD TYPES
*         LOADED (SEE CHAPTER 3 SECTION 1 *STATIC LOADING*).
*0        THE USER HAS THREE OPTIONS; HE CAN COMMUNICATE WITH RECORD
*         MANAGER IN COMPASS VIA RM MACROS RESIDENT ON TXTCRM SUCH AS 
*         OPENM, GET, ETC.; HE CAN USE COMPILER-LEVEL CALLS TO RM 
*         INTERFACE ROUTINES (WHICH USE THE TXTCRM MACROS) SUCH AS
*         CALL OPENM(...), CALL GET(...), ETC.; OR HE CAN USE STANDARD
*         COMPILER I/O STATEMENTS SUCH AS READ, WRITE, ETC. (WHICH USE
*         THE TXTCRM MACROS). 
*0        THE COMPASS MACROS LOAD ANY USER-SUPPLIED PARAMETERS INTO 
*         X-REGISTERS, SET REGISTER A0 TO THE FIT ADDRESS, SET REGISTER 
*         B6 TO THE USER RETURN ADDRESS, AND JUMP TO THE
*         CONTROLLING ROUTINE (CONTROL) AT THE ENTRY POINT FOR
*         THAT FUNCTION (E.G. PUT$RM).
*0        THE COMPILER-LEVEL CALLS ARE SIMILAR TO THE COMPASS MACROS
*         IN APPEARANCE; THE ARGUMENT LIST CONTAINS THE SAME PARAMETERS 
*         AS THE MACROS.
*         EXAMPLES FROM FORTRAN ARE 
*                   CALL FILESQ (FIT,3LLFN,5LTAPE1,3LFWB,BUF,...) 
*                   CALL OPENM  (FIT,5LINPUT,1LR) 
*                   CALL GET    (FIT,WSA,0,0,0,100,ENDATA)
*                   CALL CHECK  (FIT) 
*                   CALL CLOSEM (FIT,1LU) 
*         THESE ROUTINES CORRESPOND TO THE COMPASS MACROS  FILE,OPENM,
*         GET, CHECK, CLOSEM  RESPECTIVELY. NOTE THAT THE PARAMETER 
*         ORDER OF THE COMPILER-LEVEL CALLS DOES NOT NECESSARILY
*         CORRESPOND TO THAT OF THE COMPASS MACROS. 
*0        BY USING THE STANDARD COMPILER I/O STATEMENTS (SUCH AS READ 
*         AND WRITE IN FORTRAN AND COBOL), THE USER CAN IGNORE CRM
*         COMPLETELY. THE COMPILER WILL USE CRM TO PERFORM THE I/O
*         BUT IT WILL TAKE CARE OF THE USER/CRM INTERFACE ITSELF. IT
*         WILL IN ITS COURSE OF EVENTS EVENTUALLY USE THE COMPASS 
*         MACROS DESCRIBED ABOVE. 
*0        IN ALL OF THE ABOVE DESCRIBED LEVELS OF CRM COMMUNICATION,
*         THE USER CAN OVERRIDE EITHER DEFAULT VALUES SUPPLIED BY CRM 
*         OR THE COMPILER OR VALUES SUPPLIED IN HIS PROGRAM BY USING
*         A FILE CONTROL STATEMENT. THIS IS A CONTROL STATEMENT 
*         CALLABLE PROGRAM (OBVIOUSLY) AND IT WRITES FILE *ZZZZZDG* 
*         (WHICH CONTAINS THE DATA SPECIFIED ON THE CONTROL STATEMENT). 
*         WHEN *OPEN$RM (OR *SETFIT*) IS LATER CALLED, IT 
*         JUMPS TO *PDF$RM* WHICH WILL THEN READ FILE *ZZZZZDG* AND 
*         STORE THE DATA THERE IN THE FIT. THUS A PROGRAM CAN BE WRITTEN
*         AND EXECUTED ONCE FOR ANY COMBINATION OF FILE ORGANIZATION, 
*         BLOCK TYPE, AND RECORD TYPE BY MERELY CHANGING THE FILE 
*         CONTROL STATEMENT FOR EACH RUN AND RECOMPILATION IS NOT  .
*         NECESSARY USE OF THE LDSET(FILES=...) CONTROL STATEMENT IS
*         REQUIRED WHEN FILE CS ARE USED TO USE THE STATIC LOADING
*         FEATURE OF CRM. 
*0        CRM PROVIDES STANDARD I/O OPERATIONS - READ, WRITE, SKIP, 
*         ENDFILE, BACKSPACE, REWIND, DELETE, REPLACE, AND SEEK.
*         IN ADDITION, CRM PROVIDES TWO OPERATIONS, OPEN AND CLOSE, 
*         WHICH ALLOW THE USER TO SPECIFY FILE POSITIONING, LABEL 
*         PROCESSING REQUIREMENTS, AND PROVIDE SOME COMMON PROCESSING 
*         FOR ALL CRM FILES REGARDLESS OF FO/BT/RT. 
*0        CRM REQUIRES A FILE INFORMATION TABLE (FIT) WHICH CONTAINS
*         FILE TYPE AND STRUCTURE INFORMATION AS WELL AS FLAGS AND
*         FIELDS USED TO PROPERLY PROCESS THE FILE, SUCH AS ERROR CODE, 
*         CURRENT FILE POSITION, LAST OPERATION, ERROR AND END-OF-DATA
*         ADDRESSES, AND BLOCK AND RECORD LENGTH. THIS TABLE INCLUDES 
*         THE FILE ENVIRONMENT TABLE (FET).  THE FIT
*         IS GENERATED BY THE FILE MACRO, FILESQ, FILEWA, ETC. CALL 
*         IN FORTRAN, OR THE COMPILER ITSELF WHEN ONLY FORTRAN
*         READ/WRITE STATEMENTS ARE USED.  THEY STORE THE 
*         PARAMETERS FROM THE CALL IN THE FIT AS WELL AS SETTING
*         SOME REQUIRED FIELDS TO DEFAULT VALUES IF THE USER CALL HAS 
*         NOT SPECIFIED THEM. THE FILE IS HENCEFORTH REFERENCED BY THE
*         LFN SPECIFIED IN THE CALL OR BY THE LOCATION FIELD SYMBOL IF
*         THE LFN WAS NOT SPECIFIED (COMPASS ONLY). 
*0        CRM NEXT REQUIRES THE USER TO OPEN THE FILE FOR PROCESSING
*         BY DOING AN OPENM. THE OPENM MACRO ALWAYS CALLS OPEN$RM WHICH 
*         ALLOCATES SPACE FOR THE CIO CIRCULAR BUFFER (IF THE 
*         USER HAS NOT SPECIFIED IT IN HIS FILE CALL), PROCESSES ANY
*         FILE CONTROL STATEMENTS, AND CHECKS THE FIT FOR VALIDITY. 
*         IT OPENS THE FILE AND DOES ANY LABEL PROCESSING. IF FO=SQ/WA
*         IT PERFORMS CODE SPECIFIC TO THESE FOS AND RETURNS TO THE 
*         USER. IF FO=IS/DA/AK, IT LOADS THE AAM CONTROL ROUTINE  (IF 
*         NOT ALREADY LOADED) AND TRANSFERS CONTROL TO IT.
*0        IF THE USER WISHES TO READ FROM HIS FILE, HE ISSUES A GET.
*         AS DESCRIBED ABOVE, THE GET MACRO GENERALLY JUMPS TO THE
*         RM-LEVEL ROUTINE GET$RM WHICH WILL DO NOTHING MORE THAN LOAD
*         THE ADDRESS OF THE FO-LEVEL ROUTINE FOR THE FO OF THIS FILE 
*         (I.E. GET$SQ, GET$WA, ETC.) AND JUMP THERE. THAT ADDRESS IS 
*         STORED INTO A CAPSULE BY FDL. THE MACRO COM.CRM IS
*         CALLED BY EACH FO-LEVEL ROUTINE (GET.SQ, GET.WA, ETC.) SO 
*         THAT IF THAT FO-LEVEL ROUTINE IS LOADED (AND IT SHOULD BE 
*         SINCE IT IS REFERENCED BY <FO>.RM), ITS ADDRESS WILL BE IN
*         THE COMMON BLOCK /GET.FO/. EACH CELL OF /GET.FO/, WHICH IS 7
*         WORDS LONG, IS INITIALLY LOADED WITH A
*                             SX6       -NUM
*                             EQ        =XERR.RM
*         WHERE NUM IS A FLAG TO THE ERROR ROUTINE, ERR.RM, THAT A
*         GET.<FO> ROUTINE WAS NOT LOADED. THUS IF THE USER TRIES TO
*         DO A GET AND THE FO-LEVEL ROUTINE WAS NOT LOADED, CONTROL 
*         WOULD PASS TO ERR.RM TO OUTPUT AN ERROR MESSAGE, WHEREAS
*         UNSATISFIED EXTERNALS GENERALLY PRODUCE MODE 1 ERRORS. AT 
*         COMPLETION OF LOADING, /GET.FO/ WILL CONTAIN THE ADDRESS OF 
*         EACH FO-LEVEL GET ROUTINE LOADED. THE FO-LEVEL GET ROUTINE
*         CHECKS ERROR CONDITIONS AND KEEPS DATA IN THE CIO CIRCULAR
*         BUFFER BY ISSUING A CIO READ WHEN NECESSARY. IT USES THE MACRO
*         SYSY WHICH FORMATS A CALL TO ROUTINE CIO$RM. CIO$RM INSURES 
*         THAT THE FILE IS NOT BUSY AND THEN ISSUES AN RA+1 REQUEST.
*         IF RECALL WAS REQUESTED, CIO.RM DOES AN   XJ   IF AVAILABLE 
*         OR AN RA+1 = 0 TEST IF NOT. TO ACTUALLY TRANSFER THE DATA 
*         FROM THE CIRCULAR BUFFER TO THE USER WORKING STORAGE AREA,
*         GET$SQ (OR GET$WA, ETC.) CALLS ONE OF SEVERAL OTHER ROUTINES
*         DEPENDING ON THE FILES RECORD TYPE. THESE ROUTINES ARE
*         GET$X FOR X = W F Z D T R U S. THE FO-LEVEL ROUTINE 
*         GETS TO THE RECORD TYPE (RT) ROUTINE BY A PROCEDURE 
*         SIMILAR TO THE WAY THE RM-LEVEL ROUTINES GET
*         TO THE FO-LEVEL ROUTNES. GET$SQ (OF GET$WA, ETC.) LOADS THE 
*         ENTRY POINT ADDRESS (RTJG IN FIT) OF THE RT-LEVEL ROUTINE 
*         AND JUMPS THERE THE RT-LEVEL ROUTINES CALL ROUTINE MOVE$RM
*         THE RT-LEVEL ROUTINES CALL ROUTINE MOVE$RM TO ACTUALLY
*         TRANSFER THE DATA FROM THE BUFFER TO THE WORKING
*         STORAGE AREA. IT MAY BE NECESSARY FOR THE RT-LEVEL ROUTINE
*         TO RETURN TO THE FO-LEVEL ROUTINE IF MORE DATA IS REQUIRED
*         TO COMPLETE THE RECORD. THE FO-LEVEL ROUTINE WILL THEN CALL 
*         THE RT-LEVEL ROUTINE AGAIN. 
*0        IN SUMMARY, ON A FILE WITH FO=SQ, BT=C AND RT=F, FOR ONE USER 
*         GET, THE FLOW OF CONTROL GOES FIRST TO GET$RM, THEN TO GET$SQ 
*         (VIA FOJG IN FIT), THEN TO ENTRY POINT GET$F (VIA RTJG IN 
*         FIT) AND FINALLY TO MOVE$RM (AND POSSIBLY TO CIO$RM). AT
*         BLOCK BLOUNDARIES, IT ALSO CALLS A BLOCK TYPE ROUTINE GET$C.
*0        A SIMILAR SEQUENCE OF EVENTS OCCURS FOR WRITING. THE USER 
*         REQUESTS A PUT WHICH CALLS PUT$RM WHICH CALLS PUT$SQ (OR
*         PUT$WA, ETC.) WHICH WILL CALL A UTILITY ROUTINE PUT$X (WHERE
*         X INDICATES RT) TO GET THE RECORD LENGTH FOR THIS PARTICULAR
*         RECORD TYPE. THEN EITHER A PUT OR THE RT-LEVEL ROUTINE (ENTRY 
*         POINT PUT$<RT>) OR PERFORM THE CALL TO MOVE.RM ITSELF. THE
*         RT-LEVEL ROUTINE WILL BE CALLED WHEN RECORD TYPE IS D,
*         T, Z, W, OR R.
*0        CRM ALSO REQUIRES THE USER TO TERMINATE FILE PROCESSING BY
*         DOING A CLOSEM. THE CLOSEM MACRO ALWAYS CALLS CLSF$RM WHICH 
*         REMOVES THE LFN FROM THE CRM LIST OF ACTIVE FILES (LIST$RM
*         POINTED TO BY LOF$RM) BEFORE TRANSFERING CONTROL TO 
*         CLSF$<FO> (BY THE METHOD DESCRIBED ABOVE FOR GET) WHICH 
*         FLUSHES THE BUFFER ON I-O FILES AND ISSUES A CIO CLOSE. 
*0        CRM PROVIDES OTHER FUNCTIONS SUCH AS SKIP FORWARD OR BACKWARD 
*         A SPECIFIED NUMBER OF FILES, LOGICAL RECORDS, OR PHYSICAL 
*         RECORDS, DELETE A RECORD, REPLACE A RECORD WITH THE CURRENT 
*         RECORD, WRITE END-OF-SECTION, END-OF-PARTITION, OR TAPE MARK, 
*         REWIND A FILE, AND SEEK A RECORD. THE FOLLOWING CHART SHOWS 
*         WHICH OPERATIONS ARE LEGAL ON WHICH FILE ORGANIZATIONS. 
*0                  SQ        WA        IS        DA        AK
*                   --        --        --        --        --
*         SKIP       X                   X         X         X
*         DELETE                         X         X         X
*         REPLACE    X                   X         X         X
*         WEOS       X
*         WEOP       X
*         WTMK       X
*         REWIND     X                   X         X         X
*         SEEK                           X         X         X
*         START                          X         X         X
*0        SKIPPING IS HANDLED IN THREE WAYS. SKIPPING FILES (FORWARD
*         OR BACKWARD) IS HANDLED BY ISSUEING THE APPROPRIATE CIO CODE
*         (SKIPF OR SKIPB). SKIPPING LOGICAL RECORDS FORWARD IS HANDLED 
*         BY SETTING A DELETE (OR SKIP) FLAG AND USING CODE IN GET.SQ 
*         TO ACTUALLY READ DATA; HOWEVER, THE DELETE (SKIP) FLAG
*         INHIBITS TRANSFERING DATA TO THE USER WORKING STORAGE AREA. 
*         SKIPPING LOGICAL RECORDS BACKWARD IS A COMPLEX
*         PROCESS REQUIRING BACKWARD OPERATIONS PAST THE REQUIRED POINT,
*         READS TO REFRESH THE CIRCULAR BUFFER, AND RESETTING THE 
*         APPROPRIATE POINTERS SO THAT THE PROPER PHYSICAL RECORD 
*         FOR THE FO/BT/RT IN QUESTION IS SUBSEQUENTLY WRITTEN. 
*0        WEOS$SQ AND WEOP$SQ ARE BOTH ENTRY POINTS IN PUT$SQ 
*         THE BUFFER IS FLUSHED BY A CALL TO FLSH$SQ, AN ENTRY
*         POINT IN PUT$SQ, THE CIO FUNCTION CODE IS ISSUED (WRITER FOR
*         WEOS AND WRITEF FOR WEOP), AND THE CIRCULAR BUFFER AND FIT
*         BUFFER POINTERS ARE RESET (NOTE THAT FLSH$SQ TAKES CARE OF
*         WRITING ANY REQUIRED W-CONTROL WORDS).  WTMK$SQ MERELY ISSUES 
*         THE CIO FUNCTION CODE WRITEF (THIS DOES NOT GUARANTEE 
*         PROPER BUFFER FLUSHING AS CRM MAY NOT HAVE MOVED THE  IN
*         POINTER TO REFLECT ALL DATA IN THE CIRCULAR BUFFER).
*         IS SHOULD ONLY BE USED FOR NON-STANDARD LABEL PROCESSING. 
*0        REWIND IS DEFINED FOR FO = SQ, IS, DA, AND AK SO A REWIND 
*         REQUEST FIRST GOES TO REW.RM WHICH LOADS THE FO-LEVEL ROUTINE 
*         ADDRESS VIA CAPS$RM AND JUMPS TO IT. THE FO-LEVEL ROUTINE 
*         WILL FLUSH THE BUFFER AND ISSUE A CIO REWIND REQUEST. 
*0        REPLACE, DELETE, AND SEEK ARE DEFINED ONLY FOR FO = IS, DA, 
*         AND AK. REFERENCE SHOULD BE MADE TO THE AAM IMS FOR DETAILS 
*         ON IS, DA AND AK PROCESSING.
*0        REPLACE CAN BE USED ON FO=SQ. A REPLACE MUST FOLLOW A 
*         GET AND REPLACES THE RECORD ACCESSED BY THE GET WITH A
*         RECORD OF THE SAME LENGTH ONLY RT=W/F ARE ALLOWED ONLY
*         BT=C IS ALLOWED.
*0        CHEK$RM - RECALL JOB UNTIL I/O ACTIVITY CEASES, 
*         CIO$RM  - ISSUE CIO REQUEST,
*         ERR$RM  - HANDLE ERROR PROCESSING,
*         MOVE$RM - MOVE DATA TO AND FROM BUFFER AND WSA, 
*0        ENTRY AND EXIT FROM RECORD MANAGER ROUTINES IS DONE BY SETTING
*         B6 WITH THE RETURN ADDRESS AND DOING AN EQ =XROUTINE. 
*         THAT ROUTINE THEN DOES A JP B6 UPON COMPLETION OF ITS 
*         PROCESSING. OCCASSIONALLY B5 IS USED AS THE RETURN ADDRESS
*         REGISTER BETWEEN RECORD MANAGER ROUTINES. IF SEVERAL ROUTINES 
*         WITHIN RM ARE TO BE EXECUTED (IN A NESTED FASHION), THEN B6 
*         CAN BE SAVED AND RESTORED BY USE OF THE MACROS SAVE AND 
*         RESTORE WHICH STORE AND RETRIEVE B6 VALUES FROM FET+7.
*0        RM PERFORMS I/O REQUESTS THROUGH THE MACRO SYSY WHICH STORES
*         THE CIO CODE, SKIP COUNT, AND LEVEL NUMBER IN A REGISTER
*         THEN CALLS CIO$RM. CIO$RM DOES AN XJ (IF NOT PRESENT, RA+1
*         IS CHECKED TO BE ZERO) THEN ISSUES A CIO REQUEST THROUGH RA+1.
*0        RM ATTEMPTS TO MINIMIZE I/O TIME BY DOING READ-AHEAD ON INPUT 
*         FILES 
*0        CRM ROUTINES RELY HEAVILY ON THE PRESENCE OF VARIOUS MACROS 
*         DEFINED ON TXTCRM. THESE MACROS RETRIEVE AND STORE FIT FIELDS,
*          CHECK CIRCULAR BUFFER POINTERS, AND SAVE AND RESTORE RETURN
*         ADDRESSES (AMONG OTHER THINGS). SAVE AND RESTORE WERE 
*         DISCUSSED IN A PREVIOUS PARAGRAPH DEALING WITH ENTRY
*         AND EXIT FROM CRM ROUTINES. 
*0        MACRO F.RM FETCHES A FIT FIELD AND RETURNS
*         IT IN THE USER-SPECIFIED (OR DEFAULT) REGISTER(S). MACRO
*         SET.RM  STORES A VALUE (OR REGISTER CONTENTS) INTO FIT
*         FIELD. BOTH MACROS GENERATE EFFICIENT CODE BY USING 
*         THE TXTCRM MICROS (ONE DEFINED FOR EACH FIT FIELD)
*         TO DETERMINE FIELD SIZE AND LOCATION WITHIN ITS WORD. 
*0        MACROS BUFINC, BUFDEC, AND BUFSP INCREMENT, DECREMENT, AND
*         CALCULATE SPACE BETWEEN CIRCULAR BUFFER POINTERS WHICH MUST 
*         BE IN REGISTERS. NO DATA IS STORED BACK INTO THE FIT. THE 
*         ADVANTAGE OF THESE MACROS IS THAT THEY TAKE INTO ACCOUNT THE
*         CIRCULAR NATURE OF THE BUFFER SO THAT THEIR RESULT IS ALWAYS
*         BETWEEN FIRST AND LIMIT.
*#
* 
*         BRING IN SYSTEM PARAMETERS
          IPARAMS 
*         BRING IN INSTALLATION PARAMETERS
          DEFINHF 
*         IF MICRO #HF.L# IS EQUAL TO L THEN LCM IS AVAILABLE 
          IF        MIC,HF.L
#BETA#    EQU       1 
          ELSE
#BETA#    EQU       0 
          ENDIF 
* 
*ENDTEXT
* CALL 6RMCOM               6RMCOM   *COMDECK 6RMCOM
*CALL /CRMCOM/
          TITLE     TYTLE 
          PURGMAC   TITLE,TYTLE 
          END 
