*DECK S$GTCSP 
          PROC S$GTCSP(RP$,STATUS$);
  
#**       S$GTCSP - GET COMMAND STATEMENT PARAMETER VALUES             #
#                                                                      #
#      CALLING SEQUENCE -                                              #
#         S$GTCSP(RP$,STATUS$):                                        #
#      GIVEN -                                                         #
#         RP$ = ARRAY FOR A RAW PARAMETER                              #
#         STATUS$ = EXPANDED ERROR STATUS                              #
#      DOES -                                                          #
#         SEARCHES THE COMMAND STATEMENT AND DIRECTIVE FILES FOR       #
#         PARAMETERS AND GET THEIR VALUE(S), AND CHECKS FOR ERRORS     #
#         IN THE PARAMETER LIST.                                       #
#      CONTAINS THE FOLLOWING (INTERNAL) PROCEDURES -                  #
#         CHKXVAL =                                                    #
#         CHR2NUM =                                                    #
#         PRTPVT =                                                     #
#         SETRP$ =                                                     #
#         TESTFIL =                                                    #
#         TESTNAM =                                                    #
#                                                                      #
          BEGIN 
  
*CALL A 
  
*CALL CLPTYPE 
  
*CALL CLPARAM 
  
*CALL CLPARRA 
  
*CALL E$
  
*CALL DEBUG 
  
*CALL JCREG 
  
  
*CALL KT$ 
  
      ARRAY PDT$[1:40] S(8);
      BEGIN 
          ITEM PDT$LEN$   U(7,0,30) = [39,39(0)]; 
          ITEM PDT$HIGH$  U(7,30,30)= [31,39(0)]; 
          ITEM PDT$NAME   C( 0, 0,10) = [ 
              "E",
              "EL", 
              "ST", 
              "STATUS", 
              "EXC",
              "DIR",
              "L",
              "LO", 
              "ENR",
              "FROM", 
              "FASTIO", 
              "KEY",
              "SUM",
              "TO", 
              "MSLIM",
              "MSL",
              "SEQN", 
              "SEQS", 
              "SEQA", 
              "SEQR", 
              "DIALOG", 
              "DIA",
              "RETAIN", 
              "RET",
              "OWNFL",
              "OFL",
              "OWNMRL", 
              "OMRL", 
              "OWNF", 
              "OWNT", 
              "OWN1", 
              "OWN2", 
              "OWN3", 
              "OWN4", 
              "OWN5", 
              "TAPES",
              "T",
              "VERIFY", 
              "VER" 
              ];
          ITEM PDT$POSN  U( 1,30,30) = [
              7,  # E # 
              8,  # EL #
              27, # ST #
              27, # STATUS #
              11, # EXC # 
              4,  # DIR # 
              5,  # L # 
              6,  # LO #
              10, # ENR # 
              1,  # FROM #
              31, # FASTIO #
              3,  # KEY # 
              28, # SUM # 
              2,  # TO #
              12, # MSLIM # 
              12, # MSL   # 
              24, # SEQN #
              26, # SEQS #
              23, # SEQA #
              25, # SEQR #
              9,  # DIALOG #
              9,  # DIA # 
              22, # RETAIN #
              22, # RET # 
              14, # OWNFL # 
              14, # OFL # 
              15, # OWNMRL #
              15, # OMRL #
              13, # OWNF #
              16, # OWNT #
              17, # OWN1 #
              18, # OWN2 #
              19, # OWN3 #
              20, # OWN4 #
              21, # OWN5 #
              29, # TAPES # 
              29, # T # 
              30, # VERIFY #
              30, # VER # 
              ];
          ITEM PDT$MINS U( 4, 0,30) = 
              [40(1)];
          ITEM PDT$MAXS U( 4,30,30) =  [
              5(1),    # E, EL, ST, STATUS, EXC # 
              128,     # DIR #
              1,       # L   #
              2,       # LO  #
              1,       # ENR #
              128,     # FROM # 
              1,       # FASTIO # 
              128,     # KEY #
              128,     # SUM #
              4(1),    # TO, MSLIM, MSL, SEQN # 
              128,     # SEQS # 
              17(1),   # SEQA, SEQR, DIALOG, DIA, RETAIN, RET # 
                       # OWNFL, OFL, OWNMRL, OMRL, OWNF, OWNT, OWN1 # 
                       # OWN2, OWN3, OWN4, OWN5 # 
              2(128),  # TAPES, T # 
              2(1)     # VERIFY, VER #
              ];
          ITEM PDT$MINV  U( 5, 0, 30) = 
              [40(1)];
          ITEM PDT$MAXV  U( 5,30,30) = [
              11(1),
              2(4),  # KEY, SUM # 
              27(1) 
              ];
          ITEM PDT$VRA  B(3,1,1) =  [ 
              8(FALSE), 
              TRUE,  # ENR #
              2(FALSE), 
              2(TRUE),  # KEY, SUM #
              4(FALSE), 
              TRUE,     # SEQS #
              20(FALSE) 
              ];
          ITEM PDT$VALT S:VALTYP( 3, 2,58) = [
              4(VALTYP"NAME"),
              VALTYP"ANY",        # EXC # 
              3(VALTYP"NAME"),
              VALTYP"ANY",        # ENR # 
              2(VALTYP"NAME"),
              2(VALTYP"ANY"),     # KEY, SUM #
              VALTYP"NAME",       # TO #
              2(VALTYP"ANY"),     # MSLIM, MSL #
              VALTYP"NAME",       # SEQN #
              VALTYP"ANY",        # SEQS #
              6(VALTYP"NAME"),
              4(VALTYP"INTEGER"), # OWNFL, OFL, OWNMRL, OMRL #
              11 (VALTYP"NAME") 
              ];
      END 
  
          XDEF
              BEGIN 
*CALL PVT$
              END 
  
*CALL RP$ 
  
*CALL STATUS$ 
  
*CALL STRING$ 
  
          XREF
*CALL S$CALLR 
  
  
          XREF
              BEGIN 
              PROC CLP$GSC;            # GET SET COUNT OF A PARAMETER  #
              PROC CLP$GTV;            # GET PARAMETER VALUE           #
              PROC CLP$GVC;            # GET PARAMETER VALUE COUNT     #
              PROC CLP$SPL;            # SCAN PARAMETER LIST           #
              PROC CLP$TR;             # TEST FOR RANGE                #
              PROC CLP$TP;             # TEST PARAMETER SPECIFICATION  #
              PROC S$DIRHD;               # PRINT HEADING ON LFNAM     #
              PROC S$GORA;  # IF CATASTROPHIC THEN IT DOES NOT RETURN  #
#??#          PROC S$PRTCD; 
              PROC S$GTJCR;     # GET CONTROL REGISTERS                #
              PROC S$GTTXT;   # GET A LINE FROM A FILE OR FROM INPUT   #
              PROC S$ERROR; 
              FUNC S$NEWGR   I;   # GIVES THE NEXT KEY INDEX           #
              PROC S$OPLF;  # OPEN FILE SPECIFIED                      #
              PROC S$CLLF;  # CLOSE FILE                               #
              END 
          ARRAY [1:128] S(1); 
              BEGIN 
              ITEM DIRNAME   C(0,0,10); 
              END 
  
          SWITCH GTCSPSWITCH
*CALL MAINGSPL
  
          STATUS GTCSP
*CALL MAINGSPL
  
# ITEMS USED WITHIN THIS PROC                                          #
  
          XDEF
          BEGIN 
              ITEM DEBUGI      U = 0; 
              ITEM DIRFILENUM   U = 1;   # DIR FILE NUMBER             #
              ITEM LLN;             # LIST FILE LINE NUMBER            #
          END 
  
          ITEM BADNAME   B=FALSE;    # TRUE IF NAME ILLEGAL            #
          ITEM CH       C(1); 
          ITEM CHAR    C(10); 
          ITEM D      U = 1; # INCREMENT USED FOR DIR-FILE COUNT       #
          ITEM DFLNM   C(10);  # DIR FILE NAME                         #
          ITEM DIRFIL       B;      # DIRECTIVE-FILE FLAG              #
          ITEM DNCSFLG         B=FALSE;# "DONCS" CODE FLAG             #
          ITEM EOF             B=FALSE;# END-OF-FILE                   #
          ITEM EQUGRP;                 # RP$ INDEX FOR EQUVAL          #
          ITEM EXP        I;     # INTEGER SET IN PROC CHKXVAL         #
          ITEM F           U;  # FIRST KEY POSITION                    #
          ITEM FILNAM       C(10);  # FILE NAME                        #
          ITEM K          U;
          ITEM GROUP      I;  # INDEX FOR KEY                          #
          ITEM HIGH       U;
          ITEM I               U; 
          ITEM II           U;      # INCREMENT VALUE                  #
          ITEM IN          I; 
          ITEM DECX        C(10); 
          ITEM DONE    B = FALSE;   # FLAG SET IN SETRP$               #
          ITEM L               U; 
          ITEM LINE         C(80);
          ITEM LOSET    C(10)=" ";    # WHAT LO VALUE IS SET TO        #
          ITEM LOW        U;
          ITEM J          U;
          ITEM KEYNAME C(10); 
          ITEM MES     C(80); 
          ITEM NDIRFILES       U;      # NUMBER OF "DIR" FILES         #
          ITEM NFILES      U;  # NUMBER OF FILES SPECIFIED             #
          ITEM NSETS       U;   # NUMBER OF SETS                       #
          ITEM NUM        U;
          ITEM ORDERPOS   U;  # POSITION OF THE KEYORDER VALUE IN A SET#
          ITEM PRTYPE S:PTYP; #  PARAMETER TYPE                        #
          ITEM RANGLEN     U=0;     # NUMBER OF ELEMENTS IN A RANGE    #
          ITEM SEQNAM      C(10);   # COL-SEQ NAME                     #
          ITEM SEQORD     U=0;   # ORDINAL USED TO SET RP$T"SEQVAL"    #
          ITEM SEQ1STRLEN  U;       # FIRST RANGE LENGTH OF A SEQ      #
          ITEM SQAFLG  B=FALSE;  # FLAG SET TRUE WHEN SEQA GIVEN       #
          ITEM SQRFLG  B=FALSE;  # FLAG SET TRUE WHEN SEQR GIVEN       #
          ITEM SW              S:GTCSP = GTCSP"START";
          ITEM TEXT            C(240);
          ITEM TYPEPOS    U;  # POSITION OF THE KEYTYPE VALUE IN A SET #
          ITEM VERB      C(7);  # EITHER THE VERB SORT OR MERGE        #
          ITEM XERR      B;     # FLAG USED BY THE PROC CHKXVAL        #
          ITEM YESL       B;  # IS THERE A KEYLENGTH PARAM. GIVEN      #
  
          ARRAY SEQ$[1:64,1:10] S(1); 
              BEGIN 
              ITEM SEQ$RANGS    I(0,0,60);   # RANGE ELEMENTS OF A COL #
              END 
  
          ARRAY RANG$[1:64] S(1); 
              BEGIN 
              ITEM RANG$TEMP    I(0,0,60);   # TEMPORARY STORAGE       #
              END 
          ITEM SCANDIR     B=FALSE; # TRUE IFF SCANNING DIRECTIVE FILE #
  
          ARRAY VALUE$[0:0] S(26);
              BEGIN 
              ITEM VALUE$LEN  I(0,0,60);  # LENGTH OF VALUE            #
              ITEM VALUE$C    C(1,0,240); # VALUE IN CHARACTERS        #
              END 
  
          XREF
              BEGIN 
              ITEM S$ELEV ;        # ERROR LEVEL SPECIFIED             #
              ITEM S$EFNAM C(10);  # ERROR FILE NAME                   #
              ITEM S$LFNAM C(10);  # LIST FILE NAME                    #
              ITEM S$JCRV  S:JCREG; # CONTROL REGISTER                 #
              ITEM S$MXERR;         # MAX. ERROR SEVERITY ENCOUNTERED  #
              END 
  
          FUNC  DEC(VALUE) C(10); 
              ITEM  VALUE       I;     # VALUE TO BE CONVERTED         #
              ITEM  C10PLUS     C(20);
              ITEM  I            I; 
              ITEM  N            I; 
              BEGIN 
              C10PLUS = "         0          "; 
              N = VALUE;
              IF N LS 0  THEN 
                  N = -N; 
              IF N GR 999999999 THEN
                  BEGIN 
                  C10PLUS = " *********          "; 
                  I = 0;
                  END 
              ELSE
                  BEGIN 
                  FOR I = 9 WHILE N NQ 0  DO
                      BEGIN 
                      C<I,1>C10PLUS = N - (N/10)*10 + 27; 
                      N = N/10; 
                      I = I - 1;
                      END 
                  END 
              IF VALUE LS 0 THEN
                  C<I,1>C10PLUS = "-";
              DEC = C<I,10>C10PLUS; 
              END  # DEC #
  
CONTROL EJECT;
  
  
          PROC CHKXVAL(XERR); 
  
#**       CHKXVAL - CHECK EXPRESSION GIVEN AS A VALUE                  #
#                                                                      #
#      GIVEN -                                                         #
#         XERR = FLAG TO SPECIFY THAT S$ERROR WAS CALLED               #
#      DOES -                                                          #
#         CHECKS VALUES OF PARAMETERS THAT SHOULD BE EXPRESSIONS       #
#         (R1,R2,R3,R1G,EF OR EFG).                                    #
#         IF VALID EXPRESSION WAS GIVEN THIS ROUTINE GETS THE VALUE IN #
#         THE REGISTER WITH THE ROUTINE S$GTJCR. THEN THE  VALUE FROM  #
#         THIS REGISTER IS PUT INTO EXP TO BE USED TO SET RP$          #
#                                                                      #
  
          BEGIN 
          ITEM EF     U;
          ITEM EFG    U;
          ITEM R1     U;
          ITEM R1G    U;
          ITEM R2     U;
          ITEM R3     U;
          ITEM XERR   B;  # THIS SIGNIFYS THAT S$ERROR(E$76) WAS CALLED#
          XREF
              BEGIN 
              PROC S$ERROR; 
              PROC S$GTJCR;   # GET JOB-CONTROL REGISTERS              #
              END 
  
          XERR = FALSE; 
          S$GTJCR(R1,R2,R3,R1G,EFG,EF);   # GET CONTROL REGISTERS      #
  
          IF C<0,1>VALUE$C GR "0"  AND  C<0,1>VALUE$C LQ "9"  THEN
              BEGIN 
          # THIS CODE FIXES ENR PARAM FOR CONTROL-CARD SORTS #
              CHAR = VALUE$C; 
              CHR2NUM;
              EXP = NUM;
              END 
          ELSE
          IF VALUE$C EQ "R1"  THEN
              EXP = R1; 
          ELSE
          IF VALUE$C EQ "R2"  THEN
              EXP = R2; 
          ELSE
          IF VALUE$C EQ "R3"  THEN
              EXP = R3; 
          ELSE
          IF VALUE$C EQ "R1G"  THEN 
              EXP = R1G;
          ELSE
          IF VALUE$C EQ "EF"  THEN
              EXP = EF; 
          ELSE
          IF VALUE$C EQ "EFG"  THEN 
              EXP = EFG;
  
          ELSE  # THE VALUE GIVEN IS NOT A VALID EXPRESSION            #
              BEGIN 
              S$ERROR(E$76);  # VALUES ALLOWED AS EXPRESSIONS ARE      #
#                INTEGERS,R1,R2,R3,R1G,EF OR EFG                       #
              STATUS$NORML = FALSE; 
              XERR = TRUE;
              END 
          END  # OF CHKXVAL # 
  
  
          PROC CHR2NUM; 
#**       CHR2NUM - CONVERTS CHARATER STRING TO A NUMBER               #
#                                                                      #
#       GIVEN -                                                        #
#         NO PARAMETER                                                 #
#       DOES -                                                         #
#         GIVEN A VARIABLE, OF LENGTH 10 CHARACTERS OR LESS,           #
#         CALCULATE THE INTEGER REPRESENTATION OF CHAR AND             #
#         STORE THE INTEGER RESULT IN NUM.                             #
  
          BEGIN 
          ITEM K          U;
          ITEM CH      C(1);
  
          NUM = 0;
          FOR K=0 WHILE C<K,1>CHAR GQ "0"  AND
                        C<K,1>CHAR LQ "9"  AND
                        NUM LQ 999999  DO 
              BEGIN 
              CH = C<K,1>CHAR;
              NUM = 10 * NUM + B<0,6>CH - O"33";
              K = K + 1;
              END # FOR # 
          END 
CONTROL EJECT;
  
  
          PROC GINVAL;
  
#**       GINVAL - GENERATE COL-SEQ ELEMENTS FROM THE VALUES OF SEQS   #
#                                                                      #
#      GIVEN -                                                         #
#         NO FORMAL PARAMETERS                                         #
#      DOES -                                                          #
#         TAKES VALUE$C AND GETS FROM THE STRING OR $CHAR FUNCTION     #
#         THE INTEGER REPRESENTATION OF A VALUE TO BE USED TO          #
#         DESCRIBE THE ELEMENTS AND THEIR ORDER, OF A USER-SUPPLIED    #
#         COL-SEQ.                                                     #
#                                                                      #
  
          BEGIN 
          ITEM APOSAT      U=0;      # APOSTROPHRE FOUND AT            #
          ITEM BLNKAT      U=0;      # BLANK FOUND AT                  #
          ITEM LFPARAT    U;        # LEFT PARENTHESIS FOUND AT        #
          ITEM CHAR2      C(1);     # SECOND CHAR. IN STRING VALUE$C   #
          ITEM K          U;
  
          NUM = 0;
          IF C<0,1>VALUE$C EQ "'"  THEN 
#           THIS VALUE IS GIVEN AS A STRING$                           #
              BEGIN 
              FOR K=1 STEP 1 UNTIL 240  # MAX. STRING LENGTH #  DO
                  BEGIN 
                  IF C<K,1>VALUE$C EQ "'"  THEN 
                      BEGIN 
                      APOSAT = K; 
                      K = 240;    # TO END LOOP ON NEXT PASS           #
                      END 
                  END 
              FOR K=APOSAT STEP 1 UNTIL 240  DO 
                  BEGIN 
                  IF C<K,1>VALUE$C EQ " "  THEN 
                      BEGIN 
                      BLNKAT = K; 
                      K = 240;  # TO END LOOP ON NEXT PASS             #
                      END 
                  END 
  
#               NOW LOOK AT THE SECOND CHAR OF THIS VALUE              #
  
              CHAR2 = C<1,1>VALUE$C;
              IF CHAR2 NQ "'"  THEN 
                  BEGIN 
                  IF APOSAT EQ 2  AND  BLNKAT EQ 3  THEN
                  IF APOSAT EQ 2  AND BLNKAT EQ 3  THEN 
#***#                GOTO CALCL;
                  ELSE
                      BEGIN 
                      S$ERROR(E$58); # ONLY SINGLE CHARACTER STRINGS OR#
#                        $CHAR CAN BE USED AS A VALUE FOR SEQS         #
                      STATUS$NORML = FALSE; 
                      NUM = -1; 
#***#                 RETURN; 
                      END 
                  END 
              IF CHAR2 EQ "'"  THEN 
                  BEGIN 
                  IF C<2,2>VALUE$C EQ "''"  AND 
                          BLNKAT EQ 4  THEN 
#****#                GOTO CALCL; 
                  ELSE  # IF NONE OF THE ABOVE COMBINATIONS ARE TRUE   #
                      BEGIN 
                      S$ERROR(E$58);  # ONLY SINGLE CHARACTER          #
#                        STRINGS OR $CHAR CAN BE USED FOR SEQS VALUES  #
                      STATUS$NORML = FALSE; 
                      NUM = -1; 
#***#                 RETURN; 
                      END 
                  END 
  
CALCL:  
              NUM = B<0,6>CHAR2;
  
              END 
  
          ELSE
          IF C<0,1>VALUE$C EQ "$"  THEN 
#           THIS VALUE SHOULD BE $CHAR(N) WHERE N IS AN INTEGER        #
  
              BEGIN 
  
#               CHECK TO SEE THAT IT'S $CHAR NOT JUST ANY $NAME TOKEN  #
  
              IF C<0,6>VALUE$C NQ "$CHAR("  THEN
                  BEGIN 
                  S$ERROR(E$58);  # ONLY SINGLE CHARACTER STRINGS      #
#                    OR $CHAR CAN BE USED FOR SEQS VALUES              #
                  STATUS$NORML = FALSE; 
                  NUM = -1; 
#***#             RETURN; 
                  END 
  
              ELSE # IF "$CHAR(" WAS FOUND THEN                        #
                  BEGIN 
                  FOR K=6 STEP 1 UNTIL 240  DO
                      BEGIN 
                      IF C<K,1>VALUE$C EQ ")"  THEN 
                          BEGIN 
                          LFPARAT = K;
                          K = 240;   # TO END LOOP                     #
                          END 
                      END 
  
#                   NOW LOOK AT THE VALUE GIVEN IN $CHAR FUNCTION      #
  
                  FOR K=6 WHILE C<K,1>VALUE$C GQ "0"  AND 
                                C<K,1>VALUE$C LQ "9"  AND 
                                NUM LQ 999999  DO 
                      BEGIN 
                      CH = C<K,1>VALUE$C; 
                      NUM = 10 * NUM +B<0,6>CH - O"33"; 
                      K = K + 1;
                      END  # OF FOR # 
                  IF K EQ LFPARAT  THEN  # THE 1ST NON-DIGIT CHAR. IS )#
#***#                 RETURN;  # NUM IS SET CORRECTLY                  #
                  ELSE # IF ) IS NOT THE 1ST NON-DIGIT IN VALUE        #
                      BEGIN 
                      S$ERROR(E$59);  # FOR $CHAR(N) N MUST BE A       #
#                        POSITIVE DECIMAL INTEGER                      #
                      STATUS$NORML = FALSE; 
                      NUM = -1; 
#***#                 RETURN; 
                      END 
                  END 
              END 
          ELSE  # THE FIRST CHAR. OF VALUE$C IS NOT A $ OR '           #
              BEGIN 
              S$ERROR(E$58);  # ONLY SINGLE CHARACTER STRINGS OR       #
#                $CHAR CAN BE USED AS A SEQS VALUE                     #
              STATUS$NORML = FALSE; 
              NUM = -1; 
#***#         RETURN; 
              END 
  
          END   # OF PROC GINVAL #
          PROC PRTPVT;
CONTROL EJECT;
  
#**       PRTPVT - PRINT PVT$                                          #
#                                                                      #
#       GIVEN -                                                        #
#         NO PARAMETERS                                                #
#       DOES -                                                         #
#         PRINTS EACH ITEM ELEMENT OF THE ARRAY PVT$ TO THE FILE       #
#         CODE USING THE PROCS DEC AND S$PRTCD                         #
#                                                                      #
  
          BEGIN 
          $BEGIN
          FOR IN = 0 STEP 1 UNTIL 40  DO
              BEGIN 
              IF NOT PVT$KEYWNAM[IN] EQ " "  THEN 
                  BEGIN 
                  MES = "********* PVT$[NN] *********"; 
                  DECX = DEC(IN); 
                  C<15,2>MES = C<1,2>DECX;
                  S$PRTCD(MES); 
                  FLUSH;
                  MES = "KEYWNAM= ";
                  C<9,10>MES = PVT$KEYWNAM[IN]; 
                  S$PRTCD(MES); 
                  FLUSH;
                  MES = "KEYWNUM= ";
                  C<9,10>MES = DEC(PVT$KEYWNUM[IN]);
                  S$PRTCD(MES); 
                  FLUSH;
                  MES = "KEYWINDEX= ";
                  C<11,10>MES = DEC(PVT$KEYWINDX[IN]);
                  S$PRTCD(MES); 
                  FLUSH;
                  IF PVT$VALGIVEN[IN] THEN
                      BEGIN 
                      MES = "VALGIVEN= "; 
                      C<11,10>MES = "TRUE"; 
                      S$PRTCD(MES); 
                      FLUSH;
                      END 
                  ELSE
                      BEGIN 
                      MES = "VALGIVEN= "; 
                      C<11,10>MES = "FALSE";
                      S$PRTCD(MES); 
                      FLUSH;
                      END 
                  MES = "FIRST INDEX POINTER= ";
                  C<21,10>MES = DEC(PVT$FINDXVAL[IN]);
                  S$PRTCD(MES); 
                  FLUSH;
                  MES = "LAST INDEX POINTER= "; 
                  C<20,10>MES = DEC(PVT$LINDXVAL[IN]);
                  S$PRTCD(MES); 
                  FLUSH;
                  MES = "SETCOUNT= "; 
                  C<10,10>MES = DEC(PVT$SETCOUNT[IN]);
                  S$PRTCD(MES); 
                  FLUSH;
                  END 
              END 
              MES = "********* PVT$ END *********"; 
              S$PRTCD(MES); 
              FLUSH;
          $END
          END 
  
CONTROL EJECT;
  
              PROC RESTOFRANG;
  
#**       RESTOFRANG - REST OF RANGE                                   #
#                                                                      #
#       GIVEN -                                                        #
#         NO FORMAL PARAMETERS.  THIS ROUTINE TAKES THE VALUES         #
#         LOW AND HIGH AND PRODUCES AND ARRAY RANG$ WHICH CONTAINS     #
#         THE INTEGER VALUE FROM LOW TO HIGH INCLUSIVE                 #
#       DOES -                                                         #
#         TAKES THE VALUES LOW AND HIGH WHICH ARE GLOBAL TO            #
#         S$GTCSP, AND CHECKS FOR ERROR IN SPECIFICATION AND PUTS      #
#         THE INTEGERS FROM LOW TO HIGH INTO THE ARRAY SEQ$            #
#                                                                      #
  
          BEGIN 
          RANGLEN = 0;
          FOR K=1 STEP 1 UNTIL 64  DO 
              BEGIN 
              RANG$TEMP[K] = -1;
              END 
          IF LOW GQ HIGH  THEN
              BEGIN 
              S$ERROR(E$57);  # WHEN LOW..HIGH IS USED AS A VALUE      #
#                FOR SEQS LOW MUST BE LESS THAN HIGH                   #
              STATUS$NORML = FALSE; 
#***#         RETURN; 
              END 
          RANGLEN = HIGH - LOW + 1; 
          FOR K = 1 STEP 1 UNTIL RANGLEN  DO
              BEGIN 
              RANG$TEMP[K] = LOW + (K - 1); 
              END 
          END  # OF REATOFRANG #
CONTROL EJECT;
  
#   *   *   *   *   *   *   *   *   *   # 
#                                       # 
#         P R O C   S E T R P $         # 
#                                       # 
#   *   *   *   *   *   *   *   *   *   # 
          PROC SETRP$;
  
#**       SETRP$ - SET RP$ FROM PVT VALUES                             #
#                                                                      #
#       GIVEN -                                                        #
#         DONE = FLAG TO SIGNIFY THAT THE END OF ROUTINE WAS REACHED   #
#            THIS IS NEEDED BECAUSE CONTROL RETURNS TO SETWH TO SET RP$#
#       DOES -                                                         #
#         FOR EACH PARAMTER SPECIFIED IN A SORT OR MERGE STATEMENT     #
#         APPROPRIATE RP$TYPE,GROUP,VALUE,ETC ARE SET FROM VALUES      #
#         IN THE PVT$                                                  #
#                                                                      #
  
          BEGIN 
  
          SWITCH SETRPSWITCH
*CALL GTCSPLIST 
  
          STATUS SETRP
*CALL GTCSPLIST 
  
          ITEM SWCH     S:SETRP = SETRP"ST";
  
NEXT: 
  
          GOTO SETRPSWITCH[SWCH];  # RESUME FROM PRIOR PROCESSING      #
  
  
#   *   *   *   *   *   *   *   # 
#                               # 
#         S T A T U S           # 
#                               # 
#   *   *   *   *   *   *   *   # 
  
# HANDLE "ST" PARAMETER                                                #
  
ST: 
  
          PARAMNM = "ST"; 
          CLP$TP(PARAMNM,SPECIFIED,STATUS$);  # TEST FOR PARAMETER     #
          IF NOT SPECIFIED THEN 
              BEGIN 
                  $BEGIN
#??#              MES = " ST NOT SPECIFIED";
#??#              S$PRTCD(MES); 
                  FLUSH;
                  $END
              SWCH = SETRP"STAT"; 
#**#          GOTO NEXT;
              END 
  
#           ELSE GET VALUE OF ST PARAMETER                             #
          # THIS PARAMETER TERMINATES ANY SEQS STUFF                   #
          SEQORD = 0; 
  
          CLP$GTV(STRING$,PARAMNM,1,1,"LOW",VALUE$,STATUS$);
          IF VALUE$C EQ "R1"  THEN
              S$JCRV = JCREG"R1"; 
          ELSE
          IF VALUE$C EQ "R2"  THEN
              S$JCRV = JCREG"R2"; 
          ELSE
          IF VALUE$C EQ "R3"  THEN
              S$JCRV = JCREG"R3"; 
          ELSE
          IF VALUE$C EQ "R1G"  THEN 
              S$JCRV = JCREG"R1G";
          ELSE
          IF VALUE$C EQ "EF"  THEN
              S$JCRV = JCREG"EF"; 
          ELSE
          IF VALUE$C EQ "EFG"  THEN 
              S$JCRV = JCREG"EFG";
          ELSE  # IF VALUE NQ R1,R2,R3,R1G,EF OR EFG  THEN            # 
              BEGIN 
              S$ERROR(E$78);  # VALUES ALLOWED FOR THE ST              #
#                PARAMETER ARE R1,R2,R3,R1G,EF OR EFG                  #
              STATUS$NORML = FALSE; 
              END 
          SWCH = SETRP"STAT"; 
  
  
# HANDLE "STATUS" PARAMETER                                            #
  
STAT: 
  
          PARAMNM = "STATUS"; 
          CLP$TP(PARAMNM,SPECIFIED,STATUS$);  # TEST FOR PARAMETER     #
          IF NOT SPECIFIED THEN 
              BEGIN 
                  $BEGIN
#??#              MES = " STATUS NOT SPECIFIED";
#??#              S$PRTCD(MES); 
                  FLUSH;
                  $END
              SWCH = SETRP"DIA";
#**#          GOTO NEXT;
              END 
  
#           ELSE GET VALUE OF "STATUS" PARAMETER                       #
          # THIS PARAMETER TERMINATES ANY SEQS STUFF                   #
          SEQORD = 0; 
  
          CLP$GTV(STRING$,PARAMNM,1,1,"LOW",VALUE$,STATUS$);
          IF VALUE$C EQ "R1"  THEN
              S$JCRV = JCREG"R1"; 
          ELSE
          IF VALUE$C EQ "R2"  THEN
              S$JCRV = JCREG"R2"; 
          ELSE
          IF VALUE$C EQ "R3"  THEN
              S$JCRV = JCREG"R3"; 
          ELSE
          IF VALUE$C EQ "R1G"  THEN 
              S$JCRV = JCREG"R1G";
          ELSE
          IF VALUE$C EQ "EF"  THEN
              S$JCRV = JCREG"EF"; 
          ELSE
          IF VALUE$C EQ "EFG"  THEN 
              S$JCRV = JCREG"EFG";
          ELSE  # IF VALUE NQ R1,R2,R3,R1G,EF OR EFG  THEN             #
              BEGIN 
              S$ERROR(E$78);  # VALUES ALLOWED FOR THE ST              #
#                PARAMETER ARE R1,R2,R3,R1G,EF OR EFG                  #
              STATUS$NORML = FALSE; 
              END 
          SWCH = SETRP"DIA";
  
#   *   *   *   *   *   *   *   # 
#                               # 
#         D I A L O G           # 
#                               # 
#   *   *   *   *   *   *   *   # 
  
# TELL S$SETPT IF INTERACTIVE DIALOGUE IS DESIRED                      #
  
DIA:  
  
          PARAMNM = "DIA";
          CLP$TP(PARAMNM,SPECIFIED,STATUS$);
          IF NOT SPECIFIED  THEN
              BEGIN 
              $BEGIN
#??#          MES = "GTCSP-TEST DIA 1"; 
#??#          S$PRTCD(MES); 
              FLUSH;
              $END
#***#         GOTO DIALOG;
              END 
  
#           A 'DIA' PARAMETER WAS GIVEN SO TEST THAT THIS 'DIA'        #
#           SPECIFICATION IS NOT BEING GIVEN IN A DIRECTIVE FILE.      #
#           CHECK BOOLEAN VALUE OF 'SCANDIR'.  'SCANDIR' EQ TRUE       #
#           MEANS THAT A DIRECTIVE FILE IS BEING SCANNED AND           #
#           THAT AN ERROR SHOULD BE ISSUED.                            #
  
          IF SCANDIR  THEN
              BEGIN 
              S$ERROR(E$50);   #W = DIALOG PARAMETER CAN ONLY BE       #
#                SPECIFIED IN A CONTROL CARD STATEMENT                 #
              SWCH = SETRP"DIALOG"; 
#***#         GOTO NEXT;
              END 
  
#           ELSE GET VALUE OF "DIA" PARAMETER                          #
          # THIS PARAMETER TERMINATES ANY SEQS STUFF                   #
          SEQORD = 0; 
  
          $BEGIN
#??#      MES = "GTCSP-TEST DIA 2"; 
#??#      S$PRTCD(MES); 
          FLUSH;
          $END
          CLP$GTV(STRING$,PARAMNM,1,1,"LOW",VALUE$,STATUS$);
          IF VALUE$C EQ "Y" OR  VALUE$C EQ "YES"  THEN
              BEGIN 
              S$CALLR = 4;
#***#         RETURN; 
              END 
          ELSE
          IF VALUE$C EQ "N" OR  VALUE$C EQ "NO"  THEN 
              BEGIN 
  
#               CONTINUE WITH PROCESSING OF CONTROL STATEMENT          #
  
              SWCH = SETRP"E";
#***#         GOTO NEXT;
              END 
          ELSE
              BEGIN 
              S$ERROR(E$63);  # VALUES ALLOWED FOR THE DIALOG          #
#                PARAMETER ARE YES AND NO                              #
              STATUS$NORML = FALSE; 
              SWCH = SETRP"E";
#***#         GOTO NEXT;
              END 
  
DIALOG: 
  
          PARAMNM = "DIALOG"; 
          CLP$TP(PARAMNM,SPECIFIED,STATUS$);
          IF NOT SPECIFIED  THEN
              BEGIN 
              $BEGIN
#??#          MES = "GTCSP-TEST DIALOG 1";
#??#          S$PRTCD(MES); 
              FLUSH;
              $END
              SWCH = SETRP"DIR";
#***#         GOTO NEXT;
              END 
  
#           A 'DIALOG' PARAMETER WAS GIVEN SO TEST THAT THIS 'DIALOG'  #
#           SPECIFICATION IS NOT BEING GIVEN IN A DIRECTIVE FILE.      #
#           CHECK BOOLEAN VALUE OF 'SCANDIR'.  'SCANDIR' EQ TRUE       #
#           MEANS THAT A DIRECTIVE FILE IS BEING SCANNED AND           #
#           THAT AN ERROR SHOULD BE ISSUED.                            #
  
          IF SCANDIR  THEN
              BEGIN 
              S$ERROR(E$50);   #W = DIALOG PARAMETER CAN ONLY BE       #
#                SPECIFIED IN A CONTROL CARD STATEMENT                 #
              SWCH = SETRP"DIR";
#***#         GOTO NEXT;
              END 
  
#           ELSE GET VALUE OF "DIALOG" PARAMETER                       #
          # THIS PARAMETER TERMINATES ANY SEQS STUFF                   #
          SEQORD = 0; 
  
              $BEGIN
#??#      MES = "GTCSP-TEST DIALOG 2";
#??#      S$PRTCD(MES); 
          FLUSH;
              $END
          CLP$GTV(STRING$,PARAMNM,1,1,"LOW",VALUE$,STATUS$);
          IF VALUE$C EQ "Y" OR  VALUE$C EQ "YES"  THEN
              BEGIN 
              S$CALLR = 4;
#***#         RETURN; 
              END 
          ELSE
          IF VALUE$C EQ "N" OR  VALUE$C EQ "NO"  THEN 
              BEGIN 
  
#               CONTINUE WITH PROCESSING OF CONTROL STATEMENT          #
  
              SWCH = SETRP"DIR";
#***#         GOTO NEXT;
              END 
          ELSE
              BEGIN 
              S$ERROR(E$63);  # VALUES ALLOWED FOR THE DIALOG          #
#                PARAMETER ARE YES AND NO                              #
              STATUS$NORML = FALSE; 
              SWCH = SETRP"DIR";
#***#         GOTO NEXT;
              END 
  
#   *   *   *   *   *   *   *   # 
#                               # 
#            D I R              # 
#                               # 
#   *   *   *   *   *   *   *   # 
  
# HANDLE "DIR" PARAMETER                                               #
  
DIR:  
  
          PARAMNM = "DIR";
          CLP$TP(PARAMNM,SPECIFIED,STATUS$);   # TEST FOR PARAMETER    #
                                             # BEING SPECIFIED         #
              $BEGIN
#??#          MES = "GTCSP-TEST 2"; 
#??#          S$PRTCD(MES); 
              FLUSH;
              $END
          IF NOT SPECIFIED THEN 
              BEGIN 
              DIRFIL = FALSE; 
              NDIRFILES = 0;
                  $BEGIN
#??#              MES = "GTCSG-TEST 3"; 
#??#              S$PRTCD(MES); 
                  FLUSH;
                  $END
              SWCH = SETRP"E";
#***#         GOTO NEXT;
              END 
  
#       ELSE GET THE "DIR" PARAMETER(S)                                #
          # THIS PARAMETER TERMINATES ANY SEQS STUFF                   #
          SEQORD = 0; 
  
          DIRFIL = TRUE;
  
#      GET DEPTH OF THE SET OF PARAMETERS                              #
  
          CLP$GSC(PARAMNM,NDIRFILES,STATUS$); 
  
#           THEN GET VALUE(S) FOR "DIR" PARAMETER                      #
  
          FOR I = DIRFILENUM STEP 1 UNTIL 
                             (DIRFILENUM - 1) + NDIRFILES    DO 
              BEGIN 
              $BEGIN
#??#          MES = "S$GTCSP-6";
#??#          S$PRTCD(MES); 
              FLUSH;
              $END
              II = I - (DIRFILENUM - 1);   # SET VALUE IS DESIRED FROM #
              CLP$GTV(STRING$,PARAMNM,II,1,"LOW",VALUE$,STATUS$); 
              TESTFIL;
              IF BADNAME  THEN
                  BEGIN 
#                   RESET 'BADNAME' TO FALSE AND GOTO NEXT             #
                  BADNAME = FALSE;
                  SWCH = SETRP"DIRLOOP";
#***#             GOTO NEXT;
                  END 
  
#               TEST THAT THIS DIRFILE HAS NOT ALREADY BEEN SPECIFIED  #
  
              FOR J = 1 STEP 1 UNTIL I  DO
                  BEGIN 
                  $BEGIN
#***#             MES = "RECURSIVE CHECKING OF DIR -     "; 
#***#             C<30,10>MES = DEC(J); 
#***#             S$PRTCD(MES); 
                  FLUSH;
                  $END
                  IF FILNAM EQ DIRNAME[J]  THEN 
                      BEGIN 
  
#                       RECURSIVE DIRFILE SPECIFICATION ILLEGAL        #
  
                      S$ERROR(E$67);  # ALL DIRECTIVE FILE NAMES MUST  #
#                        BE UNIQUE                                     #
                      STATUS$NORML = FALSE; 
                      SWCH = SETRP"E";
#***#                 GOTO NEXT;
                      END 
  
#                   ELSE CONTINUE                                      #
  
                  END  # OF FOR # 
              $BEGIN
#??#          MES = " DIR FILNAM - "; 
#??#          C<14,10>MES = FILNAM; 
#??#          S$PRTCD(MES); 
              FLUSH;
              $END
              DIRNAME[I] = FILNAM;
              END 
  
DIRLOOP:  
  
          DIRFILENUM = I;   # THE NEXT DIRFILE NUMBER TO BE USED       #
          $BEGIN
#??#      MES = "DIFILENUM = "; 
#??#      C<14,10>MES = DEC(DIRFILENUM - 1);
#??#      S$PRTCD(MES); 
          FLUSH;
          $END
  
#   *   *   *   *   *   *   *   # 
#                               # 
#              E                # 
#                               # 
#   *   *   *   *   *   *   *   # 
  
# HANDLE "E" PARAMETER                                                 #
  
E:  
  
          PARAMNM = "E";
          CLP$TP(PARAMNM,SPECIFIED,STATUS$);  # TEST FOR PARAMETER     #
          IF NOT SPECIFIED  THEN
              BEGIN 
                  $BEGIN
#??#              MES = "GTCSP-TEST E1";
#??#              S$PRTCD(MES); 
                  FLUSH;
                  $END
              SWCH = SETRP"EL"; 
#***#         GOTO NEXT;
              END 
  
#           ELSE GET VALUE OF 'E' PARAMETER                            #
          # THIS PARAMETER TERMINATES ANY SEQS STUFF                   #
          SEQORD = 0; 
  
          $BEGIN
#??#      MES = "S$GTCSP-TEST E2";
#??#      S$PRTCD(MES); 
          FLUSH;
          $END
          CLP$GTV(STRING$,PARAMNM,1,1,"LOW",VALUE$,STATUS$);
          IF VALUE$C EQ "$NULL"  THEN 
              S$EFNAM = "0";
          ELSE  # CHECK TO SEE IF VALUE IS A PROPER FILE NAME          #
              BEGIN 
              TESTFIL;
              IF BADNAME  THEN
                  BEGIN 
#                   RESET 'BADNAME' TO FALSE AND GOTO NEXT             #
                  BADNAME = FALSE;
                  SWCH = SETRP"EL"; 
#***#             GOTO NEXT;
                  END 
              S$EFNAM = FILNAM; 
              END 
          $BEGIN
#??#      MES = " S$EFNAM = ";
#??#      C<11,10>MES = S$EFNAM;
#??#      S$PRTCD(MES); 
          FLUSH;
          $END
          SWCH = SETRP"EL"; 
  
  
#   *   *   *   *   *   *   *   # 
#                               # 
#             E L               # 
#                               # 
#   *   *   *   *   *   *   *   # 
  
# HANDLE "EL" PARAMETER                                                #
  
EL: 
  
          PARAMNM = "EL"; 
          CLP$TP(PARAMNM,SPECIFIED,STATUS$);
          IF NOT SPECIFIED THEN 
              BEGIN 
                  $BEGIN
#??#              MES = " EL NOT SPECIFIED";
#??#              S$PRTCD(MES); 
                  FLUSH;
                  $END
              SWCH = SETRP"ENR";
#***#         GOTO NEXT;
              END 
  
#           ELSE GET VALUE OF "EL" PARAMETER                           #
          # THIS PARAMETER TERMINATES ANY SEQS STUFF                   #
          SEQORD = 0; 
  
          $BEGIN
#??#      MES = " GET EL PARAMETER";
#??#      S$PRTCD(MES); 
          FLUSH;
          $END
          CLP$GTV(STRING$,PARAMNM,1,1,"LOW",VALUE$,STATUS$);
          IF VALUE$C EQ "T" # TRIVIAL #  THEN 
              S$ELEV = 20;
          ELSE
          IF VALUE$C EQ "W"  # WARNING #  THEN
              S$ELEV = 30;
          ELSE
          IF VALUE$C EQ "F"  # FATAL #  THEN
              S$ELEV = 40;
          ELSE
          IF VALUE$C EQ "C"  # CATASTROPHIC #  THEN 
              S$ELEV = 50;
          ELSE
              BEGIN 
              S$ERROR(E$74);  # VALUES ALLOWED FOR THE EL              #
#                PARAMETER ARE R1,R2,AND R3                            #
              STATUS$NORML = FALSE; 
#***#         GOTO ENR; 
              END 
          $BEGIN
          MES = " S$ELEV = "; 
#??#      C<10,10>MES = DEC(S$ELEV);
#??#      S$PRTCD(MES); 
          FLUSH;
          $END
  
#   *   *   *   *   *   *   *   # 
#                               # 
#             E N R             # 
#                               # 
#   *   *   *   *   *   *   *   # 
  
ENR:  
  
# HANDLE "ENR" PARAMETER                                               #
  
              $BEGIN
#??#          MES = "GTCSP-TEST ENR 1"; 
#??#          S$PRTCD(MES); 
              FLUSH;
              $END
          PARAMNM = "ENR";
          CLP$TP(PARAMNM,SPECIFIED,STATUS$);
          IF NOT SPECIFIED  THEN
              BEGIN 
                  $BEGIN
                  MES = "GTCSP-TEST ENR 2"; 
#??#              S$PRTCD(MES); 
                  FLUSH;
                  $END
              SWCH = SETRP"FASTIO"; 
#***#         GOTO NEXT;
              END 
  
#           ELSE GET VALUE OF "ENR" PARAMETER                          #
          # THIS PARAMETER TERMINATES ANY SEQS STUFF                   #
          SEQORD = 0; 
  
              $BEGIN
#??#          MES = "GTCSP-TEST ENR 3"; 
#??#          S$PRTCD(MES); 
              FLUSH;
              $END
          CLP$TR(STRING$,PARAMNM,1,1,RANGSPEC,STATUS$); 
          IF RANGSPEC  THEN 
              BEGIN 
              $BEGIN
              MES = "GTCSP-TEST ENR 4"; 
#??#          S$PRTCD(MES); 
              FLUSH;
              $END
              CLP$GTV(STRING$,PARAMNM,1,1,"HIGH",VALUE$,STATUS$); 
              END 
          ELSE  # SINCE NO RANGE WAS FOUND                             #
              BEGIN 
              $BEGIN
#??#          MES = "GTCSP-TEST ENR 5"; 
#??#          S$PRTCD(MES); 
              FLUSH;
              $END
              CLP$GTV(STRING$,PARAMNM,1,1,"LOW",VALUE$,STATUS$);
              END 
          CHKXVAL(XERR);    # EVALUATE EXPRESSION                      #
          IF XERR  THEN 
              BEGIN 
              $BEGIN
#??#      MES = " XERR FOR ENR IS TRUE";
#??#          S$PRTCD(MES); 
              FLUSH;
              $END
              SWCH = SETRP"FASTIO"; 
#***#         GOTO NEXT;
              END 
  
#           OTHERWISE NO ERROR IN THE EXPRESSION WAS FOUND             #
#           SO PUT VALUE IN APPROPRIATE RP$ VARIABLE                   #
  
          RP$TYPE = RP$T"ENR";
          RP$VALUE = EXP; 
          SWCH = SETRP"FASTIO"; 
#***#     RETURN; 
  
#   *   *   *   *   *   *   *   # 
#                               # 
#        F A S T I O            # 
#                               # 
#   *   *   *   *   *   *   *   # 
  
# HANDLE "FASTIO" PARAMETER                                            #
  
FASTIO: 
  
          PARAMNM = "FASTIO"; 
          CLP$TP(PARAMNM,SPECIFIED,STATUS$);
          IF NOT SPECIFIED  THEN
              BEGIN 
              $BEGIN
#??#          MES = "GTCSP-TEST FASTIO 1";
#??#          S$PRTCD(MES); 
              FLUSH;
              $END
              SWCH = SETRP"FROM"; 
#***#         GOTO NEXT;
              END 
  
#           ELSE GET VALUE OF "FASTIO" PARAMETER                       #
          # THIS PARAMETER TERMINATES ANY SEQS STUFF                   #
          SEQORD = 0; 
  
          $BEGIN
#??#      MES = "GTCSP-TEST FASTIO 2";
#??#      S$PRTCD(MES); 
          FLUSH;
          $END
          CLP$GTV(STRING$,PARAMNM,1,1,"LOW",VALUE$,STATUS$);
          IF VALUE$C EQ "Y" OR  VALUE$C EQ "YES"  THEN
              BEGIN 
              RP$TYPE = RP$T"FASTIO"; 
              SWCH = SETRP"FROM"; 
#***#         RETURN; 
              END 
          ELSE
          IF VALUE$C EQ "N" OR  VALUE$C EQ "NO"  THEN 
              BEGIN 
  
#               CONTINUE WITH PROCESSING OF CONTROL STATEMENT          #
  
              SWCH = SETRP"FROM"; 
#***#         GOTO NEXT;
              END 
          ELSE
              BEGIN 
              S$ERROR(E$53);  # VALUES ALLOWED FOR THE FASTIO          #
#                PARAMETER ARE YES AND NO                              #
              STATUS$NORML = FALSE; 
              SWCH = SETRP"FROM"; 
#***#         GOTO NEXT;
              END 
  
  
  
#   *   *   *   *   *   *   *   # 
#                               # 
#            F R O M            # 
#                               # 
#   *   *   *   *   *   *   *   # 
  
# HANDLE "FROM" PARAMETER                                              #
  
FROM: 
              $BEGIN
#??#          MES = "GTCSP-TEST FROM 1";
#??#          S$PRTCD(MES); 
              FLUSH;
              $END
          PARAMNM = "FROM"; 
          CLP$TP(PARAMNM,SPECIFIED,STATUS$);
          IF NOT SPECIFIED  THEN
              BEGIN 
                  $BEGIN
#??#              MES = "GTCSP-TEST FROM 2";
#??#              S$PRTCD(MES); 
                  FLUSH;
                  $END
              SWCH = SETRP"KEY";
#***#         GOTO NEXT;
              END 
  
#           ELSE GET VALUE OF "FROM" PARAMETER                         #
          # THIS PARAMETER TERMINATES ANY SEQS STUFF                   #
          SEQORD = 0; 
  
              $BEGIN
              MES = "GTCSP-TEST FROM 3";
#??#          S$PRTCD(MES); 
              FLUSH;
              $END
  
          CLP$GSC(PARAMNM,NFILES,STATUS$);
              $BEGIN
              MES = " NFILES = "; 
              C<10,10>MES = DEC(NFILES);
#??#          S$PRTCD(MES); 
              FLUSH;
              $END
          FOR I=1 STEP 1 UNTIL NFILES  DO 
              BEGIN 
              $BEGIN
              MES = "GTCSP-TEST FROM 4";
#??#          S$PRTCD(MES); 
              FLUSH;
              $END
              CLP$GTV(STRING$,PARAMNM,I,1,"LOW",VALUE$,STATUS$);
  
              IF VALUE$C EQ "$NULL"  THEN 
                  BEGIN 
                  IF NFILES EQ 1 THEN 
                      BEGIN 
                      RP$TYPE = RP$T"INFILE"; 
                      RP$VALUEC = "$NULL";
                      SWCH = SETRP"KEY";
#***#                 RETURN; 
                      END 
                  ELSE # IF NFILES GR 1                                #
                      BEGIN 
                      S$ERROR(E$77); # $NULL SHOULD NOT                #
#                        USED AS A VALUE WITHIN A SET OF VALUES        #
                      SWCH = SETRP"KEY";
#***#                 GOTO NEXT;
                      END 
                  END 
  
#               ELSE                                                   #
  
              TESTFIL;
              IF BADNAME  THEN
                  BEGIN 
#                   RESET 'BADNAME' TO FALSE AND GOTO NEXT             #
                  BADNAME = FALSE;
                  SWCH = SETRP"FROMLOP";
#***#             GOTO NEXT;
                  END 
              RP$TYPE = RP$T"INFILE"; 
              RP$VALUEC = FILNAM; 
              SWCH = SETRP"FROMLOP";
                  $BEGIN
#??#              MES = " RP$INFILE SET - FROM";
#??#              S$PRTCD(MES); 
                  FLUSH;
                  $END
#***#         RETURN; 
  
FROMLOP:  
              END # FOR # 
          $BEGIN
#??#      MES = "S$GTCSP-7";
#??#      S$PRTCD(MES); 
          FLUSH;
          $END
  
#   *   *   *   *   *   *   *   # 
#                               # 
#              K E Y            # 
#                               # 
#   *   *   *   *   *   *   *   # 
  
# HANDLE "KEY" PARAMETER                                               #
  
KEY:  
  
              $BEGIN
#??#          MES = "GTCSP-TEST KEY 1"; 
#??#          S$PRTCD(MES); 
              FLUSH;
              $END
          PARAMNM = "KEY";
          CLP$TP(PARAMNM,SPECIFIED,STATUS$);
          IF NOT SPECIFIED  THEN
              BEGIN 
                  $BEGIN
#??#              MES = "GTCSP-TEST KEY 2"; 
#??#              S$PRTCD(MES); 
                  FLUSH;
                  $END
              SWCH = SETRP"LIST"; 
#***#         GOTO NEXT;
              END 
  
#           ELSE GET VALUE OF "KEY" PARAMETER                          #
          # THIS PARAMETER TERMINATES ANY SEQS STUFF                   #
          SEQORD = 0; 
  
              $BEGIN
              MES = "GTCSP-TEST KEY 3"; 
#??#          S$PRTCD(MES); 
              FLUSH;
              $END
  
          CLP$GSC(PARAMNM,NFILES,STATUS$);
              $BEGIN
              MES = " NFILES = "; 
#??#          C<10,10>MES = DEC(NFILES);
#??#          S$PRTCD(MES); 
              FLUSH;
              $END
  
#           LOOK AT INDIVIDUAL VALUES WITHIN EACH SET                  #
          FOR I=1 STEP 1 UNTIL NFILES  DO 
              BEGIN 
              $BEGIN
              MES = "GTCSP-TEST KEY 4"; 
              S$PRTCD(MES); 
              FLUSH;
              $END
              CLP$GVC(STRING$,PARAMNM,I,VALCOUNT,STATUS$);
                  $BEGIN
                  MES = "GTCSP-TEST KEY 5"; 
                  S$PRTCD(MES); 
                  FLUSH;
#??#              MES = " VALCOUNT = "; 
#??#              C<12,10>MES = DEC(VALCOUNT);
#??#              S$PRTCD(MES); 
                  FLUSH;
                  $END
              IF VALCOUNT EQ 0  THEN
                  BEGIN 
                  SWCH = SETRP"LIST"; 
#***#             GOTO NEXT;
                  END 
              CLP$TR(STRING$,PARAMNM,I,1,RANGSPEC,STATUS$); 
              IF RANGSPEC  THEN  # A RANGE WAS USED IN THIS VAL-SET    #
                  BEGIN 
                  $BEGIN
#??#              MES = " RANGSPEC IS TRUE "; 
#??#              S$PRTCD(MES); 
                  FLUSH;
                  $END
                  IF VALCOUNT GQ 4  THEN
                      BEGIN 
                      S$ERROR(E$51, "   ", 0);  # ONLY 3 VALUES CAN BE #
#                        GIVEN IN KEY/SUM VALUE-SET IF F..L FORMAT IS  #
#                        USED                                          #
                      STATUS$NORML = FALSE; 
                      END 
                  TYPEPOS = 2;
                  ORDERPOS = 3; 
                  END 
              ELSE  # A RANGE WAS NOT FOUND                            #
                  BEGIN 
                  $BEGIN
#??#              MES = " RANGSPEC IS FALSE"; 
#??#              S$PRTCD(MES); 
                  FLUSH;
                  $END
                  IF VALCOUNT EQ 1  THEN
                      BEGIN 
                      $BEGIN
#??#                  MES = "KEY-TEST LINE 1380"; 
#??#                  S$PRTCD(MES); 
                      FLUSH;
                      $END
                      TYPEPOS = 2;
                      ORDERPOS = 3; 
                      END 
                  IF VALCOUNT GQ 2  THEN
                    BEGIN 
                    CLP$GTV(STRING$,PARAMNM,I,2,"LOW",VALUE$,STATUS$);
                    IF C<0,1>VALUE$C GQ "0" AND C<0,1>VALUE$C LQ "9"
                        THEN
                      BEGIN 
                      YESL = TRUE;
                      TYPEPOS = 3;
                      ORDERPOS = 4; 
                      END 
                    ELSE  # VALUE IS NOT A NUMBER                      #
                      BEGIN 
                      S$ERROR(E$70);  # KEY/SUM LENGTH MUST BE         #
#                        SPECIFIED IF KEY/SUM TYPE IS SPECIFIED        #
                      STATUS$NORML = FALSE; 
                      YESL = FALSE; 
                      TYPEPOS = 3;
                      ORDERPOS = 4; 
                      END 
                    END 
                  END 
  
              GROUP = S$NEWGR;
              IF VALCOUNT GQ TYPEPOS  THEN
                  BEGIN 
                  CLP$GTV(STRING$,PARAMNM,I,TYPEPOS,"LOW",VALUE$, 
                                  STATUS$); 
  
#               TEST THE 'TYPE' VALUE WITHIN THE SET TO DETERMINE IF   #
#               IT'S A KNOWN KEYTYPE OR A USER SUPPLIED COL-SEQ NAME   #
  
                  TESTLONGNM;   # TEST THE LENGTH OF VALUE$C           #
                  IF BADNAME  THEN
                      BEGIN 
#                       RESET 'BADNAME' TO FALSE AND GOTO NEXT         #
                      BADNAME = FALSE;
                      SWCH = SETRP"KEYBOTTOM";
#***#                 GOTO NEXT;
                      END 
                  KEYNAME = C<0,10>VALUE$C; 
  
#                   SET KEYTYPE FOR GIVEN KEYNAME                      #
  
                  RP$GROUP = GROUP; 
                  RP$TYPE = RP$T"KEYTYPE";
                  SWCH = SETRP"KEYLOP3";  # UNLESS OTHERWISE SPECIFIED #
  
                  IF KEYNAME EQ "BINARY"  THEN
                      BEGIN 
                      RP$VALUE = KT$T"LOGICAL"; 
#***#                 RETURN; 
                      END 
                  ELSE
                  IF KEYNAME EQ  "BINARY_BIT" THEN
                      BEGIN 
                      RP$VALUE = KT$T"LOGICAL"; 
                      SWCH = SETRP"KEYLOP5";
#***#                 RETURN; 
                      END 
                  ELSE
                  IF KEYNAME EQ "REAL"  THEN
                      BEGIN 
                      RP$VALUE = KT$T"FLOAT"; 
#***#                 RETURN; 
                      END 
                  ELSE
                  IF KEYNAME EQ "INTEGER"  THEN 
                      BEGIN 
                      RP$VALUE = KT$T"INTEGER"; 
#***#                 RETURN; 
                      END 
                  ELSE
                  IF KEYNAME EQ  "INTEGER_BI"  THEN 
                      BEGIN 
                      RP$VALUE = KT$T"INTEGER"; 
                      SWCH = SETRP"KEYLOP5";
#***#                 RETURN; 
                      END 
                  ELSE
                  IF KEYNAME EQ "NUMERIC_LO"  THEN
                      BEGIN 
                      RP$VALUE = KT$T"NUMERICLO"; 
#***#                 RETURN; 
                      END 
                  ELSE
                  IF KEYNAME EQ "NUMERIC_LS"  THEN
                      BEGIN 
                      RP$VALUE = KT$T"NUMERICLS"; 
#***#                 RETURN; 
                      END 
                  ELSE
                  IF KEYNAME EQ "NUMERIC_TO"  THEN
                      BEGIN 
                      RP$VALUE = KT$T"NUMERICTO"; 
#***#                 RETURN; 
                      END 
                  ELSE
                  IF KEYNAME EQ "NUMERIC_TS"  THEN
                      BEGIN 
                      RP$VALUE = KT$T"NUMERICTS"; 
#***#                 RETURN; 
                      END 
                  ELSE
                  IF KEYNAME EQ "NUMERIC_NS"  THEN
                      BEGIN 
                      RP$VALUE = KT$T"NUMERICNS"; 
#***#                 RETURN; 
                      END 
                  ELSE
                  IF KEYNAME EQ "NUMERIC_FS"  THEN
                      BEGIN 
                      RP$VALUE = KT$T"NUMERICFS"; 
#***#                 RETURN; 
                      END 
                  ELSE
                  IF KEYNAME EQ "PACKED"  THEN
                      BEGIN 
                      RP$VALUE = KT$T"PACKED";
#***#                 RETURN; 
                      END 
                  ELSE
                  IF KEYNAME EQ "PACKED_NS" THEN
                      BEGIN 
                      RP$VALUE = KT$T"PACKEDNS";
#***#                 RETURN; 
                      END 
                  ELSE
                  IF KEYNAME EQ "DISPLAY"  OR 
                     KEYNAME EQ "ASCII6"   OR 
                     KEYNAME EQ "COBOL6"   OR 
                     KEYNAME EQ "INTBCD" OR 
                     KEYNAME EQ "EBCDIC6"   THEN
                      BEGIN 
                      RP$VALUE = KT$T"DISPLAY"; 
                      SWCH = SETRP"KEYLOP1";
#***#                 RETURN; 
KEYLOP1:  
                      RP$GROUP = GROUP; 
                      RP$TYPE = RP$T"KEYCOLSEQ";
                      RP$VALUEC = KEYNAME;
                      SWCH = SETRP"KEYLOP3";
#***#                 RETURN; 
                      END 
  
                  ELSE  # SINCE NONE OF THE ABOVE KEYTYPE WERE USED    #
                        # THE KEYNAME WILL BE TREATED AS A USER-       #
                        # SUPPLIED COL-SEQ NAME                        #
  
                      BEGIN 
                      RP$VALUE = KT$T"DISPLAY"; 
                      SWCH = SETRP"COLSEQ"; 
#***#                 RETURN; 
COLSEQ: 
                      RP$GROUP = GROUP; 
                      RP$TYPE = RP$T"KEYCOLSEQ";
                      RP$VALUEC = KEYNAME;
                      SWCH = SETRP"KEYLOP3";
#***#                 RETURN; 
                      END 
                  END 
  
              ELSE  # SINCE NO TYPE WAS SPECIFIED,                     #
                    # SET KEYTYPE TO "ASCII6"                          #
  
                  BEGIN 
                  RP$GROUP = GROUP; 
                  RP$TYPE = RP$T"KEYTYPE";
                  RP$VALUE = KT$T"DISPLAY"; 
                  SWCH = SETRP"KEYLOP2";
#***#             RETURN; 
KEYLOP2:  
                  RP$GROUP = GROUP; 
                  RP$TYPE = RP$T"KEYCOLSEQ";
                  RP$VALUEC = "ASCII6"; 
                  SWCH = SETRP"KEYLOP3";
#***#             RETURN; 
                  END 
  
KEYLOP3:  
#               PROCESS (FIRST) BYTE POSITION OF KEY                   #
  
              CLP$GTV(STRING$,PARAMNM,I,1,"LOW",VALUE$,STATUS$);
              CHAR = C<0,10>VALUE$C;
              IF C<0,1>CHAR LS "0"  OR
                 C<0,1>CHAR GR "9"  THEN
                  BEGIN 
                  S$ERROR(E$88);  # BYTE/BIT POSITION OR LENGTH        #
#                    OF A SUM/KEY FIELD MUST BE AN INTEGER             #
                  STATUS$NORML = FALSE; 
                  END 
              CHR2NUM;
              IF NUM EQ 0 THEN
                  BEGIN 
                  S$ERROR(E$119);  # ZERO LENGTH NOT VALID #
                  STATUS$NORML = FALSE; 
                  END 
              F = NUM;
              RP$GROUP = GROUP; 
              RP$TYPE = RP$T"KEYBYTEPOS"; 
              RP$VALUE = F; 
              SWCH = SETRP"KEYLOP4";
#***#         RETURN; 
KEYLOP4:  
#               PROCESS LENGTHS (IN BYTES) OF KEY                      #
  
              IF RANGSPEC THEN
                  BEGIN 
                  CLP$GTV(STRING$,PARAMNM,I,1,"HIGH",VALUE$,STATUS$); 
                  CHAR = C<0,10>VALUE$C;
                  IF C<0,1>CHAR LS "0"  OR
                     C<0,1>CHAR GR "9"  THEN
                      BEGIN 
                      S$ERROR(E$88);  # BYTE/BIT POSITION OR LENGTH    #
#                        OF A SUM/KEY FIELD MUST BE AN INTEGER         #
                      STATUS$NORML = FALSE; 
                      END 
                  CHR2NUM;
  
# CHECK THAT LAST GQ FIRST                                             #
  
                  IF F GR NUM  THEN 
                      BEGIN 
                      S$ERROR(E$85);   # IN A KEY/SUM VALUE-SET USING  #
#                       FIRST..LAST, LAST IS LESS THAN FIRST           #
                      STATUS$NORML = FALSE; 
  
# SET LENGTH = 1 WHEN ERROR OCCURS                                     #
  
                      NUM = 1;
                      END 
                  ELSE  # IF F LQ NUM                                  #
                      NUM = NUM - F + 1;
                  END 
              IF NOT RANGSPEC  THEN 
                  BEGIN 
                  IF VALCOUNT EQ 1  THEN
                      BEGIN 
                      L = 1;   # DEFAULT LENGTH IS SET                 #
                      RP$GROUP = GROUP; 
                      RP$TYPE = RP$T"KEYNBYTES";
                      RP$VALUE = L; 
                      SWCH = SETRP"KEYLOP7";
#***#                 RETURN; 
                      END 
#                   ELSE  IF VALCOUNT GQ 2  THEN                       #
                  CLP$GTV(STRING$,PARAMNM,I,2,"LOW",VALUE$,STATUS$);
                  CHAR = C<0,10>VALUE$C;
                  IF C<0,1>CHAR LS "0"  OR
                     C<0,1>CHAR GR "9"  THEN
                      BEGIN 
                      S$ERROR(E$88); #  BYTE/BIT POSITION OR LENGTH    #
#                        OF A SUM/KEY FIELD MUST BE AN INTEGER         #
                      STATUS$NORML = FALSE; 
                      END 
                  CHR2NUM;
              IF NUM EQ 0 THEN
                  BEGIN 
                  S$ERROR(E$119);  # ZERO LENGTH NOT VALID #
                  STATUS$NORML = FALSE; 
                  END 
                  END 
              IF KEYNAME EQ "REAL"  THEN
                  BEGIN 
                  IF NUM NQ 10  THEN
                      BEGIN 
                      S$ERROR(E$71);  # KEYLENGTH FOR KEY OF KEYTYPE   #
#                        "REAL" MUST BE 10                             #
                      STATUS$NORML = FALSE; 
                      GOTO KEYLOP7; 
                      END 
                  END 
  
#               ELSE SET LENGTH                                        #
  
              L = NUM;
              RP$GROUP = GROUP; 
              RP$TYPE = RP$T"KEYNBYTES";
              RP$VALUE = L; 
              SWCH = SETRP"KEYLOP7";
#***#         RETURN; 
  
KEYLOP5:  
#               PROCESS (FIRST) BIT POSITION OF KEY                    #
              CLP$GTV(STRING$,PARAMNM,I,1,"LOW",VALUE$,STATUS$);
              CHAR = C<0,10>VALUE$C;
              IF C<0,1>CHAR LS "0"  OR
                 C<0,1>CHAR GR "9"  THEN
                  BEGIN 
                  S$ERROR(E$88);  # BYTE/BIT POSITION OR LENGTH        #
#                    OF A SUM/KEY FIELD MUST BE AN INTEGER             #
                  STATUS$NORML = FALSE; 
                  END 
              CHR2NUM;
              IF NUM EQ 0 THEN
                  BEGIN 
                  S$ERROR(E$119);  # ZERO LENGTH NOT VALID #
                  STATUS$NORML = FALSE; 
                  END 
              F = NUM;
              RP$GROUP = GROUP; 
              RP$TYPE = RP$T"KEYBITPOS";
              RP$VALUE = F; 
              SWCH = SETRP"KEYLOP6";
#***#         RETURN; 
KEYLOP6:  
#               PROCESS LENGTH (IN BITS) OF KEY                        #
  
              IF RANGSPEC THEN
                  BEGIN 
                  CLP$GTV(STRING$,PARAMNM,I,1,"HIGH",VALUE$,STATUS$); 
                  CHAR = C<0,10>VALUE$C;
                  IF C<0,1>CHAR LS "0"  OR
                     C<0,1>CHAR GR "9"  THEN
                      BEGIN 
                      S$ERROR(E$88);  # BYTE/BIT POSITION OR LENGTH    #
#                        OF A SUM/KEY FIELD MUST BE AN INTEGER         #
                      STATUS$NORML = FALSE; 
                      END 
                  CHR2NUM;
  
# CHECK THAT LAST GQ FIRST                                             #
  
                  IF F GR NUM  THEN 
                      BEGIN 
                      S$ERROR(E$85);   # IN A KEY/SUM VALUE-SET USING  #
#                       FIRST..LAST, LAST IS LESS THAN FIRST           #
                      STATUS$NORML = FALSE; 
  
# SET LENGTH = 1 WHEN ERROR OCCURS                                     #
  
                      NUM = 1;
                      END 
                  ELSE  # IF F LQ NUM                                  #
                      NUM = NUM - F + 1;
                  END 
              IF NOT RANGSPEC  THEN 
                  BEGIN 
                  IF VALCOUNT EQ 1  THEN
                      BEGIN 
                      L = 1;   # DEFAULT LENGTH IS SET                 #
                      RP$GROUP = GROUP; 
                      RP$TYPE = RP$T"KEYNBITS"; 
                      RP$VALUE = L; 
                      SWCH = SETRP"KEYLOP7";
#***#                 RETURN; 
                      END 
#                   ELSE  IF VALCOUNT GQ 2  THEN                       #
                  CLP$GTV(STRING$,PARAMNM,I,2,"LOW",VALUE$,STATUS$);
                  CHAR = C<0,10>VALUE$C;
                  IF C<0,1>CHAR LS "0"  OR
                     C<0,1>CHAR GR "9"  THEN
                      BEGIN 
                      S$ERROR(E$88);  # BYTE/BIT POSITION OR LENGTH    #
#                        OF A SUM/KEY FIELD MUST BE AN INTEGER         #
                      STATUS$NORML = FALSE; 
                      END 
                  CHR2NUM;
              IF NUM EQ 0 THEN
                  BEGIN 
                  S$ERROR(E$119);  # ZERO LENGTH NOT VALID #
                  STATUS$NORML = FALSE; 
                  END 
                  END 
              L = NUM;
              RP$GROUP = GROUP; 
              RP$TYPE = RP$T"KEYNBITS"; 
              RP$VALUE = L; 
              SWCH = SETRP"KEYLOP7";
#***#         RETURN; 
  
KEYLOP7:  
#               DETERMINE WHAT ORDER THE COL-SEQ IS IN                 #
  
              IF VALCOUNT NQ ORDERPOS  THEN 
                  BEGIN 
#***#             GOTO KEYBOTTOM; 
                  END 
              ELSE  # IF A ORDER VALUE IS SPECIFIED THEN               #
              BEGIN 
              CLP$GTV(STRING$,PARAMNM,I,ORDERPOS,"LOW",VALUE$,STATUS$); 
              IF C<0,10>VALUE$C EQ "D" THEN 
                  BEGIN 
                  RP$GROUP = GROUP; 
                  RP$TYPE = RP$T"KEYORDER"; 
#***#             SWCH = SETRP"KEYBOTTOM";
#***#             RETURN; 
                  END 
  
              ELSE
              IF C<0,10>VALUE$C EQ "A" THEN 
                  BEGIN 
#***#             GOTO KEYBOTTOM; 
                  END 
              ELSE  # IF VALUE$C NQ "A" OR "D" THEN THERE IS AN ERROR  #
                  BEGIN 
                  S$ERROR(E$72); # ONLY "A" OR "D" ARW ALLOWED AS A    #
#                    VALUE FOR KEYORDER                                #
                  STATUS$NORML = FALSE; 
                  END 
  
              END 
KEYBOTTOM:  
  
            END  # OF FOR LOOP OF I UNTIL NFILES #
  
#   *   *   *   *   *   *   *   # 
#                               # 
#              L                # 
#                               # 
#   *   *   *   *   *   *   *   # 
  
# HANDLE "L" PARAMETER                                                 #
  
LIST: 
  
          PARAMNM = "L";
          CLP$TP(PARAMNM,SPECIFIED,STATUS$);
          IF NOT SPECIFIED  THEN
              BEGIN 
                  $BEGIN
#??#              MES = " L NOT GIVEN"; 
#??#              S$PRTCD(MES); 
                  FLUSH;
                  $END
  
#               DEFAULT NAME SET LATER                                 #
  
              SWCH = SETRP"LO"; 
#***#         GOTO NEXT;
              END 
#           ELSE GET NAME OF "L" PARAMETER                             #
          # THIS PARAMETER TERMINATES ANY SEQS STUFF                   #
          SEQORD = 0; 
  
          $BEGIN
#??#      MES = " GET L PARAMETER"; 
#??#      S$PRTCD(MES); 
          FLUSH;
          $END
          CLP$GTV(STRING$,PARAMNM,1,1,"LOW",VALUE$,STATUS$);
          IF VALUE$C EQ "$NULL"  THEN 
              S$LFNAM = "0";
          ELSE # CHECK TO SEE IF VALUE IS A PROPER FILE NAME           #
              BEGIN 
              TESTFIL;
              IF BADNAME  THEN
                  BEGIN 
#                   RESET 'BADNAME' TO FALSE AND GOTO NEXT             #
                  BADNAME = FALSE;
                  SWCH = SETRP"LO"; 
#***#             GOTO NEXT;
                  END 
              S$LFNAM = FILNAM; 
              S$OPLF(S$LFNAM);       # OPEN LIST FILE  #
              END 
          $BEGIN
          MES = " S$LFNAM = ";
          C<11,10>MES = S$LFNAM;
#??#      S$PRTCD(MES); 
          FLUSH;
          $END
          SWCH = SETRP"LO"; 
  
  
#   *   *   *   *   *   *   *   # 
#                               # 
#            L O                # 
#                               # 
#   *   *   *   *   *   *   *   # 
  
# HANDLE "LO" PARAMETER                                                #
  
  
LO: 
  
  
          PARAMNM = "LO"; 
          CLP$TP(PARAMNM,SPECIFIED,STATUS$);
          IF NOT SPECIFIED  THEN
              BEGIN 
                  $BEGIN
#??#              MES = " LO NOT GIVEN";
#??#              S$PRTCD(MES); 
                  FLUSH;
                  $END
  
#               BY DEFAULT "LO=S" IS SET(A COPY OF THE DIRECTIVE       #
#               STATEMENTS WILL BE WRITTEN TO THE LISTING FILE         #
#               THIS IS DONE WITHIN STDEFLT                            #
#               OPEN BUFFER WITH S$OPLF(FLN)                           #
  
              SWCH = SETRP"OWNF"; 
#***#         GOTO NEXT;
              END 
  
#           ELSE GET VALUE OF "LO" PARAMETER                           #
          # THIS PARAMETER TERMINATES ANY SEQS STUFF                   #
          SEQORD = 0; 
  
          CLP$GSC(PARAMNM,NSETS,STATUS$);  # GET NUMBER OF SETS        #
          $BEGIN
#??#      MES = " GET LO VALUE "; 
#??#      S$PRTCD(MES); 
          FLUSH;
          $END
          CLP$GTV(STRING$,PARAMNM,1,1,"LOW",VALUE$,STATUS$);
          IF VALUE$C EQ "OFF"  THEN 
              BEGIN 
              S$LFNAM = "0";
              LOSET = "OFF";
              $BEGIN
#??#          MES = " 1ST LO = "; 
#??#          C<9,10>MES = VALUE$C; 
#??#          S$PRTCD(MES); 
              FLUSH;
              $END
              IF NSETS EQ 2  THEN 
                  BEGIN 
                  CLP$GTV(STRING$,PARAMNM,2,1,"LOW",VALUE$,STATUS$);
                  IF VALUE$C EQ "OFF"  THEN 
                      S$LFNAM = "0";
                  ELSE
                  IF VALUE$C EQ "S"  OR  VALUE$C EQ "A"  THEN 
                      BEGIN 
#                       IGNOR THE SECOND VALUE                         #
                      END 
                  ELSE # IF LO NQ OFF,S, OR A  THEN                    #
                      BEGIN 
                      S$ERROR(E$75);  # VALUES ALLOWED FOR THE         #
#                        PARAMETER ARE OFF,S (AND A)                   #
                      STATUS$NORML = FALSE; 
                      SWCH = SETRP"OWNF"; 
#***#                 GOTO NEXT;
                      END 
                  $BEGIN
#??#              MES = " 2ND LO = "; 
#??#              C<9,10>MES = VALUE$C; 
#??#              S$PRTCD(MES); 
                  FLUSH;
                  $END
                  END 
              END 
          ELSE
          IF VALUE$C EQ "S"  THEN 
              BEGIN 
#               GO DO THE SAME AS DEFAULT ABOVE                        #
              LOSET = "S";
              $BEGIN
#??#          MES = " 1ST LO = "; 
#??#          C<9,10>MES = VALUE$C; 
#??#          S$PRTCD(MES); 
              FLUSH;
              $END
              IF NSETS EQ 2  THEN 
                  BEGIN 
                  CLP$GTV(STRING$,PARAMNM,2,1,"LOW",VALUE$,STATUS$);
                  IF VALUE$C EQ "OFF"  THEN 
                      BEGIN 
                      S$LFNAM = "0";
                      S$ERROR(E$60);  #W = CONTRADICTORY VALUES FOR    #
#                        LO PARAMETER FOUND                            #
                      END 
                  ELSE
                  IF VALUE$C EQ "S"  THEN 
                      BEGIN 
#                       GO DO THE SAME AS DEFAULT ABOVE                #
                      END 
                  ELSE
                  IF VALUE$C EQ "A"  THEN 
                      BEGIN 
                      LOSET = "SA"; 
#                       NO CODE AS OF YET                              #
                      END 
                  ELSE # IF LO NQ OFF,S, OR A  THEN                    #
                      BEGIN 
                      S$ERROR(E$75);  # VALUES ALLOWED FOR THE         #
#                        PARAMETER ARE OFF,S (AND A)                   #
                      STATUS$NORML = FALSE; 
                      SWCH = SETRP"OWNF"; 
#***#                 GOTO NEXT;
                      END 
                  $BEGIN
#??#              MES = " 2ND LO = "; 
#??#              C<9,10>MES = VALUE$C; 
#??#              S$PRTCD(MES); 
                  FLUSH;
                  $END
                  END 
              END 
          ELSE
          IF VALUE$C EQ "A"  THEN 
              BEGIN 
#               NO CODE AS OF YET                                      #
              LOSET = "A";
              $BEGIN
#??#          MES = " 1ST LO = "; 
#??#          C<9,10>MES = VALUE$C; 
#??#          S$PRTCD(MES); 
              FLUSH;
              $END
              IF NSETS EQ 2  THEN 
                  BEGIN 
                  CLP$GTV(STRING$,PARAMNM,2,1,"LOW",VALUE$,STATUS$);
                  IF VALUE$C EQ "OFF"  THEN 
                      BEGIN 
                      S$LFNAM = "0";
                      S$ERROR(E$60);  #W = CONTRADICTORY VALUES FOR    #
#                        LO PARAMETER FOUND                            #
                      END 
                  ELSE
                  IF VALUE$C EQ "S"  THEN 
                      BEGIN 
#                       GO DO THE SAME AS DEFAULT ABOVE                #
                      LOSET = "SA"; 
                      END 
                  ELSE
                  IF VALUE$C EQ "A"  THEN 
                      BEGIN 
#                       NO CODE AS OF YET                              #
                      END 
                  ELSE # IF LO NQ OFF,S, OR A  THEN                    #
                      BEGIN 
                      S$ERROR(E$75);  # VALUES ALLOWED FOR THE         #
#                        PARAMETER ARE OFF,S (AND A)                   #
                      STATUS$NORML = FALSE; 
                      END 
                  $BEGIN
#??#              MES = " 2ND LO = "; 
#??#              C<9,10>MES = VALUE$C; 
#??#              S$PRTCD(MES); 
                  FLUSH;
                  $END
                  END 
              END 
          ELSE # IF LO NQ OFF,S, OR A  THEN                            #
              BEGIN 
              S$ERROR(E$75);  # VALUES ALLOWED FOR THE LO              #
#                PARAMETER ARE OFF,S (AND A)                           #
              STATUS$NORML = FALSE; 
              SWCH = SETRP"OWNF"; 
#***#         GOTO NEXT;
              END 
  
  
#   *   *   *   *   *   *   *   # 
#                               # 
#           O W N F             # 
#                               # 
#   *   *   *   *   *   *   *   # 
  
OWNF: 
  
  
# HANDLE "OWNF" PARAMETER                                              #
  
          PARAMNM = "OWNF"; 
          CLP$TP(PARAMNM,SPECIFIED,STATUS$);   # TEST FOR OWNF         #
          IF NOT SPECIFIED  THEN
              BEGIN 
              $BEGIN
#??#          MES = " OWNF NOT SPECIFIED";
#??#          S$PRTCD(MES); 
              FLUSH;
              $END
#***#         GOTO OWNFL; 
              END 
  
# ELSE GET VALUE OF OWNF PARAMETER# 
          # THIS PARAMETER TERMINATES ANY SEQS STUFF                   #
          SEQORD = 0; 
  
          CLP$GTV(STRING$,PARAMNM,1,1,"LOW",VALUE$,STATUS$);
          TESTFIL;
          IF BADNAME  THEN
              BEGIN 
#               RESET 'BADNAME' TO FALSE AND GOTO NEXT                 #
              BADNAME = FALSE;
              SWCH = SETRP"OWNFL";
#***#         GOTO NEXT;
              END 
          RP$TYPE = RP$T"OWNFILE";
          RP$VALUEC = FILNAM; 
          SWCH = SETRP"OWNFL";
#***#     RETURN; 
  
#   *   *   *   *   *   *   *   # 
#                               # 
#          O W N F L            # 
#                               # 
#   *   *   *   *   *   *   *   # 
  
OWNFL:  
  
# HANDLE "OWNFL"  PARAMETER                                            #
  
          PARAMNM = "OWNFL";
          CLP$TP(PARAMNM,SPECIFIED,STATUS$);   # TEST PARAMETER        #
          IF NOT SPECIFIED  THEN
              BEGIN 
              $BEGIN
#??#          MES = " OWNFL SPECFIED "; 
#??#          S$PRTCD(MES); 
              FLUSH;
              $END
#***#         GOTO OFL; 
              END 
  
# ELSE GET VALUE OF "OWNFL" PARAMETER                                  #
          # THIS PARAMETER TERMINATES ANY SEQS STUFF                   #
          SEQORD = 0; 
  
          CLP$GTV(STRING$,PARAMNM,1,1,"LOW",VALUE$,STATUS$);
          CHAR = C<0,10>VALUE$C;
          CHR2NUM;
          RP$TYPE = RP$T"OWNFL";
          RP$VALUE = NUM; 
          SWCH = SETRP"OFL";
#***#     RETURN; 
  
OFL:  
  
# HANDLE "OFL"  PARAMETER                                              #
  
          PARAMNM = "OFL";
          CLP$TP(PARAMNM,SPECIFIED,STATUS$);   # TEST PARAMETER        #
          IF NOT SPECIFIED  THEN
              BEGIN 
              $BEGIN
#??#          MES = " OFL NOT SPECIFIED ";
#??#          S$PRTCD(MES); 
              FLUSH;
              $END
#***#         GOTO OWNMRL;
              END 
  
# ELSE GET VALUE OF "OFL" PARAMETER                                    #
  
          CLP$GTV(STRING$,PARAMNM,1,1,"LOW",VALUE$,STATUS$);
          CHAR = C<0,10>VALUE$C;
          CHR2NUM;
          RP$TYPE = RP$T"OWNFL";
          RP$VALUE = NUM; 
          SWCH = SETRP"OWNMRL"; 
#***#     RETURN; 
  
#   *   *   *   *   *   *   *   # 
#                               # 
#          O W N M R L          # 
#                               # 
#   *   *   *   *   *   *   *   # 
  
OWNMRL: 
  
# HANDLE "OWNMRL" PARAMETER                                            #
  
          PARAMNM = "OWNMRL"; 
          CLP$TP(PARAMNM,SPECIFIED,STATUS$);
          IF NOT SPECIFIED THEN 
              BEGIN 
              $BEGIN
#??#          MES = " OWNMRL NOT GIVEN";
#??#          S$PRTCD(MES); 
              FLUSH;
              $END
#***#         GOTO OMRL;
              END 
  
# ELSE GET VALUE                                                       #
          # THIS PARAMETER TERMINATES ANY SEQS STUFF                   #
          SEQORD = 0; 
  
          CLP$GTV(STRING$,PARAMNM,1,1,"LOW",VALUE$,STATUS$);
          CHAR = C<0,10>VALUE$C;
              CHR2NUM;
              RP$TYPE = RP$T"MRL";
              RP$VALUE = NUM; 
              SWCH = SETRP"OMRL"; 
  
# TEST TO SEE THAT OWNFL WAS NOT ALSO SPECIFIED                        #
  
          CLP$TP("OWNFL",SPECIFIED,STATUS$);
          IF NOT SPECIFIED THEN 
              BEGIN 
#               SEE IF OFL WAS SPECIFIED                               #
  
              CLP$TP("OFL",SPECIFIED,STATUS$);
              IF NOT SPECIFIED THEN 
#***#             RETURN; 
              END 
          ELSE  # IF EITHER WAS SPECIFIED                              #
              BEGIN 
              S$ERROR(E$80); # OWNMRL AND OWNFL SHOULD NOT             #
#                BOTH BE USED FOR THE SAME SORT                        #
              STATUS$NORML = FALSE; 
  
#               DON'T RETURN. DON'T SET RP$T"MRL" WHEN E$80 IS FOUND   #
  
#***#         GOTO OMRL;
              END 
  
OMRL: 
  
# HANDLE   "OMRL" PARAMETER                                            #
  
          PARAMNM =   "OMRL"; 
          CLP$TP(PARAMNM,SPECIFIED,STATUS$);
          IF NOT SPECIFIED THEN 
              BEGIN 
              $BEGIN
#??#          MES = " OMRL NOT GIVEN";
#??#          S$PRTCD(MES); 
              FLUSH;
              $END
#***#         GOTO OWNT;
              END 
  
# ELSE GET VALUE                                                       #
  
          CLP$GTV(STRING$,PARAMNM,1,1,"LOW",VALUE$,STATUS$);
          CHAR = C<0,10>VALUE$C;
          CHR2NUM;
              RP$TYPE = RP$T"MRL";
              RP$VALUE = NUM; 
              SWCH = SETRP"OWNT"; 
  
# TEST TO SEE THAT OWNFL WAS NOT ALSO SPECIFIED                        #
          CLP$TP("OWNFL",SPECIFIED,STATUS$);
          IF NOT SPECIFIED THEN 
              BEGIN 
#               SEE IF OFL WAS SPECIFIED                               #
  
              CLP$TP("OFL",SPECIFIED,STATUS$);
              IF NOT SPECIFIED THEN 
#***#             RETURN; 
              END 
          ELSE  # IF EITHER WAS SPECIFIED                              #
              BEGIN 
              S$ERROR(E$80); # OWNMRL AND OWNFL SHOULD NOT             #
#                BOTH BE USED FOR THE SAME SORT                        #
              STATUS$NORML = FALSE; 
  
#               DON'T RETURN. DON'T SET RP$T"MRL" WHEN E$80 IS FOUND   #
  
              END 
  
#   *   *   *   *   *   *   *   # 
#                               # 
#            O W N T            # 
#                               # 
#   *   *   *   *   *   *   *   # 
  
OWNT: 
  
# HANDLE "OWNT" PARAMETER                                              #
  
          PARAMNM = "OWNT"; 
          CLP$TP(PARAMNM,SPECIFIED,STATUS$);   # TEST FOR OWNT         #
          IF NOT SPECIFIED   THEN 
              BEGIN 
              $BEGIN
#??#          MES = " OWNT NOT GIVEN "; 
#??#          S$PRTCD(MES); 
              FLUSH;
              $END
#***#         GOTO OWN1;
              END 
  
# ELSE GET VALUE OF OWNT PARAMTER                                      #
          # THIS PARAMETER TERMINATES ANY SEQS STUFF                   #
          SEQORD = 0; 
  
          CLP$GTV(STRING$,PARAMNM,1,1,"LOW",VALUE$,STATUS$);
          IF VALUE$C EQ "NEW"  THEN 
              BEGIN 
  
#               DON'T SET RP$ VALUE OR TYPE                            #
  
              $BEGIN
#??#          MES = " OWNT = NEW";
#??#          S$PRTCD(MES); 
              FLUSH;
              $END
              END 
          ELSE
          IF VALUE$C EQ "OLD"  THEN 
              BEGIN 
              $BEGIN
#??#          MES = " OWNT = OLD";
#??#          S$PRTCD(MES); 
              FLUSH;
              $END
              RP$TYPE = RP$T"OWNT"; 
  
#               ONLY RP$TYPE NEEDS TO BE SET                           #
  
              SWCH = SETRP"OWN1"; 
#***#         RETURN; 
              END 
          ELSE  # IF VALUE$C IS NOT OLD OR NEW THEN THERE IS AN ERROR  #
              BEGIN 
              S$ERROR(E$84);  # VALUES ALLOWED FOR THE OWNT            #
#                PARAMETER ARE OLD AND NEW                             #
              END 
  
#   *   *   *   *   *   *   *   # 
#                               # 
#        O W N 1  -  5          # 
#                               # 
#   *   *   *   *   *   *   *   # 
  
OWN1: 
  
# HANDLE "OWN1" PARAMETER                                              #
  
          PARAMNM = "OWN1"; 
          CLP$TP(PARAMNM,SPECIFIED,STATUS$);   # TEST FOR OWN1         #
          IF NOT SPECIFIED  THEN
              BEGIN 
              $BEGIN
#??#          MES = "OWN1 NOT SPECIFIED ";
#??#          S$PRTCD(MES); 
              FLUSH;
              $END
#***#         GOTO OWN2;
              END 
  
# ELSE GET VALUE OF OWN1 PARAMETER                                     #
          # THIS PARAMETER TERMINATES ANY SEQS STUFF                   #
          SEQORD = 0; 
  
          CLP$GTV(STRING$,PARAMNM,1,1,"LOW",VALUE$,STATUS$);
          RP$TYPE = RP$T"OWN1NAME"; 
  
# ONLY THE FIRST 10 CHARACTERS OF OWN1 NAME CAN BE USED                #
  
          TESTLONGNM; 
          IF BADNAME  THEN
              BEGIN 
#               RESET 'BADNAME' TO FALSE AND GOTO NEXT                 #
              BADNAME = FALSE;
              SWCH = SETRP"OWN2"; 
#***#         GOTO NEXT;
              END 
          RP$VALUEC = C<0,10>VALUE$C; 
          SWCH = SETRP"OWN2"; 
#***#     RETURN; 
  
OWN2: 
  
# HANDLE "OWN2" PARAMETER                                              #
  
          PARAMNM = "OWN2"; 
          CLP$TP(PARAMNM,SPECIFIED,STATUS$);   # TEST FOR OWN2         #
          IF NOT SPECIFIED  THEN
              BEGIN 
              $BEGIN
#??#          MES = "OWN2 NOT SPECIFIED ";
#??#          S$PRTCD(MES); 
              FLUSH;
              $END
#***#         GOTO OWN3;
              END 
  
# ELSE GET VALUE OF OWN2 PARAMETER                                     #
          # THIS PARAMETER TERMINATES ANY SEQS STUFF                   #
          SEQORD = 0; 
  
          CLP$GTV(STRING$,PARAMNM,1,1,"LOW",VALUE$,STATUS$);
          RP$TYPE = RP$T"OWN2NAME"; 
  
# ONLY THE FIRST 10 CHARACTERS OF OWN2 NAME CAN BE USED                #
  
          TESTLONGNM; 
          IF BADNAME  THEN
              BEGIN 
#               RESET 'BADNAME' TO FALSE AND GOTO NEXT                 #
              BADNAME = FALSE;
              SWCH = SETRP"OWN3"; 
#***#         GOTO NEXT;
              END 
          RP$VALUEC = C<0,10>VALUE$C; 
          SWCH = SETRP"OWN3"; 
#***#     RETURN; 
  
  
OWN3: 
  
# HANDLE "OWN3" PARAMETER                                              #
  
          PARAMNM = "OWN3"; 
          CLP$TP(PARAMNM,SPECIFIED,STATUS$);   # TEST FOR OWN3         #
          IF NOT SPECIFIED  THEN
              BEGIN 
              $BEGIN
#??#          MES = "OWN3 NOT SPECIFIED ";
#??#          S$PRTCD(MES); 
              FLUSH;
              $END
#***#         GOTO OWN4;
              END 
  
# ELSE GET VALUE OF OWN3 PARAMETER                                     #
          # THIS PARAMETER TERMINATES ANY SEQS STUFF                   #
          SEQORD = 0; 
  
          CLP$GTV(STRING$,PARAMNM,1,1,"LOW",VALUE$,STATUS$);
          RP$TYPE = RP$T"OWN3NAME"; 
  
# ONLY THE FIRST 10 CHARACTERS OF OWN3 NAME CAN BE USED                #
  
          TESTLONGNM; 
          IF BADNAME  THEN
              BEGIN 
#               RESET 'BADNAME' TO FALSE AND GOTO NEXT                 #
              BADNAME = FALSE;
              SWCH = SETRP"OWN4"; 
#***#         GOTO NEXT;
              END 
          RP$VALUEC = C<0,10>VALUE$C; 
          SWCH = SETRP"OWN4"; 
#***#     RETURN; 
  
OWN4: 
  
# HANDLE "OWN4" PARAMETER                                              #
  
          PARAMNM = "OWN4"; 
          CLP$TP(PARAMNM,SPECIFIED,STATUS$);   # TEST FOR OWN4         #
          IF NOT SPECIFIED  THEN
              BEGIN 
              $BEGIN
#??#          MES = "OWN4 NOT SPECIFIED ";
#??#          S$PRTCD(MES); 
              FLUSH;
              $END
#***#         GOTO OWN5;
              END 
  
# ELSE GET VALUE OF OWN4 PARAMETER                                     #
          # THIS PARAMETER TERMINATES ANY SEQS STUFF                   #
          SEQORD = 0; 
  
          CLP$GTV(STRING$,PARAMNM,1,1,"LOW",VALUE$,STATUS$);
          RP$TYPE = RP$T"OWN4NAME"; 
  
# ONLY THE FIRST 10 CHARACTERS OF OWN4 NAME CAN BE USED                #
  
          TESTLONGNM; 
          IF BADNAME  THEN
              BEGIN 
#               RESET 'BADNAME' TO FALSE AND GOTO NEXT                 #
              BADNAME = FALSE;
              SWCH = SETRP"OWN5"; 
#***#         GOTO NEXT;
              END 
          RP$VALUEC = C<0,10>VALUE$C; 
          SWCH = SETRP"OWN5"; 
#***#     RETURN; 
  
OWN5: 
  
# HANDLE "OWN5" PARAMETER                                              #
  
          PARAMNM = "OWN5"; 
          CLP$TP(PARAMNM,SPECIFIED,STATUS$);   # TEST FOR OWN5         #
          IF NOT SPECIFIED  THEN
              BEGIN 
              $BEGIN
#??#          MES = "OWN5 NOT SPECIFIED ";
#??#          S$PRTCD(MES); 
              FLUSH;
              $END
#***#         GOTO RETAIN;
              END 
  
# ELSE GET VALUE OF OWN5 PARAMETER                                     #
          # THIS PARAMETER TERMINATES ANY SEQS STUFF                   #
          SEQORD = 0; 
  
          CLP$GTV(STRING$,PARAMNM,1,1,"LOW",VALUE$,STATUS$);
          RP$TYPE = RP$T"OWN5NAME"; 
  
# ONLY THE FIRST 10 CHARACTERS OF OWN5 NAME CAN BE USED                #
  
          TESTLONGNM; 
          IF BADNAME  THEN
              BEGIN 
#               RESET 'BADNAME' TO FALSE AND GOTO NEXT                 #
              BADNAME = FALSE;
              SWCH = SETRP"RETAIN"; 
#***#         GOTO NEXT;
              END 
          RP$VALUEC = C<0,10>VALUE$C; 
          SWCH = SETRP"RETAIN"; 
#***#     RETURN; 
  
#   *   *   *   *   *   *   *   # 
#                               # 
#         R E T A I N           # 
#                               # 
#   *   *   *   *   *   *   *   # 
  
RETAIN: 
  
# HANDLE "RETAIN" PARAMETER                                            #
  
          PARAMNM = "RETAIN"; 
          CLP$TP(PARAMNM,SPECIFIED,STATUS$);  # TEST FOR RETAIN        #
          IF NOT SPECIFIED  THEN
              BEGIN 
              $BEGIN
#??#          MES = "RETAIN NOT SPECIFIED ";
#??#          S$PRTCD(MES); 
              FLUSH;
              $END
#***#         GOTO RET; 
              END 
  
# ELSE RETAIN WAS SPECIFIED, GET VALUE                                 #
          # THIS PARAMETER TERMINATES ANY SEQS STUFF                   #
          SEQORD = 0; 
  
          CLP$GTV(STRING$,PARAMNM,1,1,"LOW",VALUE$,STATUS$);
          IF VALUE$C EQ "Y"  OR  VALUE$C EQ "YES"  THEN 
              BEGIN 
              RP$TYPE = RP$T"RETAIN"; 
              SWCH = SETRP"RET";
#***#         RETURN; 
              END 
          ELSE
          IF VALUE$C EQ "N"  OR  VALUE$C EQ "NO"  THEN
              BEGIN 
#***#         GOTO RET; 
              END 
  
          ELSE  # IF NOT YES OR NO  THEN                               #
              BEGIN 
              S$ERROR(E$79);  # VALUES ALLOWED FOR THE RETAIN          #
#                       PARAMETER ARE YES AND NO                       #
              STATUS$NORML = FALSE; 
#***#         GOTO RET; 
              END 
  
RET:  
  
# HANDLE "RET" PARAMETER                                               #
  
  
          PARAMNM = "RET";
          CLP$TP(PARAMNM,SPECIFIED,STATUS$);  # TEST FOR RET           #
          IF NOT SPECIFIED  THEN
              BEGIN 
              $BEGIN
#??#          MES = "RET NOT SPECIFIED "; 
#??#          S$PRTCD(MES); 
              FLUSH;
              $END
#***#         GOTO SEQ; 
              END 
  
# ELSE RET WAS SPECIFIED                          /#
          # THIS PARAMETER TERMINATES ANY SEQS STUFF                   #
          SEQORD = 0; 
  
          CLP$GTV(STRING$,PARAMNM,1,1,"LOW",VALUE$,STATUS$);
          IF VALUE$C EQ "Y"  OR  VALUE$C EQ "YES"  THEN 
              BEGIN 
              RP$TYPE = RP$T"RETAIN"; 
              SWCH = SETRP"SEQ";
#***#         RETURN; 
              END 
          ELSE
          IF VALUE$C EQ "N"  OR  VALUE$C EQ "NO"  THEN
              BEGIN 
#***#         GOTO SEQ; 
              END 
  
          ELSE  # IF NOT YES OR NO  THEN                               #
              BEGIN 
              S$ERROR(E$79);  # VALUES ALLOWED FOR THE                 #
#                RETAIN PARAMETER ARE YES AND NO                       #
              STATUS$NORML = FALSE; 
#***#         GOTO SEQ; 
              END 
  
SEQ:  
  
#   *   *   *   *   *   *   *   # 
#                               # 
#           S E Q N             # 
#                               # 
#   *   *   *   *   *   *   *   # 
  
SEQN: 
  
# HANDLE "SEQN" PARAMETER                                              #
  
          $BEGIN
#??#      MES = " SEQN 1";
#??#      S$PRTCD(MES); 
          FLUSH;
          $END
          PARAMNM = "SEQN"; 
          CLP$TP(PARAMNM,SPECIFIED,STATUS$);
          IF NOT SPECIFIED  THEN
              BEGIN 
              $BEGIN
#??#          MES = " NOT SPECIFIED"; 
#??#          S$PRTCD(MES); 
              FLUSH;
              $END
              SWCH = SETRP"SEQA"; 
#***#         GOTO NEXT;
              END 
  
#           ELSE GET VALUE OF "SEQN" PARAMETER                         #
  
          $BEGIN
#??#      MES = " GET SEQN VALUE";
#??#      S$PRTCD(MES); 
          FLUSH;
          $END
          SQRFLG = FALSE; 
          SQAFLG = FALSE; 
          IF SEQORD EQ 1  THEN
              BEGIN 
#               GIVE THE WARNING BELOW                                 #
  
              S$ERROR(E$93);  #W = SEQN GIVEN WITHOUT SEQS OR SEQR     #
#                BEFORE NEXT SEQN                                      #
              END 
  
#           HOW SET THE NEW SEQN NAME IN RP$                           #
  
          CLP$GTV(STRING$,PARAMNM,1,1,"LOW",VALUE$,STATUS$);
          TESTLONGNM; 
          IF BADNAME  THEN
                  BEGIN 
#                   RESET 'BADNAME' TO FALSE AND GOTO NEXT             #
                  BADNAME = FALSE;
                  SWCH = SETRP"SEQA"; 
#***#             GOTO NEXT;
                  END 
          SEQORD = 1; 
          GROUP = S$NEWGR;
  
#           TEST THE SEQUENCE NAME GIVEN                               #
#           IT MUST NOT BE A STANDARD COL-SEQ NAME/TYPE                #
  
          IF VALUE$C EQ "BINARY"      OR
             VALUE$C EQ "BINARY_BIT"  OR
             VALUE$C EQ "REAL"        OR
             VALUE$C EQ "INTEGER"     OR
             VALUE$C EQ "INTEGER_BI"  OR
             VALUE$C EQ "NUMERIC_LO"  OR
             VALUE$C EQ "NUMERIC_LS"  OR
             VALUE$C EQ "NUMERIC_TO"  OR
             VALUE$C EQ "NUMERIC_TS"  OR
             VALUE$C EQ "NUMERIC_NS"  OR
             VALUE$C EQ "NUMERIC_FS"  OR
             VALUE$C EQ "PACKED"      OR
             VALUE$C EQ "PACKED_NS"   OR
             VALUE$C EQ "DISPLAY"     OR
             VALUE$C EQ "ASCII6"      OR
             VALUE$C EQ "COBOL6"      OR
             VALUE$C EQ "EBCDIC6" 
                    THEN
              BEGIN 
              S$ERROR(E$89);  # SEQNAME MUST NOT BE ONE OF THE         #
#                PREDEFINED KEY-TYPES                                  #
              STATUS$NORML = FALSE; 
#***#         GOTO SEQA;
              END 
          ELSE  # SINCE SEQ NAME IS LEGAL                              #
              BEGIN 
              SEQNAM = "  ";
              SEQNAM = VALUE$C; 
              RP$GROUP = GROUP; 
              RP$TYPE = RP$T"SEQNAM"; 
              RP$VALUEC = VALUE$C;
              SWCH = SETRP"SEQA"; 
#***#         RETURN; 
              END 
  
  
  
#   *   *   *   *   *   *   *   # 
#                               # 
#          S E Q A              # 
#                               # 
#   *   *   *   *   *   *   *   # 
  
SEQA: 
  
# HANDLE "SEQA" PARAMETER                                              #
  
  
          $BEGIN
#??#      MES = " SEQA 1";
#??#      S$PRTCD(MES); 
          FLUSH;
          $END
          PARAMNM = "SEQA"; 
          CLP$TP(PARAMNM,SPECIFIED,STATUS$);
          IF NOT SPECIFIED  THEN
              BEGIN 
              $BEGIN
#??#          MES = " SEQA NOT GIVEN";
#??#          S$PRTCD(MES); 
              FLUSH;
              $END
              SWCH = SETRP"SEQR"; 
#***#         GOTO NEXT;
              END 
  
#           ELSE GET VALUE OF "SEQA" PARAMETER                         #
  
          CLP$GTV(STRING$,PARAMNM,1,1,"LOW",VALUE$,STATUS$);
          IF VALUE$C EQ "NO"  OR  VALUE$C EQ "N"  THEN
              BEGIN 
              $BEGIN
#??#          MES = " SEQA IS NO";
#??#          S$PRTCD(MES); 
              FLUSH;
              $END
              SWCH = SETRP"SEQR"; 
#***#         GOTO NEXT;
              END 
          ELSE
          IF VALUE$C EQ "YES"  OR  VALUE$C EQ "Y"   THEN
              BEGIN 
              $BEGIN
#??#          MES = " SEQA IS YES"; 
#??#          S$PRTCD(MES); 
              FLUSH;
              $END
              IF SQAFLG # IS TRUE #  THEN 
#               SEQA HAS ALREADY BEEN SET FOR THIS COL-SEQ             #
  
                  BEGIN 
                  S$ERROR(E$90); # SEQR AND SEQA MAY BE SPECIFIED ONLY #
#                    ONCE FOR EACH COLLATING SEQUENCE                  #
                  STATUS$NORML = FALSE; 
                  SWCH = SETRP"SEQR"; 
#***#             GOTO NEXT;
                  END 
              IF SEQORD EQ 0  THEN
#               SEQN HAS NOT BEEN GIVEN YET                            #
  
                  BEGIN 
                  S$ERROR(E$91);  # SEQN MUST BE SPECIFIED BEFORE ANY  #
#                    OTHER SEQ PARAMETER CAN BE GIVEN                  #
                  STATUS$NORML = FALSE; 
                  SWCH = SETRP"SEQR"; 
#***#             GOTO NEXT;
                  END 
  
#               ELSE NO ERRORS HAVE BEEN FOUND                         #
  
              SQAFLG = TRUE;
              RP$GROUP = GROUP; 
              RP$TYPE = RP$T"SEQA"; 
  
#                NO VALUE NEEDS TO BE SET, TYPE IS SET TO SIGNIFY TRUE #
  
              SWCH = SETRP"SEQR"; 
#***#         RETURN; 
              END 
          ELSE      # A VALUE OTHER THAN YES OR NO WAS GIVEN           #
              BEGIN 
              S$ERROR(E$92);  # VALUES ALLOWED FOR SEQR AND SEQA       #
#                PARAMETERS ARE YES AND NO                             #
              STATUS$NORML = FALSE; 
              SWCH = SETRP"SEQR"; 
#***#         GOTO NEXT;
              END 
  
  
#   *   *   *   *   *   *   *   # 
#                               # 
#           S E Q R             # 
#                               # 
#   *   *   *   *   *   *   *   # 
  
SEQR: 
  
# HANDLE "SEQR" PARAMETER                                              #
  
          $BEGIN
#??#      MES = " SEQR 1";
#??#      S$PRTCD(MES); 
          FLUSH;
          $END
          PARAMNM = "SEQR"; 
          CLP$TP(PARAMNM,SPECIFIED,STATUS$);
          IF NOT SPECIFIED  THEN
              BEGIN 
              $BEGIN
#??#          MES = " SEQR NOT GIVEN";
#??#          S$PRTCD(MES); 
              FLUSH;
              $END
              SWCH = SETRP"SEQS"; 
#***#         GOTO NEXT;
              END 
  
#           ELSE GET VALUE OF "SEQR" PARAMETER                         #
  
          CLP$GTV(STRING$,PARAMNM,1,1,"LOW",VALUE$,STATUS$);
          IF VALUE$C EQ "NO"  OR  VALUE$C EQ "N"  THEN
              BEGIN 
              $BEGIN
#??#          MES = " SEQR IS NO";
#??#          S$PRTCD(MES); 
              FLUSH;
              $END
              SWCH = SETRP"SEQS"; 
#***#         GOTO NEXT;
              END 
          ELSE
          IF VALUE$C EQ "YES"  OR  VALUE$C EQ "Y"   THEN
              BEGIN 
              $BEGIN
#??#          MES = " SEQR IS YES"; 
#??#          S$PRTCD(MES); 
              FLUSH;
              $END
              IF SQRFLG # IS TRUE #  THEN 
#               SEQR HAS ALREADY BEEN SET FOR THIS COL-SEQ             #
  
                  BEGIN 
                  S$ERROR(E$90); # SEQR AND SEQA MAY BE SPECIFIED ONLY #
#                    ONCE FOR EACH COLLATING SEQUENCE                  #
                  STATUS$NORML = FALSE; 
                  SWCH = SETRP"SEQS"; 
#***#             GOTO NEXT;
                  END 
              IF SEQORD EQ 0  THEN
#               SEQN HAS NOT BEEN GIVEN YET                            #
  
                  BEGIN 
                  S$ERROR(E$91);  # SEQN MUST BE SPECIFIED BEFORE ANY  #
#                    OTHER SEQ PARAMETER CAN BE GIVEN                  #
                  STATUS$NORML = FALSE; 
                  SWCH = SETRP"SEQS"; 
#***#             GOTO NEXT;
                  END 
  
#               ELSE NO ERRORS HAVE BEEN FOUND                         #
  
              SQRFLG = TRUE;
              RP$GROUP = GROUP; 
              RP$TYPE = RP$T"SEQVAL"; 
              RP$VALUE =  -1; 
              SWCH = SETRP"SEQS"; 
          SEQORD = 2; 
#***#         RETURN; 
              END 
          ELSE      # A VALUE OTHER THAN YES OR NO WAS GIVEN           #
              BEGIN 
              S$ERROR(E$92);  # VALUES ALLOWED FOR SEQR AND SEQA       #
#                PARAMETERS ARE YES AND NO                             #
              STATUS$NORML = FALSE; 
              SWCH = SETRP"SEQS"; 
#***#         GOTO NEXT;
              END 
#   *   *   *   *   *   *   *   # 
#                               # 
#            S E Q S             #
#                               # 
#   *   *   *   *   *   *   *   # 
  
SEQS: 
  
# HANDLE "SEQS" PARAMETER                                              #
          $BEGIN
#??#      MES = " SEQS 1";
#??#      S$PRTCD(MES); 
          FLUSH;
          $END
          PARAMNM = "SEQS"; 
          CLP$TP(PARAMNM,SPECIFIED,STATUS$);
          IF NOT SPECIFIED  THEN
              BEGIN 
              $BEGIN
              MES = " SEQS NOT GIVEN";
#??#          S$PRTCD(MES); 
              FLUSH;
              $END
              SWCH = SETRP"SUM";
#***#         GOTO NEXT;
              END 
  
          IF SEQORD EQ 0  THEN  # A SEQN HAS NOT YET BEEN FOUND        #
              BEGIN 
              S$ERROR(E$91);  # SEQN MUST BE SPECIFIED BEFORE ANY      #
#                OTHER SEQ PARAMETER CAN BE GIVEN                      #
              STATUS$NORML = FALSE; 
              SWCH = SETRP"SUM";
#***#         GOTO NEXT;
              END 
  
  
          SEQORD = 2; 
#           ELSE GET VALUE OF "SEQS" PARAMETER                         #
  
          FOR I=1 STEP 1 UNTIL 64  DO 
              BEGIN 
              FOR J=1 STEP 1 UNTIL 10  DO 
                  BEGIN 
                  SEQ$RANGS[I,J] = -1;
                  END   # FOR OF J #
              END  # FOR OF I # 
          CLP$GSC(PARAMNM,NSETS,STATUS$); 
          IF NSETS GR 1  THEN 
              EQUGRP = S$NEWGR; 
  
          $BEGIN
#??#      MES = " NSETS = ";
#??#      C<8,10>MES = DEC(NSETS);
#??#      S$PRTCD(MES); 
          FLUSH;
          $END
          CLP$TR(STRING$,PARAMNM,1,1,RANGSPEC,STATUS$); 
  
#           EITHER THE VALUE(S) FOR SEQS ARE GIVEN AS A RANGE          #
#           OR GIVEN AS A SINGLE VALUE.  THE VALUES MAY BE             #
#           EITHER A STRING OR $CHAR(N) WHERE N IS AN INTEGER          #
  
          IF RANGSPEC  THEN   # A RANGE WAS USED IN THE FIRST VALUE-SET#
  
#               EACH OF THE CHARACTERS IN THIS RANGE ARE ORDERED       #
#               ELEMENTS OF THE COLLATING SEQUENCE                     #
  
              BEGIN 
              $BEGIN
#??#          MES = " RANGE SPECIFIED"; 
#??#          S$PRTCD(MES); 
              FLUSH;
              $END
              CLP$GTV(STRING$,PARAMNM,1,1,"LOW",VALUE$,STATUS$);
              GINVAL;  # CONVERT VALUE$ TO OCTAL REPRESENTATION        #
              LOW = NUM;
              CLP$GTV(STRING$,PARAMNM,1,1,"HIGH",VALUE$,STATUS$); 
              GINVAL; 
              HIGH = NUM; 
              RESTOFRANG;  # FIND FULL RANGE OF CHAR FROM LOW TO HIGH  #
#               SAVE THIS FIRST ARRAY IN ANOTHER ARRAY                 #
              SEQ1STRLEN = RANGLEN; 
              IF NSETS EQ 1  THEN 
                  BEGIN 
                  FOR J = 1 STEP 1 UNTIL RANGLEN  DO
                      BEGIN 
                      RP$TYPE = RP$T"SEQVAL"; 
                      RP$VALUE = RANG$TEMP[J];
                      RP$GROUP = GROUP; 
                          $BEGIN
#??#                      MES = " RP$VALUE = "; 
#??#                      DECX = DEC(RP$VALUE); 
#??#                      C<12,10>MES = DECX; 
#??#                      S$PRTCD(MES); 
                          FLUSH;
                          $END
                      SWCH = SETRP"SEQSFOR1"; 
#***#                 RETURN; 
SEQSFOR1: 
                          $BEGIN
#??#                      MES = " SEQSFOR1";
#??#                      S$PRTCD(MES); 
                          FLUSH;
                          $END
                      END   # OF FOR #
                      SWCH = SETRP"SEQSEND";
#***#                 GOTO NEXT;
                  END 
  
#               OTHERWISE MORE THAN ONE RANGE WAS SPECIFIED            #
  
              FOR J =1 STEP 1 UNTIL RANGLEN  DO 
                  BEGIN 
                  SEQ$RANGS[J,1] = RANG$TEMP[J];
                  END 
  
  
              FOR I=2 STEP 1 UNTIL NSETS  DO
                  BEGIN 
                  CLP$TR(STRING$,PARAMNM,I,1,RANGSPEC,STATUS$); 
                  IF RANGSPEC  THEN 
                      BEGIN 
                      CLP$GTV(STRING$,PARAMNM,I,1,"LOW",VALUE$
                                            ,STATUS$);
                      GINVAL; 
                      LOW = NUM;
                      CLP$GTV(STRING$,PARAMNM,I,1,"HIGH",VALUE$ 
                                            ,STATUS$);
                      GINVAL; 
                      HIGH = NUM; 
                      RESTOFRANG; 
  
#                       TEST LENGTH OF THIS RANGE TO THAT OF THE FIRST #
  
                      IF RANGLEN # OF NEW RANGE # NQ SEQ1STRLEN   THEN
                          BEGIN 
                          S$ERROR(E$56); # IF THE FIRST VALUE OF A SEQS#
#                            IS A RANGE THEN ALL OTHER VALUES OF THAT  #
#                            SEQS MUST BE RANGES OF THE SAME LENGTH    #
                          STATUS$NORML = FALSE; 
                          SWCH = SETRP"SUM";
#***#                     GOTO NEXT;
                          END 
#                       ELSE THE TWO RANGES HAVE THE SAME LENGTH       #
  
                      FOR J = 1 STEP 1 UNTIL RANGLEN  DO
                          BEGIN 
                          SEQ$RANGS[J,I] = RANG$TEMP[J];
                          END 
                      END 
                  IF NOT RANGSPEC  THEN  # A SINGLE VALUE WAS FOUND    #
                      BEGIN 
                      S$ERROR(E$56);  # IF THE FIRST VALUE OF A SEQS   #
#                        IS A RANGE THEN ALL OTHER VALUES OF THAT      #
#                        SEQS MUST BE RANGES OF THE SAME LENGTH        #
                      STATUS$NORML = FALSE; 
                      SWCH = SETRP"SUM";
#***#                 GOTO NEXT;
                      END 
  
                  END   # OF FOR I #
  
#               SET RP$VALUES FOR THE RANGES FOUND                     #
  
              FOR J = 1 STEP 1 UNTIL SEQ1STRLEN  DO 
                  BEGIN 
                  RP$GROUP = EQUGRP;
                  RP$TYPE = RP$T"EQUNAM"; 
                  RP$VALUEC = SEQNAM; 
                          $BEGIN
#??#                      MES = " RP$VALUEC = ";
#??#                      C<13,10>MES = C<0,10>RP$VALUEC; 
#??#                      S$PRTCD(MES); 
                          FLUSH;
                          $END
                  SWCH = SETRP"SEQSFOR2"; 
#***#             RETURN; 
SEQSFOR2: 
                          $BEGIN
#??#                      MES = " SEQSFOR2";
#??#                      S$PRTCD(MES); 
                          FLUSH;
                          $END
                  FOR I = 1 STEP 1 UNTIL NSETS  DO
                      BEGIN 
                      RP$GROUP = GROUP; 
                      RP$TYPE = RP$T"SEQVAL"; 
                      RP$VALUE = SEQ$RANGS[J,I];
                          $BEGIN
#??#                      MES = " RP$VALUE = "; 
#??#                      DECX = DEC(RP$VALUE); 
#??#                      C<12,10>MES = DECX; 
#??#                      S$PRTCD(MES); 
                          FLUSH;
                          $END
                      SWCH = SETRP"SEQSFOR3"; 
#***#                 RETURN; 
SEQSFOR3: 
                          $BEGIN
#??#                      MES = " SEQSFOR3";
#??#                      S$PRTCD(MES); 
                          FLUSH;
                          $END
                  RP$GROUP = EQUGRP;
                      RP$TYPE = RP$T"EQUVAL"; 
                      RP$VALUE = SEQ$RANGS[J,I];
                          $BEGIN
#??#                      MES = " RP$VALUE = "; 
#??#                      DECX = DEC(RP$VALUE); 
#??#                      C<12,10>MES = DECX; 
#??#                      S$PRTCD(MES); 
                          FLUSH;
                          $END
                      SWCH = SETRP"SEQSFOR4"; 
#***#                 RETURN; 
SEQSFOR4: 
                          $BEGIN
#??#                      MES = " SEQSFOR4";
#??#                      S$PRTCD(MES); 
                          FLUSH;
                          $END
                      END  # OF FOR OF I #
                  END   # OF FOR J #
              END 
  
          ELSE # A RANGE WAS NOT GIVEN FOR THE FIRST VALUE-SET         #
  
#               ELEMENTS OF THIS SEQS ARE EQUATED TO THIS FIRST VALUE  #
  
              BEGIN 
              $BEGIN
#??#          MES = " SINGLE VALUE SPECIFIED";
#??#          S$PRTCD(MES); 
              FLUSH;
              $END
              CLP$GTV(STRING$,PARAMNM,1,1,"LOW",VALUE$,STATUS$);
              GINVAL; 
              IF NSETS EQ 1  THEN 
                  BEGIN 
                  RP$GROUP = GROUP; 
                  RP$TYPE = RP$T"SEQVAL"; 
                  RP$VALUE = NUM; 
                          $BEGIN
#??#                      MES = " RP$VALUE = "; 
#??#                      DECX = DEC(RP$VALUE); 
#??#                      C<12,10>MES = DECX; 
#??#                      S$PRTCD(MES); 
                          FLUSH;
                          $END
                  SWCH = SETRP"SUM";
#***#             RETURN; 
                  END 
#               ELSE LOOK AT OTHER VALUES GIVEN                        #
  
                  RP$GROUP = EQUGRP;
              RP$TYPE = RP$T"EQUNAM"; 
              RP$VALUEC = SEQNAM; 
                          $BEGIN
#??#                      MES = " RP$VALUEC = ";
#??#                      C<13,10>MES = C<0,10>RP$VALUEC; 
#??#                      S$PRTCD(MES); 
                          FLUSH;
                          $END
              SWCH = SETRP"SEQS5";
#***#         RETURN; 
SEQS5:  
                          $BEGIN
#??#                      MES = " SEQS5"; 
#??#                      S$PRTCD(MES); 
                          FLUSH;
                          $END
              RP$GROUP = GROUP; 
              RP$TYPE = RP$T"SEQVAL"; 
              RP$VALUE = NUM; 
                          $BEGIN
#??#                  MES = " RP$VALUE = "; 
#??#                  DECX = DEC(RP$VALUE); 
#??#                  C<12,10>MES = DECX; 
#??#                  S$PRTCD(MES); 
                      FLUSH;
                          $END
              SWCH = SETRP"SEQS5B"; 
#***#         RETURN; 
SEQS5B: 
                          $BEGIN
#??#                  MES = " SEQS5B";
#??#                  S$PRTCD(MES); 
                      FLUSH;
                          $END
              RP$GROUP = EQUGRP;
              RP$TYPE = RP$T"EQUVAL"; 
              RP$VALUE = NUM; 
                          $BEGIN
#??#                  MES = " RP$VALUE = "; 
#??#                  DECX = DEC(RP$VALUE); 
#??#                  C<12,10>MES = DECX; 
#??#                  S$PRTCD(MES); 
                      FLUSH;
                          $END
              SWCH = SETRP"SEQS5C"; 
#***#         RETURN; 
SEQS5C: 
                          $BEGIN
#??#                  MES = " SEQS5C";
#??#                  S$PRTCD(MES); 
                      FLUSH;
                          $END
              FOR I = 2 STEP 1 UNTIL NSETS  DO
                  BEGIN 
                  CLP$TR(STRING$,PARAMNM,I,1,RANGSPEC,STATUS$); 
                  IF RANGSPEC  THEN 
                      BEGIN 
                      CLP$GTV(STRING$,PARAMNM,I,1,"LOW",VALUE$,STATUS$);
                      GINVAL; 
                      LOW = NUM;
                      CLP$GTV(STRING$,PARAMNM,I,1,"HIGH",VALUE$ 
                                                 ,STATUS$); 
                      GINVAL; 
                      HIGH = NUM; 
                      RESTOFRANG; 
                      FOR J=1 STEP 1 UNTIL RANGLEN  DO
                          BEGIN 
#               SINCE WE CALLED RESTOFRANG TO STORE RANGE IN AN ARRAY, #
#               WE SHOULD GET THE VALUES FROM THERE.                   #
                          SEQ$RANGS[J,I] = RANG$TEMP[J];
                          RP$GROUP = GROUP; 
                          RP$TYPE = RP$T"SEQVAL"; 
                          RP$VALUE = SEQ$RANGS[J,I];
                          $BEGIN
#??#                      MES = " RP$VALUE = "; 
#??#                      DECX = DEC(RP$VALUE); 
#??#                      C<12,10>MES = DECX; 
#??#                      S$PRTCD(MES); 
                          FLUSH;
                          $END
                          SWCH = SETRP"SEQSFOR6"; 
#***#                     RETURN; 
SEQSFOR6: 
                          $BEGIN
#??#                      MES = " SEQSFOR6";
#??#                      S$PRTCD(MES); 
                          FLUSH;
                          $END
                          RP$GROUP = EQUGRP;
                          RP$TYPE = RP$T"EQUVAL"; 
                          RP$VALUE = SEQ$RANGS[J,I];
                          $BEGIN
#??#                      MES = " RP$VALUE = "; 
#??#                      DECX = DEC(RP$VALUE); 
#??#                      C<12,10>MES = DECX; 
#??#                      S$PRTCD(MES); 
                          FLUSH;
                          $END
                          SWCH = SETRP"SEQSFOR7"; 
#***#                     RETURN; 
SEQSFOR7: 
                          $BEGIN
#??#                      MES = " SEQSFOR7";
#??#                      S$PRTCD(MES); 
                          FLUSH;
                          $END
                          END  # OF FOR J # 
                      END  # OF FOR I # 
                  IF NOT RANGSPEC  THEN 
                      BEGIN 
                      CLP$GTV(STRING$,PARAMNM,I,1,"LOW",VALUE$,STATUS$);
                      GINVAL; 
                      RP$GROUP = GROUP; 
                      RP$TYPE = RP$T"SEQVAL"; 
                      RP$VALUE = NUM; 
                          $BEGIN
#??#                      MES = " RP$VALUE = "; 
#??#                      DECX = DEC(RP$VALUE); 
#??#                      C<12,10>MES = DECX; 
#??#                      S$PRTCD(MES); 
                          FLUSH;
                          $END
                      SWCH = SETRP"SEQSFOR8"; 
#***#                 RETURN; 
SEQSFOR8: 
                          $BEGIN
#??#                      MES = " SEQSFOR8";
#??#                      S$PRTCD(MES); 
                          FLUSH;
                          $END
                      RP$GROUP = EQUGRP;
                      RP$TYPE = RP$T"EQUVAL"; 
                      RP$VALUE = NUM; 
                          $BEGIN
#??#                      MES = " RP$VALUE = "; 
#??#                      DECX = DEC(RP$VALUE); 
#??#                      C<12,10>MES = DECX; 
#??#                      S$PRTCD(MES); 
                          FLUSH;
                          $END
                      SWCH = SETRP"SEQSFOR9"; 
#***#                 RETURN; 
SEQSFOR9: 
                      END 
                  END 
              END 
  
SEQSEND:  
              RP$TYPE = RP$T"NONE";  # THIS IS A KLUDGE                #
                                       # TO MAKE SEQS WORK             #
                                       # WITH RANGE SPECIFIED          #
  
  
  
  
#   *   *   *   *   *   *   *   # 
#                               # 
#             S U M              #
#                               # 
#   *   *   *   *   *   *   *   # 
  
SUM:  
  
# HANDLE "SUM" PARAMETER                                               #
  
  
              $BEGIN
#??#          MES = "GTCSP-TEST SUM 1"; 
#??#          S$PRTCD(MES); 
              FLUSH;
              $END
          PARAMNM = "SUM";
          CLP$TP(PARAMNM,SPECIFIED,STATUS$);
          IF NOT SPECIFIED  THEN
              BEGIN 
                  $BEGIN
#??#              MES = "GTCSP-TEST SUM 2"; 
#??#              S$PRTCD(MES); 
                  FLUSH;
                  $END
              SWCH = SETRP"TO"; 
#***#         GOTO NEXT;
              END 
  
#           ELSE GET VALUE OF "SUM" PARAMETER                          #
          # THIS PARAMETER TERMINATES ANY SEQS STUFF                   #
          SEQORD = 0; 
  
              $BEGIN
              MES = "GTCSP-TEST SUM 3"; 
#??#          S$PRTCD(MES); 
              FLUSH;
  
              $END
          CLP$GSC(PARAMNM,NFILES,STATUS$);
              $BEGIN
              MES = " NFILES = "; 
#??#          C<10,10>MES = DEC(NFILES);
#??#          S$PRTCD(MES); 
              FLUSH;
              $END
  
#           LOOK AT INDIVIDUAL VALUES WITHIN EACH SET                  #
          FOR I=1 STEP 1 UNTIL NFILES  DO 
              BEGIN 
              $BEGIN
              MES = "GTCSP-TEST SUM 4"; 
              S$PRTCD(MES); 
              FLUSH;
              $END
              CLP$GVC(STRING$,PARAMNM,I,VALCOUNT,STATUS$);
                  $BEGIN
                  MES = "GTCSP-TEST SUM 5"; 
                  S$PRTCD(MES); 
                  FLUSH;
#??#              MES = " VALCOUNT = "; 
#??#              C<12,10>MES = DEC(VALCOUNT);
#??#              S$PRTCD(MES); 
                  FLUSH;
                  $END
              IF VALCOUNT EQ 0  THEN
                  BEGIN 
                  SWCH = SETRP"TO"; 
#***#             GOTO NEXT;
                  END 
              CLP$TR(STRING$,PARAMNM,I,1,RANGSPEC,STATUS$); 
              IF RANGSPEC  THEN  # A RANGE WAS USED IN THIS VAL-SET    #
                  BEGIN 
                  $BEGIN
#??#              MES = " RANGSPEC IS TRUE "; 
#??#              S$PRTCD(MES); 
                  FLUSH;
                  $END
                  IF VALCOUNT GQ 4  THEN
                      BEGIN 
                      S$ERROR(E$51, "   ", 0);  # ONLY 3 VALUES CAN BE #
#                        GIVEN IN KEY/SUM VALUE-SET IF F..L FORMAT IS  #
#                        USED                                          #
                      STATUS$NORML = FALSE; 
                      END 
                  TYPEPOS = 2;
                  ORDERPOS = 3; 
                  END 
              ELSE  # A RANGE WAS NOT FOUND                            #
                  BEGIN 
                  $BEGIN
#??#              MES = " RANGSPEC IS FALSE"; 
#??#              S$PRTCD(MES); 
                  FLUSH;
                  $END
                  IF VALCOUNT EQ 1  THEN
                      BEGIN 
                      $BEGIN
#??#                  MES = "SUM-TEST LINE 1380"; 
#??#                  S$PRTCD(MES); 
                      FLUSH;
                      $END
                      TYPEPOS = 2;
                      ORDERPOS = 3; 
                      END 
                  IF VALCOUNT GQ 2  THEN
                    BEGIN 
                    CLP$GTV(STRING$,PARAMNM,I,2,"LOW",VALUE$,STATUS$);
                    IF C<0,1>VALUE$C GQ "0" AND C<0,1>VALUE$C LQ "9"
                        THEN
                      BEGIN 
                      YESL = TRUE;
                      TYPEPOS = 3;
                      ORDERPOS = 4; 
                      END 
                    ELSE  # VALUE IS NOT A NUMBER                      #
                      BEGIN 
                      S$ERROR(E$70);  # KEY/SUM LENGTH MUST BE         #
#                        SPECIFIED IF KEY/SUM TYPE IS SPECIFIED        #
                      STATUS$NORML = FALSE; 
                      YESL = FALSE; 
                      TYPEPOS = 3;
                      ORDERPOS = 4; 
                      END 
                    END 
                  END 
  
              GROUP = S$NEWGR;
              IF VALCOUNT GQ TYPEPOS  THEN
                  BEGIN 
                  CLP$GTV(STRING$,PARAMNM,I,TYPEPOS,"LOW",VALUE$, 
                                  STATUS$); 
  
#               TEST THE 'TYPE' VALUE WITHIN THE SET TO DETERMINE IF   #
#               IT'S A KNOWN KEYTYPE OR A USER SUPPLIED COL-SEQ NAME   #
  
                  TESTLONGNM; 
                  IF BADNAME  THEN
                      BEGIN 
#                       RESET 'BADNAME' TO FALSE AND GOTO NEXT         #
                      BADNAME = FALSE;
                      SWCH = SETRP"SUMBOTTOM";
#***#                 GOTO NEXT;
                      END 
                  KEYNAME = C<0,10>VALUE$C; 
  
#                   SET KEYTYPE FOR GIVEN KEYNAME                      #
  
                  RP$GROUP = GROUP; 
                  RP$TYPE = RP$T"SUMTYPE";
                  SWCH = SETRP"SUMLOP1";  # UNLESS OTHERWISE SPECIFIED #
  
                  IF KEYNAME EQ "BINARY"  THEN
                      BEGIN 
                      RP$VALUE = KT$T"LOGICAL"; 
#***#                 RETURN; 
                      END 
                  ELSE
                  IF KEYNAME EQ  "BINARY_BIT" THEN
                      BEGIN 
                      RP$VALUE = KT$T"LOGICAL"; 
                      SWCH = SETRP"SUMLOP3";
#***#                 RETURN; 
                      END 
                  ELSE
                  IF KEYNAME EQ "REAL"  THEN
                      BEGIN 
                      RP$VALUE = KT$T"FLOAT"; 
#***#                 RETURN; 
                      END 
                  ELSE
                  IF KEYNAME EQ "INTEGER"  THEN 
                      BEGIN 
                      RP$VALUE = KT$T"INTEGER"; 
#***#                 RETURN; 
                      END 
                  ELSE
                  IF KEYNAME EQ  "INTEGER_BI"  THEN 
                      BEGIN 
                      RP$VALUE = KT$T"INTEGER"; 
                      SWCH = SETRP"SUMLOP3";
#***#                 RETURN; 
                      END 
                  ELSE
                  IF KEYNAME EQ "NUMERIC_LO"  THEN
                      BEGIN 
                      RP$VALUE = KT$T"NUMERICLO"; 
#***#                 RETURN; 
                      END 
                  ELSE
                  IF KEYNAME EQ "NUMERIC_LS"  THEN
                      BEGIN 
                      RP$VALUE = KT$T"NUMERICLS"; 
#***#                 RETURN; 
                      END 
                  ELSE
                  IF KEYNAME EQ "NUMERIC_TO"  THEN
                      BEGIN 
                      RP$VALUE = KT$T"NUMERICTO"; 
#***#                 RETURN; 
                      END 
                  ELSE
                  IF KEYNAME EQ "NUMERIC_TS"  THEN
                      BEGIN 
                      RP$VALUE = KT$T"NUMERICTS"; 
#***#                 RETURN; 
                      END 
                  ELSE
                  IF KEYNAME EQ "NUMERIC_NS"  THEN
                      BEGIN 
                      RP$VALUE = KT$T"NUMERICNS"; 
#***#                 RETURN; 
                      END 
                  ELSE
                  IF KEYNAME EQ "NUMERIC_FS"  THEN
                      BEGIN 
                      RP$VALUE = KT$T"NUMERICFS"; 
#***#                 RETURN; 
                      END 
                  ELSE
                  IF KEYNAME EQ "PACKED"  THEN
                      BEGIN 
                      RP$VALUE = KT$T"PACKED";
#***#                 RETURN; 
                      END 
                  ELSE
                  IF KEYNAME EQ "PACKED_NS" THEN
                      BEGIN 
                      RP$VALUE = KT$T"PACKEDNS";
#***#                 RETURN; 
                      END 
  
                  ELSE  # SINCE NONE OF THE ABOVE SUMTYPE WERE USED    #
                        # THE KEYNAME IS AN ERROR                      #
  
                      BEGIN 
                  S$ERROR(E$86);  # NUMERIC TYPES ARE THE ONLY TYPES   #
#                        VALID FOR A SUM FIELD                         #
                      STATUS$NORML = FALSE; 
#***#                 GOTO SUMLOP1; 
                      END 
                  END 
  
              ELSE  # SINCE NO TYPE WAS SPECIFIED,                     #
                    # SET DEFAULT SUM TYPE - INTEGER - INTO RP$        #
  
                  BEGIN 
                  RP$GROUP = GROUP; 
                  RP$TYPE = RP$T"SUMTYPE";
                  SWCH = SETRP"SUMLOP1";  # UNLESS OTHERWISE SPECIFIED #
                  RP$VALUE = KT$T"INTEGER"; 
#***#             RETURN; 
                  END 
  
SUMLOP1:  
#               PROCESS (FIRST) BYTE POSITION OF SUM FIELD             #
  
              CLP$GTV(STRING$,PARAMNM,I,1,"LOW",VALUE$,STATUS$);
              CHAR = C<0,10>VALUE$C;
              IF C<0,1>CHAR LS "0"  OR
                 C<0,1>CHAR GR "9"  THEN
                  BEGIN 
                  S$ERROR(E$88);  # BYTE/BIT POSITION OR LENGTH        #
#                    OF A SUM/KEY FIELD MUST BE AN INTEGER             #
                  STATUS$NORML = FALSE; 
                  END 
              CHR2NUM;
              IF NUM EQ 0 THEN
                  BEGIN 
                  S$ERROR(E$119);  # ZERO LENGTH NOT VALID #
                  STATUS$NORML = FALSE; 
                  END 
              F = NUM;
              RP$GROUP = GROUP; 
              RP$TYPE = RP$T"SUMBYTEPOS"; 
              RP$VALUE = F; 
              SWCH = SETRP"SUMLOP2";
#***#         RETURN; 
SUMLOP2:  
#               PROCESS LENGTHS (IN BYTES) OF SUM FIELD                #
  
              IF RANGSPEC THEN
                  BEGIN 
                  CLP$GTV(STRING$,PARAMNM,I,1,"HIGH",VALUE$,STATUS$); 
                  CHAR = C<0,10>VALUE$C;
                  IF C<0,1>CHAR LS "0"  OR
                     C<0,1>CHAR GR "9"  THEN
                      BEGIN 
                      S$ERROR(E$88);  # BYTE/BIT POSITION OR LENGTH    #
#                        OF A SUM/KEY FIELD MUST BE AN INTEGER         #
                      STATUS$NORML = FALSE; 
                      END 
                  CHR2NUM;
  
# CHECK THAT LAST GQ FIRST                                             #
  
                  IF F GR NUM  THEN 
                      BEGIN 
                      S$ERROR(E$85);   # IN A KEY/SUM VALUE-SET USING  #
#                       FIRST..LAST, LAST IS LESS THAN FIRST           #
                      STATUS$NORML = FALSE; 
  
# SET LENGTH = 1 WHEN ERROR OCCURS                                     #
  
                      NUM = 1;
                      END 
                  ELSE  # IF F LQ NUM                                  #
                      NUM = NUM - F + 1;
                  END 
              IF NOT RANGSPEC  THEN 
                  BEGIN 
                  IF VALCOUNT EQ 1  THEN
                      BEGIN 
                      L = 1;   # DEFAULT LENGTH IS SET                 #
                      RP$GROUP = GROUP; 
                      RP$TYPE = RP$T"SUMNBYTES";
                      RP$VALUE = L; 
                      SWCH = SETRP"SUMLOP5";
#***#                 RETURN; 
                      END 
#                   ELSE  IF VALCOUNT GQ 2  THEN                       #
                  CLP$GTV(STRING$,PARAMNM,I,2,"LOW",VALUE$,STATUS$);
                  CHAR = C<0,10>VALUE$C;
                  IF C<0,1>CHAR LS "0"  OR
                     C<0,1>CHAR GR "9"  THEN
                      BEGIN 
                      S$ERROR(E$88);  # BYTE/BIT POSITION OR LENGTH    #
#                        OF A SUM/KEY FIELD MUST BE AN INTEGER         #
                      STATUS$NORML = FALSE; 
                      END 
                  CHR2NUM;
              IF NUM EQ 0 THEN
                  BEGIN 
                  S$ERROR(E$119);  # ZERO LENGTH NOT VALID #
                  STATUS$NORML = FALSE; 
                  END 
                  END 
  
#               ELSE SET LENGTH                                        #
  
              L = NUM;
              RP$GROUP = GROUP; 
              RP$TYPE = RP$T"SUMNBYTES";
              RP$VALUE = L; 
              SWCH = SETRP"SUMLOP5";
#***#         RETURN; 
  
SUMLOP3:  
#               PROCESS (FIRST) BIT POSITION OF SUM FIELD              #
              CLP$GTV(STRING$,PARAMNM,I,1,"LOW",VALUE$,STATUS$);
              CHAR = C<0,10>VALUE$C;
              IF C<0,1>CHAR LS "0"  OR
                 C<0,1>CHAR GR "9"  THEN
                  BEGIN 
                  S$ERROR(E$88);  # BYTE/BIT POSITION OR LENGTH        #
#                    OF A SUM/KEY FIELD MUST BE AN INTEGER             #
                  STATUS$NORML = FALSE; 
                  END 
              CHR2NUM;
              F = NUM;
              RP$GROUP = GROUP; 
              RP$TYPE = RP$T"SUMBITPOS";
              RP$VALUE = F; 
              SWCH = SETRP"SUMLOP4";
#***#         RETURN; 
SUMLOP4:  
#               PROCESS LENGTH (IN BITS) OF SUM FIELD                  #
  
              IF RANGSPEC THEN
                  BEGIN 
                  CLP$GTV(STRING$,PARAMNM,I,1,"HIGH",VALUE$,STATUS$); 
                  CHAR = C<0,10>VALUE$C;
                  IF C<0,1>CHAR LS "0"  OR
                     C<0,1>CHAR GR "9"  THEN
                      BEGIN 
                      S$ERROR(E$88);  # BYTE/BIT POSITION OR LENGTH    #
#                        OF A SUM/KEY FIELD MUST BE AN INTEGER         #
                      STATUS$NORML = FALSE; 
                      END 
                  CHR2NUM;
  
# CHECK THAT LAST GQ FIRST                                             #
  
                  IF F GR NUM  THEN 
                      BEGIN 
                      S$ERROR(E$85);   # IN A KEY/SUM VALUE-SET USING  #
#                       FIRST..LAST, LAST IS LESS THAN FIRST           #
                      STATUS$NORML = FALSE; 
  
# SET LENGTH = 1 WHEN ERROR OCCURS                                     #
  
                      NUM = 1;
                      END 
                  ELSE  # IF F LQ NUM                                  #
                      NUM = NUM - F + 1;
                  END 
              IF NOT RANGSPEC  THEN 
                  BEGIN 
                  IF VALCOUNT EQ 1  THEN
                      BEGIN 
                      L = 1;   # DEFAULT LENGTH IS SET                 #
                      RP$GROUP = GROUP; 
                      RP$TYPE = RP$T"SUMNBITS"; 
                      RP$VALUE = L; 
                      SWCH = SETRP"SUMLOP5";
#***#                 RETURN; 
                      END 
#                   ELSE  IF VALCOUNT GQ 2  THEN                       #
                  CLP$GTV(STRING$,PARAMNM,I,2,"LOW",VALUE$,STATUS$);
                  IF C<0,1>CHAR LS "0"  OR
                     C<0,1>CHAR GR "9"  THEN
                      BEGIN 
                      S$ERROR(E$88);  # BYTE/BIT POSITION OR LENGTH    #
#                        OF A SUM/KEY FIELD MUST BE AN INTEGER         #
                      STATUS$NORML = FALSE; 
                      END 
                  CHAR = C<0,10>VALUE$C;
                  CHR2NUM;
                  END 
              L = NUM;
              RP$GROUP = GROUP; 
              RP$TYPE = RP$T"SUMNBITS"; 
              RP$VALUE = L; 
              SWCH = SETRP"SUMLOP5";
#***#         RETURN; 
  
SUMLOP5:  
#               DETERMINE WHAT THE REPETITION COUNT IS                 #
  
              IF VALCOUNT NQ ORDERPOS  THEN 
                  BEGIN 
#***#             GOTO SUMBOTTOM; 
                  END 
              ELSE  # IF A ORDER VALUE IS SPECIFIED THEN               #
              BEGIN 
              CLP$GTV(STRING$,PARAMNM,I,ORDERPOS,"LOW",VALUE$,STATUS$); 
              IF C<0,10>VALUE$C EQ "A"  THEN
                  BEGIN 
                  RP$GROUP = GROUP; 
                  RP$TYPE = RP$T"SUMREP"; 
                  RP$VALUE = 1; 
#***#             SWCH = SETRP"SUMBOTTOM";
#***#             RETURN; 
                  END 
  
              ELSE
#               A VALUE WAS SPECIFIED                                  #
  
                  BEGIN 
                  CLP$GTV(STRING$,PARAMNM,I,ORDERPOS,VALUE$,STATUS$); 
                  IF C<0,1>VALUE$C GQ "0"  AND
                     C<0,1>VALUE$C LQ "9"   THEN
                      BEGIN 
                          $BEGIN
#??#                  MES = " SUMREP GIVEN "; 
#??#                  S$PRTCD(MES); 
                      FLUSH;
                          $END
                      CHAR = C<0,10>VALUE$C;
                      IF C<0,1>CHAR LS "0"  OR
                         C<0,1>CHAR GR "9"  THEN
                          BEGIN 
                          S$ERROR(E$88); # BYTE/BIT POSITION OR LENGTH #
#                            OF A SUM/KEY FIELD MUST BE AN INTEGER     #
                          STATUS$NORML = FALSE; 
                          END 
                      CHR2NUM;
                      RP$GROUP = GROUP; 
                      RP$TYPE = RP$T"SUMREP"; 
                      RP$VALUE = NUM; 
                      SWCH = SETRP"SUMBOTTOM";
#***#                 RETURN; 
                      END 
  
                  ELSE  # SUM REP VALUE IS NOT VALID                   #
                      BEGIN 
                      S$ERROR(E$83);   # REP. VALUE OF A SUM FIELD     #
#                        MUST BE AN INTEGER                            #
                      STATUS$NORML = FALSE; 
                      END 
  
                  END 
  
              END 
  
SUMBOTTOM:  
  
            END  # OF FOR LOOP OF I UNTIL NFILES #
  
  
#   *   *   *   *   *   *   *   # 
#                               # 
#            T O                # 
#                               # 
#   *   *   *   *   *   *   *   # 
  
# HANDLE 'TO' PARAMETER           # 
  
TO: 
  
          PARAMNM = "TO"; 
          CLP$TP(PARAMNM,SPECIFIED,STATUS$); # TEST FOR PARAMETER      #
          IF NOT SPECIFIED THEN 
              BEGIN 
                  $BEGIN
#??#              MES = "GTCSP-TEST 5"; 
#??#              S$PRTCD(MES); 
                  FLUSH;
                  $END
              SWCH = SETRP"VER";
#***#         GOTO NEXT;
              END 
  
#      ELSE GET VALUE OF 'TO' PARAMETER                                #
          # THIS PARAMETER TERMINATES ANY SEQS STUFF                   #
          SEQORD = 0; 
  
          $BEGIN
#??#      MES = "S$GTCSP-8";
#??#      S$PRTCD(MES); 
          FLUSH;
          $END
  
          SIDEOFRANG = "LOW"; 
          CLP$GTV(STRING$,PARAMNM,1,1,"LOW",VALUE$,STATUS$);
  
              IF VALUE$C EQ "$NULL"  THEN 
                  BEGIN 
                  RP$TYPE = RP$T"OUTFILE";
                  RP$VALUEC = "$NULL";
                  SWCH = SETRP"VER";
#***#             RETURN; 
                  END 
  
#               ELSE                                                   #
  
          TESTFIL;
          IF BADNAME  THEN
              BEGIN 
#               RESET 'BADNAME' TO FALSE AND GOTO NEXT                 #
              BADNAME = FALSE;
              SWCH = SETRP"VER";
#***#         GOTO NEXT;
              END 
          RP$TYPE = RP$T"OUTFILE";
          RP$VALUEC = FILNAM; 
          SWCH = SETRP"VER";
#***#     RETURN; 
  
  
  
  
#   *   *   *   *   *   *   *   # 
#                               # 
#         V E R                 # 
#                               # 
#   *   *   *   *   *   *   *   # 
  
VER:  
  
# HANDLE "VER"    PARAMETER                                            #
  
          PARAMNM = "VER";
          CLP$TP(PARAMNM,SPECIFIED,STATUS$);  # TEST FOR VER           #
          IF NOT SPECIFIED  THEN
              BEGIN 
              $BEGIN
#??#          MES = "VER NOT SPECIFIED "; 
#??#          S$PRTCD(MES); 
              FLUSH;
              $END
#***#         GOTO VERIFY;
              END 
  
# ELSE VER WAS SPECIFIED, GET VALUE                                    #
          # THIS PARAMETER TERMINATES ANY SEQS STUFF                   #
          SEQORD = 0; 
  
          CLP$GTV(STRING$,PARAMNM,1,1,"LOW",VALUE$,STATUS$);
          IF VALUE$C EQ "Y"  OR  VALUE$C EQ "YES"  THEN 
              BEGIN 
              RP$TYPE = RP$T"VERIFY"; 
              SWCH = SETRP"VERIFY"; 
#***#         RETURN; 
              END 
          ELSE
          IF VALUE$C EQ "N"  OR  VALUE$C EQ "NO"  THEN
              BEGIN 
#***#         GOTO VERIFY;
              END 
  
          ELSE  # IF NOT YES OR NO  THEN                               #
              BEGIN 
              S$ERROR(E$79);  # VALUES ALLOWED FOR THE VER             #
#                       PARAMETER ARE YES AND NO                       #
              STATUS$NORML = FALSE; 
#***#         GOTO VERIFY;
              END 
  
  
#   *   *   *   *   *   *   *   # 
#                               # 
#         V E R I F Y           # 
#                               # 
#   *   *   *   *   *   *   *   # 
  
VERIFY: 
  
# HANDLE "VERIFY" PARAMETER                                            #
  
          PARAMNM = "VERIFY"; 
          CLP$TP(PARAMNM,SPECIFIED,STATUS$);  # TEST FOR VERIFY        #
          IF NOT SPECIFIED  THEN
              BEGIN 
              $BEGIN
#??#          MES = "VERIFY NOT SPECIFIED ";
#??#          S$PRTCD(MES); 
              FLUSH;
              $END
#***#         GOTO FINAL; 
              END 
  
# ELSE VERIFY WAS SPECIFIED, GET VALUE                                 #
          # THIS PARAMETER TERMINATES ANY SEQS STUFF                   #
          SEQORD = 0; 
  
          CLP$GTV(STRING$,PARAMNM,1,1,"LOW",VALUE$,STATUS$);
          IF VALUE$C EQ "Y"  OR  VALUE$C EQ "YES"  THEN 
              BEGIN 
              RP$TYPE = RP$T"VERIFY"; 
              SWCH = SETRP"FINAL";
#***#         RETURN; 
              END 
          ELSE
          IF VALUE$C EQ "N"  OR  VALUE$C EQ "NO"  THEN
              BEGIN 
#***#         GOTO FINAL; 
              END 
  
          ELSE  # IF NOT YES OR NO  THEN                               #
              BEGIN 
              S$ERROR(E$79);  # VALUES ALLOWED FOR THE VERIFY          #
#                       PARAMETER ARE YES AND NO                       #
              STATUS$NORML = FALSE; 
#***#         GOTO FINAL; 
              END 
  
FINAL:  
  
          DONE = TRUE;  # ROUTINE IS FINISHED                          #
          SWCH = SETRP"ST"; 
  
#***#     RETURN; 
  
  
          END # OF SETRP$ # 
  
CONTROL EJECT;
  
          PROC STDEFLT; 
  
#**       STDEFLT - SET DEFAULT VALUES                                 #
#                                                                      #
#       GIVEN -                                                        #
#         NO PARAMETERS                                                #
#       DOES -                                                         #
#              THIS ROUTINE CHECKS TO SEE IF ANY VALUES                #
#         HAVE BEEN SET FOR THE E,EL,FROM,L,LO AND TO                  #
#         PARAMETERS.  IF NO VALUE WAS SET FOR ANY ONE OF THESE        #
#         PARAMETERS THEN IT'S APPROPRIATE DEFAULT VALUE               #
#         IS SET(AS A GLOBAL VARIABLE TO BE USED BY S$ERROR).          #
#              THIS ROUTINE ALSO OPENS THE LIST FILE TO BE USED        #
#         TO PUT ERROR MESSAGES AND TO ECHO THE LINES IN DIR FILES.    #
#                                                                      #
  
          BEGIN 
          IF S$ELEV EQ 100  THEN
              S$ELEV = 30;  # WARNING LEVEL SET AS DEFAULT             #
          IF S$LFNAM EQ " "  THEN 
              S$LFNAM = "OUTPUT"; 
          IF S$EFNAM EQ " "  THEN 
              BEGIN 
              S$EFNAM = S$LFNAM;
              $BEGIN
#??#          MES = " S$EFNAM = S$LFNAM"; 
#??#          S$PRTCD(MES); 
              FLUSH;
              $END
              END 
          IF LOSET EQ " "  THEN 
  
#               THE DEFAULT OF LO IS LO=S.                             #
#               A COPY OF THE DIRECTIVE FILE LINES SHOULD BE WRITTEN   #
#               TO THE LIST FILE AND THE FILE SHOULD BE OPPENNED       #
  
              LOSET = "S";
          IF LOSET NQ "S"  AND  LOSET NQ "SA"  AND
                    LOSET NQ " "   THEN 
#                     SUPRESS LISTING OF DIRECTIVE FILES               #
#                     BECAUSE LO=OFF OR LO=A                           #
  
              S$LFNAM = "0";
          IF S$LFNAM NQ "0"  THEN 
              BEGIN 
              $BEGIN
#??#          MES = " LFNAM = ";
              C<8,10>MES = C<0,10>S$LFNAM;
#??#          S$PRTCD(MES); 
              FLUSH;
              $END
              S$OPLF(S$LFNAM);   # OPEN LIST FILE                      #
              END 
  
          END   # OF STDEFLT #
  
CONTROL EJECT;
  
  
          PROC TESTFIL; 
  
#**       TESTFIL - TEST FILE NAME                                     #
#                                                                      #
#       GIVEN -                                                        #
#         NO PARAMETERS                                                #
#       DOES -                                                         #
#         TAKING THE VARIABLE VALUE$C, THIS ROUTINE  CHECKS THAT       #
#         IT CONTAINS A 7 CHARACTER NAME TOKEN AND THEN STORES         #
#         THE NAME INTO A VARIABLE THAT IS ZERO FILLED                 #
  
          BEGIN 
          FOR L=0 STEP 1 UNTIL 9  DO
              BEGIN 
          C<L,1>FILNAM = 0; 
              END 
          FOR L=0 STEP 1 UNTIL 7  DO
              BEGIN 
  
#               SINCE A NAME TOKEN CAN CONTAIN NOT ONLY LETTERS AND    #
#               DIGITS BUT ALSO CERTAIN SPECIAL CHARACTERS, AS LISTED  #
#               BELOW, CHECK THAT THESE CHARACTERS ARE NOT IN THIS     #
#               FILE NAME                                              #
  
              IF C<L,1>VALUE$C EQ "_"  OR 
                 C<L,1>VALUE$C EQ "#"  OR 
                 C<L,1>VALUE$C EQ "$"  OR 
                 C<L,1>VALUE$C EQ "@"   THEN
                  BEGIN 
                  S$ERROR(E$69);  # A FILE NAME                        #
#                    CAN CONTAIN ONLY LETERS AND DIGITS                #
                  BADNAME = TRUE; 
                  STATUS$NORML = FALSE; 
                  END 
              IF L EQ 0  THEN 
#               TEST THAT THE FIRST CHARACTER OF THIS NAME TOKEN       #
#               IS A LETTER AND ONLY A LETTER                          #
  
                  BEGIN 
                  IF C<L,1>VALUE$C LS "A" OR  C<L,1>VALUE$C GR "Z"  THEN
                      BEGIN 
                      S$ERROR(E$52);   # FILE,PROC AND COL-SEQ. NAMES  #
#                       MUST BEGIN WITH A LETTER                       #
                      BADNAME = TRUE; 
                      STATUS$NORML = FALSE; 
                      END 
                  END 
              IF C<L,1>VALUE$C EQ " "  THEN 
                  GOTO VALID; 
#             ELSE CONTINUE LOOP                                       #
              END # FOR # 
          S$ERROR(E$61);     # FILE NAMES(BUT NOT PROC OR SEQ NAMES)   #
#                MUST NOT EXCEED 7 CHARACTERS IN LENGTH                #
          BADNAME = TRUE; 
          STATUS$NORML = FALSE; 
  
#           ELSE FILE NAME IS VALID                                    #
  
VALID:  
  
          C<0,L>FILNAM = C<0,L>VALUE$C; 
  
          END 
CONTROL EJECT;
  
          PROC TESTLONGNM;
  
#**       TESTLONGNM - TEST FOR LONG PROC OR COL-SEQ NAMES             #
#                                                                      #
#      GIVEN -                                                         #
#         NO PARAMETERS                                                #
#      DOES -                                                          #
#         TAKES VALUE$C AND DETERIMINES HOW LONG THE NAME GIVEN IS.    #
#         IF THE NAME IS LONGER THAN 10 CHAR.S A WARNING MESSAGE IS    #
#         ISSUED.  THIS PROC IS CALLED WHEN VALUES OF PROC OR          #
#         COL-SEQ NAMES WERE GOTTEN FROM CLP$GTV.                      #
#                                                                      #
  
          BEGIN 
          FOR J = 0 STEP 1 UNTIL 239  DO
              BEGIN 
              IF C<J,1>VALUE$C EQ " "  THEN 
#***#             GOTO BLNK;
#               ELSE CONTINUE                                          #
              IF J EQ 0  THEN 
#               TEST THAT THE FIRST CHARACTER OF THIS NAME TOKEN       #
#               IS A LETTER AND ONLY A LETTER                          #
  
                  BEGIN 
                  IF C<J,1>VALUE$C LS "A" OR  C<J,1>VALUE$C GR "Z"  THEN
                      BEGIN 
                      S$ERROR(E$52);   # FILE,PROC AND COL-SEQ. NAMES  #
#                       MUST BEGIN WITH A LETTER                       #
                      BADNAME = TRUE; 
                      STATUS$NORML = FALSE; 
                      END 
                  END 
              END 
BLNK: 
          IF J GR 10  AND 
                  C<0,11>VALUE$C NQ "INTEGER_BIT"  AND
                  C<0,11>VALUE$C NQ "BINARY_BITS"  THEN 
#               EITHER THE USER HAS SPELLED A KEYTYPE INCORRECTLY      #
#               OR VALUE$C IS A LONG COL-SEQ-NAME                      #
  
              BEGIN 
              S$ERROR(E$98);  #W = COL-SEQUENCE OR PROC NAMES LONGER   #
#                THAN 10 CHARACTERS ARE TRUNCATED                      #
              STATUS$NORML = FALSE; 
              END 
#***#     RETURN; 
          END  # OF PROC TESTLONGNM # 
CONTROL EJECT;
  
#          **************************************************          #
#                         M A I N   P R O G R A M                      #
#                                   O F                                #
#                             S $ G T C S P                            #
#          **************************************************          #
  
  
          GOTO GTCSPSWITCH[SW];         # RESUME FROM PRIOR PROCESSING #
  
  
START:  
  
          S$GTTXT(STRING$,EOF,FALSE,DFLNM,VERB,STATUS$);
          IF NOT STATUS$NORML  THEN 
              BEGIN 
              S$ELEV = 30;  # DEFAULT TO WARNING                       #
              S$LFNAM = "OUTPUT"; 
              S$EFNAM = "OUTPUT"; # BOTH FILE NAMES DEFAULT TO OUTPUT  #
              S$OPLF(S$LFNAM);  # OPEN LIST FILE                       #
              S$GORA;   # IF CATASTROPHIC ERROR THEN DOES NOT RETURN   #
#***#         RETURN; 
              END 
  
#               OTHERWISE CONTINUE PROCESSING                          #
  
          $BEGIN
#??#      MES = C<0,80>STRING$C;
#??#      S$PRTCD(MES); 
          FLUSH;
          $END
# CHECK FOR SYNTAX ERRORS AND PREPARE TO EXTRACT VALUES                #
  
          IF STRING$LEN EQ 0  THEN
              BEGIN 
              SW = GTCSP"SETCS";
#***#         GOTO SETCS; 
              END 
          CLP$SPL(STRING$,PDT$,STATUS$);
  
          PRTPVT; 
  
              $BEGIN
#??#          MES = "GTCSP-TEST 1"; 
#??#          S$PRTCD(MES); 
              FLUSH;
              $END
          SW = GTCSP"SETCS";
  
              $BEGIN
  
  
#??#          MES = "SETCS";
#??#          S$PRTCD(MES); 
              FLUSH;
              $END
  
SETCS:  
  
          IF DONE  THEN  # SETRP NEED NOT BE CALLED ANY MORE           #
              BEGIN 
              SW = GTCSP"CSDONE"; 
#***#         GOTO CSDONE;
              END 
          SETRP$;  # PROCESS PARAMETERS FOUND ON CONTROL STATEMENT     #
          IF NOT DONE THEN RETURN;
  
CSDONE: 
  
              $BEGIN
#??#          MES = "CSDONE"; 
#??#          S$PRTCD(MES); 
              FLUSH;
              $END
  
  
          IF DIRFIL  THEN 
              BEGIN 
  
              $BEGIN
#??#          MES = "DIRFIL IS TRUE"; 
#??#          S$PRTCD(MES); 
              FLUSH;
              $END
              DONE = FALSE; 
              SW = GTCSP"CHECK";
#***#         GOTO CHECK; 
              END 
  
          ELSE   # IF NO DIRECTIVE FILES WERE SPECIFIED                #
              BEGIN 
  
              $BEGIN
#??#          MES = "DIRFIL NOT TRUE";
#??#          S$PRTCD(MES); 
              FLUSH;
              $END
  
              STDEFLT;      # SEE IF ANY DEFAULTS NEED TO BE SET       #
  
#               PROCESS ERRORS FOUND WHILE SCANNING                    #
  
              IF NOT STATUS$NORML  THEN  # FATAL ERROR(S) FOUND        #
                  BEGIN 
                  S$GORA;  # IF CATASTROPHIC ERROR THEN NO RETURN      #
                  END 
              RP$TYPE = RP$T"$END$";
#***#         RETURN; 
              END 
  
# PROCESS DIRECTIVE FILE STATEMENTS                                    #
  
  
CHECK:  
  
          $BEGIN
#??#      MES = "S$GTCSP-10"; 
#??#      S$PRTCD(MES); 
          FLUSH;
          $END
  
#               OTHERWISE NO ERRORS ARE TO BE WRITTEN ON THE LIST FILE #
#               SO FILE S$LFNAM SHOULD NOT BE OPENNED                  #
  
#           PROCESS ERRORS FOUND WHILE SCANNING                        #
  
          IF NOT STATUS$NORML AND S$MXERR GQ 40 AND S$MXERR NQ 100  THEN
             # FATAL OR CATASTROPHIC ERRORS FOUND                      #
  
              BEGIN 
              STDEFLT;      # SEE IF ANY DEFAULTS NEED TO BE SET       #
  
              S$GORA; # IF CATASTROPHIC THEN IT DOES NOT RETURN        #
              RP$TYPE = RP$T"$END$";
              S$CLLF;  # MIGHT AS WELL CLOSE THE LIST FILE             #
#***#         RETURN; 
              END 
  
          IF D GQ DIRFILENUM  THEN  # ALL DIRFILES HAVE BEEN PROCESSED #
              BEGIN 
              STDEFLT;      # SEE IF ANY DEFAULTS NEED TO BE SET       #
  
              RP$TYPE = RP$T"$END$";
              S$CLLF;  # MIGHT AS WELL CLOSE THE LIST FILE             #
              RETURN; 
              END 
  
#           INITIALIZE PARAMETERS                                      #
          EOF = FALSE;
          DFLNM = DIRNAME[D]; 
          STRING$C = " "; 
          S$DIRHD(DFLNM);                 # PRINT HEADING ON LIST FILE #
          LLN = 0;                        # INITIALIZE LF LINE NUMBER  #
  
  
  
DIRSCAN:  
  
          SCANDIR = TRUE; 
          DONE = FALSE;  # RE-INITIALIXE THIS FLAG                     #
          S$GTTXT(STRING$,EOF,TRUE,DFLNM,XERR,STATUS$); 
  
          IF NOT STATUS$NORML  AND  S$MXERR EQ 50  THEN 
             # CATASTROPHIC ERROR(S) FOUND WHILE PROCESSING DIR FILE   #
  
              BEGIN 
              STDEFLT;      # SEE IF ANY DEFAULTS NEED TO BE SET       #
  
#               SINCE THERE IS A CATASTROPHIC ERROR THEN ABORT         #
  
              S$GORA;         # DO NOT RETURN                          #
  
              END 
  
          $BEGIN
#??#      MES = "S$GTCSP-11"; 
#??#      S$PRTCD(MES); 
          FLUSH;
          $END
          IF EOF  THEN
              BEGIN 
              D = D + 1;
              DONE = FALSE; 
              SW = GTCSP"CHECK";
#***#         GOTO CHECK; 
              END 
          IF STRING$LEN EQ 0  # AND EOF IS FALSE #  THEN
              BEGIN 
              SW = GTCSP"SETDIR"; 
#***#         GOTO SETDIR;
              END 
          $BEGIN
#??#      MES = "S$GTCSP-12"; 
#??#      S$PRTCD(MES); 
          FLUSH;
          $END
          CLP$SPL(STRING$,PDT$,STATUS$);  # CHECK FOR SYNTAX ERRORS    #
                                       # AND PREPARE TO EXTRACT VALUES #
  
          SW = GTCSP"SETDIR"; 
          PRTPVT; 
  
SETDIR: 
              $BEGIN
  
  
#??#          MES = "SETDIR"; 
#??#          S$PRTCD(MES); 
              FLUSH;
              $END
  
          IF DONE  THEN 
              BEGIN 
              $BEGIN
  
#??#          MES = "DONE IS TRUE"; 
#??#          S$PRTCD(MES); 
              FLUSH;
  
              $END
              SW = GTCSP"DIRSCAN";
              GOTO DIRSCAN; 
              END 
  
          SETRP$; 
  
          IF DONE  THEN  #     DON'T RETURN OR ELSE THE                #
                         # LAST RP$ SET WILL BE SET AGAIN              #
#***#         GOTO SETDIR;
  
#***#     RETURN; 
  
          END #S$GTCSP# 
          TERM
