*DECK DB$RMIF 
USETEXT CDCSCTX 
      PROC DB$RMIF(RECMODE);
  
 #
  
  *   DB$RMIF - RECORD MAPPER INTERFACE          PAGE  1
  *   STEVEN P. LEVIN                            DATE  01/11/77 
  
  DC  PURPOSE 
  
      THIS MODULE SERVES AS AN INTERFACE BETWEEN OTHER CDCS MODULES 
      WHICH NEED MAPPING FOR RECORD READING OR (RE)WRITING AND THE
      APPROPRIATE DDL-GENERATED RECORD MAPPING CAPSULES. THE INTERFACE
      INCLUDES CONTROLLING OR DOING MD READING, RELOCATING, PARAMETER 
      PASSING, CALLING, AND ERROR CHECKING FOR RECORD CAPSULES. 
  
  DC  ENTRY CONDITIONS
  
      THE FOLLOWING PARAMETER MUST BE PASSED ON A CALL TO DB$RMIF:  
      RECMODE  - RECORD MAPPER MODE: 0 = WRITE, 1 = REWRITE, 2 = READ 
      THE FOLLOWING BASED ARRAYS AND ITEM IN CDCSCOMMN MUST BE VALID: 
      ASL       - ACTIVE SUBSCHEMA LIST (POINT TO CURRENT SUBSC ENTRY)
      RCB       - RUN-UNIT COMMAND BLOCK (POINT TO CURRENT ENTRY) 
      RSB       - RUN-UNIT STATUS BLOCK FIXED PART (POINT TO CURRENT) 
      RSRECBLK  - RSB REC CONTROL BLOCK (POINT TO CURRENT REC ENTRY)
      TIMESTAMP - CDCS INTERNAL TIMER (MUST CONTAIN CURRENT CDCS TIME)
      TQT       - TASK QUEUE TABLE (POINT TO CURRENT TASK ENTRY)
      UFT       - USER FILE TABLE (MUST POINT TO CURRENT FILE ENTRY)
      DB$RMIF SHOULD ONLY BE CALLED BY A MODULE IF IT IS KNOWN THAT 
      RECORD MAPPING IS REQUIRED FOR THE INDICATED RECORD, THAT IS, 
      ONLY IF THERE ARE MAPPING CAPSULES FOR THE INDICATED RECORD.
      FIELDS IN THE FIT CONTAINED IN THE USER FILE TABLE (UFT) GIVE 
      ADDRESS AND LENGTH INFORMATION FOR THE SCHEMA-FORMAT RECORD.
      FIELDS IN THE RUN-UNIT STATUS BLOCK (RSB) FIXED PART GIVE 
      ADDRESS AND LENGTH INFORMATION FOR THE SUBSCHEMA-FORMAT RECORD. 
      FIELDS IN THE TASK QUEUE TABLE (TQT) GIVE ADDRESS AND LENGTH
      INFORMATION FOR THE DATABASE STATUS BLOCK.
  
  DC  EXIT CONDITIONS 
  
      ON NORMAL RETURN FROM DB$RMIF, THE RECORD WHICH IS INDICATED BY 
      FIELDS IN THE CURRENT RSB AND UFT ENTRIES WILL HAVE BEEN MAPPED.
      THE RESULTING MAPPED RECORD WILL BE IN THE SUBSCHEMA-FORMAT WSA 
      FOR A READ OR IN THE SCHEMA-FORMAT WSA FOR A WRITE OR A REWRITE.
      IF AN ITEM-LEVEL ERROR OCCURS AND THE RUN-UNIT HAS ESTABLISHED
      A DBST THAT CONTAINS THE SECTION OF AUXILIARY STATUS INFORMATION, 
      THEN THE SUBSCHEMA ITEM ORDINAL WILL BE STORED IN THE RCB ENTRY.
      IF AN ERROR IS FOUND DURING PROCESSING OF DB$RMIF OR MODULES
      SUBORDINATE TO IT THROUGH CALLS (INCLUDING THE MAPPING CAPSULE
      ITSELF), DB$ERR OR DB$PUNT WILL BE CALLED, AS APPROPRIATE.
      THUS, MODULES WHICH CALL DB$RMIF DO NOT HAVE TO TEST FOR ERRORS.
  
  DC  CALLING ROUTINES
  
      DB$RD1$ - READ NEXT (SEQUENTIAL) CONTROL SYMBIONT 
      DB$RD2$ - READ RANDOM CONTROL SYMBIONT
      DB$REL$ - READ RELATION RANDOM CONTROL SYMBIONT 
      DB$REW$ - REWRITE CONTROL SYMBIONT
      DB$RLS$ - READ RELATION NEXT (SEQUENTIAL) CONTROL SYMBIONT
      DB$WR2$ - WRITE RANDOM CONTROL SYMBIONT 
  
  DC  CALLED ROUTINES 
  
      DB$CALL - CALL A MODULE, GIVEN ITS ADDRESS AS A PARAMETER 
      DB$CEDP - ARRANGE TO CALL ITEM ERROR DBPS 
      DB$ERR  - PROCESS A CDCS OR CRM EXTERNAL ERROR
      DB$FLOP - GENERATE A FLOW POINT 
      DB$MCAP - GET A MAPPING CAPSULE FROM MD, AND HAVE IT RELOCATED
  
  DC  NON-LOCAL VARIABLES 
  
      THE VALUES OF THE FOLLOWING EXTERNAL ITEMS MAY BE MODIFIED: 
      DB$MERF - MAPPING ERROR FLAG FOR CAPSULE PROCESSING ERRORS
      DB$MERP - APLIST FWA FOR ITEM-LEVEL ON-ERROR-DURING DB PROCS
      DB$MERR - ERROR INDICATOR FOR NON-CAPSULE PROCESSING ERRORS 
      DB$MFIT - FILE INFORMATION TABLE (FIT) FIRST WORD ADDRESS 
      DB$MFWA - FIRST WORD ADDRESS OF THE MAPPING CAPSULE IN CORE 
      DB$MLEN - LENGTH IN WORDS OF THE SUBSCHEMA-FORMAT RECORD
      DB$MMOD - MAPPER MODE: 0 = WRITE, 1 = REWRITE, 2 = READ, 3 = KEY
      DB$MSSO - SUBSCHEMA ITEM ORDINAL IF ITEM-LEVEL ERROR OCCURS 
      DB$MSUB - SUBSCHEMA-FORMAT RECORD FIRST WORD ADDRESS
      THE ACL POINTER AND ACL FIELDS IN CDCSCOMMN MAY BE MODIFIED.
  
  DC  DESCRIPTION 
  
      IF THE INDICATED CAPSULE IS NOT IN CORE, CALL DB$MCAP TO GET IT.
      UPDATE FIELDS IN THE ACL TO INDICATE IMPENDING CAPSULE USAGE. 
      ASSIGN VALUES TO EXTERNAL ITEMS WHICH ARE USED BY THE CAPSULE.
      CALL DB$CALL TO CALL THE APPROPRIATE MAP CAPSULE FOR EXECUTION. 
      IF AN ITEM-LEVEL ERROR OCCURS AND A DBST EXISTS THAT
      INCLUDES THE AUXILIARY STATUS BLOCK, THEN STORE THE 
      SUBSCHEMA ITEM-ORDINAL IN THE RCB ENTRY.
      IF THE ERROR FLAG DB$MERF INDICATES AN ERROR, CALL DB$ERR.
      SET THE APLIST FWA FOR ITEM-LEVEL ON-ERROR-DURING DB PROCS TO 0.
      RETURN FROM DB$RMIF WITH THE INDICATED RECORD MAPPING NOW DONE. 
  
 #
        CONTROL EJECT;
  
        BEGIN                # DB$RMIF #
  
# THE FOLLOWING FORMAL PARAMETER IS PASSED TO DB$RMIF # 
  
        ITEM RECMODE I;      # REC MAP CODE: 0=WRITE,1=REWRITE,2=READ#
  
# THE FOLLOWING ARE EXTERNALLY REFERENCED PROCEDURES AND ITEMS #
  
        XREF PROC DB$CALL;   # CALL A MODULE, GIVEN ITS ADDRESS # 
        XREF PROC DB$CEDP;   # (ARRANGE TO) CALL ITEM ERROR DBPS       #
        XREF PROC DB$ERR;    # PROCESS A CDCS OR CRM EXTERNAL ERROR # 
        XREF PROC DB$FLOP;   # GENERATE A FLOW POINT                   #
        XREF PROC DB$MCAP;   # GET A MAPPING CAPSULE FROM THE MD FILE#
        XREF ITEM DB$MERF U; # MAPPING ERROR FLAG FOR CAPSULE ERRORS #
        XREF ITEM DB$MERP U; # APLIST FWA FOR ITEM-LEVEL ERROR DBPS # 
        XREF ITEM DB$MERR U; # ERROR INDICATOR FOR NON-CAPSULE ERRORS#
        XREF ITEM DB$MFIT U; # FILE INFORMATION TABLE WORD ADDRESS #
        XREF ITEM DB$MFWA U; # FIRST WORD ADDRESS OF CAPSULE IN CORE #
        XREF ITEM DB$MLEN U; # WORD LENGTH OF SUBSCHEMA-FORMAT RECORD#
        XREF ITEM DB$MMOD U; # MODE:0=WRITE, 1=REWRITE, 2=READ, 3=KEY#
        XREF ITEM DB$MSSO U; # SS ITEM ORDINAL FOR ITEM-LEVEL ERROR    #
        XREF ITEM DB$MSUB U; # SUBSCHEMA-FORMAT RECORD WORD ADDRESS # 
  
*CALL DBSTDCLS
# THE FOLLOWING DEFS ARE LOCAL TO DB$RMIF # 
  
        DEF DFCAPBUF #26#;   # MAPPING CAPSULE SCRATCH BUFFER LENGTH #
        DEF DFCAPHED #3#;    # MAPPING CAPSULE HEADER LENGTH IN WORDS#
        DEF DFCAPKEY #3#;    # MAPPING CAPSULE KEY MAPPING MODE # 
        DEF DFCAPRED #2#;    # MAPPING CAPSULE READ MAPPING MODE #
        DEF DFCAPREW #1#;    # MAPPING CAPSULE REWRITE MAPPING MODE # 
        DEF DFCAPWRT #0#;    # MAPPING CAPSULE WRITE MAPPING MODE # 
        DEF XCALL # #;       # USED FOR EXTERNAL MODULE CALLS # 
        CONTROL EJECT;
  
        CONTROL IFGR DFFLOP,0;
          DB$FLOP("RMIF   ");          # GENERATE FLOW POINT - ENTRY   #
        CONTROL ENDIF;
  
# IF THE INDICATED CAPSULE IS NOT YET IN CORE, CALL DB$MCAP TO GET IT#
  
        IF RECMODE EQ DFCAPRED         # IF RECORD MAP MODE IS READ # 
          THEN P<ACL> = ASACLLOC[0] + RSRCCAPP[0];         # READ # 
          ELSE P<ACL> = ASACLLOC[0] + RSRCCAPP[0]          # WRITE #
                        + DFACLENSIZE; # ACL WRITE OFFSET FROM READ # 
        IF ACCMLOC[0] EQ 0 THEN XCALL DB$MCAP;   # IF SO, GET CAPSULE#
  
# UPDATE FIELDS IN THE ACL TO INDICATE IMPENDING CAPSULE USAGE #
  
        ACNUMCLS[0] = ACNUMCLS[0] + 1;           # NUMBER OF CALLS #
        ACAGECAP[0] = TIMESTAMP;                 # AGE (LAST CALL) #
  
# ASSIGN VALUES TO EXTERNAL ITEMS WHICH ARE USED BY THE CAPSULE # 
  
        DB$MERF = 0;                   # MAPPING ERROR FLAG (CAPSULE)#
        DB$MERP = 0;                   # APLIST FWA OF ITEM ERROR DBP#
        DB$MERR = 0;                   # ERROR INDICATOR (NONCAPSULE)#
        DB$MFIT = LOC(UFFIT[0]);       # FILE INFORMATION TABLE FWA # 
        DB$MFWA = ACCMLOC[0];          # FIRST WRD ADDRESS OF CAPSULE#
        DB$MLEN = RSFSBRECL[0];        # WORD LENGTH OF SUBSCHEMA REC#
        DB$MMOD = RECMODE;             # MAPPER MODE IS REC MAP MODE #
        DB$MSSO = 0;                   # SS ITEM ORD FOR ITEM-LEVEL ERR#
        DB$MSUB = RSFSBREC[0];         # SUBSCHEMA REC WORD ADDRESS # 
  
# CALL DB$CALL TO CALL THE APPROPRIATE MAPPING CAPSULE FOR EXECUTION #
  
      $BEGIN                       #DEBUG TRACE#
      XREF PROC DB$TRCO;
      DB$TRCO("MAP RECORD:",0,0); 
      $END
        XCALL DB$CALL(DB$MFWA + DFCAPHED);       # CALL MAP CAPSULE # 
  
# CLEAR DB$MFWA SO DB$CMOH IS ALLOWED TO UNLOAD THE CAPSULE.           #
  
        DB$MFWA = 0;
  
# IF AN ITEM-LEVEL ERROR OCCURRED AND A DBST EXISTS THAT INCLUDES THE  #
# AUXILIARY STATUS BLOCK, THEN STORE THE SUBSCHEMA ITEM ORDINAL IN THE #
# RCB ENTRY.                                                           #
  
        IF DB$MSSO NQ 0 
          AND TQDBSTLW[0] GQ DFDBSTAUX
        THEN
          BEGIN 
          RCMSSO[0] = DB$MSSO;
          END 
  
# IF THE ERROR FLAG DB$MERF INDICATES AN ERROR OCCURRED, CALL DB$ERR #
  
        IF DB$MERF NQ 0            # IF SOME MAPPING ERROR OCCURRED    #
        THEN
          BEGIN 
  
          CONTROL IFGR DFFLOP,0;
            DB$FLOP("RMIF-C1");        # GENERATE FLOW POINT - COMPASS1#
          CONTROL ENDIF;
  
          DB$CEDP;                 # ARRANGE TO CALL ITEM ERROR DBPS   #
          DB$ERR(40);              # RECORD MAPPING ERROR MSG          #
          END 
  
  
# SET THE APLIST FWA FOR ITEM-LEVEL ON-ERROR-DURING DB PROCS TO ZERO #
  
        DB$MERP = 0;         # APLIST FWA FOR ITEM-LEVEL ERROR DBPS # 
  
# RETURN FROM DB$RMIF WITH THE INDICATED RECORD MAPPING NOW DONE #
  
        RETURN;              # INDICATED RECORD MAPPING NOW DONE #
  
        END                  # DB$RMIF #
  
      TERM
