Retro1.org codex

*DECK NS$CRA
USETEXT CYB$NS
USETEXT COM$NS
USETEXT DEF$NS
      PROC NS$CRA;           # CONTROL CARD CRACKER                    #
 
# TITLE NS$CRA - CONTROL CARD CRACKER. #
 
      BEGIN    # NS$CRA # 
# 
**    NS$CRA - CONTROL CARD CRACKER.
* 
*     J.C. LEE    1981
* 
*     THIS ROUTINE IS PART OF THE INITIALIZATIN PROCESS FOR NS. 
*     ITS FUNCTION IS TO CRACK THE NS CONTROL CARD, SAVE VALID
*     VALUES, AND FLAG ERRORS IF FOUND. 
* 
*     PROC NS$CRA 
* 
*     ENTRY:  
*       ARGUMENT LIST IN COMMUNICATION AREA.
* 
*     EXIT: 
*       1.  NIN, NDFCT, NSM, MC, AND RT VALUES
*       2.  ERROR MESSAGE(S) SENT IF FOUND. 
* 
*     METHOD: 
*       LOOP THROUGH THE ARGUMENT LIST.  FOR EACH OPTION, SEARCH THE
*       PARAMETER TABLE FOR VALID OPTION.  IF FOUND, JUMP TO THE
*       APPROPRIATE PARAGRAPH TO CONVERT AND SAVE VALUE, ELSE FLAG
*       AS ILLEGAL OPTION.
* 
# 
 
      XREF
        BEGIN                          # RA COMMUNICATION AREA         #
        ARRAY ARG[1:22] S(1); 
          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 
        ARRAY ACT[0:0] S(1);
          BEGIN 
          ITEM ACT$COUNT  U(00,NL,AL); # ARGUMENT COUNT                #
          END 
        END 
 
      XREF
        BEGIN 
        PROC ABORT;                    # ABORT NS                      #
        PROC NS$MSG;                   # DISPATCH MESSAGE              #
        PROC NS$CVD;                   # CONVERT DECIMAL DC TO BINARY  #
        PROC NS$CVH;                   # CONVERT HEX DC TO BINARY      #
        END 
# 
      DEFINITIONS FOR PARAMETER INDEXES 
# 
      DEF PAR$COUNT  #05#;             # NUMBER OF VALID NS PARAMETERS #
      DEF PAR$NIN    #01#;             # NIN INDEX                     #
      DEF PAR$NDFCT  #02#;             # NDFCT INDEX                   #
      DEF PAR$FDP    #03#;             # NSM INDEX                     #
      DEF PAR$MC     #04#;             # MC INDEX                      #
      DEF PAR$RT     #05#;             # RT INDEX                      #
# 
      MISCELLANEOUS DEFINITIONS 
# 
      DEF COMMA      # O"56" #; 
      DEF EQUAL      # O"54" #; 
      DEF PERIOD     # O"57" #; 
      DEF YES        #O"31052300000000"#; 
      DEF NO         #O"16170000000000"#; 
      DEF CT$P       #O"20000000000000"#; # FILE CATEGORY = PRIVATE    #
      DEF CT$S       #O"23000000000000"#; # FILE CATEGORY = SEMIPRIVATE#
      DEF CT$PU      #O"20250000000000"#; # FILE CATEGORY = PUBLIC     #
# 
      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"16111600000000", # NIN        #
                                       O"16040603240000", # NDFCT      #
                                       O"06042000000000", # FDP        #
                                       O"15030000000000", # MC         #
                                       O"22240000000000", # RT         #
                                      ];
        ITEM PAR$NCV    U(00,42,12) = [ # CHARS ALLOWED FOR PARAM VALUE#
                                       3,  # UP TO 3 DEC CHARS FOR NIN #
                                       2,  # UP TO 2 CHARS FOR NDFCT   #
                                       3,  # UP TO 3 CHARS FOR FDP     #
                                       7,  # UP TO 7 DEC CHARS FOR MC  #
                                       3,  # UP TO 3 CHARS FOR RT      #
                                      ];
        ITEM PAR$PRC    B(00,54,06) = [ # PARAMETER PROCESSED FLAG     #
                                       FALSE, 
                                       FALSE, 
                                       FALSE, 
                                       FALSE, 
                                       FALSE, 
                                      ];
        END 
      DEF L$PARERR   # 5 #; 
      DEF DM$PARERR  # DM$SYSLOC+DM$ABORT #;
      ARRAY MSG$PARERR [RC$PARILL:RC$PARMIS] S(L$PARERR); 
        BEGIN                # CONTROL CARD ERROR DIAGNOSTICS          #
        ITEM PEM$TEXT   C(00,00,40) = [ # MESSAGE TEXT                 #
          "NS/UNRECOGNIZED CONTROL CARD PARAMETER.",
          "NS/CONTROL CARD PARAMETER SYNTAX ERROR.",
          "NS/ILLEGAL CONTROL CARD PARAMETER VALUE.", 
          "NS/DUPLICATE CONTROL CARD PARAMETER.", 
          "NS/NIN IS 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$NIN, 
        TYPE$NDFCT, 
        TYPE$FDP, 
        TYPE$MC,
        TYPE$RT;
CONTROL EJECT;
# 
      LOOP TO PROCESS ALL SPECIFIED PARAMETERS
# 
      NARGS = ACT$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$NIN: 
              I = PAR$NIN;
              NS$CVD(ARG$WORD[ARGPTR],K,J,ERR);  # CONVERT DEC TO BIN  #
              ZDMBID$NIN[0] = K; # SET NETWORK INVOCATION NUMBER       #
              B<0,18>K = J + O"333333";# SET TO DISPLAY-CODED DEC      #
              GOTO ENDPRC;
TYPE$NDFCT: 
              I = PAR$NDFCT;
              IF ARG$SYMBO[ARGPTR] EQ CT$P
              THEN # FILE CATEGORY IS PRIVATE                          #
                K = 0;
              ELSE
                BEGIN 
                IF ARG$SYMBO[ARGPTR] EQ CT$S
                THEN # FILE CATEGORY IS SEMIPRIVATE                    #
                  K = 1;
                ELSE
                  BEGIN 
                  IF ARG$SYMBO[ARGPTR] EQ CT$PU 
                  THEN # FILE CATEGORY IS PUBLIC                       #
                    K = 2;
                  ELSE # UNRECOGNIZED PARAMETER VALUE                  #
                    ERR = TRUE; 
                  END 
                END 
              GOTO ENDPRC;
TYPE$FDP: 
              I = PAR$FDP;
              GOTO CHECKYN; 
TYPE$MC:  
              I = PAR$MC; 
              NS$CVD(ARG$WORD[ARGPTR],K,J,ERR) ; # CONVERT DEC TO BIN  #
              GOTO ENDPRC;
TYPE$RT:  
              I = PAR$RT; 
CHECKYN:  
              IF ARG$SYMBO[ARGPTR] EQ YES 
              THEN
                K = ASC$YY;            # PARAMETER VALUE IS -YES-      #
 
              ELSE
                BEGIN 
                IF ARG$SYMBO[ARGPTR] EQ NO
                THEN
                  K = ASC$NN;          # PARAMETER VALUE IS -NO-       #
 
                ELSE
                  ERR = TRUE;          # BAD PARAMETER VALUE           #
                END 
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  #
                  P<DUMMY> = LOC(NIN);
                  PARAMWORD[I] = K;    # STORE PARAM VALUE IN COMMON   #
                  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 EQ 0 
        AND NOT PAR$PRC[PAR$NIN]
      THEN                   # NIN MUST BE SPECIFIED                   #
        ERRCODE = RC$PARMIS;
 
      IF ERRCODE NQ 0 
      THEN                             # ERROR FOUND                   #
        NS$MSG(MSG$PARERR[ERRCODE],L$PARERR,DM$PARERR); 
      RETURN; 
      END 
TERM