*DECK FCSCDCI 
USETEXT TEXTFCS;
      PROC FCSCDCI; 
*CALL COPYRITE
# TITLE FCSCDCI - PROCESS DISPLAY_COMMAND_INFORMATION COMMAND.         #
  
      BEGIN                            # FCSCDCI                       #
  
# 
**    FCSCDCI - PROCESS DISPLAY_COMMAND_INFORMATION COMMAND.
* 
*     C. J. RAMSAY                     87/11/03 
* 
*     THIS PROCEDURE PROCESSES THE DISPLAY_COMMAND_INFORMATION COMMAND. 
* 
*     PROC FCSCDCI
* 
*     ENTRY   PARMS[1]   = COMMAND NAME.
*             PARMS[2]   = STATUS VARIABLE (IGNORED). 
* 
*     EXIT    FTPERROR   = TRUE IF PROTOCOL ERROR DETECTED. 
*             FTPFAIL    = TRUE IF COMMAND FAILURE DETECTED.
*             FTPUSERE   = TRUE IF USER ERROR DETECTED. 
* 
*     METHOD  SEARCH COMMAND DESCRIPTOR TABLE AND COMMAND NAME TABLE
*             FOR MATCHING COMMAND NAME.
*             IF FOUND THEN DISPLAY ALL PARAMETERS APPLICABLE TO THE
*             COMMAND.
* 
# 
  
# 
****  PROC FCSCDCI - XREF LIST
# 
      XREF
        BEGIN 
        PROC FCSOWOF;                  # WRITE TO OUTPUT FILE          #
        PROC NETUCAC;                  # COPY AN ASCII CHARACTER       #
        PROC NETUCAS;                  # COPY AN ASCII STRING          #
        PROC NETUCDA;                  # CONVERT DISPLAY CODE TO ASCII #
        END 
# 
****
# 
      DEF NAMEST$        #  0 #;       # INDEX TO PARAMETER NAME       #
      DEF PARFSZ$        # 42 #;       # SIZE OF PARAMETER FORMAT      #
      DEF REQDST$        # 34 #;       # INDEX TO PARAMETER REQUIRED   #
      DEF REQDSZ$        #  8 #;       # SIZE OF PARAMETER REQUIRED    #
      DEF TYPEST$        # 23 #;       # INDEX TO PARAMETER TYPE       #
      DEF TYPESZ$        #  7 #;       # SIZE OF PARAMETER TYPE        #
  
      ITEM CMDNUM        I;            # COMMAND NUMBER                #
      ITEM I             I;            # LOOP INDUCTION VARIABLE       #
      ITEM PNUM          I;            # INDEX INTO DESCRIPTOR TABLE   #
      ITEM PPTR          I;            # INDEX FIRST PARAMETER FOR CMD #
      ITEM PSIZ          I;            # NUMBER OF PARAMETERS FOR CMD  #
      ITEM RESPLIM       I;            # LAST INDEX IN EXPANDED RESP   #
  
      ITEM COMMA         U = X"2C0000000000000";
      ITEM CRLF          U = X"0D0A00000000000";
      ITEM SPACING       U = O"55550000000000000000"; 
  
      ARRAY THISCHAR [00:00] S(1);     # CURRENT CHARACTER             #
        BEGIN 
        ITEM THISCHR     U(00,00,08); 
        END 
  
      ARRAY PARFORM [00:00] S(5);      # PARAMETER FORMAT TEMPLATE     #
        BEGIN 
        ITEM TPARFORM    C(00,00,PARFSZ$) = 
       ["                     : TTTT    = $RRRRRRRR"];
        END 
  
      DEF LWSIZ$   # 6 #;              # NO OF WORDS IN RESPONSE LINE  #
      DEF LCSIZ$  # 60 #;              # NO OF CHARS IN RESPONSE LINE  #
      DEF GETLIM$  # 2 #;              # MAX INDEX IN RESPONSE         #
      ARRAY GETRSP [00:GETLIM$] S(LWSIZ$);  # GET (LOCAL_FILE)         #
        BEGIN 
        ITEM GET$RSP  C(00,00,LCSIZ$) = 
     ["LOCAL_FILE, LF       : FILE                                ",
      "                         OR                                ",
      "                       'FILE [,CS=CS] [,TRUNC]' = $OPTIONAL"]; 
        END 
  
      DEF APPTLIM$  # 3 #;             # MAX INDEX IN RESPONSE         #
      ARRAY APPTRSP [00:APPTLIM$] S(LWSIZ$); # APP OR PUT (LOCAL_FILE) #
        BEGIN 
        ITEM APPT$RSP  C(00,00,LCSIZ$) =
     ["LOCAL_FILE, LF       : FILE                                ",
      "                         OR                                ",
      "                      'FILE [,CS=CS] [,FSC=FSC] [,READEOI]'",
      "                       = $REQUIRED                         "]; 
        END 
  
      BASED ARRAY RESP [00:00] S(LWSIZ$); # RESPONSE TEMPLATE          #
        BEGIN 
        ITEM RESP$LIN C(00,00,LCSIZ$);
        END 
  
      ARRAY PTNAMES [PTFIRST:PTLAST] S(1);
        BEGIN 
        ITEM TPTNAME     C(00,00,TYPESZ$) = 
       ["NAME   ",
        "NAME   ",
        "FILE   ",
        "BOOLEAN",
        "KEYWORD"]; 
        END 
  
      ARRAY RQNAMES [RQFIRST:RQLAST] S(1);
        BEGIN 
        ITEM TRQNAME     C(00,00,REQDSZ$) = 
       ["OPTIONAL", 
        "REQUIRED"];
        END 
  
      ARRAY EUNKCMD [00:00] S(5); 
        BEGIN 
        ITEM TUNKCMD     C(00,00,47) =
       ["--ERROR--  NO INFORMATION ON SPECIFIED COMMAND."]; 
        ITEM ZUNKCMD     U(04,42,18) = [0]; 
        END 
  
      ARRAY NOPARMS [00:00] S(2); 
        BEGIN 
        ITEM TNOPARMS    C(00,00,14) =
       ["NO PARAMETERS."];
        ITEM ZNOPARMS    U(01,24,36) = [0]; 
        END 
      CONTROL EJECT;
# 
*     START MAIN PROCEDURE
# 
      CMDNUM = CMDERROR;               # INITIALIZE TO NOT FOUND       #
      FOR I = 1 STEP 1
        WHILE (I LQ CDTSIZ$) AND
              (CMDNUM EQ CMDERROR) DO 
        BEGIN                          # LOOP COMMAND DESCRIPTOR TABLE #
        IF PARAMD[1] EQ CDT$NAME[I] 
        THEN
          BEGIN                        # MATCHING COMMAND NAME         #
          CMDNUM = CDT$CNUM[I];        # PICK UP COMMAND NUMBER        #
          END 
        END 
      FOR I = 1 STEP 1
        WHILE (I LQ CNTSIZ$) AND
              (CMDNUM EQ CMDERROR) DO 
        BEGIN                          # LOOP COMMAND NAME TABLE       #
        IF PARAMN[1] EQ CNT$NAME[I] 
        THEN
          BEGIN                        # MATCHING COMMAND NAME         #
          CMDNUM = CDT$CNUM[I];        # PICK UP COMMAND NUMBER        #
          END 
        END 
# 
*     IF COMMAND NAME NOT RECOGNIZED THEN WRITE ERROR MESSAGE AND EXIT. 
# 
      IF CMDNUM EQ CMDERROR 
      THEN
        BEGIN                          # COMMAND NOT RECOGNIZED        #
        FCSOWOF (EUNKCMD, INTERNAL$);  # WRITE MESSAGE TO OUTPUT FILE  #
        RETURN;                        # GET OUT OF HERE QUICKLY       #
        END 
# 
*     PICK UP PARAMETER TABLE INDEX AND NUMBER OF PARAMETERS. 
*     CHECK FOR NO PARAMETERS ASSOCIATED WITH COMMAND.
# 
      PPTR = CDT$PPTR[CMDNUM];         # INDEX OF FIRST PARAMETER      #
      PSIZ = CDT$PSIZ[CMDNUM];         # NUMBER OF PARAMETERS          #
      IF PSIZ EQ 0
      THEN
        BEGIN                          # NO PARAMETERS FOR COMMAND     #
        FCSOWOF (NOPARMS, INTERNAL$);  # WRITE MESSAGE TO OUTPUT FILE  #
        END 
# 
*     FOR EACH PARAMETER WRITE A LINE DEFINING THE PARAMETER FORMAT.
# 
      FOR PNUM = PPTR STEP 1
        WHILE PNUM LS PPTR + PSIZ DO
        BEGIN                          # LOOP THRU ALL PARAMETERS      #
        IF PDT$TYPE[PNUM] EQ PTFILE    # GIVE EXPANDED FILE DESCRIPTION#
        THEN
          BEGIN 
          IF (CMDNUM EQ CMDAPPF) OR    # APPEND_FILE OR REPLACE_FILE   #
             (CMDNUM EQ CMDREPF)
          THEN
            BEGIN 
            P<RESP> = LOC (APPTRSP);
            RESPLIM = APPTLIM$; 
            END 
          ELSE                         # GET_FILE                      #
            BEGIN 
            P<RESP> = LOC (GETRSP); 
            RESPLIM = GETLIM$;
            END 
  
          FOR I = 0 STEP 1 UNTIL RESPLIM DO 
            BEGIN 
            OUTLEN = 0; 
            NETUCDA (RESP$LIN [I], 0, LCSIZ$,   # COPY LINE OF DISPLAY #
                     OUTBUF, OUTLEN, FALSE);
            NETUCAS (CRLF, 0, 2,
                     OUTBUF, OUTLEN);           # COPY CR + LF         #
            FCSOWOF (OUTBUF, OUTLEN);           # WRITE TO OUTPUT FILE #
            END 
  
          TEST PNUM;                   # PROCESS NEXT PARAMETER        #
  
          END 
  
        OUTLEN = 0;                    # INITIALIZE INDEX              #
        NETUCDA (PARFORM, 0, PARFSZ$, OUTBUF, 
                 OUTLEN, FALSE);       # COPY PARAMETER FORMAT TEMPLATE#
  
        OUTLEN = NAMEST$;              # INITIALIZE INDEX              #
        P<TBUF> = LOC(PNT$NAME[PNUM]);
        NETUCAS (TBUF, 0, PNT$SIZE[PNUM], 
                 OUTBUF, OUTLEN);      # COPY FULL PARAMETER NAME      #
  
        IF PDT$SIZE[PNUM] NQ 0
        THEN
          BEGIN                        # PARAMETER ABBREVIATION EXISTS #
          NETUCAC (COMMA, 0,
                   OUTBUF, OUTLEN);    # COPY ASCII COMMA              #
          OUTLEN = OUTLEN + 1;         # ALLOW FOR ASCII SPACE         #
          P<TBUF> = LOC(PDT$NAME[PNUM]);
          NETUCAS (TBUF, 0, PDT$SIZE[PNUM], 
                   OUTBUF, OUTLEN);    # ABBREVIATED PARAMETER NAME    #
          END 
  
        OUTLEN = TYPEST$;              # INITIALIZE INDEX              #
        P<TBUF> = LOC(TPTNAME[PDT$TYPE[PNUM]]); 
        NETUCDA (TBUF, 0, TYPESZ$, OUTBUF,
                 OUTLEN, FALSE);       # COPY PARAMETER TYPE           #
  
        OUTLEN = REQDST$;              # INITIALIZE INDEX              #
        P<TBUF> = LOC(TRQNAME[PDT$REQD[PNUM]]); 
        NETUCDA (TBUF, 0, REQDSZ$, OUTBUF,
                 OUTLEN, FALSE);       # COPY REQUIRED OR OPTIONAL     #
  
        NETUCAS (CRLF, 0, 2,
                 OUTBUF, OUTLEN);      # COPY CR + LF                  #
        FCSOWOF (OUTBUF, OUTLEN);      # WRITE TO OUTPUT FILE          #
        END 
  
      FCSOWOF (SPACING, INTERNAL$);    # WRITE A BLANK LINE            #
  
      RETURN;                          # RETURN TO CALLER              #
  
      END                              # FCSCDCI                       #
  
      TERM
