*DECK DB$DMGR 
      PROC DB$DMGR; 
  
      BEGIN 
      DEF   DFAL          # 18#;    # LENGTH IN BITS OF ADDRESS FIELD  #
      DEF   DFDELAY      #0600#;    # DELAY COUNT                      #
      DEF   DFKBUFLEN     #  7#;    # LENGTH OF KEYBOARD INPUT BUFFER  #
      DEF   DFOVRFLHDRLG  #  1#;    # LENGTH OF OVERFLOW BUFFER HEADER #
      DEF   DFRSPLNS      #  2#;    # NUMBER OF RESPONSE LINES - 1     #
      DEF   DFWC          # 10#;    # LENGTH OF WORD IN CHARACTERS     #
      DEF   DFWL          # 60#;    # LENGTH OF WORD IN BITS           #
  
*CALL SACSTDCLS     SCHEMA/AREA/CDCS STATUS 
  
  
 #
* *   DB$DMGR - DISPLAY MANAGER                  PAGE  1
* *   J G SERPA                                  DATE  11/30/78 
* 
* DC  PURPOSE 
* 
*     THE DISPLAY MANAGER IS A SET OF ROUTINES WHICH PROVIDE A HIGH 
*     LEVEL, OPERATING SYSGEM INDEPENDENT INTERFACE TO THE USE OF 
*     THE *L* DISPLAY. IT IS INTENDED THAT ONLY THIS MODULE AND ITS 
*     COMPASS INTERFACE MODULE WILL KNOW THE NITTY DETAILS OF THE 
*     OPERATING SYSTEM INTERFACE. THE DISPLAY BUFFERS WILL BE KNOWN 
*     ONLY TO THE DISPLAY MANAGER (AND PARTIALLY TO DB$ROLL, SO IT
*     KNOWS HOW TO DETECT A WATCHER). THIS PROC IS ONLY FOR USE AS A
*     PACKAGING MODULE. ITS ENTRY POINT WILL NOT BE REFERENCED. 
* 
* DC  CONTAINED ROUTINES
# 
      XDEF PROC DB$DACD;           # ACTIVATE CONSOLE DISPLAY          #
      XDEF PROC DB$DADV;           # ADVANCE A PAGE                    #
      XDEF PROC DB$DAED;           # ACTIVATE ERROR DISPLAY            #
      XDEF PROC DB$DBHL;           # BEGIN HEADER LINES                #
      XDEF PROC DB$DBKU;           # BACK UP A PAGE                    #
      XDEF PROC DB$DBLL;           # BEGIN LIST LINES                  #
      XDEF PROC DB$DCDL;           # CLEAR DIAGNOSTIC LINE             #
      XDEF PROC DB$DCRL;           # CLEAR RESPONSE LINES              #
      XDEF PROC DB$DDIL;           # LOCK IN OVCAP CD2DDIF             #
      XDEF PROC DB$DECE;           # ENTER COMMAND ECHO                #
      XDEF PROC DB$DEDL;           # ENTER DIAGNOSTIC LINE             #
      XDEF PROC DB$DEHL;           # ENTER HEADER LINES                #
      XDEF PROC DB$DELL;           # ENTER LIST LINES                  #
      XDEF PROC DB$DERL;           # ENTER RESPONSE LINES              #
      XDEF PROC DB$DGOC;           # GET OPERATOR COMMAND              #
      XDEF PROC DB$DIDM;           # INITIALIZE DISPLAY MANAGER        #
      XDEF PROC DB$DROT;           # ROLL OUT TASKS                    #
      XDEF PROC DB$DUDF;           # UPDATE DYNAMIC FIELDS             #
  
# 
* DC  NON LOCAL VARIABLES 
* 
# 
      XREF ITEM DB$DCWE B;         # TRUE - CONSOLE WATCHER EXISTS     #
      XREF ITEM DB$DMAA C(DFWC);   # NUMBER OF ACTIVE AREAS            #
      XREF ITEM DB$DMAS C(DFWC);   # NUMBER OF ACTIVE SCHEMAS          #
      XREF ITEM DB$DMAU C(DFWC);   # NUMBER OF ACTIVE USERS            #
      XREF ITEM DB$DMCL I;         # NUMBER OF CURRENT COMMAND LIST    #
      XREF ITEM DB$DMCP I;         # BEGINNING CHARACTER POSITION      #
                                   # FOR L DISPLAY BUFFER WORDS        #
                                   #    4  - NOS                       #
                                   #    6  - NOS/BE                    #
      XREF ITEM DB$DMDG C(70);     # CDCS DIAGNOSTIC LINE              #
      XREF ITEM DB$DMFF B;         # FLASHING MESSAGE FLAG             #
      XREF ITEM DB$DMFM C(50);     # FLASHING MESSAGE TO BE ISSUED     #
      XREF ITEM DB$DMH2 C(70);     # LINE 2 OF HEADER                  #
      XREF ITEM DB$DMLC C(70);     # CDCS LAST COMMAND LIST            #
      XREF ITEM DB$DMSF B;         # SUSPEND FLAG                      #
      XREF ITEM DB$DMTU C(DFWC);   # TOTAL NUMBER OF USERS             #
      XREF ITEM DB$DNAA I;         # NUMBER OF ACTIVE AREAS            #
      XREF ITEM DB$DNAS I;         # NUMBER OF ACTIVE SCHEMAS          #
      XREF ITEM DB$DNAU I;         # NUMBER OF ACTIVE USERS            #
      XREF ITEM DB$DNTU I;         # NUMBER OF TOTAL USERS             #
      XREF ITEM DB$DSST S:SACSTAT; # SYSTEM STATUS                     #
      XREF ITEM DB$DWSC B;         # CONSOLE WATCHER STATUS CHANGED    #
      XREF ITEM DB$NOS  B;         # NOS = TRUE, NOS/BE = FALSE        #
      XREF ITEM DB$TRMF B;         # CDCS TERMINATION FLAG             #
  
  
      XREF ARRAY DB$DMDL S(7);     # L DISPLAY DYNAMIC LINES           #
             BEGIN
             ITEM DYNAMICLINE  C(00,00,70); 
             ITEM DYNAMICWORD  U(00,00,DFWL); 
             END
  
      XREF ARRAY DB$DMEB [0,0];              # ERROR DISPLAY BUFFER    #
             BEGIN
             ITEM ERRBUFWORD U(00,00,DFWL); 
             ITEM ERRDISPIB  U(00,06,DFAL);  # INPUT BUFFER WA         #
             ITEM ERRDISPRB  U(00,24,DFAL);  # RIGHT DISPLAY BUFFER    #
             ITEM ERRDISPLB  U(00,42,DFAL);  # LEFT DISPLAY BUFFER     #
             END
  
      XREF ARRAY DB$DMMB [0:0];              # MINI DISPLAY BUFFER     #
             BEGIN
             ITEM MINIBUFWORD U(00,00,DFWL);
             ITEM MINIDISPIB  U(00,06,DFAL); # INPUT BUFFER WA         #
             ITEM MINIDISPRB  U(00,24,DFAL); # RIGHT DISPLAY BUFFFER   #
             ITEM MINIDISPLB  U(00,42,DFAL); # LEFT DISPLAY BUFFER     #
             END
  
      XREF ARRAY DB$DMMD [0:0];                # MAIN DISPLAY BUFFER   #
             BEGIN
             ITEM MAINBUFWORD   U(00,00,DFWL);
             ITEM MAINDISPIB    U(00,06,DFAL); # MAIN DISPLAY INPUT WA #
             ITEM MAINDISPRB    U(00,24,DFAL); # RIGHT DISPLAY BUFFER  #
             ITEM MAINDISPLB    U(00,42,DFAL); # LEFT DISPLAY BUFFER   #
             END
  
      XREF ARRAY DB$DMRP [0:DFRSPLNS] S(7);    # CDCS RESPONSE LINES   #
             BEGIN
             ITEM RESPLINE   C(00,00,70); 
             END
 #                                                                     #
#     LOCAL VARIABLES                                                  #
  
  
      ITEM CHAR10    C(10) = " ";  # TEN CHARACTER SCRATCH WORD        #
      ITEM CURRDISP  U;      # CURRENT DISPLAY BUFFER CONTROL WORD     #
      ITEM DISPSIZ   I;      # DISPLAY PAGE SIZE                       #
      ITEM DONE      B;      # TRUE IF THE SCAN IS TO BE ENDED         #
      ITEM FIRSTBUF  B;      # TRUE WHEN NEXT OVERFLOW IS FIRST ONE    #
      ITEM FIRSTPAGE I = 0;  # POINTER TO FIRST PAGE BUFFER            #
      ITEM FIRSTPG   C(50) = "         (FIRST PAGE, ENTER + TO SEE NEXT 
PAGE)"; 
      ITEM GRLENGTH  I;      # LENGTH OF A GROUP OF DISPLAY LINES      #
      ITEM I         I;      # FOR LOOP VARIABLE                       #
      ITEM LASTPG    C(50) = "         (LAST PAGE, ENTER - TO SEE PRIOR 
PAGE)"; 
      ITEM MIDPG     C(50) = "            (ENTER + OR - TO SEE OTHER PAG
ES)"; 
      ITEM NUMHDRLNS I = 0;  # NUMBER OF HEADER LINES                  #
      ITEM NUMLINES  I = 0;  # NUMBER OF LIST LINES IN DYNAMIC AREA    #
      ITEM NXTLNPTR  I = 0;  # POINTER TO WHERE NEXT LIST LINE IS      #
                             # TO BE ENTERED                           #
      ITEM NXTRLPTR  I = 0;  # POINTER TO NEXT RESPONSE LINE           #
      ITEM ONLYPG    C(40) = "                   (SINGLE PAGE DISPLAY)";
      ITEM OPRMSG    C(40) = "$OPERATOR REPLY NEEDED. SEE -L- DISPLAY:";
      ITEM OVRBUFSIZ I = 0;  # SIZE OF OVERFLOW PAGE BUFFER            #
      ITEM PLUSPGC   I;      # *PLUS* PROCESSING PAGE COUNTER          #
      ITEM PLUSX     I;      # *PLUS* PROCESSING INDEX                 #
  
  
#     THE FOLLOWING ARRAY IS DEFINED AS S(1) SO THAT WE MAY ZERO       #
#     EACH WORD INDIVIDUALLY. HOWEVER, *CONSOLEWATCH* IS DEFINED AS    #
#     U(07,00,DFWL) BECAUSE WE HAVE TO ACCESS THE WATCHER WORD WHICH   #
#     IS LOCATED AT KEYBOARD INPUT BUFFER + 7.                         #
#     *CONSOLEWORD* IS USED FOR ZEROING THE BUFFER AND ALSO FOR        #
#     DETECTING A OPERATOR COMMAND (FIRST WORD NON-ZERO).              #
  
  
      BASED ARRAY CONSOLEBUF [0:DFKBUFLEN] S(1);  # CONSOLE INPUT BUFF #
              BEGIN 
              ITEM CONSOLEWORD     U(00,00,DFWL); # OPERATOR COMMAND   #
              ITEM CONSOLECOMMD    C(00,00,70);   # OPR. COMMD. STRING #
              ITEM CONSOLEWATCH    U(07,00,DFWL); # CONSOLE WATCHER    #
              END 
  
      BASED ARRAY DESTBUFFWA [0:0] S(2);     # DESTINATION BUFFER FWA  #
              BEGIN 
              ITEM PAGEBUFPOS  U(DFOVRFLHDRLG,00,DFWL);  # POSITION    #
                                  # OF FIRST NON HEADER WORD IN BUFFER #
              END 
  
      BASED ARRAY DESTBUFFER [0:0] S(7);    # BUFFER USED BY DB$DELL   #
              BEGIN 
              ITEM DESTLINE   C(00,00,70);  # DESTINATION LINE         #
              END 
  
      BASED ARRAY OVRFLPAGE [0:0] S(7);     # OVERFLOW PAGE BUFFER     #
              BEGIN 
              ITEM OVRFLLINE  C(00,00,70);  # OVERFLOW LINES           #
              END 
  
      BASED ARRAY OVRFLWFW [0:0] S(2);       # FIRST WORD OF OVERFLOW  #
              BEGIN                          # PAGE BUFFERS            #
              ITEM PRIORPAGE  U(00,24,DFAL); # POINTER TO PRIOR PAGE   #
              ITEM NEXTPAGE   U(00,42,DFAL); # POINTER TO NEXT PAGE    #
              ITEM PAGEPOS    U(DFOVRFLHDRLG,00,DFWL);  # POSITION     #
                                  # OF FIRST NON HEADER WORD IN BUFFER #
              END 
  
#     TWO ARRAYS USED FOR INSERTING THE PLUS PAGE COUNTS INTO THE      #
#     FIRST PAGE.                                                      #
  
      BASED ARRAY PLUSBUF1 S(7);
        BEGIN 
        ITEM PLUSNUM1   C(01,00,20);  # PLUS NUMBER FOR MAIN BUFFER    #
        END 
  
      BASED ARRAY PLUSBUF2 S(7);
        BEGIN 
        ITEM PLUSNUM2   C(01,00,20);  # PLUS NUMBER FOR OVERFLOW BUFFER#
        ITEM PLUSNEXT   I(00,42,18);  # POINTER TO NEXT OVERFLOW BUFFER#
        END 
  
  
      ARRAY DB$DMST [0:4];                   # CDCS STATUS             #
        BEGIN 
        ITEM CDCS$STATUS  C(00,00,DFWC) = 
                                         ["UP"
                                         ,"IDLE"
                                         ,"IDLE"
                                         ,"DOWN"
                                         ,"DOWN"
                                         ]; 
        END 
  
  
  
  
  
#     E M B E D D E D   P R O C E D U R E   -   D B $ D A C D .        #
  
  
  
      PROC DB$DACD;               # ACTIVATE CONSOLE DISPLAY           #
  
      BEGIN 
 #
* *   DB$DMGR                                    PAGE  1
* *   DB$DACD - ACTIVATE CONSOLE DISPLAY
* *   J G SERPA                                  DATE  11/30/78 
* 
* DC  PURPOSE 
* 
*     TO ACTIVATE THE MAIN DISPLAY. 
* 
* DC  ENTRY CONDITIONS
* 
*     NONE
* 
* DC  EXIT CONDITIONS 
* 
*     CONSOLE DISPLAY HAS BEEN SWITCHED TO MAIN DISPLAY.
*     DB$DMFF HAS BEEN SET TO FALSE.
*     MESSAGE *CDCS ACTIVE* HAS BEEN DISPLAYED ON THE B DISPLAY.
* 
* DC  CALLING ROUTINES
* 
*     DB$DGOC    GET OPERATOR COMMAND 
* 
* DC  CALLED ROUTINES 
# 
      XREF PROC DB$MSGB;     # ISSUE B DISPLAY MESSAGE                 #
      XREF PROC DB$MSG2;     # CLEAR LINE 2 OF THE B DISPLAY           #
# 
*          PROC DB$DMSD        SET/SWITCH DISPLAYS
*          PROC DB$DUDF        UPDATE DYNAMIC FIELDS
* 
* DC  DESCRIPTION 
* 
*     DB$DMSD IS CALLED TO SWITCH THE DISPLAYS FROM THE MINI BUFFER 
*     TO THE MAIN DISPLAY BUFFER.  IF THE FLASHING MESSAGE FLAG IS
*     SET,  IT IS CLEARED AND THE MESSAGE ITSELF IS REPLACED WITH 
*     *CDCS ACTIVE* ON THE B DISPLAY. THEN DB$DUDF IS CALLED TO UPDATE
*     THE DYNAMIC FIELDS. 
* 
 #
  
  
#     E X E C U T A B L E   C O D E   F O R   D B $ D A C D            #
  
  
      DB$DMSD(DB$DMMD);           # SWITCH TO MAIN DISPLAY             #
      DB$MSG2;                    # CLEAR LINE 2 OF THE B DISPLAY      #
  
      IF DB$DMFF                  # IF FLASHING MESSAGE FLAG SET       #
      THEN
        BEGIN 
        DB$DMFF = FALSE;          # CLEAR FLASHING MESSAGE FLAG        #
        DB$MSGB("  CDCS ACTIVE:"); # CLEAR FLASHING B DISPLAY MESSAGE  #
  
        END 
      DB$DUDF;                    # UPDATE DYNAMIC FIELDS IN HEADER    #
  
      RETURN; 
  
      END  # DB$DACD #
  
  
  
  
#     E M B E D D E D   P R O C E D U R E   -   D B $ D A D V .        #
  
  
  
      PROC DB$DADV;               # ADVANCE A PAGE                     #
  
      BEGIN 
 #
* *   DB$DMGR                                    PAGE  1
* *   DB$DADV - ADVANCE A PAGE
* *   J G SERPA                                  DATE  11/29/78 
* 
* DC  PURPOSE 
* 
*     TO DISPLAY THE NEXT PAGE BUFFER IN THE STRING OF SAVED PAGES. 
* 
* DC  ENTRY CONDITIONS
* 
*     NEXTPAGE CONTAINS THE POSITION OF THE NEXT OVERFLOW PAGE
* 
* DC  EXIT CONDITIONS 
* 
*     PAGE HAS BEEN DISPLAYED AND NEW PAGE POSITION SAVED 
* 
* DC  CALLING ROUTINES
* 
*     DB$DS01 
* 
* DC  CALLED ROUTINES 
* 
*     NONE
* 
* DC  DESCRIPTION 
* 
*     THIS ROUTINE INSTRUCTS THE DISPLAY MANAGER TO ADVANCE TO THE
*     NEXT PAGE BUFFER IN ITS STRING OF SAVED PAGES. IF THERE ARE 
*     NO FURTHER BUFFERS OR NO BUFFERS AT ALL, THIS CALL TURNS INTO 
*     A NO-OP. IF THERE IS A NEXT PAGE BUFFER, THE CONTENTS ARE MOVED 
*     INTO THE DISPLAY BUFFER AND THE NEW PAGE POSITION IS SAVED. 
* 
 #
  
  
#     E X E C U T A B L E   C O D E   F O R   D B $ D A D V            #
  
  
  
      IF NEXTPAGE[0] NQ 0         # IF A NEXT PAGE EXISTS              #
      THEN
        BEGIN 
        P<OVRFLWFW> = NEXTPAGE[0];     # ADVANCE PAGE POSITION         #
        P<OVRFLPAGE> = LOC(PAGEPOS[0]); 
  
        FOR I = 0 STEP 1
          UNTIL DISPSIZ - NUMHDRLNS 
        DO                        # MOVE OVERFLOW PAGE TO DISPLAY      #
          BEGIN 
          DYNAMICLINE[NUMHDRLNS+I] = OVRFLLINE[I];    # BUFFER         #
          END 
        END 
      RETURN; 
  
  
      END  # DB$DADV #
  
  
  
  
#     E M B E D D E D   P R O C E D U R E   -   D B $ D A E D .        #
  
  
  
      PROC DB$DAED;                # ACTIVATE ERROR DISPLAY            #
  
      BEGIN 
 #
* *   DB$DMGR                                    PAGE  1
* *   DB$DAED - ACTIVATE ERROR DISPLAY
* *   M. E. STERMER                              DATE  09/10/80 
* 
* DC  PURPOSE 
* 
*     TO DISPLAY ERROR MESSAGES DUE TO THE LACK OF CM.
* 
* DC  ENTRY CONDITIONS
* 
*     ASSUMPTIONS 
* 
*     CMM ERROR OCCURRED WHEN TRYING TO LOAD OPERATOR OVERLAY CAPSULE.
* 
* DC  EXIT CONDITIONS 
* 
*     CONSOLE DISPLAY HAS BEEN SWITCHED TO ERROR DISPLAY.  MESSAGES TO
*     THE B DISPLAY AND DAYFILE HAVE BEEN ISSUED. 
* 
* DC  CALLING ROUTINE 
* 
*     DB$DDOP - DISPLAY DRIVER OVERFLOW PROCEDURE 
* 
* DC  CALLED ROUTINES 
* 
*     PROC DB$DMSD                   SET/SWITCH DISPLAYS
# 
      XREF PROC DB$MSG;            # ISSUE DAYFILE AND B DISPLAY MSG   #
      XREF PROC DB$MSGB;           # ISSUE B DISPLAY MESSAGE           #
      XREF PROC DB$MSG2;           # CLEAR LINE 2 OF B DISPLAY         #
# 
* DC  NON-LOCAL VARIABLES MODIFIED
* 
*     NONE
* 
* DC  DESCRIPTION 
* 
*     DB$DMSD IS CALLED TO SWITCH FROM THE MINI DISPLAY TO THE
*     ERROR DISPLAY. ISSUE A MESSAGE TO THE DAYFILE AND THE B DISPLAY.
* 
 #
  
#     E X E C U T A B L E  C O D E  F O R  D B $ D A E D               #
  
      DB$DMSD(DB$DMEB);            # SWITCH TO ERROR DISPLAY           #
  
      DB$MSG("DUE TO CM USAGE:"); 
  
      DB$MSG("OPERATOR COMMAND NOT POSSIBLE:"); 
  
      DB$MSG2;                     # CLEAR LINE 2 OF THE B DISPLAY     #
  
      DB$MSGB("CDCS ACTIVE:");
  
      RETURN; 
  
      END  # DB$DAED #
  
  
  
  
#     E M B E D D E D   P R O C E D U R E   -   D B $ D A P B .        #
  
  
  
      PROC DB$DAPB;          # ALLOCATE AND PRESET NEW BUFFER          #
  
      BEGIN 
 #
* *   DB$DMGR                                    PAGE  1
* *   DB$DAPB - ALLOCATE AND PRESET NEW BUFFER
* *   J G SERPA                                  DATE  12/07/78 
* 
* DC  PURPOSE 
* 
*     TO ALLOCATE AND PRESET A NEW OVERFLOW PAGE BUFFER.
* 
* DC  ENTRY CONDITIONS
* 
*     OVRBUFSIZ CONTAINS THE SIZE OF THE BUFFER TO BE ALLOCATED.
* 
* DC  EXIT CONDITIONS 
* 
*     A NEW PAGE BUFFER HAS BEEN ALLOCATED AND PRESET TO BLANKS.
* 
* DC  CALLING ROUTINES
* 
*     DB$DELL    ENTER LIST LINES 
* 
* DC  CALLED ROUTINES 
# 
      XREF FUNC DB$LNK;      # CREATE A LINKED BLOCK                   #
# 
* DC  DESCRIPTION 
* 
*     THIS ROUTINE ALLOCATES AN OVERFLOW PAGE BUFFER OF OVRBUFSIZ SIZE
*     BY CALLING DB$LNK. IT THEN PROCEEDS TO INITIALIZE IT. FIRST THE 
*     ENTIRE BUFFER IS PRESET TO BLANKS AND THEN THE CONTROL BYTES
*     ARE PRESET WITH VALUES TAKEN FROM THE DYNAMIC LINES. AFTER ALL THE
*     PRESETTING IS DONE, THE TWO BOTTOM LINES OF THE BUFFER ARE SET
*     TO EOL AND ENTERMINS STRINGS. 
* 
 #
  
  
#     E X E C U T A B L E   C O D E   F O R   D B $ D A P B            #
  
  
#     PLUS/MINUS MESSAGE TO OLD BUFFER.                                #
  
      C<DB$DMCP,64>DESTLINE[NUMLINES +1] = MIDPG; 
  
      P<DESTBUFFWA> = DB$LNK(P<DESTBUFFWA>,OVRBUFSIZ+DFOVRFLHDRLG); 
      P<DESTBUFFER> = LOC(PAGEBUFPOS[0]);  # SET POSITION OF DEST BUFF #
      FOR I = 0 STEP 1
        UNTIL NUMLINES + 1
      DO
        BEGIN 
        DESTLINE[I] =  " ";  # BLANK OUT DESTINATION BUFFER            #
  
#       COPY IN THE X,Y COORDINATES                                    #
  
        C<0,DB$DMCP>DESTLINE[I] = C<0,DB$DMCP>DYNAMICLINE[I+NUMHDRLNS]; 
        END 
      PLUSPGC = PLUSPGC +1;  # INCREMENT PAGE OFFSET COUNT             #
      NXTLNPTR = 0;          # RESET NEXT LINE POINTER                 #
      C<DB$DMCP,64>DESTLINE[NUMLINES+1] = LASTPG;  # LAST PAGE MESSAGE #
      RETURN; 
  
      END  # DB$DAPB #
  
  
  
  
#     E M B E D D E D   P R O C E D U R E   -   D B $ D B H L .        #
  
  
  
      PROC DB$DBHL;                    # BEGIN HEADER LINES            #
  
      BEGIN 
 #
* *   DB$DMGR                                    PAGE  1
* *   DB$DBHL - BEGIN HEADER LINES
* *   J G SERPA                                  DATE  11/24/78 
* 
* DC  PURPOSE 
* 
*     TO FLAG THE START OF ENTERING NEW HEADER LINES AND MAYBE LIST 
*      LINES INTO THE DYNAMIC AREA OF THE DISPLAY BUFFER. 
* 
* DC  ENTRY CONDITIONS
* 
*     FIRSTPAGE POINTS TO THE FIRST OVERFLOW PAGE BUFFER. 
* 
* DC  EXIT CONDITIONS 
* 
*     ALL OVERFLOW PAGES (IF ANY EXISTED) HAVE BEEN RELEASED AND THE
*     THE DYNAMIC AREA OF THE DISPLAY BUFFER HAS BEEN BLANKED OUT.
* 
* DC  CALLING ROUTINES
* 
*     DB$DSL1 
*     DB$DLS2 
      DB$DS27 
* 
* DC  CALLED ROUTINES 
* 
# 
      XREF PROC  DB$LNKD;    # DELETE A LINKED BLOCK                   #
# 
* 
* DC  DESCRIPTION 
* 
*     THIS ROUTINE FLAGS THE START OF ENTERING NEW HEADER LINES AND 
*     LIST LINES INTO THE DYNAMIC AREA OF THE DISPLAY BUFFER. IT
*     INITIALIZES THE POSITION OF THE NEXT AVAILABLE LINE IN THE
*     DYNAMIC AREA. THEN RELEASES ANY EXISTING OVERFLOW PAGE BUFFER 
*     AND FINALLY, THE DYNAMIC AREA IS BLANKED OUT. 
* 
 #
  
  
#     E X E C U T A B L E   C O D E   F O R   D B $ D B H L            #
  
  
      NUMHDRLNS = 0;                   # RESET NUMBER OF HEADER LINES  #
                                       # ALSO RESET IN DGOC            #
  
      FOR I = I 
        WHILE FIRSTPAGE NQ 0
      DO
        BEGIN 
        P<OVRFLWFW> = FIRSTPAGE;
        DB$LNKD(P<OVRFLWFW>);          # RELEASE ALL OVERFLOW PAGES    #
        END 
      P<OVRFLWFW> = LOC(FIRSTPAGE);    # SET CURRENT BUFFER POINTER    #
      FOR I = 0 STEP 1
        UNTIL DISPSIZ 
      DO
        BEGIN 
        C<DB$DMCP,64>DYNAMICLINE[I] = " ";  # CLEAR DYNAMIC AREA       #
        END 
      RETURN; 
  
      END  # DB$DBHL #
  
  
  
  
#     E M B E D D E D   P R O C E D U R E   -   D B $ D B K U .        #
  
  
  
      PROC DB$DBKU;                    # BACK UP A PAGE                #
  
      BEGIN 
 #
* *   DB$DMGR                                    PAGE  1
* *   DB$DBKU - BACK UP A PAGE
* *   J G SERPA                                  DATE  11/26/78 
* 
* DC  PURPOSE 
* 
*     TO  DISPLAY THE PRIOR PAGE BUFFER IN THE STRING OF SAVED PAGES. 
* 
* DC  ENTRY CONDITIONS
* 
*     PRIORPAGE CONTAINS THE ADDRESS OF THE PRIOR OVERFLOW PAGE BUFFER
* 
* DC  EXIT CONDITIONS 
* 
*     PAGE HAS BEEN DISPLAYED, AND NEW PAGE POSITION SAVED. 
* 
* DC  CALLING ROUTINES
* 
*     DB$DS02 
* 
* DC  CALLED ROUTINES 
* 
*     NONE
* 
* DC DESCRIPTION
* 
*     THIS ROUTINE INSTRUCTS THE DISPLAY MANAGER TO BACK UP TO THE
*     PREVIOUS PAGE BUFFER IN ITS STRING OF SAVED PAGES. IF NO
*     PREVIOUS PAGE BUFFER OR NO BUFFERS AT ALL EXIST, THIS CALL
*     TURNS INTO A NO-OP. IF THERE IS A PREVIOUS PAGE BUFFER, ITS 
*     CONTENTS ARE MOVED INTO THE DISPLAY BUFFER AND THE NEW PAGE 
*     POSITION IS SAVED.
* 
 #
  
  
#     E X E C U T A B L E   C O D E   F O R   D B $ D B K U            #
  
  
      IF PRIORPAGE[0] NQ 0                      # IF PRIOR PAGE EXISTS #
         AND PRIORPAGE[0] NQ LOC(FIRSTPAGE)     # AND NOT 1ST LINK WRD #
      THEN
        BEGIN 
        P<OVRFLWFW> = PRIORPAGE[0];    # BACK UP PAGE POSITION         #
        P<OVRFLPAGE> = LOC(PAGEPOS[0]); 
        FOR I = 0 STEP 1
          UNTIL DISPSIZ - NUMHDRLNS 
        DO
          BEGIN              # TRANSFER LINES                          #
          DYNAMICLINE[NUMHDRLNS+I] = OVRFLLINE[I];
          END 
        END 
      RETURN; 
  
      END  # DB$DBKU #
  
  
  
  
#     E M B E D D E D   P R O C E D U R E   -   D B $ D B L L .        #
  
  
  
      PROC DB$DBLL;                    # BEGIN LIST LINES              #
  
      BEGIN 
  
 #
* *   DB$DMGR                                    PAGE  1
* *   DB$DBLL- BEGIN LIST LINES 
* *   J G SERPA                                  11/18/78 
* *   BOB MCALLESTER - 721 CONSOLE SUPPORT       DATE  01/17/84 
* 
* DC  PURPOSE 
* 
*     TO FLAG THE START OF ENTERING NEW LIST LINES INTO THE DYNAMIC 
*      AREA OF THE DISPLAY. 
* 
* DC  ENTRY CONDITIONS
* 
*     NUMHDRLNS CONTAINS THE NUMBER OF HEADER LINES IN THE DISPLAY
* 
* DC  EXIT CONDITIONS 
* 
*     THE DYNAMIC AREA OF THE DISPLAY BUFFER RESERVED FOR LIST LINES
*     (I.E. AREA NOT USED BY HEADER LINES) HAS BEEN BLANKED OUT.
* 
* DC  CALLING ROUTINES
* 
*     DB$DSL1 
*     DB$DSL2 
*     DB$DS27 
* 
* DC  CALLED ROUTINES 
* 
*     NONE
* 
* DC  DESCRIPTION 
* 
*     THIS PROCEDURE MUST BE CALLED AFTER ALL OF THE HEADER LINES HAVE
*     BEEN ENTERED, BUT BEFORE ENTERING ANY OF THE LIST LINES.
*     IT INITIALIZES THE BUFFERS AND VARIABLES USED BY DB$DELL. 
* 
 #
  
  
#     E X E C U T A B L E   C O D E   F O R   D B $ D B L L            #
  
  
      NXTLNPTR = 0;                    # NEXT DYNAMIC LINE POINTER     #
  
      FOR I = NUMHDRLNS STEP 1
        UNTIL DISPSIZ 
      DO
        BEGIN 
        C<DB$DMCP,64>DYNAMICLINE[I] = " ";  # CLEAR DYNAMIC AREA       #
        END 
      FIRSTBUF = TRUE;             # FIRST OVERFLOW IS TO FIRST BUFFER #
      NUMHDRLNS = NUMHDRLNS + 1;   # NUMBER OF HEADER LINES            #
      P<DESTBUFFWA> = LOC(FIRSTPAGE);           # POSITION             #
      P<DESTBUFFER> = LOC(DB$DMDL[NUMHDRLNS]);  # DESTINATION LINES    #
      P<PLUSBUF1> = LOC(DESTBUFFER) -1;      # BUFFER FOR PLUS PROCESS #
      P<PLUSBUF2> = LOC(PLUSBUF1);
      P<OVRFLWFW> = LOC(FIRSTPAGE);          # POSITION OVERFLOW BUFFER#
      NUMLINES = (DISPSIZ - NUMHDRLNS) - 1;  # NUMBER OF USABLE LINES  #
      PLUSPGC = 0;                           # *PLUS* PAGE COUNT       #
      PLUSX   = 0;                           # *PLUS* LINE INDEX       #
      OVRBUFSIZ = (NUMLINES + 2) * 7 + 1;    # SIZE OF OVERFLOW BUFFERS#
      C<DB$DMCP,64>DESTLINE[NUMLINES +1] = ONLYPG;  # SINGLE PAGE MSG  #
      RETURN; 
  
      END  # DB$DBLL #
  
  
  
  
#     E M B E D D E D   P R O C E D U R E   -   D B $ D C C W .        #
  
  
  
      PROC DB$DCCW;          # CHECK FOR CONSOLE WATCHER               #
  
      BEGIN 
 #
* *   DB$DMGR                                    PAGE  1
* *   DB$DCCW - CHECK FOR CONSOLE WATCHER 
* *   J G SERPA                                  DATE  11/10/78 
* 
* DC  PURPOSE 
* 
*     CHECK THAT A CONSOLE WATCHER EXISTS (I.E. *L* DISPLAY IS ASSIGNED 
*     TO THE CONTROL POINT).
* 
* DC  ENTRY CONDITIONS
* 
*     NONE
* 
* DC  EXIT CONDITIONS 
* 
*     DB$DCWE - TRUE IF A WATCHER EXISTS, 
*               FALSE OTHERWISE.
*     DB$DWSC = TRUE IF WATCHER STATUS CHANGED SINCE LAST CALL TO DCCW, 
*               FALSE OTHERWISE.
* 
* DC  CALLING ROUTINES
* 
*     DB$DGOC 
* 
* DC  CALLED ROUTINES 
* 
*     NONE
* 
* DC  DESCRIPTION 
* 
*     THIS ROUTINE IS CALLED AT THE BEGINNING OF MTR OPERATIONS THAT
*     HANDLE THE DISPLAY INTERFACE. IT UPDATES TWO FLAGS (DCWE AND
*     DWSC) BASED ON ITS INTERROGATION OF THE DISPLAY BUFFER. DWSC IS 
*     MERELY THE LOGICAL EXCLUSIVE OR OF DWCE AND THE PRIOR VALUE OF
*     DWCE.  DWCE IS TRUE IF A CONSOLE WATCHER EXISTS, ELSE IT IS 
*     FALSE. DETECTION OF A WATCHER INVOLVES CHECKING A CLEARED FIELD 
*     FOR A VALUE STORED BY DSD (PPU CONSOLE DRIVER). DUE TO THE
*     RELATIVE SPEED OF THE CPU, THIS ROUTINE MUST DELAY ITS RETURN 
*     OF A FALSE VALUE FOR DCWE UNTIL IT FINDS NO WATCHER FOR THE 
*     FIRST *DFDELAY* CALLS SINCE A WATCHER WAS LAST DETECTED. THUS 
*     IT TAKES ONE CALL FOR A WATCHER TO APPEAR, AND *DFDELAY* CALLS
*     FOR IT TO DISAPPEAR.
* 
*     THIS ROUTINE PICKS UP THE STATUS FROM THE CURRENT DISPLAY BUFFER. 
*     IT IS COMPLETELY UNAWARE OF THE EXISTENCE OF TWO DISPLAY BUFFERS
*     (MINI AND MAIN DISPLAYS). 
* 
 #
  
      ITEM DELAYCOUNT I;     # DELAY BEFORE A NO CONSOLE WATCHER STATUS#
                             # IS RETURNED                             #
  
#     E X E C U T A B L E   C O D E   F O R   D B $ D C C W            #
  
  
  
      DB$DWSC = FALSE;          # ASSUME NO CHANGE OF STATUS           #
      IF CONSOLEWATCH[0] NQ 0   # CONSOLE WATCHER EXISTS               #
      THEN
        BEGIN 
        CONSOLEWATCH[0] = 0;    # RESET TO CATCH WATCHER DISAPPEARANCE #
        DB$DWSC = NOT DB$DCWE;  # DWSC = OLD-DCWE XOR NEW-DCWE(TRUE)   #
        DB$DCWE = TRUE;         # CONSOLE WATCHER EXISTS               #
        DELAYCOUNT = 0;         # RESET DELAY COUNT                    #
        END 
      ELSE
        BEGIN 
        IF DELAYCOUNT LQ DFDELAY       # IF WATCHER EXISTED RECENTLY   #
        THEN
          DELAYCOUNT = DELAYCOUNT + 1;  # WAIT TO SEE IF WATCHER       #
                                        # STAYS GONE.                  #
        ELSE
          BEGIN 
          DELAYCOUNT = 0;       # RESET DELAY COUNT                    #
          DB$DWSC = DB$DCWE;    # DWSC = OLD-DCWE XOR NEW-DCWE(FALSE)  #
          DB$DCWE = FALSE;
          END 
        END 
      RETURN; 
  
      END  # DB$DCCW #
  
  
  
  
#     E M B E D D E D   P R O C E D U R E   -   D B $ D C D L .        #
  
  
  
      PROC DB$DCDL;                    # CLEAR DIAGNOSTIC LINE         #
  
      BEGIN 
  
 #
* *   DB$DMGR                                    PAGE  1
* *   DB$DCDL - CLEAR DIAGNOSTIC LINE 
* *   J G SERPA                                  DATE  11/09/78 
* 
* DC  PURPOSE 
* 
*     CLEAR THE RESERVED DIAGNOSTIC LINE ON THE SCREEN. 
* 
* DC  ENTRY CONDITIONS
* 
*     NONE
* 
* DC  EXIT CONDITIONS 
* 
*     THE RESERVED DIAGNOSTIC LINE ON THE SCREEN HAS BEEN CLEARED.
* 
* DC  CALLING ROUTINES
* 
*     DB$DS09 
* 
* 
*     NONE
* 
* DC DESCRIPTION
* 
*     THE DIAGNOSTIC LINE *DB$DMDG* IS BLANKED OUT. 
* 
 #
  
  
#     E X E C U T A B L E   C O D E   F O R   D B $ D C D L            #
  
  
      C<16+DB$DMCP,48>DB$DMDG = "  ";  # CLEAR DIAGNOSTIC LINE         #
      RETURN; 
  
      END  # DB$DCDL #
  
  
  
  
#     E M B E D D E D   P R O C E D U R E   -   D B $ D C R L .        #
  
  
  
      PROC DB$DCRL;          # CLEAR RESPONSE LINES                    #
  
      BEGIN 
 #
* *   DB$DMGR                                    PAGE  1
* *   DB$DCRL - CLEAR RESPONSE LINE 
* *   J G SERPA                                  DATE  11/17/78 
* 
* DC  PURPOSE 
* 
*     CLEAR THE RESERVED REPONSE LINE ON THE SCREEN 
* 
* DC  ENTRY CONDITIONS
* 
*     NONE
* 
* DC  EXIT CONDITIONS 
* 
*     THE RESERVED RESPONSE LINES ON THE SCREEN HAVE BEEN CLEARED 
* 
* DC  CALLING ROUTINES
* 
*     DB$DS06 
*     DB$DS07 
*     DB$DS09 
*     DB$DS20 
* 
* DC  CALLED ROUTINES 
* 
*     NONE
* 
* DC  DESCRIPTION 
* 
*     THIS ROUTINE BLANKS OUT THE THREE CDCS RESPONSE LINES RESERVED
*     ON THE DISPLAY AND RESETS THE POINTER TO THE NEXT RESPONSE
*     LINE TO POINT TO THE FIRST LINE.
* 
 #
  
  
#     E X E C U T A B L E   C O D E   F O R   D B $ D C R L            #
  
  
      FOR I = 0 STEP 1
        UNTIL DFRSPLNS
      DO
        BEGIN 
        C<DB$DMCP,64>RESPLINE[I] = "  ";
        END 
      NXTRLPTR = 0;          # RESET NEXT RESPONSE LINE POINTER        #
      RETURN; 
  
      END  # DB$DCRL #
  
  
  
  
#     E M B E D D E D   P R O C E D U R E   -   D B $ D D I L .        #
  
  
  
      PROC DB$DDIL; 
  
      BEGIN 
 #
* *   DB$DMGR                                    PAGE  1
* *   DB$DDIL - LOCK IN OVCAP CD2DDIF 
* *   R L MCALLESTER                             DATE  05/25/89 
* 
* DC  PURPOSE 
* 
*     TO PROVIDE AN ENTRY POINT OUTSIDE THE OVCAP TO CALL DB$DDIF.
* 
* 
* DC  CALLING ROUTINES
* 
*     DB$DSCS 
*     DB$DSMC 
* 
* DC  CALLED ROUTINES 
# 
      XREF PROC DB$DDIF;     # DUMMY ENTRY POINT TO OVCAP CD2DDIF      #
# 
* DC  DESCRIPTION 
* 
*     DB$DDIF IS A DO-NOTHING PROCEDURE.
*     THE IMPORTANT POINT IS THAT IT IS REGISTERED AS AN INTERRUPTIBLE
*     PROCEDURE.
*     CALLING IT, SETS A USAGE COUNT THAT LOCKS THE OVCAP IN. 
* 
 #
  
  
#     E X E C U T A B L E   C O D E   F O R   D B $ D D I L            #
  
  
      DB$DDIF;
      RETURN; 
  
      END  # DB$DDIL #
  
  
  
  
#     E M B E D D E D   P R O C E D U R E   -   D B $ D E C E .        #
  
  
  
      PROC DB$DECE(STRING,LENGTH);   # ENTER COMMAND ECHO              #
  
      BEGIN 
 #
* *   DB$DMGR                                    PAGE  1
* *   DB$DECE - ENTER COMMAND ECHO
* *   J G SERPA                                  DATE  11/14/78 
* 
* DC  PURPOSE 
* 
*     TO DISPLAY A STRING IN THE LINE RESERVED FOR LAST CDCS COMMAND
* 
* DC  ENTRY CONDITIONS
# 
      ITEM STRING C(48);     # CONTAINS STRING TO BE ECHOED            #
      ITEM LENGTH I;         # LENGTH OF STRING TO BE DISPLAYED        #
# 
* DC  EXIT CONDITIONS 
* 
*     *STRING* HAS BEEN DISPLAYED ON THE LINE RESERVED FOR CDCS 
*     LAST COMMAND. 
* 
* DC  CALLING ROUTINES
* 
*     DB$DS09 
* 
* DC  CALLED ROUTINES 
* 
*     NONE
* 
* DC  DESCRIPTION 
* 
*     THIS ROUTINES ACCEPTS A STRING AND A LENGTH AND DISPLAYS THAT 
*     STRING  ON THE DISPLAY LINE RESERVED FOR CDCS LAST COMMAND. 
* 
 #
  
  
#     E X E C U T A B L E   C O D E   F O R   D B $ D E C E            #
  
  
      C<16+DB$DMCP,48>DB$DMLC = C<0,LENGTH>STRING;
      RETURN; 
  
      END  # DB$DECE #
  
  
  
  
#     E M B E D D E D   P R O C E D U R E   -   D B $ D E D L .        #
  
  
  
      PROC DB$DEDL(STRING,LENGTH);    # ENTER DIAGNOSTIC LINE          #
  
      BEGIN 
 #
* *   DB$DMGR                                    PAGE  1
* *   DB$DEDL - ENTER DIAGNOSTIC LINE 
* *   J G SERPA                                  DATE  11/08/78 
* 
* DC  PURPOSE 
* 
*     ENTER A STRING IN THE LINE RESERVED FOR CDCS DIAGNOSTICS
* 
* DC  ENTRY CONDITIONS
* 
# 
      ITEM STRING C(48);     # STRING TO BE DISPLAYED AS DIAGNOSTIC    #
  
      ITEM LENGTH I;         # LENGTH OF STRING TO BE DISPLAYED        #
  
# 
* DC  ASSUMPTIONS 
* 
*     DB$DBHL HAS BEEN CALLED TO INITIALIZE THE DISPLAY 
*     NUMDHDRLNS CONTAINS THE NUMBER OF HEADER LINES DISPLAYED SO FAR 
* 
* DC  EXIT CONDITIONS 
* 
*     *STRING* HAS BEEN DISPLAYED ON THE DIAGNOSTIC LINE. 
* 
* DC  CALLING ROUTINES
* 
*     DB$DIAG (IN DB$DDGN)
*     DB$MABT (IN DB$DIFF)
*     DB$DS06 
*     DB$DS07 
*     DB$DS20 
*     DB$DS25 
*     DB$DS27 
*     DB$DS28 
* 
* DC  CALLED ROUTINES 
* 
*     NONE
* 
* DC  DESCRITPION 
* 
*     THIS ROUTINE ACCEPTS A STRING AND A LENGTH AND DISPLAYS THAT
*     STRING ON THE DISPLAY LINE RESERVED FOR CDCS DIAGNOSTICS. 
* 
 #
  
  
#     E X E C U T A B L E   C O D E   F O R   D B $ D E D L            #
  
  
      C<16+DB$DMCP,48>DB$DMDG = C<0,LENGTH>STRING;
      RETURN; 
  
      END  # DB$DEDL #
  
  
  
  
#     E M B E D D E D   P R O C E D U R E   -   D B $ D E H L .        #
  
  
  
      PROC DB$DEHL(STRING,LENGTH);     # ENTER HEADER LINES            #
  
      BEGIN 
 #
* *   DB$DMGR                                    PAGE  1
* *   DB$DEHL - ENTER HEADER LINES
* *   J G SERPA                                  DATE  11/13/78 
* 
* DC  PURPOSE 
* 
*     TO ENTER A STRING IN THE NEXT AVAILABLE LINE IN THE DYNAMIC AREA. 
* 
* DC  ENTRY CONDITONS 
* 
*     PARAMETERS
# 
      ITEM STRING C(64);     # STRING TO BE DISPLAYED AS HEADER        #
  
      ITEM LENGTH I;         # LENGTH OF LINE TO BE DISPLAYED          #
# 
* DC  ASSUMPTIONS 
* 
*     DB$DBHL HAS BEEN CALLED TO CLEAR THE DYNAMIC AREA, RELEASE ALL
*     OVERFLOW PAGE BUFFERS AND RESET NUMHDRLNS.
* 
* DC  EXIT CONDITIONS 
* 
*     *STRING* HAS BEEN DISPLAYED IN THE NEXT AVAILABLE LINE IN THE 
*     DYNAMIC AREA, AND THE NUMBER OF HEADER LINES HAS BEEN UPDATED.
* 
* DC  CALLING ROUTINES
* 
*     DB$DSL1 
*     DB$DSL2 
*     DB$DS27 
* 
* DC  CALLED ROUTINES 
* 
*     NONE
* 
* DC  DESCRIPTION 
* 
*     THIS ROUTINE ACCEPTS A STRING AND A LENGTH, AND ENTERS IT IN THE
*     NEXT AVAILABLE LINE IN THE DYNAMIC AREA. IF MORE HEADER LINES ARE 
*     ATTEMPTED THAN CAN BE ACCOMODATED, EXCESS LINES ARE IGNORED. A
*     POINTER IS UPDATED TO INDICATE THE NEXT AVALILABLE LINE POSITION. 
* 
 #
  
  
#     E X E C U T A B L E   C O D E   F O R   D B $ D E H L            #
  
  
      IF NUMHDRLNS LQ DISPSIZ          # IF SPACE LEFT IN DISPLAY      #
      THEN
        BEGIN 
        C<DB$DMCP,64>DYNAMICLINE[NUMHDRLNS] = C<0,LENGTH>STRING;
        NUMHDRLNS = NUMHDRLNS + 1;     # NEXT AVAILABLE LINE           #
        END 
      RETURN; 
  
      END  # DB$DEHL #
  
  
  
  
#     E M B E D D E D   P R O C E D U R E   -   D B $ D E L L .        #
  
  
  
      PROC DB$DELL(STRING,LENGTH);    # ENTER LIST LINES               #
  
      BEGIN 
  
 #
* *   DB$DMGR                                    PAGE  1
* *   DB$DELL - ENTER LIST LINES
* *   J G SERPA                                  DATE  12/06/78 
* *   BOB MCALLESTER  - 721 CONSOLE SUPPORT      DATE  01/17/84 
* 
* DC  PURPOSE 
* 
*     TO ENTER A STRING INTO THE NEXT AVAILABLE LINE IN THE DESTINATION 
*     BUFFER. 
* 
* DC  ENTRY CONDITIONS
* 
# 
      ITEM STRING C(64);     # STRING TO BE DISPLAYED AS LIST LINE     #
      ITEM LENGTH I;         # LENGTH OF LINE TO BE DISPLAYED          #
# 
* DC  ASSUMPTIONS 
* 
*     DESTBUFFER IS POSITIONED TO THE APPROPRIATE DESTINATION, WHETHER
*     THE DISPLAY BUFFER ITSELF OR AN OVERFLOW PAGE BUFFER. 
*     DB$DBLL HAS BEEN CALLED TO PRESET ALL VARIABLES NEEDED BY DB$DELL.
*     NUMLINES CONTAINS THE NUMBER OF LINES AVAILABLE IN THE DISPLAY
*     PLUS ONE FOR PAGING MESSAGES. 
* 
* DC  EXIT CONDITIONS 
* 
*     *STRING* HAS BEEN ENTERED INTO THE NEXT AVAILABLE LINE OF 
*     DESTBUFFER
* 
* DC  CALLING ROUTINES
* 
*     DB$DSL1 
*     DB$DSL2 
*     DB$DS27 
* 
* DC  CALLED ROUTINES 
# 
      XREF FUNC DB$CDEC C(10);  # CONVERT INTEGER TO DECIMAL           #
#          PROC DB$DAPB           ALLOCATE AND PRESET A PAGE BUFFER 
* 
* DC  DESCRIPTION 
* 
*     THIS ROUTINE ACCEPTS A STRING AND A LENGTH TO BE ENTERED IN THE 
*     NEXT AVAILABLE LINE OF THE DYNAMIC AREA (LIST LINES). 
*     CHECK FOR A > CHARACTER IN THE FIRST POSITION OF THE STRING.
*     IF ONE IS THERE, IT FLAGS THE BEGINNING OF A NEW DISPLAY GROUP. 
*     THE TWO DIGITS FOLLOWING THE > DESIGNATE THE NUMBER OF LINES
*     IN THE GROUP. 
*     CHECK TO SEE IF THE GROUP WILL FIT ON THE CURRENT PAGE. 
*     IF IT WONT FIT, ALLOCATE A NEW PAGE BUFFER. 
* 
*     THE FIRST TIME THE PAGE OVERFLOW OCCURS, SOME SPECIAL PROCESSING
*     IS REQUIRED.  THIS IS BECAUSE THE FIRST PAGE IS BUILT DIRECTLY
*     IN THE DYNAMIC AREA DEFINED IN DB$DMGI. 
*     WHEN THAT PAGE OVERFLOWS IT BECOMES APPARENT THAT THERE IS GOING
*     TO BE MORE THAN ONE PAGE. 
*     EACH PAGE NEEDS ITS OWN BUFFER AND THE DB$DMGI BUFFER WILL BE 
*     USED JUST FOR DISPLAYING THE CURRENT PAGE.
*     ONE BUFFER IS ALLOCATED FOR THE FIRST PAGE AND THE CONTENTS OF
*     THE DB$DMGI DYNAMIC AREA IS COPIED INTO THAT PAGE.
*     A SECOND BUFFER IS THEN ALLOCATED AND CLEARED IN PREPARATION FOR
*     BUILDING THE SECOND PAGE. 
*     THIS LEAVES A COPY OF THE FIRST PAGE IN THE DB$DMGI BUFFER READY
*     FOR DISPLAY.
* 
*     A BLANK LINE THAT IS PASSED AS THE GROUP SEPARATOR, >NN, WILL 
*     NOT BE INCLUDED IN THE DISPLAY IF IT CAUSES AN OVERFLOW.
* 
*     WHEN A GROUP SEPARATOR HAS BEEN PROCESSED, THERE IS A SCAN OF THE 
*     PRECEEDING LINES TO FIND THE NEXT OCCURRENCE OF THE CHARACTER 
*     STRING "+00" IN THE FIRST THREE CHARACTERS OF THE LINE. 
*     THIS INDICATES AN OFFSET INDEX. 
*     THE OFFSET INDEX IS THEN MODIFIED TO A "+XX" WHERE XX IS THE
*     PAGE OFFSET FROM THE OFFSET INDEX TO THE PAGE CONTAINING THE
*     CORRESPONDING GROUP.
*     THE SCAN FOR THE OFFSET INDEX USES TWO BASED ARRAYS BECAUSE 
*     IF THE OFFSET INDEX IS IN THE FIRST PAGE, IT IS USUALLY 
*     NECESSARY TO MODIFY THE TWO COPIES OF THE FIRST PAGE. 
*     BEFORE THE FIRST PAGE OVERFLOW OCCURS, BOTH POINTERS POINT
*     TO THE DB$DMGI BUFFER.
*     AFTER THE SCAN PROGRESSES TO OR BEYOND THE SECOND PAGE, BOTH
*     POINTERS POINT TO THE CURRENT PAGE BUFFER.
* 
 #
  
  
#     E X E C U T A B L E   C O D E   F O R   D B $ D E L L            #
  
  
      GRLENGTH = 0;          # THE DEFAULT GROUP LENGTH                #
  
      IF C<0,1>STRING EQ ">"
      THEN                   # IT IS A GROUP SEPARATOR,                #
                             # COMPUTE THE GROUP LENGTH                #
        BEGIN 
        GRLENGTH = ( B<06,6>STRING -O"33" ) *10   # CONVERT TO BINARY  #
                   + B<12,6>STRING -O"33";
        END 
  
      IF NXTLNPTR NQ 0
                             # IF NOT ENOUGH SPACE IN DESTBUFFER       #
        AND NXTLNPTR + GRLENGTH GR NUMLINES 
      THEN
        BEGIN 
        DB$DAPB;              # ALLOCATE AND PRESET NEW BUFFER         #
  
        IF FIRSTBUF           # IF FIRST OVERFLOW BUFFER               #
        THEN
          BEGIN               # IT IS A SPECIAL CASE                   #
          P<PLUSBUF2> = LOC(DESTBUFFWA);  # SAVE LOC OF 1ST PAGE BUFFER#
          C<DB$DMCP,64>DYNAMICLINE[NUMLINES + NUMHDRLNS +1] = FIRSTPG;
          FOR I = 0 STEP 1
            UNTIL NUMLINES + 1
          DO
            BEGIN 
            DESTLINE[I] = DYNAMICLINE[NUMHDRLNS+I];  # TRANSFER LINES  #
            END 
          FIRSTBUF = FALSE;   # CLEAR FIRSTBUF FLAG                    #
          P<OVRFLWFW> = NEXTPAGE[0];   # POSITION CURRENT BUFFER       #
          P<OVRFLPAGE> = LOC(PAGEPOS[0]);  # TO FIRST BUFFER           #
          DB$DAPB;            # ALLOCATE AND PRESET NEW PAGE           #
          PLUSPGC = 1;
  
          END 
        END 
# 
*     IF IT IS NOT A GROUP SEPARATOR FOR THE FIRST LINE OF THE PAGE,
*         ENTER A LINE INTO THE PAGE BUFFER.
# 
      IF NXTLNPTR NQ 0
        OR GRLENGTH EQ 0
      THEN
        BEGIN 
        C<DB$DMCP,64>DESTLINE[NXTLNPTR] = C<0,LENGTH>STRING;
        IF GRLENGTH NQ 0
        THEN                       # BLANK OUT THE GROUP SEPARATOR     #
          BEGIN 
          C<DB$DMCP,3>DESTLINE[NXTLNPTR] = "   "; 
          END 
  
        NXTLNPTR = NXTLNPTR + 1;    # INCREMENT NEXT LINE POINTER      #
        END 
# 
*     IF IT IS A GROUP SEPARATOR, SCAN FOR THE CORRESPONDING OFFSET 
*     INDEX.
# 
      IF GRLENGTH NQ 0
      THEN
        BEGIN 
        DONE = FALSE; 
        FOR I=I WHILE NOT DONE
        DO
          BEGIN 
# 
*         THE SCAN RESUMES IN THE PAGE BUFFER POINTED TO BY P<PLUSBUF1> 
*         USING THE CURRENT VALUE OF THE INDEX "PLUSX". 
# 
          IF C<DB$DMCP,3>PLUSNUM1[PLUSX] EQ "+00" 
          THEN
            BEGIN 
            IF PLUSPGC EQ 0 
            THEN             # THE OFFSET IS ZERO, CLEAR OFFSET INDEX  #
              BEGIN 
              C<DB$DMCP,3>PLUSNUM1[PLUSX] = "   ";
              END 
            ELSE
              BEGIN 
              C<0,2>CHAR10 = DB$CDEC(PLUSPGC,2);
              IF C<0,1>CHAR10 EQ "0"
              THEN           # THE OFFSET IS A SINGLE DIGIT            #
                BEGIN 
                C<0,2>CHAR10 = C<1,1>CHAR10;
                END 
              C<DB$DMCP+1,2>PLUSNUM1[PLUSX] = C<0,2>CHAR10; 
              END 
# 
*           COPY THE OFFSET INDEX TO THE SECONDARY BUFFER.
*           THIS MAY COPY IT TO ITSELF WHEN BOTH BUFFERS ARE THE SAME.
# 
            C<DB$DMCP,3>PLUSNUM2[PLUSX] = C<DB$DMCP,3>PLUSNUM1[PLUSX];
            DONE = TRUE;
            TEST I; 
  
            END 
# 
*         IF THE SCAN REACHES THE LINE OF CURRENT INSERTION, THEN 
*         THERE IS NO OFFSET INDEX.  EXIT FROM THE LOOP.
# 
          IF LOC(PLUSNUM1[PLUSX]) EQ LOC(DESTLINE[NXTLNPTR])
          THEN
            BEGIN 
            DONE = TRUE;
            TEST I; 
  
            END 
  
          PLUSX = PLUSX +1;  # INCREMENT THE OFFSET INDEX              #
# 
*         IF THE SCAN REACHES THE END OF A BUFFER, ADVANCE TO THE NEXT
*         PAGE BUFFER.
# 
          IF PLUSX GR NUMLINES
          THEN
            BEGIN 
            P<PLUSBUF2> = PLUSNEXT[0];
            P<PLUSBUF1> = LOC(PLUSBUF2);
            PLUSX = 0;
            PLUSPGC = PLUSPGC -1;   # REDUCE THE OFFSET BY ONE         #
            END 
          END 
        END 
  
  
  
      RETURN; 
  
      END  # DB$DELL #
  
  
  
  
#     E M B E D D E D   P R O C E D U R E   -   D B $ D E R L .        #
  
  
  
      PROC DB$DERL(STRING,LENGTH);     # ENTER RESPONSE LINES          #
  
      BEGIN 
 #
* *   DB$DMGR                                    PAGE  1
* *   DB$DERL - ENTER RESPONSE LINES
* *   J G SERPA                                  DATE  11/16/78 
* 
* DC  PURPOSE 
* 
*     TO ENTER A STRING IN THE NEXT AVAILABLE RESPONSE LINE 
* 
* DC  ENTRY CONDITIONS
* 
# 
      ITEM STRING C(64);     # STRING TO BE DISPLAYED AS REPONSE       #
  
      ITEM LENGTH I;         # LENGTH OF LINE TO BE DISPLAYED          #
# 
* DC  EXIT CONDITIONS 
* 
*     *STRING* HAS BEEN ENTERED IN THE NEXT AVAILABLE RESPONSE LINE 
*     AND A POINTER HAS BEEN UPDATED TO REFLECT THE NEXT POSITION.
* 
* DC  CALLING ROUTINES
* 
*     DB$DSCF 
*     DB$DB06 
*     DB$DB07 
*     DB$DB20 
* 
* DC  CALLED ROUTINES 
* 
*     NONE
* 
* DC  DESCRIPTION 
* 
*     THIS ROUTINE ACCEPTS A STRING AND A LENGTH AND ENTERS IT IN THE 
*     NEXT AVAILABLE RESPONSE LINE. A POINTER IS UPDATED TO INDICATE
*     THE NEXT AVAILABLE RESPONSE LINE POSITON. IF MORE THAN 3 (THREE)
*     RESPONSE LINES ARE ATTEMPTED, ONLY THE FIRST THREE ARE DISPLAYED
*     WITH THE REMAINING LINES BEING IGNORED. 
* 
 #
  
  
#     E X E C U T A B L E   C O D E   F O R   D B $ D E R L            #
  
  
      IF NXTRLPTR LQ DFRSPLNS       # IF SPACE LEFT IN RESPONSE BUFFER #
      THEN
        BEGIN 
        C<DB$DMCP,64>RESPLINE[NXTRLPTR] = C<0,LENGTH>STRING;
        NXTRLPTR = NXTRLPTR + 1;
        END 
      RETURN; 
  
      END  # DB$DERL #
  
  
  
  
#     E M B E D D E D   P R O C E D U R E   -   D B $ D G O C .        #
  
  
  
      PROC DB$DGOC(STRING,LENGTH);     # GET OPERATOR COMMAND          #
  
      BEGIN 
 #
* *   DB$DMGR                                    PAGE  1
* *   DB$DGOC - GET OPERATOR COMMAND
* *   J G SERPA                                  DATE  11/28/78 
* 
* DC  PURPOSE 
* 
*     TO GET THE COMMAND TYPED IN BY THE CONSOLE OPERATOR 
* 
* DC  ENTRY CONDITIONS
* 
# 
      ITEM STRING C(48);               # COMMAND TYPED IN BY OPERATOR  #
  
      ITEM LENGTH I;                   # LENGTH OF COMMAND             #
                                       # ZERO IF NO COMMAND            #
# 
* DC  EXIT CONDITIONS 
* 
*     DB$DMCL    0 IF NO COMMAND LIST GIVEN YET 
*     DB$DMFF    TRUE IF FLASHING MESSAGE ISSUED, ELSE UNCHANGED
* 
* DC  CALLING ROUTINES
* 
*     DB$DDVR 
* 
* DC  CALLED ROUTINES 
* 
# 
      XREF PROC DB$MSGB;     # ISSUE *B* DISPLAY MESSAGE               #
      XREF PROC DB$LNKD;     # DELETE A LINKED BLOCK                   #
# 
*     PROC DB$DCCW              CHECK FOR CONSOLE WATCHER 
* 
* DC  DESCRIPTION 
* 
*     THIS IS THE KEY ROUTINE OF THE DISPLAY MANAGER. 
*     ITS PURPOSE IS TO RETURN A STRING AND A LENGTH WHICH DESCRIBE 
*     A COMMAND ENTERED BY THE CONSOLE OPERATOR.
* 
*     IF A CONSOLE WATCHER HAS APPEARED, THE CONSOLE DISPLAY IS 
*     ACTIVATED. IF NOT IN SUSPEND MODE AND NO COMMAND HAS BEEN TYPED 
*     IN BY THE OPERATOR YET, A PERIOD (.) IS SENT BACK AS THE COMMAND. 
*     WHICH WILL CAUSE CDCS TO INITIALIZE THE OPTION LIST.
*     IF THE WATCHER HAS JUST DISAPPEARED, THEN IF IN SUSPEND MODE
*     AND NO COMMAND TYPED IN YET, THE MESSAGE *OPERATOR REPLY NEEDED.
*     SEE -L- DISPLAY* IS FLASHED ON THE *B* DISPLAY. IF NOT IN 
*     SUSPEND MODE, THEN ALL OVERFLOW PAGE BUFFERS ARE RELEASED.
*     IF THERE IS A COMMAND, IT IS RETURNED WITH ITS LENGTH,OTHERWISE 
*     A LENGTH OF ZERO IS RETURNED TO INDICATE THAT THERE IS NO COMMAND 
* 
 #
  
  
      ITEM CH     I;                   # TEMPORARY CHARACTER VARIABLE  #
  
  
  
  
#     E X E C U T A B L E   C O D E   F O R   D B $ D G O C            #
  
  
      DB$DCCW;                         # CHECK FOR CONSOLE WATCHER     #
  
      LENGTH = 0; 
      IF DB$DWSC                       # IF STATUS CHANGED             #
      THEN
        BEGIN 
        IF DB$DCWE                     # IF WATCHER JUST APPEARED      #
        THEN
          BEGIN 
          DB$DACD;                     # ACTIVATE CONSOLE DISPLAY      #
  
          IF NOT DB$DMSF               # IF NOT IS SUSPEND MODE        #
             AND CONSOLEWORD[0] EQ 0   # AND NO COMMAND                #
          THEN
            BEGIN 
            DB$DMCL = 0;               # NO COMMAND LIST YET           #
            C<0,1>STRING = ".";        # SEND A PERIOD BACK            #
            LENGTH = 1; 
            RETURN; 
  
            END 
          END 
        ELSE                           # WATCHER JUST DISAPPEARED      #
          BEGIN 
          IF DB$DMSF                   # IF IN SUSPEND MODE            #
             AND CONSOLEWORD[0] EQ 0   # AND NO COMMAND                #
          THEN
            BEGIN 
            IF DB$NOS 
            THEN
              BEGIN 
              C<29,1>OPRMSG = "K";     # "SEE *K* DISPLAY" FOR NOS     #
              END 
            DB$DMFM = OPRMSG;          # OPERATOR REPLY NEEDED         #
            DB$MSGB(DB$DMFM);          # ISSUE FLASHING MESSAGE        #
  
            DB$DMFF = TRUE;            # SET MESSAGE FLAG              #
            END 
          IF NOT DB$DMSF               # IF NOT IN SUSPEND MODE        #
          THEN
            BEGIN 
  
            FOR I = I 
              WHILE FIRSTPAGE NQ 0
            DO
              BEGIN 
              P<OVRFLWFW> = FIRSTPAGE;
              DB$LNKD(P<OVRFLWFW>);    # RELEASE PAGE BUFFERS          #
  
              END 
            P<OVRFLWFW> = LOC(FIRSTPAGE);  # SET CURRENT BUFFER PTR    #
            END 
          END 
        END 
  
#     MUST COMPUTE THE LENGTH OF THE COMMAND JUST TYPED IN, IF ANY.    #
#     SINCE COLONS (:),DISPLAY CODE 00B CANNOT BE TYPED AT THE         #
#     OPERATOR"S CONSOLE, ANY OCCURRENCE OF A 00B MARKS THE END        #
#     OF THE OPERATOR COMMAND. THEREFORE WE ONLY HAVE TO COUNT UNTIL   #
#     A 00B IS FOUND.                                                  #
  
      IF CONSOLEWORD[0] EQ 0           # IF NO COMMAND                 #
      THEN
        RETURN;                        # NOTHIN TO DO, LENGTH = 0      #
  
      CH = 1; 
      STRING = CONSOLECOMMD[0]; 
      FOR I = 0 STEP 1                 # COMPUTE LENGTH OF STRING      #
        WHILE CH NQ 0 
      DO
        BEGIN 
        CH = C<I,1>STRING;
        LENGTH = I; 
        END 
  
#     NOW THE INPUT BUFFER MUST BE ZEROED OUT, SO THAT WE DONT FIND    #
#     THE SAME COMMAND IF WE ARE CALLED BEFORE ANOTHER COMMAND IS      #
#     ENTERED.                                                         #
  
      FOR I = 0 STEP 1
        UNTIL DFKBUFLEN 
      DO
        BEGIN 
        CONSOLEWORD[I] = 0; 
        END 
      RETURN; 
  
      END  # DB$DGOC #
  
  
  
  
#     E M B E D D E D   P R O C E D U R E   -   D B $ D I D M .        #
  
  
  
      PROC DB$DIDM;                # INITIALIZE DISPLAY MANAGER        #
  
      BEGIN 
  
 #
* *   DB$DMGR                                    PAGE  1
* *   DB$DIDM - INITIALIZE DISPLAY MANAGER
* *   J G SERPA                                  DATE  11/22/78 
* 
* DC  PURPOSE 
* 
*     INITIALIZE DISPLAY MANAGER
* 
* DC  ENTRY CONDITIONS
* 
*     NONE
* 
* DC  EXIT CONDITIONS 
* 
*     *L* DISPLAY BUFFER HAS BEEN SET TO MINI DISPLAY 
* 
* DC  CALLING ROUTINES
* 
*     DB$INT
* 
* DC  CALLED ROUTINES 
# 
      XREF PROC DB$DMDS;     # GET DISPLAY PAGE SIZE                   #
#          PROC DB$DMSD        SWITCH DISPLAYS
* 
* DC  DESCRIPTION 
* 
*     THE CURRENT DISPLAY IS SET TO BE THE MAIN DISPLAY AND THEN IT IS
*     FORCED TO THE MINI DISPLAY BY CALLING DB$DMSD.
* 
 #
  
  
#     E X E C U T A B L E   C O D E   F O R   D B $ D I D M            #
  
  
      DB$DMDS(DISPSIZ);               # GET THE DISPLAY PAGE SIZE      #
      CURRDISP = MAINBUFWORD[0];      # SET CURRENT DISPLAY TO MAIN    #
      P<CONSOLEBUF> = MAINDISPIB[0];  # SET OLD DISPLAY TO MAIN DISPLAY#
      DB$DMSD(DB$DMMB);               # FORCE CURRENT DISPLAY TO MINI  #
  
      RETURN; 
  
      END  # DB$DIDM #
  
  
  
  
#     E M B E D D E D   P R O C E D U R E   -   D B $ D M S D .        #
  
  
  
      PROC DB$DMSD(LDISP);             # SET DISPLAY                   #
  
      BEGIN 
  
 #
* *   DB$DMGR                                    PAGE  1
* *   DB$DMSD - SET DISPLAY 
* *   J G SERPA                                  DATE  11/14/78 
* 
* DC  PURPOSE 
* 
*     TO SET OR SWITCH DISPLAY BUFFERS
* 
* DC  ENTRY CONDITIONS
# 
      ARRAY LDISP [0:0];               # *L* DISPLAY CONTROL WORD      #
        BEGIN 
        ITEM LDISPCW  U(00,00,DFWL);   # COMPLETE WORD                 #
        ITEM LDISPIB  U(00,06,DFAL);   # FWA OF INPUT BUFFER           #
        ITEM LDISPRB  U(00,24,DFAL);   # FWA OF RIGHT DISPLAY BUFFER   #
        ITEM LDISPLB  U(00,42,DFAL);   # FWA OF LEFT DISPLAY BUFFER    #
        END 
# 
* DC  EXIT CONDITIONS 
* 
*     DISPLAY HAS BEEN SET TO THE APPROPRIATE DISPLAY BUFFER, AND IF
*     SWITCHED, ANY INPUT THAT EXISTED IN THE OLD INPUT BUFFER IS 
*     COPIED INTO THE NEW INPUT BUFFER, AND THE OLD ONE IS ZEROED 
*     OUT.
* 
* DC  CALLING ROUTINES
* 
*     DB$DACD    ACTIVATE CONSOLE DISPLAY 
*     DB$DIDM    INITIALIZE DISPLAY MANAGER 
*     DB$DROT    ROLL OUT TASKS 
* 
* 
# 
      XREF PROC DB$DMCN;     # IDENTIFY *L* DISPLAY COMMUNICATION BUFF #
# 
* 
* DC  DESCRIPTION 
* 
*     IF THE INCOMING DISPLAY IS THE SAME AS THE ONE THAT IS ALREADY
*     UP, THIS CALL BECOMES A NO-OP. OTHERWISE THE CURRENT DISPLAY
*     BECOMES THE OLD AND THE INCOMING DISPLAY BECOMES THE CURRENT
*     DISPLAY. THEN DB$DMCN IS CALLED TO IDENTIFY CURRDISP AS THE 
*     CURRENT *L* DISPLAY COMMUNICATION BUFFER. IF THERE EXISTS ANY 
*     INFORMATION ON THE OLD DISPLAY BUFFER, IT IS COPIED INTO THE
*     CURRENT DISPLAY INPUT BUFFER. THE WATCHER WORD IS ALSO COPIED 
*     TO THE CURRENT INPUT BUFFER IF IT WAS NON ZERO IN THE OLD INPUT 
*     BUFFER. 
 #
  
#     THE FOLLOWING ARRAY IS DEFINED AS S(1) SO THAT WE MAY ZERO       #
#     EACH WORD INDIVIDUALLY. HOWEVER, *OLDWATCHER* IS DEFINED AS      #
#     U(07,00,DFWL) BECAUSE WE HAVE TO ACCESS THE WATCHER WORD WHICH   #
#     IS LOCATED AT KEYBOARD INPUT BUFFER + 7.                         #
#     *OLDBUFWORD* IS USED FOR ZEROING THE BUFFER AND ALSO FOR         #
#     DETECTING AN OPERATOR COMMAND (FIRST WORD NON-ZERO).             #
  
  
      BASED ARRAY OLDBUF [0:DFKBUFLEN] S(1);  # KEYBOARD INPUT BUFFER  #
              BEGIN 
              ITEM OLDBUFWORD  U(00,00,DFWL); 
              ITEM OLDWATCHER  U(07,00,DFWL);  # OLD WATCHER WORD      #
              END 
  
  
  
#     E X E C U T A B L E   C O D E   F O R   D B $ D M S D            #
  
  
      IF LDISPCW[0] NQ CURRDISP        # IF NEW DISP NQ CURRENT DISP   #
      THEN
        BEGIN                          # SWITCH TO NEW DISPLAY         #
        P<OLDBUF> = LOC(CONSOLEBUF);   # CURRENT DISPLAY BECOMES OLD   #
        P<CONSOLEBUF> = LDISPIB[0];    # NEW DISPLAY BECOMES CURRENT   #
        CURRDISP = LDISPCW[0];         # UPDATE CURRDISP               #
        DB$DMCN(CURRDISP);             # SET DISPLAY                   #
  
        IF OLDBUFWORD[0] NQ 0          #IF THERE IS A COMMAND IN OLDBUF#
        THEN
          BEGIN 
  
          FOR I = 0 STEP 1
            UNTIL DFKBUFLEN - 1 
          DO
            BEGIN 
            CONSOLEWORD[I] = OLDBUFWORD[I]; # TRANSFER IT TO CONSOLEBUF#
            OLDBUFWORD[I] = 0;              # ZERO OUT OLDBUF          #
            END 
          END 
        IF OLDWATCHER[0] NQ 0          # IF WATCHER EXISTS IN OLDBUF   #
        THEN
          CONSOLEWATCH[0] = OLDWATCHER[0];   #TRANSFER IT TO CONSOLEBUF#
        END 
      RETURN; 
  
      END  # DB$DMSD #
  
  
  
  
#     E M B E D D E D   P R O C E D U R E   -   D B $ D R O T .        #
  
  
  
      PROC DB$DROT;                # ROLL OUT TASKS                    #
  
      BEGIN 
  
 #
* *   DB$DMGR                                    PAGE  1
* *   DB$DROT - ROLL OUT TASK 
* *   J G SERPA                                  DATE  11/22/78 
* 
* DC  PURPOSE 
* 
*     PERFORM SOME DISPLAY MANAGER CLEAN UP BEFORE CDCS ROLLS OUT 
* 
* DC  ENTRY CONDITIONS
* 
*     NONE
* 
* DC  EXIT CONDITIONS 
* 
*     DISPLAY HAS BEEN SWITCHED TO MINI DISPLAY.
*     IF NOT IN SUSPEND MODE, ALL OVERFLOW PAGE BUFFERS HAVE BEEN 
*     RELEASED. IF IN SUSPEND MODE, THE MESSGE *OPERATOR REPLY NEEDED.
*     SEE -L- DISPLAY* IS SENT TO THE B DISPLAY.
* 
* DC  CALLING ROUTINES
* 
*     DB$MTR
* 
* DC  CALLED ROUTINES 
* 
# 
      XREF PROC DB$LNKD;     # DELETE A LINKED BLOCK                   #
      XREF PROC DB$MSGB;     # ISSUE MESSAGES TO *B* DISPLAY           #
# 
*          PROC DB$DMSD         SWITCH DISPLAYS 
* 
* DC  DESCRIPTION 
* 
*     DB$DMSD IS CALLED TO SWITCH FROM THE MAIN TO THE MINI DISPLAY 
*     BUFFER. AFTER SWITCHING, IF NOT IN SUSPEND MODE, ALL OVERFLOW 
*     PAGE BUFFERS ARE RELEASED. IF IN SUSPEND MODE  THE MESSAGE
*     *OPERATOR REPLY NEEDED. SEE -L- DISPLAY* IS FLASHED ON THE *B*
*     DISPLAY, AND DB$DMFF IS SET TO INDICATE THAT A FLASHIN MESSAGE
*     CURRENTLY EXISTS. 
* 
 #
  
  
#     E X E C U T A B L E   C O D E   F O R   D B $ D R O T            #
  
  
      DB$DMSD(DB$DMMB);            # SWITCH TO MINI DISPLAY            #
  
      IF NOT DB$DMSF               # IF NOT IN SUSPEND MODE            #
      THEN
        BEGIN 
  
        FOR I = I 
          WHILE FIRSTPAGE NQ 0     # WHILE MORE PAGE BUFFERS EXIST     #
        DO
          BEGIN 
          P<OVRFLWFW> = FIRSTPAGE;
          DB$LNKD(P<OVRFLWFW>);    # RELEASE PAGE BUFFER               #
          END 
        P<OVRFLWFW> = LOC(FIRSTPAGE);  # SET CURRENT BUFFER POINTER    #
        END 
      ELSE
        BEGIN 
        IF NOT DB$DMFF             # IF FLASHING MESSAGE NOT ISSUED    #
        THEN
          BEGIN 
          IF DB$NOS 
          THEN
            BEGIN 
            C<29,1>OPRMSG = "K";  # "SEE *K* DISPLAY" FOR NOS          #
            END 
          DB$DMFM = OPRMSG;       # OPERATOR REPLY NEEDED              #
          DB$MSGB(DB$DMFM);       # ISSUE FLASHING MESSAGE             #
  
          DB$DMFF = TRUE;         # SET FLASHING MESSAGE FLAG          #
          END 
        END 
      RETURN; 
  
      END  # DB$DROT #
  
  
  
  
#     E M B E D D E D   P R O C E D U R E   -   D B $ D U D F .        #
  
  
  
      PROC DB$DUDF;          # UPDATE DYNAMIC FIELDS                   #
  
      BEGIN 
 #
* *   DB$DMGR                                    PAGE  1
* *   DB$DUDF - UPDATE DYNAMIC FIELDS 
* *   J G SERPA                                  DATE  11/05/78 
* 
* DC  PURPOSE 
* 
*     TO UPDATE SOME DYNAMIC FIELDS IN THE CDCS DISPLAY HEADER
* 
* DC  ENTRY CONDITIONS
* 
*     FOLLOWING GLOBAL VARIABLES MUST HAVE BEEN SET TO THE APPROPRIATE
*     VALUE BY THE CALLING ROUTINE. 
* 
*     DB$DNAA    NUMBER OF ACTIVE AREAS 
*     DB$DNAS    NUMBER OF ACTIVE SCHEMAS 
*     DB$DNAU    NUMBER OF ACTIVE USERS 
*     DB$DNTU    TOTAL NUMBER OF USERS
*     DB$DSST    CDCS STATUS
* 
* DC  EXIT CONDITIONS 
* 
*     FOLLOWING FIELDS HAVE BEEN UPDATED IN THE DISPLAY HEADER
* 
*     DB$DMAA    NUMBER OF ACTIVE AREAS 
*     DB$DMAS    NUMBER OF ACTIVE SCHEMAS 
*     DB$DMAU    NUMBER OF ACTIVE USERS 
*     DB$DMTU    TOTAL NUMBER OF USRS 
*     AND CDCS STATUS 
* 
* DC  CALLING ROUTINES
* 
*     DB$ADAX 
*     DB$INV$ 
*     DB$TQTD 
*     DB$DS06 
*     DB$DS07 
*     DB$DS20 
*     DB$DS28 
* 
* DC  CALLED ROUTINES 
* 
# 
      XREF FUNC DB$CDEB C(10);  # BINARY TO DECIMAL WITH BLANK FILL    #
      XREF PROC DB$MSGB;     # ISSUE B DISPLAY MESSAGE                 #
      XREF PROC DB$MSG2;     # CLEAR LINE 2 OF THE B DISPLAY           #
# 
* 
* DC  DESCRIPTION 
* 
*     IF NO WATCHER EXISTS, THIS CALL BECOMES A NO-OP. OTHERWISE THIS 
*     ROUTINE UPDATES THE DYNAMIC COUNT FIELDS AND CDCS STATUS IN 
*     THE CDCS DISPLAY HEADER TO REFLECT THE CURRENT CONTENTS OF THE
*     BINARY COUNTS. IF THE TERMINATION FLAG IS SET, THE WORD *TERM*
*     IS APPENDED TO THE STATUS.
* 
 #
      ITEM ACTIVEMSG C(26) = "00000 CDCS USER(S) ACTIVE:";
  
  
      C<0,5>ACTIVEMSG = DB$CDEB(DB$DNAU,5);  # ACTIVE USERS            #
      DB$MSG2;               # CLEAR LINE 2 OF THE B DISPLAY           #
      DB$MSGB(ACTIVEMSG);    # CDCS ACTIVE USER COUNT                  #
  
      IF DB$DCWE             # IF CONSOLE WATCHER EXISTS               #
      THEN
        BEGIN                # UPDATE FOLLOWING DYNAMIC FIELDS         #
        C<5,5>DB$DMAU = DB$CDEB(DB$DNAU,5);  # ACTIVE USERS            #
        C<5,5>DB$DMTU = DB$CDEB(DB$DNTU,5);  # TOTAL USERS             #
        C<5,5>DB$DMAS = DB$CDEB(DB$DNAS,5);  # ACTIVE SCHEMAS          #
        C<5,5>DB$DMAA = DB$CDEB(DB$DNAA,5);  # ACTIVE AREAS            #
        C<DB$DMCP,9>DB$DMH2 = CDCS$STATUS[DB$DSST];   # CDCS STATUS    #
        IF DB$TRMF           # IF TERMINATION FLAG IS SET              #
        THEN
          BEGIN 
          C<DB$DMCP+4,5>DB$DMH2 = "/TERM";
          END 
        END 
      RETURN; 
  
      END  # DB$DUDF #
      END 
      TERM
