*DECK ASGNDR
USETEXT COMCBEG 
USETEXT COMRAPL 
USETEXT COMRNET 
USETEXT COMRNDR 
USETEXT COMRQUE 
USETEXT COMRRTN 
PROC ASGNDR(REQASSIGNED,NOSTATUS);
# TITLE ASGNDR - ASSIGN REQUEST TO NDR.  #
  
      BEGIN  # ASGNDR # 
  
# 
**    ASGNDR  - ASSIGN REQUEST TO NDR.
* 
*     ASSIGN REQUEST TO NDR.
* 
*     PROC ASGNDR(REQASSIGNED,NOSTATUS) 
* 
*     ENTRY   - NAD$ENTRY IS BASED ARRAY CONTAINING LOCAL NAD ENTRY.
*               NDR$COMMUN IS BASED ARRAY CONTAINING NDR COMMUN. AREA.
*               NAD$Q CONTAINS ENTRY TO PROCESS.
*               NOSTATUS IS TRUE IF NO STATUS IS DESIRED. 
* 
*     EXIT    - REQASSIGNED IS TRUE IF REQUEST ASSIGNED.
*               REQASSIGNED IS FALSE IF NO REQUEST ASSIGNED.
* 
*     PROCESS - SAVE APL$HEADER AND CONNECTION POINTERS.
*               SET REQUEST FOUND TO FALSE. 
*               WHILE NO REQUEST FOUND
*                 AND (NOSTATUS AND NON-STATUS REQUEST QUEUED 
*                      OR NOT NOSTATUS AND REQUEST QUEUED)
*               THEN: 
*                 SET REQUEST FOUND TO TRUE.
*                 DELINK NEXT NAD REQUEST.
*                 IF STATUS REQUEST AND OTHER REQUESTS ARE QUEUED 
*                 THEN: 
*                   RELINK STATUS REQUEST.
*                   DELINK NEXT NAD REQUEST.
*                 DEPENDING ON WHICH REQUEST TYPE:  
*                   CASE (UCP REQUEST): 
*                     IF CONNECTION BROKEN
*                     THEN: 
*                       SET REQUEST FOUND TO FALSE. 
*                     ELSE: 
*                       INITIALIZE PATH ID, ACN, AND JOB ORDINAL. 
*                       IF CHANNEL MAY BE DEDICATED AND (ONLY ONE NDR 
*                         ALLOWED ON CHANNEL OR ONLY ONE ACTIVE 
*                         CONNECTION) 
*                       THEN: 
*                         SET NDR CHANNEL DEDICATED FLAG. 
*                       ELSE: 
*                         CLEAR NDR CHANNEL DEDICATED FLAG. 
*                       IF NETPUT 
*                       THEN: 
*                         SET WRITE PATH DATA FUNCTION. 
*                       ELSE: 
*                         IF NOT NETXFR 
*                         THEN: 
*                           INITIALIZE ACT. 
*                           CREATE ACK QUEUE ENTRY. 
*                           SET READ PATH DATA FUNCTION.
*                         ELSE: 
*                           INITIALIZE FET ADDRESS AND RETRY COUNTER. 
*                           VALIDATE FET FUNCTION.
*                           IF VALID FUNCTION 
*                           THEN
*                             SET PROPER FET I/O FUNCTION.
*                           ELSE
*                             QUEUE AN ERROR LOGICAL MESSAGE. 
*                             FREE QUEUE ENTRY. 
*                             SET REQUEST NOT FOUND FLAG. 
*                   CASE (ACKNOWLEDGE MESSAGE): 
*                     IF CONNECTION BROKEN
*                     THEN: 
*                       SET REQUEST FOUND TO FALSE. 
*                     ELSE: 
*                       INITIALIZE PATH ID AND MESSAGE BYTE LENGTH. 
*                       SET SEND CONTROL MESSAGE FUNCTION.
*                   CASE (OUTGOING CONTROL MESSAGE):  
*                     IF CONNECTION BROKEN
*                     THEN: 
*                       SET REQUEST FOUND TO FALSE. 
*                     ELSE: 
*                       INITIALIZE PATH ID AND MESSAGE BYTE LENGTH. 
*                       SET SEND CONTROL MESSAGE FUNCTION.
*                   CASE (REQUEST CONNECTION):  
*                     SET REQUEST CONNECTION FUNCTION.
*                   CASE (OBTAIN CONNECT REQUEST):  
*                     SET OBTAIN CONNECT REQUEST FUNCTION.
*                   CASE (DISCONNECT PATH): 
*                     INITIALIZE PATH ID. 
*                     SET DISCONNECT PATH FUNCTION. 
*                   CASE (FLUSH PATH):  
*                     INITIALIZE PATH ID. 
*                     SET FLUSH PATH FUNCTION.
*                   CASE (INITIALIZE NAD):  
*                     SET INITIALIZE NAD FUNCTION.
*                   CASE (STATUS):  
*                     SET STATUS FUNCTION.
*                   CASE  (SELECT CONVERT MODE):  
*                     INITIALIZE PATH ID. 
*                     SET CONVERT MODE TYPE.
*                     SET SELECT CONVERT MODE FUNCTION. 
*                   CASE  (EXIT CONVERT MODE):  
*                     INITIALIZE PATH ID. 
*                     SET EXIT CONVERT MODE FUNCTION. 
*                 IF REQUEST FOUND
*                 THEN: 
*                   INCREMENT NDRS ASSIGNED TO NAD. 
*                   CLEAR REQUEST AND DROP INTERLOCK FLAG.
*                   INITIALIZE QUEUE ENTRY ADDRESS, LOCAL NAD ORDINAL,
*                     CHANNEL, AND EST ORDINAL. 
*                   CLEAR REPLY WORD TO START NDR PROCESS.
*                 ELSE: 
*                   IF A LOGIC ERROR WAS NOT ENCOUNTERED
*                   THEN
*                     GRACEFULLY TERMINATE FUNCTION AFTER CON BREAK.
*               RESTORE APL$HEADER AND CONNECTION POINTERS. 
*               SET REQASSIGNED TO REQUEST FOUND STATE. 
*               RETURN. 
# 
  
      ITEM REQASSIGNED B;            # REQUEST ASSIGNED STATUS #
      ITEM NOSTATUS B;               # NO STATUS DESIRED FLAG # 
  
# 
****  PROC ASGNDR - XREF LIST BEGIN.
# 
      XREF
        BEGIN 
        PROC DEQUEUE;                # DEQUEUE #
        PROC QUEUE;                  # QUEUE #
        PROC ACKQ;                   # CREATE ACKNOWLEDGE QUEUE ENTRY # 
        PROC VFETFNC;                # VALIDATE FET FUNCTION #
        PROC QERRLGL;                # QUEUE AN ERROR LOGICAL MESS. # 
        PROC FREE;                   # PLACE QUEUE ENTRY ON FREE Q #
        PROC REQUECS;                # GRACEFULLY FREE ENTRY #
        PROC NDRRSTR;                # NDR RESTART #
        END 
  
# 
****  PROC ASGNDR - XREF LIST END.
# 
  
  
      ITEM APLADR I;                 # SAVE APL$HEADER POINTER #
      ITEM CONNECT I;                # SAVE CONNECTION POINTER #
      ITEM FETFUNCOD  I;             # VALIDATE FET FUNCTION #
      ITEM FETSFCODE  I;             # FET SUB-FUNCTION FOR NDR # 
      ITEM LOGICERROR B;             # LOGIC ERROR ENCOUNTERED #
      ITEM NDRFUNCODE I;             # NDR FUNCTION CODE #
      ITEM REQFND B;                 # REQUEST FOUND FLAG # 
      ITEM VALFUNC    B;             # VALID  FET FUNCTION FLAG # 
  
      SWITCH FUNCTION 
             UCPREQ,                 # LABEL FOR UCP REQUEST #
             ACKMSG,                 # LABEL FOR ACK MESSAGE #
             OUTCTL,                 # LABEL FOR OUTGOING CONTROL MSG # 
             REQCON,                 # LABEL FOR REQUEST CONNECTION # 
             OBTCONR,                # LABEL FOR OBTAIN CONNECT REQ # 
             DISCON,                 # LABEL FOR DISCONNECT PATH #
             FLUSH,                  # LABEL FOR FLUSH PATH # 
             INITNAD,                # LABEL FOR INITIALIZE NAD # 
             STATUSF,                # LABEL FOR STATUS # 
             SELCM,                  # SELECT CONVERT MODE #
             EXITCM,                 # EXIT CONVERT MODE #
             ;
  
CONTROL EJECT;
  
      CONNECT = P<CONNECTION>;
      APLADR = P<APL$HEADER>; 
      REQFND = FALSE; 
      ASLONGAS NOT REQFND 
        AND ( NAD$QCOUNT GR 1 
        OR ( NAD$QCOUNT EQ 1
        AND ( NOT NOSTATUS
        OR NOT NAD$STATQ )))
      DO
        BEGIN 
        REQFND = TRUE;
        LOGICERROR = FALSE; 
        DEQUEUE(LOC(NAD$Q));
        NAD$QCOUNT = NAD$QCOUNT - 1;
        IF QU$TYPE EQ QT$STATUS 
          AND NAD$QCOUNT NQ 0 
        THEN
          BEGIN  # EXCHANGE STATUS REQUEST WITH NEXT REQUEST #
          QUEUE(LOC(NAD$Q));
          DEQUEUE(LOC(NAD$Q));
          END 
  
# 
*       PROCESS REQUESTED FUNCTION THRU SIMULATED CASE STATEMENT. 
# 
  
        GOTO FUNCTION[QU$TYPE-QU$FRSTNDR];
  
UCPREQ:                              # UCP REQUEST #
        P<APL$HEADER> = QU$APLADR;
        P<CONNECTION> = P<APL$HEADER> + APL$LENGTH +
                        (QU$UCPACN - APL$MINACN) * CON$LENGTH;
        IF CON$BROKEN 
        THEN
          BEGIN 
          REQFND = FALSE; 
          END 
  
        ELSE
          BEGIN 
          NDR$PATHID = CON$PATHID;
          NDR$ACN = QU$UCPACN;
          NDR$JDTORD = APL$JOBORD;
          IF NAD$CHDED AND (NAD$MAXNDR EQ 1 OR NAD$CCOUNT EQ 1) 
          THEN
            BEGIN  # CHANNEL DEDICATED DURING ENTIRE FUNCTION # 
            NDR$CHDED = TRUE; 
            END 
  
          ELSE
            BEGIN  # CHANNEL CAN BE RELEASED BETWEEN DATA BLOCKS #
            NDR$CHDED = FALSE;
            END 
  
          IF QU$FUNCT EQ UCP$NETPUT 
          THEN
            BEGIN  # WRITE #
            NDRFUNCODE = NF$WRITE;
            END 
  
          ELSE
            BEGIN 
            IF QU$FUNCT NQ UCP$NETXFR 
            THEN
              BEGIN  # READ # 
              NDR$ACT = CON$ACT;
              ACKQ; 
              NDRFUNCODE = NF$READ; 
              END 
  
            ELSE
              BEGIN  # FET I/O #
              NDR$FETADR = QU$FETADR; 
              NDR$RETRY = QU$RETRY; 
              VFETFNC(VALFUNC,FETFUNCOD,FETSFCODE); 
              IF VALFUNC
              THEN
                BEGIN 
                NDRFUNCODE = FETFUNCOD; 
                NDR$FETSFC = FETSFCODE; 
                END 
  
              ELSE
                BEGIN 
                QERRLGL(LGL$INVNXF,0,QU$FETADR,0,0,QU$WD4,QU$WD5);
                FREE; 
                LOGICERROR = TRUE;
                REQFND = FALSE; 
                END 
  
              END 
  
            END 
  
          END 
  
        GOTO ENDCASE; 
  
ACKMSG:                              # ACKNOWLEDGE MESSAGE #
OUTCTL:                              # OUTGOING CONTROL MESSAGE # 
        P<APL$HEADER> = QU$APPL;
        P<CONNECTION> = P<APL$HEADER> + APL$LENGTH +
                        (QU$ACN - APL$MINACN) * CON$LENGTH; 
        IF CON$BROKEN 
        THEN
          BEGIN 
          REQFND = FALSE; 
          END 
  
        ELSE
          BEGIN 
          NDR$PATHID = CON$PATHID;
          NDR$BYLGTH = (QU$CTLLGTH + 11) / 12;
          NDRFUNCODE = NF$SNDCTL; 
          END 
  
        GOTO ENDCASE; 
  
REQCON:                              # REQUEST CONNECTION # 
        NDRFUNCODE = NF$REQCON; 
        GOTO ENDCASE; 
  
OBTCONR:                             # OBTAIN CONNECT REQUEST # 
        NDRFUNCODE = NF$OBTCONR;
        GOTO ENDCASE; 
  
DISCON:                              # DISCONNECT PATH #
        NDR$PATHID = QU$PATHID; 
        NDRFUNCODE = NF$DISCON; 
        GOTO ENDCASE; 
  
FLUSH:                               # FLUSH PATH # 
        NDR$PATHID = QU$PATHID; 
        NDRFUNCODE = NF$FLUSH;
        GOTO ENDCASE; 
  
INITNAD:                             # INITIALIZE NAD # 
        NDRFUNCODE = NF$INITNAD;
        NDR$CMCSF = QU$CMCSF; 
        NDR$CMPATH = QU$CMPATHS;
        NDR$CMBUFF = QU$CMBUFFS;
        GOTO ENDCASE; 
  
STATUSF:                             # STATUS NAD # 
        NDRFUNCODE = NF$STATUS; 
        GOTO ENDCASE; 
  
SELCM:  
        NDR$PATHID = QU$PATHID; 
        NDR$CMTYPE = QU$CMTYPE; 
        NDRFUNCODE = NF$SELCM;
        GOTO ENDCASE; 
  
EXITCM: 
        NDR$PATHID = QU$PATHID; 
        NDRFUNCODE = NF$EXITCM; 
        GOTO ENDCASE; 
  
# 
*     END OF SIMULATED CASE STATEMENT.
# 
ENDCASE:  
        IF REQFND 
        THEN
          BEGIN  # FINISH NDR ASSIGNMENT #
          NAD$NDRASG = NAD$NDRASG + 1;
          REQ$DROPIL = FALSE; 
          NDR$QADDR = P<QU$ADDRESS>;
          NDR$NADORD = NAD$ORD; 
          NDR$CHAN = NAD$CHAN;
          NDR$ESTORD = NAD$ESTORD;
          NDR$FUNC = NDRFUNCODE;
          NDRRSTR;
          END 
  
        ELSE
          BEGIN 
          IF NOT LOGICERROR 
          THEN
            BEGIN  # GRACEFULLY END REQUEST ON CON. BREAK # 
            REQUECS;
            END 
  
          END 
  
        END 
  
      REQASSIGNED = REQFND; 
      P<CONNECTION> = CONNECT;
      P<APL$HEADER> = APLADR; 
      RETURN; 
      END  # ASGNDR # 
  
      TERM
