*DECK VFETFNC 
USETEXT COMCBEG 
USETEXT COMRQUE 
USETEXT COMRRTN 
USETEXT COMRNDR 
USETEXT COMRAPL 
PROC VFETFNC(VALFUNC,FETFUNCOD,FETSFCODE);
# TITLE VFETFNC - VALIDATE FET FUNCTION. #
  
      BEGIN  # VFETFNC #
  
# 
**    VFETFNC - VALIDATE FET FUNCTION.
* 
*     DETERMINE IF FET I/O FUNCTION REQUESTED IS SUPPORTED BY RHF.
* 
*     PROC VFETFNC(VALFUNC,FETFUNCOD,FETSFCODE).
* 
*     ENTRY   - QU$ADDRESS IS BASED ARRAY CONTAINING NETXFR REQUEST.
*               (CONNECTION) = POINTER TO CORRESPONDING CON. ENTRY. 
* 
*     EXIT    - VALFUNC IS TRUE IF FUNCTION IS VALID. 
*                          FALSE IF FUNCTION IS INVALID.
*               IF THE FUNCTION IS VALID
*               THEN
*                 (FETFUNCOD) = NDR FUNCTION CODE.
*                 (FETSFCODE) = NDR SUB-FUNCTION CODE.
* 
*     PROCESS - INITIALIZE LOOP TERMINATORS.
*               INITIALIZE COMPARE WORD.
*               ASLONGAS NOT END OF TABLE 
*                 AND NO FUNCTION MATCH 
*               DO
*                 IF FUNCTION MATCH 
*                   THEN SET MATCH TO TRUE
*                   ELSE INCREMENT INDEX. 
*               SET RETURN VALUES.
# 
  
      ITEM FETFUNCOD  I;             # FET I/O FUNCTION CODE FOR NDR #
      ITEM FETSFCODE  I;             # NDR FET I/O SUB-FUNCTION # 
      ITEM VALFUNC    B;             # VALID FUNCTION FLAG #
  
  
      DEF SEND       #1#;            # DIRECTION = SEND # 
      DEF RECEIVE    #2#;            # DIRECTION = RECEIVE #
      DEF FIRSTFF    #1#;            # FIRST FET FUNCTION # 
      DEF LASTFF     #21#;           # LAST FET FUNCTION #
  
      ITEM INDEX      I;             # LOOP INDEX # 
      ITEM MATCH      B;             # FUNCTION MATCH FLAG #
  
      ARRAY RHFFETFUN  [FIRSTFF:LASTFF]; # RHF SUPPORTED FET FUNCTIONS #
        BEGIN 
        ITEM RHF$NDRFNC I(00,00,12) = [     # NDR FUNCTION CODE # 
                                       NF$FREAD,
                                       NF$CMREAD, 
                                       NF$CMREAD, 
                                       NF$FWRITE, 
                                       NF$CMWRITE,
                                       NF$CMWRITE,
                                       NF$FREADC, 
                                       NF$CMREAD, 
                                       NF$CMREAD, 
                                       NF$FWRITEC,
                                       NF$CMWRITE,
                                       NF$CMWRITE,
                                       NF$FWRITER,
                                       NF$CMWRITE,
                                       NF$CMWRITE,
                                       NF$FWRITEF,
                                       NF$CMWRITE,
                                       NF$CMWRITE,
                                       NF$FCLOSE, 
                                       NF$CMWRITE,
                                       NF$CMWRITE,
                                                 ]; 
        ITEM RHF$NDRSFC I(00,12,12) = [     # NDR SUB-FUNCTION #
                                       NULLSFC, 
                                       CM$READ, 
                                       CM$READ, 
                                       NULLSFC, 
                                       CM$WRITE,
                                       CM$WRITE,
                                       NULLSFC, 
                                       CM$READC,
                                       CM$READC,
                                       NULLSFC, 
                                       CM$WRITEC, 
                                       CM$WRITEC, 
                                       NULLSFC, 
                                       CM$WRITER, 
                                       CM$WRITER, 
                                       NULLSFC, 
                                       CM$WRITEF, 
                                       CM$WRITEF, 
                                       NULLSFC, 
                                       CM$CLOSE,
                                       CM$CLOSE,
                                               ]; 
        ITEM RHF$DIREC  U(00,24,12) = [     # TRANSFER DIRECTION #
                                       RECEIVE, 
                                       RECEIVE, 
                                       RECEIVE, 
                                       SEND,
                                       SEND,
                                       SEND,
                                       RECEIVE, 
                                       RECEIVE, 
                                       RECEIVE, 
                                       SEND,
                                       SEND,
                                       SEND,
                                       SEND,
                                       SEND,
                                       SEND,
                                       SEND,
                                       SEND,
                                       SEND,
                                       SEND,
                                       SEND,
                                       SEND,
                                           ]; 
        ITEM RHF$COMVAL I(00,36,24);        # VALID FUNC VALUES # 
        ITEM RHF$CMTYPE I(00,36,12) = [     # CONVERT MODE TYPE # 
                                       BINARY,
                                       RNASCTODC, 
                                       RNASCTOASC,
                                       BINARY,
                                       WDCTONASC, 
                                       WASCTONASC,
                                       BINARY,
                                       RNASCTODC, 
                                       RNASCTOASC,
                                       BINARY,
                                       WDCTONASC, 
                                       WASCTONASC,
                                       BINARY,
                                       WDCTONASC, 
                                       WASCTONASC,
                                       BINARY,
                                       WDCTONASC, 
                                       WASCTONASC,
                                       BINARY,
                                       WDCTONASC, 
                                       WASCTONASC,
                                                 ]; 
        ITEM RHF$FETFNC I(00,48,12) = [     # RHF FET FUNCTIONS # 
                                       CIORQ$READ,
                                       CIORQ$READ,
                                       CIORQ$READ,
                                       CIORQ$WRIT,
                                       CIORQ$WRIT,
                                       CIORQ$WRIT,
                                       CIORQ$RDC, 
                                       CIORQ$RDC, 
                                       CIORQ$RDC, 
                                       CIORQ$WRTC,
                                       CIORQ$WRTC,
                                       CIORQ$WRTC,
                                       CIORQ$WRTR,
                                       CIORQ$WRTR,
                                       CIORQ$WRTR,
                                       CIORQ$WRTF,
                                       CIORQ$WRTF,
                                       CIORQ$WRTF,
                                       CIORQ$CLOS,
                                       CIORQ$CLOS,
                                       CIORQ$CLOS,
                                                 ]; 
        END 
  
      ARRAY COMARWORD [0:0] S(1); 
        BEGIN 
        ITEM CW$COMVAL  I(00,36,24); # VALUE TO COMPARE VALID FUNC. # 
        ITEM CW$CMTYPE  I(00,36,12); # CONVERT MODE REQUESTED # 
        ITEM CW$FETFNC  I(00,48,12); # FET I/O FUNCTION REQUESTED # 
        END 
  
CONTROL EJECT;
  
      INDEX = FIRSTFF;
      MATCH = FALSE;
      CW$CMTYPE = QU$CMTREQ;
      CW$FETFNC = QU$FETFUNC; 
  
      IF CW$CMTYPE EQ CON$CM
        OR CW$CMTYPE EQ BINARY
      THEN
        BEGIN 
        ASLONGAS INDEX LE LASTFF
          AND NOT MATCH 
        DO
          BEGIN 
          IF RHF$COMVAL[INDEX] EQ CW$COMVAL 
          THEN
            BEGIN 
            MATCH = TRUE; 
            FETFUNCOD = RHF$NDRFNC[INDEX];
            FETSFCODE = RHF$NDRSFC[INDEX];
            END 
  
          ELSE
            BEGIN 
            INDEX = INDEX + 1;
            END 
  
          END 
  
        IF CW$CMTYPE EQ BINARY
          AND ((RHF$DIREC[INDEX] EQ RECEIVE AND (CON$CM EQ RNASCTODC
                                              OR CON$CM EQ RNASCTOASC 
                                              OR CON$CM EQ CMENTEXT)) 
            OR (RHF$DIREC[INDEX] EQ SEND    AND (CON$CM EQ WDCTONASC
                                              OR CON$CM EQ WASCTONASC 
                                              OR CON$CM EQ CMENTEXT)))
        THEN
          BEGIN 
          MATCH = FALSE;
          END 
  
        END 
  
      VALFUNC = MATCH;
  
      RETURN; 
  
      END  # VFETFNC #
  
      TERM
