*DECK FFSIBCT 
USETEXT TEXTFFS 
      PROC FFSIBCT; 
*CALL COPYRITE
                                                                       #
*     CDCNET - COPYRIGHT CONTROL DATA SYSTEMS INC. 1994.
                                                                       #
# TITLE FFSIBCT - BUILD COMMAND TABLES.                                #
  
      BEGIN   # FFSIBCT                                                #
# 
**    FFSIBCT - BUILD COMMAND TABLES. 
* 
*     TET TRAN                         88/01 29 
* 
*     THIS PROCEDURE BUILDS THE COMMAND AND PARAMETER DESCRIPTOR TABLES.
* 
*     PROC FFSIBCT
* 
*     ENTRY   NONE. 
* 
*     EXIT    COMMAND AND PARAMETER DESCRIPTOR/NAME TABLES BUILT. 
* 
*     NOTES 
* 
*     THREE INTERNAL PROCEDURES ARE USED TO AID THE INITIALIZING
*     OF THE TABLES.  THE TABLES ARE DEFINED IN COMMON BLOCK
*     *COMMAND* IN *TEXTFFS*. 
* 
*     1. FFS2ILT - INITIALIZING LIST ELEMENT TABLE
*          FFS2IPT IS CALLED TO DEFINE A LIST ELEMENT. THIS PROC
*          IS USED TO BUILD THE LET (LIST ELEMENT TABLE). A LIST IS 
*          A SET OF KNOWN VALUES.  EG. CS PARAMETER ONLY ACCEPTS
*          VALUES FROM LIST (DIS, D, ASCII, A, ASCII8, 8,...) 
* 
*          FFS2IPT (ELEMENT)
*            . ELEMENT  - THE LIST ELEMENT THIS PARAMETER ALLOWS. 
* 
*     2. FFS2ICT - INITIALIZING COMMAND (DISCRIPTOR) TABLE
*          FFS2ICT IS CALLED TO DEFINE A COMMAND. 
*          FFS2ICT (CNANE,CNUM,SPPT,NOSPF)
*            . CNAME    - THE COMMAND NAME (ZERO FILLED). 
*            . CNUM     - AN INTEGER UNIQUELY ASSIGNED TO THIS COMMAND. 
*            . SPPT     - TRUE IF THIS COMMAND IS CURRENTLY SUPPORTED.
*            . NOSPF    - TRUE IF THIS COMMAND INVOLVES NOS PERMANENT 
*                         FILE, EG. STOR, APPE, RETR,...
* 
*     3. FFS2IPT - INITIALIZING PARAMETER (DISCRIPTOR) TABLE
*          FFS2IPT IS CALLED TO DEFINE A PARAMETER.  IT IS CALLED 
*            AFTER EACH COMMAND TO DEFINE THE PARAMETERS THIS COMMAND 
*            ALLOWS.
*          FFS2IPT (PNAME,TYPE,PSONLY,REQD) 
*            . PNAME    - THE PARAMETER NAME (ZERO FILLED). 
*                         EG. *UN* IN *UN=XXXX*, *CT* IN *CT=PU*. 
*                         BINARY ZERO MUST BE SUPPIED FOR THIS FIELD
*                         IN CALLS FOR POSITIONAL PARAMETERS. 
*            . TYPE     - TYPE OF THIS PARAMETER, ONE OF THE PRE- 
*                         DEFINED TYPES IN TEXTFFS. 
*            . REQD     - TRUE INDICATES PARAMETER IS REQUIRED FOR
*                         THE PRECEDING COMMAND.
*            . LPTR     - USED ONLY FOR PARAMETERS OF TYPE LIST.
*                         INDEX OF THE FIRST ELEMENT OF THIS LIST.
*            . LSIZ     - USED ONLY FOR PARAMETERS OF TYPE LIST.
*                         NUMBER OF ELEMENT OF IN THIS LIST.
* 
*     METHOD
* 
*     1. FIRST, BUILT THE LET (LIST ELEMENT TABLE) FOR ALL APPLICABLE 
*        LISTS, AND RECORD THE BEGIN INDEX OF EACH LIST. A LIST IS A SET
*        OF KNOWN VALUES, EG. THE NOS AL PARAMETER ASSUMES A VALUE FROM 
*        LIST (LVL0, LVL1, LVL2, LVL3, LVL4, LVL5, LVL6, LVL7). 
* 
*     2. FFS2ICT IS CALLED ONE FOR EACH FTP COMMAND.
* 
*     3. IF THE COMMAND TAKES PARAMETER(S), FFS2IPT WILL BE CALLED, ONCE
*        PER PARAMETER, IMMEDIATELY AFTER THE FFS2ICT CALL. 
* 
# 
  
# 
****  PROC FFSIBCT - XREF LIST
# 
      XREF
        BEGIN 
        END 
# 
****
# 
  
# 
*     LOCAL DEFS AND VARIABLES
# 
      DEF AC$LEN          #02#;    #NO. OF ACCEPTABLE VALUES FOR AC    #
      DEF AL$LEN          #08#;    #NO. OF ACCEPTABLE VALUES FOR AL    #
      DEF BR$LEN          #03#;    #NO. OF ACCEPTABLE VALUES FOR BR    #
      DEF CS$LEN          #10#;    #NO. OF ACCEPTABLE VALUES FOR CS    #
      DEF CT$LEN          #07#;    #NO. OF ACCEPTABLE VALUES FOR CT    #
      DEF LO$LEN          #05#;    #NO. OF ACCEPTABLE VALUES FOR LO    #
      DEF M$LEN           #20#;    #NO. OF ACCEPTABLE VALUES FOR M     #
      DEF MCODE$LEN       #03#;    #NO. OF ACCEPTABLE VALUES FOR MCODE #
      DEF PR$LEN          #04#;    #NO. OF ACCEPTABLE VALUES FOR PR    #
      DEF SCODE$LEN       #03#;    #NO. OF ACCEPTABLE VALUES FOR SCODE #
      DEF SS$LEN          #14#;    #NO. OF ACCEPTABLE VALUES FOR SS    #
  
      DEF SUPPORTED     #TRUE#; 
      DEF NOTSUPPTD    #FALSE#; 
      DEF REQUIRED      #TRUE#; 
      DEF NOTREQD      #FALSE#; 
      DEF NOSPF         #TRUE#; 
      DEF NOTNOSPF     #FALSE#; 
# 
*     LOCAL VARIABLE DECLARATIONS 
# 
      ITEM CDT$INDX       I;      # CURRENT INDEX INTO CDT             #
      ITEM PDT$INDX       I;      # CURRENT INDEX INTO PDT             #
      ITEM LET$INDX       I;      # CURRENT INDEX INTO LET             #
  
      ITEM AC$PTR         U;      # BEGINING INDEX TO LET FOR AC       #
      ITEM AL$PTR         U;      # BEGINING INDEX TO LET FOR AL       #
      ITEM BR$PTR         U;      # BEGINING INDEX TO LET FOR BR       #
      ITEM CS$PTR         U;      # BEGINING INDEX TO LET FOR CS       #
      ITEM CT$PTR         U;      # BEGINING INDEX TO LET FOR CT       #
      ITEM LO$PTR         U;      # BEGINING INDEX TO LET FOR LO       #
      ITEM M$PTR          U;      # BEGINING INDEX TO LET FOR M        #
      ITEM MCODE$PTR      U;      # BEGINING INDEX TO LET FOR MCODE    #
      ITEM PR$PTR         U;      # BEGINING INDEX TO LET FOR PR       #
      ITEM SCODE$PTR      U;      # BEGINING INDEX TO LET FOR SCODE    #
      ITEM SS$PTR         U;      # BEGINING INDEX TO LET FOR SS       #
  
      CONTROL EJECT;
      PROC FFS2ICT(CNAME,CNUM,SPPT,NOSPF);
      BEGIN                            # FFS2ICT                       #
# 
*     INTERNAL PROCEDURE - FFS2ICT
* 
*     THIS EMBEDDED PROCEDURE INITIALIZE AN FTP COMMAND.
# 
      ITEM CNAME   U;             # COMMAND NAME IN NUMERIC FORM       #
      ITEM CNUM    U;             # COMMAND NUMBER                     #
      ITEM SPPT    B;             # THIS COMMAND IS CURRENTLY SUPPORTED#
      ITEM NOSPF   B;             # IF COMMAND INVOLVES NOS PF PARAM   #
  
      CDT$INDX = CDT$INDX + 1;
      CDT$NAMEN[CDT$INDX] = CNAME;
      CDT$CNUM[CDT$INDX]= CNUM; 
      CDT$PPTR[CDT$INDX] = 0; 
      CDT$PSIZ[CDT$INDX] = 0; 
      CDT$SPPT[CDT$INDX] = SPPT;
      CDT$NOSPF[CDT$INDX] = NOSPF;
  
      RETURN;                          # RETURN TO CALLER              #
  
      END                              # FFS2ICT                       #
  
      CONTROL EJECT;
      PROC FFS2IPT(PNAME,TYPE,REQD,LPTR,LSIZ);
      BEGIN                            # FFS2IPT                       #
# 
*     INTERNAL PROCEDURE - FFS2IPT
* 
*     THIS EMBEDDED PROCEDURE INITIALIZE AN ENTRY IN PDT TABLE. 
* 
# 
      ITEM PNAME   U;             # PARAMETER NAME IN NUMERIC FORM     #
      ITEM TYPE    U;             # PARAMETER TYPE                     #
      ITEM REQD    B;             # IF THIS PARAMETER IS REQUIRED      #
      ITEM LPTR    U;             # POINT TO LET TABLE FOR LIST TYPE   #
      ITEM LSIZ    I;             # NUMBER OF LIST ELEMENTS FOR LIST TP#
  
      PDT$INDX = PDT$INDX + 1;
      PDT$NAMEN[PDT$INDX] = PNAME;
      PDT$TYPE[PDT$INDX]  = TYPE; 
      PDT$REQD[PDT$INDX]  = REQD; 
      PDT$LPTR[PDT$INDX]  = LPTR; 
      PDT$LSIZ[PDT$INDX]  = LSIZ; 
      IF CDT$PSIZ[CDT$INDX] EQ 0       # IF THIS IS FIRST PARAMETER FOR#
      THEN                             # THIS COMMAND,                 #
        BEGIN 
        CDT$PPTR[CDT$INDX] = PDT$INDX; # INITIALIZE THE PARA POINTER   #
        END 
      CDT$PSIZ[CDT$INDX] = CDT$PSIZ[CDT$INDX] + 1;
      RETURN;                          # RETURN TO CALLER              #
  
      END                              # FFS2IPT                       #
  
      CONTROL EJECT;
      PROC FFS2ILT(ELEMENT);
      BEGIN                            # FFS2ILT                       #
# 
*     INTERNAL PROCEDURE - FFS2ILT
* 
*     THIS EMBEDDED PROCEDURE INITILAIZES AN LIST ELEMENT TABLE ENTRY.
* 
# 
      ITEM ELEMENT U;             # LIST ELEMENT IN NUMERIC FORM       #
  
      LET$VALUEN[LET$INDX] = ELEMENT; 
      LET$INDX = LET$INDX + 1;
  
      RETURN;                          # RETURN TO CALLER              #
  
      END                              # FFS2ILT                       #
  
      CONTROL EJECT;
# 
*     START MAIN PROCEDURE, INITLIALZE LET TABLE
# 
      LET$INDX = LET$FIRST;            # POINT TO BEGINING OF LET TABLE#
  
# 
*     LIST OF ACCEPTABLE VALUES FOR NOS PFM AC PARAMETER
# 
      AC$PTR = LET$INDX;               # BEGINING INDEX FOR THIS LIST  #
        FFS2ILT (Y$0);                 #   Y - YES                     #
        FFS2ILT (N$0);                 #   N - NO                      #
  
# 
*     LIST OF ACCEPTABLE VALUES FOR NOS PFM AL PARAMETER
# 
      AL$PTR = LET$INDX;               # BEGINING INDEX FOR THIS LIST  #
        FFS2ILT (LVL0$0); 
        FFS2ILT (LVL1$0); 
        FFS2ILT (LVL2$0); 
        FFS2ILT (LVL3$0); 
        FFS2ILT (LVL4$0); 
        FFS2ILT (LVL5$0); 
        FFS2ILT (LVL6$0); 
        FFS2ILT (LVL7$0); 
  
# 
*     LIST OF ACCEPTABLE VALUES FOR NOS PFM BR PARAMETER
# 
      BR$PTR = LET$INDX;               # BEGINING INDEX FOR THIS LIST  #
        FFS2ILT (Y$0);
        FFS2ILT (MSF$0);
        FFS2ILT (N$0);
  
# 
*     LIST OF ACCEPTABLE VALUES FOR CS (CODE SET - DATA HANDLING) 
# 
      CS$PTR = LET$INDX;               # BEGINING INDEX FOR THIS LIST  #
        FFS2ILT (D$0);
        FFS2ILT (DIS$0);
        FFS2ILT (A$0);                 # STRING "A", ZERO FILLED       #
        FFS2ILT (ASCII$0);             # STRING "ASCII", ZERO FILLED   #
        FFS2ILT (ASCII8$0);            # STRING "ASCII8", ZERO FILLED  #
        FFS2ILT (ASCII8E$0);           # STRING "ASCII8E", ZERO FILLED #
        FFS2ILT (ASCII88$0);           # STRING "ASCII88", ZERO FILLED #
        FFS2ILT (CHAR$8$0);            # STRING "8", ZERO FILLED       #
        FFS2ILT (CHAR$8E$0);           # STRING "8E", ZERO FILLED      #
        FFS2ILT (CHAR$88$0);           # STRING "88", ZERO FILLED      #
  
# 
*     LIST OF ACCEPTABLE VALUES FOR NOS PFM CT PARAMETER
# 
      CT$PTR = LET$INDX;               # BEGINING INDEX FOR THIS LIST  #
        FFS2ILT (P$0);
        FFS2ILT (PR$0); 
        FFS2ILT (PRIVATE$0);
        FFS2ILT (S$0);
        FFS2ILT (SPRIV$0);
        FFS2ILT (PU$0); 
        FFS2ILT (PUBLIC$0); 
  
# 
*     LIST OF ACCEPTABLE VALUES FOR NOS PFM LO PARAMETER
# 
      LO$PTR = LET$INDX;               # BEGINING INDEX FOR THIS LIST  #
        FFS2ILT (F$0);
        FFS2ILT (FP$0); 
        FFS2ILT (CHAR$0$0);            # CHARACTER "0", ZERO FILLED    #
        FFS2ILT (P$0);
        FFS2ILT (X$0);
  
# 
*     LIST OF ACCEPTABLE VALUES FOR NOS PFM M PARAMETER 
# 
      M$PTR = LET$INDX;                # BEGINING INDEX FOR THIS LIST  #
        FFS2ILT (E$0);
        FFS2ILT (EXECUTE$0);
        FFS2ILT (R$0);
        FFS2ILT (READ$0); 
        FFS2ILT (RU$0); 
        FFS2ILT (READUP$0); 
        FFS2ILT (RA$0); 
        FFS2ILT (READAP$0); 
        FFS2ILT (RM$0); 
        FFS2ILT (READMD$0); 
        FFS2ILT (U$0);
        FFS2ILT (UPDATE$0); 
        FFS2ILT (A$0);
        FFS2ILT (APPEND$0); 
        FFS2ILT (M$0);
        FFS2ILT (MODIFY$0); 
        FFS2ILT (W$0);
        FFS2ILT (WRITE$0);
        FFS2ILT (N$0);
        FFS2ILT (NULL$0); 
  
# 
*     LIST OF ACCEPTABLE VALUES FOR M-CODE
# 
      MCODE$PTR = LET$INDX;            # BEGINING INDEX FOR THIS LIST  #
        FFS2ILT (S$0);                 #   S - STREAM                  #
        FFS2ILT (B$0);                 #   N - BLOCK                   #
        FFS2ILT (C$0);                 #   N - COMPRESS                #
  
# 
*     LIST OF ACCEPTABLE VALUES FOR NOS PFM PR PARAMETER
# 
      PR$PTR = LET$INDX;               # BEGINING INDEX FOR THIS LIST  #
        FFS2ILT (D$0);
        FFS2ILT (L$0);
        FFS2ILT (M$0);
        FFS2ILT (N$0);
  
# 
*     LIST OF ACCEPTABLE VALUES FOR S-CODE
# 
      SCODE$PTR = LET$INDX;            # BEGINING INDEX FOR THIS LIST  #
        FFS2ILT (F$0);                 #   F - FILE                    #
        FFS2ILT (R$0);                 #   R - RECORD STRUCTURE        #
        FFS2ILT (P$0);                 #   P - PAGE STRUCTURE          #
  
# 
*     LIST OF ACCEPTABLE VALUES FOR NOS PFM SS PARAMETER
# 
      SS$PTR = LET$INDX;               # BEGINING INDEX FOR THIS LIST  #
        FFS2ILT (SSNUL$); 
        FFS2ILT (SSNULL$);
        FFS2ILT (SSBAS$); 
        FFS2ILT (SSBASIC$); 
        FFS2ILT (SSFOR$); 
        FFS2ILT (SSFORT$);
        FFS2ILT (SSFORTRAN$); 
        FFS2ILT (SSFTN$); 
        FFS2ILT (SSFTNTS$); 
        FFS2ILT (SSEXE$); 
        FFS2ILT (SSEXEC$);
        FFS2ILT (SSEXECUTE$); 
        FFS2ILT (SSBAT$); 
        FFS2ILT (SSBATCH$); 
  
# 
*     INITIALIZE CDT AND PDT TABLES 
# 
  
      CDT$INDX  = CDT$FIRST-1;
      PDT$INDX  = PDT$FIRST-1;
  
# 
*     ABOR
# 
      FFS2ICT (ABOR,ABOR$CMD,SUPPORTED,NOTNOSPF); 
  
# 
*     ACCT [SP] [CHARGENUM,PROJECTNUM]
# 
      FFS2ICT (ACCT,ACCT$CMD,SUPPORTED,NOTNOSPF); 
        FFS2IPT (NONAME,ALNUMAS10,REQUIRED, 0, 0 );     # CHARGENUM    #
        FFS2IPT (NONAME,ALNUMAS20,REQUIRED, 0, 0 );     # PROJECTNUM   #
  
# 
*     ALLO
# 
      FFS2ICT (ALLO,ALLO$CMD,SUPPORTED,NOTNOSPF); 
        FFS2IPT (NONAME,NUM10,REQUIRED,0,0);
  
# 
*     APPE [SP] [PF-PARAMETERS] [,DATA-HANDLING]
# 
      FFS2ICT (APPE,APPE$CMD,SUPPORTED,NOSPF);
        FFS2IPT ( 0 ,ALNUM07,REQUIRED, 0, 0 );         # FILE NAME     #
        FFS2IPT (AC$0,LISTTYPE,NOTREQD,AC$PTR,AC$LEN);
        FFS2IPT (AL$0,LISTTYPE,NOTREQD,AL$PTR,AL$LEN);
        FFS2IPT (BR$0,LISTTYPE,NOTREQD,BR$PTR,BR$LEN);
        FFS2IPT (CT$0,LISTTYPE,NOTREQD,CT$PTR,CT$LEN);
        FFS2IPT (M$0 ,LISTTYPE,NOTREQD, M$PTR, M$LEN);
        FFS2IPT (PN$0,ALNUM07 ,NOTREQD, 0, 0 ); 
        FFS2IPT (PR$0,LISTTYPE,NOTREQD,PR$PTR,PR$LEN);
        FFS2IPT (PW$0,ALNUM07 ,NOTREQD, 0, 0 ); 
        FFS2IPT (R$0 ,ALNUM03 ,NOTREQD, 0, 0 ); 
        FFS2IPT (S$0 ,ALNUM07 ,NOTREQD, 0, 0 ); 
        FFS2IPT (SS$0,LISTTYPE,NOTREQD,SS$PTR,SS$LEN);
        FFS2IPT (UN$0,ALNUM07 ,NOTREQD, 0, 0 ); 
        FFS2IPT (XD$0,NUM06   ,NOTREQD, 0, 0 ); 
        FFS2IPT (XT$0,NUMAS04 ,NOTREQD, 0, 0 ); 
        FFS2IPT (DA$0,KEYWORD ,NOTREQD, 0, 0 ); 
        FFS2IPT (IA$0,KEYWORD ,NOTREQD, 0, 0 ); 
        FFS2IPT (CS$0,LISTTYPE,NOTREQD,CS$PTR,CS$LEN);
        FFS2IPT (TRUNC$0,KEYWORD,NOTREQD, 0, 0 ); 
  
  
# 
*     CDUP - NOT SUPPORTED
# 
      FFS2ICT (CDUP,CDUP$CMD,NOTSUPPTD,NOTNOSPF); 
  
  
# 
*     CWD  - NOT SUPPORTED
# 
      FFS2ICT (CWD,CWD$CMD,NOTSUPPTD,NOTNOSPF); 
  
  
  
# 
*     DELE [SP] [PURGE-PARAMETERS]
# 
      FFS2ICT (DELE,DELE$CMD,SUPPORTED,NOSPF);
        FFS2IPT (NONAME,ALNUM07,REQUIRED, 0, 0 );     # FILE NAME      #
        FFS2IPT (PN$0,ALNUM07 ,NOTREQD, 0, 0 ); 
        FFS2IPT (PW$0,ALNUM07 ,NOTREQD, 0, 0 ); 
        FFS2IPT (R$0 ,ALNUM03 ,NOTREQD, 0, 0 ); 
        FFS2IPT (UN$0,ALNUM07 ,NOTREQD, 0, 0 ); 
  
  
# 
*     HELP [SP] [KEYWORD] 
# 
      FFS2ICT (HELP,HELP$CMD,SUPPORTED,NOTNOSPF); 
        FFS2IPT (NONAME,ALPHA04,NOTREQD, 0, 0 );          # STRING     #
  
  
# 
*     LIST [SP] [CATLIST-PARAMETERS]
# 
      FFS2ICT (LIST,LIST$CMD,SUPPORTED,NOSPF);
        FFS2IPT (DN$0,NUM02,NOTREQD, 0, 0 );
        FFS2IPT (FN$0,ALNUMAS07,NOTREQD, 0, 0 );
        FFS2IPT (PN$0,ALNUM07 ,NOTREQD, 0, 0 ); 
        FFS2IPT (R$0 ,ALNUM03 ,NOTREQD, 0, 0 ); 
        FFS2IPT (UN$0,ALNUM07 ,NOTREQD, 0, 0 ); 
  
  
# 
*     MODE [SP] S/B/C 
# 
      FFS2ICT (MODE,MODE$CMD,SUPPORTED,NOTNOSPF); 
        FFS2IPT ( 0 ,LISTTYPE,REQUIRED,MCODE$PTR,MCODE$LEN);
  
  
# 
*     MKD  - NOT SUPPORTED
# 
      FFS2ICT (MKD,MKD$CMD,NOTSUPPTD,NOTNOSPF); 
  
  
# 
*     NLST [SP] [CATLIST-PARAMETERS]
# 
      FFS2ICT (NLST,NLST$CMD,SUPPORTED,NOSPF);
        FFS2IPT (DN$0,NUM02,NOTREQD, 0, 0 );
        FFS2IPT (FN$0,ALNUMAS07,NOTREQD, 0, 0 );
        FFS2IPT (PN$0,ALNUM07 ,NOTREQD, 0, 0 ); 
        FFS2IPT (R$0 ,ALNUM03 ,NOTREQD, 0, 0 ); 
        FFS2IPT (UN$0,ALNUM07 ,NOTREQD, 0, 0 ); 
  
  
# 
*     NOOP
# 
      FFS2ICT (NOOP,NOOP$CMD,SUPPORTED,NOTNOSPF); 
  
  
# 
*     PASS [SP] [PASSWORD] [,FAMILY]
# 
      FFS2ICT (PASS,PASS$CMD,SUPPORTED,NOTNOSPF); 
        FFS2IPT ( 0 ,ALNUM07, REQUIRED, 0 , 0 );           # PASSWORD # 
        FFS2IPT ( 0 ,ALNUM07, NOTREQD,  0 , 0 );           # FAMILY   # 
  
# 
*     PASV
# 
      FFS2ICT (PASV,PASV$CMD,SUPPORTED,NOTNOSPF); 
  
  
# 
*     PORT [SP] [HOST-PORT] 
# 
      FFS2ICT (PORT,PORT$CMD,SUPPORTED,NOTNOSPF); 
        FFS2IPT (0 ,NUM03, REQUIRED, 0, 0 );
        FFS2IPT (0 ,NUM03, REQUIRED, 0, 0 );
        FFS2IPT (0 ,NUM03, REQUIRED, 0, 0 );
        FFS2IPT (0 ,NUM03, REQUIRED, 0, 0 );
        FFS2IPT (0 ,NUM03, REQUIRED, 0, 0 );
        FFS2IPT (0 ,NUM03, REQUIRED, 0, 0 );
  
  
# 
*     PWD  - NOT SUPPORTED
# 
      FFS2ICT (PWD,PWD$CMD,NOTSUPPTD,NOTNOSPF); 
  
  
# 
*     QUIT
# 
      FFS2ICT (QUIT,QUIT$CMD,SUPPORTED,NOTNOSPF); 
  
  
# 
*     REIN - NOT SUPPORTED
# 
      FFS2ICT (REIN,REIN$CMD,NOTSUPPTD,NOTNOSPF); 
  
  
# 
*     REST - NOT SUPPORTED
# 
      FFS2ICT (REST,REST$CMD,NOTSUPPTD,NOTNOSPF); 
  
  
# 
*     RETR [SP] [PF-PARAMETERS] [,DATA-HANDLING]
# 
      FFS2ICT (RETR,RETR$CMD,SUPPORTED,NOSPF);
        FFS2IPT ( 0 ,ALNUM07,REQUIRED, 0, 0 );         # FILE NAME     #
        FFS2IPT (PN$0,ALNUM07 ,NOTREQD, 0, 0 ); 
        FFS2IPT (PW$0,ALNUM07 ,NOTREQD, 0, 0 ); 
        FFS2IPT (R$0 ,ALNUM03 ,NOTREQD, 0, 0 ); 
        FFS2IPT (UN$0,ALNUM07 ,NOTREQD, 0, 0 ); 
        FFS2IPT (FSC$0,NUM07  ,NOTREQD, 0, 0 ); 
        FFS2IPT (READEOI$0,KEYWORD,NOTREQD, 0, 0 ); 
        FFS2IPT (CS$0,LISTTYPE,NOTREQD,CS$PTR,CS$LEN);
  
  
# 
*     RMD  - NOT SUPPORTED
# 
      FFS2ICT (RMD,RMD$CMD,NOTSUPPTD,NOTNOSPF); 
  
  
# 
*     RNFR [SP] [CHANGE-PARAMETERS] 
# 
      FFS2ICT (RNFR,RNFR$CMD,SUPPORTED,NOSPF);
        FFS2IPT ( 0 ,ALNUM07,REQUIRED, 0, 0 );         # FILE NAME     #
  
  
# 
*     RNTO [SP] [CHANGE-PARAMETERS] 
# 
      FFS2ICT (RNTO,RNTO$CMD,SUPPORTED,NOSPF);
        FFS2IPT ( 0 ,ALNUM07,REQUIRED, 0, 0 );         # FILE NAME     #
        FFS2IPT (AC$0,LISTTYPE,NOTREQD,AC$PTR,AC$LEN);
        FFS2IPT (BR$0,LISTTYPE,NOTREQD,BR$PTR,BR$LEN);
        FFS2IPT (CT$0,LISTTYPE,NOTREQD,CT$PTR,CT$LEN);
        FFS2IPT (M$0 ,LISTTYPE,NOTREQD, M$PTR, M$LEN);
        FFS2IPT (PN$0,ALNUM07 ,NOTREQD, 0, 0 ); 
        FFS2IPT (PR$0,LISTTYPE,NOTREQD,PR$PTR,PR$LEN);
        FFS2IPT (PW$0,ALNUM07 ,NOTREQD, 0, 0 ); 
        FFS2IPT (R$0 ,ALNUM03 ,NOTREQD, 0, 0 ); 
        FFS2IPT (SS$0,LISTTYPE,NOTREQD,SS$PTR,SS$LEN);
        FFS2IPT (XD$0,NUM06   ,NOTREQD, 0, 0 ); 
        FFS2IPT (XT$0,NUMAS04 ,NOTREQD, 0, 0 ); 
        FFS2IPT (CP$0,KEYWORD ,NOTREQD, 0, 0 ); 
        FFS2IPT (CE$0,KEYWORD ,NOTREQD, 0, 0 ); 
  
  
# 
*     SITE [SP] [CS=CS] [,DA OR IA] 
# 
      FFS2ICT (SITE,SITE$CMD,SUPPORTED,NOSPF);
        FFS2IPT (CS$0,LISTTYPE,NOTREQD,CS$PTR,CS$LEN);
        FFS2IPT (DA$0,KEYWORD ,NOTREQD, 0, 0 ); 
        FFS2IPT (IA$0,KEYWORD ,NOTREQD, 0, 0 ); 
  
  
# 
*     SMNT - NOT SUPPORTED
# 
      FFS2ICT (SMNT,SMNT$CMD,NOTSUPPTD,NOTNOSPF); 
  
  
# 
*     STAT - NOT SUPPORTED
# 
      FFS2ICT (STAT,STAT$CMD,NOTSUPPTD,NOTNOSPF); 
  
  
# 
*     STOR [SP] [PF-PARAMETERS] [,DATA-HANDLING]
# 
      FFS2ICT (STOR,STOR$CMD,SUPPORTED,NOSPF);
        FFS2IPT ( 0 ,ALNUM07,REQUIRED, 0, 0 );         # FILE NAME     #
        FFS2IPT (AC$0,LISTTYPE,NOTREQD,AC$PTR,AC$LEN);
        FFS2IPT (AL$0,LISTTYPE,NOTREQD,AL$PTR,AL$LEN);
        FFS2IPT (BR$0,LISTTYPE,NOTREQD,BR$PTR,BR$LEN);
        FFS2IPT (CT$0,LISTTYPE,NOTREQD,CT$PTR,CT$LEN);
        FFS2IPT (M$0 ,LISTTYPE,NOTREQD, M$PTR, M$LEN);
        FFS2IPT (PN$0,ALNUM07 ,NOTREQD, 0, 0 ); 
        FFS2IPT (PR$0,LISTTYPE,NOTREQD,PR$PTR,PR$LEN);
        FFS2IPT (PW$0,ALNUM07 ,NOTREQD, 0, 0 ); 
        FFS2IPT (R$0 ,ALNUM03 ,NOTREQD, 0, 0 ); 
        FFS2IPT (S$0 ,ALNUM07 ,NOTREQD, 0, 0 ); 
        FFS2IPT (UN$0,ALNUM07 ,NOTREQD, 0, 0 ); 
        FFS2IPT (SS$0,LISTTYPE,NOTREQD,SS$PTR,SS$LEN);
        FFS2IPT (XD$0,NUM06   ,NOTREQD, 0, 0 ); 
        FFS2IPT (XT$0,NUMAS04 ,NOTREQD, 0, 0 ); 
        FFS2IPT (DA$0,KEYWORD ,NOTREQD, 0, 0 ); 
        FFS2IPT (IA$0,KEYWORD ,NOTREQD, 0, 0 ); 
        FFS2IPT (CS$0,LISTTYPE,NOTREQD,CS$PTR,CS$LEN);
        FFS2IPT (TRUNC$0,KEYWORD,NOTREQD, 0, 0 ); 
  
  
# 
*     STOU - NOT SUPPORTED
# 
      FFS2ICT (STOU,STOU$CMD,NOTSUPPTD,NOTNOSPF); 
  
  
# 
*     STRU [SP] F/R/P 
# 
      FFS2ICT (STRU,STRU$CMD,SUPPORTED,NOSPF);
        FFS2IPT ( 0, LISTTYPE, REQUIRED, SCODE$PTR, SCODE$LEN );
  
  
# 
*     SYST  - NOT SUPPORTED 
# 
      FFS2ICT (SYST,SYST$CMD,NOTSUPPTD,NOTNOSPF); 
  
  
# 
*     TYPE [SP] A/I [N] 
# 
      FFS2ICT (TYPE,TYPE$CMD,SUPPORTED,NOTNOSPF); 
        FFS2IPT ( 0, ALPHA01, NOTREQD, 0, 0); 
        FFS2IPT ( 0, ALNUM03, NOTREQD, 0, 0); 
  
  
# 
*     USER [SP] [USERNAME] [,PASSWORD] [,FAMILY]
# 
      FFS2ICT (USER,USER$CMD,SUPPORTED,NOTNOSPF); 
        FFS2IPT ( 0, ALNUM07,REQUIRED, 0, 0 );             # USER      #
        FFS2IPT ( 0, ALNUM07,NOTREQD,  0, 0 );             # PASSWORD  #
        FFS2IPT ( 0, ALNUM07,NOTREQD,  0, 0 );             # FAMILY    #
  
  
      RETURN;                          # RETURN TO CALLER              #
      END                              # FFSIBCT                       #
  
      TERM
