*DECK SSICCCA 
USETEXT TEXTATS 
      PROC SSICCCA; 
*CALL COPYRITE
# TITLE SSICCCA - CRACK CONTROL CARD ARGUMENTS                         #
  
      BEGIN                            # SSICCCA                       #
# 
****  SSICCCA - CRACK CONTROL CARD ARGUMENTS. 
* 
*     THIS PROCEDURE CRACKS THE PARAMETERS PASSED ON THE CONTROL
*     STATEMENT.  A PARAMETER DESCRIPTOR ARRAY IS UTILIZED TO DEFINE
*     ALLOWABLE PARAMETERS AND ASSOCIATED ASPECTS OF EACH PARAMETER.
* 
*     ENTRY    PARAMETERS IN THE CONTROL BLOCK AREA.
* 
*     EXIT     SS     = SERVER SYSTEM PARMETER VALUE
*              TCPUN  = TCPHOST USERNAME PARAMETER VALUE
*              NIN    = NAM INVOCATION NUMBER PARAMETER VALUE 
*              MC     = DEBUG MESSAGE COUNT PARAMETER VALUE 
* 
* 
*     METHOD   COMPASS ROUTINE *XARG* IS CALLED TO CRACK THE PARAMTERS. 
*              THE ENTERED PARAMETERS ARE STORED IN THE ARG$ARRAY FOR 
*              FURTHER PROCESSING.  ALL PARAMETERS ARE VERIFIED TO HAVE 
*              BEEN ENTERED, *MC* IS VERIFIED TO BE LESS THAN 10000000, 
*              AND *NIN* LESS THAN 1000. IF ANY ERRORS ARE ENCOUNTERED
*              *SSIAEPR* IS CALLED TO TERMINATE THE APPLICATION.
# 
  
# 
****  PROC SSICCCA - XREF LIST. 
# 
  
      XREF
        BEGIN 
        PROC ABORT;      # ABORT CONTROL POINT                         #
        PROC SSIAEPR;    # ATS ERROR PROCESSIN ROUTINE                 #
        PROC XARG;       # CRACK CONTROL STATEMENT PARMS               #
        PROC XDXB;       # CONVERT DISPLAY TO BINARY                   #
        FUNC XSFN C(10); # SPACE FILL NAME                             #
        END 
  
# 
****  MISCELLANEOUS DEFINITIONS 
# 
      DEF MCDEFAULT # "500" #;         # DEFAULT MC PARAMETER VALUE    #
      DEF NUMPARAMS   # 4 #;           # NUMBER OF CONTROL CARD PARAMS #
      DEF NUMPAR1     # 5 #;           # NUMBER OF PARAMETERS + 1      #
  
# 
****  REASON CODE FOR NORMAL CONTROL CARD PROCESSING
# 
      DEF RC$OK      # 0 #;            # NO ERRORS ENCOUNTERED         #
  
# 
****  PARAMETER ARRAY ELEMENTS
# 
      DEF NIN$ENT    # 1 #;            # NAM INVOCATION PARAMETER      #
      DEF MC$ENT     # 2 #;            # MESSAGE COUNT PARAMETER       #
      DEF SS$ENT     # 3 #;            # SERVER SYSTEM PARAMETER       #
      DEF UN$ENT     # 4 #;            # TCPHOST USERNAME PARAMETER    #
  
# 
****  PARM$ARRAY - THIS ARRAY WILL CONTAIN THE VALUES FOR EACH
*     PARAMETER SPECIFIED IN THE APPLICATION CALL.
# 
  
      ARRAY PARM$ARRAY [1:NUMPARAMS] S(3);
        BEGIN 
        ITEM PARM$CHAR    C(00,00,30); # CHARACTER VALUE OF PARAMETER  #
        ITEM PARM$INTEGER U(00,00,60); # INTEGER VALUE OF PARAMETER    #
        ITEM PARM$INT2    U(01,00,60); # INTEGER VALUE OF PARAMETER    #
        ITEM PARM$INT3    U(02,00,60); # INTEGER VALUE OF PARAMETER    #
        END 
  
# 
****  ARG$ARRAY - THIS ARRAY SETS UP THE ARGUMENT TABLE FOR CRACKING
*     THE CONTROL CARD. IT IS USED IN THE CALL TO *XARG*. 
# 
  
      ARRAY ARG$ARRAY [1:NUMPAR1] S(2); 
        BEGIN 
        ITEM ARG$2WORDARG U(00,00,12) = [ 
                                    O"77",                 # NIN       #
                                    O"77",                 # MC        #
                                    O"77",                 # SS        #
                                    O"77",                 # UN        #
                                    0,                     # ZERO WORD #
                                    ];
        ITEM ARG$ADDEFLT  U(00,12,18) = [ 
                                    0,                     # NIN       #
                                    0,                     # MC        #
                                    0,                     # SS        #
                                    0,                     # UN        #
                                    0,                     # ZERO WORD #
                                    ];
        ITEM ARG$STATUS   U(00,30,09) = [ 
                                    O"400",                # NIN       #
                                    O"400",                # MC        #
                                    O"400",                # SS        #
                                    O"400",                # UN        #
                                    0,                     # ZERO WORD #
                                    ];
        ITEM ARG$WORDCNT  U(00,39,03) = [ 
                                    1,                     # NIN       #
                                    1,                     # MC        #
                                    3,                     # SS        #
                                    1,                     # UN        #
                                    0,                     # ZERO WORD #
                                    ];
        ITEM ARG$RESULT   U(00,42,18) = [ 
                                    0,                     # NIN       #
                                    0,                     # MC        #
                                    0,                     # SS        #
                                    0,                     # UN        #
                                    0,                     # ZERO WORD #
                                    ];
        ITEM ARG$KEYWORD  U(01,00,42) = [ 
                                    O"16111600000000",     # NIN       #
                                    O"15030000000000",     # MC        #
                                    O"23230000000000",     # SS        #
                                    O"25160000000000",     # UN        #
                                    0,                     # ZERO WORD #
                                    ];
        ITEM ARG$ZERO     U(01,42,18) = [ 
                                    0,                     # NIN       #
                                    0,                     # MC        #
                                    0,                     # SS        #
                                    0,                     # UN        #
                                    0,                     # ZERO WORD #
                                    ];
        END 
  
# 
****  LOCAL VARIABLES 
# 
  
      ITEM ERRFLAG             I;      # STATUS RETURNED BY *XARG*     #
      ITEM LOOP                I;      # LOOP COUNTER                  #
  
CONTROL EJECT;
  
# 
****  START MAIN PROCEDURE
# 
  
      C<0,3>PARM$CHAR [MC$ENT] = MCDEFAULT; 
  
      FOR LOOP = 1 STEP 1 UNTIL NUMPARAMS 
      DO
        BEGIN                          # INITIALIZE ARGUMENT ARRAY     #
        ARG$RESULT [LOOP] = LOC (PARM$ARRAY [LOOP]);
        END 
  
      XARG (LOC (ARG$ARRAY [1]), 0, ERRFLAG); # CRACK CONTROL CARD     #
  
      IF ERRFLAG LS 0 
      THEN
        ERRFLAG = CCSYNTAX$;
      ELSE IF ERRFLAG GR 0
      THEN
        ERRFLAG = PARMINV$; 
  
      IF ERRFLAG EQ RC$OK 
      THEN
        BEGIN                          # CHECK THAT ALL PARMS VALID    #
        FOR LOOP = 1 STEP 1 UNTIL NUMPARAMS 
        DO
          BEGIN                        # VERIFY ALL PARAMETERS ENTERED #
          IF PARM$INTEGER [LOOP] EQ 0 
          THEN
            BEGIN 
            ERRFLAG = PARMISS$; 
            GOTO SAVEPARM;
            END 
          END 
        END 
  
    SAVEPARM: 
  
      IF ERRFLAG NQ RC$OK 
      THEN
        BEGIN                          # TERMINATE APPLICATION         #
        SSIAEPR (ERRFLAG);
        END 
  
      C<0,10>SS = XSFN (PARM$INTEGER [SS$ENT]); 
      C<10,10>SS = XSFN (PARM$INT2 [SS$ENT]); 
      C<20,10>SS = XSFN (PARM$INT3 [SS$ENT]); 
      TCPUN = PARM$CHAR [UN$ENT]; 
      XDXB (PARM$INTEGER [NIN$ENT], 1, NIN);
      XDXB (PARM$INTEGER [MC$ENT], 1, MC);
  
      IF (NIN GR 999) OR (MC GR 9999999)
      THEN
        BEGIN                          # INVALID VALUES ABORT APPLIC   #
        SSIAEPR (PARMINV$); 
        END 
  
      RETURN; 
  
      END                              # SSICCCA                       #
  
      TERM
