*DECK,CMDCLA
USETEXT COMCBEG 
USETEXT COMCAPR 
USETEXT COMQDEF 
USETEXT COMQKDS 
USETEXT COMQPAR 
USETEXT COMQSCH 
USETEXT COMQSEL 
    PROC CMDCLA;
      BEGIN  # CMDCLA # 
# 
**    CMDCLA     PROCESS *CLASS* COMMAND. 
* 
*     PROCESSES THE OPERATOR *CLASS* COMMAND. 
* 
*     CLASS,SC=SCNAME,FSI=FSIRANGE,MAXIMUM=MAX
* 
*     PROC CMDCLA 
* 
*     ENTRY      PARMS = PARSED COMMAND PARAMETERS. 
* 
*     EXIT       PARAMETERS PROCESSED.
* 
# 
  
# 
****  XREF
# 
      XREF
        BEGIN 
        PROC CMPCOVS;              # COMPUTE COVER CLASSES #
        PROC NAME;                 # DEBUG CODE # 
        END 
  
# 
****  XREF END
# 
  
      STATUS KEYST
         SC                        # SC= #
        ,FSI                       # FSI= # 
        ,MAXIMUM                   # MAXIMUM= # 
        ,RESERVE                   # RESERVE= # 
        ,UNKNOWN                   # *UNKNOWN* #
        ; 
  
      ARRAY FP [KEYST"SC":KEYST"UNKNOWN"] S(1); 
        BEGIN 
        ITEM FP$KEY     C(00,00,07) = 
          [ "SC", "FSI", "MAXIMUM", "RESERVE", "*******"];
        ITEM FP$MIN     U(00,42,06) = 
          [    1,     1,         1,         1,         1];
        ITEM FP$KEYST   S:KEYST(00,54,06) = 
          [S"SC",S"FSI",S"MAXIMUM",S"RESERVE",S"UNKNOWN"];
        END 
  
      SWITCH SW$FP:KEYST
         SW$SC     :SC             # SC= #
        ,SW$FSI    :FSI            # FSI= # 
        ,SW$MAXIMUM:MAXIMUM        # MAXIMUM= # 
        ,SW$RESERVE:RESERVE        # RESERVE= # 
        ,SW$UNKNOWN:UNKNOWN        # *UNKNOWN* #
        ; 
  
      ITEM FPORD      S:KEYST;     # PARAMETER ORDINAL #
      ITEM I          I;           # INDEX #
      ITEM PCNT       U;           # PARAMETER COUNT #
      ITEM SELLFSI    U;           # FSI LOWER BOUND #
      ITEM SELMAX     U;           # MAXIMUM SLOTS #
      ITEM SELNAME    C(1);        # SELECTION CLASS NAME # 
      ITEM SELRSV     U;           # RESERVED SLOTS # 
      ITEM SELUFSI    U;           # FSI UPPER BOUND #
  
        $BEGIN
        NAME("CMDCLA");            # DEBUG CODE # 
        $END
  
      SELLFSI = -1;                # NO RANGE # 
      SELMAX = -1;                 # NO MAXIMUM # 
      SELRSV = -1;                 # NONE RESERVED #
      SELNAME = " ";               # NO NAME YET #
      SLOWFOR PCNT = 1 STEP 1 WHILE (PCNT LE PARM$PCNT) 
                                AND (PARM$STAT EQ S"OK")
      DO
        BEGIN 
        IF PARM$PLEN[PCNT] EQ 0 
        THEN
          BEGIN 
          PARM$STAT = S"PARMERR"; 
          PARM$ECOL = PARM$COL[PCNT]; 
          CYCLE PCNT; 
          END 
  
        IF PARM$PLEN[PCNT] GT 7 
        THEN
          BEGIN 
          PARM$PLEN[PCNT] = 7;
          END 
  
        FP$KEY[KEYST"UNKNOWN"] = PARM$KEY[PCNT];
        FPORD = S"SC";
        ASLONGAS (C<0,PARM$PLEN[PCNT]>FP$KEY[FPORD] 
                    NE C<0,PARM$PLEN[PCNT]>PARM$KEY[PCNT])
              OR (PARM$PLEN[PCNT] LT FP$MIN[FPORD]) 
        DO
          BEGIN 
          FPORD = FPORD + 1;
          END 
  
        GOTO SW$FP[FP$KEYST[FPORD] ];  # CASE STATEMENT # 
  
SW$SC:                             # SC= #
          IF (PARM$VTYPE[PCNT] EQ S"NAME")
            AND (PARM$VLEN[PCNT] EQ 1)
            AND (PARM$NAME[PCNT] GE "A")
            AND (PARM$NAME[PCNT] LE "L")
          THEN
            BEGIN 
            SELNAME = PARM$NAME[PCNT];
            END 
  
          ELSE
            BEGIN 
            PARM$STAT = S"SCERROR"; 
            END 
  
          PARM$ECOL = PARM$COL[PCNT]; 
          GOTO SW$END;
  
SW$FSI:                            # FSI= # 
          IF (PARM$VTYPE[PCNT] EQ S"RANGE") 
            AND (PARM$LB[PCNT] GE MNFSI)
            AND (PARM$LB[PCNT] LE PARM$UB[PCNT])
            AND (PARM$UB[PCNT] LE MXFSI)
          THEN
            BEGIN 
            SELLFSI = PARM$LB[PCNT];
            SELUFSI = PARM$UB[PCNT];
            END 
  
          ELSE
            BEGIN 
            IF (PARM$VTYPE[PCNT] EQ S"INTEGER") 
              AND (PARM$INT[PCNT] GE MNFSI) 
              AND (PARM$INT[PCNT] LE MXFSI) 
            THEN
              BEGIN 
              SELLFSI = PARM$INT[PCNT]; 
              SELUFSI = PARM$INT[PCNT]; 
              END 
  
            ELSE
              BEGIN 
              IF (PARM$VTYPE[PCNT] EQ S"ASTERISK")
              THEN
                BEGIN 
                SELLFSI = MNFSI;
                SELUFSI = MXFSI;
                END 
  
              ELSE
                BEGIN 
                PARM$STAT = S"PARMERR"; 
                END 
  
              END 
  
            END 
  
          GOTO SW$END;
  
SW$MAXIMUM:                        # MAXIMUM= # 
          IF (PARM$VTYPE[PCNT] EQ S"INTEGER") 
            AND (PARM$INT[PCNT] LE ACNMAXC) 
          THEN
            BEGIN 
            SELMAX = PARM$INT[PCNT];
            END 
  
          ELSE
            BEGIN 
            IF (PARM$VTYPE[PCNT] EQ S"ASTERISK")
            THEN
              BEGIN 
              SELMAX = 0; 
              END 
  
            ELSE
              BEGIN 
              PARM$STAT = S"PARMERR"; 
              END 
  
            END 
  
          GOTO SW$END;
  
SW$RESERVE:                        # RESERVE= # 
          IF (PARM$VTYPE[PCNT] EQ S"INTEGER") 
            AND (PARM$INT[PCNT] LE ACNMAXC) 
          THEN
            BEGIN 
            SELRSV = PARM$INT[PCNT];
            END 
  
          ELSE
            BEGIN 
            PARM$STAT = S"PARMERR"; 
            END 
  
          GOTO SW$END;
  
SW$UNKNOWN:                        # *UNKNOWN* #
          PARM$STAT = S"PARMERR"; 
          GOTO SW$END;
  
SW$END:                            # END OF CASE #
        IF PARM$STAT NE S"OK" 
        THEN
          BEGIN 
          PARM$ECOL = PARM$COL[PCNT]; 
          END 
  
        END 
  
      IF PARM$STAT NE S"OK"        # IF ERROR IN COMMAND #
      THEN
        BEGIN 
        RETURN; 
        END 
  
      SEL$NAME[MXSEL] = SELNAME;
      I = 0;
      ASLONGAS SEL$NAME[I] NE SELNAME 
      DO
        BEGIN 
        I = I + 1;
        END 
  
      IF I EQ MXSEL 
      THEN
        BEGIN 
        PARM$STAT = S"SCERROR"; 
        RETURN; 
        END 
  
      SEL$NOTDEF[I] = FALSE;
      IF SELLFSI GE 0 
      THEN
        BEGIN 
        SEL$LFSI[I] = SELLFSI;
        SEL$UFSI[I] = SELUFSI;
        END 
  
      IF SELMAX GE 0
      THEN
        BEGIN 
        SEL$MAXCNT[I] = SELMAX; 
        END 
  
      IF SELRSV GE 0
      THEN
        BEGIN 
        SEL$RSVCNT[I] = SELRSV; 
        END 
  
      KS$UPDATE[KDIS"SC"] = TRUE; 
      TIMSELSECS = 0;              # RESCHEDULE FILE SELECTION #
      CMPCOVS;                     # COMPUTE COVER SETS # 
  
      END  # CMDCLA # 
    TERM
