*DECK FCSIPCS 
USETEXT TEXTFCS;
      PROC FCSIPCS; 
*CALL COPYRITE
# TITLE FCSIPCS - PARSE FTP CONTROL STATEMENT PARAMETERS.              #
  
      BEGIN                            # FCSIPCS                       #
  
# 
**    FCSIPCS - PARSE FTP CONTROL STATEMENT PARAMETERS. 
* 
*     C. J. RAMSAY                     87/11/03 
* 
*     THIS PROCEDURE PARSES THE FTP CONTROL STATEMENT PARAMETERS. 
* 
*     PROC FCSIPCS
* 
*     ENTRY   (RA+2)     = ARGUMENT LIST. 
*             (RA+64)    = ARGUMENT COUNT.
* 
*     EXIT    FTPINPUT   = FTP INPUT FILE NAME. 
*             FTPOUTPUT  = FTP OUTPUT FILE NAME.
*             FTPPROLOG  = FTP PROLOG FILE NAME.
* 
*     NOTES   FTP(P1,P2,P3) 
* 
*             I    OMITTED OR I    INPUT FILE IS *INPUT*. 
*                  I=0             NO INPUT FILE. 
*                  I=LFN           INPUT FILE IS *LFN*. 
* 
*             O    OMITTED OR O    OUTPUT FILE IS *OUTPUT*. 
*                  O=0             NO OUTPUT FILE.
*                  O=LFN           OUTPUT FILE IS *LFN*.
* 
*             P    OMITTED OR P    PROLOG FILE IS *FTPPRLG*.
*                  P=0             NO PROLOG FILE.
*                  P=LFN           PROLOG FILE IS *LFN*.
* 
*     METHOD  VALIDATE FTP CONTROL STATEMENT PARAMETERS.
*             IF ANY ERRORS THEN ABORT FTP CONTROL STATEMENT. 
* 
# 
  
# 
****  PROC FCSIPCS - XREF LIST
# 
      XREF
        BEGIN 
        PROC ABORT;                    # ABORT JOB                     #
        FUNC FCSUVFC B;                # VALIDATE FILE CHARACTERISTICS #
        FUNC FCSUVFN B;                # VALIDATE NOS FILE NAME        #
        PROC MESSAGE;                  # DAYFILE A MESSAGE             #
        PROC NETUCDA;                  # CONVERT DISPLAY CODE TO ASCII #
        PROC NETUCLR;                  # CLEAR AN AREA OF MEMORY       #
        END 
# 
****
# 
      DEF PVTMAX$        #    4  #;    # NUMBER OF PARAMETERS + 1      #
      DEF EQUAL          # O"54" #;    # EQUAL SIGN                    #
      DEF SCOPECOMMA     # O"01" #;    # PRODUCT SET COMMA             #
      DEF SCOPEEQUAL     # O"02" #;    # PRODUCT SET EQUAL SIGN        #
      DEF SCOPETERM      # O"17" #;    # PRODUCT SET TERMINATOR        #
      DEF LUNKPAR        #   24  #;    # LENGTH UNKNOWN PARAMETER      #
      DEF LINVSEP        #   38  #;    # LENGTH INVALID SEPARATOR      #
      DEF LDUPPAR        #   26  #;    # LENGTH DUPLICATE PARAMETER    #
      DEF LMISVAL        #   34  #;    # LENGTH VALUE MISSING          #
      DEF LINVINP        #   31  #;    # LENGTH INVALID INPUT FILE     #
      DEF LINVOUT        #   30  #;    # LENGTH INVALID OUTPUT FILE    #
      DEF LINVLFN        #   38  #;    # LENGTH INVALID FILE NAME      #
      DEF LDUPLFN        #   26  #;    # LENGTH DUPLICATE FILE NAME    #
  
      ITEM ARGI          I;            # ARGUMENT LIST INDEX           #
      ITEM BITI          I;            # BIT INDEX                     #
      ITEM DAYI          I;            # DAYFILE MESSAGE INDEX         #
      ITEM DIND          I;            # DESTINATION INDEX             #
      ITEM NUMC          I;            # NUMBER OF CHARACTERS          #
      ITEM PVTI          I;            # PARAMETER VALIDATION INDEX    #
# 
*     THIS ARRAY DEFINES THE FORMAT OF THE ARGUMENT COUNT.
# 
      BASED ARRAY ACT [00:00] S(1); 
        BEGIN 
        ITEM ACT$COUNT   U(00,42,18);  # ARGUMENT COUNT                #
        END 
# 
*     THIS ARRAY DEFINES THE FORMAT OF THE ARGUMENT LIST. 
# 
      BASED ARRAY ARG [01:22] S(1); 
        BEGIN 
        ITEM ARG$WORD    U(00,00,60);  # FULL WORD REFERENCE           #
        ITEM ARG$NAME    U(00,00,42);  # ARGUMENT NAME                 #
        ITEM ARG$VALUE   U(00,00,42);  # ARGUMENT VALUE                #
        ITEM ARG$SEP     U(00,42,18);  # ARGUMENT SEPARATOR            #
        END 
# 
*     THIS ARRAY DEFINES THE PARAMETER TABLE WHICH IS USED TO 
*     VALIDATE THE ARGUMENT LIST. 
# 
      ARRAY PVT [01:PVTMAX$] S(3);
        BEGIN 
        ITEM PVT$NAMEW   U(00,00,60); 
        ITEM PVT$NAME    U(00,00,42) = [O"11000000000000",
                                        O"17000000000000",
                                        O"20000000000000",
                                        O"00000000000000"]; 
        ITEM PVT$ZBYTE1  U(00,42,18) = [0, 0, 0, 0];
        ITEM PVT$SEEN    B(01,59,01) = [FALSE,
                                        FALSE,
                                        FALSE,
                                        FALSE]; 
        ITEM PVT$VALUEW  U(02,00,60); 
        ITEM PVT$VALUE   U(02,00,42) = [O"11162025240000",
                                        O"17252420252400",
                                        O"06242020221407",
                                        O"00000000000000"]; 
        ITEM PVT$ZBYTE2  U(02,42,18) = [0, 0, 0, 0];
        END 
# 
*     THESE STRINGS DEFINE THE CONTROL STATEMENT ERROR MESSAGES.
# 
      ITEM EDUPLFN       C(LDUPLFN) = 
      " FTP DUPLICATE FILE NAME, "; 
  
      ITEM EDUPPAR       C(LDUPPAR) = 
      " FTP DUPLICATE PARAMETER, "; 
  
      ITEM EINVLFN       C(LINVLFN) = 
      " FTP INVALID FILE NAME FOR PARAMETER, "; 
  
      ITEM EINVSEP       C(LINVSEP) = 
      " FTP INVALID SEPARATOR FOR PARAMETER, "; 
  
      ITEM EUNKPAR       C(LUNKPAR) = 
      " FTP UNKNOWN PARAMETER, "; 
  
      ITEM EMISVAL       C(LMISVAL) = 
      " FTP VALUE MISSING FOR PARAMETER, "; 
  
      ITEM EINVINP       C(LINVINP) = 
      " FTP UNABLE TO READ FROM FILE, ";
  
      ITEM EINVOUT       C(LINVOUT) = 
      " FTP UNABLE TO WRITE TO FILE, "; 
      CONTROL EJECT;
      PROC FCS2DEM (EMESS, LMESS, EPARM); 
      BEGIN                            # FCS2DEM                       #
# 
*     INTERNAL PROCEDURE - FCS2DEM
* 
*     THIS EMBEDDED PROCEDURE DAYFILES AN ERROR MESSAGE AND ABORTS. 
* 
# 
      ITEM EMESS         C(60);        # ERROR MESSAGE                 #
      ITEM LMESS         I;            # LENGTH OF ERROR MESSAGE       #
      ITEM EPARM         C(10);        # PARAMETER OF ERROR MESSAGE    #
  
      ITEM DMESS         C(80);        # DAYFILE ERROR MESSAGE         #
  
      NETUCLR (LOC(DMESS), 8);         # CLEAR DAYFILE MESSAGE BUFFER  #
  
      C<0,LMESS>DMESS = C<0,LMESS>EMESS;
  
      DAYI = LMESS; 
  
      FOR BITI = 0 STEP 6 
        WHILE B<BITI,6>EPARM NQ 0 DO
        BEGIN                          # LOOP ALL CHARACTERS PARMAETER #
        C<DAYI,1>DMESS = C<BITI/6,1>EPARM;
        DAYI = DAYI + 1;               # INCREMENT DAYFILE INDEX       #
        END 
  
      C<DAYI,1>DMESS = ".";            # STORE TERMINATING PERIOD      #
  
      MESSAGE (DMESS, 0);              # DAYFILE ERROR MESSAGE         #
      ABORT;                           # ABORT JOB                     #
  
      END                              # FCS2DEM                       #
      CONTROL EJECT;
# 
*     START MAIN PROCEDURE
# 
      FTPINPUT  = "0";                 # INITIALIZE INPUT FILE         #
      FTPOUTPUT = "0";                 # INITIALIZE OUTPUT FILE        #
      FTPPROLOG = "0";                 # INITIALIZE PROLOG FILE        #
# 
*     PICK UP FTP CONTROL STATEMENT PARAMETERS. 
# 
      P<ARG> = O"2";                   # BASE ARGUMENT LIST POINTER    #
      P<ACT> = O"64";                  # BASE ARGUMENT COUNT POINTER   #
  
      FOR ARGI = 0
        WHILE ARGI LS ACT$COUNT[0] DO 
        BEGIN                          # WHILE MORE ARGUMENTS          #
        ARGI = ARGI + 1;               # INCREMENT ARGUMENT INDEX      #
# 
*     VALIDATE PARAMETER NAME.
# 
        PVT$NAME[PVTMAX$] = ARG$NAME[ARGI]; 
        FOR PVTI = 1
          WHILE PVT$NAME[PVTI] NQ ARG$NAME[ARGI] DO 
          BEGIN                        # WHILE MORE NAMES + NOT FOUND  #
          PVTI  = PVTI + 1;            # INCREMENT VALIDATION INDEX    #
          END 
        IF PVTI EQ PVTMAX$
        THEN
          BEGIN                        # PARAMETER NAME NOT FOUND      #
          FCS2DEM (EUNKPAR, LUNKPAR,
                   PVT$NAMEW[PVTI]);   # DAYFILE ERROR MESSAGE + ABORT #
          END 
# 
*     VALIDATE PARAMETER SEPARATOR. 
# 
        IF NOT ((ARG$SEP[ARGI] EQ 0) OR 
                (ARG$SEP[ARGI] EQ EQUAL) OR 
                (ARG$SEP[ARGI] EQ SCOPEEQUAL) OR
                (ARG$SEP[ARGI] EQ SCOPECOMMA) OR
                (ARG$SEP[ARGI] EQ SCOPETERM)) 
        THEN
          BEGIN                        # INVALID SEPARATOR DETECTED    #
          FCS2DEM (EINVSEP, LINVSEP,
                   PVT$NAMEW[PVTI]);   # DAYFILE ERROR MESSAGE + ABORT #
          END 
# 
*     CHECK FOR DUPLICATE PARAMETER.
# 
        IF PVT$SEEN[PVTI] 
        THEN
          BEGIN                        # DUPLICATE PARAMETER DETECTED  #
          FCS2DEM (EDUPPAR, LDUPPAR,
                   PVT$NAMEW[PVTI]);   # DAYFILE ERROR MESSAGE + ABORT #
          END 
        PVT$SEEN[PVTI] = TRUE;         # MARK PARAMETER SEEN           #
# 
*     IF PARAMETER IS OF THE FORM PARAMETER NAME = PARAMETER VALUE
*     THEN PICK UP THE PARAMETER VALUE. 
# 
        IF (ARG$SEP[ARGI] EQ EQUAL) OR
           (ARG$SEP[ARGI] EQ SCOPEEQUAL)
        THEN
          BEGIN                        # PARAMETER NAME = VALUE        #
          ARGI = ARGI + 1;             # INCREMENT ARGUMENT INDEX      #
          IF (ARGI GR ACT$COUNT[0]) OR
             (ARG$VALUE[ARGI] EQ 0) 
          THEN
            BEGIN                      # NO PARAMETER VALUE SPECIFIED  #
            FCS2DEM (EMISVAL, LMISVAL,
                     PVT$NAMEW[PVTI]); # DAYFILE ERROR MESSAGE + ABORT #
            END 
          PVT$VALUE[PVTI] = 
            ARG$VALUE[ARGI];           # STORE PARAMETER VALUE         #
          END 
        END 
# 
*     VALIDATE PARAMETERS AS VALID NOS FILE NAMES.
# 
      FOR PVTI = 1 STEP 1 
        WHILE PVTI LS PVTMAX$ DO
        BEGIN                          # FOR ALL POSSIBLE PARAMETERS   #
        NUMC = 0;                      # INITIALIZE NUMBER OF CHARS    #
        FOR BITI = 0 STEP 6 
          WHILE B<BITI,6>PVT$VALUEW[PVTI] NQ 0 DO 
          BEGIN                        # WHILE ZERO BYTE NOT FOUND     #
          NUMC = NUMC + 1;             # INCREMENT NUMBER OF CHARS     #
          END 
        P<TBUF> = LOC(PVT$VALUEW[PVTI]);
        DIND = 0;                      # RESET DESTINATION INDEX       #
        NETUCDA (TBUF, 0, 
                 NUMC, PARMS[PVTI], 
                 DIND, FALSE);         # CONVERT VALUE TO ASCII        #
        PARAMSZ[PVTI] = NUMC;          # NUMBER OF CHARACTERS IN NAME  #
        IF NOT FCSUVFN (PARMS[PVTI])
        THEN
          BEGIN                        # NOT VALID NOS FILE NAME       #
          FCS2DEM (EINVLFN, LINVLFN,
                   PVT$NAMEW[PVTI]);   # DAYFILE ERROR MESSAGE + ABORT #
          END 
        END 
# 
*     CHECK FOR A DUPLICATE FILE NAME.
# 
      IF ((PARAMNB[1] EQ PARAMNB[2]) OR (PARAMNB[1] EQ PARAMNB[3])) AND 
          (PARAMNB[1] NQ "0") 
      THEN
        BEGIN                          # DUPLICATE FILE NAME FOUND     #
        FCS2DEM (EDUPLFN, LDUPLFN,
                 PARAMNZ[1]);          # DAYFILE ERROR MESSAGE + ABORT #
        END 
      IF (PARAMNB[2] EQ PARAMNB[3]) AND 
         (PARAMNB[2] NQ "0")
      THEN
        BEGIN                          # DUPLICATE FILE NAME FOUND     #
        FCS2DEM (EDUPLFN, LDUPLFN,
                 PARAMNZ[2]);          # DAYFILE ERROR MESSAGE + ABORT #
        END 
# 
*     VALIDATE INPUT FILE CAN BE READ FROM AND OUTPUT FILE CAN BE 
*     WRITTEN TO. 
# 
      IF PARAMNB[1] NQ "0"
      THEN
        BEGIN                          # INPUT FILE DESIRED            #
        IF NOT FCSUVFC (PARAMNZ[1], FALSE, TRUE, FALSE) 
        THEN
          BEGIN                        # INPUT FILE CANNOT BE READ     #
          FCS2DEM (EINVINP, LINVINP,
                   PARAMNZ[1]);        # DAYFILE ERROR MESSAGE + ABORT #
          END 
        END 
      IF PARAMNB[2] NQ "0"
      THEN
        BEGIN                          # OUTPUT FILE DESIRED           #
        IF NOT FCSUVFC (PARAMNZ[2], FALSE, FALSE, TRUE) 
        THEN
          BEGIN                        # OUTPUT FILE CANNOT BE WRITTEN #
          FCS2DEM (EINVOUT, LINVOUT,
                   PARAMNZ[2]);        # DAYFILE ERROR MESSAGE + ABORT #
          END 
        END 
# 
*     PICK UP INPUT, OUTPUT AND PROLOG FILE NAMES, AND UPDATE USER
*     STATE.
# 
      FTPINPUT  = PARAMNB[1];          # PICK UP INPUT FILE NAME       #
      FTPOUTPUT = PARAMNB[2];          # PICK UP OUTPUT FILE NAME      #
      FTPPROLOG = PARAMNB[3];          # PICK UP PROLOG FILE NAME      #
  
  
      RETURN;                          # RETURN TO CALLER              #
  
      END                              # FCSIPCS                       #
  
      TERM
