*DECK CKESTAT 
USETEXT COMCBEG 
USETEXT COMRNET 
USETEXT COMRQUE 
USETEXT COMRSTA 
USETEXT COMRNDR 
USETEXT COMRFLS 
PROC CKESTAT; 
# TITLE CKESTAT - CHECK FOR CHANGE OF EST STATUS. # 
  
      BEGIN  # CKESTAT #
  
# 
**    CKESTAT - CHECK FOR CHANGE OF EST STATUS. 
* 
*     ISSUES INITIALIZE NAD FUNCTION IF NAD EST STATUS HAS CHANGED
*     FROM OFF TO ON. 
* 
*     PROC CKESTAT. 
* 
*     ENTRY   -  NAD$ENTRY IS BASED ARRAY CONTAINING LOCAL NAD ENTRY. 
* 
*     EXIT    -  NAD INITIALIZED IF EST STATUS CHANGED FROM OFF TO ON.
* 
*     PROCESS -  IF EST ON AND CONTROLWARE SHOULD BE LOADED FLAG SET
*                  SET NAD STATE = LOAD REQUIRED
*                  QUEUE MESSAGE TO MHF.
*                IF EST CURRENTLY ON AND IT WAS OFF 
*                THEN:  
*                  SET NAD STATE = AVAILABLE. 
*                  CLEAR PREVIOUSLY OFF FLAG
*                  GET FREE QUEUE ENTRY 
*                  SET UP QUEUE ENTRY FOR INITIALIZE NAD FUNCTION 
*                  IF CONVERT MODE IS TO BE ENABLED 
*                  THEN 
*                    SET CONVERT MODE ENABLE PARAMETERS.
*                    SET ENABLE CONVERT MODE SUB-FUNCTION.
*                  ELSE 
*                    SET SUB-FUNCTION TO NORMAL INITIALIZE. 
*                  SET UP COMPLETION STATUS WORD
*                  ISSUE INITIALIZE NAD REQUEST 
*                  WAIT FOR COMPLETION
*                  PROCESS RETURN CODE. 
*                IF NAD STATE CHANGED 
*                  CALL MHFMSG TO UPDATE NAD STATE. 
*                RETURN.
* 
****  PROC CKESTAT - XREF LIST BEGIN. 
# 
  
      XREF
        BEGIN 
        PROC GETFREE;                # OBTAIN FREE GUEUE ENTRY #
        PROC MHFMSG;                 # UPDATE MHF-S NDT # 
        PROC NADREQ;                 # INITIATE NAD REQUEST # 
        PROC UPDNWS;
        PROC WAIT;                   # WAIT FOR COMPLETION #
        PROC RHFMSG;                 # DAYFILE MESSAGE #
        FUNC BINTOHD C(10);          # CONVERT BIN TO HEX DISPLAY # 
        FUNC BINTOOD C(10);          # CONVERT BIN TO OCT DISPLAY # 
        END 
  
# 
****  PROC CKESTAT - XREF LIST END. 
# 
  
  
      ITEM COMPSTAT I;               # COMPLETION STATUS WORD # 
      ITEM NADINIT   B;              # NAD INITIALIZED  # 
      ITEM NSTCHANGE  B;             # NST STATE CHANGE # 
  
      SWITCH NADRTN 
             INITIALIZD,             # LABEL FOR NAD INITIALIZED #
             NADOFF,                 # LABEL FOR NAD TURNED OFF BY NDR #
             ESTUNUSABL,             # NAD BIT DOES NOT ALLOW OPERATION#
             CODCONENAB,             # CODE CONVERSION ENABLED #
             CODCONNAVL,             # CODE CONVERSION NOT AVAIL. # 
             INITFAILED,             # INITIALIZATION FAILED #
             ;
    CONTROL IFEQ OS$NOS;
      ITEM NADTYPE   B = TRUE;       # NAD ORDINAL TYPE  #
      ITEM UPDSTAT   I = NW$PTHSUP;  # PATH STATUS  # 
      ITEM UPDORD    I;              # NAD ORDINAL  # 
    CONTROL ENDIF;
  
CONTROL EJECT;
  
      P<NST$ENTRY> = LOC(NAD$NSTWD0);  # NAD STATUS ENTRY # 
      NSTCHANGE    = FALSE; 
      IF NAD$CWSBL                   # CONTROLWARE SHOULD BE LOADED # 
        AND NST$AUTOL 
        AND (   (NST$STATE EQ NS$AVAIL) 
             OR (NST$STATE EQ NS$DISAB) ) 
      THEN
        BEGIN 
        NST$STATE = NS$LDREQ; 
        NSTCHANGE = TRUE; 
        END 
  
      IF NOT NAD$ESTOFF AND NAD$PREVOF
      THEN
        BEGIN  # NAD EST STATUS CHANGE OFF TO ON #
        NST$STATE = NS$AVAIL;      # SET NAD STATE AVAILABLE #
        NSTCHANGE = TRUE; 
        GETFREE;
        COMPSTAT = 0; 
        QU$TYPE = QT$INITNAD; 
        NAD$CMPA = 0; 
        NAD$CME = FALSE;
        IF NAD$CMPATH NE 0
        THEN
          BEGIN 
          QU$CMPATHS = NAD$CMPATH;
          QU$CMBUFFS = NAD$CMBUFF;
          QU$CMCSF   = ENACONMODE;
          END 
  
        ELSE
          BEGIN 
          QU$CMCSF = NOCONMODE; 
          END 
  
        QU$CMPST = LOC(COMPSTAT); 
        NADREQ(NAD$ORD);             # INITIALIZE NAD # 
        WAIT(LOC(COMPSTAT));
        P<CST$ADDR> = LOC(COMPSTAT);
        NADINIT = FALSE;
  
# 
*     PROCESS INITIALIZE NAD RETURN CODE THRU SIMULATED CASE. 
# 
  
        GOTO NADRTN[CST$RTNCOD];
  
INITIALIZD: 
        NAD$PREVOF = FALSE; 
        NADINIT = TRUE; 
        GOTO ENDCASE; 
  
NADOFF: 
        GOTO ENDCASE; 
  
ESTUNUSABL: 
        NAD$ESTOFF = TRUE;
        NST$STATE = NS$DISAB;      # DISABLE NAD #
        NSTCHANGE = TRUE; 
        GOTO ENDCASE; 
  
CODCONENAB: 
          NAD$PREVOF = FALSE; 
          NADINIT = TRUE; 
          NAD$CMPA = CST$CMPATH;
          NAD$CME = TRUE; 
          CME$BUFF = BINTOHD(CST$CMBUFF,2); 
          CME$PATH = BINTOHD(CST$CMPATH,2); 
          CME$EST = BINTOOD(NAD$ESTORD,3);
          RHFMSG(LOC(CONMODEN),CME$LENGTH); 
          GOTO ENDCASE; 
  
CODCONNAVL: 
          NAD$PREVOF = FALSE; 
          NADINIT = TRUE; 
          CMN$EST = BINTOOD(NAD$ESTORD,3);
          RHFMSG(LOC(CONMODNA),CMN$LENGTH); 
          GOTO ENDCASE; 
  
INITFAILED: 
          NAD$ESTOFF = TRUE;
          NAD$PREVOF = TRUE;
          NST$STATE = NS$LDREQ; 
          NSTCHANGE = TRUE; 
          GOTO ENDCASE; 
ENDCASE:  
  
# 
*     END OF SIMULATED CASE STATEMENT.
# 
  
      CONTROL IFEQ OS$NOS;
        IF NADINIT
        THEN
          BEGIN 
          UPDORD=NAD$ORD; 
          UPDNWS(UPDSTAT,UPDORD,NADTYPE); 
          END 
  
      CONTROL ENDIF;
  
        END 
  
      IF NSTCHANGE
      THEN
        BEGIN 
        MHFMSG (LOC(NST$STATE));  # UPDATE NAD STATE #
        END 
      RETURN; 
      END  # CKESTAT #
  
      TERM
  
