*DECK S$OPT 
  
          PROC  S$OPT(NPARMS, ARRY);
  
#**       S$OPT -  GATHER PARAMETERS ABOUT OPTIONS                     #
#                                                                      #
#     CALLING SEQUENCE-                                                #
#         CALL SMOPT(<OPTION-1>, ..., <OPTION-N>)                      #
#         (THIS CALLS THE MACHINE-DEPENDENT ROUTINE SMOPT WHICH        #
#          COUNTS PARAMETERS AND PUTS THE VALUE OF EACH PARAMETER      #
#          INTO AN ARRAY THAT IS A PARAMETER TO S$OPT.)                #
#                                                                      #
#     GIVEN-                                                           #
#         <NPARMS > = NUMBER OF PARAMETERS ORIGINALLY SUPPLIED.        #
#         <ARRY> = ARRAY WITH <OPTION-1>, ..., <OPTION-N>.             #
#         <OPTION-I>: FIRST 6 CHARACTERS MUST MATCH-                   #
#             "VERIFY"       "DUMP"         "ORDER "                   #
#             "RETURN"       "NODUMP"       "ORDER$"                   #
#             "VOLDUM"       "NODAY "       "COMPAR"                   #
#                                           "EXTRAC"                   #
#          "DUMP", "ORDER ", AND "ORDER*" MUST BE FOLLOWED BY AN       #
#          INTEGER.                                                    #
#                                                                      #
#     DOES-                                                            #
#         IF CALLED IN THE WRONG ORDER,                                #
#             ISSUE A DIAGNOSTIC, AND                                  #
#             RETURN.                                                  #
#         IF MORE THAN 7 PARAMETERS WERE ORIGINALLY SUPPLIED,          #
#             ISSUE A DIAGNOSTIC, AND                                  #
#             RETURN.                                                  #
#         IF ANY OF THE PARAMETERS ARE UNRECOGNIZABLE AS KEYWORDS,     #
#             ISSUE A DIAGNOSTIC, AND                                  #
#             RETURN.                                                  #
#         FOR EACH <OPTION-I>,                                         #
#             SAVE RAW PARAMETER OF-                                   #
#                 TYPE = RP$T"<OPTION-I>",                             #
#                 IF <OPTION-I> IS "DUMP", "ORDER" OR "ORDER*",        #
#                     VALUE = NEXT OPTION.                             #
  
  
          BEGIN 
*CALL NPARMS
          ARRAY  ARRY  [1:7]; 
              BEGIN 
              ITEM  ARRY$VAL     I(0, 0,60);     # <OPTION-I>          #
              ITEM ARRY$VALC     C(0, 0, 6);
              END 
  
          XREF
              BEGIN 
              PROC  S$ERROR;           # HANDLE A USER ERROR           #
              FUNC  S$INSEQ  B;        # TRUE IFF CALL IN SEQUENCE     #
              PROC  S$SVREL;           # SAVE RAW PARAM. FROM RELOC.   #
              END 
  
*CALL A 
  
*CALL E$
  
*CALL RP$ 
  
*CALL STRING$ 
*CALL SQ$ 
  
          DEF  NOPTS  #10#; 
          ITEM  I            I; 
          ITEM  N            I; 
          ARRAY  [1:10];
              BEGIN 
              ITEM  OPTVAL       C(0, 0, 6)  =
                                       [ "VERIFY" 
                                       , "RETAIN" 
                                       , "VOLDUM" 
                                       , "DUMP  " 
                                       , "NODUMP" 
                                       , "NODAY " 
                                       , "ORDER " 
                                       , "ORDER*" 
                                       , "COMPAR" 
                                       , "EXTRAC" 
                                       ]; 
              ITEM  OPTTYPE      I(0,42,18)  =
                                       [ RP$T"VERIFY" 
                                       , RP$T"RETAIN" 
                                       , RP$T"VOLDUM" 
                                       , RP$T"DUMP" 
                                       , RP$T"NODUMP" 
                                       , RP$T"NODAY"
                                       , RP$T"ORDER"
                                       , RP$T"ORDER$" 
                                       , RP$T"COMPAR" 
                                       , RP$T"EXTRAC" 
                                       ]; 
              END 
  
CONTROL DISJOINT; 
  
CONTROL INERT;
  
CONTROL EJECT;
  
#     IF CALLED IN THE WRONG ORDER,                                    #
#         ISSUE A DISGNOSTIC, AND                                      #
#         RETURN.                                                      #
  
          IF NOT S$INSEQ(SQ$"SMOPT")  THEN
              BEGIN 
              S$ERROR(E$110);          # CALL OUT OF SEQUENCE          #
#***#         RETURN; 
              END 
  
#     IF MORE THEN 7 PARAMETERS WERE NOT ORIGINALLY SUPPLIED,          #
#         ISSUE A DIAGNOSTIC, AND                                      #
#         RETURN.                                                      #
  
          IF NPARMS GR 7  THEN
              BEGIN 
              S$ERROR(E$108);          # TOO MANY PARAMETERS           #
#***#         RETURN; 
              END 
  
          FOR I=1 STEP 1 UNTIL NPARMS DO
              BEGIN 
              FOR N=1 STEP 1 UNTIL NOPTS DO 
                  BEGIN 
                  IF ARRY$VALC[I] EQ OPTVAL[N]  THEN
                      BEGIN 
                      RP$TYPE = OPTTYPE[N]; 
                      IF ARRY$VALC[I] EQ "DUMP  " 
                       OR ARRY$VALC[I] EQ "ORDER "
                       OR ARRY$VALC[I] EQ "ORDER$"
                      THEN
                          BEGIN 
                          RP$VALUE = ARRY$VAL[I+1]; 
                          I=I+1;
                          END 
                      S$SVREL(RP$); 
#***#                 TEST I; 
                      END 
                  END 
          STRING$LEN = 6; 
          STRING$C = ARRY$VAL[I]; 
          S$ERROR(E$6,STRING$,1);  # INVALID KEYWORD DETECTED          #
#***#     RETURN; 
              END 
  
          END  # S$OPT #
          TERM
