*DECK NADFUNC 
USETEXT COMCBEG 
USETEXT COMRNET 
USETEXT COMRNDR 
PROC NADFUNC; 
# TITLE NADFUNC - DETERMINE NEXT NAD FUNCTION.  # 
  
      BEGIN  # NADFUNC #
  
# 
**    NADFUNC - DETERMINE NEXT NAD FUNCTION.
* 
*     DETERMINE NEXT NAD FUNCTION.
* 
*     ENTRY   - NDR$COMMUN IS BASED ARRAY CONTAINING NDR COMMON. AREA.
* 
*     EXIT    - NDR HAS BEEN ASSIGNED NEXT FUNCTION.
* 
*     PROCESS - FOR EACH ACTIVE NDR:  
*                 IF STATUS OR SHORT IDLE FUNCTION
*                 THEN: 
*                   SAVE STATUS NDR ADDRESS.
*                   SET STATUS ACTIVE.
*               RESTORE NDR POINTER TO CURRENT NDR. 
*               IF STATUS NOT ACTIVE. 
*               THEN: 
*                 IF LAST FUNCTION IS START 
*                 THEN: 
*                   SET STATUS RECALL TO DROP IN ONE ITERATION. 
*                 ELSE: 
*                   CLEAR STATUS RECALL COUNT.
*               IF LAST FUNCTION IS SHORT IDLE
*                 OR STATUS NOT ACTIVE
*               THEN: 
*                 FOR EACH LOCAL NAD: 
*                   SET STATUS NOT TAKEN. 
*               IF LAST FUNCTION IS (STATUS OR SHORT IDLE)
*                 OR STATUS NOT ACTIVE
*               THEN: 
*                 FOR EACH LOCAL NAD WHILE REQUEST NOT FOUND: 
*                   IF STATUS QUEUED AND STATUS NOT TAKEN 
*                     AND ANOTHER NDR ALLOWED ON CHANNEL
*                     AND ( CHANNEL MAY NOT BE DEDICATED
*                     OR MULTIPLE CONNECTIONS ARE ACTIVE
*                     OR NO NDR IS ASSIGNED ) 
*                   THEN: 
*                     SET REQUEST FOUND.
*                     ASSIGN NDR TO LOCAL NAD.
*                 IF REQUEST NOT FOUND
*                 THEN: 
*                   INCREMENT STATUS RECALL COUNT.
*                   IF TOO LONG SINCE LAST ACTUAL WORK
*                   THEN: 
*                     SET DROP FUNCTION.
*                   ELSE: 
*                     IF MORE SHORT IDLES ALLOWED 
*                     THEN: 
*                       SET VERY SHORT IDLE.
*                     ELSE: 
*                       SET SHORT IDLE. 
*                   CLEAR FUNCTION COMPLETED. 
*               ELSE: 
*                 SET LONG IDLE FUNCTION. 
*                 CLEAR FUNCTION COMPLETED. 
*                 POINT TO STATUS NDR.
*                 CLEAR STATUS RECALL COUNT.
*               RETURN. 
# 
  
# 
****  PROC NADFUNC - XREF LIST BEGIN. 
# 
  
      XREF
        BEGIN 
        PROC ASGNDR;                 # ASSIGN REQUEST TO NDR #
        PROC NDRRSTR;                # NDR RESTART #
        ITEM NDRCOM  I;              # NDR COMMUNICATION AREA # 
        ITEM NADTBL  I;              # NAD TABLE ADDRESS #
        ITEM MAXNDRS I;              # MAXIMUM NDRS # 
        ITEM NUMNADS I;              # NUMBER OF LOCAL NADS # 
        END 
  
# 
****  PROC NADFUNC - XREF LIST END. 
# 
  
      ITEM CURRENTNDR I;             # CURRENT NDR ADDRESS #
      ITEM STATUSACT  B;             # STATUS ACTIVE #
      ITEM I          I;             # LOOP CONTROL VARIABLE #
      ITEM STATUSNDR  I;             # STATUS NDR ADDRESS # 
      ITEM REQUESTFND B;             # REQUEST FOUND #
      ITEM NOSTATUS   B = FALSE;     # STATUS DESIRED # 
  
  
CONTROL EJECT;
  
      CURRENTNDR = P<NDR$COMMUN>; 
      STATUSACT = FALSE;
      FASTFOR I=0 STEP NDR$LENGTH WHILE I LS MAXNDRS * NDR$LENGTH 
      DO
        BEGIN  # FIND ANY STATUS ACTIVE # 
        P<NDR$COMMUN> = NDRCOM + I; 
        IF NDR$FUNC EQ NF$STATUS
          OR (NDR$FUNC EQ NF$IDLE 
          AND NDR$IDLTIM LS LONGIDLE )
        THEN
          BEGIN  # STATUS NDR FOUND # 
          STATUSNDR = P<NDR$COMMUN>;
          STATUSACT = TRUE; 
          END 
  
        END 
  
      P<NDR$COMMUN> = CURRENTNDR; 
      IF NOT STATUSACT
      THEN
        BEGIN  # STATUS NOT ACTIVE #
        IF NDR$FUNC EQ NF$START 
        THEN
          BEGIN  # SET RECALL TO DROP IN TWO ITERATIONS # 
          NDR$RECALL = MAXRECALLS - 2;
          END 
  
        ELSE
          BEGIN  # CLEAR RECALL COUNT # 
          NDR$RECALL = 0; 
          END 
  
        END 
  
      IF NOT STATUSACT
        OR NDR$FUNC EQ NF$IDLE
      THEN
        BEGIN  # FOR EACH NAD CLEAR STATUS TAKEN #
        FASTFOR I=0 STEP NAD$LENGTH WHILE I LS NUMNADS * NAD$LENGTH 
        DO
          BEGIN 
          P<NAD$ENTRY> = NADTBL + I;
          NAD$STATTK = FALSE; 
          END 
  
        END 
  
      IF NOT STATUSACT
        OR NDR$FUNC EQ NF$STATUS
        OR NDR$FUNC EQ NF$IDLE
      THEN
        BEGIN  # PROCESS ANY REQUIRED STATUS #
        REQUESTFND = FALSE; 
        FASTFOR I=0 STEP NAD$LENGTH WHILE I LS NUMNADS*NAD$LENGTH 
          AND NOT REQUESTFND
        DO
          BEGIN  # EXAMINE NEXT NAD # 
          P<NAD$ENTRY> = NADTBL + I;
          IF NAD$STATQ
            AND NOT NAD$STATTK
            AND NAD$NDRASG LS NAD$MAXNDR
            AND ( NOT NAD$CHDED 
            OR NAD$CCOUNT GT 1
            OR NAD$NDRASG EQ 0 )
          THEN
            BEGIN  # PROCESS STATUS # 
            ASGNDR(REQUESTFND,NOSTATUS);
            NAD$STATTK = TRUE;
            REQUESTFND = TRUE;
            END 
  
          END 
  
        IF NOT REQUESTFND 
        THEN
          BEGIN  # INCREMENT RECALL COUNT # 
          NDR$RECALL = NDR$RECALL + 1;
          IF NDR$RECALL EQ MAXRECALLS 
          THEN
            BEGIN  # TOO LONG SINCE LAST WORK SO DROP # 
            NDR$FUNC = NF$DROP; 
            END 
  
          ELSE
            BEGIN  # DETERMINE IDLE TIME #
            IF NDR$RECALL LQ SHORTRECAL 
            THEN
              BEGIN  # SET VERY SHORT IDLE TIME # 
              NDR$IDLTIM = VERYSHORT; 
              END 
  
            ELSE
              BEGIN  # SET SHORT IDLE TIME #
              NDR$IDLTIM = SHORTIDLE; 
              END 
  
            NDR$FUNC = NF$IDLE; 
            END 
  
          NDRRSTR;
          END 
  
        END 
  
      ELSE
        BEGIN  # LONG IDLE #
        NDR$IDLTIM = LONGIDLE;
        NDR$FUNC = NF$IDLE; 
        NDRRSTR;
        P<NDR$COMMUN> = STATUSNDR;
        NDR$RECALL = 0; 
        END 
  
      RETURN; 
      END  # NADFUNC #
  
      TERM
