*DECK VERIFY
USETEXT TAREATB 
USETEXT TCMMDEF 
USETEXT TCONVRT 
USETEXT TDESATT 
USETEXT TENVIRN 
USETEXT TEXPRES 
USETEXT TFIT
USETEXT TIMF
USETEXT TINDTBL 
USETEXT TOPTION 
USETEXT TPSTACK 
USETEXT TSBASIC 
USETEXT TXSTD 
      PROC VERIFY;
  
#----------------------------------------------------------------------#
#                                                                      #
#  THE FOLLOWING PROCS ARE XDEF"D WITHIN THIS DECK:                    #
#                                                                      #
#     VERINIT                      INITIALIZATION FOR *VERIFY*         #
#     VERRLS                       ERROR TERMINATION FOR *VERIFY*      #
#     VERSEM                       PROCESS ANOTHER VERIFY NAME         #
#     VERSEMX                      NORMAL TERMINATION FOR *VERIFY*     #
#                                                                      #
#----------------------------------------------------------------------#
  
      BEGIN 
  
      BASED ARRAY BASTEMP;              #TEMPORARY BASED ARRAY# 
        ITEM BTEMP; 
      ITEM AREAORDINAL I;          # AREA ORDINAL OF DATA ITEM         #
      ITEM FRSTVER      B = TRUE;  # TRUE IF FIRST VERIFY ITEM         #
      ITEM I            I;         # SCRATCH TEMPORARY                 #
      ITEM J            I;         # SCRATCH TEMPORARY                 #
      ITEM PFLOOPCTR    I;
      ITEM VERILOC I;              # ADDRESS OF 1ST BLOCK OF VERIFY TBL#
      ITEM VERLEN I;               # NO OF CHARACTERS IN VERIFY ARRAY  #
      ITEM WORDBASE I;             # LOC(FITKA) OR LOC(FITWSA)         #
*CALL DEFMURL 
      XREF ITEM SM$GROUPID   I;    # GROUP ID FOR CURRENT SYNTAX STUFF #
      BASED ARRAY TOATTRI;     # FOR SAVING ATTRIBUTES USED FOR CONVERT#
              ITEM TMRPT I(0,42,18),
                   TCLASS I(0,12,6),
                   TWPOS I(0,18,18),
                   TDISPSIZ I(0,9,6), 
                   TDECPT I(0,21,6),
                   TPICSIZ I(0,27,15),
                   TBPOS I(0,36,6), 
                   TLG I(0,42,18),
                   TMLG I(0,0,3), 
              TBP I(0,0,30),
              TWP I(0,30,30), 
                   TMURAL U(0,0,60);
      BASED ARRAY VERX; 
       ITEM VERTAB; 
      DEF VTBLSIZE #7#; 
      BASED ARRAY VMOVETBL; 
       ITEM VENTRY    U(0,00,03), 
            VERWORD   I(0,00,60),  # FULL WORD                         #
            VEDIT     B(0,03,01), 
            VFCHAR    U(0,04,04), 
            VTOCHAR    U(0,08,04),
            VCHARLG   U(0,12,12),  # LENGTH OF FIELD IN CHARACTERS     #
            VFROMADDR I(0,24,18), 
            VTOADDR   I(0,42,18), 
            VCNVT     U(1,00,06), 
            VSTACK    I(1,06,18),  # INDEX TABLE OR PROG STACK ADDRESS #
            VADDRFR   I(1,24,18), 
            VPKEY     B(2,00,01),  # TRUE IF PRIMARY KEY               #
            VKEYEXCL  B(2,01,01),  # TRUE IF PART/ALL OF EXCLUDED KEY  #
            VADDRTO   I(1,42,18); 
      ITEM CHARLG I;               # NUMBER OF CHARACTERS IN ITEM      #
                                   # (INCLUDES BLANK BETWEEN ITEMS     #
                                   # AND ALL OCCURRENCES IF NECESSARY) #
      XREF PROC DIAG;              # ISSUE DIAGNOSTIC MESSAGE TO USER  #
      XREF PROC RECNO;
      XREF PROC RECYES; 
      XREF FUNC SAVATTR I;
      XREF ITEM AREATBLPTR I; 
      XREF ITEM IMFDBM B;          # TRUE IF IN IMF DATABASE MODE      #
  
CONTROL EJECT;
#----------------------------------------------------------------------#
#                                                                      #
#     PROC FNDFITADR                                                   #
#                                                                      #
#     CONVERT AREA ORDINAL TO FIT ADDRESS OF AREA                      #
#                                                                      #
#----------------------------------------------------------------------#
  
      PROC FNDFITADR(TOBASE); 
      BEGIN 
      ITEM K I;                    # LOOP COUNTER                      #
      ITEM TOBASE I;               # AREA ORDINAL                      #
      IF AREAORDINAL EQ 0          # IF NO PREVIOUS AREA ENCOUNTERED   #
      THEN
        BEGIN 
        AREAORDINAL = TOBASE;      # ORDINAL OF FIRST AREA FOUND       #
  
        IF NOT IMFDBM              # IF PROCESSING VIA CRM OR CDCS     #
        THEN
          BEGIN 
  
          P<AREA$TABLE> = AREATBLPTR;  # POSITION TO SUBSCHEMA         #
  
          FOR K = 1 STEP 1
            UNTIL AREAORDINAL      # AT PROPER POSITION IN CHAIN       #
          DO
            BEGIN 
            P<AREA$TABLE> = AT$FORWARD;  # POSITION AREA TABLE         #
            END 
  
          P<FIT> = LOC ( AT$AFITPOS[0] );  # SET FIT ADDRESS OF AREA   #
  
          END                      # END CMR/CDCS PROCESSING           #
  
        END 
      ELSE                         # IF PREVIOUS AREA ENCOUNTERED      #
        BEGIN 
        IF AREAORDINAL NQ TOBASE   # IF DIFFERENT AREAS                #
        THEN
          BEGIN 
          STDNO;                   # ERROR EXIT, MULTIPLE AREAS        #
          END 
        END 
      RETURN; 
      END 
CONTROL EJECT;
#----------------------------------------------------------------------#
#                                                                      #
#     PROC SCANVPROGSTK                                                #
#                                                                      #
#     REPLACE AREA ORDINAL WITH AREA WSA IN PROGRAMSTACK               #
#                                                                      #
#----------------------------------------------------------------------#
  
      PROC SCANVPROGSTK(TABLEPTR);
      BEGIN 
      ITEM FINISHED B;             # LOOP CONTROL                      #
      ITEM I I;                    # LOOP COUNTER                      #
      ITEM PREVIOUS I;             # INDEX OF SUB PROGRAMSTACKS        #
      ITEM STEPPER I;              # LOOP COUNTER                      #
      ITEM TABLEPTR I;             # PROGRAM STACK ADDRESS             #
      ARRAY EXPRSTACK [9];         # ARRAY FOR HOLDING INFO IN CASE    #
                                   # THERE ARE SUB-EXPRESSIONS         #
        BEGIN 
        ITEM STACKADDR I(0,42,18); # ADDRESS OF PROGRAMSTACK           #
        ITEM PSTKPTR   I(0,24,18); # INDEX WITHIN PROGRAMSTACK         #
        END 
  
      PREVIOUS = -1;
      P<PROGRAMSTACK> = TABLEPTR;  # POSITION TO PROGRAM STACK         #
      FOR STEPPER = STEPPER 
        WHILE TRUE
      DO
        BEGIN 
        FOR I = 0 STEP 1
          WHILE NOT FINISHED
        DO
          BEGIN 
          IF ENTRYTYPE[I] EQ 3     # IF A SUB-EXPRESSION EXISTS        #
            OR ENTRYTYPE[I] EQ 6
          THEN
            BEGIN 
            PREVIOUS = PREVIOUS + 1;  # COUNT OF SUB-EXPRESSIONS       #
            STACKADDR[PREVIOUS] = P<PROGRAMSTACK>;  # SAVE ADDRESS OF  #
                                                    # PROGRAMSTACK     #
            PSTKPTR[PREVIOUS] = I; # INDEX INTO PROGRAMSTACK           #
            P<PROGRAMSTACK> = EXPRESSTACK[I];  # POSITION TO SUB-      #
                                               # EXPRESSION STACK      #
            TEST STEPPER;          # RESTART LOOP                      #
            END 
          IF ENTRYTYPE[I] NQ 7     # IF NOT OPERATOR                   #
          THEN
            BEGIN 
            IF TOWORDBASE[I] LQ O"100"  # IF AREA ORDINAL              #
              AND TOWORDBASE[I] GR 0
            THEN
              BEGIN 
              FNDFITADR(TOWORDBASE[I]);  # CONVERT AREA ORDINAL TO FIT #
                                   # ADDRESS                           #
              IF KEYEXCL[I]        # IF PART/ALL OF EXCLUDED KEY       #
              THEN
                BEGIN 
                WORDBASE = LOC(FITKA);  # ADDRESS OF KEY               #
                END 
              ELSE
                BEGIN 
                IF IMFDBM          # IF PROCESSING VIA IMF             #
                THEN
                  BEGIN 
                  WORDBASE = LOC(RECORDS[TOWORDBASE[I]]);  # RECORD WSA#
                  END 
                ELSE               # IF PROCESSING VIA CRM OR CDCS     #
                  BEGIN 
                  WORDBASE = LOC(FITWSA);  # ADDRESS OF RECORD         #
                  END 
  
                END 
              IF ENTRYTYPE[I] EQ 2  # IF CONVERSION REQUIRED           #
                OR ENTRYTYPE[I] EQ 3
                OR ENTRYTYPE[I] EQ 4
              THEN
                BEGIN 
                FROMWORDBASE[I] = WORDBASE; 
                TOWORDBASE[I] = 0;
                END 
              ELSE                 # NO CONVERSION REQUIRED            #
                BEGIN 
                TOWORDBASE[I] = WORDBASE; 
                END 
              AREAORD[I] = TOWORDBASE[I];  # SAVE AREA ORDINAL IN      #
                                           # PROGRAMSTACK              #
              END 
            ELSE                   # IF TOWORDBASE[I] GR O"100"        #
              BEGIN 
              IF AREAORDINAL EQ 0  # IF NO PREVIOUS AREA ENCOUNTERED   #
              THEN
                BEGIN 
                AREAORDINAL = AREAORD[I]; 
                END 
              ELSE                 # IF PREVIOUS AREA ENCOUNTERED      #
                BEGIN 
                IF AREAORDINAL NQ AREAORD[I]  # IF DIFFERENT AREAS     #
                THEN
                  BEGIN 
                  STDNO;
                  END 
                END 
              END 
            END 
          ELSE                     # IF OPERATOR                       #
            BEGIN 
            IF OPCODE[I] EQ O"70"  # IF END OF STACK                   #
            THEN
              BEGIN 
              IF PREVIOUS LS 0     # IF NO SUB-EXPRESSION              #
              THEN
                BEGIN 
                RETURN;            # EXIT ROUTINE                      #
                END 
              ELSE                 # IF EVALUATING SUB-EXPRESSION      #
                BEGIN 
                P<PROGRAMSTACK> = STACKADDR[PREVIOUS];
                I = PSTKPTR[PREVIOUS];
                PREVIOUS = PREVIOUS - 1;
                TEST I; 
                END 
              END 
            END 
          END 
        END 
      END 
  
CONTROL EJECT;
#----------------------------------------------------------------------#
#                                                                      #
#     PROC VERINIT                                                     #
#                                                                      #
#     INITIALIZE POINTERS FOR VERIFY AND CLEAR PREVIOUS VERIFY, IF ANY #
#                                                                      #
#----------------------------------------------------------------------#
  
      XDEF PROC VERINIT;
      PROC VERINIT; 
      BEGIN 
  
      FRSTVER = TRUE;              # INITIALIZE FLAGS AND POINTERS     #
      VERLEN = 1;                  # CHARACTER POSITION OF 1ST ITEM    #
      RECYES;                      # RETURN TO STDYES IF RECORDING     #
      IF VERAREATBL NQ 0           # IF ACTIVE VERIFY LIST             #
      THEN
        BEGIN 
  
        IF IMFDBM                  # IF PROCESSING VIA IMF             #
        THEN
          BEGIN 
          CMM$FGR ( REC$VERGRPID[VERAREATBL] );  # FREE CMM BLOCKS     #
          REC$VERWORD[VERAREATBL] = 0;   # CLEAR VERIFY LIST POINTERS  #
          END 
        ELSE                       # IF PROCESSING VIA CRM OR CDCS     #
          BEGIN 
          P<AREA$TABLE> = VERAREATBL;  # POSITION TO CORRECT AREA      #
          CMM$FGR ( AT$VERGRPID ); # FREE ANY CMM BLOCKS IN GROUP      #
          AT$VERWORD = 0;          # CLEAR VERIFY LIST POINTERS        #
          END 
  
        VERAREATBL = 0;            # INDICATE NO ACTIVE VERIFY LIST    #
        END 
      SM$GROUPID = CMM$AGR(0);     # GET NEW CMM GROUP ID              #
      STDYES; 
      END 
  
      CONTROL EJECT;
#----------------------------------------------------------------------#
#                                                                      #
#     PROC VERRLS                                                      #
#                                                                      #
#     RELEASE CM ASSOCIATED WITH VERIFY LIST AND RESTORE CURRELATION   #
#                                                                      #
#----------------------------------------------------------------------#
  
      XDEF PROC VERRLS;            # RELEASE VERIFY LIST               #
      PROC VERRLS;
      BEGIN 
  
      RECNO;                       # RETURN TO STDNO  IF RECORDING     #
      IF SM$GROUPID NQ 0           # IF GROUP ID ASSIGNED              #
      THEN
        BEGIN 
        CMM$FGR(SM$GROUPID);       # FREE ANY CMM BLOCKS IN GROUP      #
        SM$GROUPID = 0;            # INDICATE NO GROUP ID ASSIGNED     #
        END 
      STDNO;
      END 
CONTROL EJECT;
#----------------------------------------------------------------------#
#                                                                      #
#     PROC VERSEM                  INSERT DATANAME IN VERIFY LIST      #
#                                                                      #
#----------------------------------------------------------------------#
  
  
  
  
      XDEF PROC VERSEM; 
      PROC VERSEM;
     BEGIN
      IF RECORDFLAG THEN STDNO;                                         000120
      IF FRSTVER                   # IF FIRST DATA ITEM                #
      THEN
        BEGIN 
        VERILOC = CMM$ALF(VTBLSIZE, 0, SM$GROUPID);  # VERIFY TABLE    #
        P<VERX> = VERILOC;
        END 
NOTFRST:       # #
      FOR I = 0 STEP EESIZE UNTIL VTBLSIZE-EESIZE DO
     BEGIN
      IF VERTAB[I] EQ 0 THEN GOTO GOTSLOT;
      P<VMOVETBL> = P<VERX> + I;
     END
      IF VERTAB[VTBLSIZE-1] EQ 0 THEN 
     BEGIN
      VERTAB[VTBLSIZE-1] = CMM$ALF(VTBLSIZE,0,SM$GROUPID);
      P<VERX> = VERTAB[VTBLSIZE-1]; 
      GOTO NOTFRST; 
     END
      P<VERX> = VERTAB[VTBLSIZE-1]; 
      GOTO NOTFRST; 
GOTSLOT:         # #
      P<VMOVETBL> = P<VERX> + I;
      VEDIT[0] = TRUE;
      VFCHAR[0] = DATACHARPOS;
      VCHARLG[0] = RESULTSIZE;
      VFROMADDR[0] = DATAWORDADDR;                                      001690
      VCNVT[0] = C<DATATYPE,1>CCODE[DATATYPE];
      VADDRTO[0] = LOC(VERIBUF);
      VTOADDR[0] = VERLEN / 10;    # STARTING WORD POSITION            #
      VTOCHAR[0] = VERLEN - (VTOADDR[0] * 10);  # STARTING CHAR POS    #
      IF NOT ABSADDRESS            # IF NOT LITERAL                    #
      THEN
        BEGIN 
        VADDRFR[0] = DATANAMEBASE;
        END 
      IF (DATATYPE EQ 1 AND DATANAMEUSE NQ 1 ) OR                       000150
      (FIGLITDATA EQ 1 AND DATATYPE EQ 0 ) AND                          000160
      NOT INDICED THEN GOTO VDT1;                                       000170
      IF PROGSTACKLEN LS 0 THEN GOTO VDT2;                              000180
      IF PROGSTACKLEN GR 0 THEN GOTO VDT3;                              000200
      DIAG (200);                                                       000210
      STDNO;                                                            000220
VDT1:        # SET UP MOVEC CALL FOR 4-0#                               000230
      VENTRY[0] = 1;                                                    000240
      VFROMADDR[0] = DATAWORDADDR;                                      000250
      CHARLG = RESULTSIZE + 1;     # SIZE OF ITEM PLUS BLANK           #
      GOTO VCOM;                                                        000260
VDT2:      # SET UP CONVERT CALL FOR 4-0 #                              000270
      VENTRY[0] = 2;                                                    000280
      IF FIGLITDATA EQ 1 AND DATATYPE GR 1 THEN GOTO VDT2A;             000290
      IF FIGLITDATA NQ 1 THEN GOTO VDT2B;                               000300
VDT2A:      # ITEM IS A CONSTANT LITERAL #                              000310
      P<TOATTRI> = CMM$ALF(3,0,SM$GROUPID); 
      VFROMADDR[0] = LOC(TOATTRI) - 1;                                  000340
          TMRPT[1]=0; 
          TCLASS[0]=DATATYPE; 
          TPICSIZ[1]=PICSIZ[DATATYPE];
          TDECPT[1]=DECPT[DATATYPE];
          TDISPSIZ[1]=DISPSIZ[DATATYPE];
          TWPOS[0]=DATAWORDADDR;
          TBPOS[0]=0; 
          TLG[0] = SIZE[DATATYPE] * 10 ;                                000360
          IF DEFMURAL[DATATYPE] NQ 0  # IF MURAL REQUIRED              #
          THEN
            BEGIN 
            TMRPT[1] = 3;          # REL PTR TO MURAL                  #
            TMURAL[2] = DEFMURAL[DATATYPE];  # STORE MURAL             #
            END 
     VCHARLG[0] = PICSIZ[DATATYPE];                                     000370
      CHARLG = PICSIZ[DATATYPE] + 1;  # SIZE OF ITEM PLUS BLANK        #
      GOTO VCOM;                                                        000380
VDT2B:      # ITEM IS A DATA NAME #                                     000390
      VPKEY[0] = AKEYITEM;         # TRUE IF PRIMARY KEY               #
      VKEYEXCL[0] = EXCLKEYITEM;   # TRUE IF PART/ALL OF EXCLUDED KEY  #
      P<DESATT1> = DATANAMEPTR;                                         000400
      J = DATACHARPOS * 6;                                              000410
      IF NOT INDICED AND                                                000420
      (J NQ DBITPOS[0] OR DATAWORDADDR NQ DEWPOS[0]) THEN               000430
     BEGIN                                                              000440
      P<BASTEMP> = P<DESATT1>;
      P<DESATT1> = CMM$ALF(7, 0, SM$GROUPID); 
      FOR PFLOOPCTR = 0 STEP 1 UNTIL 6 DO                               000460
              DDWORD0[PFLOOPCTR] = BTEMP[PFLOOPCTR];
      DEWPOS[0] = DATAWORDADDR;                                         000480
      DBITPOS[0] = J;                                                   000490
     END                                                                000500
      ELSE                                                              000510
      IF AREAITM THEN P<DESATT1> = SAVATTR;                             000520
      VFROMADDR[0] = P<DESATT1>;                                        000530
      CHARLG = RESULTSIZE + 1;     # SIZE OF ITEM PLUS BLANK           #
      IF INDICED
      THEN
        BEGIN 
        VENTRY[0] = 4;             # CALL FIGSUB                       #
        VSTACK[0] = INDCTBLOC;     # INDEX TABLE                       #
        IF FALL                    # IF SUBSCRIPT -ALL-                #
        THEN
          BEGIN 
          P<INDTBL> = INDCTBLOC;
          CHARLG = CHARLG * UPBND[0];  # N ITEMS, N BLANKS             #
          END 
        END 
      GOTO VCOM;                                                        000540
VDT3:      # SET UP EXPEVALUATE CALL FOR 4-0 #                          000550
      VENTRY[0] = 3;                                                    000560
      VSTACK[0] = PROGSTACKLOC;                                         000570
      P<TOATTRI> = CMM$ALF(3,0,SM$GROUPID); 
      VFROMADDR[0] = P<TOATTRI> - 1;                                    000590
      TDISPSIZ[1] = DISPSIZ[DATATYPE];                                  000630
      TDECPT[1] = DECPT[DATATYPE];                                      000640
      TPICSIZ[1] = PICSIZ[DATATYPE];                                    000650
      TWPOS[0] = RESULTSLOC;                                            000660
      TCLASS[0] = RESULTUSAGE;                                          000670
      TLG[0] = RESULTSIZE;                                              000680
      IF DEFMURAL[DATATYPE] NQ 0   # IF MURAL REQUIRED                 #
      THEN
        BEGIN 
        TMRPT[1] = 3;              # REL PTR TO MURAL                  #
        TMURAL[2] = DEFMURAL[DATATYPE];  # STORE MURAL                 #
        END 
      CHARLG = RESULTSIZE + 1;     # SIZE OF ITEM PLUS BLANK           #
      GOTO VCOM;                                                        000690
VCOM:      # FINAL COMMON PROCESSING FOR ALL VERIFY STUFF#              000760
      FRSTVER = FALSE;
      VERLEN = VERLEN + CHARLG;    # NO OF CHARACTERS IN VERIFY ARRAY  #
      STDYES; 
     END
  
  
  
  
CONTROL EJECT;
#----------------------------------------------------------------------#
#                                                                      #
#     PROC VERSEMX                 TERMINATE VERIFY PROCESSING         #
#                                                                      #
#     REPLACE AREA ORDINAL WITH AREA WSA IN VERIFY TABLE OR            #
#     PROGRAMSTACK.  ERROR EXIT IF NOT EXACTLY ONE AREA REFERENCED.    #
#     STORE VERIFY LIST INFORMATION IN AREA TABLE .                    #
#                                                                      #
#----------------------------------------------------------------------#
  
  
  
  
      XDEF PROC VERSEMX;
      PROC VERSEMX; 
      BEGIN 
      ITEM LOOPCON B;              # LOOP CONTROL                      #
      ITEM STEPPER I;              # LOOP VARIABLE                     #
      ITEM FINISHED B;             # LOOP CONTROL                      #
      ITEM I I;                    # LOOP VARIABLE                     #
  
      RECYES;                      # RETURN TO STDYES IF RECORDING     #
      AREAORDINAL = 0;             # INITIALLY NO AREA REFERENCED      #
      LOOPCON = TRUE; 
      P<VMOVETBL> = VERILOC;       # POSITION TO VERIFY TABLE          #
      FOR STEPPER = STEPPER 
        WHILE LOOPCON 
      DO
        BEGIN 
        FINISHED = FALSE; 
        FOR I = 0 STEP EESIZE 
          WHILE NOT FINISHED
        DO
          BEGIN 
          IF I GQ VTBLSIZE - 1     # IF END OF VERIFY TABLE BLOCK      #
          THEN
            BEGIN 
            IF VERWORD[I] NQ 0     # IF ANOTHER BLOCK EXISTS           #
            THEN
              BEGIN 
              P<VMOVETBL> = VERWORD[I];  # POSITION TO NEXT BLOCK      #
              TEST STEPPER; 
              END 
            ELSE                   # IF END OF VERIFY TABLE            #
              BEGIN 
              LOOPCON = FALSE;     # SIGNAL END OF LOOP                #
              TEST STEPPER; 
              END 
            END 
          IF VERWORD[I] EQ 0       # IF END OF VERIFY TABLE            #
          THEN
            BEGIN 
            LOOPCON = FALSE;       # SIGNAL END OF LOOP                #
            TEST STEPPER; 
            END 
          IF VENTRY[I] EQ 3        # IF SUB-EXPRESSION EXISTS          #
          THEN
            BEGIN 
            SCANVPROGSTK(VSTACK[I]);  # SCAN PROGRAM STACK             #
            END 
          IF VADDRFR[I] LQ O"100"  # IF AREA ORDINAL                   #
            AND VADDRFR[I] GR 0 
          THEN
            BEGIN 
            FNDFITADR(VADDRFR[I]);  # CONVERT AREA ORDINAL TO FIT ADDR #
              IF VKEYEXCL[I]       # IF PART/ALL OF EXCLUDED KEY       #
            THEN
              BEGIN 
              VADDRFR[I] = LOC(FITKA);   # ADDRESS OF KEY              #
              END 
            ELSE
              BEGIN 
              IF IMFDBM            # IF PROCESSING VIA IMF             #
              THEN
                BEGIN 
                VADDRFR[I] = LOC(RECORDS[VADDRFR[I]]);  # WSA OF RECORD#
                END 
              ELSE                 # IF PROCESSING VIA CRM OR CDCS     #
                BEGIN 
                VADDRFR[I] = LOC(FITWSA);  # ADDRESS OF RECORD         #
                END 
              END 
            END 
          END                      # END OF *I* LOOP                   #
        END                        # END OF *STEPPER* LOOP             #
      IF AREAORDINAL EQ 0          # IF NO AREA ITEM REFERENCED        #
      THEN
        BEGIN 
        STDNO;                     # ERROR EXIT, EXACTLY ONE AREA      #
                                   # MUST BE REFERENCED                #
        END 
      IF IMFDBM                    # IF PROCESSING VIA IMF             #
      THEN
        BEGIN 
                                   # STORE ADDR OF VERIFY TABLE        #
        REC$VERILOC[AREAORDINAL] = VERILOC;   # FOR THIS RECORD        #
        REC$VERGRPID[AREAORDINAL] = SM$GROUPID;     # CMM GROUP ID     #
        REC$VERLEN[AREAORDINAL] = (VERLEN + 9)/10;  # NO OF WORDS      #
                                   # STORE RECORD ORDINAL TO INDICATE  #
        VERAREATBL = AREAORDINAL;  # THIS RECORD HAS A VERIFY LIST     #
        END 
      ELSE                         # IF PROCESSING VIA CRM OR CDCS     #
        BEGIN 
                                   # STORE ADDR OF VERIFY TABLE        #
        AT$VERILOC = VERILOC;      # IN CURRENT AREA TABLE             #
        AT$VERGRPID = SM$GROUPID;     # CMM GROUP ID                   #
        AT$VERLEN = (VERLEN + 9)/10;  # NUMBER OF WORDS IN ARRAY       #
        VERAREATBL = P<AREA$TABLE>;   # STORE THIS AREAS TABLE ADDR    #
        END 
  
      SM$GROUPID = 0;              # CLEAR CMM GROUP ID                #
  
      STDYES; 
      END 
  
  
  
  
#----------------------------------------------------------------------#
  
  
      END 
      TERM
