*COMDECK PBDECODET
_$J+  PAGE EJECT? 
_*****************************
*                            *
*        PBDECODETUP         *
*   DECODE TUP MESSAGE       *
*                            *
*****************************?
_$R-,G-,I+     NON-RECURSIVE
               NON-INTERRUPTABLE ?
_***********************************************************************
*                                                                      *
**OVERVIEW- PBDECODET DECODES TUP INPUT MESSAGES, EXECUTES THEM        *
*           AND FORMATS THE RESPONSE. GOTO 20 MEANS ERROR IN           *
*           TUP INPUT.  THE FOLLOWING TUP COMMANDS ARE                 *
*           IMPLEMENTED:                                               *
*                                                                      *
*                    SH       SYSTEM HALT                              *
*                    SR       SYSTEM RESTART                           *
*                    RS       BREAKPOINT RESTART                       *
*                    DR       DISPLAY REGISTERS                        *
*                    ER       ENTER REGISTER (R=1,2,3,4,Q,A,I OR M)    *
*                    DP       DUMP CORE                                *
*                    LH       LOAD HEX                                 *
*                    EB       ENTER BREAKPOINT                         *
*                    RB       REMOVE BREAKPOINT                        *
*                    BL       ENABLE BP BY PRIORITY LEVEL              *
*                    DL       DISABLE BP BY PRIORITY LEVEL             *
*                    DF       DISPLAY FILE 1 REGISTER                  *
*                    EF       ENTER FILE 1 REGISTER                    *
*                    BG       GET A BUFFER                             *
*                    BR       RELEASE A BUFFER                         *
*                    LP       MAKE A WORKLIST ENTRY                    *
*                    LG       GET A WORKLIST ENTRY                     *
*                    DA       DEVICE ASSIGNMENT                        *
*                    LC       DUMP LINE CONTROL BLOCK                  *
*                    TC       DUMP TCB OR LLCB (DN,SN,CN)              *
*                    TS       DUMP TCB (LINE NO, CA, TA)               *
*                                                                      *
**INPUT- TUP MESSAGE.                                                  *
*                                                                      *
**OUTPUT- APPROPRIATE FUNCTION EXECUTED.                               *
*                                                                      *
**EXTERNAL SUBROUTINES- LOTS                                           *
*                                                                      *
***********************************************************************?
PROCEDURE PBDECODET;
CONST LSTCHAR = J1LST32;
TYPE TUPMSG = (OH,                          _OPS HALT                  ?
               OR,                          _OPS RESTART               ?
               RS,                          _BREAKPOINT RESTART        ?
               DR,                          _DISPLAY REGISTERS         ?
               E1,                          _ENTER R1                  ?
               E2,                          _ENTER R2                  ?
               E3,                          _ENTER R3                  ?
               E4,                          _ENTER R4                  ?
               EQ,                          _ENTER Q                   ?
               EA,                          _ENTER A                   ?
               EI,                          _ENTER I                   ?
               EM,                          _ENTER M                   ?
               DP,                          _DUMP HEX                  ?
               LH,                          _LOAD HEX START ADDRESS    ?
               C1,                          _LOAD HEX                  ?
               C2,                          _LOAD HEX                  ?
               EB,                          _ENTER BREAKPOINT          ?
               RB,                          _REMOVE BREAKPOINT         ?
               BL,                          _ENABLE BP BY PRIORITY LVL ?
               DL,                          _DISABLE BP BY PRIORITY LVL?
               DF,                          _DISPLAY FILE 1 REGISTER   ?
               EF,                          _ENTER FILE 1 REGISTER     ?
               BG,                          _GET A BUFFER              ?
               BR,                          _RELEASE A BUFFER          ?
               LG,                          _GET A WL ENTRY            ?
               LP,                          _MAKE A WL ENTRY           ?
               DA,                          _DEVICE ASSIGNMENT         ?
               LC,                          _DUMP LCB                  ?
               TC,                          _DUMP TCB/LLCB (DN,SN,CN)  ?
               TS,                          _DUMP TCB (LINE NO,CA,TA)  ?
               DM,                          _DUMP OPS PROGRAM LOCATIONS?
               LD,                          _LOAD OPS PROGRAM LOCATIONS?
               RP,                          _READ PAGE REGISTER        ?
               BAD);                        _INVALID TUP COMMAND       ?
_?
VAR MSG : TUPMSG; 
    REG : B0REGISTERS;
    I,J : INTEGER;
    ERR : BOOLEAN;
    JCBECTPTR : BECTPTR;                    _BUFFER CONTROL BLOCK PTR  ?
_?
    TUPSRCH : ARRAY [TUPMSG] OF INTEGER;    _TUP MESSAGE MNEMONICS     ?
_?
    I18 : B018BITS;                         _18-BIT ADDRESS WORK FIELD ?
    SYSHLTERR : J0ML14;                     _*ERR SYS HLT              ?
    ERRMSG    : J0ML6;                      _*ERR                      ?
    ASTERISK  : J0ML6;                      _*                         ?
    LISTEMPTY : J0ML10;                     _*LIST EMPTY               ?
    WLENTRY : BWWORKLIST; 
    LRP : JCPACKET;                         _SPECIAL I/O REQUEST PKT   ?
_?
VALUE TUPSRCH = ($4F48,                     _OH                        ?
                 $4F52,                     _OR                        ?
                 $5253,                     _RS                        ?
                 $4452,                     _DR                        ?
                 $4531,                     _E1                        ?
                 $4532,                     _E2                        ?
                 $4533,                     _E3                        ?
                 $4534,                     _E4                        ?
                 $4551,                     _EQ                        ?
                 $4541,                     _EA                        ?
                 $4549,                     _EI                        ?
                 $454D,                     _EM                        ?
                 $4450,                     _DP                        ?
                 $4C48,                     _LH                        ?
                 $4320,                     _C                         ?
                 $432C,                     _C,                        ?
                 $4542,                     _EB                        ?
                 $5242,                     _RB                        ?
                 $424C,                     _BL                        ?
                 $444C,                     _DL                        ?
                 $4446,                     _DF                        ?
                 $4546,                     _EF                        ?
                 $4247,                     _BG                        ?
                 $4252,                     _BR                        ?
                 $4C47,                     _LG                        ?
                 $4C50,                     _LP                        ?
                 $4441,                     _DA                        ?
                 $4C43,                     _LC                        ?
                 $5443,                     _TC                        ?
                 $5453,                     _TS                        ?
                 $444D,                     _DM                        ?
                 $4C44,                     _LD                        ?
                 $5250,                     _RP                        ?
                  0); 
_?
      SYSHLTERR = (J1CRLF,#*ERR SYS HLT]#); 
      ERRMSG    = (J1CRLF,#*ERR]#); 
      ASTERISK  = (J1CRLF,#*   ]#); 
      LISTEMPTY = (#LIST EMPTY]#);
*CALL PBOUTOFRN 
_$J+? 
_*****************************
*                            *
*        PNTCBSRCH           *    LOCAL TO PBDECODET
*     SEARCH FOR TCB         *
*                            *
*****************************?
_***********************************************************************
*                                                                      *
**OVERVIEW- PNTCBSRCH RETURNS A TCB ADDRESS GIVEN A LINE NUMBER,       *
*           CLUSTER ADDRESS (CA), TERMINAL ADDRESS (TA),               *
*           AND DEVICE TYPE (DT).                                      *
*                                                                      *
**INPUT- LINE NUMBER, CA, TA AND DT.                                   *
*                                                                      *
**OUTPUT- TCB ADDRESS OR NIL, IF TCB NOT FOUND.                        *
*                                                                      *
**EXTERNAL SUBROUTINES-                                                *
*                1) PNLNBAD        VALIDATE LINE NUMBER                *
*                                                                      *
***********************************************************************?
FUNCTION PNTCBSRCH(LINENO : B0LINO; CA,TA,DT: INTEGER): B0BUFPTR; 
VAR X : B0BUFPTR; 
    DEVTYPE: NPDT;                          _DEVICE TYPE OVERLAY       ?
BEGIN 
  PNTCBSRCH := NIL;                         _RETURN NIL IF TCB NOT FND ?
  IF NOT PNLNBAD(LINENO) THEN               _CHECK FOR VALID LINE NO.  ?
  BEGIN 
    X := C0LCBADDR'.BZTCBPTR;               _PNLNBAD SETS UP C0LCBADDR ?
    DEVTYPE.NPCHAR := CHR(DT);              _SET UP DEVICE TYPE FIELD  ?
    WHILE NIL " X DO                        _LOOP THROUGH TCB#S        ?
    WITH X'.BSTCB DO
    BEGIN                                   _CHECK FOR CA,TA,DT MATCH  ?
      IF CA = BSCA THEN 
      IF TA = BSTA THEN 
      IF DEVTYPE.NPDEV = BSDEVTYPE
      THEN
        GOTO 10;                            _YES - EXIT SEARCH         ?
      X := BSCHAIN;                         _NO  - CHAIN TO NEXT TCB   ?
    END;
 10:PNTCBSRCH := X;                         _RETURN TCB ADDRESS OR NIL ?
  END;
END; _PNTCBSRCH?
_$J+? 
_***********************************************************************
*     DECODE TUP INPUT AND SET UP PARAMETER TABLE                      *
***********************************************************************?
BEGIN 
  WITH JUTUPTABLE DO                        _TUP TABLE                 ?
  BEGIN 
    WITH JUTUPIN' DO                        _TUP INPUT BUFFER          ?
    BEGIN 
      JUMSGINFLG := FALSE;                  _CLEAR MESSAGE IN FLAG     ?
      ERR := FALSE; 
      I := J1FRSTCHAR;
      JULRPOUT.JCPD := JBASSIGNTABLE[J2TUPOUT]; _ASSIGN TUP OUTPUT     ?
      IF J1TUPEOM " BFDATAC[BFLCD]          _CHECK FOR EOM             ?
      THEN GOTO 20; 
      MSG := OH;
      JUTEMP.BAINT := BIINT[J1FRSTCHAR/2 + 1];_ CHECK MSG MNEMONIC     ?
      WHILE (JUTEMP.BAINT " TUPSRCH[MSG]) & 
            (BAD " MSG) DO
      MSG := SUCC(MSG);                     _SEARCH FOR MATCH IN TABLE ?
      IF BAD = MSG                          _CHECK IF INVALID          ?
      THEN GOTO 20; 
      REPEAT
        I := I+1; 
        JUTEMP.BA1CHAR := BFDATAC[I]; 
      UNTIL PBMEMBER(JUTEMP,JSDELIMSET);    _ADVANCE TO 1ST PARAM      ?
      FOR J := 1 TO J1WLMAX DO              _CLEAR PARAMETER AREA      ?
        JUPARAM[J].JVWORD.BAINT := 0; 
      I := I+1; 
      J := 0; 
      PBLOAD(JUTUPOUT,ASTERISK,             _LOAD CR,LF,ASTERISK       ?
             J1FRSTCHAR,LSTCHAR); 
      WHILE (I < BFLCD) & (7 \ J) DO        _CONVERT ALL PARAMETERS    ?
      WITH JUPARAM[J] DO
      BEGIN 
        JVLSTFLG := FALSE;                  _CLEAR LAST PARAM FLAG     ?
        IF NOT PBFMAH(JV18BITS,JUTUPIN,I)   _CONVERT PARAMETER         ?
        THEN GOTO 20;                       _EXIT IF BAD INPUT         ?
        J := J+1; 
      END;
      IF 0 < J
      THEN JUPARAM[J-1].JVLSTFLG := TRUE;   _SET FLAG ON LAST PARAM    ?
      J := 0; 
    END; _WITH? 
_?
    WITH JUTUPOUT' DO                       _TUP OUTPUT BUFFER         ?
    CASE MSG OF                             _EXECUTE PROPER COMMAND    ?
_***********************************************************************
*     OPS HALT                                                         *
***********************************************************************?
    OH: 
    IF JUSHLTFLG                            _CHECK IF SYSTEM HALTED    ?
    THEN PBLOAD(JUTUPOUT,SYSHLTMSG,         _SYSTEM HALT ERROR         ?
                J1FRSTCHAR,LSTCHAR) 
    ELSE JUSHLTFLG := TRUE;                 _SET SYSTEM HALT FLAG      ?
_***********************************************************************
*     OPS RESTART                                                      *
***********************************************************************?
    OR: 
    IF JUSHLTFLG                            _CHECK IF SYSTEM HALTED    ?
    THEN JUSHLTFLG := FALSE                 _CLEAR SYSTEM HALT FLAG    ?
    ELSE PBLOAD(JUTUPOUT,SYSHLTERR,         _SYSTEM HALT ERROR         ?
                J1FRSTCHAR,LSTCHAR);
_***********************************************************************
*     BREAKPOINT RESTART                                               *
***********************************************************************?
    RS: 
    IF JUHLTFLG                             _CHECK IF BREAKPOINT HALT  ?
    THEN JUHLTFLG := FALSE                  _CLEAR BP HALT FLAG        ?
    ELSE PBLOAD(JUTUPOUT,SYSHLTERR,         _HALT ERROR                ?
                J1FRSTCHAR,J1LSTCHAR);
_***********************************************************************
*   DISPLAY REGISTERS                                                  *
***********************************************************************?
    DR: 
    PBDMPREG(JUTUPOUT,JUREGSAVE);           _FORMAT REGISTER DISPLAY   ?
_***********************************************************************
*   ENTER REGISTER                                                     *
***********************************************************************?
    E1,E2,E3,E4,EQ,EA,EI,EM:  
    IF JUSHLTFLG ! JUHLTFLG THEN            _SYSTEM MUST BE HALTED     ?
    BEGIN 
      REG := B0EXTRA; 
      REPEAT
        REG := SUCC(REG); 
      UNTIL JIPRINTREGS[REG] =              _SEARCH FOR REG MNEMONIC   ?
            JUTUPIN'.BFDATAC[J1FRSTCHAR+1]; 
      BFDATAC[J1FRSTCHAR+3] := JIPRINTREGS[REG];
      BFDATAC[J1FRSTCHAR+4] := #=#; 
      JUTEMP.BAINT := JUTREGS[REG]; 
      PBTOAH(JUTEMP.BAHEX,JUTUPOUT,         _CONVERT REG CONTENTS      ?
             J1FRSTCHAR+5,LSTCHAR); 
      JUTREGS[REG] := JUPARAM[0].JVWORD.BAINT; _STORE NEW CONTENTS     ?
      BFLCD := J1FRSTCHAR+8;                _SET LCD                   ?
    END 
    ELSE GOTO 20; 
_***********************************************************************
*     LOAD HEX START ADDRESS                                           *
***********************************************************************?
    LH: 
    WITH JUPARAM[0] DO
    BEGIN 
      JULHXADDR := JUPARAM[0].JV18BITS;     _DISPLACEMENT              ?
      IF NOT JVLSTFLG                       _CHECK IF BASE/DISPL FORM  ?
      THEN PB18ADD(JUPARAM[1].JV18BITS,     _ADD BASE TO DISPLACEMENT  ?
                   JULHXADDR);
    END;
_***********************************************************************
*     LOAD HEX                                                         *
***********************************************************************?
    C1,C2:  
    BEGIN 
      JUTUPIN'.BFDATAC[J1FRSTCHAR] := # #;  _DEFEAT 5 MIN TUP TIMEOUT  ?
      P1TOAH(JULHXADDR,JUTUPOUT,            _CONVERT LOAD START ADDR   ?
             J1FRSTCHAR+3,LSTCHAR); 
      REPEAT
      WITH JUPARAM[J] DO
      BEGIN 
        IF PBOUTOFRANGE (JULHXADDR) THEN    _CHECK IF ADDR OUT OF RANGE?
        BEGIN 
          I := 5*J + J1FRSTCHAR+9;
          FOR I := I TO I+5 DO
          BFDATAC[I] := #-#;                _PUT ----- INTO OUTPUT BFR ?
        END 
        ELSE
        BEGIN 
          PB18BITS(JULHXADDR,JUTEMP.BAINT,J0GET); 
          PBTOAH(JUTEMP.BAHEX,JUTUPOUT,     _CONVERT CURRENT CONTENTS  ?
                 5*J+J1FRSTCHAR+9,LSTCHAR); 
          PB18BITS (JULHXADDR,JVWORD.BAINT,J0LOAD); 
        END;
        J := J+1;                           _-BUMP                     ?
        PB18ADD(ONE,JULHXADDR);             _-INDICES                  ?
      END;
      UNTIL JUPARAM[J-1].JVLSTFLG;          _GO THRU ALL PARAMETERS    ?
      BFLCD := 5*J + J1FRSTCHAR+7;          _SET LCD                   ?
    END;
_***********************************************************************
*     DUMP HEX                                                         *
***********************************************************************?
    DP: 
    WITH JUPARAM[0] DO
    BEGIN 
      IF JVLSTFLG                           _DUMP ONE WORD             ?
      THEN JUPARAM[1].JV18BITS := JV18BITS  _SET UPPER BOUND           ?
      ELSE
      IF NOT JUPARAM[1].JVLSTFLG THEN       _CHECK IF BASE/DISPL FORM  ?
      BEGIN 
        PB18ADD(JUPARAM[2].JV18BITS,        _ADD BASE TO START DISPL   ?
                JV18BITS);
        PB18ADD(JUPARAM[2].JV18BITS,        _ADD BASE TO END DISPL     ?
                JUPARAM[1].JV18BITS); 
      END;
      IF PBOUTOFRNGE(JV18BITS) !            _CHECK START/END RANGE     ?
         PBOUTOFRNGE(JUPARAM[1].JV18BITS) 
      THEN GOTO 20; 
   10:PB18ADD(ONE,JUPARAM[1].JV18BITS);     _BUMP END ADDR BY ONE      ?
      JUTUPIN'.BIINT[3] := TUPSRCH[DP];     _SET MNEMONIC TO DUMP      ?
      JUDPLFLG :=                           _DUMP NOT TO CONSOLE       ?
      #L# = JUTUPIN'.BFDATAC[J1FRSTCHAR+2]; 
      JUDPCFLG := NOT JUDPLFLG;             _SET REGULAR DUMP OTHERWISE?
      IF JUDPLFLG 
      THEN JULRPOUT.JCPD := JBASSIGNTABLE[J2TUPDUMP]; _GET DUMP DEVICE ?
      JU16WDS := FALSE;                     _16 WDS/LINE FLAG          ?
      BFEOTFLG := FALSE;                    _CLEAR EOT FLAG            ?
      PBTUPDUMP;                            _START DUMP                ?
    END;
_***********************************************************************
*     DUMP OPS PROGRAM LOCATIONS                                       *
***********************************************************************?
    DM: 
    WITH JUPARAM[2],JVWORD DO 
    IF JVLSTFLG THEN                        _TEST RIGHT NO. OF PARAMS  ?
    BEGIN 
      IF BAPGM > B0DUMMY                    _CHECK OPS INDEX TOO BIG   ?
      THEN GOTO 20; 
      JV18BITS := JZOPSBASE[BAPGM];         _GET OPS PGM START ADDRESS ?
      PB18ADD(JV18BITS,JUPARAM[0].JV18BITS);_SET UP LOWER LIMIT        ?
      PB18ADD(JV18BITS,JUPARAM[1].JV18BITS);_SET UP UPPER LIMIT        ?
      IF PBOUTOFRNGE(JUPARAM[0].JV18BITS) ! _CHECK START/END ADDR RANGE?
         PBOUTOFRNGE(JUPARAM[1].JV18BITS) 
      THEN GOTO 20; 
      JUPARAM[1].JVLSTFLG := TRUE;          _ALLOW DUMP TO REPEAT      ?
      GOTO 10;                              _GO PERFORM DUMP           ?
    END 
    ELSE GOTO 20;                           _WRONG NO. OF PARAMETERS   ?
_***********************************************************************
*     LOAD OPS PROGRAM LOCATIONS                                       *
***********************************************************************?
    LD: 
    WITH JUPARAM[1],JVWORD DO 
    IF JVLSTFLG THEN                        _CHECK NO. OF PARAMETERS   ?
    BEGIN 
      JULHXADDR := JUPARAM[0].JV18BITS;     _DISPLACEMENT              ?
      PB18ADD(JZOPSBASE[BAPGM],JULHXADDR);  _ADD OPS BASE              ?
    END 
    ELSE GOTO 20;                           _WRONG NO. OF PARAMETERS   ?
_***********************************************************************
*     READ PAGE REGISTER                                               *
***********************************************************************?
    RP: 
    WITH JUPARAM[0].JVWORD DO 
    IF ($1F < BAINT) & ($8000 > BAINT)
    THEN GOTO 20                            _TOO BIG                   ?
    ELSE
    BEGIN 
      PBGETPAGE(BAINT,BAINT);               _READ PAGE REGISTER        ?
      PBTOAH(BAHEX,JUTUPOUT,                _CONVERT RESULT            ?
             J1FRSTCHAR+3,LSTCHAR); 
      BFLCD := J1FRSTCHAR+7;                _SET LCD                   ?
    END;
_***********************************************************************
*     ENTER BREAKPOINT                                                 *
***********************************************************************?
    EB: 
    WITH JEBPTABLE DO                       _BREAKPOINT TABLE          ?
    BEGIN 
      REPEAT
        J := J+1; 
        ERR :=
        DELIM " JEBPENTRY[J].JEBPCODE;
      UNTIL NOT ERR ! (J1BREAKMAX = J);     _SEARCH FOR END-OF-TABLE   ?
      IF ERR ! JUPARAM[0].JVLSTFLG ! JUPARAM[1].JVLSTFLG
      THEN GOTO 20; 
      IF PBOUTOFRNGE(JUPARAM[0].JV18BITS) ! 
         PBOUTOFRNGE(JUPARAM[1].JV18BITS) 
      THEN GOTO 20; 
      WITH JEBPENTRY[J] DO                  _AVAILABLE BP ENTRY        ?
      BEGIN                                 _SET UP ENTRY              ?
        JEBEGINADDR := JUPARAM[0].JV18BITS; 
        JEENDADDR   := JUPARAM[1].JV18BITS; 
        JEBPCODE    := JUPARAM[2].JVWORD.BAINT; 
        ERR := FALSE; 
        FOR I := 5 DOWNTO 1 DO              _BREAKPOINT PARAMETERS     ?
        WITH JUPARAM[I+2] DO
        BEGIN 
          ERR := ERR ! JVLSTFLG;            _FIND LAST PARAMETER       ?
          IF ERR
          THEN JEPARAM[I] := JV18BITS       _MOVE IN BP PARAMETER      ?
          ELSE JEPARAM[I] := ZERO;          _CLEAR MISSING PARAMETER   ?
        END;
        I18 := JEBEGINADDR; 
        PB18ADD(MINUSONE,I18);
        REPEAT
          PB18ADD(ONE,I18); 
          PB18BITS(I18,J,J0CLRP);           _CLEAR PROTECT BIT         ?
        UNTIL PB18COMP(I18,J0EQ,JEENDADDR); 
        PB18ADD(ONE,JEENDADDR);             _FOR INTERRUPT RANGE CHECK ?
      END;
    END;
_***********************************************************************
*     REMOVE BREAKPOINT                                                *
***********************************************************************?
    RB: 
    WITH JEBPTABLE DO                       _BREAKPOINT TABLE          ?
    BEGIN 
      IF NOT JUPARAM[2].JVLSTFLG            _TOO MANY/NOT ENOUGH PARAMS?
      THEN GOTO 20; 
      REPEAT
        J := J+1; 
        WITH JEBPENTRY[J] DO                _SEARCH FOR BP ENTRY       ?
        ERR := (JUPARAM[0].JV18BITS " JEBEGINADDR) !
               (JUPARAM[2].JVWORD.BAINT " JEBPCODE);
      UNTIL NOT ERR ! (J1BREAKMAX = J); 
      IF ERR
      THEN GOTO 20;                         _ENTRY NOT FOUND           ?
      WITH JEBPENTRY[J] DO                  _ENTRY FOUND               ?
      BEGIN 
        I18 := JEBEGINADDR; 
        PB18ADD(MINUSONE,I18);
        PB18ADD(MINUSONE,JEENDADDR);
        JEBPCODE := DELIM;
        REPEAT
          PB18ADD(ONE,I18); 
          PB18BITS(I18,J,J0SETP);           _SET PROTECT BIT           ?
        UNTIL PB18COMP(I18,J0EQ,JEENDADDR); 
      END;
    END;
_***********************************************************************
*     ENABLE/DISABLE BREAKPOINT BY PRIORITY LEVEL                      *
***********************************************************************?
    BL,DL:  
    WITH JUPARAM[0].JVWORD DO 
    BEGIN 
      IF (0 = BAINT) ! (OPS < BAINT)        _CHECK PRIORITY RANGE      ?
      THEN GOTO 20; 
      JRLEVELFLG[BAINT] :=                  _SET/RESET PRIORITY FLAG   ?
      #B# = JUTUPIN'.BFDATAC[J1FRSTCHAR]; 
    END;
_***********************************************************************
*     GET A BUFFER                                                     *
***********************************************************************?
    BG: 
    WITH JUPARAM[0].JVWORD DO 
    IF (B3LOWER @ BABUFSIZE) &              _CHECK LOWER INDEX         ?
       (B3UPPER \ BABUFSIZE) THEN           _CHECK UPPER INDEX         ?
    BEGIN 
      ADDR(BECTLBK[BABUFSIZE],JCBECTPTR);   _SET UP CONTROL BLOCK ADDR ?
      BABUFPTR := PBGET1BF (JCBECTPTR);     _GET REQUESTED BUFFER      ?
      PBTOAH(BAHEX,JUTUPOUT,                _CONVERT ADDRESS           ?
             J1FRSTCHAR+3,LSTCHAR); 
      BFLCD := J1FRSTCHAR+7;                _SET LCD                   ?
    END 
    ELSE GOTO 20;                           _BAD BUFFER INDEX          ?
_***********************************************************************
*     RELEASE A BUFFER                                                 *
***********************************************************************?
    BR: 
    WITH JUPARAM[1].JVWORD DO 
    IF (B3LOWER @ BABUFSIZE) &              _CHECK LOWER INDEX         ?
       (B3UPPER \ BABUFSIZE)                _CHECK UPPER INDEX         ?
    THEN
    BEGIN 
      ADDR (BECTLBK[BABUFSIZE],JCBECTPTR);  _SET UP CONTROL BLOCK      ?
      PBREL1BF (JUPARAM[0].JVWORD.BABUFPTR, 
                  JCBECTPTR)                _RELEASE BUFFER            ?
    END 
    ELSE GOTO 20;                           _BAD BUFFER INDEX          ?
_***********************************************************************
*     GET A WORKLIST ENTRY                                             *
***********************************************************************?
    LG: 
    WITH JUPARAM[0].JVWORD DO 
    IF (B4FSTL @ BAWKLST) &                 _CHECK LOWER WL INDEX      ?
       (B0DUMMY > BAWKLST) THEN 
    BEGIN 
    WLENTRY := BWWLENTRY[LEVELNO];          _SAVE INT ARRAY            ?
    IF PBLSGET (BWWLENTRY[LEVELNO], 
                          BYWLCB[BAWKLST])  _GET WL ENTRY              ?
    THEN PBLOAD(JUTUPOUT,LISTEMPTY,         _*LIST EMPTY               ?
                J1FRSTCHAR+3,LSTCHAR) 
    ELSE
    WITH BWWLENTRY[LEVELNO] DO
    BEGIN 
      J := J1FRSTCHAR+3;
      FOR I := 1 TO PBMIN(8,J1WLMAX) DO     _GO THRU WL ENTRY          ?
      BEGIN 
        PBTOAH(BWIMED[I].BAHEX,JUTUPOUT,    _CONVERT ONE WORD OF ENTRY ?
               J,LSTCHAR);
        J := J+5; 
      END;
      BFLCD := J-1;                         _SET LCD                   ?
    END;
    BWWLENTRY[LEVELNO] := WLENTRY;          _RESTORE INT ARRAY         ?
    END 
    ELSE GOTO 20;                           _BAD WL INDEX              ?
_***********************************************************************
*     MAKE A WORKLIST ENTRY                                            *
***********************************************************************?
    LP: 
    WITH JUPARAM[0].JVWORD DO 
    IF (B4FSTL @ BAWKLST) &                 _CHECK LOWER WL INDEX      ?
       (B0DUMMY > BAWKLST) THEN             _ CHECK UPPER WL RANGE     ?
    WITH WLENTRY DO 
    BEGIN 
      FOR I := 1 TO J1WLMAX DO              _COPY WORKLIST ENTRY       ?
      BWIMED[I].BAINT := JUPARAM[I].JVWORD.BAINT; 
      PBLSPUT (WLENTRY,BYWLCB[BAWKLST]);    _MAKE WORKLIST ENTRY       ?
    END 
    ELSE GOTO 20;                           _BAD WL ENTRY              ?
_***********************************************************************
*     DEVICE ASSIGNMENT                                                *
***********************************************************************?
    DA: 
    WITH JUPARAM[0].JVWORD DO 
    IF (J2LAST < BALIO) ! (J2SUPIN > BALIO) ! _CHECK LIO CODE RANGE    ?
       (LP1742 < JUPARAM[1].JVWORD.BAINT)   ! _CHECK DEVICE CODE RANGE ?
       (NODEVICE > JUPARAM[1].JVWORD.BAINT) 
    THEN GOTO 20                              _BAD DATA                ?
    ELSE JBASSIGNTABLE[BALIO] :=              _PERFORM DEVICE ASSIGNMNT?
         JUPARAM[0].JVWORD.BAINT; 
_***********************************************************************
*     ENTER/DISPLAY FILE 1 REGISTER                                    *
***********************************************************************?
    EF,DF:  
    WITH JUPARAM[0],JVWORD DO 
    IF $FF \ BAINT THEN                     _CHECK FILE 1 REG RANGE    ?
    BEGIN 
      JUPARAM[7].JVWORD.BAINT := BAINT+1;   _SAVE NEXT FILE 1 REG      ?
      BASET := BASET ! [BIT8];              _READ ONE REG ONLY         ?
      PBDF(BAINT,JUPARAM[2].JVWORD);        _READ FILE 1 REG           ?
      PBTOAH(JUPARAM[2].JVWORD.BAHEX,JUTUPOUT,
             J1FRSTCHAR+3,LSTCHAR);         _CONVERT FILE 1 REG CONTENT?
      BFLCD := J1FRSTCHAR+6;                _SET LCD                   ?
      IF #E# = JUTUPIN'.BFDATAC[J1FRSTCHAR] THEN _LOAD FILE 1 REG      ?
      IF JVLSTFLG 
      THEN GOTO 20                          _NO DATA TO LOAD           ?
      ELSE PBEF(BAINT,JUPARAM[1].JVWORD)    _LOAD FILE 1 REG           ?
      ELSE
      BEGIN 
        PBTOAH(JUPARAM[7].JVWORD.BAHEX,JUTUPIN,  _-SET UP INPUT BFR TO ?
               J1FRSTCHAR+3,LSTCHAR);            _-DUMP NEXT FILE 1 REG?
        JUTUPIN'.BFDATAC[J1FRSTCHAR+7] := #/#;   _-IF MANUAL INT IS    ?
        JUTUPIN'.BFLCD := J1FRSTCHAR+7;          _-PRESSED.            ?
      END;
    END 
    ELSE GOTO 20;                           _ERROR                     ?
_***********************************************************************
*     DUMP LINE CONTROL BLOCK                                          *
***********************************************************************?
    LC: 
    WITH JUPARAM[0],JVWORD,BALINO DO
    BEGIN 
      IF (C4LCBS < BDPORT) !                _CHECK PORT RANGE          ?
         (C4SUBLCB < BDSUBPORT)             _CHECK SUBPORT RANGE       ?
      THEN GOTO 20;                         _BAD LINE NUMBER           ?
      ADDR(CGLCBP'[0], I);                  _ GET 1ST LCB ADDRESS      ?
      ADDR(CGLCBP'[1], J);                  _ GET 2ND LCB ADDRESS      ?
      I := J-I-1;                           _CALCULATE LCB SIZE        ?
      IF 0 = BDPORT 
      THEN ADDR(CSUBLCBP'[BDSUBPORT],BAINT) _GET SUB LCB ADDRESS       ?
      ELSE ADDR(CGLCBP'[BDPORT], BAINT);    _GET LCB ADDRESS           ?
      JUPARAM[1].JVWORD.BAINT := BAINT+I;   _SET END ADDRESS           ?
      PB18BITS(JV18BITS,BAINT,J0XFORM);     _FORM 18-BIT ADDRESS       ?
      WITH JUPARAM[1],JVWORD DO 
      PB18BITS(JV18BITS,BAINT,J0XFORM);     _FORM 18-BIT ADDRESS       ?
      GOTO 10;                              _GO PERFORM DUMP           ?
    END;
_***********************************************************************
*     DUMP TCB/LLCB BY DN,SN,CN (CN = 0 MEANS DUMP LLCB)               *
***********************************************************************?
    TC: 
    WITH JUPARAM[0],JVWORD DO 
    BEGIN 
      IF NOT JUPARAM[2].JVLSTFLG            _TOO MANY/NOT ENOUGH PARAMS?
      THEN GOTO 20; 
      BABUFPTR := PNGTLLCB(BAINT,           _GET LLCB ADDRESS          ?
                          JUPARAM[1].JVWORD.BAINT); 
      IF NIL = BABUFPTR 
      THEN GOTO 20;                         _NO LLCB                   ?
      IF 0 = JUPARAM[2].JVWORD.BAINT THEN   _ZERO CN = DUMP LLCB       ?
      JUPARAM[1].JVWORD.BAINT :=            _GET STATIC LLCB END ADDR  ?
      BAINT + D0SLLCBSZE-1
      ELSE
      BEGIN 
        BABUFPTR := PNGTCB(BABUFPTR,        _GET TCB ADDRESS           ?
                           JUPARAM[2].JVWORD.BAINT);
        IF NIL = BABUFPTR 
        THEN GOTO 20;                       _TCB NOT FOUND             ?
        JUPARAM[1].JVWORD.BAINT :=          _GET TCB END ADDRESS       ?
        BAINT + TCBLENGTH[BJTIPTYPT[        _ BY FINDING THE TCB SIZE  ?
                  BABUFPTR'.BSTCB.BSLCBP'.  _ IN TIPTYPE TBL (BUT TIP  ?
                  BZTIPTYPE].BJTCBSIZE] - 1;_ TYPE IS IN THE LCB)      ?
        PB18BITS(JV18BITS,BAINT,J0XFORM);   _FORM 18-BIT ADDRESS       ?
        WITH JUPARAM[1],JVWORD DO 
        PB18BITS(JV18BITS,BAINT,J0XFORM);   _FORM 18-BIT ADDRESS       ?
      END;
      GOTO 10;                              _GO PERFORM DUMP           ?
    END;
_***********************************************************************
*     DUMP TCB BY LINE NO., CA, TA                                     *
***********************************************************************?
    TS: 
    WITH JUPARAM[0],JVWORD DO 
    BEGIN 
      IF NOT JUPARAM[3].JVLSTFLG            _TOO MANY / NOT ENOUGH     ?
      THEN GOTO 20;                         _PARAMETERS                ?
      BABUFPTR := PNTCBSRCH(BALINO,         _GET TCB ADDRESS           ?
                            JUPARAM[1].JVWORD.BAINT,
                            JUPARAM[2].JVWORD.BAINT,
                            JUPARAM[3].JVWORD.BAINT); 
      IF NIL = BABUFPTR 
      THEN GOTO 20;                         _TCB NOT FOUND             ?
      JUPARAM[1].JVWORD.BAINT :=            _GET TCB END ADDRESS       ?
        BAINT + TCBLENGTH[BJTIPTYPT[        _ BY FINDING THE TCB SIZE  ?
                  BABUFPTR'.BSTCB.BSLCBP'.  _ IN TIPTYPE TBL (BUT TIP  ?
                  BZTIPTYPE].BJTCBSIZE] - 1;_ TYPE IS IN THE LCB)      ?
      PB18BITS(JV18BITS,BAINT,J0XFORM);     _FORM 18-BIT ADDRESS       ?
      WITH JUPARAM[1],JVWORD DO 
      PB18BITS(JV18BITS,BAINT,J0XFORM);     _FORM 18-BIT ADDRESS       ?
      GOTO 10;                              _GO PERFORM DUMP           ?
    END;
_***********************************************************************
*     BAD TUP INPUT MESSAGE                                            *
***********************************************************************?
    BAD:  
    20: PBLOAD(JUTUPOUT,ERRMSG,             _LOAD *ERR MESSAGE         ?
               J1FRSTCHAR,LSTCHAR); 
_?
    END; _CASE? 
    JUNEEDFLG := TRUE;                      _SET NEED TUP OUTPUT FLAG  ?
    JUPARAM[0].JVLSTFLG := TRUE;            _SET LAST PARAMETER FLAG   ?
    IF (TTY = JBASSIGNTABLE[J2TUPINPUT]) &
       ((JUDPLFLG & (TTY " JBASSIGNTABLE[J2TUPDUMP])) ! 
       (TTY " JBASSIGNTABLE[J2TUPOUT])) THEN
    BEGIN                                   _TUP OUTPUT NOT TO CONSOLE ?
      LRP := JCOPSLRP;                      _COPY OPS CONSOLE LRP      ?
      WITH LRP DO 
      BEGIN 
        JCPOINTER := PBGET1BF(B0S32);       _GET BUFFER                ?
        JCBUFSZE  := B0S32;                 _SET OUTPUT BUFFER SIZE    ?
        JCIMMEDFLG := TRUE;                 _REQUEST IMMEDIATE OUTPUT  ?
        PBLOAD(JCPOINTER,J0SETUP,           _LOAD CR LF ASTERISK       ?
               J1FRSTCHAR,LSTCHAR); 
        PBIOSERV(LRP,ERR);                  _OUTPUT TO CONSOLE         ?
      END;
    END;
  END; _WITH? 
END; _PBDECODET?
