*DECK CLP$TP
          PROC CLP$TP (PARAMNM,SPECIFIED,STATUS$);
  
#**       CLP$TP  -  TESTS TO DETERIMINE IF A PARTICULAR PARAMETER     #
#                    HAS BEEN SPECIFIED ON LAST PARAMETER-LIST         #
#                                                                      #
#       CALLING SEQ -                                                  #
#         CLP$TP(PARAMENM,SPECIFIED,STATUS$):                          #
#       GIVEN -                                                        #
#         PARAMNM = NAME OF PARAMETER FOR WHICH REQUEST IS MADE        #
#         SPECIFIED = IS A VALUE SPECIFIED FOR THE PAR.?(OUTPUT)       #
#         STATUS$ = EXPANDED ERROR STATUS(OUTPUT)                      #
#       DOES -                                                         #
#         TESTS TO DETERMINE IF A PARTICULAR PARAMETER WAS SPECIFIED   #
#         ON THE LAST PARAMETER-LIST('STRING$') AND RETURNS TRUE IF SO #
#                                                                      #
          BEGIN 
*CALL A 
  
*CALL CLPARAM 
  
*CALL STATUS$ 
  
*CALL STRING$ 
  
  
*CALL E$
  
*CALL CLPTYPE 
  
*CALL DEBUG 
  
          DEF  PVTLENGTH    #40#; 
  
          ITEM    J    I; 
          ITEM    MES   C(60);
  
          XREF
          BEGIN 
*CALL PVT$
  
#??#           PROC S$PRTCD;
              PROC S$ERROR; 
  
          END 
  
  
              PROC TESTDUP(PARAMNM,J);
  
#**           TESTDUP - TEST FOR DUPLICATE PARAMETER SPECIFICATION     #
#                                                                      #
#            GIVEN -                                                   #
#             PARAMNM = PARAMETER NAME BEING TESTED FOR                #
#             J = POSITION WITHIN THE ARRAY OF SPECIFIED KEYWORDS      #
#            DOES -                                                    #
#             TESTS FOR TWO THINGS:  TO MAKE SURE THAT THERE IS NO     #
#             DUPLICATE PARAMETER SPECIFICATION ON ANY GIVEN CONTROL   #
#             STATEMENT LINE,  AND TO MAKE SURE THAT ONLY THE          #
#             PARAMETERS DIR, FROM, KEY, SUM, AND SEQX ARE THE ONLY    #
#             PARAMETERS THAT ARE SPECIFIED MORE THAN ONCE IN ALL      #
#             CONTROL STATEMENTS AND DIRECTIVE FILES FOR ANY GIVEN     #
#             SORT/MERGE.                                              #
#                                                                      #
  
              BEGIN 
  
              ITEM PARAMNM      C(7);  # PARAMETER BEING SCANNED       #
              ITEM J               I;  # POSITION OF KEYWORD IN PVT$   #
              ITEM SYNONYM      C(7);  # A 2ND KEYWORD EQUAL TO ANOTHER#
              ITEM PTOTAL        I=0;  # NUMBER OF PARAM.S IN ARRAY    #
              ITEM I               I;  # INCREMENT VALUE               #
              ITEM K               I;  # INCREMENT VALUE               #
  
              ARRAY PARAM$  [1:30]  S(1); 
                  BEGIN 
                  ITEM PARAM$GIVEN  C(0,0,7);   # PARAM.S GIVEN        #
                  END 
  
  
#          INITIALIZE VARIABLE AND ARRAY USED TO TEST PARAMETERS       #
#          WITHIN A SINGLE CONTROL STATEMENT LINE. . .                 #
#          WHEN A NEW LINE IS BEGINNING TO BE PROCESSED BY S$GTCSP     #
#          THEN THE FIRST 'PARAMNM' CLP$TP IS CALLED WITH IS 'ST'      #
  
              IF PARAMNM EQ "ST"  THEN
                  BEGIN 
                  PTOTAL = 0; 
                  FOR K=1 STEP 1 UNTIL 30  DO 
                      BEGIN 
                      PARAM$GIVEN[K] = " "; 
                      END 
                  END 
  
#          FOR THE PARAMETERS THAT HAVE TWO FORMS, SET THE             #
#          VARIABLE 'SYNONYM' TO CONTAIN THIS 2ND FORM                 #
  
              IF PARAMNM EQ "ST"  THEN
                  SYNONYM = "STATUS"; 
              ELSE
              IF PARAMNM EQ "STATUS"  THEN
                  SYNONYM = "ST"; 
              ELSE
              IF PARAMNM EQ "DIA"  THEN 
                  SYNONYM = "DIALOG"; 
              ELSE
              IF PARAMNM EQ "DIALOG"  THEN
                  SYNONYM = "DIA";
              ELSE
              IF PARAMNM EQ "OWNMRL"  THEN
                  SYNONYM = "OMRL"; 
              ELSE
              IF PARAMNM EQ "OMRL"  THEN
                  SYNONYM = "OWNMRL"; 
              ELSE
              IF PARAMNM EQ "OWNFL"  THEN 
                  SYNONYM = "OFL";
              ELSE
              IF PARAMNM EQ "OFL"  THEN 
                  SYNONYM = "OWNFL";
              ELSE
              IF PARAMNM EQ "RETAIN"  THEN
                  SYNONYM = "RET";
              ELSE
              IF PARAMNM EQ "RET"  THEN 
                  SYNONYM = "RETAIN"; 
              ELSE
              IF PARAMNM EQ "VER" THEN
                  SYNONYM = "VERIFY"; 
              ELSE
              IF PARAMNM EQ "VERIFY" THEN 
                  SYNONYM = "VER";
  
              ELSE
                  SYNONYM = PARAMNM;
  
  
#          TEST A SINGLE LINE FOR DUPLICATION OF PARAMETER.            #
#            DO SO BY SCANNING THE REST OF PVT$KEYWNAM ELEMENTS FROM   #
#            WHERE SIMILAR SCANNING OF PVT$ WAS DONE BY CLP$SPL        #
  
              FOR I=J+1 STEP 1 UNTIL PVTLENGTH  DO
                  BEGIN 
                  IF PVT$KEYWNAM[I] EQ PARAMNM  OR
                     PVT$KEYWNAM[I] EQ SYNONYM   THEN 
                      BEGIN 
                      S$ERROR(E$101);  # NO PARAMETER CAN BE SPECIFIED #
#                          MORE THAN ONCE ON ONE LINE                  #
                      STATUS$NORML = FALSE; 
                      END 
                  END 
  
  
#          TEST FOR PARAMETER DUPLICATION OVER ALL LINES               #
  
              IF PARAMNM EQ "DIR"  OR  PARAMNM EQ "FROM"  OR
                    PARAMNM EQ "KEY"  OR  PARAMNM EQ "SUM"
                    OR  C<0,3>PARAMNM EQ "SEQ"  THEN
#***#             RETURN; # THESE KEYWORDS CAN BE USED MORE THAN ONCE  #
  
              ELSE   # PARAMNM IS NOT ONE OF THE ABOVE                 #
                  BEGIN 
  
#                   SCAN THRU 'PARAM$', WHICH CONTAINS ALL 'PARAMNM'   #
#                   'TESTDUP' HAS BEEN CALLED WITH THUS FAR            #
  
                  FOR K=1 STEP 1 UNTIL PTOTAL  DO 
                      BEGIN 
                      IF PARAMNM EQ PARAM$GIVEN[K]  OR
                         SYNONYM EQ PARAM$GIVEN[K]  THEN
                          BEGIN 
                            S$ERROR(E$102);  # DUPLICATE PARAMETER     #
#                              SPECIFIED                               #
                          STATUS$NORML = FALSE; 
#***#                     RETURN;  # DON'T PUT DUP. PARAMNM IN PARAM$  #
                          END 
                      END  # OF FOR # 
  
                  PTOTAL = PTOTAL + 1;
                  PARAM$GIVEN[PTOTAL] = PARAMNM;
                  END 
  
              END  # OF TESTDUP # 
  
CONTROL EJECT;
          SPECIFIED = FALSE;
  
          $BEGIN
          MES = " ";     # BLANK OUT THE LINE # 
#??#      C<0,30>MES = "CLP$TP PARAMNM =  ";
#??#      C<30,10>MES = PARAMNM;
#??#      S$PRTCD(MES); 
          FLUSH;
          $END
          FOR J=0 STEP 1 UNTIL PVTLENGTH  DO
              BEGIN 
              IF PVT$KEYWNAM[J] EQ PARAMNM THEN 
                  BEGIN 
                  TESTDUP(PARAMNM,J); 
                  IF PVT$VALGIVEN[J] THEN 
                      BEGIN 
                      SPECIFIED = TRUE; 
                      GOTO BOTTOMTP;
                      END 
                  ELSE
                      GOTO BOTTOMTP;
                  END 
#               OTHERWISE CONTINUE                                     #
              END 
          $BEGIN
#??#      MES = "CLP$TP SPECIFIED NOT SET TRUE";
#??#      S$PRTCD(MES); 
          FLUSH;
          $END
  
BOTTOMTP: 
  
          $BEGIN
#??#      C<0,30>MES = "CLP$TP PVT$KEYWNAM =  ";
          IF SPECIFIED THEN 
              C<30,10>MES = PVT$KEYWNAM[J]; 
          ELSE
              C<30,10>MES = "NOT FOUND";
#??#      S$PRTCD(MES); 
          FLUSH;
  
          $END
#***#     RETURN; 
          END 
          TERM
