*COMDECK PBTUPBREA
_$J+  PAGE EJECT? 
_*****************************
*                            *
*        PBTUPBREAKPT        *
*  TUP BREAKPOINT HANDLER    *
*                            *
*****************************?
_$R+,G+,I+     RECURSIVE
               NON-INTERRUPTABLE ?
_***********************************************************************
*                                                                      *
**OVERVIEW- PBTUPBREAKPT IS ENTERED FROM THE BREAKPOINT INTERRUPT      *
*           HANDLER.  TUP COMMANDS CAN THEN BE ENTERED.  A             *
*           BREAKPOINT RESTART (RS) CAUSES AN EXIT FROM                *
*           PBTUPBREAKPT.                                              *
*                                                                      *
**INPUT- TUP TABLE.                                                    *
*                                                                      *
**OUTPUT- NONE.                                                        *
*                                                                      *
**EXTERNAL SUBROUTINES-                                                *
*              1) PBTUP            TEST UTILITY PACKAGE                *
*              2) PBLOAD           LOAD A CANNED MESSAGE               *
*              3) PBTOAH           CONVERT TO ASCII HEX                *
*              4) PBTESTIORDY      TEST I/O READY                      *
*              5) PBWRITE          WRITE CHAR/STATUS                   *
*              6) PBOMASK          OR INTERRUPT MASK                   *
*              7) LOCK             LOCK INTERRUPTS                     *
*              8) UNLOCK           UNLOCK INTERRUPTS                   *
*              9) PBDMPREG         FORMAT REGISTER DISPLAY             *
*              10)PBQUICKIO        QUICK I/O                           *
*                                                                      *
***********************************************************************?
PROCEDURE PBTUPBREAKPT; 
CONST LSTCHAR = J1LST32;
VAR REGSAVE : B0REGSAVE;
    ADDR : B018BITS;
_?
BEGIN 
  WITH JUTUPTABLE,JUTUPOUT' DO
  BEGIN 
    INST($E000,$F0,                         _STOP THE REAL TIME CLOCK  ?
         $B00,
         $3FE); 
    REGSAVE := JUTREGS;                     _SAVE TUP REGISTERS LOCALLY?
    JUTREGS := JEBPTABLE.JEREGSAVE';        _SET UP TUP REGISTERS      ?
    JUHLTFLG:= TRUE;                        _SET BP HALT FLAG          ?
    PBOMASK([J8TTY]);                       _ENABLE CONSOLE INTERRUPT  ?
    UNLOCK;                                 _UNLOCK INTERRUPTS         ?
    REPEAT
    UNTIL PBTESTIORDY(NODEVICE) &           _WAIT FOR CONSOLE READY    ?
          NOT JACT[TTY].JAINPROGFLG;        _WAIT FOR CONSOLE IDLE     ?
    LOCK;                                   _LOCK INTERRUPTS           ?
    PBWRITE(TTYSTAT,TTYRITE,TTY);           _SET CONSOLE TO WRITE MODE ?
    JUTUPFLG := TRUE;                       _SET TUP MODE              ?
    PBDMPREG(JUTUPOUT,JUREGSAVE);           _FORMAT REGISTER DUMP      ?
    PBQUICKIO(TTY,JUTUPOUT);                _PRINT REGISTER CONTENTS   ?
    PBLOAD(JUTUPOUT,J0HLTMSG,               _LOAD *HLT XXXX MSG        ?
           J1FRSTCHAR,LSTCHAR); 
    JUTEMP.BAINT :=                         _GET BP ADDRESS            ?
    JEBPTABLE.JERTNADDR'; 
    PB18BITS(ADDR,JUTEMP.BAINT,J0XFORM);    _FORMAT 18-BIT ADDRESS     ?
    P1TOAH(ADDR,JUTUPOUT,                   _CONVERT TO HEX            ?
           J1FRSTCHAR+6,LSTCHAR); 
    JUNEEDFLG := TRUE;                      _SET NEED TUP OUTPUT FLAG  ?
    UNLOCK;                                 _UNLOCK INTERRUPTS         ?
    REPEAT
      PBTUP;                                _CALL TUP                  ?
    UNTIL NOT JUHLTFLG;                     _RETURN CONTROL            ?
    LOCK;                                   _LOCK INTERRUPTS           ?
    JUTREGS := REGSAVE;                     _RESTORE TUP REGISTERS     ?
    INST($E000,$F3,                         _RESTART THE REAL TIME     ?
         $B00,                              _ CLOCK                    ?
         $3FE); 
  END; _WITH? 
END; _PBTUPBREAKPT? 
_$J+? 
_*****************************
*                            *
*          PBOPSHALT         *
*     HALT OPS LEVEL PGMS    *
*                            *
*****************************?
_$R-,G-,I-     NON-RECURSIVE
               INTERRUPTABLE ?
_***********************************************************************
*                                                                      *
**OVERVIEW- PBOPSHALT IS ENTERED FROM THE SYSTEM MONITOR (PBMON)       *
*           WHEN THE OPS HALT FLAG IS SET VIA A SH/ TUP COMMAND.       *
*           AN IDENTIFYING MESSAGE IS PRINTED ON THE LOCAL             *
*           CONSOLE AND A LOOP IS ENTERED ALLOWING TUP COMMANDS        *
*           BUT NO OPS LEVEL PROGRAMS RUN.  THE TUP COMMAND SR/        *
*           RETURNS CONTROL TO THE OPS MONITOR.                        *
*                                                                      *
**INPUT- NONE                                                          *
*                                                                      *
**OUTPUT- OPS PROGRAMS LOCKED OUT.                                     *
*                                                                      *
**EXTERNAL SUBROUTINES-                                                *
*              1) PBTESTIORDY      TEST I/O READY                      *
*              2) PBWRITE          WRITE CHAR/STATUS                   *
*              3) PBLOAD           LOAD A CANNED MSG                   *
*              4) PBTUP            TEST UTILITY PACKAGE                *
*                                                                      *
***********************************************************************?
PROCEDURE PBOPSHLT; 
CONST LSTCHAR = J1LST32;
VAR OPSHLT : J0ML10;
    REGSAVE : B0REGSAVE;
    REGPTR  : B0REGPTR; 
VALUE OPSHLT = (J1CRLF,#*OPS HLT]#);
BEGIN 
  ADDR(REGSAVE,REGPTR);                     _A,Q DON#T MATTER AT OPS   ?
  REGPTR := REGPTR-10;                      _CALCULATE REG SAVE ADDR   ?
  STREGS(REGPTR);                           _SAVE REGISTERS            ?
  WITH JUTUPTABLE DO
  BEGIN 
    JUTREGS := REGSAVE;                     _STORE INTO TUP TABLE      ?
    REPEAT
    UNTIL PBTESTIORDY(NODEVICE) !           _WAIT FOR CONSOLE AVAILABLE?
          NOT JACT[JBASSIGNTABLE[J2TUPOUTPUT]]. 
          JAINPROGFLG;
    PBWRITE(TTYSTAT,TTYRITE,TTY);           _SET CONSOLE TO WRITE MODE ?
    JUTUPFLG := TRUE;                       _ENTER TUP MODE            ?
    PBLOAD(JUTUPOUT,OPSHLT,                 _LOAD *OPS HLT             ?
           J1FRSTCHAR,LSTCHAR); 
    JUNEEDFLG := TRUE;                      _SET TUP OUTPUT READY FLAG ?
    REPEAT
      PBTUP;                                _CALL TUP                  ?
    UNTIL NOT JUSHLTFLG;                    _RETURN CONTROL TO MONITOR ?
  END; _WITH? 
  LDREGS(REGPTR);                           _RESTORE REGISTERS         ?
END; _PBOPSHLT? 
