ACCMAP
PROC MBUFMAN ((SM$ID),(ORDINAL),OFFSET,RSTATUS);
# TITLE MBUFMAN - RETURNS MAP ENTRY OFFSET.                           # 
  
      BEGIN  # MBUFMAN  # 
  
# 
**    MBUFMAN - ENSURES THAT THE DESIRED MAP ENTRY IS IN THE BUFFER 
*               AND RETURNS THE WORD OFFSET OF THE ENTRY WITHIN 
*               THE BUFFER. 
* 
*     MBUFMAN - IS CALLED BY MGETENT AND MPUTENT. 
* 
*     PROC MBUFMAN (SM$ID,ORDINAL,OFFSET,RSTATUS) 
* 
*     ENTRY     SM$ID   - *SM* NUMBER.
*               ORDINAL  - *XY* COORDINATE ORDINAL. 
* 
*     EXIT      OFFSET   - OFFSET OF ENTRY. 
*               RSTATUS  - ERROR STATUS.
*                          (VALUES DEFINED IN *COMBCMS*)
*                          = NO ERRORS. 
*                          = *CIO* ERROR. 
*                          = MAP ORDINAL OUT OF RANGE.
# 
  
      ITEM SM$ID      U;             # *SM* NUMBER  # 
      ITEM ORDINAL    U;             # *XY* COORDINATE ORDINAL  # 
      ITEM OFFSET     U;             # ENTRY OFFSET  #
      ITEM RSTATUS    U;             # STATUS RETURNED TO CALLER  # 
  
# 
****  PROC MBUFMAN - XREF LIST BEGIN. 
# 
  
      XREF
        BEGIN 
        PROC MCLOSE;                 # CLOSE MAP  # 
        PROC MFLUSH;                 # FLUSH MAP TO FILE  # 
        PROC READ;                   # INTERFACE TO *READ* MACRO #
        PROC ZSETFET;                # INITIALIZES A *FET* FOR *I/O* #
        END 
  
# 
****  PROC MBUFMAN - EXREF LIST END.
# 
  
      DEF  LISTCON   #0#;      # DO NOT LIST COMMON DECKS # 
*CALL COMBFAS 
*CALL COMBCMD 
*CALL COMBCMS 
*CALL COMBFET 
*CALL COMBMAP 
*CALL COMBMCT 
*CALL COMXMSC 
*CALL COMSPFM 
  
      ITEM BFWA       U;             # WORD ADDRESS OF FIRST ENTRY
                                       IN BUFFER  # 
      ITEM DWA        U;             # WORD ADDRESS OF DESIRED ENTRY #
      ITEM PRUNUM     U;             # *PRU* NUMBER WHERE *XY* ENTRY
                                       RESIDES  # 
  
  
  
  
  
      RSTATUS = CMASTAT"NOERR"; 
  
# 
*     *XY* COORDINATE HAS TO BE 1 -  352. 
# 
  
      IF ORDINAL LQ 0 OR ORDINAL GR MAXORD
      THEN
        BEGIN 
        RSTATUS = CMASTAT"ORDERR";
        RETURN; 
        END 
  
# 
*     COMPUTE 
*       DWA - WORD ADDRESS IN MAP OF DESIRED MAP ENTRY. 
*       BFWA - WORD ADDRESS OF FIRST ENTRY IN BUFFER. 
# 
  
      DWA = ORDINAL * MAPENTL;
      BFWA = (MB$PRUNUM[0] - 1) * PRULEN; 
  
# 
*     ENSURE DESIRED ENTRY IS IN THE BUFFER.
# 
  
      IF MB$SMID[0] NQ SM$ID  OR MB$PRUNUM[0] EQ 0 # #
        OR BFWA GR DWA OR DWA GR (BFWA + MAPBUFL - MAPENTL) 
      THEN
        BEGIN  # ENTRY NOT IN BUFFER #
        IF MB$BMF[0]
        THEN
          BEGIN 
          MFLUSH; 
          END 
  
        PRUNUM = (DWA/PRULEN) + 1;
        ZSETFET(MAPFADR,OMT$LFN[SM$ID],MAPBADR,MAPBUFL,RFETL);
        FET$R[0] = TRUE;
        FET$RR[0] = PRUNUM; 
        FET$EP[0] = TRUE; 
        READ(MAPFET,RCL); 
        IF FET$AT[0] NQ 0 
        THEN
          BEGIN 
          MCLOSE(ORDINAL);
          RSTATUS = CMASTAT"CIOERR";
          RETURN; 
          END 
  
        MB$PRUNUM[0] = PRUNUM;
        MB$SMID[0] = SM$ID; 
        MB$LFN[0] = OMT$LFN[SM$ID]; 
        BFWA = (PRUNUM - 1) * PRULEN; 
        END  # ENTRY NOT IN BUFFER #
  
      OFFSET = (DWA - BFWA);
      RETURN; 
      END  # MBUFMAN #
  
    TERM
PROC MCLOSE((SM$ID),RSTATUS); 
# TITLE MCLOSE - TERMINATE MAP REFERENCE BY CALLER.                   # 
      BEGIN  # MCLOSE  #
  
# 
**    MCLOSE - INDICATES TERMINATION OF MAP REFERENCES BY CALLER. 
* 
*     MCLOSE - IS CALLED BY  DBCMAP,DBFLAG,DBRDSTM,MBUFMAN,MOPEN, 
*              TERMCAT,USRPC,VLSUBFM. 
* 
*     PROC MCLOSE (SM$ID,RSTATUS) 
* 
*     ENTRY     SM$ID  - *SM* NUMBER FROM CALLER. 
* 
*     EXIT      RSTATUS - ERROR STATUS. 
*                         (VALUES DEFINED IN *COMBCMS*) 
*                         = NO ERRORS.
*                         = MAP NOT OPEN. 
* 
# 
  
      ITEM SM$ID     U;             # *SM* NUMBER FROM CALLER  #
      ITEM RSTATUS    U;             # ERROR STATUS RETURNED  # 
  
# 
****  PROC MCLOSE - XREF LIST BEGIN.
# 
  
      XREF
        BEGIN 
        PROC MFLUSH;                 # FLUSH MAP TO FILE  # 
        PROC RETERN;                 # INTERFACE TO *RETURN* MACRO  # 
        PROC ZSETFET;                # INITIALIZES A *FET* FOR *I/O* #
        END 
  
# 
****  PROC MCLOSE - EXREF LIST END. 
# 
  
      DEF LISTCON #0#;               # CONTROLS COMDECK LISTING # 
*CALL COMBFAS 
*CALL COMBCMD 
*CALL COMBCMS 
*CALL COMBFET 
*CALL COMBMCT 
*CALL COMXMSC 
*CALL COMSPFM 
  
  
  
  
  
      RSTATUS = CMASTAT"NOERR"; 
  
# 
*     MAP HAS TO BE OPEN. 
# 
  
      IF NOT OMT$OPEN[SM$ID]
      THEN
        BEGIN 
        RSTATUS = CMASTAT"NOTOPEN"; 
        RETURN; 
        END 
  
# 
*     CLEAR *OMT* ENTRY IF INTERLOCKED. 
# 
  
      IF OMT$INTLK[SM$ID] 
      THEN
        BEGIN 
        OMT$OPEN[SM$ID] = FALSE;
        OMT$INTLK[SM$ID] = FALSE; 
        RETURN; 
        END 
  
  
# 
*     FLUSH BUFFER IF *MODIFY* MODE.
# 
  
      IF MB$SMID[0] EQ SM$ID AND OMT$ATTM[SM$ID] EQ "M" 
      THEN
        BEGIN 
        MFLUSH; 
        END 
  
# 
*     SET UP *FET* AND RETURN THE FILE. 
# 
  
      ZSETFET(MAPFADR,OMT$LFN[SM$ID],MAPBADR,MAPBUFL,RFETL);
      RETERN(MAPFET,RCL); 
      OMT$OPEN[SM$ID] = FALSE;
      RETURN; 
      END  # MCLOSE  #
  
    TERM
PROC MFLUSH;
# TITLE MFLUSH - FLUSH MAP TO FILE.                                   # 
      BEGIN  # MFLUSH  #
  
# 
**    MFLUSH - ENSURES THAT THE RESULTS OF ANY PREVIOUS *MPUTENT* 
*              REQUESTS ARE WRITTEN TO THE MAP FILE.
* 
* 
*     MFLUSH - IS CALLED BY ADDCAR,ADDCUBE,MBUFMAN,MCLOSE,MRELSLK,
*              RVMCAR,RVMCUBE.
* 
*     PROC MFLUSH 
* 
# 
  
# 
****  PROC MFLUSH - XREF LIST BEGIN.
# 
  
      XREF
        BEGIN 
        PROC REWRITE;                # INTERFACE TO *REWRITE* MACRO  #
        PROC REWRITR;             # INTERFACE # 
        END 
  
# 
****  PROC MFLUSH - EXREF LIST END. 
# 
  
      DEF LISTCON #0#;               # CONTROLS COMDECK LISTING  #
*CALL COMBFAS 
*CALL COMBCMD 
*CALL COMBCMS 
*CALL COMBFET 
*CALL COMBMAP 
*CALL COMBMCT 
*CALL COMXMSC 
*CALL COMSPFM 
  
  
  
  
  
# 
*     IF BUFFER NOT MODIFIED, EXIT. 
# 
  
      IF NOT MB$BMF[0]
      THEN
        BEGIN 
        IF OMT$ATTM[MB$SMID[0]] NQ "M"
        THEN
          BEGIN 
          MB$CWRD[0] = 0; 
          END 
  
        RETURN; 
        END 
  
# 
*     REWRITE MAP BUFFER TO THE FILE. 
# 
  
      P<FETSET> = MAPFADR;
      FET$R[0] = TRUE;
      FET$RR[0] = MB$PRUNUM[0]; 
      FET$EP[0] = TRUE; 
      FET$LFN[0] = MB$LFN[0]; 
      IF MB$PRUNUM[0] EQ 17 
      THEN                         # PARTIAL PRU #
        BEGIN 
        REWRITR(MAPFET,RCL);
        END 
  
      ELSE
        BEGIN 
        IF MB$PRUNUM[0] EQ 16 
        THEN                         # PARTIAL PRU STILL REMAINS #
          BEGIN 
          REWRITE(MAPFET,RCL);
          FET$RR[0] = 17; 
          REWRITR(MAPFET,RCL);
          END 
  
        ELSE
          BEGIN 
          REWRITE(MAPFET,RCL);
          END 
        END 
  
      P<FETSET> = TFETADR;
      MB$CWRD[0] = 0; 
      RETURN; 
      END  # MFLUSH  #
  
    TERM
PROC MGETENT ((SM$ID),(ORDINAL),(MAPADR),RSTATUS);
# TITLE MGETENT - RETURN THE MAP ENTRY TO THE CALLER.                 # 
      BEGIN  # MGETENT  # 
  
# 
**    MGETENT - RETURNS THE REQUESTED MAP ENTRY TO THE CALLERS
*               MEMORY SPACE. 
* 
*     MGETENT - IS CALLED BY ADDCAR,ADDCUBE,DBCMAP,DBFLAG,
*               DBVSN,MSFINIT,RMVCAR,RMVCUBE,SERCSU,USRPG,VLCMAP, 
*               VLCSUSC.
* 
* 
*     PROC MGETENT (SM$ID,ORDINAL,MAPADR,RSTATUS) 
* 
*     ENTRY     SM$ID   - *SM* NUMBER.
*               ORDINAL  - *XY* COORDINATE ORDINAL. 
*               MAPADR   - ADDRESS OF ENTRY DESTINATION.
* 
*     EXIT      (MAPADR) - MAP ENTRY. 
*               RSTATUS  - ERROR STATUS.
*                          (VALUES DEFINED IN *COMBCMS*)
*                          = NO ERRORS. 
*                          = MAP INTERLOCKED. 
*                          = MAP NOT OPEN.
*                          = *CIO* ERROR. 
*                          = MAP ORDINAL OUT OF RANGE.
# 
  
      ITEM SM$ID     U;             # *SM* NUMBER  #
      ITEM ORDINAL    U;             # *XY* COORDINATE ORDINAL  # 
      ITEM MAPADR     U;             # ENTRY DESTINATION  # 
      ITEM RSTATUS    U;             # STATUS RETURNED TO CALLER  # 
  
# 
****  PROC MGETENT - XREF LIST BEGIN. 
# 
  
      XREF
        BEGIN 
        PROC MBUFMAN;                # GET ENTRY OFFSET  #
        END 
  
# 
****  PROC MGETENT - EXREF LIST END.
# 
  
      DEF LISTCON #0#;               # CONTROLS COMDECK LISTING  #
*CALL COMBFAS 
*CALL COMBCMD 
*CALL COMBCMS 
*CALL COMBMAP 
  
      ITEM I          I;             # INDUCTION VARIABLE  #
      ITEM OFFSET     U;             # RELATIVE LOCATION OF *XY* IN 
                                       BUFFER  #
  
      BASED 
      ARRAY MENTRY [0:0] P(1);
        BEGIN 
        ITEM ENT$WRD    U(00,00,60);  # ENTRY WORD  # 
        END 
  
  
  
  
  
      RSTATUS = CMASTAT"NOERR"; 
  
# 
*     RETURN ERROR IF FILE INTERLOCKED. 
# 
  
      IF OMT$INTLK[SM$ID] 
      THEN
        BEGIN 
        RSTATUS = CMASTAT"INTLK"; 
        RETURN; 
        END 
  
# 
*     MAP FILE HAS TO BE OPEN.
# 
  
      IF NOT OMT$OPEN[SM$ID]
      THEN
        BEGIN 
        RSTATUS = CMASTAT"NOTOPEN"; 
        RETURN; 
        END 
  
# 
*     GET OFFSET OF ENTRY IN BUFFER.
# 
  
      MBUFMAN(SM$ID,ORDINAL,OFFSET,RSTATUS);
      IF RSTATUS NQ 0 
      THEN
        BEGIN 
        RETURN; 
        END 
  
# 
*     TRANSFER ENTRY TO CALLER. 
# 
  
      P<MENTRY> = MAPADR; 
      P<MAPBUF> = MAPBADR;
      FASTFOR I = 1 STEP 1 UNTIL MAPENTL
      DO
        BEGIN 
        ENT$WRD[I - 1] = MAPB$W[OFFSET + I];
        END 
  
      RETURN; 
      END  # MGETENT #
  
    TERM
PROC MINIT ((LFN),(SM$ID),RSTATUS); 
# TITLE MINIT - INITIALIZE A *SMU* MAP.                               # 
      BEGIN  # MINIT #
  
# 
**    MINIT - INITIALIZE A *SMMAP* TO INDICATE CARTRIDGES ARE 
*             EITHER: 
*                  1. NON EXISTENT (NO CUBES) 
*                  2. RESERVED FOR CE USE OR
*                  3. UNASSIGNED
*                  4. RESERVED FOR SYSTEM USE 
* 
*              THE PREAMBLE OF THE FILE WHICH CONTAINS THE MAP AND
*              OTHER FIELDS IN THE MAP ARE APPROPRIATELY FILLED IN
*              WITH ZEROES OR SPACES. 
* 
* 
*     MINIT - IS CALLED BY SSDEF FOR EACH SM THAT SSDF CREATES. 
* 
*     PROC MINIT(LFN,RSTATUS) 
* 
*     ENTRY     LFN     - MAP FILE NAME.
* 
*     EXIT      RSTATUS - ERROR STATUS. 
*                         (VALUES DEFINED IN *COMBCMS*) 
*                         = NO ERRORS.
*                         = MAP ALREADY EXISTS. 
*                         = *CIO* ERROR.
*                         = MAP DEFINE ERROR. 
# 
  
      ITEM LFN        C(6);         # NAME OF MAP FILE #
      ITEM SM$ID      U;             # *SM* NUMBER #
      ITEM RSTATUS    I;             # ERROR STATUS # 
  
# 
****  PROC MINIT - XREF LIST BEGIN. 
# 
  
      XREF
        BEGIN 
        PROC PFD;                    # PERMANENT FILE REQUEST DELAYS #
        PROC RETERN;                 # INTERFACE TO *RETURN* MACRO  # 
        PROC WRITER;                 # INTERFACE TO *WRITER* MACRO  # 
        PROC WRITEW;                 # INTERFACE TO *WRITEW* MACRO  # 
        PROC ZSETFET;                # INITIALIZES A *FET* FOR *I/O* #
        END 
  
# 
****  PROC MINIT - EXREF LIST END.
# 
  
      DEF LISTCON #0#;               # CONTROLS COMDECK LISTING  #
*CALL COMBFAS 
*CALL COMBCMD 
*CALL COMBCMS 
*CALL COMBFET 
*CALL COMBMAP 
*CALL COMBMCT 
*CALL COMBPFS 
*CALL COMXMSC 
*CALL COMSPFM 
  
  
      ITEM ZI         U;             # *Z* COUNTER FOR ORDINAL
                                       CALCULATION  # 
      ITEM YI         U;             # *Y* COUNTER FOR ORDINAL
                                       CALCULATION  # 
      ITEM MAPORD     U;             # ORDINAL OF CARTRIDGE IN MAP  # 
      ITEM WRITESTAT  U;             # STATUS FROM *WRITEW* MACRO  #
  
# 
*     DEFINITION OF A MAP ENTRY WHICH IS USED 
*     TO INITIALIZE A MAP FILE. 
# 
  
      ARRAY SMUENTRY [0:0] P(MAPENTL); # CHANGE LINES 2032,2035,2099 #
        BEGIN 
        ITEM FILLWRD1   U(00,00,60) = [O"0000 0055 5555 5555 5555"];
        ITEM FILLWRD2  U(01,00,60); 
        ITEM FILLWRD3  U(02,00,60) = [O"0000 5555 5555 5555 5555"]; 
        END 
  
  
  
  
      RSTATUS = CMASTAT"NOERR"; 
# 
*     DEFINE A PERMANENT FILE FOR THE MAP.
# 
  
      PFD("DEFINE",LFN,0,"BR","Y","RC",PFSTAT,"UP",0,0);
      IF PFSTAT NQ 0
      THEN
        BEGIN 
        IF PFSTAT EQ FAP
        THEN
          BEGIN 
          RSTATUS = CMASTAT"INTLZD";
          END 
  
        ELSE
          BEGIN 
          RSTATUS = CMASTAT"DEFERR";
          END 
  
        RETURN; 
        END 
  
# 
*     INITIALIZE A *SMUMAP* FET.
# 
  
      ZSETFET (MAPFADR,LFN,MAPBADR,MAPBUFL,RFETL);
      FET$EP[0] =TRUE;
  
# 
*     INITIALIZE THE PREAMBLE FOR THE MAP FILE. 
# 
  
      P<SMUMAP> = LOC(SMUENTRY); # CHANGE CSUMAP TO SMUMAP #
      CM$CODE[0] = CUBSTAT"NOCUBE"; 
      CM$SMID = SM$ID;
      WRITEW(MAPFET,SMUENTRY,MAPENTL,WRITESTAT);
      IF FET$AT[0] NQ 0 
      THEN
        BEGIN 
        RSTATUS = CMASTAT"CIOERR";
        RETERN(MAPFET); 
        RETURN; 
        END 
  
  
# 
*     PREPARE A BUFFER FOR THE FILE.
*     DATA IS MOVED INTO THE CIRCULAR BUFFER IN ORDINAL FASHION BY
*     EXECUTING A DRECEMENTING * DO*  LOOP FOR * Z*  INSIDE A 
*     *DO* LOOP FOR *Y*.  THIS IS EQUIVALENT TO THE ORDINAL 
*     CALCULATION DESCRIBED BY NOCUBES-Z-(Y-MAX$Z). 
# 
  
  
# CHANGE LINES 2054 THROUGH 2110 #
      FASTFOR YI = MAX$Y STEP -1 UNTIL 0
      DO
        BEGIN  # YI DO #
        FASTFOR ZI = MAX$Z STEP -1 UNTIL 0
        DO
          BEGIN  # ZI DO #
          CM$CODE[0] = CUBSTAT"UNASGN"; 
  
# 
*      THERE ARE NO CUBICLES FOR CARTRIDGES AT *Z* = 6 BECAUSE
*      THE DRDS RESIDE IN THIS AREA. THERE ARE NO CUBICLES
*      AT THE FOLLOWING COORDINATES: *Z* = 0 *Y* = 15,
*      *Z* = 1  *Y* = 15, *Z* = 0 *Y* = 14, *Z* = 1 *Y* = 14, 
*      *Z* = 0  *Y* = 13, *Z* = 1 *Y* = 13, *Z* = 0 *Y* = 12, 
*      *Z* = 1  *Y* = 12, *Z* = 0 *Y* = 11, *Z* = 1 *Y* = 11. 
*      THERE ARE NO CUBLICLES IN  THE PREVIOUSLY LISTED COORDINATES 
*      BECAUSE THE ENTRY TRAY IS PHYSICALLY LOCATED AT THESE LOCATIONS. 
# 
  
          IF ZI EQ 6 OR (( YI LQ 15 AND YI GQ 11) 
             AND (ZI EQ 0 OR ZI EQ 1))
          THEN
            BEGIN 
            CM$CODE[0] = CUBSTAT"NOCUBE"; 
            END 
  
# 
*     RESERVE *CE* CUBICLES.
# 
  
          IF ((YI EQ 0) AND ( ZI EQ 0 OR   ZI EQ 15)) 
             OR (( ZI EQ 15) AND ( YI EQ 11 OR YI EQ 21)) 
          THEN
            BEGIN 
            CM$CODE[0] = CUBSTAT"CEUSE";
            END 
  
  
          WRITEW(MAPFET,SMUENTRY,MAPENTL,WRITESTAT);
          IF FET$AT[0] NQ 0 
          THEN
            BEGIN 
            RSTATUS = CMASTAT"CIOERR";
            RETERN(MAPFET); 
            RETURN; 
            END 
  
          END  # ZI DO  # 
  
        END  # YI DO  # 
  
# 
*     FLUSH THE CIRCULAR BUFFER TO DISK.
# 
  
      WRITER(MAPFET,RCL); 
      IF FET$AT[0] NQ 0 
      THEN
        BEGIN 
        RSTATUS = CMASTAT"CIOERR";
        END 
  
      RETERN(MAPFET); 
      RETURN; 
      END  # MINIT #
  
    TERM
PROC MOPEN ((SM$ID),(LFN),(MODE),RSTATUS);
# TITLE MOPEN - ESTABLISH CALLER ACCESS TO MAP FILE.                  # 
      BEGIN  # MOPEN  # 
  
# 
**    MOPEN - PREPARES THE MAP FILE FOR SUBSEQUENT REFERENCES BY THE
*             CALLER. 
* 
*     MOPEN - IS CALLED BY USRPC,VLSUBSM. 
* 
*     PROC MOPEN (SM$ID,LFN,MODE,RSTATUS) 
* 
*     ENTRY     SM$ID   - *SM* NUMBER FOR THE MAP.
*               LFN     - NAME OF MAP FILE. 
*               MODE    - FILE ATTACH MODE IN DISPLAY CODE. 
*                         = *M*, MODIFY MODE. 
*                         = *RM*, READ/ALLOW MODIFY MODE. 
* 
*     EXIT      RSTATUS - ERROR STATUS. 
*                         (VALUES DEFINED IN *COMBCMS*) 
*                         = NO ERRORS.
*                         = MAP INTERLOCKED.
*                         = MAP ALREADY OPEN. 
*                         = *CIO* ERROR.
*                         = MAP ATTACH ERROR. 
# 
  
      ITEM SM$ID     U;             # *SM* NUMBER FOR MAP  #
      ITEM LFN        C(6);         # NAME OF MAP FILE #
      ITEM MODE       C(2);          # FILE ATTACH MODE # 
      ITEM RSTATUS    U;             # ERROR STATUS RETURNED  # 
  
# 
****  PROC MOPEN - XREF LIST BEGIN. 
# 
  
  
      XREF
        BEGIN 
        PROC MCLOSE;                 # CLOSE MAP #
        PROC MFLUSH;                 # FLUSH MAP TO FILE  # 
        PROC PFD;                    # PERMANENT FILE REQUEST DELAYS #
        PROC READ;                   # INTERFACE TO *READ* MACRO #
        PROC ZSETFET;                # INITIALIZES A *FET* FOR *I/O* #
        END 
  
# 
****  PROC MOPEN - EXREF LIST END.
# 
  
  
      DEF LISTCON #0#;               # NO LISTING OF COMMON DECKS  #
*CALL COMBFAS 
*CALL COMBCMD 
*CALL COMBCMS 
*CALL COMBFET 
*CALL COMBMAP 
*CALL COMBMCT 
*CALL COMBPFS 
*CALL COMXCTF 
*CALL COMXMSC 
*CALL COMSPFM 
  
  
      ITEM ZERO       U = 0;         # WORD OF ZERO  #
  
  
  
  
  
      RSTATUS = CMASTAT"NOERR"; 
      P<OMT> = OMTADR;
  
# 
*     RETURN ERROR IF FILE OPEN.
# 
  
      IF OMT$OPEN [SM$ID] 
      THEN
        BEGIN 
        RSTATUS = CMASTAT"FOPEN"; 
        RETURN; 
        END 
  
      PFD("ATTACH",LFN,0,"M",MODE,"RC",PFSTAT,"NA",0,"UP",0,0); 
  
# 
*     RETURN ATTACH ERROR IF NOT BUSY.
# 
  
      IF PFSTAT NQ 0 AND PFSTAT NQ FBS
      THEN
        BEGIN 
        RSTATUS = CMASTAT"ATTERR";
        RETURN; 
        END 
  
# 
*     CREATE AN OPEN MAP TABLE ENTRY FOR AN EXISTING FILE.
# 
  
      OMT$ATTM[SM$ID] = MODE; 
      OMT$LFN[SM$ID] = LFN; 
      OMT$ZER[SM$ID] = 0; 
  
# 
*     INTERLOCK THE FILE IF BUSY. 
# 
  
      IF PFSTAT EQ FBS
      THEN
        BEGIN 
        OMT$INTLK[SM$ID] = TRUE;
        MAPINTLK = TRUE;
        RSTATUS = CMASTAT"INTLK"; 
        RETURN; 
        END 
  
# 
*     SET FILE OPEN AND AVAILABLE.
# 
  
      OMT$INTLK[SM$ID] = FALSE; 
      OMT$OPEN[SM$ID] = TRUE; 
      MFLUSH; 
      ZSETFET (MAPFADR,LFN,MAPBADR,MAPBUFL,RFETL);
      P<MAPFET> = MAPFADR;
      FET$EP[0] = TRUE; 
      FET$R[0] = TRUE;
      FET$RR[0] = 1;
      READ(MAPFET,RCL); 
      IF FET$AT[0] NQ 0 
      THEN
        BEGIN 
        MCLOSE(SM$ID);
        RSTATUS = CMASTAT"CIOERR";
        RETURN; 
        END 
  
# 
*     UPDATE MAP BUFFER CONTROL WORD TO REFLECT CURRENT CONTENTS. 
# 
  
      P<SMUMAP> = MAPBADR;
      MB$PRUNUM[0] = 1; 
      MB$SMID[0] = CM$SMID[0];
      MB$LFN[0] = OMT$LFN[SM$ID]; 
  
# 
*     VERIFY THAT THE RIGHT FILE HAS BEEN ATTACHED. 
# 
  
      IF CM$SMID[0] NQ SM$ID
      THEN
        BEGIN 
        MCLOSE(SM$ID,RSTATUS);
        RSTATUS = CMASTAT"ATTERR";
        END 
  
      RETURN; 
      END  # MOPEN  # 
  
    TERM
PROC MPUTENT ((SM$ID),(ORDINAL),(MAPADR),RSTATUS);
# TITLE MPUTENT - MAP ENTRY TO THE MAP FILE BUFFER.                   # 
      BEGIN  # MPUTENT  # 
  
# 
**    MPUTENT - MOVES THE REQUESTED MAP ENTRY FROM THE CALLERS
*               MEMORY SPACE TO THE MAP *I/O* BUFFER. 
* 
*               THE BUFFER IS NOT WRITTEN TO THE FILE AT THIS TIME
*               BUT THE BUFFER MODIFIED FLAG IS SET.
*               THE CALLER IS RESPONSIBLE FOR CALLING *MFLUSH* AT THE 
*               TIME THE BUFFER SHOULD BE WRITTEN TO THE FILE.
* 
*     MPUTENT - IS CALLED BY ADDCAR,ADDCUBE,RMVCAR,RMVCUBE, 
*               UPDMAP. 
* 
*     PROC MPUTENT (SM$ID,ORDINAL,MAPADR,RSTATUS) 
* 
*     ENTRY     SM$ID   - *SM* NUMBER OF MAP FILE.
*               ORDINAL - *XY* COORDINATE ORDINAL FOR THE ENTRY.
*               MAPADR  - ADDRESS OF MAP ENTRY WITHIN CALLER AREA.
* 
*     EXIT      RSTATUS - ERROR STATUS. 
*                         (VALUES DEFINED IN *COMBCMS*) 
*                         = NO ERRORS.
*                         = MAP INTERLOCKED.
*                         = MAP NOT OPEN. 
*                         = MAP NOT OPEN IN MODIFY MODE.
*                         = *CIO* ERROR.
*                         = MAP ORDINAL OUT OF RANGE. 
# 
  
      ITEM SM$ID     U;             # *SM* NUMBER  #
      ITEM ORDINAL    U;             # *XY* COORDINATE ORDINAL  # 
      ITEM MAPADR     U;             # SOURCE OF CATALOG ENTRY  # 
      ITEM RSTATUS    U;             # STATUS RETURNED TO THE CALLER  # 
  
# 
****  PROC MPUTENT - XREF LIST BEGIN. 
# 
  
      XREF
        BEGIN 
        PROC MBUFMAN;                # GET ENTRY INTO BUFFER #
        END 
  
# 
****  PROC MPUTENT - EXREF LIST END.
# 
  
      DEF LISTCON #0#;               # CONTROLS COMDECK LISTING  #
*CALL COMBFAS 
*CALL COMBCMD 
*CALL COMBCMS 
*CALL COMBMAP 
*CALL COMSPFM 
  
      ITEM I          I;             # INDUCTION VARIABLE  #
      ITEM OFFSET     U;             # RELATIVE LOCATION OF *XY* IN 
                                       BUFFER  #
  
      BASED 
      ARRAY MENTRY [0:0] P(1);
        BEGIN 
        ITEM ENT$WRD     U(00,00,60);  # ENTRY WORD  #
        END 
  
  
  
  
  
      RSTATUS = CMASTAT"NOERR"; 
  
# 
*     RETURN ERROR IF FILE INTERLOCKED. 
# 
  
      IF OMT$INTLK[SM$ID] 
      THEN
        BEGIN 
        RSTATUS = CMASTAT"INTLK"; 
        RETURN; 
        END 
  
# 
* 
*     MAP FILE HAS TO BE OPENED IN *MODIFY* MODE. 
# 
  
      IF NOT OMT$OPEN[SM$ID]
      THEN
        BEGIN 
        RSTATUS = CMASTAT"NOTOPEN"; 
        RETURN; 
        END 
  
      IF OMT$ATTM[SM$ID] EQ "RM"
      THEN
        BEGIN 
        RSTATUS = CMASTAT"MODERR";
        RETURN; 
        END 
  
# 
*     GET OFFSET OF ENTRY IN BUFFER.
# 
  
      MBUFMAN(SM$ID,ORDINAL,OFFSET,RSTATUS);
      IF RSTATUS NQ 0 
      THEN
        BEGIN 
        RETURN; 
        END 
  
# 
*     TRANSFER ENTRY TO BUFFER. 
# 
  
      P<MENTRY> = MAPADR; 
      P<MAPBUF> = MAPBADR;
      FASTFOR I = 1 STEP 1 UNTIL MAPENTL
      DO
        BEGIN 
        MAPB$W[OFFSET + I] = ENT$WRD[I - 1];
        END 
  
      MB$BMF[0] = TRUE; 
      RETURN; 
      END  # MPUTENT #
  
    TERM
PROC MRCLMLK((SM$ID),RSTATUS);
# TITLE MRCLMLK - RECLAIM MAP INTERLOCK.                              # 
      BEGIN  # MRCLMLK  # 
  
# 
**    MRCLMLK - TRIES TO RECLAIM THE MAP FILE FOR THE SPECIFIED *SM*. 
*               IT IS ASSUMED THAT THE CALLER IS RUNNING UNDER THE
*               DEFAULT FAMILY AND USER INDEX OF 377760B. 
* 
*     MRCLMLK - IS CALLED BY RCLMLK AND MAPRCLM.
* 
*     PROC MRCLMLK(SM$ID,RSTATUS) 
* 
*     ENTRY     SM$ID  - *SM* NUMBER OF THE MAP.
* 
*     EXIT      RSTATUS - ERROR STATUS. 
*                         (VALUES DEFINED IN *COMBCMS*) 
*                         = NO ERRORS.
*                         = MAP INTERLOCKED.
*                         = MAP ATTACH ERROR. 
* 
* 
*     MESSAGES   * UNABLE TO REATTACH SMUMAP. 
*                  CSMAPX CLOSED.*
# 
  
      ITEM SM$ID     U;             # *SM* NUMBER  #
      ITEM RSTATUS    U;             # ERROR STATUS RETURNED  # 
  
# 
****  PROC MRCLMLK - XREF LIST BEGIN. 
# 
  
      XREF
        BEGIN 
        PROC MESSAGE;                # ISSUE MESSAGE #
        PROC MOPEN;                  # OPEN MAP # 
        PROC PF;                     # *PFM* REQUEST INTERFACE #
        END 
  
# 
****  PROC MRCLMLK - EXREF LIST END.
# 
  
      DEF LISTCON #0#;               # DO NOT LIST COMMON DECKS  #
*CALL COMBFAS 
*CALL COMBCMD 
*CALL COMBCMS 
*CALL COMBMCT 
*CALL COMXMSC 
*CALL COMSPFM 
  
      ITEM ATCH$STAT  U;             # STATUS FROM *ATTACH* REQUEST # 
  
      RSTATUS = CMASTAT"NOERR"; 
      P<OMT> = OMTADR;
  
# 
*     EXIT IF MAP NOT INTERLOCKED.
# 
  
      IF NOT OMT$INTLK[SM$ID] 
      THEN
        BEGIN 
        RETURN; 
        END 
  
# 
*     IF THE FILE IS OPEN, ATTACH IT. 
*     IF THE FILE IS NOT OPEN, OPEN IT. 
# 
  
      IF NOT OMT$OPEN[SM$ID]
      THEN
        BEGIN 
        MOPEN(SM$ID,OMT$LFN[SM$ID],OMT$ATTM[SM$ID],RSTATUS);
        RETURN; 
        END 
  
      PF("ATTACH",OMT$LFN[SM$ID],0,"M",OMT$ATTM[SM$ID], 
        "RC",ATCH$STAT,"NA",0,"UP",0,0);
      IF ATCH$STAT NQ 0 
      THEN
        BEGIN          # INTERLOCK NOT RECLAIMED #
        IF ATCH$STAT EQ FBS OR ATCH$STAT EQ PFA  ## 
          OR ATCH$STAT EQ INA OR ATCH$STAT EQ FTF  ## 
          OR ATCH$STAT EQ PEA 
        THEN                         # MAP BUSY OR TEMPORARY ERROR #
          BEGIN 
          RSTATUS = CMASTAT"INTLK"; 
          END 
  
        ELSE
          BEGIN 
          RSTATUS = CMASTAT"ATTERR";
          OMT$OPEN[SM$ID] = FALSE;
          OMT$INTLK[SM$ID] = FALSE; 
          CMSGLINE[0] = MMSG1;       # ISSUE ERROR MESSAGE #
          MESSAGE(CMSGAREA,UDFL1);
          CMSGLINE[0] = MMSGCLOSE;
          CMSGMAPID[0] = SM$ID; 
          MESSAGE(CMSGAREA,UDFL1);
          END 
  
        END            # INTERLOCK NOT RECLAIMED #
  
      ELSE                         # INTERLOCK RECLAIMED #
        BEGIN 
        OMT$INTLK[SM$ID] = FALSE; 
        END 
  
  
      RETURN; 
  
      END  # MRCLMLK  # 
  
    TERM
PROC MRELSLK ((SM$ID)); 
# TITLE MRELSLK - RETURN A MAP FILE.                                  # 
      BEGIN  # MRELSLK  # 
  
# 
**    MRELSLK - RETURNS A *SMMAP* FILE FOR A *SMID* WHICH HAS BEEN
*               PREVIOUSLY OPENED IN *MODIFY* MODE. 
* 
*     MRELSLK - IS CALLED BY MAPRELS. 
* 
*     PROC MRELSLK (SM$ID)
* 
*     ENTRY     SM$ID  - *SM* NUMBER OF MAP FILE. 
# 
  
      ITEM SM$ID     U;             # *SM* NUMBER FROM CALLER  #
  
# 
****  PROC MRELSLK - XREF LIST BEGIN. 
# 
  
      XREF
        BEGIN 
        PROC MFLUSH;                 # FLUSH MAP TO FILE  # 
        PROC RETERN;                 # INTERFACE TO *RETURN* MACRO  # 
        PROC RTIME;                  # GET CURRENT TIME # 
        PROC ZSETFET;                # INITIALIZES A *FET* FOR *I/O* #
        END 
  
# 
****  PROC MRELSLK - EXREF LIST END.
# 
  
      DEF LISTCON #0#;               # CONTROLS COMDECK LISTING  #
*CALL COMBFAS 
*CALL COMBCMD 
*CALL COMBCMS 
*CALL COMBFET 
*CALL COMBMCT 
*CALL COMXCTF 
*CALL COMXIPR 
*CALL COMXMSC 
*CALL COMSPFM 
  
  
  
  
  
# 
*     MAP FILE HAS TO BE OPEN AND IN *MODIFY* MODE. 
# 
  
      IF OMT$OPEN[SM$ID]                    # # 
        AND OMT$ATTM[SM$ID] EQ "M"           # #
        AND NOT OMT$INTLK[SM$ID]
      THEN
        BEGIN 
        MFLUSH; 
        P<FETSET> = MAPFADR;
        FET$LFN[0] = OMT$LFN[SM$ID];
        RETERN(MAPFET,RCL); 
        OMT$INTLK[SM$ID] = TRUE;
        MAPINTLK = TRUE;
        RTIME(RTIMESTAT[0]);
        MAP$EXPIR = RTIMSECS[0] + MAP$INTV; 
        END 
  
      RETURN; 
      END  # MRELSLK  # 
  
    TERM
