*DECK     CSSAGO
USETEXT TEXTCS; 
USETEXT TEXTSS; 
USETEXT TXTSMCS;
USETEXT TXTAPSS;
USETEXT TXTSUSS;
USETEXT TXCMDCS;
PROC CSSAGO;
# TITLE CSSAGO - ACTION GO COMMAND #
 
      BEGIN # CSSAGO #
 
# 
**    CSSAGO - ACTION GO COMMAND. 
* 
*     C. BRION          82/04/15. 
* 
*     THIS PROCEDURE PROCESSES THE GO COMMAND FROM AN OPERATOR. 
* 
*     PROC CSSAGO 
* 
*     ENTRY:  
*       HDRCMD = COMMAND HEADER WORD. 
*       PARMS = ARRAY THAT CONTAINS THE COMMAND TEXT, THE SYNTAX PARAM- 
*               ETER LIST, THE ADDRESS PARAMETER LIST.
* 
*     EXIT: 
*       A SUP/GO/N SM IS SENT TO THE APPROPRIATE NPU. 
*       THE COMMAND TEXT IS SENT TO THE LOG FILE VIA AN EVENT TO THE
*       EVENT PROCESSOR QUEUE.
* 
# 
 
# 
****  PROC CSSAGO XREF LIST 
# 
 
      XREF
        BEGIN 
        PROC SSCCTR;                     # SS-CANCEL TIMER REQUEST #
        PROC SSTAQE;                     # SS-ACCEPT QUEUE ENTRY #
        PROC MOVE;                       # MACREL MOVE MEMORY # 
        END 
 
# 
****
# 
 
# 
*     PROC CSSAGO ITEMS 
# 
 
      ITEM NPUORD       U;               # NPUCB ORDINAL #
      ITEM I            U;
      ITEM BEGAPIX      U;               # START ADDR LIST INDEX #
      ITEM BEGNPU       I;               # START NPUCB #
      ITEM FINAPIX      U;               # END ADDR LIST INDEX #
      ITEM FINNPU       I;               # END NPUCB #
      ITEM SUCCESS      B;               # FLAG SET AFTER CANCEL TIMER #
 
 
 
 
 
# 
*     PROC CSSAGO EXECUTION STARTS HERE 
# 
 
# 
*     INITIALIZE THE OUTGOING ENTRY STORAGE AREAS AND LOCAL VARS. 
# 
 
      WCB$WORD[1] = 0;
      ABHWORD[1] = 0; 
      SPMSG0[1] = 0;
      NPUORD = 0; 
 
# 
*     SET THE ADDRESS LIST INDEX BOUNDS.
# 
 
      BEGAPIX = HDR$TXWCNT[0] + HDR$SPCNT[0]; 
      FINAPIX = HDR$APCNT[0] + BEGAPIX - 1; 
 
# 
*     IF THIS IS JUST FOR ONE NPU, THEN...
*     SEARCH THE COMMAND ADDRESS PARAMETER LIST OF PARMS ARRAY FOR AN 
*     NPU ORDINAL KEYWORD (NOR). SHOULD ALWAYS FIND THE KEYWORD.
# 
      IF BEGAPIX LQ FINAPIX 
      THEN
        BEGIN 
 
        FOR I = BEGAPIX STEP 1 WHILE
          PAR$PCODE[I] NQ "NOR" 
        DO
          BEGIN 
          END 
 
        NPUORD = PAR$ORD[I];             # SET NPUCB ORDINAL #
 
        BEGNPU = NPUORD;
        FINNPU = NPUORD;
        END 
 
# 
*     THE GO IS FOR ALL NPUS.  SET THE PARAMETERS TO CHECK ALL THE
*     NPUCB-S.
# 
      ELSE
        BEGIN 
        BEGNPU = 0; 
        FINNPU = CSNPCNT - 1; 
        END 
# 
*     SET UP THE ABH WORD FOR THE OUTGOING SUP/GO/N SM. 
# 
 
      ABHABT[1] = APPSUP; 
      ABHBT[1] = APPSUP;
      ABHACT[1] = ACTCSNP$; 
      ABHTLC[1] = NSUPGO; 
      PFCSFC[1] = SUPGON; 
 
# 
*     SET UP THE WORD COUNT WORD OF THE SM ENTRY TO THE OUTGOING
*     OPERATOR TRAFFIC QUEUE. 
# 
 
      WCB$SMID[1] = SMID"SUPGON"; 
      WCB$WC[1] = LSUPGO + 2; 
 
# 
*     SEND THE SM TO THE NPU(S).
# 
      FOR NPUORD=BEGNPU STEP 1 UNTIL FINNPU 
      DO
        BEGIN 
        IF NPU$STAT[NPUORD] EQ SUPSTAT"SUP" 
        THEN
          BEGIN 
          ABHDN[1] = NPU$NID[NPUORD]; 
          ABHSN[1] = NPU$HID[NPUORD]; 
 
          SSTAQE(P<OTQ>,WCBUF[1],ABH[1],CSSM[1]); 
 
          IF NPU$GFLAG[NPUORD]
          THEN
            BEGIN 
# 
*     CANCEL TIMER REQUEST AND CLEAR -NEED GO- FLAG IN THE NPUCB. 
# 
            SSCCTR(NPU$CNUM[NPUORD],SUCCESS); 
 
            NPU$GFLAG[NPUORD] = FALSE;
            END 
          END 
        END 
 
# 
*     SET UP TO SEND THE NULL TEXT TO THE OPERATOR TO CAUSE THE 
*     READY.. MESSAGE.
# 
 
      WCB$WORD[1] = 0;
      ABHWORD[1] = 0; 
      ABHADR[1] = HDR$OPORD[0]; 
      WCB$SMID[1] = SMID"TTEXT";
      WCB$IAF[1] = TRUE;
      WCB$WC[1] = 2;
      SSTAQE(P<CNQ>,WCBUF[1],ABH[1],CSSM[1]); 
 
# 
*     SET UP AND SEND THE EVENT ENTRY TO LOG THE TEXT.
# 
 
      WCB$WORD[1] = 0;
      ABHWORD[1] = 0; 
      WCB$SMID[1] = SMID"CMDTXT"; 
      WCB$WC[1] = HDR$TXWCNT[0] + 4;
      P<MSCMD> = LOC(CMD$TEXT[0]);
      CMD$TNAM[0] = OC$TNAM[HDR$OPORD[0]];
 
# 
*     MOVE THE TEXT INTO THE TEXT BUFFER. 
# 
 
      MOVE(HDR$TXWCNT[0],PARMS[0],MSCMD[0]);
 
      SSTAQE(P<EVQ>,WCBUF[1],ABH[1],CMDLINE[0]);
 
      END #CSSAGO#
 
 TERM