*DECK NXTNADR 
USETEXT COMCBEG 
USETEXT COMRNET 
USETEXT COMRNDR 
PROC NXTNADR; 
# TITLE NXTNADR - LOCATE NEXT NAD REQUEST.  # 
  
      BEGIN  # NXTNADR #
  
# 
**    NXTNADR - LOCATE NEXT NAD REQUEST.
* 
*     LOCATE NEXT NAD REQUEST.
* 
*     ENTRY   - NDR$COMMUN IS BASED ARRAY CONTAINING NDR COMMUN. AREA.
* 
*     EXIT    - NDR HAS BEEN GIVEN THE NEXT REQUEST.
* 
*     PROCESS - CLEAR REQUEST FOUND.
*               FOR EACH LOCAL NAD WHILE REQUEST NOT FOUND: 
*                 IF ANY NON-STATUS REQUEST QUEUED
*                 THEN: 
*                   ASSIGN REQUEST TO NDR.
*                   SET REQUEST FOUND.
*               IF REQUEST NOT FOUND
*               THEN: 
*                 IF LAST FUNCTION IS LONG IDLE 
*                 THEN: 
*                   SET DROP FUNCTION.
*                   CLEAR NDR FUNCTION COMPLETED. 
*                 ELSE: 
*                   CALL TO DETERMINE NEXT NAD FUNCTION.
# 
  
# 
****  PROC NXTNADR - XREF LIST BEGIN. 
# 
      XREF
        BEGIN 
        PROC ASGNDR;                 # ASSIGN REQUEST TO NDR #
        PROC NADFUNC;                # DETERMINE NEXT NAD FUNCTION #
        PROC NDRRSTR;                # NDR RESTART #
        ITEM NADTBL  I;              # NAD TABLE ADDRESS #
        ITEM NUMNADS I;              # NUMBER OF LOCAL NADS # 
        END 
  
# 
****  PROC NXTNADR - XREF LIST END. 
# 
  
  
      ITEM REQUESTFND B;             # REQUEST FOUND #
  
      ITEM LSTNADPROC I;             # LAST NAD PROCESSED # 
      ITEM DONE       B;             # SEARCH DONE #
      ITEM LASTNAD    I;             # LAST NAD ADDRESS # 
      ITEM NOSTATUS B = TRUE;        # NO STATUS REQUIRED # 
CONTROL EJECT;
  
      IF LSTNADPROC LS NADTBL 
      THEN
        BEGIN  # SET LAST NAD PROCESSED TO FIRST NAD #
        LSTNADPROC = NADTBL;
        END 
  
      LASTNAD = NADTBL +(NUMNADS - 1) * NAD$LENGTH; 
      P<NAD$ENTRY> = LSTNADPROC + NAD$LENGTH; 
      DONE = FALSE; 
      REQUESTFND = FALSE; 
      ASLONGAS NOT DONE AND NOT REQUESTFND
      DO
        BEGIN  # SEARCH EACH LOCAL NAD FOR A NON STATUS REQUEST # 
        IF P<NAD$ENTRY> GR LASTNAD
        THEN
          BEGIN  # POINT TO FIRST NAD # 
          P<NAD$ENTRY> = NADTBL;
          END 
  
        IF P<NAD$ENTRY> EQ LSTNADPROC 
        THEN
          BEGIN  # POINTING TO LAST NAD OF SEARCH # 
          DONE = TRUE;
          END 
  
        IF NAD$NDRASG LS NAD$MAXNDR 
        THEN
          BEGIN  # ASSIGN REQUEST TO NDR #
          ASGNDR(REQUESTFND,NOSTATUS);
          END 
  
        IF REQUESTFND 
        THEN
          BEGIN 
          LSTNADPROC = P<NAD$ENTRY>;
          END 
  
        ELSE
          BEGIN  # POINT TO NEXT NAD ENTRY #
          P<NAD$ENTRY> = P<NAD$ENTRY> + NAD$LENGTH; 
          END 
  
        END 
  
      IF NOT REQUESTFND 
      THEN
        BEGIN  # NO WORK FOUND #
        IF NDR$FUNCOM EQ NF$IDLE
          AND NDR$IDLTIM EQ LONGIDLE
        THEN
          BEGIN  # LAST FUNCTION LONG IDLE SO DROP NDR #
          NDR$FUNC = NF$DROP; 
          NDRRSTR;
          END 
  
        ELSE
          BEGIN  # DETERMINE NEXT NAD FUNCTION #
          NADFUNC;
          END 
  
        END 
  
      RETURN; 
      END  # NXTNADR #
  
      TERM
