*DECK,OPRCMD
USETEXT COMCBEG 
USETEXT COMQDEF 
USETEXT COMQCMD 
USETEXT COMQKDS 
USETEXT COMQPAR 
      PROC OPRCMD(SOURCE);
        BEGIN    # OPRCMD # 
# 
**    OPRCMD     PROCESS OPERATOR COMMAND.
* 
*     OPRCMD PROCESSES ONE OPERATOR COMMAND.
* 
*     PROC OPRCMD(SOURCE) 
* 
*     ENTRY      SOURCE = SOURCE OF COMMAND INPUT:  
*                           "CFO"     = CFO INPUT,
*                           "DSD"     = K/L DISPLAY INPUT,
*                           "XXXXXXX" = READ FROM INCLUDE-FILE XXXXXXX. 
*                COMMAND = COMMAND TO BE PROCESSED. 
* 
*     EXIT       COMMAND PROCESSED. 
* 
*     PROCESS    CALL CMDPRSR TO PARSE COMMAND
*                SEND COMMAND TO OPERATOR DISPLAY 
*                SEARCH FOR MATCHING VERB 
*                PROCESS COMMAND OR ERROR.
* 
# 
  
      ITEM SOURCE    C(7);         # SOURCE OF COMMAND INPUT #
  
# 
****  XREF
# 
      XREF
        BEGIN 
        PROC CMDCLA;               # PROCESS *CLASS* COMMAND #
        PROC CMDDIS;               # PROCESS *DIS/ENABLE* COMMANDS #
        PROC CMDINC;               # PROCESS *INCLUDE* COMMAND #
        PROC CMDPRSR;              # COMMAND PARSER # 
        PROC CMDSCH;               # PROCESS *SCHED* COMMAND #
        PROC CMDSTA;               # PROCESS *STATUS* COMMAND # 
        PROC MSGLOG;               # LOG MESSAGE #
        PROC NAME;                 # DEBUG CODE # 
        PROC OPRMSG;               # SEND MESSAGE TO OPERATOR # 
        PROC UPDKDSP;              # UPDATE K-DISPLAY # 
        END 
  
# 
****  XREF END
# 
  
      STATUS CMDVERB
         NULL                      # NO VERB #
        ,AT                        # AT # 
        ,CLASS                     # CLASS #
        ,DISABLE                   # DISABLE #
        ,ENABLE                    # ENABLE # 
        ,HELP                      # HELP # 
        ,IDLE                      # IDLE # 
        ,INCLUDE                   # INCLUDE #
        ,SCHED                     # SCHED #
        ,STATUS                    # STATUS # 
        ,STOP                      # STOP # 
        ,TRACE                     # TRACE #
        ,PLUS                      # + #
        ,MINUS                     # - #
        ,LEFTP                     # ( #
        ,RIGHTP                    # ) #
        ,UNKNOWN                   # UNKNOWN #
        ; 
  
      ARRAY CMDTABLE [CMDVERB"NULL":CMDVERB"UNKNOWN"] S(1); 
        BEGIN 
        ITEM CMD$VERB   C(00,00,07) = 
          [ " "      , "AT"     , "CLASS"  , "DISABLE", "ENABLE", 
            "HELP"   , "IDLE"   , "INCLUDE", "SCHED"  , "STATUS", 
            "STOP"   , "TRACE"  , "+"      , "-"      , "("     , 
            ")"      ,
            "*******"]; 
  
        ITEM CMD$STAT   S:CMDVERB(00,42,06) = 
          [S"NULL"   ,S"AT"     ,S"CLASS"  ,S"DISABLE",S"ENABLE", 
           S"HELP"   ,S"IDLE"   ,S"INCLUDE",S"SCHED"  ,S"STATUS", 
           S"STOP"   ,S"TRACE"  ,S"PLUS"   ,S"MINUS"  ,S"LEFTP" , 
           S"RIGHTP" ,
           S"UNKNOWN"]; 
  
        ITEM CMD$MIN    U(00,48,03) = 
          [         0,         2,         1,         1,        1, 
                    1,         4,         2,         2,        2, 
                    4,         5,         1,         1,        1, 
                    1,
                    1]; 
        END 
  
      SWITCH SW$CMD:CMDVERB 
         SW$NULL   :NULL           # NO VERB #
        ,SW$AT     :AT             # AT # 
        ,SW$CLASS  :CLASS          # CLASS #
        ,SW$DISABLE:DISABLE        # DISABLE #
        ,SW$ENABLE :ENABLE         # ENABLE # 
        ,SW$HELP   :HELP           # HELP # 
        ,SW$IDLE   :IDLE           # IDLE # 
        ,SW$INCLUDE:INCLUDE        # INCLUDE #
        ,SW$SCHED  :SCHED          # SCHED #
        ,SW$STATUS :STATUS         # STATUS # 
        ,SW$STOP   :STOP           # STOP # 
        ,SW$TRACE  :TRACE          # TRACE #
        ,SW$PLUS   :PLUS           # + #
        ,SW$MINUS  :MINUS          # - #
        ,SW$LEFTP  :LEFTP          # ( #
        ,SW$RIGHTP :RIGHTP         # ) #
        ,SW$UNKNOWN:UNKNOWN        # UNKNOWN #
        ; 
  
      DEF LEMSGCMD   #28#;
      ARRAY EMSGCMD [STAT"OK":STAT"PARMERR"] S(3);
        BEGIN 
        ITEM EMSGCMDMSG C(00,00,28) = 
                 ["INCORRECT COMMAND."
                 ,"INCORRECT VERB." 
                 ,"*=* NOT VALID HERE." 
                 ,"INCORRECT SEPARATOR."
                 ,"INCORRECT CHARACTER."
                 ,"*..* NOT VALID HERE."
                 ,"ASTERISK NOT VALID HERE."
                 ,"INCORRECT RANGE VALUE."
                 ,"FILE NOT FOUND." 
                 ,"PID NOT DEFINED."
                 ,"INCORRECT SELECTION CLASS."
                 ,"INCORRECT PARAMETER."
                 ]; 
        ITEM EMSGCMDSTA S:STAT(02,48,12) =
                 [S"OK", S"VERBERR", S"EQUALERR", S"SEPERR", S"INVCHAR",
                  S"ELIPERR", S"ASTKERR", S"RANGERR", S"NOFILE",
                  S"PIDERROR", S"SCERROR", S"PARMERR"]; 
        END 
  
      DEF LEMSGIDL   #35#;
      ITEM EMSGIDL    C(LEMSGIDL) = 
                 " QTF, NETWORK IDLEDOWN IN PROGRESS."; 
  
      DEF LEMSGSHU   #23#;
      ITEM EMSGSHU    C(LEMSGSHU) = 
                 " QTF, NETWORK SHUTDOWN."; 
  
      ITEM CMDORD     S:CMDVERB;   # COMMAND TABLE ORDINAL #
      ITEM STAORD     S:STAT;      # STATUS ORDINAL # 
  
        $BEGIN
        NAME("OPRCMD");            # DEBUG CODE # 
        $END
  
      COMMANDSOU = SOURCE;
      CMDPRSR;                     # PARSE COMMAND #
      KL$CMD1 = C<00,50>COMMAND;   # MOVE COMMAND TO K DISPLAY #
      KL$CMD2 = C<50,30>COMMAND;
      MSGLOG(LOC(COMMANDBEG), (PARM$CMDL+20) ); 
      IF PARM$STAT NE S"OK" 
      THEN
        BEGIN 
        PARM$VERB = CMD$VERB[CMDVERB"NULL"];
        PARM$VERBL = 7; 
        END 
  
      IF PARM$VERBL GT 7
      THEN
        BEGIN 
        PARM$VERBL = 7; 
        END 
  
      CMD$VERB[CMDVERB"UNKNOWN"] = PARM$VERB; 
      CMDORD = S"NULL"; 
      ASLONGAS (C<0,PARM$VERBL>CMD$VERB[CMDORD] 
                  NE C<0,PARM$VERBL>PARM$VERB)
            OR (PARM$VERBL LT CMD$MIN[CMDORD])
      DO
        BEGIN 
        CMDORD = CMDORD + 1;
        END 
  
      GOTO SW$CMD[CMD$STAT[CMDORD] ];  # CASE STATEMENT # 
  
SW$NULL:                           # NO VERB #
        GOTO SW$END;
  
SW$AT:                             # AT # 
        GOTO SW$END;
  
SW$CLASS:                          # CLASS #
        CMDCLA;                    # PROCESS *CLASS* COMMAND #
        GOTO SW$END;
  
SW$DISABLE:                        # DISABLE #
        CMDDIS(TRUE); 
        GOTO SW$END;
  
SW$ENABLE:                         # ENABLE # 
        CMDDIS(FALSE);
        GOTO SW$END;
  
SW$HELP:                           # HELP # 
        KDISORD = S"HELP";
        KS$UPDATE[KDIS"HELP"] = TRUE; 
        GOTO SW$END;
  
SW$IDLE:                           # IDLE # 
        IDLE = TRUE;
        SHUTDOWN = SHUTDOWN OR (ACNNO EQ 0);
        MSGLOG(LOC(EMSGIDL),LEMSGIDL);
        KL$IDLE = "*IDLEDOWN*"; 
        MSGWFAIDLE = "*IDLEDOWN*";
        GOTO SW$END;
  
SW$INCLUDE:                        # INCLUDE #
        CMDINC; 
        GOTO SW$END;
  
SW$SCHED:                          # SCHED #
        CMDSCH; 
        GOTO SW$END;
  
SW$STATUS:                         # STATUS # 
        CMDSTA; 
        GOTO SW$END;
  
SW$STOP:                           # STOP # 
        IDLE = TRUE;
        SHUTDOWN = TRUE;
        MSGLOG(LOC(EMSGSHU),LEMSGSHU);
        KL$IDLE = "*SHUTDOWN*"; 
        GOTO SW$END;
  
SW$TRACE:                          # TRACE #
        GOTO SW$END;
  
SW$PLUS:                           # + #
        IF KS$CURPAGE[KDISORD] LT KS$MAXPAGE[KDISORD] 
        THEN
          BEGIN 
          KS$CURPAGE[KDISORD] = KS$CURPAGE[KDISORD] + 1;
          END 
  
        KDISPREV = KDISPREV + 1;   # FORCE ENTIRE DISPLAY REFRESH # 
        GOTO SW$END;
  
SW$MINUS:                          # - #
        IF KS$CURPAGE[KDISORD] GT 1 
        THEN
          BEGIN 
          KS$CURPAGE[KDISORD] = KS$CURPAGE[KDISORD] - 1;
          END 
  
        KDISPREV = KDISPREV + 1;   # FORCE ENTIRE DISPLAY REFRESH # 
        GOTO SW$END;
  
SW$LEFTP:                          # ( #
        GOTO SW$END;
  
SW$RIGHTP:                         # ) #
        GOTO SW$END;
  
SW$UNKNOWN:                        # UNKNOWN #
        PARM$STAT = S"VERBERR"; 
        GOTO SW$END;
  
SW$END:                            # END OF CASE #
  
      KS$UPDATE[KDISORD] = TRUE;   # UPDATE DISPLAY # 
      IF PARM$STAT NE S"OK" 
      THEN
        BEGIN 
        EMSGCMDSTA[STAT"OK"] = PARM$STAT; 
        STAORD = S"PARMERR";
        ASLONGAS EMSGCMDSTA[STAORD] NE EMSGCMDSTA[STAT"OK"] 
        DO
          BEGIN 
          STAORD = STAORD - 1;
          END 
  
        OPRMSG(LOC(EMSGCMDMSG[STAORD]), LEMSGCMD);
        IF (PARM$ECOL GT 0) 
          AND (PARM$ECOL LE 50) 
        THEN
          BEGIN 
          C<PARM$ECOL-1,1>KL$CMDEPTR = "*"; 
          END 
  
        ELSE
          BEGIN 
          IF (PARM$ECOL GT 50)
            AND (PARM$ECOL LE 80) 
          THEN
            BEGIN 
            C<PARM$ECOL-41,1>KL$CMDEPTR = "+";
            END 
  
          END 
  
        END 
  
      ELSE
        BEGIN 
        KL$CMDEPTR = " "; 
        KL$OPRMSG = "READY..";
        END 
  
      END  # OPRCMD # 
    TERM
