*DECK FFSUPCP 
USETEXT TEXTFFS 
FUNC FFSUPCP B; 
*CALL COPYRITE
# TITLE FFSUPCP - PROCESS COMMAND PARAMETERS.                          #
      BEGIN                            # FFSUPCP                       #
# 
**    FFSUPCP - PROCESS COMMAND PARAMETERS. 
* 
*     A. LIM                           88/02/19 
* 
*     THIS PROCEDURE PROCESSES ALL THE NOS PERMANENT FILE PARAMETERS
*     AND DATA HANDLING PARAMETERS OF THE FTP PROTOCOL ELEMENTS.
*     IT SETS THE APPROPRIATE FIELDS IN THE CIO FET AND IN THE SITE 
*     COMMON BLOCK *SITECOM*. 
* 
*     ENTRY   PAR = PARAMETER LIST BUFFER CONTAINING THE LIST 
*                   OF CRACKED NOS PF PARAMETERS AND DATA HANDLING
*                   PARAMETERS. 
* 
*     EXIT    IF NO ERROR ENCOUNTERED:  
*               *FFSUPCP* SET TO TRUE.
*               APPROPRIATE FIELDS IN THE FET SET.
*               APPROPRIATE FIELDS IN *SITECOM* SET.
*             ELSE
*               *FFSUPCP* SET TO FALSE. 
* 
*     METHOD  THIS PROCEDURE CONSISTS OF PRIMARILY A LOOP.
*             EACH TIME THROUGH THE LOOP. ONE PARAMETER IS PROCESSED. 
*             FOR EACH PARAMETER, VALIDATE THE PARAMETER VALUE, 
*             AND SET THE APPROPRIATE VALUE IN THE FET OF THE 
*             MANAGED BUFFER TABLE *MBT* OR IN THE SITE COMMON BLOCK
*             *SITECOM* WHICHEVER APPLIES.
*             FOR ANY INVALID PARAMETER, EXIT WITH *FFSUPCP* SET TO 
*             FALSE.
# 
  
# 
***   FUNC FFSUPCP - XREF LIST BEGIN. 
# 
  
      XREF
        BEGIN 
        PROC FFSUCLR;                # CLEAR A BLOCK OF MEMORY         #
        PROC DATEVAL;                # CONVERT AND VALIDATE DATE       #
        PROC PDATE;                  # GET CURRENT DATE FROM SYSTEM    #
        FUNC XDXB U;                 # CONVERT DISPLAY TO BINARY       #
        END 
  
      ITEM DATEBIN    U;             # DATE IN BINARY                  #
      ITEM DATETIME   U;             # DATE AND TIME                   #
      ITEM DNBIN      U;             # DEVICE NUMBER IN BINARY         #
      ITEM EXPRCD     B;             # EXPIRATION DATE/TERM PROCESSED  #
      ITEM PERR       B;             # PARAMETER ERROR INIDICATION     #
      ITEM FSCBIN     U;             # FSC PARAMETER VALUE IN BINARY   #
      ITEM FTPRCD     B;             # FILE TYPE PROCESSED INDICATOR   #
      ITEM I          U;             # LOOP INDEX                      #
      ITEM J          U;             # LOOP INDEX                      #
      ITEM PVALUE     U;             # PARAMETER VALUE                 #
      ITEM PVALUC     C(2);          # PARAMETER VALUE AS 2 CHARS      #
      ITEM RETSTATUS  U;             # RETURN STATUS                   #
      ITEM SBIN       U;             # S PARAMETER VALUE IN BINARY     #
      ITEM SRPRCD     B;             # SPECIAL REQUEST PROCESSED INDTR #
      ITEM XTERMBIN   U;             # EXPIRATION TERM IN BINARY       #
  
      ARRAY CDATE [00:00] S(1);        # CURRENT DATE                  #
        BEGIN 
        ITEM DATE$WD    U(00,00,60);   # FULL WORD REFERENCE           #
        ITEM DATE$DATE  U(00,42,18);   # DATE IN YYMMDD                #
        ITEM DATE$YY    U(00,42,06);   # YEAR                          #
        END 
# 
*     THIS ARRAY DEFINES THE VALID PARAMTER VALUES AND THE
*     CORRESPONDING NUMERICAL VALUES FOR THE "AC" - ALTERNATE CATLIST 
*     PARAMETER.
# 
  
      ARRAY ACPV [00:ACMAX$] S(2);
        BEGIN 
        ITEM ACPV$MN    U(00,00,60) =  # PARAMETER VALUE IN MNEMONICS  #
                                     [ACN$, 
                                      ACY$];
        ITEM ACPV$NC    U(01,00,60) =  # PARAMETER VALUE IN NUMERIC    #
                                     [ACNN$,
                                      ACNY$,
                                          0]; 
        END 
# 
*     THIS ARRAY DEFINES THE VALID PARAMTER VALUES AND THE
*     CORRESPONDING NUMERICAL VALUES FOR THE "AL" - ACCESS LEVEL
*     PARAMETER.
# 
  
      ARRAY ALPV [00:ALMAX$] S(2);
        BEGIN 
        ITEM ALPV$MN    U(00,00,60) =  # PARAMETER VALUE IN MNEMONICS  #
                                     [ALLVL0$,
                                      ALLVL1$,
                                      ALLVL2$,
                                      ALLVL3$,
                                      ALLVL4$,
                                      ALLVL5$,
                                      ALLVL6$,
                                      ALLVL7$]; 
        ITEM ALPV$NC    U(01,00,60) =  # PARAMETER VALUE IN NUMERIC    #
                                     [ALNLVL0$, 
                                      ALNLVL1$, 
                                      ALNLVL2$, 
                                      ALNLVL3$, 
                                      ALNLVL4$, 
                                      ALNLVL5$, 
                                      ALNLVL6$, 
                                      ALNLVL7$, 
                                             0];
        END 
  
# 
*     THIS ARRAY DEFINES THE VALID PARAMTER VALUES AND THE
*     CORRESPONDING NUMERICAL VALUES FOR THE "BR" - BACKUP REQUIREMENT
*     PARAMETER.
# 
  
      ARRAY BRPV [00:BRMAX$] S(2);
        BEGIN 
        ITEM BRPV$MN    U(00,00,60) =  # PARAMETER VALUE IN MNEMONICS  #
                                     [BRN$, 
                                      BRY$, 
                                      BRMD$]; 
        ITEM BRPV$NC    U(01,00,60) =  # PARAMETER VALUE IN NUMERIC    #
                                     [BRNN$,
                                      BRNY$,
                                      BRNMD$, 
                                          0]; 
        END 
  
# 
*     THIS ARRAY DEFINES THE VALID PARAMTER VALUES AND THE
*     CORRESPONDING NUMERICAL VALUES FOR THE "CT" - CATEGORY
*     PARAMETER.
# 
  
      ARRAY CTPV [00:CTMAX$] S(2);
        BEGIN 
        ITEM CTPV$MN    U(00,00,60) =  # PARAMETER VALUE IN MNEMONICS  #
                                     [CTP$, 
                                      CTPR$,
                                      CTPRIVATE$, 
                                      CTS$, 
                                      CTSPRIV$, 
                                      CTPU$,
                                      CTPUBLIC$]; 
        ITEM CTPV$NC    U(01,00,60) =  # PARAMETER VALUE IN NUMERIC    #
                                     [CTNP$,
                                      CTNP$,
                                      CTNP$,
                                      CTNS$,
                                      CTNS$,
                                      CTNPU$, 
                                      CTNPU$, 
                                           0];
        END 
  
# 
*     THIS ARRAY DEFINES THE VALID PARAMTER VALUES AND THE
*     CORRESPONDING NUMERICAL VALUES FOR THE "M" - MODE PARAMETER.
# 
  
      ARRAY MPV [00:MMAX$] S(2);
        BEGIN 
        ITEM MPV$MN     U(00,00,60) =  # PARAMETER VALUE IN MNEMONICS  #
                                     [MW$,
                                      MWRITE$,
                                      MR$,
                                      MREAD$, 
                                      MA$,
                                      MAPPEND$, 
                                      ME$,
                                      MEXECUTE$,
                                      MN$,
                                      MNULL$, 
                                      MM$,
                                      MMODIFY$, 
                                      MRM$, 
                                      MREADMD$, 
                                      MRA$, 
                                      MREADAP$, 
                                      MU$,
                                      MUPDATE$, 
                                      MRU$, 
                                      MREADUP$];
        ITEM MPV$NC     U(01,00,60) =  # PARAMETER VALUE IN NUMERIC    #
                                     [MNW$, 
                                      MNW$, 
                                      MNR$, 
                                      MNR$, 
                                      MNA$, 
                                      MNA$, 
                                      MNE$, 
                                      MNE$, 
                                      MNN$, 
                                      MNN$, 
                                      MNM$, 
                                      MNM$, 
                                      MNRM$,
                                      MNRM$,
                                      MNRA$,
                                      MNRA$,
                                      MNU$, 
                                      MNU$, 
                                      MNRU$,
                                      MNRU$,
                                          0]; 
        END 
  
# 
*     THIS ARRAY DEFINES THE VALID PARAMTER VALUES AND THE
*     CORRESPONDING NUMERICAL VALUES FOR THE "PR" - PREFERRED RESIDENCE 
*     PARAMETER.
# 
  
      ARRAY PRFPV [00:PRMAX$] S(2); 
        BEGIN 
        ITEM PRPV$MN    U(00,00,60) =  # PARAMETER VALUE IN MNEMONICS  #
                                     [PRL$, 
                                      PRD$, 
                                      PRM$, 
                                      PRN$];
        ITEM PRPV$NC    U(01,00,60) =  # PARAMETER VALUE IN NUMERIC    #
                                     [PRNL$,
                                      PRND$,
                                      PRNM$,
                                      PRNN$,
                                         0];
        END 
  
# 
*     THIS ARRAY DEFINES THE VALID PARAMTER VALUES AND THE
*     CORRESPONDING DISPLAY CODE VALUES FOR THE "R" - DEVICE TYPE 
*     PARAMETER.
# 
  
      ARRAY RPV [00:RMAX$] S(2);
        BEGIN 
        ITEM RPV$MN    U(00,00,60) =   # PARAMETER VALUE IN MNEMONICS  #
                                    [RDB$,
                                     RDC$,
                                     RDD$,
                                     RDE$,
                                     RDI$,
                                     RDJ$,
                                     RDK$,
                                     RDL$,
                                     RDM$,
                                     RDP$,
                                     RDQ$,
                                     RDV$,
                                     RDW$,
                                     RMT$,
                                     RNE$,
                                     RNT$,
                                     RTT$]; 
        ITEM RPV$DC    U(01,00,60) =
                                    [0,RMAX$(0)]; 
        ITEM RPV$DC1   C(01,48,02) =
                                    [RDDB$, 
                                     RDDC$, 
                                     RDDD$, 
                                     RDDE$, 
                                     RDDI$, 
                                     RDDJ$, 
                                     RDDK$, 
                                     RDDL$, 
                                     RDDM$, 
                                     RDDP$, 
                                     RDDQ$, 
                                     RDDV$, 
                                     RDDW$, 
                                     RDMT$, 
                                     RDNE$, 
                                     RDNT$, 
                                     RDTT$, 
                                     "  "]; 
        END 
  
# 
*     THIS ARRAY DEFINES THE VALID PARAMTER VALUES AND THE
*     CORRESPONDING NUMERICAL VALUES FOR THE "SS" - SUBSYSTEM PARAMETER.
# 
  
      ARRAY SSPV [00:SSMAX$] S(2);
        BEGIN 
        ITEM SSPV$MN    U(00,00,60) =  # PARAMETER VALUE IN MNEMONICS  #
                                     [SSNUL$, 
                                      SSNULL$,
                                      SSBAS$, 
                                      SSBASIC$, 
                                      SSFOR$, 
                                      SSFORT$,
                                      SSFORTRAN$, 
                                      SSFTN$, 
                                      SSFTNTS$, 
                                      SSEXE$, 
                                      SSEXEC$,
                                      SSEXECUTE$, 
                                      SSBAT$, 
                                      SSBATCH$];
        ITEM SSPV$NC    U(01,00,60) =  # PARAMETER VALUE IN NUMERIC    #
                                     [SSNNULL$, 
                                      SSNNULL$, 
                                      SSNBASIC$,
                                      SSNBASIC$,
                                      SSNFORT$, 
                                      SSNFORT$, 
                                      SSNFORT$, 
                                      SSNFTNTS$,
                                      SSNFTNTS$,
                                      SSNEXEC$, 
                                      SSNEXEC$, 
                                      SSNEXEC$, 
                                      SSNBATCH$,
                                      SSNBATCH$,
                                               0];
        END 
  
      CONTROL EJECT;
PROC PVALID(PBUFF, PBSIZE); 
# TITLE PVALID - PARAMETER VALUE VALIDATION.                           #
  
      BEGIN                            # PVALID                        #
  
# 
**    PVALID - PARAMETER VALUE VALIDATION.
* 
*     THIS EMBEDDED PROCEDURE VALIDATES THE VALUE OF A GIVEN PARAMETER. 
*     UPON SUCCESSFUL VALIDATION, *PVALUE* CONTAINS THE CORRESPONDING 
*     NUMERICAL OR DISPLAY CODE VALUE OF THE PARAMETER. 
*     IF VALIDATION FAILS, *PERR* IS SET TO TRUE. 
* 
*     ENTRY PAR$VALUE[I]= CURRENT PARAMETER 
*           PBUFF       = BUFFER CONTAINING A LIST OF VALID MNEMONICS 
*                         AND THE CORRESPONDING NUMERICAL/DISPLAY CODE
*                         VALUES OF THE GIVEN PARAMETER.
*                         FORMAT OF THIS BUFFER:  
*                              TWO WORDS PER ENTRY. 
*                              WORD 0 = MNEMONIC, LEFT JUSTIFIED ZERO 
*                                       FILLED. 
*                              WORD 1 = NUMERICAL/DISPLAY-CODE VALUE, 
*                                       RIGHT JUSTIFIED ZERO FILLED.
*           PBSIZE      = NUMBER OF ENTRIES IN *PBUFF* PLUS ONE, THE
*                         LAST ENTRY IS USED TO STORE THE CURRENT 
*                         PARAMETER FOR EASE OF *PBUFF* SEARCHING.
*     EXIT PVALUE       = NUMERICAL/DISPLAY-CODE VALUE OF THE GIVEN 
*                         PARAMETER UPON SUCCESSFUL VALIDATION, ELSE
*                         IT IS UNDEFINED.
*          PERR         = FALSE, UPON SUCCESSFUL VALIDATION.
*                         TRUE, UPON UNSUCCESSFUL VALIDATION. 
* 
*     METHOD INITIALIZE *PERR* TO FALSE.
*            PLACE GIVEN PARAMETER IN LAST ENTRY IN *PBUFF*.
*            LOOP THROUGH *PBUFF* UNTIL A MATCH IS FOUND. 
*            UPON EXIT FROM LOOP. 
*            IF LOOP INDEX EQ *PSIZE*  (NO MATCH) 
*              SET *PERR* TO TRUE.
*            ELSE (MATCH FOUND) 
*              *PVALUE* = VALUE IN FOUND ENTRY. 
* 
# 
  
      ARRAY PBUFF[00:00] S(2);
        BEGIN 
        ITEM PBF$PMNIC  U(00,00,60);   # PARAMETER MNEMONICS           #
        ITEM PBF$PVALUE U(01,00,60);   # PARAMETER VALUE               #
        ITEM PBF$PVALUC C(01,48,02);   # PARAMETER VALUE AS 2 CHARS    #
        END 
  
      ITEM PBSIZE     U;               # SIZE OF *PBUFF*               #
      ITEM STARTINDEX I;
      ITEM II         U;               # LOOP INDUCTION VARIABLE       #
  
  
      CONTROL EJECT;
# 
**    START OF EMBEDDED PROCEDURE - *PVALID*
* 
# 
  
      PERR = FALSE;                     # INIT TO SUCCESSFUL VALIDATION#
  
  
      PBF$PMNIC[PBSIZE]= PAR$VALUE[I];  # STORE PARAMETER IN BUFFER... #
                                        # ...TO GUARANTEE A MATCH.     #
  
      FOR II = 0 STEP 1 WHILE 
            (II LQ PBSIZE)
        AND (PAR$VALUE[I] NQ PBF$PMNIC[II]) 
      DO
        BEGIN                          # LOOP THRU BUFFER TIL MATCH    #
        END 
  
      IF II EQ PBSIZE 
      THEN
        BEGIN 
        PERR = TRUE;                   # UNSUCCESSFUL VALIDATION       #
        END 
      ELSE
        BEGIN 
        PVALUE = PBF$PVALUE[II];       # GET VALUE OF PARAMETER        #
        PVALUC = PBF$PVALUC[II];       # GET VALUE OF PARAMETER        #
        END 
  
      RETURN; 
  
      END                              # PVALID                        #
  
  
  
      CONTROL EJECT;
# 
**    START MAIN PROCEDURE. 
# 
      FFSUPCP  = TRUE;                      # PRESET TO VALID PARAMETER#
  
      FFSUCLR(LOC(MBT$WORD[0]), FETSIZ$);   # CLEAR MBT FET            #
  
      MBT$COMPB[0] = TRUE;                  # SET COMPLETION BIT       #
      MBT$LFN[0]   = C<0,7>PAR$VALUEN[1];   # LFN FROM PARAMETER LIST  #
      MBT$PFN[0]   = C<0,7>PAR$VALUEN[1];   # PFN = LFN                #
      MBT$UP[0]    = TRUE;                  # SET USER PROCESSING BIT  #
      MBT$EP[0]    = TRUE;                  # SET ERROR PROCESSING BIT #
      MBT$LEN[0]   = FETSIZ$ - 5;           # SET FET SIZE - 5 WORDS   #
      MBT$FIRST[0] = LOC(CIO$WORD[0]);      # SET FIRST ADDRESS        #
      MBT$IN[0]    = MBT$FIRST[0];          # SET IN = FIRST           #
      MBT$OUT[0]   = MBT$FIRST[0];          # SET OUT = FIRST          #
      MBT$LIMIT[0] = MBT$FIRST[0]+FBUFSIZ$; # SET LIMIT = FIRST+BUFFER #
      IF READMODE 
      THEN
        BEGIN 
        MBT$M[0] = MNR$;               # PRESET MODE TO READ           #
        END 
  
      SITECS = DFLTCS;                 # PRESET CODE SET TO DEFAULT    #
      SITEFT = DFLTFT;                 # PRESET FILE TYPE TO DEFAULT   #
      SITEFSC = 0;                     # FILE SKIP COUNT TO ZERO       #
      SITETRUNC = FALSE;               # DEFAULT NO TRUNCATION         #
      SITERDEOI = FALSE;               # DEFAULT NO READEOI            #
  
# 
**    LOOP THROUGH ALL PARAMETERS IN PARAMETER LIST, OR 
*     WHEN ERROR IS ENCOUNTERED.
*     NOTE:  1) XD AND XT ARE MUTUALLY EXCLUSIVE. 
*            2) DA AND IA ARE MUTUALLY EXCLUSIVE. 
*            3) CE AND CP ARE MUTUALLY EXCLUSIVE. 
# 
  
      EXPRCD = FALSE;                  # PRESET TO EXPIRATION NOT PROCD#
      FTPRCD = FALSE;                  # PRESET TO FILE TYPE NOT PROCD #
      SRPRCD = FALSE;                  # PRESET TO SPECIAL REQ NOT PROC#
      PERR   = FALSE;                  # PRESET TO NO PARAMETER ERROR  #
  
      FOR I = 2 STEP 1 WHILE I LQ PARA$NUM[0] 
                        AND (NOT PERR)
      DO
        BEGIN 
# 
************************************************************************
*                                                                      *
*     THE FOLLOWING ARE NOS PERMANENT FILE PARAMETERS                  *
*                                                                      *
************************************************************************
# 
  
        IF PAR$NAME[I] EQ AC$0
        THEN
          BEGIN                        # AC = ALTERNATE CATLIST        #
          PVALID(ACPV[0], ACMAX$);     # VALIDATE PARAMETER VALUE      #
          IF NOT PERR 
          THEN
            BEGIN 
            MBT$AC[0] = PVALUE;        # SAVE PARAMETER VALUE IN FET   #
            END 
          END 
  
        IF PAR$NAME[I] EQ AL$0
        THEN
          BEGIN                        # AL = ACCESS LEVEL             #
          PVALID(ALPV[0], ALMAX$);     # VALIDATE PARAMETER VALUE      #
          IF NOT PERR 
          THEN
            BEGIN 
            MBT$AL[0] = PVALUE;        # SAVE PARAMETER VALUE IN FET   #
            MBT$A[0]  = TRUE; 
            END 
          END 
  
        IF PAR$NAME[I] EQ BR$0
        THEN
          BEGIN                        # BR = BACKUP REQUIREMENT       #
          PVALID(BRPV[0], BRMAX$);     # VALIDATE PARAMETER VALUE      #
          IF NOT PERR 
          THEN
            BEGIN 
            MBT$BR[0] = PVALUE;        # SAVE PARAMETER VALUE IN FET   #
            END 
          END 
  
        IF PAR$NAME[I] EQ CE$0
        THEN
          BEGIN                        # CE = CLEAR ERROR CODE         #
          IF SRPRCD 
          THEN
            BEGIN                      # SEMANTIC ERROR                #
            PERR = TRUE;
            END 
          ELSE
            BEGIN 
            SRPRCD    = TRUE;          # SET SPECIAL REQUEST PROCESSED #
            MBT$SR[0] = SRCE$;         # SAVE CE IN FET                #
            END 
          END 
  
        IF PAR$NAME[I] EQ CP$0
        THEN
          BEGIN                        # CP = RESET CHARGE/PROJECT NO  #
          IF SRPRCD 
          THEN
            BEGIN                      # SEMANTIC ERROR                #
            PERR = TRUE;
            END 
          ELSE
            BEGIN 
            SRPRCD    = TRUE;          # SET SPECIAL REQUEST PROCESSED #
            MBT$SR[0] = SRCP$;         # SAVE CP IN FET                #
            END 
          END 
  
        IF PAR$NAME[I] EQ CT$0
        THEN
          BEGIN                        # CT = CATEGORY                 #
          PVALID(CTPV[0], CTMAX$);     # VALIDATE PARAMETER VALUE      #
          IF NOT PERR 
          THEN
            BEGIN 
            MBT$CT[0] = PVALUE;        # SAVE PARAMETER VALUE IN FET   #
            END 
          END 
  
        IF PAR$NAME[I] EQ DN$0
        THEN
          BEGIN                             # DN = DEVICE NUMBER       #
          RETSTATUS = XDXB(PAR$VALUE[I],    # CONVERT VALUE FROM..     #
                      1, DNBIN);            #..DISPLAY CODE TO BINARY. #
  
          IF     (DNBIN GQ 1) 
             AND (DNBIN LQ PFMFETMDN) 
          THEN
            BEGIN                           # DN WITHIN RANGE          #
            MBT$DN[0] = DNBIN;
            END 
          ELSE
            BEGIN 
            PERR = TRUE;
            END 
          END 
  
        IF PAR$NAME[I] EQ FN$0
        THEN
          BEGIN                        # FN = FILE-NAME                #
          MBT$PFN[0] = PAR$VALUE[I];   # SAVE PFN                      #
          END 
  
        IF PAR$NAME[I] EQ M$0 
        THEN
          BEGIN                        # M = MODE                      #
          PVALID(MPV[0], MMAX$);       # VALIDATE PARAMETER VALUE      #
          IF NOT PERR 
          THEN
            BEGIN 
            MBT$M[0] = PVALUE;         # SAVE PARAMETER VALUE IN FET   #
            END 
          END 
  
        IF PAR$NAME[I] EQ PN$0
        THEN
          BEGIN                        # PN = PACK NAME                #
          MBT$PN[0] = PAR$VALUE[I];    # SAVE PACK NAME                #
          END 
  
        IF PAR$NAME[I] EQ PR$0
        THEN
          BEGIN                        # PR = PREFERRED RESIDENCY      #
          PVALID(PRFPV[0], PRMAX$);    # VALIDATE PARAMETER VALUE      #
          IF NOT PERR 
          THEN
            BEGIN 
            MBT$PR[0] = PVALUE;        # SAVE PARAMETER VALUE IN FET   #
            END 
          END 
  
        IF PAR$NAME[I] EQ PW$0
        THEN
          BEGIN                        # PW = PASSWORD                 #
          MBT$PW[0] = PAR$VALUE[I] ;   # SAVE PARAMETER VALUE IN FET   #
          END 
  
        IF PAR$NAME[I] EQ R$0 
        THEN
          BEGIN                        # R = DEVICE TYPE               #
          PVALID(RPV[0], RMAX$);       # VALIDATE PARAMETER VALUE      #
          IF NOT PERR 
          THEN
            BEGIN 
            MBT$DT[0] = PVALUC;        # SAVE PARAMETER VALUE IN FET   #
            END 
          END 
  
        IF PAR$NAME[I] EQ S$0 
        THEN
          BEGIN                          # S = NUMBER OF PRUS          #
          RETSTATUS = XDXB(PAR$VALUE[I], # CONVERT FROM DISPLAY CODE.. #
                           1, SBIN);     #..TO BINARY.                 #
          MBT$S[0] = SBIN;
          END 
  
        IF PAR$NAME[I] EQ SS$0
        THEN
          BEGIN                        # SS = SUBSYSTEM                #
          PVALID(SSPV[0], SSMAX$);     # VALIDATE PARAMETER VALUE      #
          IF NOT PERR 
          THEN
            BEGIN 
            MBT$SS[0] = PVALUE;        # SAVE PARAMETER VALUE IN FET   #
            END 
          END 
  
        IF PAR$NAME[I] EQ UN$0
        THEN
          BEGIN                        # UN = USER NAME                #
          MBT$UN[0] = PAR$VALUE[I] ;   # SAVE USER NAME                #
          END 
  
        IF PAR$NAME[I] EQ XD$0
        THEN
          BEGIN                        # XD = EXPIRATION DATE          #
          IF EXPRCD 
          THEN
            BEGIN                      # SEMANTIC ERROR                #
            PERR = TRUE;
            END 
          ELSE
            BEGIN 
            DATEVAL(PAR$VALUE[I],DATEBIN,  # VALIDATE AND CONVERT DATE #
                    RETSTATUS); 
            IF RETSTATUS EQ PFMFETXDOK
            THEN
              BEGIN                        # EXPIRATION DATE O.K.      #
              EXPRCD    = TRUE;            # EXPIRATION DATE PROCESSED #
              MBT$XT[0] = DATEBIN;         # STORE BINARY DATE IN FET  #
              END 
            ELSE
              BEGIN 
              PERR = TRUE;                 # ERROR ENCOUNTERED         #
              END 
            END 
          END 
  
        IF PAR$NAME[I] EQ XT$0
        THEN
          BEGIN                        # XT = EXPIRATION TERM          #
          IF EXPRCD 
          THEN
            BEGIN                      # SEMANTIC ERROR                #
            PERR = TRUE;
            END 
          ELSE
            BEGIN 
            IF PAR$VALUE[I] EQ PFMFETMXTS 
            THEN
              BEGIN                    # VALUE IS A MAX TERM SYMBOL    #
              EXPRCD = TRUE;           # EXPIRATION TERM PROCESSED     #
              MBT$XT[0] = PFMFETMXT;
              END 
  
            ELSE                              # VALUE IS NUMERIC       #
              BEGIN 
              RETSTATUS = XDXB(PAR$VALUE[I],  # CONVERT FROM DC TO BIN #
                               1, XTERMBIN);
  
              IF XTERMBIN EQ PFMFETCD 
              THEN
                BEGIN                         # VALUE IS CURRENT DATE  #
                PDATE(DATETIME);              #GET CURRENT DATE W/ TIME#
                DATE$DATE = B<PFMFETDFB, PFMFETDLEN>DATETIME; 
                EXPRCD = TRUE;                # EXPIRATION TERM PROCESS#
                MBT$XT[0] = DATE$DATE;        # SAVE BINARY DATE IN FET#
                END 
  
              ELSE IF XTERMBIN LQ PFMFETMXT 
              THEN
                BEGIN                         # EXPIRATN TERM W/I RANGE#
                EXPRCD = TRUE;
                MBT$XT[0] = XTERMBIN; 
                END 
              ELSE
                BEGIN 
                PERR = TRUE;
                END 
              END 
            END 
          END                          # XT                            #
# 
************************************************************************
*                                                                      *
*     THE FOLLOWING ARE DATA-HANDLING PARAMETERS                       *
*                                                                      *
************************************************************************
# 
  
        IF PAR$NAME[I] EQ CS$0
        THEN
          BEGIN                        # CS = CODE SET                 #
          IF   (PAR$VALUEN[I] EQ A$0) 
            OR (PAR$VALUEN[I] EQ ASCII$0) 
          THEN
            BEGIN                      # CS = 6/12 ASCII               #
            SITECS = 0; 
            C<0, 1>SITECS = CSA;
            END 
  
          IF   (PAR$VALUEN[I] EQ ASCII8$0)
            OR (PAR$VALUEN[I] EQ CHAR$8$0)
          THEN
            BEGIN                      # CS = 8/12 ASCII, ZB TERM      #
            SITECS = 0; 
            C<0, 1>SITECS = CS8;
            END 
  
          IF   (PAR$VALUEN[I] EQ ASCII8E$0) 
            OR (PAR$VALUEN[I] EQ CHAR$8E$0) 
          THEN
            BEGIN                      # CS = 8/12 ASCII, EOLN TERM    #
            SITECS = 0; 
            C<0, 2>SITECS = CS8E; 
            END 
  
          IF   (PAR$VALUEN[I] EQ ASCII88$0) 
            OR (PAR$VALUEN[I] EQ CHAR$88$0) 
          THEN
            BEGIN                      # CS = 8/8 ASCII                #
            SITECS = 0; 
            C<0, 2>SITECS = CS88; 
            END 
  
          IF   (PAR$VALUEN[I] EQ D$0) 
            OR (PAR$VALUEN[I] EQ DIS$0) 
          THEN
            BEGIN                      # CS = 6/6 DISPLAY CODE         #
            SITECS = 0; 
            C<0, 1>SITECS = CSD;
            END 
  
          END                          # CS = CODE SET                 #
  
        IF PAR$NAME[I] EQ FSC$0 
        THEN
          BEGIN                        # FSC = FILE SKIP COUNT         #
          RETSTATUS = XDXB(PAR$VALUE[I], 1, # CONVERT FROM DC TO BINARY#
                          FSCBIN);
          SITEFSC = FSCBIN; 
          END 
  
        IF PAR$NAME[I] EQ READEOI$0 
        THEN
          BEGIN                        # READ TO END OF INFORMATION    #
          SITERDEOI = TRUE; 
          END 
  
        IF PAR$NAME[I] EQ TRUNC$0 
        THEN
          BEGIN                        # TRUNC                         #
          SITETRUNC = TRUE; 
          END 
  
  
        IF   (PAR$NAME[I] EQ DA$0)
          OR (PAR$NAME[I] EQ IA$0)
        THEN
          BEGIN                        # FILE TYPE IS DIRECT/INDIRECT  #
          IF FTPRCD 
          THEN
            BEGIN                      # SEMANTIC ERROR                #
            PERR = TRUE;
            END 
          ELSE
            BEGIN 
            FTPRCD = TRUE;             # SET FILE TYPE PROCESSED       #
            SITEFT = PAR$NAME[I];      # SAVE FILE TYPE                #
            END 
          END 
  
        END                            # FOR I LOOP                    #
  
# 
*     ERROR ENCOUNTERED.
*     SET *FFSUPCP* = FALSE.
# 
      IF PERR 
      THEN
        BEGIN 
        FFSUPCP            = FALSE; 
        END 
  
      RETURN; 
  
      END                              # FFSUPCP                       #
  
      TERM
