*DECK CTRLCDP 
USETEXT CYBRDEF 
USETEXT GLOBALI 
USETEXT MISC$ 
USETEXT RBF$COM 
      PROC CTRLCDP;          # CONTROL CARD PROCESSOR                  #
      BEGIN 
 #
*1DC  CTRLCDP 
* 
*     1. PROC NAME             AUTHOR               DATE
*        CTRLCDP               E. GEE               JULY 15, 1982 
* 
*     2. FUNCTIONAL DESCRIPTION.
*        PROCESS RBF CONTROL CARD PARAMETERS. 
* 
*     3. METHOD USED. 
*        SCAN RA+2 TO RA+22 FOR CONTROL CARD PARAMETERS.
*          (THEY MUST CONFORM TO OPERATING SYSTEM FORMAT) 
*        CHECK FOR VALID KEYWORDS.
*        CHECK VALUES ASSOCIATED WITH KEYWORDS. 
*        PROCESS VALIDATED KEYWORDS.
* 
*     4. ENTRY PARAMETERS.
*        CONTROL CARD PARAMETERS IN RA+2
* 
*     5. EXIT PARAMETERS. 
*        NONE 
* 
*     6. COMDECKS AND SYMPL TEXT USED.
*        CYBRDEF              CYBER 170 MACHINE DEPENDENT DEFS
*        GLOBALI              GLOBAL VARIABLES
*        MISC$                MISCELLANEOUS DEFS
*        RBF$COM              MISCELLANEOUS ARRAYS
* 
*     7. ROUTINES CALLED. 
*        CONVDDB              CONVERT DECIMAL DISPLAY CODE TO BINARY
*        ENDRBF               TERMINATE RBF 
*        MESSAGE              ISSUE DAYFILE MESSAGE 
* 
*     8. DAYFILE MESSAGES.
*        * UNRECOGNIZED CONTROL CARD PARAMETER* 
*        * CONTROL CARD PARAMETER SYNTAX ERROR* 
*        * ILLEGAL CONTROL CARD PARAMETER VALUE*
*        * DUPLICATE CONTROL CARD PARAMETERS* 
*        * REQUIRED PARAMETER NOT SPECIFIED*
* 
 #
  
        BASED ARRAY ARG[1:22] S(1);    #RA CONTROL CARD PARAMETER ARRAY#
          BEGIN                        # RA.ARGR                       #
          ITEM ARG$SYMBO  U(00,00,NL); # ARGUMENT VALUE                #
          ITEM ARG$SEPAR  U(00,NL,AL); # ARGUMENT SEPARATOR            #
          ITEM ARG$WORD   U(00,00,WL);
          END 
        BASED ARRAY ARGCTWD[0:0] S(1);  #RA CONTROL CARD PARAMETER CT  #
          BEGIN 
          ITEM ARG$COUNT  U(00,NL,AL); # ARGUMENT COUNT                #
          END 
  
# 
      EXTERNAL ROUTINES CALLED
# 
      XREF
        BEGIN 
        PROC CONVDDB;                  # CONVERT DEC DISPLAY CDE TO BIN#
        PROC ENDRBF;                   # TERMINATE RBF                 #
        PROC MESSAGE;                  # DISPATCH MESSAGE              #
        END 
# 
      DEFINITIONS FOR PARAMETER INDEXES 
# 
      DEF PAR$COUNT  #01#;             # NUMBER OF VALID RBF PARAMETERS#
      DEF PAR$MC     #01#;             # MC INDEX                      #
# 
      MISCELLANEOUS DEFINITIONS 
# 
      DEF COMMA      # O"56" #; 
      DEF EQUAL      # O"54" #; 
      DEF PERIOD     # O"57" #; 
      DEF YES        #O"31052300000000"#; 
      DEF NO         #O"16170000000000"#; 
# 
      REASON CODES FOR CONTROL CARD ERRORS
# 
      DEF RC$PARILL  #01#;             # ILLEGAL PARAMETER             #
      DEF RC$PARFMT  #02#;             # PARAMETER FORMAT ERROR        #
      DEF RC$PARVAL  #03#;             # BAD PARAMETER VALUE           #
      DEF RC$PARDUP  #04#;             # DUPLICATE PARAMETER           #
      DEF RC$PARMIS  #05#;             # MISSING REQUIRED PARAMETER    #
# 
      LOCAL VARIABLES 
# 
      ITEM ARGPTR     I = 0;           # ARGUMENT POINTER              #
      ITEM ERR        B;               # ERROR INDICATOR               #
      ITEM ERRCODE    I = 0;           # ERROR CODE                    #
      ITEM I          I;               # TEMPORARY VARIABLE            #
      ITEM J          U;               # TEMPORARY VARIABLE            #
      ITEM K          U;               # TEMPORARY VARIABLE            #
      ITEM MATCH      B;               # FOUND VALID PARAMETER FLAG    #
      ITEM NARGS      U;               # NO OF ARGUMENTS               #
  
      ARRAY PAR [1:PAR$COUNT] S(1); 
        BEGIN                          # VALID PARAMETER LIST          #
        ITEM PAR$KEY    U(00,00,42) = [                   # KEYWORDS   #
                                       O"15030000000000", # MC         #
                                      ];
        ITEM PAR$NCV    U(00,42,12) = [ # CHARS ALLOWED FOR PARAM VALUE#
                                       7,  # UP TO 7 DEC CHARS FOR MC  #
                                      ];
        ITEM PAR$PRC    B(00,54,06) = [ # PARAMETER PROCESSED FLAG     #
                                       FALSE, 
                                      ];
        END 
  
      DEF L$PARERR   # 5#;  # MAX NO OF ERROR MESSAGES IN THIS PROC    #
  
      ARRAY MSG$PARERR [RC$PARILL:RC$PARMIS] S(L$PARERR); 
        BEGIN                # CONTROL CARD ERROR DIAGNOSTICS          #
        ITEM PEM$TEXT   C(00,00,40) = [ # MESSAGE TEXT                 #
          " UNRECOGNIZED CONTROL CARD PARAMETER.",
          " CONTROL CARD PARAMETER SYNTAX ERROR.",
          " ILLEGAL CONTROL CARD PARAMETER VALUE.", 
          " DUPLICATE CONTROL CARD PARAMETER.", 
          " REQUIRED PARAMETER NOT SPECIFIED.", 
                                      ];
        ITEM PEM$END    U(04,00,60) = [ RC$PARMIS(0) ]; 
        END 
  
      BASED ARRAY DUMMY [1:PAR$COUNT] S(1); 
        BEGIN 
        ITEM PARAMWORD  U(00,00,60);
        END 
  
      SWITCH PARTYPE  ,                # SWITCHES FOR PARAMETERS       #
        TYPE$MC;
CONTROL EJECT;
      P<ARG> = 2;            # RA CONTROL CARD PARAMETER AREA          #
      P<ARGCTWD> = O"64";    # RA CONTROL CARD PARAM COUNT WORD        #
# 
      LOOP TO PROCESS ALL SPECIFIED PARAMETERS
# 
      NARGS = ARG$COUNT[0];            # NO OF ARGUMENTS               #
      FOR ARGPTR=ARGPTR WHILE ARGPTR LS NARGS 
                        AND ERRCODE EQ 0
      DO                     # SCAN RA+2 THRU RA+22 FOR ARGUMENTS      #
        BEGIN 
        ARGPTR = ARGPTR + 1;           # MOVE POINTER TO NEXT ARGUMENT #
        MATCH = FALSE;
  
        FOR I=1 STEP 1 WHILE I LQ PAR$COUNT 
                       AND NOT MATCH
        DO
          BEGIN 
          IF ARG$SYMBO[ARGPTR] EQ PAR$KEY[I]
          THEN                         # FOUND VALID KEYWORD           #
            BEGIN 
            MATCH = TRUE; 
            K = I;                     # SET TO KEYWORD INDEX          #
            END 
          END 
  
        IF MATCH
        THEN                           # FOUND VALID PARAMETER         #
          BEGIN 
          I = ARGPTR + 1;              # POINTER TO PARAMETER VALUE    #
  
          IF (ARG$SEPAR[ARGPTR] EQ EQUAL) 
            AND (I LQ NARGS)
          THEN                         # PARAMETER FORMAT OK           #
            BEGIN 
            ARGPTR = I;                # UPDATE POINTER TO NEXT ARG    #
            J = PAR$NCV[K];            # CHARS ALLOWED FOR VALUE       #
  
            IF J EQ NC
              OR C<J,NC-J>ARG$SYMBO[ARGPTR] EQ 0
            THEN                       # PARAMETER VALUE NOT EXCEEDING #
              BEGIN                    # MAX NUMBER OF CHARS ALLOWED   #
# 
              SWITCH TO PARAMETER PROCESSING CASES
# 
              GOTO PARTYPE[K];
TYPE$MC:  
              I = PAR$MC; 
              CONVDDB(ARG$WORD[ARGPTR],K,J,ERR) ; # CONVERT DEC TO BIN #
              MC = K;        # MESSAGE COUNT BEFORE CALLING NETREL     #
              GOTO ENDPRC;
ENDPRC: 
              IF NOT ERR
              THEN                     # NO ERROR FOUND                #
                BEGIN 
                IF NOT PAR$PRC[I] 
                THEN                   # PARAMETER NOT PROCESSED       #
                  BEGIN 
                  PAR$PRC[I] = TRUE;   # SET PARAMETER PROCESSED FLAG  #
                  END 
  
                ELSE                   # DUPLICATE PARAMETER           #
                  ERRCODE = RC$PARDUP;
                END 
  
              ELSE                     # BAD PARAMETER VALUE           #
                ERRCODE = RC$PARVAL;
              END 
  
            ELSE                       # CHARS EXCEED ALLOWED VALUE    #
              ERRCODE = RC$PARVAL;
            END 
  
          ELSE                         # PARAMETER FORMAT ERROR        #
            ERRCODE = RC$PARFMT;
          END 
  
        ELSE                           # ILLEGAL PARAMETER             #
          ERRCODE = RC$PARILL;
        END 
  
      IF ERRCODE NQ 0 
      THEN                             # ERROR FOUND                   #
        BEGIN 
        MESSAGE(MSG$PARERR[ERRCODE],DFLOPT);
        ENDRBF;              # *****  TERMINATE RBF  *****             #
        END 
      RETURN; 
      END 
TERM
