*DECK,NP$DATA 
*IF,DEF,XFR 
USETEXT AIPDEF
USETEXT HEADER
USETEXT NP$NWL
USETEXT NP$GETS 
USETEXT NX$ACBX 
      PROC NP$DATA; 
      BEGIN 
# 
*1DC  NP$DATA 
* 
*     1. PROC NAME         AUTHOR               DATE
*        NP$DATA           Y. C. YIP            02/19/1985
* 
*     2. FUNCTIONAL DESCRIPTION 
*        NP$DATA CHECKS THE MESSAGES THAT THE NETXFRC PASSES
*        TO IT. THE END RESULT OF THE VARIOUS CHECKS WILL 
*        PROCDUCE A TRIGGER USED IN CALLING NETSTPR, THE
*        THE STATE TABLE ACTION PROCESSOR.
* 
*     3. METHOD USED
*        VALUES OF THE QMSG MESSAGES FOR FILE TRANSFER ARE
*        STORED IN AN ARRAY TOGETHER WITH INTERNAL TRIGGER
*        VALUE. THE UPPER SLOT + 1 OF EACH QMSG COLUMN
*        ALWAYS CONTAINS THE ILLEGAL TRIGGER VALUE FOR
*        EACH STATE TABLE, (PRU MODE SEND, RECEIVER, AND
*        CHARACTER MODE SEND, AND RECEIVE). THE RECEIVED
*        QMSG IS ALWAYS DEPOSITED AT THE UPPDER SLOT + 1
*        OF EACH QMSG COLUMN OF THE RESPECTIVE TABLES.
*        IN CASE THERE IS NO MATCH FOR THAT QMSG FOR THE
*        PRESET QMSGS WITHIN THE ARRAY, IT WILL FINALLY 
*        MATCHES ITSELF AT THE UPPER SLOT + 1 LOCATION AND
*        GENERATES THE ILLEGAL TRIGGER VALUE. 
* 
*        NON-QBLK/QMSG MESSAGES:  
* 
*        IN THE CASE OF A INTRAHOST FILE TRANSFER, IT WILL
*        STORE THE DATA AND WRITES DIRECTLY ON THE OUTPUT 
*        FET WHEREAS, IN THE CASE OF A CHARACTER MODE FILE
*        TRANSFER, IT WILL ALWAYS WRITE ON THE DISK BUFFER. 
* 
*     4. ENTRY CONDITIONS 
*        LOC$HA AND LOC$TA ARE THE HEADERS AND TEXT AREAS 
*        FOR THE MESSAGES BLOCK TYPE CAN BE 1,2,6 OR 7. 
* 
*     5. EXIT CONDITONS 
*        A TRIGGER VALUE IS GENERATED USED IN 
*        CALLING NP$STPR. 
* 
*     6. COMDECKS CALLED AND SYMPL TEXTS USED.
*        NP$NWL, NX$ACBX. 
* 
*     7. ROUTINES CALLED
*        NP$MSG - DAYFILE ILLEGAL TRIGGER RECEIVED. 
* 
*     8. DAYFILE MESSAGES 
*        -  "ILLEGAL TRIGGER RECEIVED"
* 
# 
  
# 
**** PROC NP$DATA - XREF LIST.
# 
      XREF                         # EXTERNAL REFERENCE PROCS          #
        BEGIN 
        PROC NP$STPR;              # STATE TABLE PROCESSOR             #
        PROC NP$MSG;               # DAYFILE MESSAGE PASSER            #
        PROC NP$CIO;               # PROC FOR ISSUING CIO CALLS        #
        END 
# 
****
# 
      DEF ERTABLMT # 6 #;          # LIMIT OF ERROR CODE TABLE         #
      DEF PRDLMT # 28 #;           # TABLE SIZE OF THE FOUR TABLES     #
      DEF PRDSPLOWER # 1 #;        # LOWER BOUND FOR PRU SENDER TABLE  #
      DEF PRDSPUPPER # 4 #;        # UPPER BOUND FOR PRU SENDER TABLE  #
      DEF PRDRPLOWER # 8 #;        # LOWER BOUND FOR PRU RECE'V TABLE  #
      DEF PRDRPUPPER # 10 #;       # UPPER BOUND FOR PRU RECE'V TABLE  #
      DEF PRDSCLOWER # 15 #;       # LOWER BOUND FOR CHAR SENDER TABLE #
      DEF PRDSCUPPER # 20 #;       # UPPER BOUND FOR CHAR SENDER TABLE #
      DEF PRDRCLOWER # 22 #;       # LOWER FOR CHAR RECEIVER TABLE     #
      DEF PRDRCUPPER # 25 #;       # UPPER BOUND FOR CHAR RECEIVER TAB #
      DEF ERTABNO # 5 #;           # NUMBER OF TABLES FOR ERROR CODE - #
                                   # TRIGGER MATCH                     #
      ITEM CRNT$ORD;               # CURRENT VALUE OF TABLE ORDINAL    #
      ITEM CONTRIG;                # CURRENT VALUE OF TRIGGER          #
      ITEM LEVLOP B;               # FLAG FOR EXITTING LOOP            #
      ITEM INDEX;                  # LOOP INDEX                        #
      ITEM TABSELECT;              # ERROR TABLE SELECTOR              #
      ITEM BACKTRIG;               # RETURN TRIGGER BY CALLING NP$STPR #
  
      ARRAY ILLTRIG[0:0] S(3);     # ILLEGAL TRIGGER                   #
        BEGIN 
        ITEM ILLTRIGC C(00,00,24) = ["ILLEGAL TRIGGER RECEIVED"]; 
        ITEM ILLTRIGZ U(02,24,36) = [0];
        END 
  
      ARRAY ERBLK[0:0] S(3);       # ERROR BLOCK                       #
        BEGIN 
        ITEM ERBLKV C(00,00,21) = ["BLOCK TYPE NOT QMSG"];
        ITEM ERBLKZ U(02,06,54) = [0];
        END 
  
      BASED ARRAY ERR$TAB[0:0] S(1);  # BASED ARRAY FOR ERROR CODE     #
        BEGIN 
        ITEM ERR$CODE U(00,00,32); # ERROR CODE                        #
        END 
  
      ARRAY PFCSFCTAB[1:PRDLMT] S(1); # PFCSFC TABLE FOR LEVEL 7 QMSG  #
        BEGIN 
        ITEM PFSFV U(00,00,16) = [ # START OF PRU SENDER LEVEL 7 QMSG  #
                                   LEV7$ER,  # ER(E)                   #
                                   LEV7$SR,  # SR                      #
                                   LEV7$RR,  # RR                      #
                                          ,  # ILLEGAL TRIGGER         #
                                          , 
                                          , 
                                          , 
                                   # START OF PRU RECEIVER LEVEL 7 QMSG#
                                   LEV7$ES,  # ES(E)                   #
                                   LEV7$SS,  # SS                      #
                                          ,  # ILLEGAL TRIGGER         #
                                          , 
                                          , 
                                          , 
                                          , 
                                   # START OF CHAR SENDER LEVEL 7 QMSG# 
  
                                   LEV7$SR,  # SR                      #
                                   LEV7$RR,  # RR                      #
                                   LEV7$ER,  # ER                      #
                                   LEV7$QR,  # QR                      #
                                   LEV7$MR,  # MR                      #
                                          ,  # ILLEGAL TRIGGER         #
                                          , 
                                   # START OF CHAR RECEIVER LEVEL 7 QMS#
                                   LEV7$SS,  # SS                      #
                                   LEV7$ES,  # ES                      #
                                   LEV7$MS,  # MS                      #
                                          ,  # ILLEGAL TRIGGER         #
                                          , 
                                          , 
                                   ]; 
  
        ITEM PFSFTRIG U(00,30,30) = [ 
                                   # START OF PRU SENDER TRIGGER       #
                                   NSPTERK,  # ER(OK)                  #
                                    NSPTSR,  # SR                      #
                                   NSPTRRT,  # RR RECEIVED             #
                                   NRSTILL,  # ILLEGAL TRIGGER         #
                                          , 
                                          , 
                                          , 
                                   # START OF PRU RECEIVER TRIGGER     #
                                   NRPTESE,  # ES(E)                   #
                                    NRPTSS,  # SS                      #
                                   NRSTILL,  # ILLEGAL TRIGGER         #
                                          , 
                                          , 
                                          , 
                                          , 
                                   # START OF CHAR SENDER TRIGGER TABLE#
                                    NSCTSR,  # SR                      #
                                   NSCTRRT,  # RR                      #
                                   NSCTERK,  # ER                      #
                                   NSCTQRE,  # QR                      #
                                   NSCTMRR,  # MR                      #
                                   NSCTILL,  # ILLEGAL TRIGGER         #
                                          , 
                                   # START OF CHAR RECEIVER TRIGGER TAB#
                                    NRCTSS,  # SS                      #
                                   NRCTESE,  # ES(E)                   #
                                   NRCTMSR,  # MS                      #
                                   NRCTILL,  # ILLEGAL TRIGGER         #
                                          , 
                                          , 
                                   ]; 
        END                        # END OF PFCSFCTAB                  #
  
      ARRAY ERTAB [1: ERTABLMT] S(1);  # ERROR CODE TABLE FOR ER AND ES#
        BEGIN 
        ITEM ERCODE U(00,00,32) = [ 
                                   PRDER1,  # ER OR ES(OK)             #
                                   PRDER2,  # RETRYABLE RECEIVER ERROR #
                                   PRDER3,  # NONRETRYABLE RECEIVE ERR #
                                   PRDER6,  # RETRYABLE SENDER ERROR   #
                                   PRDER7,  # NON RETRYABLE SENDER ERR #
                                            # ILLEGAL ERROR CODE       #
                                   ]; 
        END 
  
      ARRAY QRTAB [1: ERTABLMT] S(1);    # ERROR CODE TABLE FOR QR     #
        BEGIN 
        ITEM QRCODE U(00,00,32) =  [
                                    PRDER1, # NO ERROR                 #
                                    PRDER2, # RETRYABLE RECEIVE ERROR  #
                                    PRDER3, # NONRETRYABLE RECEIVE ERR #
                                    PRDER4, # PROTOCOL ERROR           #
                                    PRDER5, # GO NOT ACCEPTED          #
                                            # ILLEGAL ERROR CODE       #
                                    ];
        END 
  
      ARRAY PRDPTR [0:NETRCOD] S(1);  # CONTROL BLOCK FOR INDEXES INTO #
        BEGIN                         # PFCSFC LEVEL 7 QMSG            #
        ITEM PRDLOWER U(00,00,30) = [ PRDSPLOWER,  # LOWER BOUND SEND  #
                                      PRDRPLOWER,  # LOWER BOUND PRU   #
                                                   # RECEIVE           #
                                      PRDSCLOWER,  # LOWER BOUND CHAR  #
                                                   # SEND              #
                                      PRDRCLOWER   # LOWER BOUND CHAR  #
                                                   # RECEIVE           #
                                     ]; 
        ITEM PRDUPPER U(00,30,30) = [ PRDSPUPPER, # UPPER BOUND  SEND  #
                                      PRDRPUPPER, # UPPER BOUND  PRU   #
                                                  # RECEIVE            #
                                      PRDSCUPPER, # UPPER BOUND CHAR   #
                                                  # SEND               #
                                      PRDRCUPPER  # UPPER BOUND CHAR   #
                                                  # RECEIVE            #
                                     ]; 
        END                        # END OF PRDPTR                     #
  
      ARRAY ERRTRIG [1: ERTABLMT, 1 : ERTABNO] S(1);
        BEGIN 
        ITEM ENTRV U(00,32,28) = [ # ER(E) AND PRU SENDER TABLE        #
                                   [ NSPTERK,     # ER(OK)             #
                                     NSPTERE,     # ER(E) WITH E=X20   #
                                     NSPTERE,     # ER(E) WITH E=X21   #
                                     NSPTERE,     # ER(E) WITH E=X28   #
                                     NSPTERE,     # ER(E) WITH E=X29   #
                                     NRSTILL      # ILLEGAL TRIGGER    #
                                   ]
                                   # ER(E) AND CHARACTER SENDER TABLE  #
                                   [ NSCTERK,     # ER(OK)             #
                                     NSCTERE,     # ER(E) WITH E=X20   #
                                     NSCTERE,     # ER(E) WITH E=X21   #
                                     NSCTERE,     # ER(E) WITH E=X28   #
                                     NSCTERE,     # ER(E) WITH E=X29   #
                                     NSCTILL      # ILLEGAL TRIGGER    #
                                   ]
                                   # ES(E) AND PRU RECEIVER TABLE      #
                                   [ NRPTESE,     # ES(OK)             #
                                     NRPTESE,     # ES(E) WITH E=X20   #
                                     NRPTESE,     # ES(E) WITH E=X21   #
                                     NRPTESE,     # ES(E) WITH E=X28   #
                                     NRPTESE,     # ES(E) WITH E=X29   #
                                     NRSTILL      # ILLEGAL TRIGGER    #
                                   ]
                                   # ES(E) AND CHARACTER RECEIVER TABLE#
                                   [ NRCTESK,     # ES(OK)             #
                                     NRCTESE,     # ES(E) WITH E=X20   #
                                     NRCTESE,     # ES(E) WITH E=X21   #
                                     NRCTESE,     # ES(E) WITH E=X28   #
                                     NRCTESE,     # ES(E) WITH E=X29   #
                                     NRCTILL      # ILLEGAL TRIGGER    #
                                   ]
                                   # QR(E) AND CHARACTER SENDER TABLE  #
                                   [ NSCTQRK,     # QR(OK)             #
                                     NSCTQRE,     # QR(E) WITH E=X20   #
                                     NSCTQRE,     # QR(E) WITH E=X21   #
                                     NSCTQRE,     # QR(E) WITH E=X22   #
                                     NSCTQRE,     # QR(E) WITH E= X23  #
                                     NSCTILL      # ILLEGAL TRIGGER    #
                                   ]
                                  ];
        END                        # END OF TABLE                      #
  
      STATUS ERTABID NULL,         # TABLE ID FOR SEARCHING ERROR CODE #
                     TAB1,         # ERROR CODE FOR ER AND PRU SENDER  #
                     TAB2,         # ERROR CODE FOR ER AND CHAR SENDER #
                     TAB3,         # ERROR CODE FOR ES AND PRU RECEIVER#
                     TAB4,         # ERROR CODE FOR ES AND CHAR RECVER #
                     TAB5;         # ERROR CODE FOR QR AND CHAR SENDER #
  
      CONTROL EJECT;
      PROC PRDCOPY; 
      BEGIN 
# 
*1DC  PRDCOPY 
* 
*     1. PROC NAME         AUTHOR               DATE
*        PRDCOPY           Y. C. YIP            02/19/1985
* 
*     2. FUNCTIONAL DESCRIPTION 
*        PRDCOPY COPYIES CONTENT OF DATA RECEIVED THROUGH NETGETL 
*        IN NETXFRC TO NET WORK BUFFER INDEXED BY FTTINDEX. 
* 
*     3. METHOD USED
*        FIRST, TEMPLATE FOR NETWORK BUFFER, FET$WORK IS PULLED 
*        FET ADDRESS INDICATED BY FTTFETW[FTTINDEX].
*        SECOND, A LOCAL TEMPLATE, WORD IS SET TO THE FIRST WORD
*        ADDRESS OF THE NETWORK BUFFER INDEXED BY FTT.
*        A LOCAL INDEX, IN$ADR IS SET SUCH IT POINTS TO THE WORD
*        WHERE DATA FROM LOC$TA SHOULD BE STORED. IN$ADR IS NORMALLY
*        ONE GREATER THAN THE VALUE OF IN POINTER OF NETWORK BUFFER 
*        EXCEPT FOR THE BOUNDARY CONDITION MENTIONED BELOW. 
*        THEN THE WHOLE CHUNK OF DATA IN LOC$TA IS COPIED TO
*        THE NETWORK BUFFER USING THE TLC IN THE LOC$TA.
*        BOUNDARY CONDITIONS ARE: 
*          IN POINTER IN NETWORK BUFFER FET IS EQUAL TO 
*          OUT POINTER IN NETWORK BUFFER FET. IN THIS CASE, 
*          IN$ADR IS SET TO VALUE OF IN POINTER.
*        ERROR CONDITION IS:  
*           IN$ADR IS EQUAL TO LIMIT POINTER IN NETBUF FET. 
*           IN THIS CASE, CONTRIG IS SET TO INTERNAL ERROR TRIGGER. 
* 
*     4. ENTRY CONDITIONS 
*        CONTRIG IS ZEROED OUT. 
* 
*     5. EXIT CONDITONS 
*        CONTRIG IS ASSIGNED TO ERROR TRIGGER SHOULD AN ERROR 
*        OCCUR. DATA IS COPYIED FROM DATA$WORD TO NETBUF
* 
*     6. COMDECKS CALLED AND SYMPL TEXTS USED.
* 
*     7. ROUTINES CALLED
*        -NONE
*     8. DAYFILE MESSAGES 
*        -NONE
* 
# 
      BASED ARRAY COPYAREA[0:0] S(1);    # TEMPLATE FOR ADDRESSING     #
        BEGIN                            # COPYING AREA                #
        ITEM WORD U(00,00,60);
        END 
      ITEM IN$ADR;                 # POINTER TO NETBUF AREA            #
      ITEM INDEX;                  # LOOP INDEX                        #
      ITEM LOCTLC;                 # LENGTH OF TEXT TO BE COPIED       #
      CONTROL EJECT;
#                                                                      #
#                   CODE OF PRDCOPY BEGINS HERE                        #
#                                                                      #
      P<FET$WORK> = FTTFETW[FTTINDEX];  # PULL NETBUF TEMPLATE TO      #
                                   #      NETBUF ADDRESS IN THE FTT    #
      P<COPYAREA> = 0;             # SET COPYAREA TEMPLATE TO POINT TO #
                                   # 0                                 #
      P<FET$CIO> = FTTFETADR[FTTINDEX];  # SET DISK FET TEMPLATE TO    #
                                   # MEMORY ADDRESS OF DISK FET        #
      P<CMB> = FTTCMV$BLK[FTTINDEX];  # SET CMB TEMPLATE TO CHARACTER  #
                                   # CONVERSION TABLE ADDRESS          #
      P<HEADER> = LOC$HA;        #   PULL HEADER TEMPLATE TO HA        #
      IF NOT FTTNOTRAN[FTTINDEX]   # IF TRANSLATION NEEDED             #
      THEN
        BEGIN 
        IF ABHTLC NQ 0             # NON-ZERO ABHTLC                   #
        THEN
          BEGIN 
          IN$ADR = FETWIN[0] + 1;  # IN$ADR NOW POINTS TO INPOINTER + 1#
          IF FETWIN[0] EQ FETWOUT[0] # INITIAL CONDITION OF FET        #
          THEN
            BEGIN 
            IN$ADR = FETWIN[0];  # IN$ADR NOW IS THE SAME AS FETWIN    #
            END 
          LOCTLC = (ABHTLC*2 +14)/15;# COMPUTE LENGTH OF TEXT IN  WORDS#
          WORD[IN$ADR] = DATA$WORD[0]; # COPY HEADER                   #
          FOR INDEX = 1 STEP 1 UNTIL LOCTLC 
          DO
            BEGIN 
            IN$ADR = IN$ADR + 1;     # NEXT WORD                       #
            IF IN$ADR EQ FETWLIMIT[0]  # IF IN POINTER EQ LIMIT POINTER#
            THEN
              BEGIN 
              CONTRIG = NRCTITR;   # SET CONTRIG TO INTERNAL ERROR     #
              GOTO ENDCOPY;        # RETURN WITHOUT FURTHER COPYING    #
              END 
            ELSE
              BEGIN 
              WORD[IN$ADR] = DATA$WORD[INDEX]; # COPY WORD             #
              END 
            END                    # END OF FOR                        #
          FETWIN[0] = IN$ADR ;     # UPDATE IN POINTER                 #
          END                      # END OF NON-ZERO ABHTLC            #
        END                        # END OF TRANSLATION NEEDED         #
      ELSE                         # TRANSLATION NOT NEEDED            #
        BEGIN                      # FOR INTRAHOST BINARY              #
        LOCTLC =(ABHTLC + 1 )*2/15 ; # GET NUMBER OF CM WORDS          #
                                   # EXCLUDING THE ONE WORD TBH HEADER #
        IF LOCTLC GR 1             # IF NOT JUST THE TBH HEADER        #
        THEN
          BEGIN 
          FOR INDEX = 2 STEP 1 UNTIL LOCTLC# COPY DATA DIRECTLY TO CIO #
                                   # BUFFER                            #
          DO
            BEGIN 
            IF FETIN[0]  EQ FETOUT[0] - 1  # IF DISK BUFFER IS FULL    #
            THEN
              BEGIN                # RESET OUT PTR BY WRITING          #
              NP$CIO(CIO$WRITE);   # TO CIO BUFFER                     #
              END 
            WORD[FETIN[0]] = DATA$WORD[INDEX];# COPY DATA TO DISK BUFF #
            FETIN[0] = FETIN[0] + 1; # BUMP IN POINTER OF DISK FET     #
            IF FETIN[0] EQ FETLIM[0]    # END OF BUFFER REACHED        #
            THEN
              BEGIN 
              FETIN[0] = FETFIR[0];  # RESET IN POINTER OF DISK BUFFER #
              END 
            END 
          END                      # END OF FOR LOOP                   #
        END                        # END OF IF                         #
ENDCOPY:  RETURN;                  # RETURN TO CALLER                  #
      END                          # END OF PROC PRDCOPY               #
  
      CONTROL EJECT;
      PROC PRDERR;
      BEGIN 
# 
*1DC  PRDERR
* 
*     1. PROC NAME         AUTHOR               DATE
*        PRDERR            Y. C. YIP            02/19/1985
* 
*     2. FUNCTIONAL DESCRIPTION 
*        PRDERR CHECKS ERROR CODE FOR LEVEL 7 PFCSFC OF QR, ER
*        AND ES. IT THEN GENERATES THE VALUE OF THE TRIGGER 
*        CORRESPONDING TO THESE ERROR CODES.
* 
*     3. METHOD USED
*        FIRST,PFCSFC IS IDENTIFIED AND THE BASE ARRAY ERR$TAB IS 
*        SET TO EITHER ERTAB OR QRTAB DEPENDING ON THE VALUE OF 
*        TABSELECT. TABSELECT VALUE OF 1-4 WILL USE ERTAB AS
*        ERROR CODE TABLE WHEREAS VALUE OF 5 WILL USE QRTAB AS
*        THE ERROR CODE TABLE.
*        AFTER THE SEARCH, IF THE LOOP INDEX IS EQUAL TO THE
*        VALUE OF ERTABLMT, THE ERROR CODE RECEIVED IS ILLEGAL
*        ELSE, THE RIGHT TRIGGER IS PRODUCED BY INDEXING INTO 
*        THE ARRAY ENTRV WITH INDEX OF THE ERROR TABLE AND THE
*        TABLE SELECTOR.
* 
*     4. ENTRY CONDITIONS 
*        TABSELECT - TABLE ORDINAL USED AS THE COLUMN SELECTOR
*                    OF THE ENTRV ARRAY.
* 
*     5. EXIT CONDITONS 
*        CONTRIG IS UPDATED TO HAVE THE TRIGGER VALUE.
* 
*     6. COMDECKS CALLED AND SYMPL TEXTS USED.
*        NX$ACBX
*     7. ROUTINES CALLED
*        NP$MSG - DAYFILE PROCESSOR 
* 
*     8. DAYFILE MESSAGES 
*        -ILLEGAL TRIGGER RECEIVED
* 
# 
  
      ITEM INDEX;                  # LOOP INDEX                        #
      ITEM CTEMP C(10); 
      CONTROL EJECT;
#                                                                      #
#            PRDERR CODE BEGINS HERE                                   #
#                                                                      #
  
      IF TABSELECT EQ ERTABID"TAB5" # QR ERROR CODE TABLE IS USED      #
      THEN
        BEGIN 
        P<ERR$TAB> = LOC(QRTAB);
        END 
      ELSE
        BEGIN 
        P<ERR$TAB> = LOC(ERTAB);   # ELSE ER AND ES ERROR TABLE IS USED#
        END 
      ERR$CODE[ERTABLMT-1] = LV7$ERROR;# DEPOSIT ERROR CODE IN TABLE   #
      LEVLOP = FALSE;               # SET LEAVE LOOP FLAG TO FALSE     #
      FOR INDEX = 0 STEP 1 WHILE NOT LEVLOP  # SCAN TABLE              #
      DO
        BEGIN 
        IF ERR$CODE[INDEX]  EQ LV7$ERROR  # OF A MATCH IS FOUND        #
        THEN
          BEGIN 
          CONTRIG = ENTRV[INDEX + 1,TABSELECT]; # GET TRIGGER          #
          LEVLOP = TRUE;           # SET EXIT FLAG                     #
          IF INDEX EQ ERTABLMT - 1 # IF FOUND IN LAST ENTRY            #
          THEN
            BEGIN 
            NP$MSG(ILLTRIG,XFRDTYPE);  # ILLEGAL TRIGGER RECEIVED      #
            END 
          END 
        END 
      RETURN;                      # RETURN TO CALLER                  #
      END                          # END OF PRDERR                     #
  
  
      CONTROL EJECT;
#                                                                      #
#            CODE OF NP$DATA BEGINS HERE                               #
#                                                                      #
      P<LV7$BASE> = LOC$TA;        # PULL LEVEL 7 MESSAGE TEMPLATE     #
      P<HEADER> = LOC$HA;          # PULL BLOCK HEADER TEMPLATE OVER   #
      CRNT$ORD = FTTSTORD[FTTINDEX];#ASSIGN CURRENT TABLE ORDINAL FROM #
                                   # COMMON BLOCK VARIABLE FTTINDEX    #
      LEVLOP =FALSE;               # CONTROL LOOP INITIALIZED TO FALSE #
      IF ABHABT EQ APMSG AND FTTSTORD[FTTINDEX] EQ NETRCOD
      THEN                         # IF MSG AND CHARACTER RECEIVER     #
        BEGIN                      # THE TABLE ORDINAL IS CHAR RECEIVER#
        CONTRIG = 0;               # ZERO OUT CONTRIG                  #
        IF FTTSTATE[FTTINDEX] EQ   # ONLY COPY IF IN DATA STATE        #
           NRCDATA
        THEN
          BEGIN 
          PRDCOPY;                 # COPY DATA RECEIVED TO NETBUF      #
          END 
        IF CONTRIG EQ 0            # IF NO COPY ERROR                  #
        THEN
          BEGIN 
          CONTRIG = NRCTDAT;       # DATA TRIGGER                      #
          END 
        END 
      ELSE
        BEGIN 
        IF ABHABT EQ APPBLK AND FTTSTORD[FTTINDEX] EQ NETRCOD 
        THEN                       # IF BLOCK AND CHARACTER RECEIVER   #
          BEGIN 
          CONTRIG = 0;             # ZERO OUT CONTRIG                  #
          IF FTTSTATE[FTTINDEX] EQ # COPY BLK ONLY IN DATA STATE       #
             NRCDATA
          THEN
            BEGIN 
            PRDCOPY;               # COPY BLOCK TO NETBUF              #
            END 
          END 
        ELSE
          BEGIN                    # MUST BE APPQMSG OR APPQBLK        #
          PFSFV[PRDUPPER[CRNT$ORD]] = LV7$BPFC;  # PUT PFC IN LAST SLOT#
          FOR INDEX = PRDLOWER[CRNT$ORD] STEP 1 WHILE NOT LEVLOP
          DO
            BEGIN 
            IF LV7$BPFC EQ PFSFV[INDEX] 
            THEN
              BEGIN 
              CONTRIG = PFSFTRIG[INDEX] ;  # ASSIGN TRIGGER VALUE      #
              LEVLOP = TRUE;
              IF INDEX EQ PRDUPPER[CRNT$ORD]
              THEN
                BEGIN 
                NP$MSG(ILLTRIG,XFRDTYPE);  # ILLEGAL TRIGGER           #
                END 
              END 
            END 
          IF CONTRIG EQ NSPTERK AND CRNT$ORD EQ NETSPOD 
          THEN
            BEGIN                    # ER(E) AND PRU SENDER            #
            TABSELECT = ERTABID"TAB1"; # SET TABLE SELECTOR TO TABLE 1 #
            END 
          ELSE
            BEGIN 
            IF CONTRIG EQ NSCTERK AND CRNT$ORD EQ NETSCOD 
            THEN
              BEGIN 
              TABSELECT = ERTABID"TAB2"; # ER(E) AND CHARACTER SENDER  #
              END 
            ELSE
              BEGIN 
              IF CONTRIG EQ NRPTESE AND CRNT$ORD EQ NETRPOD 
              THEN
                BEGIN 
                TABSELECT = ERTABID"TAB3";  # ES(E) AND PRU RECEIVER   #
                END 
              ELSE
                BEGIN 
                IF CONTRIG EQ NRCTESE AND CRNT$ORD EQ NETRCOD 
                THEN
                  BEGIN 
                  TABSELECT = ERTABID"TAB4";  # ES(E) AND CHAR RECEIVER#
                  END 
                ELSE
                  BEGIN 
                  IF CONTRIG EQ NSCTQRE AND CRNT$ORD EQ NETSCOD 
                  THEN
                    BEGIN 
                    TABSELECT = ERTABID"TAB5";# QR(E) AND CHAR SENDER  #
                    END 
                  ELSE
                    BEGIN 
                    TABSELECT = ERTABID"NULL";# NO TABLE SELECT NEEDED #
                    END 
                  END 
                END 
              END 
            END 
          IF TABSELECT NQ ERTABID"NULL"   # SCAN ERROR CODE TABLE      #
          THEN
            BEGIN 
            PRDERR;                     # UPDATE DD FIELD              #
            END 
          END 
        END 
      BACKTRIG = CONTRIG;               # SET BACKTRIG TO CONTRIG      #
      FOR INDEX = 0 WHILE BACKTRIG NQ NIL  # REPEAT WHILE BACKTRIG IS  #
      DO                                # NOT NULL                     #
        BEGIN 
        CONTRIG = BACKTRIG;             # SET CONTRIG TO BACKTRIG      #
        NP$STPR(FTTINDEX,CONTRIG,BACKTRIG); # CALLS STATE TABLE PROCSS #
        END 
      RETURN;                      # RETURN TO CALLER                  #
      END                          # END OF NP$DATA                    #
TERM
*ENDIF
  
  
