*DECK CBPASS3 
USETEXT TSBDIT,TSBTBL 
      PRGM DL30403;                # THIS IS 4,3 OVERLAY               # DL3A030
    BEGIN 
#**********************************************************************#
#                                                                      #
#                  D E F S                                             #
#                                                                      #
#**********************************************************************#
*CALL COMHDRLEN 
      DEF BUFWRDS #10#;                # NUMBER OF WORDS FOR SCHEMA    #
                                       # BUFFER. REPRESENTS THE MAX-   #
                                       # IMUM FIXED WORDS + NAME OF    #
                                       # A SCHEMA ENTRY(AREA,REC,ITEM) #
      DEF DATANME #3#;                 # ENTRY TYPE FOR DATA-NAME.     #
      DEF DBINOMAP #1#;                # DBI WHICH DOES NOT REQUIRE    #
                                       # MAPPING.                      #
      DEF DBIMAP #2#;                  # DBI THAT REQUIRES MAPPING.    #
      DEF ENDDEL #13#;                 # END DELIMETER FOR THE QIN TBLE#
      DEF LITERAL #4#;                 # ENTRY TYPE FOR LITERAL.       #
      DEF MAXRELNS #4095#;             # MAXIMUM NUMBER OF RELATIONS.  #
      DEF OPERATOR #5#;                # ENTRY TYPE FOR OPERATOR.      #
                                       # AND FELATIONAL OPERATORS.     #
      DEF RLMINCR  #O"0050"#;          # INCREMENT FOR REALM SIZE      #
      DEF RSTHEADER #2#;               # NUMBER OF HEADER WORDS IN A   #
                                       # RST ENTRY.                    #
#**********************************************************************#
#                                                                      #
#                  X D E F S                                           #
#                                                                      #
#**********************************************************************#
      XDEF ITEM ERRCODE;               # USED TO FLAG ERRORS EITHER IN #
                                       # LITERAL CONVERSION OR IN      #
                                       # POLISH NOTATION PROCESSING.   #
      XDEF ARRAY QIN [500] S;      #CONTAINS THE OPERATOR ENTRIES      #
        BEGIN                          # OF THE RESTRICT CLAUSE BEFORE #
          ITEM QINWORD U(0,0,60);      # USED WHEN REFERENCING A COM-  #
                                       # PLETE WORD IN QINBUF.         #
                                       # THEY ARE ARRANGED IN POLISH   #
                                       # NOTATION.                     #
          ITEM QINOPCDE U(0,0,6);      # OPERATOR CODE.                #
                                       #   RELATIONAL                  #
                                       #     EQ = 1                    #
                                       #     NE = 2                    #
                                       #     GE = 3                    #
                                       #     LE = 4                    #
                                       #     GT = 5                    #
                                       #     LT = 6                    #
                                       #   LOGICAL                     #
                                       #     AND = 7                   #
                                       #     OR  = 8                   #
                                       #     XOR = 9                   #
                                       #     NOT = 10                  #
                                       #   SPECIAL                     #
                                       #     BEGDEL = 0                #
                                       #     (      = 11               #
                                       #     )      = 12               #
                                       #     ENDDEL = 13               #
          ITEM QINSRCDBI U(0,6,15);    # POINTER TO THE SOURCE DBI     #
                                       # STACK ENTRY.                  #
          ITEM QINTARDBI U(0,21,15);   # POINTER TO THE TARGET DBI     #
                                       # STACK ENTRY.                  #
          ITEM QINOPPTR U(0,36,15);    # POINTER TO THE OPERATOR STACK #
                                       # ENTRY.                        #
        END 
#**********************************************************************#
#                                                                      #
#                  X R E F S                                           #
#                                                                      #
#**********************************************************************#
      XREF
        BEGIN 
          ITEM CURLENG;                # LENGTH IN CHARACTERS OF THE   #
                                       # CURRENT SOURCE WORD           #
          ITEM CURLENW;                # LENGTH IN WORDS OF THE CURRENT#
                                       # SOURCE WORD.                  #
          ITEM CURP1;                  # CONTAINS A VALUE ASSOCIATED   #
          ITEM CURTYPE;                # CONTAINS THE SYNTACTIC TYPE   #
                                       # OF THE CURRENT SOURCE WORD.   #
          ITEM DDLDIAG;                # ADDRESS OF THE DIAG TABLE (   #
                                       # NEEDED BY STD).               #
          ITEM DDLMEM;                 # LEFT MOST 30 BITS CONTAINS THE#
                                       # LAST WORD ADDRESS OF THE USERS#
                                       # FIELD LENGTH.                 #
          ITEM DDLSU ;                 # STORAGE USED (MIN FL NEEDED). #
          ITEM FIRSTWORD;              # FIRST WORD OF THE WORDKING    #
                                       # STORAGE AREA. ALSO THE ADDRESS#
                                       # THE REALM LIST.               #
          ITEM LBLPTR;                 # ADDRESS OF THE SUBROUTINE LIST#
                                       # (NEEDED BY CTLSTD).           #
          ITEM LBLPTRS;                # LOCATION OF THE SUB-SROUTINE  #
                                       # LIST CREATED BY SYNGEN.       #
          ITEM LEXICO;                 # ADDRESS OF THE KEYWORD INDEX  #
                                       # (NEEDED BY CTLSTD).           #
          ITEM LEXICON;                # LOCATION OF THE KEYWORD INDEX #
                                       # CREATED BY SYNGEN.            #
          ITEM LEXWD;                  # ADDRESS OF THE KEYWORD LIST   #
                                       # (NEEDED BY CTLSTD).           #
          ITEM LEXWORD;                # LOCATION OF THE KEYWORD LIST  #
                                       # CREATED BY SYNGEN.            #
          ITEM MAXFL ;                 # MAX FL ALLOWED BY O.S.        #
          ITEM MAXSELENG;              # CONTAINS THE MAXIMUM SUB-ENTRY#
                                       # LENGTH.                       #
          ITEM MULTSS B;               # TRUE - MULTIPLE COMPILATION   #
          ITEM REALMSZ;                # REALM LIST LENGTH IN WORDS    #
          ITEM SBSCHMA;                # CONTAINS THE FIRST WORD ADDR  #
                                       # OF THE SUB-SCHEMA IN CORE.    #
          ITEM SWITCHVCTR;             # ADDRESS OF THE SWITCH VECTOR  #
                                       # THAT CONTAINS ALL THE SEMANTIC#
                                       # ROUTINES DEFINED IN THE       #
                                       # SUBROUTINE LIST (NEEDED BY    #
                                       # CTLSTD).                      #
          ITEM SYNTBL;                 # ADDRESS OF THE SYNTAX TABLE   #
                                       # (NEEDED BY CTLSTD).           #
          ITEM SYNTBLE;                # LOCATION OF THE RELATION SYNTX#
                                       # TABLE.                        #
*IF DEF,DEBUG,2 
      ITEM TRACE; 
      ITEM TRACEM;
          ARRAY CWORD [25] S;          # CURRENT SYNTAX SOURCE WORD    #
            BEGIN                      # KRACKED BY CTLSCAN.           #
              ITEM CURWORD U(0,0,60); 
              ITEM CURWRD30 C(0,0,30);
            END 
        END 
  
  
      XREF
        BEGIN 
          PROC ABRT1;                  # ISSUES DAYFILE MESSAGE INSUFF #
                                       # ICENT FIELD LENGTH AND ABORTS #
                                       # RUN.                          #
          PROC CBRDIAG;                # ERROR PROCESSING ROUTINE.     #
          PROC CBOVLP4;                # IF NO DIAGNOSTICS ARE ISSUED  #
                                       # THE SUB-SCHEMA IN CORE IS     #
                                       # WRITTEN TO DISK. ENTRY POINT  #
                                       # IN CBMAIN.                    #
          PROC CONVLIT;                # PROCEDURE THAT DOES THE ACTUAL#
                                       # CONVERSION OF THE LITERAL     #
                                       # SPECIFIED IN THE RESTRICT     #
                                       # CLAUSE.                       #
          PROC CBHASHN;                # CALCULATES THE HASH-ID FOR    #
                                       # USE BY THE HASH ROUTINE TO    #
                                       # ACCESS THE SYMBOL TABLE.      #
          PROC DE$DISC;                # SCHEMA DIRECTORY ACCESS ROUTIN#
                                       # E USED TO FETCH DBI S THAT PRE#
                                       # QUALIFIED WITH THE RECORD NAME#
          PROC DE$NMSC;                # SCHEMA DIRECTORY ACCESS ROUT- #
                                       # INE USED TO FETCH A SCHEMA    #
                                       # ENTRY BY NAME.                #
          PROC DCTINIT;                # ALTERNATE ENTRY POINT IN CTL- #
                                       # SCAN TO GET THE SYNTAX KRACK- #
                                       # ING STARTED FOR THE RELATION  #
                                       # DIVISION.                     #
          PROC DIAGSTD;                # ENTRY POINT IN CTLSTD THAT    #
                                       # PROCESSES DIAGNOSTICS ISSUED  #
                                       # IN SYNGEN SPECIFICATION.      #
          PROC MEMORY ;                # ISSUE FIELD LENGTH REQUEST.   #
          PROC READSC;                 # SCHEMA DIRECTORY ACCESS ROUT- #
                                       # INE USED TO FETCH A SCHEMA    #
                                       # ENTRY BY WORD ADDRESS.        #
          PROC CBPOLSH;                # REORDERS THE RQTSTACK ENTRIES #
                                       # INTO POLISH NOTATION.         #
          PROC STDNO;                  # ENTRY POINT IN STD.           #
          PROC STDYES;                 #  ENTRY POINT IN STD.          #
          PROC STD$START;              # INITIAL ENTRY POINT IN CTLSTD.#
        END 
#**********************************************************************#
#                                                                      #
#                  L O C A L     I T E M S                             #
#                                                                      #
#**********************************************************************#
      ITEM ACCUM;                      # CONTAINS THE ACCUMULATED POSIT#
                                       # ION OF A DBI FROM THE START OF#
                                       # THE RECORD (IN CHARACTERS).   #
      ITEM AREARANK;                   # CONTAINS THE RANK NUMBER OF   #
                                       # THE OWNER AREA OF THE CURRENT #
                                       # RESTRICTED RECORD.            #
      ITEM ATTRPTR;                    # POINTER USED WHEN REFERENCING #
                                       # THE ATTRIBUTE WORK STORAGE    #
                                       # BUFFER.                       #
      ITEM DBIADR;                     # WORD ADDRESS OF THE QUALIFIER #
                                       # DBI IN THE SUB-SCHEMA.        #
      ITEM DBILFTPTR;                  # POINTER IN THE ATTRIBUTE BUFFR#
                                       # TO THE DBI ENTRY LEFT OF THE  #
                                       # OPERATOR.                     #
      ITEM DBILENG;                    # CONTAINS THE LENGTH OF THE    #
                                       # QUALIFIER DBI IN CHARACTERS   #
      ITEM DBILENW;                    # CONTAINS THE LENGTH IN WORDS  #
                                       # OF THE QUALIFIER DBI.         #
      ITEM DBI3CNTR;                   # NUMBER OF DBIS WHOSE KEY INDIC#
                                       # ATOR (RST) IS EQUAL TO OR LESS#
                                       # THAN 3.                       #
      ITEM DEFINED;                    # 0 - UNDEFINED NAME.           #
                                       # 1 - DEFINED NAME.             #
                                       # USED IN CALL TO HASH ROUTINE  #
                                       # FOR A REFERENCE.              #
      ITEM DTEMP;                      # CONTAINS THE SOURCE VALUE     #
                                       # OF A DECIMAL DISPLAY TO BINARY#
                                       # CONVERSION.                   #
      ITEM FIRSTDBI;                   # WORD ADDRESS OF THE FIRST DBI #
                                       # IN A RECORD.                  #
      ITEM FLAG B;                     # TEMPORARY CELL USED TO INDIC- #
                                       # ATE AN OCCURENCE OF AN ERROR  #
                                       # (USED IN CONLIT).             #
      ITEM HIGHESTRANK;                # CONTAINS THE HIGHEST RANK     #
                                       # SPECIFIED IN THE SUB-SCHEMA.  #
      ITEM HIRQTRNK;                   # CONTAINS THE HIGHEST AREA RANK#
                                       # SPECIFIED IN THE CURRENT RQT  #
                                       # ENTRY.                        #
      ITEM I;                          # SCRATCH ITEM.                 #
      ITEM ITEMP;                      # CONTAINS THE TARGET VALUE     #
                                       # OF A DECIMAL DISPLAY TO BINARY#
                                       # CONVERSION.                   #
      ITEM J;                          # SCRATCH ITEM.                 #
      ITEM K;                          # SCRATCH ITEM.                 #
      ITEM LARGESTDBI;                 # CONTAINS THE LENGTH IN WORDS  #
                                       # OF THE LARGEST DBI WHOSE KEY  #
                                       # INDICATOR IS 3 OR LESS.       #
      ITEM LARGESTRQT;                 # CONTAINS THE SIZE IN WORDS OF #
                                       # THE LARGEST RQT ENTRY.        #
      ITEM LASTWRD;                    # LAST WORD OF THE USERS FIELD  #
                                       # LENGTH.                       #
      ITEM LITLENG;                    # LENGTH IN CHARACTERS OF THE   #
                                       # LITERAL SPECIFIED IN THE      #
                                       # RESTRICT CLAUSE.              #
      ITEM M;                          # SCRATCH CELL.                 #
      ITEM MAXRELRANK;                 # CONTAINS THE HIGHEST RANK IN  #
                                       # THE RST ENTRY.                #
      ITEM N;                          # SCRATCH CELL.                 #
      ITEM NBRDBIS;                    # NUMBER OF JOIN DBIS SPECIFIED #
                                       # IN A RELATION.                #
      ITEM QALNUM;                     # NUMBER OF QUALIFIERS SPECIFIED#
                                       # (A OF B IN C, B AND C ARE QAL-#
                                       #  IFIERS).                     #
      ITEM QALPTR;                     # POINTER USED WHEN CREATING OR #
                                       # REFERENCING A QUALIFIER ENTRY #
                                       # IN QUALBUF.                   #
      ITEM QINPTR;                     # POINTER USED WHEN CREATING THE#
                                       # QIN TABLE (QIN INDEX).        #
      ITEM RANKORD;                    # TEMPORARY STORAGE FOR AREA    #
                                       # ORDINAL AS SPECIFIED IN THE   #
                                       # RST.                          #
      ITEM REALMLISTPTR;               # POINTER TO THE CURRENT RELAT- #
                                       # ION ENTRY IN THE REALM LIST.  #
      ITEM REALMORD;                   # ORDINAL NUMBER OF THE OWNER   #
                                       # REALM OF THE RESTRICTED       #
                                       # RECORD.                       #
      ITEM REALMPTR;                   # POINTER USED WHEN LINKING THRU#
                                       # THE REALM ENTRIES IN THE SUB- #
                                       # SCHEMA.                       #
      ITEM RECLENG;                    # LENG IN CHARS OF THE RESTRICT #
                                       # RECORD NAME.                  #
      ITEM RECLENGTH;                  # LENGTH OF THE SCHEMA REC. ENT.#
      ITEM RECLENW;                    # LENG IN WORDS OF THE RESTRICT #
                                       # RECORD NAME.                  #
      ITEM RECPTR;                     # WORD ADDRESS OF THE RECORD    #
                                       # ENTRY SPECIFIED IN THE RESTRIC#
                                       # T CLAUSE.                     #
      ITEM RQTPTR;                     # POINTER USED WHEN CREATING THE#
                                       # RQT TABLE. IT ALWAYS POINTS TO#
                                       # THE FIRST WORD OF THE RQT     #
                                       # ENTRY.                        #
      ITEM RSTORDINAL = 1;             # CONTAINS THE CURRENT ORDINAL  #
                                       # OF THE SUBJECT RST ENTRY.     #
      ITEM RSTPTR;                     # POINTER USED WHEN CREATING A  #
                                       # RELATION ENTRY. IT ALWAYS     #
                                       # POINTS TO THE FIRST WORD OF   #
                                       # THE RST ENTRY.                #
      ITEM SCRECADR;                   # CONTAINS THE WORD ADDRESS OF  #
                                       # SCHEMA RECORD ENTRY THAT      #
                                       # CORRESPONDS TO THE RESTRICTED #
                                       # RECORD.                       #
      ITEM STACKPTR;                   # POINTER USED WHEN REFERENCING #
                                       # THE RQT ENTRIES BEFORE THEIR  #
                                       # IN POLISH NOTATION.           #
      ITEM SUBSCOUNT;                  # CONTAINS THE NUMBER OF SUB-   #
                                       # SCRIPTS SPECIFIED WITH A DBI  #
                                       # IN THE WHERE CLAUSE.          #
      ITEM TARGET B;                   # TRUE = PROCESSING TARGET DBI. #
                                       # FALSE = PROCESSING SOURCE DBI.#
      ITEM WBPTR;                      # POINTER USED WHEN BUILDING THE#
                                       # VARIABLE LENGTH ENTRIES IN THE#
                                       # RST TABLE.                    #
#**********************************************************************#
#                                                                      #
#                  L O C A L     A R R A Y S                           #
#                                                                      #
#**********************************************************************#
      ARRAY DBIBUF [BUFWRDS] S;        # CONTAINS THE SCHEMA ENTRIES   #
                                       # THAT CORRESPONDS TO THE       #
                                       # CURRENT DBI  BEING PROCESSED  #
                                       # IN THE RESTRICT CLAUSE.       #
        BEGIN 
          ITEM DBIWRD U(0,0,60);       # ITEM USED WHEN REFERENCING A  #
                                       # A 60 ENTRY IN DBIBUF.         #
*CALL SCHDECLS
        END 
      ARRAY DBINME [2] S;              # CONTAINS THE ITEM NAME SPECIF-#
        ITEM DBINAME30 C(0,0,30);      # IED IN THE WHERE CLAUSE.      #
      ARRAY INTERBUFF [3];;            # INTERMEDIATE BUFFER USED BY   #
                                       # DD$CON.                       #
      ARRAY LITBUF [25] S;             # CONTAINTS THE LITERAL SPECIF- #
                                       # IED IN THE RESTRICT CLAUSE.   #
                                       # IT IS IN ITS TARGET FORM.     #
        ITEM LITWRD U(0,0,60);
      ARRAY QUALBUF   [35] S(1);       # CONTAINS THE QUALIFIER ENTRIES#
        BEGIN                          # (A OF B, B IS A QUALIFIER).   #
          ITEM QALWORD U(0,0,60);      # USED WHEN REFERENCING A COM-  #
                                       # PLETE WORD IN QALBUF.         #
          ITEM QALNMELENW U(0,0,3);    # LENGTH IN WORDS OF THE QAL NME#
          ITEM QALNMELENC U(0,3,6);    # LENGTH IN CHRS OF THE QAL NAME#
          ITEM QALNAME U(1,0,60); 
          ITEM QALNME30 C(1,0,30);
        END 
      ARRAY RANKLIST [64];             # EACH WORD POSITION IN THIS    #
        ITEM RANKFLAG B(0,0,1);        # ARRAY CORRESPONDS TO A RANK   #
                                       # NUMBER. WHEN A RANK NUMBER IS #
                                       # ENCOUNTERED IN THE DDL PROCESS#
                                       # ING, IT IS USE AS A SUB-SCRIPT#
                                       # TO THIS ARRAY TO SET A BIT    #
                                       # WHICH INDICATES THAT A RANK   #
                                       # VALUE HAS BEEN SPECIFIED.     #
      ARRAY RECORDNAME [2] S;          # TEMPORARY BUFFER THAT CONTAINS#
        BEGIN                          # THE RESTRICT RECORD NAME.     #
          ITEM RECNAME U(0,0,60); 
          ITEM RECNME30 C(0,0,30);
        END 
      ARRAY RQTSTACK  [1000];          # THE RQT ENTRIES ARE INITIALLY #
        BEGIN                          # BUILT IN THIS BUFFER (ALL     #
*CALL SBRQSTDCL 
        END                            # ).                            #
      ARRAY SUBSCRIPTBUF [3];          # CONTAINS THE BINARY VALUES OF #
        ITEM SUBSCRIPTS U(0,0,60);     # THE SUB-SCRIPTS SPECIFIED WITH#
                                       # A DBI.                        #
#**********************************************************************#
#                                                                      #
#                  L O C A L     P O I N T E R S      A R R A Y S      #
#                                                                      #
#**********************************************************************#
      BASED ARRAY ATTRBUF [0] S;       # RQT ATTRIBUTE ENTRIES ARE     #
        BEGIN                          # INITIALLY BUILT IN THIS BUFFER#
*CALL SBRQATDCL 
        END                            # THIS IS A BOTTOM-UP BUFFER.   #
      BASED ARRAY RSTBUF [0] S(1);     # POINTS TO THE WORDADDRESS IN  #
                                       # WORKBUF WHERE THE RELATION    #
                                       # ENTRY IS BUILT.               #
        BEGIN 
*CALL SCRLDECLS 
        END 
  
      SWITCH RELJUMP AREARNK, 
                     CONLIT,
                     DATANAME,
                     ENDSTACK,
                     FINDREC, 
                     FINDSBDBI, 
                     FINDSCDBI, 
                     GETSCREC,
                     LOGICALOP, 
                     L66DBI,
                     NORQT, 
                     QALNME,
                     RELNAME, 
                     RELRQT,
                     RELRST,
                     RELRSTAR,
                     RELTERM, 
                     RESTRDBI,
                     RESTREND,
                     RESTRREC,
                     RQTATTR, 
                     RQTDBI,
                     RQTDBILFT, 
                     RQTDBIRT,
                     RQTLIT,
                     RQTNOTATION, 
                     SETBCPBWP, 
                     SETSSFGT,
                     STORSUB, 
                     VALIDATEDBI, 
                     VALIDSUB,
                     VIRTDBI; 
#**********************************************************************#
#                                                                      #
#**** F I R S T    E X C U T A B L E     I N S T R U C T I O N S  *****#
#                                                                      #
#                  R E L S T A R T                                     #
#                                                                      #
#    INITIALIZES VARIOUS POINTERS AND POINTER ARRAYS USED IN PROCESSING#
#    THE RELATION DIVISION. RETURN IS TO STDNO.                        #
#                                                                      #
#**********************************************************************#
      LASTWRD = B<0,30>DDLMEM; # STORE LAST  WORD OF USERS FIELDLENG.  #
      P<REALMLIST> = FIRSTWORD; # REALM LIST.                          #
      P<CBWORKBUF> = SBSCHMA; # SUB-SCHEMA .                           #
      P<ATTRBUF> = LASTWRD;       # SET  THE ATTRIBUTE BUFFER TO THE   #
                             # LAST WORD  OF THE USERS FIELD LENGTH.   #
      SBCWFRSTRELA[0] = SBCWSBLENG; 
      WBPTR = SBCWFRSTRELA[0];     # SET POINTER TO FIRST AVAILABLE WRD#
      DDLDIAG = LOC(DIAGSTD); # SET LOCATION OF DIAGNOSTIC ROUTINE     #
                              # (ENTRY POINT IN CBRDIAG) FOR CTLSTD.   #
      LEXWD = LOC(LEXWORD);  # SET LOCATION OF THE KEY WORD LIST FOR   #
                             # CTLSTD.                                 #
      LEXICO = LOC(LEXICON);  # SET LOCATION OF THE KEY WORD INDEX FOR #
                              # CTLSTD.                                #
      SYNTBL = LOC(SYNTBLE);  # SET LOCATION OF THE SYNTAX TABLE FOR   #
                              # CTLSTD.                                #
      LBLPTR = LOC(LBLPTRS);  # SET LOCATION OF SUBROUTINE LIST.       #
*IF DEF,DEBUG 
      TRACE = LOC(TRACEM);
*ENDIF
      SWITCHVCTR = LOC(RELJUMP); # SET THE LOCATION OF THE SWITCH VECTR#
                                 # ( CONTAINS THE SUB-ROUTINES FOR THE #
                                 # RELATION PROCESSING) FOR CTLSTD.    #
      DCTINIT; # CALL ALTERNATE ENTRY POINT IN CTLSCAN TO GET THE BALL #
               # ROLLING WITH OUT READING IN A NEW SOURCE INPUT RECORD.#
      FOR I=WBPTR STEP 1 UNTIL (LASTWRD-LOC(CBWORKBUF)) - 1 DO
        RQTWORD[I] = 0; # ZERO OUT CORE FROM THE LAST WORD + 1 OF THE  #
                        # SUB-SCHEMA TO THE LAST WORD OF THE USERS     #
                        # FIELD LENGTH.                                #
      STD$START;
  AREARNK:   #   #
#**********************************************************************#
#                  A R E A R N K                                     #
#                                                                      #
#    VALIDATES THAT THE OWNER REALM OF THE RESTRICTED RECORD WAS SPEC- #
#    IFIED IN THE RST ENTRY OF THE CURRENT RELATION BEING PROCESSED.   #
#    THIS IS DONE BY SCANNING THE JOIN DBI ENTRIES FOR AN AREA ORDINAL #
#    THAT MATCHES THE REALM ORDINAL THAT THE RESTRICTED RECORD BELONGS #
#    TO (ESTABLISHED IN THE LABEL FINDREC). IF A MATCH WAS FOUND,      #
#    RETURN IS TO STDYES. IF A MATCH WAS NOT FOUND, RETURN IS TO STDNO #
#    WHERE STD ISSUES DIAGNOSTIC 426.                                  #
#                                                                      #
#**********************************************************************#
      RANKORD = 0;
      AREARANK = 0; 
      FOR I = RSTPTR + RSTRELNMELW[RSTPTR] + RSTHEADER STEP 2 
        WHILE I LS RQTPTR DO
        BEGIN 
          IF RSTAREAORD[I] NQ RANKORD THEN  # IF NOT EQUAL MUST BE NEW #
            BEGIN                           # RANK.                    #
              AREARANK = AREARANK + 1;
              RANKORD = RSTAREAORD[I];
            END 
          IF REALMORD EQ RSTAREAORD[I] THEN 
            BEGIN 
              IF RANKFLAG[AREARANK] THEN # CHECK IF THE SUBJECT RECORD #
                    # WAS PREVIOUSLY SPECIFIED IN A WHERE CLAUSE.      #
                CBRDIAG(429); 
               ELSE 
                RANKFLAG[AREARANK] = TRUE; # SET FLAG TO INDICATE AREA #
                    # HAS BEEN SPECIFIED.                              #
              IF HIRQTRNK LS AREARANK THEN
                HIRQTRNK = AREARANK; # STORE THE HIGHEST RANK ENCOUNTER#
                    # ED IN THE CURRENT RELATION ENTRY. LATER THIS     #
                    # VALUE IS TO STORED INTO THE RST HEADER.          #
              STDYES; 
            END 
        END 
      STDNO;
  CONLIT: 
#**********************************************************************#
#                  C O N L I T                                         #
#   CHECKS THE TYPE OF LITERAL SPECIFIED IN THE CHECK CLAUSE           #012970
#   AGAINST THE ITEM TYPE SPECIFIED IN THE TYPE CLAUSE. CONVERTS       #012980
#   THE LITERAL IF POSSIBLE AND STORES THE CONVERTED RESULT INTO       #012990
#   THE DIRECTORY WORKING BUFFER.                                      #013000
#                                                                      #013010
#   IF THE CONVERSION WAS NOT POSSIBLE, IT RETURNED TO STDNO,          #013020
#   ELSE IT HAD RETURNED TO STDYES.                                    #013030
#**********************************************************************#013040
      J = RQTITMCLASS[DBILFTPTR]; 
      FLAG = FALSE;     # INITIALIZE DIAGNOSTIC FLAG  # 
      IF J LQ 1 THEN   # FOR ALPHA OR ALPHANUMERIC ITEM # 
        BEGIN          # MUST HAVE NON-NUMERIC LITERAL. # 
          IF CURTYPE NQ 103 THEN
            FLAG = TRUE;  # RETURN WILL BE TO STDNO.    # 
          ELSE
            BEGIN 
              IF CURLENG GR RQTITMSIZE[DBILFTPTR] THEN # IF LENG OF LIT#
                FLAG = TRUE; # GREATER THAN TARGET ITEM, SET FLAG. #
              ELSE
              BEGIN 
              IF J EQ 1 THEN      # IF ITEM ALPHABETIC,                #
                BEGIN 
                  K = 0;          # CHECK TO SEE THAT LITERAL CONTAINS #
                  N = 0;          # ALL ALPHABETIC CHARACTERS OR BLANK.#
                  FOR I = 1 STEP 1 UNTIL CURLENG DO # IF NOT RETURN   # 
                    BEGIN 
                      FOR M = M WHILE K GR 9 DO    # WILL BE TO STDNO. #
                        BEGIN 
                          K = 0;
                          N = N + 1;
                        END 
                      IF C<K>CURWORD[N] GR O"32" AND
                                    (C<K>CURWORD[N] NQ O"55") THEN
                        BEGIN 
                          FLAG = TRUE;
                          I = CURLENG;
                        END 
                      ELSE
                        BEGIN 
                          K = K + 1;
                          TEST; 
                        END 
                    END 
                END 
              LITLENG = CURLENG;
              FOR I = 0 STEP 1 UNTIL CURLENW-1 DO 
                BEGIN    # BEGIN OF FOR-LOOP #
                  IF LITLENG GR ((I+1)*10) THEN 
                    BEGIN 
                    LITWRD[I] = CURWORD[I]; 
                    TEST I; 
                    END 
                  ELSE
                    BEGIN 
                      LITWRD[I] = O"55555555555555555555";
                      K = 10 - ((CURLENW*10)-CURLENG);
                      C<0,K>LITWRD[I] = C<0,K>CURWORD[I]; 
                    END 
                 END   # END OF FOR-LOOP #
                LITLENG = CURLENW;
               END
             END
         END
      ELSE
        BEGIN 
          IF CURTYPE EQ 103 THEN  # IF TARGET ITEM NUMERIC AND LITERAL# 
            FLAG = TRUE;     # NON-NUMERIC, SET FLAG.              #
          ELSE
          BEGIN 
          CONVLIT(DBIBUF,INTERBUFF,LITBUF,ERRCODE);# CONVERT LITERAL.  #
          IF ERRCODE NQ 0 THEN
            STDNO;
          IF J LS 10 THEN   # CHECK FOR DISPLAY NUMERIC.               #
            BEGIN 
              K = RQTITMSIZE[DBILFTPTR];
              LITLENG = K / 10; 
              I = K - (LITLENG * 10); 
              IF I GR 0 THEN
                LITLENG = LITLENG + 1;
            END 
             ELSE 
              IF J EQ 14 THEN 
                LITLENG = 2;
             ELSE 
              LITLENG = 1;
          END 
        END 
      IF FLAG THEN
        BEGIN 
          ERRCODE = 1;
          STDNO;
        END 
       STDYES;
  DATANAME: 
#**********************************************************************#
#                  D A T A N A M E                                     #
#                                                                      #
#    CREATES THE STACK ENTRY AND ATTRIBUTE ENTRY FOR A DATA NAME.      #
#    RETURN IS TO STDNO.                                               #
#                                                                      #
#**********************************************************************#
      RELHSHREF;             # CALL PROC TO DETERMINE IF NAME IS UNIQ- #
                             # UE AMONG ALL NAMES IN THE SUB-SCHEMA.   #
      IF DEFINED EQ 1 THEN   # IF NAME IS NOT UNIQUE,                  #
        BEGIN 
        CBRDIAG(411,DBINME,DBILENG);  # ISSUE DIAGNOSTIC.              #
        DEFINED = 0;
        END 
      IF QALNUM GR 0 THEN 
        CBRDIAG(414);        # DATA-NAME QUALIFIED - ERROR.            #
      INITQAL;
      I = (RQTITMSIZE[DBILFTPTR]-1)/10 + 1; # CORRESPONDING SCHEMA ITEM# D2A131 
                                            #SIZE(IN WORDS)            # D2A131 
      SBCWDNSBUFSZ[0] = SBCWDNSBUFSZ[0] + I;#DATA-NAME BUFFER SIZE(WRD)# D2A131 
      ALLOCA (DBILENW+1) ;
      C<0,DBILENG>RQTDATANM30[ATTRPTR] = C<0,DBILENG>DBINAME30[0];
      RQTATTRLENG[ATTRPTR] = DBILENW + 1; # STORE ENTRY LENGTH.        #
      RQTDATALENC[ATTRPTR] = DBILENG; # STORE THE CHARACTER LENGTH.    #
      IF RQTATTRLENG[ATTRPTR] GR MAXSELENG THEN 
        MAXSELENG = RQTATTRLENG[ATTRPTR]; # SUB-ENTRY LENGTH GREATER   #
                                          # THAN PREVIOUS MAXIMUM.     #
      RQTSTACKTYPE[STACKPTR] = DATANME; # SET STACK ENTRY TYPE.        #
      RQTAREARANK[STACKPTR] = AREARANK; 
      RQTATRIBTEWA[STACKPTR] = LOC(ATTRBUF) - ABS(ATTRPTR); 
      RQTITEMPTR[STACKPTR] = RQTPTR - DBIADR; # STORE AN OFFSET POINTER#
                 # FROM THE FIRST WORD OF THE RQT ENTRY (HEADER) TO THE#
                 # FIRST WORD OF THE DBI LEFT OF THE OPERATOR.         #
      STACKPTR = STACKPTR + 1; # INCREMENT POINTER                     #
      SBITMRLDNFLG[DBIADR] = TRUE; # SET FLAG IN ITEM ENTRY THIS DATA- #
                                   # NAME IS ASSOCIATED WITH.          #
      STDNO;
  ENDSTACK:   #   # 
#**********************************************************************#
#                  E N D S T A C K                                     #
#                                                                      #
#    STORES THE ENDING DELEMITER IN THE STACK THAT IS PROCESSED BY     #
#    THE STACK PROCESSING ROUTINE. RETURN IS TO STDNO.                 #
#                                                                      #
#**********************************************************************#
      RQTSTACKTYPE[STACKPTR] = ENDDEL;
      STDNO;
  FINDREC:   #   #
#**********************************************************************#
#                  F I N D R E C                                       #
#                                                                      #
#    GETS THE ADDRESS OF THE FIRST RECORD ENTRY IN THE SUB-SCHEMA      #
#    (CONTROL WORD). A SCAN OF THE RECORD ENTRIES ARE MADE LOOKING FOR #
#    A MATCH OF RECORD NAME SPECIFIED IN THE RESTRICT CLAUSE. THE NEXT #
#    RECORD POINTER FIELD IS USED TO GET FROM ONE RECORD TO ANOTHER.   #
#    WHEN A MATCH IS FOUND, A CHECK IS MADE TO SEE IF A QUALIFIER WAS  #
#    SPECIFIED. IF SO, THE WORD ADDRESS OF THE OWNER REALM (WORD 2 ) IS#
#    READ AND THEN  COMPARED WITH THE QUALIFIER                        #
#    NAME. IF THEY DO NOT MATCH THE SCAN OF THE RECORD ENTRIES IS      #
#    RESUMED UNTIL ANOTHER MATCH IS FOUND OR THE RECORD ENTRIES HAVE   #
#    BEEN EXUSTED. IF NO MATCH WAS FOUND RETURN TO STDNO WHERE STD     #
#    ISSUES DIAGNOSTICS 406, ELSE RETURN IS TO STDYES.                 #
#                                                                      #
#**********************************************************************#
      M = 0;     # INITIALIZE RECORD COUNTER.                          #
      FOR RECPTR = SBCWFRSTRECA[0] STEP SBRECNXRECP[RECPTR] 
        WHILE M NQ SBCWNUMBERCS[0] DO 
        BEGIN 
          K = SBRECNMELENC[RECPTR]; 
          I = RECPTR; 
          M = M + 1;         #INCREMENT RECORD COUNT. # 
          IF C<0,K>SBRECNAME30[I+SBRECNAMEPTR[I]] NQ
                 C<0,RECLENG>RECNME30[0] THEN 
            # COMPARE THE RECORD NAME SPECIFIED IN THE RESTRICT CLAUSE #
            # WITH THE NAME IN THE RECORD ENTRY.                       #
              TEST RECPTR;   # MO MATCH, GET NEXT RECORD ENTRY.        #
          FIRSTDBI = RECPTR + SBRECNXITEMP[RECPTR]; # CALCULATE THE WRD#
                # ADDRESS OF THE FIRST DBI IN THE RECORD.              #
          REALMORD = SBARORDINAL[SBRECRLMADR[RECPTR]]; # GET THE OWNER #
                                  # REALM ORDINAL.                     #
          IF QALNUM EQ 0 THEN # CHECK IF THE RECORD NAME WAS QUALIFIED.#
            STDYES; 
          J = REALMORD * 4 - 4; # CALCULATE THE SCRATCH POINTER TO     #
                                # POINTER THE OWNER REALM ENTRY IN THE #
                                # REALM LIST.                          #
          IF QALNME30[0] NQ REALMLSTNM30[J] THEN # COMPARE THE         #
              TEST RECPTR;     # QAL NAME WITH THE REALM NAME IN THE   #
                               # REALM LIST.                           #
          INITQAL;     # INITIALIZE THE QUALIFIER BUFFERS AND CELLS.   #
          STDYES; 
        END 
      STDNO;
  FINDSBDBI:  
#**********************************************************************#
#                  F I N D S B D B I                                   #
#                                                                      #
#    SCANS THRU THE RECORD ENTRY SPECIFIED IN THE CURRENT RESTRICT     #
#    CLAUSE (USING THE NEXT ITEM LINKAGE) LOOKING FOR THE ENTRY OF THE #
#    CURRENT DBI. IF THE DBI IS NOT FOUND, RETURN IS TO STDNO WHERE STD#
#    ISSUES DIAGNOSTIC 409. ELSE RETURN IS TO STDYES.                  #
#                                                                      #
#**********************************************************************#
      M = 0; # INITIALIZE THE ITEM COUNTER.                            #
      FOR N = FIRSTDBI STEP SBITMNEXTP[N] 
        WHILE M LQ SBRECNBRITMS[RECPTR] DO
        BEGIN 
          M = M + 1;         # INCREMENT ITEM COUNTER.                 #
          K = SBITMNMELENC[N];
          IF C<0,K>SBITMNAME30[N+SBITMNAMEPTR[N]] NQ
                 C<0,DBILENG>DBINAME30[0] THEN
            TEST N; 
          IF QALNUM GR 0 THEN # CHECK FOR DBI QUALIFIERS.              #
            BEGIN 
              K = 0; # SCRATCH ITEM USED AS A POINTER INTO QALBUF.     #
              I = SBITMDOMADR[N];  # GET THE DOMINANT ADDRESS OF       #
                             # THE CURRENT DBI.                        #
              FOR J=0 STEP 1 UNTIL QALNUM - 1 DO # STEP THRU THE       #
                BEGIN                            # QALIFIER ENTRIES.   #
                  IF SBITMTYPE[I] EQ 3 THEN # CHECK IF QUALIFIER IS A  #
                    BEGIN    # RECORD ENTRY OR DBI ENTRY.              #
                      IF C<0,QALNMELENC[K]>QALNME30[K] NQ 
                      C<0,SBITMNMELENC[I]>SBITMNAME30[I+SBITMNAMEPTR[I]]
                          THEN TEST N;
                    END 
                   ELSE 
                    BEGIN 
                      IF C<0,QALNMELENC[K]>QALNME30[K] NQ 
                      C<0,SBRECNMELENC[I]>SBRECNAME30[I+SBRECNAMEPTR[I]]
                          THEN TEST N;
                    END 
                  I = SBITMDOMADR[I]; # GET THE NEXT DOMINANT ITEM.    #
                  K = K + QALNMELENW[K] + 1; # ADJUST POINTER TO THE   #
                                   # NEXT QUALIFIER ENTRY.             #
                  TEST J; 
                END 
              INITQAL; # INITIALIZE THE QUALIFIER BUFFER AND CELLS.    #
            END 
          DBIADR = N;        # STORE WORD ADDRESS OF DBI.              #
          STDYES; 
        END 
      IF STACKPTR LS 1 OR          # CHECK IF CURRENT DBI IS LEFT OF   #
          RQTSTACKTYPE[STACKPTR-1] NQ OPERATOR  # THE OPERATOR.        #
                 OR RQTOPCDE[STACKPTR-1] GR 6 THEN
                # ENT DBI IS LEFT  OF THE OPERATOR.                    #
          CBRDIAG(408,DBINME,DBILENG);
      STDNO;
  FINDSCDBI:  
#**********************************************************************#
#                  F I N D S C D B I                                   #
#                                                                      #
#    CALL THE SCHEMA DIRECTORY ACCESS ROUTINE DA$NMSC TO FETCH THE     #
#    SCHEMA DBI ENTRY THAT CORRESPONDS TO THE CURRENT DBI. IF NOT FOUND#
#    RETURN TO STDNO WHERE STD ISSUES DIAGNOSTIC 410. ELSE RETURN TO   #
#    STDYES.                                                           #
#                                                                      #
#**********************************************************************#
      IF SBITMALIASP[DBIADR] GR 0 THEN   # CHECK FOR ALIAS ITEM NAME.  #
        BEGIN 
          I = DBIADR + SBITMALIASP[DBIADR]; 
          K = SBITMALIASLW[DBIADR]; 
          C<0,K*10>DBINAME30[0] = C<0,K*10>SBITMALIAS30[I]; 
          DBILENG = SBITMALIASLC[DBIADR]; 
          DBILENW = K;
        END 
      DE$DISC(DITSC,SCRECADR,DBINME,DBILENW,BUFWRDS,DBIBUF);
      I = DAENTAD[0] - SCRECADR; # DETERMINE THAT THE DBI DOES NOT RE- #
      IF I GR 0 THEN # SIDE LOWER THAN THE CURRENT RECORD ADDRESS.     #
        BEGIN 
          IF DASTATE[0] GR 0 OR  # IF DASTATE GR 0 THE RECORD ENTRY    #
            DAENTAD[0] GR SCRECADR + RECLENGTH OR    # WAS NOT FOUND   #
              C<0,SCITMNAMLENC[0]>SCITMNAM30[SCITMNAMEPTR[0]] NQ#IN SCH#
                C<0,DBILENG>DBINAME30[0] THEN   # ALSO CHECK IF THE DBI#
                  BEGIN 
                   CBRDIAG(409,DBINME,DBILENG); 
                   STDNO; # ADDRESS IS OUT OF RANGE OF THE CURRENT     #
                END # RECORD. ALSO CHECK IF NAMES ARE THE SAME.        #
          ALLOCA (DFSCITMLG-1);    # ADJUST ATTRPTR TO START OF ENTRY  #
          FOR I = 1 STEP 1         # MOVE SCHEMA DBI                   #
            UNTIL DFSCITMLG - 2 
          DO
            RQTATTRWRD[ATTRPTR+I] = DBIWRD [I-1] ; # TO ATTRIB ENTRY.  #
          STDYES; 
        END 
      CBRDIAG(409,DBINME,DBILENG);
      STDNO;
  GETSCREC:   #   # 
#**********************************************************************#
#                  G E T S C R E C                                     #
#                                                                      #
#    CALL THE SCHEMA DIRECTORY ACCESS ROUTINE TO READ THE SCHEMA ENTRY #
#    OF THE CURRENT RESTRICTED RECORD INTO A SCRATCH BUFFER RETURN IS  #
#    TO STDNO.                                                         #
#                                                                      #
#**********************************************************************#
      IF SBRECALIASLW[RECPTR] GR 0 THEN  # CHECK FOR ALIAS RECORD NAME #
        BEGIN 
          I = SBRECALIASP[RECPTR] + RECPTR; #ADJUST POINTER TO SCH.NAME#
                                             # NAME.                   #
          K = SBRECALIASLC[RECPTR];          # LENGTH IN CHARACTERS.   #
          RECNAME[0] = 0; 
          RECNAME[1] = 0; 
          RECNAME[2] = 0; 
          C<0,K>RECNME30[0] = C<0,K>SBRECALIAS30[I]; #STORE SCHEMA NAME#
          RECLENW = SBRECALIASLW[RECPTR];  # LENGTH IN WORDSFOR CALL TO#
          RECLENG = K;                 # DIRECTORY ACCESS ROUTINES.    #
        END 
      DE$NMSC(DITSC,1,RECORDNAME,RECLENW,BUFWRDS,DBIBUF); 
      SCRECADR = DAENTAD[0];
      RECLENGTH = SCRECENTLEN[0];  # RECORD ENTRY LENGTH.              #
      STDNO;
  
  LOGICALOP:   # #
#**********************************************************************#
#                  L O G I C A L O P                                   #
#                                                                      #
#    CREATES BOTH THE OPERATOR ENTRY IN THE RQT AND RQT ATTRIBUTE TABLE#
#    . CURP1 CONTAINS THE OPERATOR CODE. THE ATTRIBUTE TABLE STARTS    #
#    WITH THE LAST WORD OF THE USES FIELD LENGTH (BOTTOM UP). RETURN   #
#    IS TO STDNO.                                                      #
#                                                                      #
#**********************************************************************#
      RQTSTACKTYPE[STACKPTR] = OPERATOR; # SET STACK ENTRY TYPE.       #
      RQTRECORDORD[STACKPTR] = SBRECORDINAL[RECPTR]; # STORE THE ORDIN-#
                             # AL NUMBER OF THE CURRENT RESTRICTED     #
                             # RECORD.                                 #
      RQTOPCDE[STACKPTR] = CURP1; # STORE THE OPERATOR CODE.           #
      RQTAREARANK[STACKPTR] = AREARANK; 
      IF CURP1 GR 10 THEN # CHECK IF OPERATOR IS A LEFT OR RIGHT PARN. #
        BEGIN 
          STACKPTR = STACKPTR + 1;
          STDNO;
          END 
      ALLOCA (1) ;           # ADVANCE ATTRIBUTE POINTER TO NEXT WORD. #
      RQTATRIBTEWA[STACKPTR] = LOC(ATTRBUF) - ABS(ATTRPTR); 
                                       # STORE THE WORD ADDRESS OF THE #
                             # ATTRIBUTE ENTRY. THIS WILL LATER BE     #
                             # CONVERTED TO AN OFFSET POINTER          #
      RQTATTRLENG[ATTRPTR] = 1; # STORE THE LENGTH IN WORDS OF THE     #
                             # ATTRIBUTE ENTRY.                        #
      RQTOPERCODE[ATTRPTR] = CURP1; # STORE OPERATOR CODE              #
      STACKPTR = STACKPTR + 1; # INCREMENT POINTER TO THE NEXT AVAILABL#
                               # ENTRY.                                #
      STDNO;
  
  L66DBI:   #   # 
#**********************************************************************#
#                  L 6 6 D B I                                         #
#                                                                      #
#    CHECKS TO SEE IF THE CURRENT QUALIFIER ITEM ENTRY IS A LEVEL 66,  #
#    88 OR A REDEFINES ITEM. IF SO RETURN IS TO STDNO WHERE STD ISSUES #
#    DIAGNOSTIC 425. ELSE RETURN IS TO STDYES.                         #
#                                                                      #
#**********************************************************************#
      IF SBITMLEVEL[DBIADR] GR O"61" OR    # CHECK IF LEVEL 66, 88 OR  #
        SBITMRNRDPTR[DBIADR] GR 0 THEN     # REDEFINES.                #
          STDNO;
      STDYES; 
  
  NORQT:  #  #
#**********************************************************************#
#                  N O R Q T                                           #
#                                                                      #
#    THERE IS NO RESTRICT FOR THE CURRENT RELATION. THEREFORE THE VALUE#
#    IN RQT POINTER IS STORED INTO THE NEXT RST POINTER. THE RQT POINT-#
#    ER IS ZEROED OUT AND RSTPTR IS INCREMENTED TO POINT TO THE NEXT   #
#    RST ENTRY. RETURN IS TO STDNO.                                    #
#                                                                      #
#**********************************************************************#
      REALMENTRYLG[REALMLISTPTR] = RSTRQTPTR[RSTPTR]; # STORE THE LENG #
                 # IN WORDS OF THE RST ENTRY INTO THE REALM LIST.      #
      RSTRQTPTR[RSTPTR] = 0; # SINCE THERE IS NO RQT, ZERO OUT POINTER #
                             # TO RQT THAT WAS SET IN RELRSTR.         #
      STDNO;
  
  QALNME:    #  # 
#**********************************************************************#
#                  Q A L N M E                                         #
#                                                                      #
#    STORES THE QUALIFIER NAME INTO QUALBUF ALONG WITH ITS LENGTH IN   #
#    WORDS AND CHARACTERS. RETURN IS TO STDNO.                         #
#                                                                      #
#**********************************************************************#
      QALNUM = QALNUM + 1; # INCRMEENT QUALIFIER COUNTER.              #
      QALNMELENW[QALPTR] = CURLENW; # STORE LENGTH IN WORDS            #
      QALNMELENC[QALPTR] = CURLENG; # STORE LENGTH IN CHARACTERS.      #
      C<0,CURLENG>QALNME30[QALPTR] = CURWRD30[0]; 
      QALPTR = QALPTR + CURLENW + 1; # INCREMENT POINTER TO THE FIRST  #
      STDNO;                         # AVAILABLE WORD.                 #
  
  RELNAME:   #   #
#**********************************************************************#
#                  R E L N A M E                                       #
#                                                                      #
#    SCANS THE REALM LIST FOR AN ENTRY THAT MATCHES THE SUBJECT        #
#    RELATION NAME. IF A MATCH IS FOUND RETURN IS TO STDNO WHERE STD   #
#    ISSUES DIAGNOSTIC 402. IF NO MATCH WAS FOUND THE RELATION NAME IS #
#    ADDED TO THE REALM LIST AND RETURN IS TO STDYES.                  #
#**********************************************************************#
  
 #    CHECK IF THIS IS THE FIRST RST ENTRY IN THE SUB-SCHEMA.          #
  
      IF RSTPTR GR 0
      THEN
        BEGIN 
  
#       STORE THE FIRST WORD ADDRESS OF THE CURRENT RST ENTRY INTO     #
#       THE "NEXT RST POINTER" FIELD OF THE PRIOR RST ENTRY.           #
  
        RSTNXTRSTPTR[RSTPTR] = WBPTR - RSTPTR;
        END 
      RSTPTR = WBPTR; 
  
#     TEST IF THE LAST ENTRY IN THE REALM LIST IS ALREADY USED.        #
  
      I = (REALMSZ -4) /4 *4; 
      IF REALMLISTNME[I] NQ 0 
      THEN
        BEGIN                # MUST NOW EXPAND THE REALM LIST          #
        ALLOCW(RLMINCR);     # A DUMMY EXPANSION OF CBWORKBUF          #
        WBPTR = WBPTR - RLMINCR;  # REDUCE IT AGAIN                    #
  
#       MOVE THE CBWORKBUF INTO THE SPACE THAT WAS PROVIDED BY ITS     #
#       DUMMY EXPANSION.                                               #
  
        FOR I = WBPTR STEP -1 UNTIL 0 
        DO
          BEGIN 
          BUFWORD[I + RLMINCR] = BUFWORD[I];
          END 
        SBSCHMA = SBSCHMA + RLMINCR;
        P<CBWORKBUF> = SBSCHMA; 
  
#       CLEAR THE REALM LIST EXTENSION AREA.                           #
  
        FOR I = REALMSZ + RLMINCR -1 STEP -1 UNTIL REALMSZ
        DO
          BEGIN 
          REALMLISTNME[I] = 0;
          END 
        REALMSZ = REALMSZ + RLMINCR;
        END 
  
#     SEARCH EACH ENTRY OF THE REALM LIST FOR A MATCH                  #
#     WITH THE RELATION NAME.                                          #
  
      FOR I=0 STEP 4 WHILE REALMLISTNME[I] NQ 0 
      DO
        BEGIN 
        IF REALMLSTNM30[I] EQ CURWRD30[0] 
        THEN                 # THE RELATION NAME IS ALREADY IN USE     #
          BEGIN 
          STDNO;
  
          END 
        END 
  
#     STORE THE RELATION NAME INTO THE REALM LIST.                     #
  
      REALMLSTNM30[I] = CURWRD30[0];
  
#     STORE THE WORD ADDRESS OF THE RELATION ENTRY.                    #
  
      RELATIONADR[I] = RSTPTR;
  
      REALMLISTPTR = I; 
      STDYES; 
  
  RELRQT:  #  # 
#**********************************************************************#
#                  R E L R Q T                                         #
#                                                                      #
#    CREATES THE HEADER WORD IN THE RQT ENTRY. RETURN IS TO STDNO.     #
#**********************************************************************#
      RQTPTR = WBPTR; # SET THE RQT PTR TO THE FIRST RQT ENTRY IN THE  #
                      # RELATION.                                      #
      RQTENTRYTYPE[RQTPTR] = 5; # ENTRY TYPE.                          #
      ALLOCW (1) ;              # ALLOCATE HEADER WORD.                #
      RQTORDINAL[RQTPTR] = RSTORDINAL - 1;
      STDNO;
  RELRST:   #   # 
#**********************************************************************#
#                  R E L R S T                                         #
#                                                                      #
#    CALLS THE SCHEMA DIRECTORY ACCESS ROUTINE DA$NMSC TO FETCH THE    #
#    RELATION ENTRY IN THE SCHEMA THAT CORRESPONDS TO THE CURRENT      #
#    RELATION NAME. IF NOT FOUND IN THE SCHEMA (DASTATE = 1) THEN      #
#    RETURN TO STDNO WHERE STD ISSUES DIAGNOSTIC 403. ELSE RETURN IS TO#
#    STDYES.                                                           #
#**********************************************************************#
      P<RSTBUF> = LOC(CBWORKBUF) + WBPTR; # POINT BASED ARRAY TO THE   #
            # FIRST AVAILABLE WORD IN THE SUB-SCHEMA IN CORE.          #
      DE$NMSC(DITSC,3,CWORD,CURLENW,1,RSTBUF); # READ IN RELATION ENTRY#
                                               # HEADER WORD.          #
      I = 2 + SCRELNAMLENW[0]+(SCRELMAXRANK[0]-2)*4+4; # LENGTH OF RST.#
      ALLOCW (I) ;              # MAKE ROOM FOR RST BUT                #
      WBPTR = WBPTR - I ;       # DO NOT ADVANCE WBPTR.                #
      DE$NMSC(DITSC,3,CWORD,CURLENW,I,RSTBUF); # GET THE CORRESP-      #
                 # ONDING RELATION ENTRY IN THE SCHEMA.                #
      IF DASTATE[0] GR 0 THEN # CHECK IF THE RELATION ENTRY WAS FOUND. #
        STDNO; # WAS NOT FOUND, ERROR.                                 #
      P<RSTBUF> = LOC(CBWORKBUF); # RE-ADJUST THE LOC OF RSTBUF SO     #
                 # RSTBUF AND CBWORKBUF CAN BE REFERENCED BY THE SAME  #
                 # POINTER.                                            #
      STDYES; 
  RELRSTAR:  #   #
#**********************************************************************#
#                                                                      #
#                  R E L R S T A R                                     #
#                                                                      #
#    CONVERTS THE SCHEMA AREA WORD ADDRESS STORED IN THE RST TABLE TO  #
#    THE SUB-SCHEMA REALM WORD ADDRESS. ALSO STORES THE ORDINAL NUMBER #
#    OF THE SUBJECT REALM INTO THE RST TABLE. THIS IS DONE BY CALLING  #
#    READSC USING THE ORIGINAL WORD ADDRESS STORED IN THE RST TABLE.   #
#    READSC WILL FETCH THE SCHEMA AREA ENTRY AND STORE IT INTO A       #
#    SCRATCH BUFFER. A SEQUENTIAL SEARCH OF THE REALMS IS MADE LOOK-   #
#    ING FOR MATCH WITH THE AREA NAME OF THE SCHEMA ENTRY STORED IN THE#
#    SCRATCH BUFFER. IF THE AREA NAME CANNOT BE FOUND IN THE SUB-SCHEMA#
#    DIAGNOSTIC 404 WILL BE ISSUED. RETURN IS TO STDNO                 #
#    NOTES - 1. OFFSET POINTER IS RELATION NAME SIZE IN WORDS PLUS 1.  #
#            2.  NUMBER OF AREA ENTRIES IN THE RST TABLE IS THE MAXIMUM#
#               RANK IN A RELATION.                                    #
#**********************************************************************#
      IF SCRELMAXRANK[RSTPTR] GR HIGHESTRANK THEN # CHECK IF THE HIGH- #
        HIGHESTRANK = SCRELMAXRANK[RSTPTR]; # EST RANK SPECIFIED IN    #
                 # THE CURRENT RELATION ENTRY IS GREATER THEN THE      #
                 # PREVIOUS RELATION ENTRY.                            #
      NBRDBIS = SCRELMAXRANK[RSTPTR] *2 - 2; # CALCULATE THE NUMBER OF #
                             # DBIS SPECIFIED IN THE CURRENT RELATION. #
      WBPTR = SCRELNAMLENW[RSTPTR] + RSTHEADER + WBPTR;#SET DBI POINTER#
                       # TO THE FIRST JOIN DBI IN THE RST TABLE.       #
      FOR M=1 STEP 1 UNTIL NBRDBIS DO    # STEP THRU THE JOIN          #
        BEGIN  #DBI ENTRIES REPLACING SCHEMA AREA ADDRESS WITH THE     #
               # SUB-SCHEMA REALM ORDINAL AND ADDING THE SUB-SCHEMA    #
               # WORD ADDRESS TO THE SECOND WORD OF THE ENTRY.         #
          REALMPTR = SBCWFRSTAREA[0];  # GET ADDR OF THE 1ST REALM     #
          READSC(DBIBUF,BUFWRDS,SCRLDBIARPTR[WBPTR]);#READ AREA ENTRY. #
          FOR I=0 STEP 1 UNTIL SBCWNUMAREAS[0] - 1 DO # STEP THRU THE  #
            BEGIN # REALM ENTRIES.                                     #
              IF SBARALIASLW[REALMPTR] GR 0 THEN # CHECK FOR ALIAS     #
                K = REALMPTR + SBARALIASPTR[REALMPTR]; #NAME. IF SO    #
              ELSE                 # ADJUST POINTER TO ALIAS NAME.     #
                K = REALMPTR + SBARNAMEPTR[REALMPTR]; 
              FOR J=0 STEP 1 UNTIL SCHAREANAMEL[0] - 1 DO # COMPARE    #
                 # SCHEMA AREA NAME IN THE SCRATCHER WITH THE REALM    #
                 # NAME IN THE SUB-SCHEMA IN CORE                      #
                IF SCHAREANAME[SCARNAMEPTR[0]+J] NQ SBARNAME[K+J] THEN
                  BEGIN 
                    REALMPTR = SBARNEXT[REALMPTR];
                    TEST I; 
                  END 
              IF M EQ 1 THEN                                             D2162G 
                BEGIN        # FIRST AREA IN RST                       # D2162G 
                  K = 0;   N = 1;    # INITIALIZE                      # D2162G 
                  J = SBARDCONTRLA[REALMPTR]; #ADR OF DATA CONTROL ENT.# D2162G 
                  J = J + SBDCALTRKYPT[J]; # ADDR OF FIRST KEY ENTRY   # D2162G 
                  FOR J = J STEP SBDCKEYNITM[J+1] WHILE N NQ 0 DO        D2162G 
                    BEGIN    # LOOP THRU KEY ENTRIES                   # D2162G 
                      IF SBDCKEYSIZ[J+1] GR K THEN                       D2162G 
                        K = SBDCKEYSIZ[J+1];   # MAXIMUM KEY SIZE      # D2162G 
                      IF SBDCKEYNITM[J+1] EQ 0 THEN                      D2162G 
                        N = 0;     #LAST KEY ITEM-FORCE EXIT FROM LOOP # D2162G 
                    END                                                  D2162G 
                  RSTMAXKEYLG[WBPTR] = K;  # STORE KEY LENGTH IN RST   # D2162G 
                END                                                      D2162G 
              RSTAREAORD[WBPTR] = SBARORDINAL[REALMPTR]; # STORE THE   #
                 # ORDINAL NUMBER OF THE REALM ENTRY.                  #
              RSTAREAADR[WBPTR] = REALMPTR; # STORE THE WORD ADDRESS OF#
                                   # THE REALM ENTRY.                  #
              RSTNOMAPIND[WBPTR] = SBARNOMAPIND[REALMPTR];
              RSTSEQOPT[WBPTR] = SBDCSEQOPT[SBARDCONTRLA[REALMPTR]];
               IF TARGET THEN      # CHECK IF CURRENT DBI IS A TARGET  #
                BEGIN              # DBI.                              #
                IF RSTKEYIND[WBPTR] LQ 3 THEN 
               BEGIN
                IF RSTITEMSIZE[WBPTR] GR LARGESTDBI THEN # CONTROL WORD#
                  LARGESTDBI = RSTITEMSIZE[WBPTR]; # THAT CONTAINS THE #
                             # SIZE IN WORDS OF THE LARGEST DBI SPECIF-#
                             # IED IN THE RST TABLE, LARGESTDBI CONTAIN#
                             # S THE LARGEST DBI.                      #
                DBI3CNTR = DBI3CNTR + 1;   # COUNTER FOR DBI WHOSE KEY #
                             # INDICATOR IS 3 OR LESS.                 #
               END
                END 
              WBPTR = WBPTR + 2; # INCREMENT POINTER TO THE NEXT JOIN  #
                                 # ENTRY.                              #
              TARGET = NOT TARGET;
              TEST M; 
            END 
          J = SCARNAMEPTR[0];      # OFFSET POINTER TO AREA NAME       #
          CBRDIAG(404,SCHAREANAM30[J],SCHAREANAMEC[0]); #COULD NOT FIND#
                             # THE SCHEMA AREA NAME IN THE SUB-SCHEMA. #
            WBPTR = WBPTR + 2;
        END 
      RSTENTRYTYPE[RSTPTR] = 4; # SET ENTRY TYPE.                      #
      RSTRELORD[RSTPTR] = RSTORDINAL; # STORE RST ORDINAL.             #
      IF RSTORDINAL EQ MAXRELNS + 1 THEN
        CBRDIAG( 441 );      # MAXIMUM RELATION COUNT EXCEEDED.        #
      RSTORDINAL = RSTORDINAL + 1;
      IF RSTHIGHRANK[RSTPTR] GR MAXRELRANK THEN  # THERE IS A FIELD    #
       MAXRELRANK = RSTHIGHRANK[RSTPTR]; # IN THE CONTROL WORDS THAT   #
                 # CONTAINS THE HIGHEST RANK SPECIFIED IN THE RELATION #
                 # DIVISION. MAXRELRANK ALWAYS CONTAINS THE HIGHEST    #
                 # RANK ENCOUNTERED.                                   #
      RSTRQTPTR[RSTPTR] = WBPTR - RSTPTR; # SET THE OFFSET POINTER     #
                                              # TO THE FIRST RQT ENTRY.#
      STDNO;
  RELTERM:   #   #
#**********************************************************************#
#**********************************************************************#
      SBCWNUMRELS[0] = RSTORDINAL - 1; # STORE THE TOTAL NUMBER OF     #
                 # RELATION ENTRIES SPECIFIED IN THE SUB-SCHEMA.       #
      SBCWSBLENG[0] = WBPTR; # STORE THE NEW SUB-SCHEMA LENGTH.        #
      SBCWMAXRANK[0] = HIGHESTRANK; 
      SBCWLARGRQT[0] = LARGESTRQT;
      SBCWMAXJDBI3[0] = LARGESTDBI; 
      SBCWKEYIND3[0] = DBI3CNTR;
      RSTNXTRSTPTR[RSTPTR] = 0; # NO MORE ENTRIES, ZERO OUT NEXT PTR.  #
      K = ((P<CBWORKBUF> + WBPTR + ABS(ATTRPTR) + 63) / 64) * 64 ;
      IF K GR DDLSU THEN
        DDLSU = K ; 
      CBOVLP4;  # LOAD THE SUB-SCHEMA LIBRARY OVERLAY.                 #
  RESTRDBI:   #   # 
#**********************************************************************#
#                 R E S T R D B I                                      #
#                                                                      #
#    STORES THE DBI NAME INTO A TEMPORARY BUFFER WHICH IS LATER TO BE  #
#    USED IN A SEQUENTIAL SEARCH OF THE RESTRICTED RECORD FOR A MATCH. #
#    RETURN IS TO STDNO.                                               #
#                                                                      #
#**********************************************************************#
      DBINAME30[0] = CURWRD30[0]; 
      DBILENG = CURLENG;
      DBILENW = CURLENW;
      STDNO;
  RESTREND:   #   # 
#**********************************************************************#
#                  R E S T R E N D                                     #
#                                                                      #
#    ZEROES OUT THE VARIOUS ARRAYS USED WHEN PROCESSING THE RESTRICT   #
#    CLAUSE. RETURN IS TO STDNO.                                       #
#                                                                      #
#**********************************************************************#
      RQTHIGHRANK[RQTPTR] = HIRQTRNK; 
      HIRQTRNK = 0; 
      I = WBPTR - RQTPTR; # CALCULATE THE LENGTH OF THE CURRENT RQT ENT#
                 # COMPLETE RQT ENTRY.                                 #
      RQTTBLLENG[RQTPTR] = I;              # STORE THE LENGTH OF THE   #
      IF I GR LARGESTRQT THEN # CHECK IF LARGEST DBI ENCOUNTERED. IFSO #
        LARGESTRQT = I; # STORE LENGTH. LARGESTRQT WILL ALL WAYS CONT- #
                 # AIN THE LARGEST RQT ENTRY. THIS VALUE WILL LATER BE #
                 # STORED INTO THE CONTROL WORDS.                      #
      FOR I=0 STEP 1 UNTIL 63 DO # ZERO OUT THE RANK LIST.             #
        RANKFLAG[I] = FALSE;
      FOR I=0 STEP 1 UNTIL STACKPTR DO # ZERO OUT THE RQT STACK BUFFER.#
        RQTSTACKWD[I] = 0;
      STACKPTR = 0; 
      STDNO;
  RESTRREC:   #   # 
#**********************************************************************#
#                  R E S T R R E C                                     #
#                                                                      #
#    STORES THE RECORD NAME INTO A TEMPORARY BUFFER LATER TO BE USED   #
#    IN A SEARCH OF THE RECORD ENTRIES FOR A MATCH. RETURN IS TO STDNO.#
#                                                                      #
#**********************************************************************#
      RECNME30[0] = CURWRD30[0];
      RECLENG = CURLENG;
      RECLENW = CURLENW;
      STDNO;
  RQTATTR:   #   #
#**********************************************************************#
#                  R Q T A T T R                                       #
#                                                                      #
#     WHEN THE STACK ENTRIES WHERE BUILT, THE CORRESPONDING ATTRIBUTE  #
#     ENTRIES WHERE BUILT IN A BOTTOM UP FASHION STARTING WITH THE LAST#
#     WORD OF THE USERS FIELDLENGTH. THE STACK ENTRY CONTAINED THE WORD#
#     ADDRESS OF THE CORRESPONDING ATTRIBUTE ENTRY. THIS SEMANTIC      #
#     ROUTINE MOVES THE ATTRIBUTE ENTRIES FROM THE BOTTOM OF CORE TO   #
#     THE FIRST AVAILABLE WORD AFTER THE LAST STACK ENTRY (ONE RANK)   #
#     IN SBWORKBUF. IT THEN CONVERTS THE WORD ADDRESS OF THE ATTRIBUTE #
#     ENTRY IN THE STACK ENTRY TO AN OFFSET POINTER FROM THE RQT HEADER#
#     RETURN IS TO STDNO.                                              #
#                                                                      #
#**********************************************************************#
      I = (LASTWRD - ABS(ATTRPTR) - WBPTR); # CALC THE GAP BETWEEN THE #
          # NEXT AVAILABLE WORD IN CBWORKBUF AND THE FIRST WORD OF THE #
          # LAST ATTRIBUTE ENTRY.                                      #
      FOR J=RQTPTR+1 STEP 1 UNTIL WBPTR - 1 DO
        RQTATTRIBPTR[J] = (RQTATTRIBPTR[J] - I) - RQTPTR; # RE-ADJ THE #
          # WORD ADDRESS OF THE CORRESPONDING ATTRIBUTE ENTRY TO THE   #
          # OFFSET POINTER TO THE ATTRIBUTE ENTRY WITHIN THE SUB-SCHEMA#
      FOR J=0 STEP 1 UNTIL ABS(ATTRPTR) - 1 DO
        BEGIN 
          RQTWORD[WBPTR+J] = RQTATTRWRD[ATTRPTR+J];# MOVE THE ATTRIBUTE#
                 # ENTRIES FROM THE END OF CORE INTO THE SUB-SCHEMA.   #
          RQTATTRWRD[ATTRPTR+J] = 0; # RE-INITIALIZE RQT ATTRIBUTE STOR#
        END 
      RQTATTRIBPTR[RQTPTR] = WBPTR - RQTPTR; # STORE OFFSET POINTER    #
                 # TO THE FISST ATTRIBUTE ENTRY INTO THE RQT HEADER WRD#
      WBPTR = WBPTR + ABS (ATTRPTR) ; 
      ATTRPTR = 0 ; 
      STDNO;
  RQTDBI: 
#**********************************************************************#
#                  R Q T D B I                                         #
#                                                                      #
#    BUILDS THE STACK ENTRY IN THE RQT TABLE FOR DBI"S. RETURN IS TO   #
#    STDNO.                                                            #
#                                                                      #
#**********************************************************************#
      IF SBITMIDNTICL[DBIADR] THEN # CHECK IF MAPPING IS NEEDED FOR DBI#
        RQTSTACKTYPE[STACKPTR] = DBINOMAP;
       ELSE 
        RQTSTACKTYPE[STACKPTR] = DBIMAP;
      RQTAREARANK[STACKPTR] = AREARANK; 
      RQTATRIBTEWA[STACKPTR] = LOC(ATTRBUF) - ABS(ATTRPTR); 
      RQTITEMORD[STACKPTR] = SBITMORDINAL[DBIADR];
      STACKPTR = STACKPTR + 1;
      STDNO;
  RQTDBILFT:   #   #
#**********************************************************************#
#                  R Q T D B I L F T                                   #
#                                                                      #
#    STORES THE LENGTH OF THE ATTRIBUTE ENTRY INTO THE FIRST WORD OF   #
#    ENTRY. SAVES THE POINTER TO THE SUBJECT ATTRIBUTE ENTRY. THIS     #
#    POINTER IS LATER USED WHEN COMPARING AND VALIDATING THE ENTRY     #
#    RIGHT OF THE OPERATOR WITH THE ENTRY LEFT OF THE OPERATOR (THIS   #
#    ONE). ALSO ADVANCES THE ATTRIBUTE POINTER TO THE NEXT AVAILABLE   #
#    WORD. RETURN IS TO STDNO.                                         #
#                                                                      #
#**********************************************************************#
      RQTATTRLENG[ATTRPTR] = DFSCITMLG - 1;  # LENGTH OF ATTR ENTRY    #
      DBILFTPTR = ATTRPTR; # SAVE THE POINTER TO THE DBI LEFT OF THE   #
                          # OPERATOR.                                  #
      IF RQTATTRLENG[ATTRPTR] GR MAXSELENG THEN 
        MAXSELENG = RQTATTRLENG[ATTRPTR]; # SUB-ENTRY LENGTH GREATER   #
                                          # THAN PREVIOUS MAXIMUM.     #
      STDNO;
  RQTDBIRT: 
#**********************************************************************#
#                  R Q T D B I R T                                     #
#                                                                      #
#    STORES THE LENGTH OF THE ATTRIBUTE ENTRY INTO THE FIRST WORD OF   #
#    THE ENTRY. ADVANCES THE ATTRIBUTE POINTER TO THE NEXT AVAILABLE   #
#    WORD RETURN IS TO STDNO.                                          #
#                                                                      #
#**********************************************************************#
      RQTATTRLENG[ATTRPTR] = DFSCITMLG - 1;  # LENGTH OF ATTR ENTRY    #
      IF RQTATTRLENG[ATTRPTR] GR MAXSELENG THEN 
        MAXSELENG = RQTATTRLENG[ATTRPTR]; # SUB-ENTRY LENGTH GREATER   #
                                          # THAN PREVIOUS MAXIMUM.     #
      STDNO;
  RQTLIT:   #   # 
#**********************************************************************#
#                  R Q T L I T                                         #
#                                                                      #
#    BUILDS THE ATTRIBUTE ENTRY FOR A LITERAL. THE LITERAL IS STORED IN#
#  - LITBUF, CONVERTED TO THE DATA TYPE OF THE SOURCE DBI. LITLENG     #
#  - CONTAINS THE LENGTH OF THE LITERAL IN WORDS. RETURN IS TO STDNO.  #
#                                                                      #
#**********************************************************************#
      RQTSTACKTYPE[STACKPTR] = LITERAL; # SET STACK ENTRY TYPE.        #
      RQTAREARANK[STACKPTR] = AREARANK; 
      ALLOCA (LITLENG+1) ;             # ALLOCATE LITERAL + HEADER WORD#
      FOR I=0 STEP 1 UNTIL LITLENG - 1 DO # STORE LITERAL INTO ATTRIBUT#
        RQTLITWRD[ATTRPTR+I] = LITWRD[I]; # ENTRY.                     #
      RQTATTRLENG[ATTRPTR] = LITLENG + 1; # STORE THE LENGTH OF THE    #
                   # IN WORDS PLUS THE HEADER WORD.                    #
      RQTATRIBTEWA[STACKPTR] = LOC(ATTRBUF) - ABS(ATTRPTR); 
                                           # STORE THE WORD ADDRESS OF #
                 # THE ATTRIBUTE ENTRY. THIS WILL LATER BE CONVERTED   #
                 # TO AN OFFSET POINTER.                               #
      STACKPTR = STACKPTR + 1; # INCREMENT STACK POINTER TO THE NEXT   #
                               # AVAILABLE WORD.                       #
      IF RQTATTRLENG[ATTRPTR] GR MAXSELENG THEN 
        MAXSELENG = RQTATTRLENG[ATTRPTR]; # SUB-ENTRY LENGTH GREATER   #
                                          # THAN PREVIOUS MAXIMUM.     #
      STDNO;
  RQTNOTATION:   # . #
#**********************************************************************#
#                  R Q T N O T A T I O N                               #
#                                                                      #
#    THIS ROUTINE BUILDS THE RQT STACK ENTRIES IN THE SUB-SCHEMA (IN   #
#    POLISH NOTATION). WHEN PROCESSING THE QUALIFICATION CLAUSES, THE  #
#    STACK ENTRIES ARE INITIALLY BUILD IN AN ARRAY CALLED RQTSTACK.    #
#    THE ORDER OF THESE NEED NOT TO BE IN RANK ORDER AND ARE NOT IN    #
#    POLISH NOTATION. A LIST OF THE RANKS INVOLVED IN THE QUALIFICAT-  #
#    ION CLAUSES IS ALSO BUILT (RANKLIST). RANKLIST IS A 65 WORD ARRAY.#
#    EACH WORD IN THE ARRAY CORRESPONDS TO A SCHEMA AREA RANK NUMBER.  #
#    THE FIRST BIT IN A WORD IN RANKLIST IS SET IF THERE IS A CORRESP- #
#    ONDING RANKNUMBER.                                                #
#                                                                      #
#    RQTNOTATION SCANS RANKLIST LOOKING FOR THE FIRST RANKFLAG. WHEN   #
#    FOUND, RQTSTACK TABLE IS SCANED LOOKING FOR A MATCH ON RANK NUMBER#
#    WHEN THE MATCH IS FOUND, A ONE WORD ENTRY (QIN TABLE) IS BUILT    #
#    FOR EACH STACK OPERATOR ENTRY WITH THE SAME RANK NUMBER. IF THE   #
#    OPERATOR IS A RELATIONAL OPER, THE QIN ENTRY CONTAINS POINTER TO  #
#    THE SOURCE DBI, TARGET AND OPERATOR ENTRIES IN RQTSTACK. IF THE   #
#    OPERATOR IS A LOGICAL OPERATORR, THE QIN ENTRY CONTAINS THE POINTE#
#    TO THE OPERATOR ENTRY IN RQTSTACK. ALL THE QIN ENTRIES CONTAIN THE#
#    OPERATOR CODE. BUILDING THE QIN ENTRIES STOP WHEN THE RANK NUMBERS#
#    CHANGE IN RQTSTACK. A TERMINATING DELIMITER IS THEN STORED IN THE #
#    QIN TABLE INDICATING THE LAST ENTRY. CBPOLISH IS CALLED TO        #
#    RE-ARANGE THE QIN ENTRIES IN POLISH NOTATION. IF CBERROR ENCOUNT- #
#    ERED AN ERROR, IT STORES THE ROTSTACK POINTER OF THE OPERATOR IN  #
#    ERROR INTO THE CELL "ERRCODE".                                    #
#                                                                      #
#    RQTNOTATION CHECKS TO SEE IF ERRCODE IS NON-ZERO. IF SO IT USES   #
#    THE VALUE IN ERRCODE AS AN INDEX INTO RQTSTACK TO FETCH THE SOURCE#
#    LINE NUMBER OF THE OPERATOR IN ERROR. CBRDIAG IS CALLED TO ISSUE  #
#    DIAGNOSTIC 414. THE PROCEDURE INITQIN IS CALLED TO RE-INITIALIZE  #
#    THE QIM TABLE AND RELATIVE CELLS. THIS WHERE CLAUSE IS IGNORED.   #
#                                                                      #
#    IF ERRCODE IS ZERO, CBPOLISH RETURNS THE QIN ENTRIES IN POLISH    #
#    NOTATION IN THE ARRAY QOPS. THE RQT STACK ENTRIES ARE THEN BUILD  #
#    IN THE SUB-SCHEMA BY USING THE OPERATOR, SOURCE AND TARGET POINTER#
#    S TO THE RQT STACK ENTRIES STORED IN THE OPERATOR ENTRIES IN QOPS.#
#    RETURN IS TO STDNO.                                               #
#                                                                      #
#**********************************************************************#
      K = 0; # INITIALIZE PARN COUNTER.                                #
      FOR AREARANK=1 STEP 1 UNTIL 63 DO  # STEP THRU THE RANK LIST     #
        BEGIN                            # LOOKING FOR THE RANK NUMBERS#
          IF NOT RANKFLAG[AREARANK] THEN # OF THE SCHEMA AREAS INVOLVED#
            TEST AREARANK;               # IN THE RESTRICT CLAUSE.     #
          FOR J=0 STEP 1 UNTIL STACKPTR - 1 DO  # SCAN THRU THE STACK  #
            BEGIN  # ENTRIES LOOKING FOR A MATCH OF THE SCHEMA AREA    #
                   # RANK FOUND IN THE PREVIOUS FOR LOOP.              #
              IF RQTAREARANK[J] NQ AREARANK THEN
                TEST J; 
              M = J; # SAVE THE POINTER TO THE FIRST STACK ENTRY OF A  #
                     # RANK.                                           #
    CONTBLDQIN:   # # 
              IF RQTSTACKTYPE[J] EQ OPERATOR THEN # CHECK FOR LOGICAL  #
                BEGIN                    # OPERATOR. IF SO, THEREWILL  #
                                         # BE NO SOURCE OR TARGET DBIS.#
                  QINOPCDE[QINPTR] = RQTOPCDE[J]; # STORE THE LOGICAL  #
                  QINOPPTR[QINPTR] = J; 
                  IF RQTOPCDE[J] GR 10 THEN # CHECK IF THE OPERATOR    #
                      # IS A RIGHT OR LEFT PARAN. IF SO ADD ITS        #
                      # OCCURENCE TO A COUNTER.                        #
                    K = K + 1;
                  QINPTR = QINPTR + 1;  # OPERATOR CODE.               #
                  J = J + 1;
                END 
               ELSE 
                BEGIN 
                  QINSRCDBI[QINPTR] = J; # STORE THE STACK LOCATION OF #
                                         # THE SOURCE DBI,   TARGET    #
                                         # ENTRY AND RELATIONAL OPERAT-#
                                         # OR CODE AND POINTER.        #
                  QINTARDBI[QINPTR] = J + 2;
                  QINOPPTR[QINPTR] = J + 1; 
                  QINOPCDE[QINPTR] = RQTOPCDE[J+1]; 
                  J = J + 3;
                  QINPTR = QINPTR + 1;
                END 
              IF RQTAREARANK[J] EQ AREARANK THEN # CHECK IF MORE STACK #
                GOTO CONTBLDQIN;  # ENTRIES FOR THE CURRENT RANK BEING #
                                  # PROCESSED.                         #
              QINOPCDE[QINPTR] = ENDDEL; # NO MORE ENTRIES FOR CURRENT #
                     # RANK, SET END DELIMTER FOR THE QIN TABLE.       #
              CBPOLSH;        # CALL THE ROUTINE THAT ARRANGES THE QIN #
                 # ENTRIES INTO POLISH NOTATION. THE REORDERED STACK   #
                 # IS RETURNED IN QIN.                                 #
              FOR I = M STEP 1 WHILE RQTSTACKTYPE[I] GR 2 DO
                TEST I; 
              RQTSTACKLEN[I] = J - M - K; 
              IF RQTSTACKLEN[I] GR MAXSELENG THEN 
                MAXSELENG = RQTSTACKLEN[I]; # SUB-ENTRY LENGTH GREATER #
                                            # THAN PREVIOUS MAXIMUM.   #
              K = 0;
              FOR QINPTR=0 STEP 1 WHILE QINOPCDE[QINPTR] NQ 13 DO 
                BEGIN # STEP THRU THE QIN  TABLE GETING THE POINTERS   #
                      # OF THE SOURCE, TARGET DBIS AND OPERATORS, AND  #
                      # MOVING THEM FROM THE ORIGINAL STACT BUFFER TO  #
                      # THE RQT ENTRY IN THE SUB-SCHEMA.               #
                  IF QINOPCDE[QINPTR] LS 7 THEN # CHECK FOR RELATION-  #
                    BEGIN  # AL OPERATOR. RELATIONAL OPERATORS HAVE    #
                           # SOURCE AND TARGET DBIS ASSOCIATED WITH    #
                           # THEM, LOGICAL OPERATORS DO NOT.           #
                      ALLOCW (3) ;
                      RQTWORD[WBPTR-3] = RQTSTACKWD[QINSRCDBI[QINPTR]] ;
                      RQTWORD[WBPTR-2] = RQTSTACKWD[QINTARDBI[QINPTR]] ;
                      RQTWORD[WBPTR-1] = RQTSTACKWD[QINOPPTR[QINPTR]] ; 
                    END 
                   ELSE 
                    BEGIN 
                      ALLOCW (1) ;
                      RQTWORD[WBPTR-1] = RQTSTACKWD[QINOPPTR[QINPTR]] ; 
                    END 
                END 
              INITQIN; # RE-INITIALIZE THE ARRAY AND CELLS USED IN THE #
                       # NOTATION PROCESSING.                          #
              TEST AREARANK; # CHECK FOR MORE RESTRICT ENTRIES.        #
            END 
        END 
      STDNO;
  SETBCPBWP:   #   #
#**********************************************************************#
#                  S E T B C P B W P                                   #
#                                                                      #
#    CALCULATES THE BEGINNING CHARACTER POSITION AND THE BEGINNING     #
#    WORD POSITION OF THE SCHEMA DBI THAT CORRESPONDS TO THE CURRENT   #
#    SUB-SCHEMA SUB-SCRIPTED DBI. THE CALCULATED VALUE IS THEN STORED  #
#    INTO THE RESPECTIVE SCHEMA FIELD IN THE ATTRIBUTE ENTRY. RETURN   #
#    IS TO STDNO.                                                      #
#                                                                      #
#**********************************************************************#
      IF SCITMDATATYP[0] EQ 5 OR SCITMDATATYP[0] EQ 7 THEN # CHECK IF  #
        BEGIN # DBI IS A VECTOR.                                       #
          ACCUM = (SUBSCRIPTS[SUBSCOUNT-1] - 1) * SCITEMSIZE[0] + 
            (SCITEMBBP[0]/6) + (SCITEMPBWP[0]*10);
          SUBSCOUNT = SUBSCOUNT - 1; # ADJUST COUNT OF SUB-SCRIPTS.    #
        END 
       ELSE 
        ACCUM = SCITEMPBWP[0] * 10 + SCITEMBBP[0]/6;
      J = DAENTAD[0] - SCITRLDOMPTR[0];  #GET THE WORD ADDRESS OF THE  #
                                       # DOMINANT ENTRY.               #
      FOR I= SUBSCOUNT STEP -1 WHILE I NQ 0 DO # STEP THRU THE DOMINANT#
        BEGIN # TO CALCULATE THE BEGINNING POSITIONS.                  #
          READSC(DBIBUF,5,J); # READ DOMINANT ENTRY.                   #
          ACCUM = ACCUM + (SUBSCRIPTS[SUBSCOUNT-1] - 1) * SCITEMSIZE[0] 
            + (SCITEMBBP[0]/6) + (SCITEMPBWP[0] * 10);
          J = J - SCITRLDOMPTR[0]; # GET DOMINANT ADDRESS OF THE DOMIN-#
                                  # ANT ENTRY.                         #
        END 
      RQTITMBWP[ATTRPTR] = ACCUM / 10; # STORE THE CALCULATED RELATIVE #
                                       # WORD POSITION.                #
      RQTITMBCP[ATTRPTR] = ACCUM - RQTITMBWP[ATTRPTR] * 10; # STORE THE#
                 # CALCULATED RELATIVE CHARACTER POSITION.             #
      SUBSCOUNT = 0;
      STDNO;
  SETSSFGT: 
#**********************************************************************#
#                  S E T S S F G T                                     #
#                                                                      #
#   TURNS ON THE MULTIPLE COMPILATION FLAG. RETURNS TO STDNO.          #
#**********************************************************************#
      MULTSS = TRUE;         #MULTIPLE COMPILATION DETECTED-SET FLAG# 
      STDNO;
  STORSUB:   #   #
#**********************************************************************#
#                  S T O R S U B                                       #
#                                                                      #
#    CONVERTS THE DISPLAY CODED SUB-SCRIPT TO BINARY AND STORES IT     #
#    INTO THE SUB-SCRIPT BUFFER. A CHECK IS THEN MADE TO SEE IF MORE   #
#    THEN 3 SUB-SCRIPTS WERE SPECIFIED, IF SO RETURN IS TO STDNO WHERE #
#    STD ISSUES DIAGNOSTIC 437. ELSE RETURN IS TO STDYES.              #
#                                                                      #
#**********************************************************************#
      DTEMP = CURWORD[0]; # CONVERT SUB-SCRIPT FROM DISPLAY CODE TO    #
      DISPDECTOBIN;       # BINARY.                                    #
      SUBSCRIPTS[SUBSCOUNT] = ITEMP; # STORE THE CONVERTED SUB-SCRIPT  #
                 # INTO THE SUB-SCRIPT BUFFER, WHICH IS LATER TO BE    #
                 # PROCESSED BY SETBCPBWP.                             #
      SUBSCOUNT = SUBSCOUNT + 1; # INCREMENT SUB-SCRIPT COUNTER.       #
      IF SUBSCOUNT GR 3 THEN # CHECK IF THE NUMBER OF SUB-SCRIPTS      #
        STDNO;  # EXCEEDED THE MAXIMUM NUMBER ALLOWED (3).             #
      STDYES; 
  VALIDATEDBI:   #   #
#**********************************************************************#
#                  V A L I D A T E D B I                               #
#                                                                      #
#    VALIDATES THAT THE CLASS OF THE DBI LEFT OF THE OPERATOR IS       #
#    COMPATIBLE WITH THE CLASS OF THE DBI RIGHT OF THE OPERATOR. IF    #
#    THE DBI CLASS IS NOT COMPATIBLE, RETURN IS TO STDNO WHERE STD WILL#
#    ISSUE DIAGNOSTIC 413. ELSE RETURN IS TO STDYES.                   #
#                                                                      #
#**********************************************************************#
      IF ((RQTITMCLASS[ATTRPTR] LQ 4)            # CLASSES MUST BE LQ 4#
           AND (RQTITMCLASS[DBILFTPTR] LQ 4))    # OR IDENTICAL        #
          OR (RQTITMCLASS[ATTRPTR] EQ RQTITMCLASS[DBILFTPTR]) 
      THEN
        STDYES; 
  
      STDNO;
  
  VALIDSUB:   #   # 
#**********************************************************************#
#                  V A L I D S U B                                     #
#                                                                      #
#    VALIDATES THAT A SUB-SCRIPT AS BEEN SPECIFIED FOR EACH REPEATING  #
#    DOMINANT ITEM FOR THE CURRENT DBI. VALIDATES THAT THE SUB-SCRIPT  #
#    DOES NOT EXCEED THE OCCURS VALUE. A SO CHECKS IF TOO MANY SUB-    #
#    SCRIPTS WERE SPECIFIED. RETURN IS TO STDNO IF SUB-SCRIPTS WHERE   #
#    SPECIFIED, ELSE RETURN IS TO STNYES.                              #
#                                                                      #
#**********************************************************************#
      J = SBITMDOMADR[DBIADR]; # STORE THE WORD ADDRESS OF THE DOMINANT#
                               # ENTRY OF THE CURRENT DBI.             #
      M = SUBSCOUNT; # STORE SUB-SCRIPT COUNT IN TEMPORARY CELL. LATER #
                     # LATER TO BE USED TO RESTORE THE ORIGINAL VALUE  #
                     # BACK INTO SUBSCOUNT.                            #
      IF SUBSCOUNT GR 0 THEN # CHECK IF ANY SUB-SCRITPS WHERE SPECIFIED#
        BEGIN 
          IF SBITMTYPE[DBIADR] GR 3 AND SBITMTYPE[DBIADR] NQ 6 THEN 
            BEGIN # CHECK IF THE CURRENT ITEM IS A VECTOR.             #
              K = DBIADR + SBITMOCCURP[DBIADR]; # CALC THE POINTER TO  #
                 # THE OCCURS ENTRY IN THE CURRENT ITEM ENTRY.         #
              IF SBITMHIBNDS[K] LS SUBSCRIPTS[SUBSCOUNT-1] THEN # CHECK#
                BEGIN # IF THE SUB-SCRIPT VALUE EXCEEDED THE OCCURS VAL#
                  CBRDIAG(439,SBITMNAME30[J],SBITMNMELENC[J]);
                  GOTO ZEROSUB; 
                END 
              SUBSCOUNT = SUBSCOUNT - 1;
            END 
          FOR I=SUBSCOUNT STEP -1 WHILE I NQ 0 DO # CHAIN BACK THROUGH #
            BEGIN # THE DOMINANT ENTRIES CHECKING FOR REPEATING GROUPS.#
    CONTSUB:   #   #
              IF J EQ RECPTR THEN # DOMINANT ENTRY WAS RECORD, SUBS-   #
                BEGIN # COUNT INDICATED MORE SUB-SCRIPTS, THEREFORE    #
                  CBRDIAG(421,SBITMNAME30[DBIADR+SBITMNAMEPTR[DBIADR]], 
                              SBITMNMELENC[DBIADR]);
                  GOTO ZEROSUB; 
                END 
              IF SBITMTYPE[J] LS 2 THEN # CHECK IF NON-REPEATING GROUP.#
                BEGIN 
                  J = SBITMDOMADR[J]; # GET NEXT DOMINANT ITEM.        #
                  GOTO CONTSUB; 
                END 
              K = J + SBITMOCCURP[J]; # CALC POINTER TO THE OCCURS     #
                              # ENTRY IN THE DOMINANT ENTRY.           #
              IF SUBSCRIPTS[SUBSCOUNT] GR SBITMHIBNDS[K] THEN 
                BEGIN 
                  CBRDIAG(439,SBITMNAME30[J+SBITMNAMEPTR[J]], 
                              SBITMNMELENC[J]); 
                                # SUB-SCRIPT VALUE EXCEEDED THE OCCURS #
                  GOTO ZEROSUB;   # VALUE.                             #
                END 
              J = SBITMDOMADR[J]; # GET THE NEXT DOMINANT ITEM ADDRESS.#
            END 
        END 
      FOR J=J WHILE J NQ RECPTR DO # STEP THROUGH THE DOMINANT CHAIN TO#
        BEGIN # TO VERIFY THAT THERE IS NO MORE REPEATING GROUPS.      #
              # SUBSCOUNT IS ZERO, THEREFORE IT WOULD BE AN ERROR TO   #
              # HAVE A REPEATING DOMINANT ITEM.                        #
          IF SBITMTYPE[J] GR 1 THEN 
            BEGIN 
              CBRDIAG(440,SBITMNAME30[J+SBITMNAMEPTR[J]], 
                          SBITMNMELENC[J]); 
              GOTO ZEROSUB; 
            END 
          J = SBITMDOMADR[J]; 
        END 
      SUBSCOUNT = M; # RESET THE ORIGINAL SUB-SCRIPT COUNT.            #
      IF SUBSCOUNT GR 0 THEN # RETURN TO STDNO WHERE THE NEXT SEMANTIC #
                 # ROUTINE CALLED IS SETBCPBWP, WHERE THE RELATIVE     #
                 # POSITIONS OF THE SCHEMA DBI ARE RE-CALCULATED TO    #
                 # REFLECT SUB-SCRIPTS.                                #
        STDNO;
      RQTITMBCP[ATTRPTR] = RQTITMBCP[ATTRPTR]/6; # CONVERT TO BCP.     #
      STDYES; 
    ZEROSUB:   #   #
      SUBSCOUNT = 0;
      STDYES; 
  VIRTDBI:   #   #
#**********************************************************************#
      #            V I R T D B I                                       #
#                                                                      #
#    CHECKS TO SEE IF THE CORRESPONDING ITEM IN THE SCHEMA IS AN       #
#    VIRTUAL RESULT OR DECODE ITEM. THE OFFSET POINTER TO THE RESULT   #
#    ENTRY IS CHECKED FOR NON-ZERO. IF SO, THEN THE RESULT ENTRY HAS TO#
#    BE CHECKED TO SEE IF ITS AN ACTUAL OR VIRTUAL ITEM. THE RESULT    #
#    ENTRY IS A VARIABLE ENTRY (CAN BE LOCATED ANY WHERE AFTER THE ITEM#
#    NAME IN THE ITEM ENTRY). THE WORD ADDRESS OF THE RESULT ENTRY IS  #
#    CALCULATED BY GETTING THE WORD ADDRESS OF THE SUBJECT ITEM        #
#    (DAENTAD) AND ADDING THE OFFSET POINTER TO THE RESULT ENTRY TO IT.#
#    READSC IS CALL TO GET THE RESULT ENTRY AND READ IT INTO A SCRATCH #
#    BUFFER (THE SCHEMA AREA BUFFER IS USED AS A TEMPORARY SCRATCH     #
#    BUFFER). THE FLAG WHICH INDICATES IF ITS A ACTUAL OR VIRTUAL      #
#    RESULT ENTRY IS CHECKED. IF VIRTUAL RETURN IS TO STDNO WHERE STD  #
#    ISSUES DIAGNOSTIC 424.                                            #
#                                                                      #
#    IF THE OFFSET POINTER TO THE RESULT ENTRY WAS ZERO OR IT WAS DETER#
#    MINED THAT ACTUAL RESULT WAS SPECIFIED, THEN A CHECK FOR ENCODE/  #
#    DECODE IS MADE. THE SAME PROCEDURE IS USED HERE HAS IN THE CHECK  #
#    FOR THE RESULT ENTRY. IF IT IS FOUND TO BE A DECODE ITEM RETURN   #
#    IS TO STDNO WHERE STD ISSUES DIAGNOSTIC 424.                      #
#                                                                      #
#    IF VIRTUAL RESULT OR DECODE WAS NOT SPECIFIED, RETURN IS STDYES.  #
#                                                                      #
#**********************************************************************#
      IF RQTITMACTVTP[ATTRPTR] GR 0 THEN # CHECK IF ACTUAL/VIRTUAL RSLT#
        BEGIN  # IS SPECIFIED FOR CURRENT ITEM.                        #
          I = DAENTAD[0] + RQTITMACTVTP[ATTRPTR]; # GET ADDRESS OF RSLT#
          READSC(DBIBUF,1,I); # ENTRY. GET ENTRY AND STORE IT IN A     #
          IF B<59,1>DBIWRD[0] EQ 1 THEN # TEMPORARY BUFFER. CHECK IF   #
            STDNO;    # VIRTUAL WAS SPECIFIED.                         #
        END 
      IF RQTITMENCDP[ATTRPTR] GR 0 THEN  # CHECK IF ENCODE/DECODE WAS  #
        BEGIN  # SPECIFIED FOR THE CURRENT ITEM.                       #
          I = DAENTAD[0] + RQTITMENCDP[ATTRPTR]; # GET THE ADDRESS OF  #
          READSC(DBIBUF,1,I); # THE ENCODE/DECODE ENTRY. GET ENTRY AND #
          IF B<59,1>DBIWRD[0] EQ 1 THEN # PLACE IT INTO A TEMPOR-      #
            STDNO; # ARY. CHECK IF DECODE WAS SPECIFIED.               #
        END 
      STDYES; 
  PROC ALLOC ((N)) ;
#**********************************************************************#
#                  A L L O C                                           #
#                                                                      #
#    CHECK IF THERE IS A COLLISION BETWEEN THE LAST WORD OF CBWORKBUF  #
#    (SUB-SCHEMA AND THE FIRST WORD OF THE CURRENT ENTRY IN ATTRBUF    #
#    (WORKING STORAGE AREA THAT CONTAINS THE RQT ATTRIBUTE ENTRIES). IF#
#    NO COLLISION, RETURN TO CALLER. IF COLLISION AND FIELD LENGTH IS  #
#    LESS THAN MAXFL, INCREASE FL ENOUGH TO PREVENT COLLISION, MOVE    #
#    ATTRBUF TO NEW END OF FIELD LENGTH, ADJUST POINTERS AND RETURN.   #
#    IF COLLISION AND FIELD LENGTH CANNOT BE INCREASED, ISSUE          #
#    DIAGNOSTIC 428 AND CALL ABRT1 TO ABORT THE RUN.                   #
#                                                                      #
#**********************************************************************#
    BEGIN 
      ITEM N ;
      ITEM M ;
      M = LOC(CBWORKBUF) + WBPTR + ABS(ATTRPTR) ; 
      IF  M + N LS LASTWRD THEN         # IF SPACE AVAILABLE, RETURN   #
        RETURN ;
      M = ((M + N + 63) / 64) * 64; 
      IF M GQ MAXFL THEN                # IF CANNOT GET ENOUGH, ABORT  #
        BEGIN 
          CBRDIAG(428); 
          ABRT1;
        END 
      MEMORY (M) ;                      # INCREASE FIELD LENGTH        #
      LASTWRD = B<0,30>DDLMEM ; 
      M = LASTWRD - P<ATTRBUF> ;        # ADJUST POINTERS              #
      P<ATTRBUF> = LASTWRD ;
      FOR N = -1 STEP -1 UNTIL ATTRPTR + 1 DO 
        BEGIN                           # MOVE ATTRIBUTE BUFFER TO NEW #
          RQTATTRWRD[N] = RQTATTRWRD[N-M] ;     # END OF FIELD LENGTH  #
          RQTATTRWRD[N-M] = 0 ; 
        END 
      RETURN; 
    END 
  PROC ALLOCA ((N)) ; 
#**********************************************************************#
#                  A L L O C A                                         #
#                                                                      #
#    INCREASE SIZE OF ATTRBUF BY N WORDS, AND ADVANCE ATTRPTR.         #
#    NOTE THAT ATTRBUF GROWS TOWARD LOWER ADDRESS.                     #
#                                                                      #
#**********************************************************************#
    BEGIN 
      ITEM N ;
      ALLOC (N) ;                       # GET SPACE                    #
      ATTRPTR = ATTRPTR - N ;           # ADVANCE POINTER              #
      RETURN ;
    END 
  PROC ALLOCW ((N)) ; 
#**********************************************************************#
#                  A L L O C W                                         #
#                                                                      #
#    INCREASE SIZE OF CBWORKBUF BY N WORDS, AND ADVANCE WBPTR.         #
#                                                                      #
#**********************************************************************#
    BEGIN 
      ITEM N ;
      ALLOC (N) ;                       # GET SPACE                    #
      WBPTR = WBPTR + N ;               # ADVANCE POINTER              #
      RETURN ;
    END 
      CONTROL EJECT;
  PROC DISPDECTOBIN;                                                     CBPASS1
#**********************************************************************# CBPASS1
#                  D I S P D E C B I N                                 # CBPASS1
#                                                                      # CBPASS1
#   CONVERTS THE DECIMAL DISPLAY VALUE SPECIFIED IN THE DDL SOURCE     # CBPASS1
#   INPUT INTO BINARY.                                                 # CBPASS1
#   ENTRY CONDITION:  DTEMP CONTAINS THE DISPLAY CODED VALUE.          # CBPASS1
#   EXIT CONDITION:  ITEMP CONTAINS THE BINARY VALUE.                  # CBPASS1
#                                                                      # CBPASS1
#                                                                      # CBPASS1
#**********************************************************************# CBPASS1
    BEGIN                                                                CBPASS1
      ITEMP = 0;   #INITIALIZE.                                        # CBPASS1
      FOR I=0 STEP 6 UNTIL 54 DO  # STORE A CHARACTER OF THE INPUT     # CBPASS1
        BEGIN                     # STRING                             # CBPASS1
          J = B<I,6>DTEMP;                                               CBPASS1
          IF J EQ 0 THEN   # CHECK IF AT END OF INPUT STRING.          # CBPASS1
            RETURN;                                                      CBPASS1
          ITEMP = ITEMP*10 + J-O"33";                                    CBPASS1
        END                                                              CBPASS1
    END                                                                  CBPASS1
  PROC INITQAL; 
#**********************************************************************#
#                                                                      #
#    ZEROES OUT THE VARIOUS CELLS USED IN THE QALIFICATION PROCESSING  #
#    ( AAA OF B IN C, WHERE B AND C ARE QUALIFIERS).                   #
#                                                                      #
#**********************************************************************#
    BEGIN 
      QALNUM = 0;  # ZERO OUT THE QUALIFIER COUNTER.                   #
      QALPTR = 0; # RE-INITIALIZE THE QUALIFIER POINTER.               #
      FOR I=0 STEP 1 WHILE QALWORD[I] NQ 0 DO # ZERO OUT QALBUF.       #
        QALWORD[I] = 0; 
      RETURN; 
    END 
  PROC INITQIN; 
#**********************************************************************#
#                  I N I T Q I N                                       #
#                                                                      #
#    RE-INITIALIZES THE ARRAYS AND CELLS USED IN THE OPERATOR PROCESS- #
#    ING. RETURN IS TO STDNO.                                          #
#                                                                      #
#**********************************************************************#
    BEGIN 
      FOR I=0 STEP 1 WHILE QINWORD[I] NQ 0 DO # ZERO OUT OPERATOR STACK#
        QINWORD[I] = 0; 
      QINPTR = 0; 
      RETURN; 
    END 
  PROC RELHSHREF; 
#**********************************************************************#
#                  R E L H S H R E F                                   #
#                                                                      #
#   CHECKS THE SYMBOL TABLE FOR RESTRICT DBIS. SPECIFICALLY USED FOR   #
#   DETERMINING WHETHER A NAME TO THE RIGHT OF A RELATIONAL OPERATOR   #
#   IN A RESTRICT CLAUSE IS A DBI OR A DATA-NAME.                      #
#**********************************************************************#
    BEGIN 
      DEF ITEMS # 3 #;
      DEF RECORD # 2 #; 
  
      ITEM ENTRYTYPE;              # TYPE OF ENTRY - AREA,RECORD,ITEM. #
      ITEM HRSLT;                  # HASH-ID - FROM CBHASH. INDEX INTO #
                                   # SYMBOL TABLE.                     #
      ITEM I,J,K;                  # SCRATCH VARIABLES.                #
      ITEM SYNONYM;                # WORD ADDRESS OF NAME IN SYNONYM   #
                                   # CHAIN.                            #
  
      CBHASHN(CWORD,CURLENW,HRSLT);   # NAME STORED IN CWORD IS HASHED #
    # IF NAME NOT DEFINED, RETURN.                                     #
      IF NOT HASHOCCUP[HRSLT] THEN
        BEGIN 
        DEFINED = 0;
        RETURN; 
        END 
      ENTRYTYPE = HASHTYPE[HRSLT];
      K = HASHENTRY[HRSLT];  # STORE WORD ADDRESS OF ENTRY IN HASH LOC.#
      SYNONYM = 1;           # INITIALIZE SYNONYM POINTER.             #
  
    # TRACE THROUGH SYNONYM CHAIN FOR A NAME MATCH.                    #
      FOR I = I WHILE SYNONYM NQ 0 DO 
        BEGIN    # BEGIN OF LOOP--1  #
        IF ENTRYTYPE EQ ITEMS THEN
          BEGIN 
          I = K + SBITMNAMEPTR[K]; # POINT TO NAME IN SUBSCH DIRECTORY.#
          J = SBITMNELENW[K];      # STORE LENGTH IN WORDS OF NAME.    #
          SYNONYM = SBITMSYNADDR[K]; # STORE SYNONYM ADDRESS, IF ANY.  #
          END 
        ELSE
        IF ENTRYTYPE EQ RECORD THEN 
          BEGIN 
          I = K + SBRECNAMEPTR[K]; # POINT TO NAME.                    #
          J = SBRECNMELENW[K];     # STORE LENGTH IN WORDS.            #
          SYNONYM = SBRECSYNADR[K];# STORE SYNONYM ADDRESS.            #
          END 
        ELSE                       # MUST BE AREA ENTRY.               #
          BEGIN 
          I = K + SBARNAMEPTR[K]; 
          J = SBARLENGWRDS[K];   # STORE LENGTH IN WORDS.            #
          SYNONYM = SBARSYNADDR[K];# STORE SYNONYM ADDRESS.            #
          END 
        IF J NQ CURLENW THEN       # IF LENGTH OF NAMES NOT SAME, GO   #
          GOTO CONTSYN;            # AND CHECK SYNONYM CHAIN.          #
        FOR J = 0 STEP 1 UNTIL CURLENW-1 DO  # COMPARE NAMES.          #
          BEGIN 
          IF CURWORD[J] NQ SBENTRYNAME[I+J] THEN  # IF DIFFERENT, GO   #
            GOTO CONTSYN;    # SEARCH SYNONYM CHAIN.                   #
          END 
        DEFINED = 1;         # NAME MATCH FOUND. SET FLAG AND RETURN   #
        RETURN;              # TO CALLING ROUTINE.                     #
  CONTSYN:       #     #
        K = SYNONYM;         # INITIALIZE IN PREPARATION FOR FURTHER   #
        ENTRYTYPE = SBENTRYTYPE[K];  # SEARCH OF SYNONYM CHAIN.        #
        END      # END OF LOOP--1  #
  
      DEFINED = 0;           # NAME NOT FOUND. SET FLAG AND            #
      RETURN;                # RETURN TO CALLING ROUTINE.              #
    END          # END OF PROC  # 
    END 
  TERM; 
