* DEBUGGER FOR PASCAL PRODUCT *
* SYSTEM INTERFACE            *
* rdq JAN 82 rdq scs  SEP 82 rdq SEP 84 *
* SEP 84 changes made to allow operation in 32 bit address space *
* CHANGES MARKED BY CHG32
* COPYRIGHT (C) 1984 HEWLETT-PACKARD CO. 1.0
	NOSYMS
	SPRINT
*
	DEF     REALDEBUGGER
*
	REFA    LOADER,sysglobals                       (scs)
	REFA    ASM_NEWWORDS
	REFA    SYSBUG_CALLSYSCODE
	REFA    ASM_CACHE_OFF,ASM_FLUSH_ICACHE,ASM_ICACHE_OFF   CHG32
	REFA    ASM_CACHE_MODE
	LMODE   SYSBUG_CALLSYSCODE,ASM_NEWWORDS
	LMODE   ASM_CACHE_OFF,ASM_FLUSH_ICACHE,ASM_ICACHE_OFF   CHG32
	LMODE   ASM_CACHE_MODE

*
T15OP   EQU     $4E4F
JMPOP   EQU     $4EF9
RTSOP   EQU     $4E75
SYSFLAG2 EQU    $FFFFFEDA
E@DIV   EQU     $3242   BOOT ROM LOCATIONS
E@MPY   EQU     $31A6

BUS_ERRORV EQU  $FFFFFFFA
GLOBALBASE EQU  LOADER-66       PROGRAM GLOBAL BASE
RBASEPTR   EQU  LOADER-50       PROGRAM RELOCATION BASE
SYSDEFS    EQU  LOADER-70       SYSTEM SYMBOL TABLE
escapecode equ  sysglobals-2                              (scs)
recoverblk equ  sysglobals-10                             (scs)
ioresult   equ  sysglobals-22                             (scs)
DEFADDR EQU     6
DEFSIZE EQU     10
RUNFLAG EQU     1       (rdq)
*
*       PROCEDURE DEBUGGER(OP:INTEGER; P1,P2:INTEGER);
*
*       SP+12   OP      A6+16
*       SP+8    P1      A6+12
*       SP+4    P2      A6+8
*       SP      RETURN  A6+4
*       A6
*       SR

	DC.W    0               DUMMY PROC INFO
REALDEBUGGER EQU    *
	movem.l (sp)+,a0-a3     return address, parameters      (scs)
	trap    #11             move into supervisor mode       (scs)
	move    (sp)+,d0        user's status register          (scs)
	movem.l a0-a3,-(sp)     push paramters, return address  (scs)

	LINK    A6,#-4          GET LOCAL SPACE
	move    d0,-4(a6)       SAVE STATUS REG                 (scs)
	MOVE    #$2700,SR       BLOCK INTERUPTS
	MOVE.B  DSTATUS2,D7     SAVE CURRENT RUNFLAG
	BSET    #RUNFLAG,DSTATUS2       NOW RUNNING             (rdq)
	MOVE.L  16(A6),D0       GET OPCODE
	TST.L   D0              RANGE CHECK IT
	BMI.S   BADOPCODE
	CMPI.L  #8,D0           MAX VALUE                       (rdq)
	BGT.S   BADOPCODE
	ASL.L   #2,D0            * 4
	LEA     DBUGOPS,A0      GET EXECUTE ADDRESS
	MOVEA.L 0(A0,D0),A0
	JMP     (A0)
DBUGOPS DC.L    DBUGINIT  0     POWER ON INITIALIZE
	DC.L    DBUGSPRG  1     PROGRAM STARTING
	DC.L    DBUGEPRG  2     PROGRAM ENDED
	DC.L    DBUGKBD   3     CALL FROM KEYBOARD ISR
	DC.L    DBUGIPLT  4     IMPLANT CALL FROM SYSTEM/USER
	DC.L    DBUGLNUM  5     SYS WANTS LAST LINE #
	DC.L    DBUGPAUSE 6     NON ISR WANTS PAUSE
	DC.L    DBUGRESET 7     RESET KEY HOOK                  (rdq)
	DC.L    DBISRIPLT 8     IMPLANT CALL FROM ISR
BADOPCODE EQU   *
*
DEBUGXIT EQU    *
	BCLR    #1,DSTATUS      CLEAR WAIT FLAG
DEBUGXIT2 EQU   *
	BTST    #RUNFLAG,D7
	BNE.S   DEBUGXITX                                               (rdq)
	BCLR    #RUNFLAG,DSTATUS2                                       (rdq)
DEBUGXITX move  -4(a6),d0       GET CALLERS SR                          (scs)
	unlk    a6                                                      (scs)
	MOVEA.L (SP)+,A0        GET RETURN ADDRESS
	ADDA.L  #12,SP          POP ARGS
	move    d0,sr           restore caller's status register        (scs)
	JMP     (A0)
	TTL     INITIALIZE DEBUGGER VARIABLES
	PAGE
DBUGINIT EQU    *       INITIALIZE DEBUGGER VARIABLES
	MOVE.L  #HIBUGRAM,D0    CLEAR CONTROL VARIABLES
	SUB.L   #LTFLAGS,D0
	LSR.W   #2,D0   DIV 4
	LEA     LTFLAGS,A0
	MOVEQ   #0,D1
DBGINIT0 MOVE.L D1,(A0)+
	DBRA    D0,DBGINIT0
*
*       ALLOW 64 ENTRIES IN TRACE QUEUE
*
	PEA     QSTART          GET SPACE FROM HEAP
	MOVE.L  #128,-(SP)      QUEUE BUFFER FOR 64 LINES
	JSR     ASM_NEWWORDS
	MOVEA.L QSTART,A0
	MOVE.L  A0,QLAST
	LEA     256(A0),A0
	MOVE.L  A0,QEND
*
*       INITIALIZE INPUT STACK AREA  JWS 6/12/85
*
	PEA     INSTACK
	MOVE.L  #12,-(SP)       NEED 24 BYTES
	JSR     ASM_NEWWORDS
	MOVE.L  INSTACK,D0
	ADDQ.L  #4,D0
	MOVE.L  D0,INSTACKB
	ADD.L   #20,D0
	MOVE.L  D0,INSTACKE
*
*       ALLOW 10 IMPLANTS OF 80 TEXT CHARACTERS
*
	PEA     IMFIRST         GET IMPLANT SPACE
	MOVE.L  #450,-(SP)      IMSIZE * 10 IMPLANTS / 2  CHG32 rdq
	JSR     ASM_NEWWORDS
	MOVEA.L IMFIRST,A0
	ADDA.L  #900,A0         IMSIZE * 10               CHG32 rdq
	MOVE.L  A0,IMLAST
	MOVEQ   #9,D1           CLEAR BREAK POINTS
DBUGINIT1 SUBA.L #IMSIZE,A0
	CLR.B   (A0)            CLEAR STATUS BYTE
	MOVE.B  #IMSIZE-10,8(A0) SET MAX CHARS.           CHG32 rdq
	DBRA    D1,DBUGINIT1
*                               GET K0..K9 SPACE
	PEA     KDATAP
	MOVE.W  #UDKSIZE,D0
	LSR.W   #1,D0   DIV 2 TO GET WORDS
	MULU    #10,D0
	MOVE.L  D0,-(SP)        UDKSIZE * 10 VARIABLES
	JSR     ASM_NEWWORDS
	BSR     DINITK4         SET DEFAULT K4 VALUE
*
	PEA     RECALLV         SPACE FOR RECALL
	MOVE.L  #RECALLMAX,D0
	LSR.L   #1,D0   DIV 2
	MOVE.L  D0,-(SP)
	JSR     ASM_NEWWORDS
*       CLR.B   RECALLV MARK RECALL EMPTY  *** DELETE 5/9/85 JWS
	MOVE.B  #2,DSCODE       DEFAULT FORMAT
	BSR.S   PSETUP
	MOVEA.L G_DOLLAR,A0     SAVE STOP RECOVER
	MOVE.L  recoverblk(A0),INITRECOVER                              (scs)
	move    -4(A6),initsr                                           (scs)
	MOVE.W  #JMPOP,D0       TAKE CONTROL OF
	MOVE.W  D0,TRAP0V       SELECTED VECTORS
	MOVE.L  #TRAP0,TRAP0V+2
	MOVE.W  D0,TRACEV
	MOVE.L  #TRACE,TRACEV+2
	MOVE.W  D0,TRAP15V
	MOVE.L  #TRAP15,TRAP15V+2
	MOVE.W  #RTSOP,SYMBOLHOOK  NO_OP SYMBOL TABLE HOOK
	PEA     UEXCPI          ERROR TRAP COMMAND STRING
	MOVE.L  #41,-(SP)
	JSR     ASM_NEWWORDS
	MOVEA.L UEXCPI,A0
	MOVE.W  #$5000,(A0)     80 MAX, CURRENT SIZE 0
	ADDQ.L  #1,UEXCPI       MAKE IT POINT TO STRING PART
*
	JSR     ASM_FLUSH_ICACHE
	BRA     DEBUGXIT
*
PSETUP  EQU     *
	CLR.L   LASTLINE        CLEAR QUEUE
	BSR     QLINE
	MOVE.W  #RTSOP,DEBUGESCAPE   KILL ESCAPE TRAP
	JSR     ASM_FLUSH_ICACHE     CHG32   3/23/85

TRACECLR BSR    CLRFLASH        CLEAR LINE AREA
	MOVE.B  #$80,LTFLAGS    KILL TRACE CONTROL
	MOVE.B  #$80,TFLAGS
	RTS
	TTL     INITIALIZE FOR PROGRAM START
	PAGE
DBUGSPRG EQU    *       SYSTEM WILL START A PROGRAM
	BSR     PSETUP
	MOVE.L  #2,LASTLINE     MARK PROG START IN QUEUE
	BSR     QLINE
	TST.L   8(A6)           DEBUGGER TO CONTOL ?
	BEQ     DEBUGXIT
	MOVEA.L IMFIRST,A0      SET BREAK #0
	MOVEA.L 12(A6),A1
	MOVE.L  A1,2(A0)         ADDRESS     CHG32 3/25/85
	MOVE.B  #$31,(A0)
	ADDQ.L  #6,A0           CHG32  3/23/85
	MOVE.W  (A1),(A0)+      CODE
	MOVE.W  #T15OP,(A1)     SET TRAP 15
	ADDQ.L  #1,A0
	MOVE.B  #26,(A0)+       STRING LENGTH
	LEA     SMSG,A1
DBUGSP_1 MOVE.B  (A1)+,(A0)+
	BNE     DBUGSP_1
*       TRAP ALL EXCEPTIONS EXCEPT ESC 0 AND STOP
	MOVE.W  #JMPOP,DEBUGESCAPE
	MOVE.L  #UEXCPE,DEBUGESCAPE+2
	JSR     ASM_FLUSH_ICACHE     CHG32  3/23/85
	MOVE.B  #2,NUMET        RESET ESCAPE TRAP
	CLR.W   ETCODES         IGNORE ESC 0
	MOVE.W  #-20,ETCODES+2  IGNORE STOP
	BRA     DEBUGXIT        SYSTEM RECOVER
SMSG    DC.B    'BC PC^;D "NOW AT START";? ',0
*
*       CONTROL THE EXIT FROM KEYBOARD ISR
*
CALLDEBUG EQU   *
	BCLR    #1,DSTATUS RELEASE PAUSE/STEP
	BNE.S   DEBUGXIT3  CALL LATER EXIT
	LEA     DBUGCMDS,A1
CTRLEXIT EQU    *       :CONTROL FROM KEYBOARD ISR
	BCLR    #RUNFLAG,DSTATUS2                       (rdq)
	MOVE.L  A1,PCTEMP       SET TARGET ADDRESS
	MOVE.W  #-22,escapecode(A5)     DO ESCAPE(-22)                  (scs)
	MOVEA.L recoverblk(A5),SP                                       (scs)
	RTS
DEBUGXIT3 EQU   *
	BSET    #6,DSTATUS SET CALL DEBUG FLAG
	BRA     DEBUGXIT2  THEN EXIT NORMALY
	TTL     CLEANUP AFTER PROGRAM ENDED
	PAGE
DBUGEPRG EQU    *       PROGRAM ENDED
	MOVEA.L G_DOLLAR,A0
	MOVE.L  recoverblk(A0),INITRECOVER                              (scs)
	move    -4(a6),initsr                                           (scs)
	TST.L   LASTLINE
	BEQ     DEBUGXIT        QUEUE EMPTY
	MOVEQ   #4,D0
	CMP.L   LASTLINE,D0
	BEQ     DEBUGXIT        ALREADY ENDED
	MOVE.L  D0,LASTLINE
	BSR     QLINE   MARK PROG ENDED IN QUEUE
	BSR     CLRBRKS         DISABLE ALL IMPLANTS
	BSR     BRDACA  DEACTIVATE ALL
	MOVE.W  #RTSOP,DEBUGESCAPE   KILL ESCAPE TRAP
	JSR     ASM_FLUSH_ICACHE
	BSR     TRACECLR        CLEAR FLASH DISPLAY AND
*                               TRACE/STEP FUNCTIONS
	BRA     DEBUGXIT
	TTL     PROCESS DEBUGGER SYSTEM KEYS
	PAGE
DBUGKBD EQU     *       DEBUGGER KEY RECIEVED
*                       P1=STATUS; P2=DATA
	CMPI.B  #$38,11(A6)     PAUSE ?
	BNE.S   DBUGKEY0
	BTST    #5,15(A6)       IF CTRL PAUSE THEN
	BEQ     CALLDEBUG       CALL INTERPRETER
	BSET    #1,DSTATUS      ALREADY WAITING ?
	BNE     DEBUGXIT2       THEN EXIT
	MOVE.B  #'p',TEMPR
	BSR     EXCHANGERUN     SWITCH RUNLIGHT WITH TEMPR
	LEA     WAITC,A1        WAIT FOR CONTINUE
	BRA     CTRLEXIT
*
DBUGKEY0 CMPI.B #$33,11(A6)     STEP
	BNE.S   DBUGKEY2
	BTST    #5,15(A6)       CTRL STEP
	BEQ.S   DBUGKEY1
*               is step         go to step mode
	ORI.B   #$42,LTFLAGS    SET STEP & FLASH BITS (1,6)
	BCLR    #2,LTFLAGS      CLEAR COUNT BIT (2)
	MOVEQ   #'s',D0
	BSR.S   SHOWSTAT0
	BRA     DEBUGXIT
*               is ctrl step    go to flash mode
DBUGKEY1 BSET   #6,LTFLAGS      SET FLASH FLAG
	ANDI.B  #$F9,LTFLAGS    CLEAR STEP & COUNT BITS (1,2)
	MOVEQ   #'f',D0         SET WAITING CHARACTER
	BSR.S   SHOWSTAT0
	BRA     DEBUGXIT
*
DBUGKEY2 CMPI.B #$3A,11(A6)     CONTINUE
	BNE     DEBUGXIT2       ignore unknown key
	BSR     CLRFLASH
	ANDI.B  #$B9,LTFLAGS    CLEAR STEP,FLASH & COUNT (BITS 1,2,6)
	BRA     DEBUGXIT
*
SHOWSTAT0 MOVE.B D0,STAT0CHAR
	MOVEQ   #5,D0
	BRA     SYSCALL9        (SYSCALL9 DOES RTS)
*
DBUGIPLT EQU    *       CALL FOR COMMAND EXECUTE
	MOVE.L  12(A6),TEMPL    GET STRING ADDR.
	TST.B   M68KTYPE        FAKE EXCEPTION ON STACK         (rdq)
	BEQ.S   DBUGIPLTA                                       (rdq)
	CLR.W   -(SP)           FAKE VECTOR WORD                (rdq)
DBUGIPLTA PEA   DEBUGXIT2                                       (scs)
	MOVE    #$2700,-(SP)    SYS MODE PRIORITY 7             (scs)
	BRA     DBUGOBEY
*
DBISRIPLT EQU   *       CALL FOR COMMAND EXECUTE FROM ISR
	MOVEA.L 12(A6),A0       GET STRING ADDR.
	MOVEQ   #0,D0
	MOVE.B  (A0)+,D0        GET STRING SIZE
	CMPI.B  #DINBUFMAX,D0   RANGE CHECK SIZE
	BLE.S   DBISR1
	MOVEQ   #DINBUFMAX,D0   CLIP IT
DBISR1  LEA     DINSIZE,A1
	MOVE.B  D0,(A1)+
	BRA.S   DBISR3
DBISR2  MOVE.B  (A0)+,(A1)+     COPY STRING TO INPUT BUFFER
DBISR3  DBRA    D0,DBISR2
	LEA     DBISRX,A0       SET TO RETURN HERE
	BRA     CTRLEXIT
*
DBISRX  TST.B   M68KTYPE        FAKE EXCEPTION & DO COMMAND
	BEQ.S   DBISRX1
	CLR.W   -(SP)
DBISRX1 MOVE.L  PCTEMP,-(SP)
	MOVE.W  SRTEMP,-(SP)
	MOVE.L  #DINSIZE,TEMPL
	BRA     DBUGOBEY
*
DBUGLNUM EQU    *       SYSTEM WANTS LAST LINE No.
	MOVEA.L 12(A6),A2       GET ADDRESS OF VAR.
	BSR     GETLNUM
	MOVE.L  (A0),(A2)       SET THE NUMBER
	BRA     DEBUGXIT2
*
WAITC   EQU     *       WAIT FOR CONTINUE TYPE KEY
	TST.B   M68KTYPE        RESTORE USER RTE INFO.
	BEQ.S   WAITC0
	CLR.W   -(SP)           FAKE VECTOR WORD
WAITC0  MOVE.L  PCTEMP,-(SP)
	MOVE.W  SRTEMP,-(SP)
	BCLR    #6,DSTATUS      CLEAR CALL FLAG
	MOVE    #$2000,SR       ALLOW KEYBOARD INTERUPTS
WAITC1  BTST    #1,DSTATUS      WAIT FOR FLAG TO CLEAR
	BNE     WAITC1
	MOVE    #$2100,SR       BLOCK KEYBOARD
	MOVE.L  D0,-(SP)
	BSR     RESTORERUN      RESTORE RUNLIGHT
	MOVE.L  (SP)+,D0
	BCLR    #6,DSTATUS
	BNE     DBUGCMD2
	RTE
	PAGE
DBUGPAUSE EQU   *       NON ISR WANTS TO PAUSE
	BSET    #1,DSTATUS      SET WAIT FLAG
	MOVE.W  -4(A6),SRTEMP   SAVE SR
	MOVE    SR,-4(A6)       SWITCH SR FOR RETURN TO WAITC
	MOVE.L  4(A6),PCTEMP    SAVE RETURN
	LEA     WAITC,A0        FAKE RETURN
	MOVE.L  A0,4(A6)
	MOVE.B  #'p',TEMPR
	BSR     EXCHANGERUN
	BRA     DEBUGXIT2       EXIT TO WAIT
*
DBUGRESET EQU   *       RESET KEY PRESSED       SETUP FOR ACTION
	LEA     DEBUGESCAPE,A0
	MOVEM.W (A0),A1-A3
	MOVEM.W A1-A3,SAVEHOOK
	MOVE.W  #JMPOP,(A0)+
	MOVE.L  #DORESET,(A0)   LOAD HOOK
	JSR     ASM_FLUSH_ICACHE     CHG32   3/23/85
	BRA     DEBUGXIT2
*
DORESET MOVE.W  SAVEHOOK,DEBUGESCAPE    RESTORE THE ESCAPE HOOK
	MOVE.L  SAVEHOOK+2,DEBUGESCAPE+2
	JSR     ASM_FLUSH_ICACHE     CHG32   3/23/85
	ADDQ.L  #4,SP                   POP RETURN ADDRESS
	MOVEM.L A0-A6/D0-D7,-(SP)       SAVE REGISTERS
	BSR     KBEEP
	MOVEM.L (SP)+,A0-A6/D0-D7       RESTORE REGISTERS
	BTST    #RUNFLAG,DSTATUS2       DEBUGGER RUNNING ?
	BEQ.S   DORESET1
	BSET    #4,DSTATUS2             RESET HAPPENED
	RTE                             HOPE FLAG IS SEEN
DORESET1 BCLR   #1,DSTATUS      RELEASE PAUSE/STEP
	BEQ.S   DBUGCMD2
	BSET    #6,DSTATUS      SET CALL FLAG THEN EXIT
	RTE
*
	TTL     COMMAND INTERPRETER
	PAGE
*------------------------------------------------
*------------------------------------------------
* DEBUGGER COMMAND INTERPRETER
*------------------------------------------------
*------------------------------------------------
* rdq SEP 81
*
DBUGOBEY EQU    *       EXTERNAL CALL TO OBEY
*       ENTRY HERE IS FROM EXCEPTION PROCESSES  (IMPLANT EXECUTION)
	BSR     SAVEREGS
	BSR.S   MONPREP
	BCLR    #0,DSTATUS2     CHECK 2nd STRING FLAGFLAG
	BEQ.S   DBUGOBEY1
	MOVEA.L TEMPL2,A0       PUSH 2nd STRING
	BSR     A0A23
	BSR     PUSHIN
DBUGOBEY1 EQU   *
	MOVEA.L TEMPL,A0        GET STRING PTR
	BCLR    #6,DSTATUS      CHECK CALL FLAG
	BNE.S   DEBUGC_2
	BSET    #5,DSTATUS      SET DONE FLAG
	BRA.S   DEBUGC_2        DO IT
*
DBUGCMDS EQU    *       ENTRY TO DEBUGGER COMMAND INTERPRETER
*       ENTRY HERE IS FROM DEBUGGER SYSTEM INTERFACE
	TST.B   M68KTYPE                                        (rdq)
	BEQ.S   DBUGCMDX                                        (rdq)
	CLR.W   -(SP)           FAKE VECTOR WORD                (rdq)
DBUGCMDX MOVE.L PCTEMP,-(SP)    RESTORE REAL PC
	MOVE.W  SRTEMP,-(SP)    RESTORE REAL SR
*
DBUGCMD2 EQU    *       ENTRY TO DEBUGGER COMMAND INTERPRETER
*       ENTRY HERE IS FROM EXCEPTION PROCESSES
	BSR     SAVEREGS
	BSR     SAVECRT
	BSR.S   MONPREP
DEBUGC_1 EQU    *                                       (rdq)
	BCLR    #4,DSTATUS2     CLEAR RESET REQUEST     (rdq)
	BSR     DINPUT          GET A LINE FROM KEYBOARD
	MOVEA.L IMFIRST,A1
	CLR.B   (A1)            KILL GT/TT BREAK POINT
	BCLR    #6,DSTATUS2     KILL TRACE MODE
	ANDI.B  #$CF,LTFLAGS    KILL P PX AND PN COMMANDS (BITS 4,5)
DEBUGC_2 BSR    OBEY            EXECUTE THE COMMAND STRING
	BCLR    #5,DSTATUS      ALL DONE YET
	BEQ     DEBUGC_1
	BSR.S   USRPREP
	BCLR    #7,DSTATUS      ERROR IN PREP ?
	BNE     DEBUGC_1
	BSR     UNSAVECRT
	BRA     UNSAVEREGS      RESTART USER CODE
*
MONPREP EQU     *       COMPLETE CONTEXT SWITCH
*                       ADJUST OPERATING PRIORITY
	MOVE.W  REGSR,D0                        {rdq}
	ANDI.W  #$0F00,D0                       {rdq}
	BNE.S   MONPREP1                        {rdq}
	MOVE    #$0100,D0       AT LEAST LOCKOUT KEYBOARD
MONPREP1 ORI.W  #$2000,D0                       {rdq}
	MOVE    D0,SR                           {rdq}
*
	BSR     CLRBRKS         CLEAN UP BREAK POINTS
	BSR     INPUTCLR        CLEAR INSTACK
	MOVEQ   #2,D0
	BSR     SYSCALL9        SWITCH RUNLIGHT TO 'd'
	MOVE.B  #4,OUTFLAGS     SET OUTPUT TO CRT ONLY
	BSR     WRCMD           SET STACK FRAME ^
*                       SHOW LINE NUMBER
	BSET   #1,D7    DON'T DELAY IN FLASH
	BSR     GETLNUM
	CMPI.B  #6,D0   NUMBER
	BEQ     LFLASH  FLASH IT AND EXIT
	RTS
*
USRPREP EQU     *       FINAL CHECKS BEFORE USER
*                       GETS CONTROL
	BCLR    #4,DSTATUS2     CHECK RESET REQUEST
	BNE     ERRORX          DON'T EXIT IF SET
	BTST    #0,REGPC+3      CHECK PC
	BNE.S   BADPC
	BSR     GETSP           CHECK STACK POINTER
	BTST    #0,3(A0)
	BEQ.S   UPREPB
BADPC   LEA     BADPCM,A0
	BSR     OUTMSG
	BRA     ERRORX
BADPCM  DC.B    'PC/SP HAS ODD ADDRESS',0
*
UPREPB  BCLR    #7,REGSR        CLEAR TRACE BIT
	MOVE.W  #$0104,ACCUMT
	MOVE.L  REGPC,ACCUMD    CHECK FOR BP
	BSR     FINDACBR
	BNE.S   UPREPC
	BSET    #7,DSTATUS2     EXEC THRU BP
	BSET    #7,REGSR        SET TRACE BIT
	BRA.S   UPREPX
UPREPC  BTST    #6,DSTATUS2     TRACE MODE
	BEQ.S   UPREPD
	BSET    #7,REGSR
UPREPD  BSR     SETBRKS         SET TRAP15'S
UPREPX  MOVEQ   #3,D0
	BRA     SYSCALL9        CLEAR FLASH & RESTORE RUNLIGHT
*       RTS             (SYSCALL9 DOES RTS)
*
SAVECRT EQU     *       SAVE USER CRT
	BTST    #4,DSTATUS      CRT SAVED ALREADY ?
	BNE.S   RETURNA
	BSR.S   CRTEXCHG
	BSET    #4,DSTATUS      MARK CRT SAVED
RETURNA RTS
*
CRTEXCHG MOVE.B #0,-(SP)        EXCHANGE CRT/MEMORY
	BRA     JCALL0
*
UNSAVECRT EQU   *       RESTORE USER CRT
	BTST    #4,DSTATUS      ALREADY UNSAVED ?
	BEQ     RETURNA
	BSR     CRTEXCHG
	BCLR    #4,DSTATUS      CRT NOW UNSAVED
	RTS
*
*
SAVEREGS EQU    *
	BSET    #RUNFLAG,DSTATUS2               (rdq)
	BTST    #0,DSTATUS      REGS SAVED ?
	BNE     RETURNA
	MOVEM.L D0-D7/A0-A6,REGS
	MOVEA.L (SP)+,A1        GET RETURN ADDR
	MOVE.W  (SP)+,REGSR
	MOVE.L  (SP)+,REGPC
	PEA     SAVEREGS1                      CHG32
	MOVE    SR,-(SP)
	RTE
*
SAVEREGS1 MOVE.L SP,REGA7       REAL STACK POINTER
	MOVE    USP,A0
	MOVE.L  A0,REGUS
	BSET    #0,DSTATUS      REGS SAVED
	MOVE.W  DEBUGESCAPE,SAVEESC             SWITCH ESCAPE VECTOR
	MOVE.L  DEBUGESCAPE+2,SAVEESC+2         (rdq)
	MOVE.W  #JMPOP,DEBUGESCAPE              (rdq)
	MOVE.L  #EXTERRTRAP,DEBUGESCAPE+2       (rdq)
	JSR     ASM_FLUSH_ICACHE                     CHG32  3/23/85
	JMP     (A1)
*
UNSAVEREGS EQU  *
	MOVEA.L REGUS,A0
	MOVE    A0,USP
	MOVEM.L REGS,D0-D7/A0-A7
	TST.B   M68KTYPE
	BEQ.S   UNSAVEREGS1
	CLR.W   -(SP)           FAKE FORMAT WORD
UNSAVEREGS1 MOVE.L REGPC,-(SP)
	MOVE.W  REGSR,-(SP)
	BCLR    #0,DSTATUS      REGS NOT SAVED
*                               RESTORE ESCAPE VECTOR
	MOVE.W  SAVEESC,DEBUGESCAPE             (rdq)
	MOVE.L  SAVEESC+2,DEBUGESCAPE+2         (rdq)
	JSR     ASM_FLUSH_ICACHE                     CHG32  3/23/85
	BCLR    #RUNFLAG,DSTATUS2               (rdq)
	RTE     RETURN TO USER
*
MBUSERR DC.B    9,'BUS ERROR ',0
MONBUS  LEA     MBUSERR+1,A0
*
ESCAPE  MOVEA.L -4(A6),SP       CODE IS IN A0
EEXIT   RTS
*
RESTORE_BUSV EQU  *                             (rdq)
	BCLR    #3,DSTATUS      SET RECOVERY CODE NOT IN PLACE
	MOVEM.W SAVEBUS,D0-D2                   (rdq)
	MOVEM.W D0-D2,BUS_ERRORV                (rdq)
	RTS                                     (rdq)
*
OBEYERR EQU     *       MESSAGE ADDR IN A0
	BSR     RESTORE_BUSV                    (rdq)
	UNLK    A6      REMOVE TRAP POINTER
	ANDI.B  #$5F,DSTATUS    CLR ERROR & DONE FLAGS
	ANDI.B  #$FC,OUTFLAGS   CLR CHK & BUFFER FLAGS
	BSET    #2,OUTFLAGS     SET CRT FLAG
	BSR     OUTEOL
	MOVE.L  A0,D0   ERROR CODE 0 = EXIT
	BEQ     EEXIT
	BCLR    #6,DSTATUS2     CLEAR TRACE BIT
OUTMSG  EQU     *       A0 HAS ADDRESS OF TEXT
OBEYE   MOVE.B  (A0)+,D0
	BEQ     OUTEOL  END MESSAGE AND RETURN
	BSR     OUTBYTE OUTPUT THE MESSAGE
	BRA     OBEYE
*
* EXECUTION COMES HERE FROM DEBUGESCPE VECTOR
* ERROR CONDITION OCCURED IN DEBUGGER BUT SYSTEM TRAPPED IT
EXTERRTRAP EQU  *
	MOVEA.L G_DOLLAR,A5
	CMPI.W  #-28,ESCAPECODE(A5)
	BEQ.S   PTRAP0
	RTS                     IGNORE ANYTHING BUT PARITY ERROR
PTRAP0  LEA     PARITYMSG+1,A0
	BTST    #3,DSTATUS      RECOVERY OK ?
	BNE     ESCAPE          YES
	BCLR    #0,OUTFLAGS     NO
PTRAP1  MOVE.B  (A0)+,D0
HANGIT  BEQ.S   HANGIT          HANG WHEN LAST CHAR OUT
	BSR     CRTOUT
	BRA     PTRAP1
*
*       A0 CONTAINS STRING ADDRESS
*
*       CHG32                   DON'T CLEAR HIGH BYTE OF ADDRESS
A0A23   MOVEA.L A0,A2           COPY TO A2 FOR USE
	MOVEQ   #0,D0
	MOVE.B  (A2)+,D0        SIZE
	MOVEA.L A2,A3           END POINTER
	ADDA.L  D0,A3
	RTS
*
*       GIVEN A0 AS A COMMAND POINTER  EXECUTE THE COMMAND(S)
*
OBEY    EQU     *
	BSET    #5,DSTATUS2     SET FLAG TO ALLOW EXECUTION
	BSR     A0A23   CONVERT A0 TO A2 A3
	LINK    A6,#-4  ERROR RECOVERY & SCRATCH SPACE
	PEA     OBEYERR
	MOVE.L  SP,-4(A6)
*                               SWAP CONTROL OF BUS ERROR VECTOR
	MOVEM.W BUS_ERRORV,D0-D2
	MOVEM.W D0-D2,SAVEBUS
	MOVE.W  #JMPOP,BUS_ERRORV
	MOVE.L  #MONBUS,BUS_ERRORV+2
	JSR     ASM_FLUSH_ICACHE     CHG32  3/23/85
	BSET    #3,DSTATUS      RECOVERY CODE NOW IN PLACE
*
*                       A2 IS FRONT POINTER
*                       A3 IS END POINTER
CMDLOOP BSR     IFEOI   CHECK FOR END OF INPUT
	BEQ     OBEYEND
	MOVE.B  (A2)+,D0        1ST. CHAR
	CMPI.B  #';',D0 END OF COMMAND ?
	BEQ     CMDLOOP NULL COMMAND
	CMPI.B  #' ',D0
	BEQ     CMDLOOP
	CMPI.B  #'?',D0         HANDLE ? COMMAND HERE   (rdq)
	BNE.S   CMDL00          RDQ 3/15/84 ? SUBJECT TO IF CONTROL
	BTST    #5,DSTATUS2     .
	BNE     CMDIN           .
	BRA     CMDL7           RDQ 3/15/84
*                               CHECK FOR IMPLIED D COMMAND
CMDL00  CMPI.B  #'A',D0         IMPLIED D COMMAND
	BCS.S   IMPDCMD         IF 1st CHAR IS UPPER OR LOWER ALPHA
	CMPI.B  #'Z',D0
	BLS.S   CMDL0
	CMPI.B  #'a',D0
	BCS.S   IMPDCMD
	CMPI.B  #'z',D0
	BHI.S   IMPDCMD
CMDL0   LSL.W   #8,D0
	MOVE.B  #' ',D0 PAD WITH BLANK
	BSR     IFTERM
	BEQ.S   CMDL1
	CMPI.B  #' ',(A2)
	BEQ.S   CMDL1
	MOVE.B  (A2)+,D0        2ND. CHAR
	CMPI.W  #'EL',D0        ELSE COMMAND
	BNE.S   CMDL1
	BCHG    #5,DSTATUS2     TOGGLE THE XQT ENABLE
	BRA     CMDL7
CMDL1   CMPI.W  #'EN',D0        END COMMAND
	BNE.S   CMDL2
	BSET    #5,DSTATUS2     SET XQT ENABLE
	BRA     CMDL7
CMDL2   LEA     CMDTAB,A0       ADDRESS OF COMMAND TABLE
CMDCHKEND TST.W (A0)
	BPL.S   CMDL3
*                       COMMAND NOT FOUND
WHATERR LEA     WHATM,A0
	BRA     ESCAPE
WHATM   DC.B    'WHAT?',0
SYNTAXE LEA     SYNTAXM,A0
	BRA     ESCAPE
SYNTAXM DC.B    'SYNTAX ERROR',0
*       IMPLIED D COMMAND
IMPDCMD MOVE.B  D0,-(A2)        PUT BACK THE CHARACTER
	BSR     PUSHIN
	LEA     DOPC,A2
	LEA     2(A2),A3
	BRA     CMDLOOP         RESTART THE SCAN
DOPC    DC.B    'D '
*
CMDL3   MOVE.W  (A0)+,D1        GET CMD FROM TABLE
	CMPI.B  #'@',D1
	BEQ.S   CMDL3A
	CMPI.B  #'#',D1
	BNE.S   CMDL4   SECOND CHAR IS 0..7
	CMPI.B  #'0',D0
	BCS.S   CMDL5
	CMPI.B  #'9',D0
	BHI.S   CMDL5
CMDL3A  MOVE.B  D0,D1   REPLACE LOW BYTE
CMDL4   CMP.W   D0,D1
	BEQ.S   CMDXQT
CMDL5   ADDQ.L  #2,A0   NO MATCH YET
	BRA     CMDCHKEND
*
CMDXQT  BTST    #5,DSTATUS2     XQT OR NOT
	BEQ.S   CMDL7
	MOVE.W  D0,D1   SAVE D0
	BTST    #7,(A0) BLANK CHECK
	BEQ.S   CMDXQT1
	BSR     IFTERM
	BEQ.S   CMDXQT1
	CMPI.B  #' ',(A2)
	BNE     WHATERR
CMDXQT1 BTST    #6,(A0) IGNORE REST OF COMMAND
	BEQ.S   CMDXQT2
	BSR     FINDCMD
CMDXQT2 MOVE.W  (A0),D0 GET ROUTINE ADDRESS
	ANDI.W  #$3FFF,D0       STRIP CONTROL           (rdq)
	MOVEA.W D0,A0
	MOVE.W  D1,D0   RESTORE D0
	JSR     CMDTAB(A0)      DO IT
	BCLR    #7,DSTATUS      ERROR RETURN ?
	BNE.S   CMDL8
CMDL7   BSR     FINDCMD POSITION TO NEXT COMMAND
	BRA     CMDLOOP
CMDL8   BCLR    #5,DSTATUS      KILL DONE FLAG
	RTS
*
OBEYEND BSR     RESTORE_BUSV                    (rdq)
	UNLK    A6      NORMAL EXIT
	RTS
	PAGE
BLNKCHK EQU     $8000
SIMPLE  EQU     $C000
CMDTAB  EQU     *
	DC.W    'A7'
	DC.W    SETA7-CMDTAB+BLNKCHK
	DC.W    'AA'
	DC.W    DUMPAA-CMDTAB+SIMPLE
	DC.W    'A#'
	DC.W    SETAREG-CMDTAB+BLNKCHK
	DC.W    'B@'
	DC.W    BRCMDS-CMDTAB+BLNKCHK
	DC.W    'CA'
	DC.W    CALLCMD-CMDTAB+BLNKCHK
	DC.W    'DD'
	DC.W    DUMPDD-CMDTAB+SIMPLE
	DC.W    'D#'
	DC.W    SETDREG-CMDTAB+BLNKCHK
	DC.W    'D '
	DC.W    DCMD-CMDTAB
	DC.W    'DE'
	DC.W    DECMD-CMDTAB+SIMPLE
	DC.W    'D@'
	DC.W    DAGCMD-CMDTAB+SIMPLE
	DC.W    'EC'
	DC.W    ESCCMD-CMDTAB+BLNKCHK
	DC.W    'ET'
	DC.W    ETCMD-CMDTAB
	DC.W    'F@'
	DC.W    FCMD-CMDTAB+SIMPLE
	DC.W    'G@'
	DC.W    GOCMD-CMDTAB
	DC.W    'IF'
	DC.W    IFCMD-CMDTAB+BLNKCHK
	DC.W    'K#'
	DC.W    UDKCMDS-CMDTAB+BLNKCHK
	DC.W    'O@'
	DC.W    OPENCMD-CMDTAB+BLNKCHK
	DC.W    'PC'
	DC.W    SETPC-CMDTAB+BLNKCHK
	DC.W    'P@'
	DC.W    PROCCMD-CMDTAB+SIMPLE
	DC.W    'Q@'
	DC.W    QCMD-CMDTAB+SIMPLE
	DC.W    'sb'
	DC.W    SYSBOOT-CMDTAB+BLNKCHK
	DC.W    'SF'
	DC.W    WDUMP-CMDTAB+SIMPLE
	DC.W    'SR'
	DC.W    SETSR-CMDTAB+BLNKCHK
	DC.W    'SP'
	DC.W    SETSP-CMDTAB+BLNKCHK
	DC.W    'TD'
	DC.W    TDCMD-CMDTAB+BLNKCHK
	DC.W    'T@'
	DC.W    TCMD-CMDTAB
	DC.W    'US'
	DC.W    SETUS-CMDTAB+BLNKCHK
	DC.W    'WD'
	DC.W    WCMD-CMDTAB+SIMPLE
	DC.W    'WS'
	DC.W    WSCMD-CMDTAB+SIMPLE
	DC.W    'WR'
	DC.W    WRCMD-CMDTAB+SIMPLE
	DC.W    -1
	PAGE
CMDIN   SUBA.L  A0,A0   NO MESSAGE
	BRA     ESCAPE  FORCE TO INPUT COMMANDS
*
DEFTD   DC.B    'D PC:"PC=", SR:"SR=",H2 PC^:" ",X;AA;DD '
DEFTDE  EQU *   SET DEFAULT TD IN K4
DINITK4 LEA     DEFTD,A0
	MOVE.L  A0,K4DATA+2     ADDRESS
	LEA     DEFTDE,A1
	SUBA.L  A0,A1
	MOVE.W  A1,K4DATA       SET SIZE
	MOVE.B  #$83,K4DATA     MARK AS ALPHA
	RTS
*
SB_DEFAULT CMPI.B  #'*',(A2)
	   RTS
SYSBOOT EQU     *
*
*               10/21/88 DEW & QUIST
*               ADDED SUPPORT FOR NAMED REBOOT EXTENSTIONS
*
*===========================================================
* KLUDGE ADDED 2/11/91. If you do an 'sb' command from the
* debugger and an FP exception is pending, the reboot fails
* and the system hangs. Could be a Boot ROM bug. JWH 2/11/91.
	BTST       #3,SYSFLAG2
	BNE        NOTTA_40
	trap       #11
	FSAVE      256
	fmove.l    #0,FPSTATUS
	move       (sp)+,SR
NOTTA_40   equ   *
*==========================================================
	BSR     FINDNP
	BSR     IFTERM  IF AT END OF COMMAND
	BNE.S   SB_NEW
SB_OLD  CLR     $FFFFFDC2       CLEAR SYSTEM NAME
SB_GOROM EQU    *
	CLR.B   -(SP)           ROM CACHE MODE
	JSR     ASM_CACHE_MODE  TURN OFF ALL CACHES
*
* JWH 1/17/94
* Defect fix for named reboot problem spotted by the NSA.
* Suspected cause - uninitialized variable in the secondary
* loader. Fix - zero out the memory where the secondary
* loader will be loaded/executed - RAM just below HIGHMEM.
* This seems to fix the problem. Note : HIGHMEM = $FFFFFB00.
*
	LEA     $FFFE0000,A0    128K DOWN - SEEMS SAFE
	LEA     HIGHMEM,A1      HIGHMEM - $FFFFFB00
SB_ZERO EQU     *
	MOVE.L  #0,(A0)+
	CMPA.L  A1,A0
	BLT     SB_ZERO         < NOT <=
*
* Now jump to BOOT ROM :
*
	JMP     $1C0            HAVE BOOT ROM BOOT A SYSTEM
SB_NEW  EQU     *
SB_NAME EQU     * GET THE SYSTEM NAME.
	BSR     SB_DEFAULT  CHECK FOR DEFAULT CHARACTER
	BEQ.S   SB_MSUS
	BSR     GVALUE      GET THE USERS SYSTEM NAME AND VERIFY
	CMPI.B  #$83,ACCUMT
	BNE.S   SB_NERR
	MOVEQ   #0,D0
	MOVE.B  ACCUMS,D0
	CMPI.B  #$10,D0
	BGT.S   SB_NERR
	CMPI.B  #$0,D0
	BEQ.S   SB_MSUS
	MOVE.L  D0,D1       NAME VERIFIED, MOVE PADDED W/SPACES TO ROM
	SUBI.L  #1,D0
	LEA     $FFFFFDC2,A0
	MOVEA.L ACCUMD,A1
SB_T1   MOVE.B  (A1)+,(A0)+
	DBRA    D0,SB_T1
	MOVEQ   #10,D0
	SUB.B   D1,D0
	BRA.S   SB_T3
SB_T2   MOVE.B  #' ',(A0)+
SB_T3   DBRA    D0,SB_T2
	BRA.S   SB_MSUS
NERRSTR DC.B    'BAD SYSTEM NAME',0
SB_NERR EQU     *  THE NAME ENTERED IS NOT A GOOD ONE.
	LEA     NERRSTR,A0
	BRA     ESCAPE
SB_MSUS EQU     *
	BSR     FINDNP
	BSR     IFTERM  IF AT END OF COMMAND
	BEQ     SB_GOROM        DEFAULT THE MSUS AND THE STATION ADDRESS.
	BSR     SB_DEFAULT      IF CHARACTER IS THE DEFAULT CHARACTER
	BEQ.S   SB_ST_ADDR      DEFAULT MSUS, GET THE STATION ADDR.
	CMPI.B  #'#',(A2)       FS UNIT NUMBER REQUEST?
	BEQ.S   SB_FSUNIT
	LEA     -1(A2),A2       GETCOUNT CALLS FINDNP
	BSR     GETCOUNT        GET THE USERS MSUS
	MOVE.L  ACCUMD,$FFFFFEDC   GOOD NUMBER FROM USER, PUT IT IN ROM D AREA
	BRA.S   SB_ST_ADDR
FSUNITSTR DC.B   'UNIT NUMBER INVALID FOR BOOT.',0
SB_UNITERR EQU *
	LEA     FSUNITSTR,A0
	BRA     ESCAPE
SB_FSUNIT EQU    *
	MOVE.B  #' ',(A2)
	BSR     GETCOUNT
	MOVE.L  ACCUMD,TEMPL
	MOVEQ   #10,D0
	BSR     SYSCALL
	TST.L   TEMPL3
	BNE     SB_UNITERR
	MOVE.L  TEMPL2,$FFFFFEDC
SB_ST_ADDR EQU  *       CHECK FOR A STATION ADDRESS
	BSR     FINDNP
	BSR     IFTERM          IF AT END OF COMMAND
	BEQ     SB_GOROM        DEFAULT THE STATION ADDRESS.
	BSR     SB_DEFAULT      IF CHARACTER IS THE DEFAULT CHARACTER
	BEQ     SB_GOROM
	BSR     GVALUE          GET THE USERS STATION ADDRESS
	CMPI.B  #$83,ACCUMT
	BNE.S   SB_SERR
	CMPI.B  #12,ACCUMS
	BNE.S   SB_SERR         MUST BE 12 CHARACTERS.
	MOVEQ   #11,D1
	MOVEA.L ACCUMD,A2
	MOVE.W  #16,BASE
	LEA     TEMPL,A0
	MOVEQ   #0,D2
SB_ST1  EQU     *               CONVERT THE 12 DIGIT ADDR TO 6 BYTE #
	MOVE.B  (A2)+,D0
	BSR     GETHEX
	BCLR    #7,DSTATUS      CHECK FOR AN ERROR
	BNE.S   SB_SERR
	BTST    #0,D1
	BEQ.S   SB_ST2
	MOVE.B  D0,D2           BIT IS SET, PUT IN LOW NIBBLE OF D2
	BRA.S   SB_ST3
SB_ST2  EQU     *               SHIFT D2, PUT IN LOW NIBBLE, STORE
	ASL     #4,D2
	OR.B    D0,D2
	MOVE.B  D2,(A0)+
	MOVEQ   #0,D2
SB_ST3  EQU     *
	DBRA    D1,SB_ST1
	LEA     TEMPL,A0
	BTST    #0,(A0)         reject broadcast and multicast
	BNE.S   SB_SERR
	MOVEA.L $FFFFFED4,A1
	MOVE.L  (A0)+,(A1)+
	MOVE.W  (A0),(A1)
	BRA     SB_GOROM
SERRSTR DC.B    'STATION ADDRESS ERROR.',0
SB_SERR EQU     *
	LEA     SERRSTR,A0
	BRA     ESCAPE
*
IFCMD   BSR     GETGVALUE       IF COMMAND
	TST.B   ACCUMT
	BEQ     SYNTAXE
	BSR     LSIZE
	TST.L   ACCUMD
	BEQ.S   IFCMDC
	BSET    #5,DSTATUS2     EXECUTE NEXT COMMAND
	RTS
IFCMDC  BCLR    #5,DSTATUS2     DON'T EXECUTE NEXT COMMAND
	RTS
*
ESCCMD  EQU     *       ESCAPE COMMAND
	BSR     GETCOUNT
	BSR     WSIZE
	BTST    #0,REGA7+3
	BNE     BADPC
	BTST    #0,REGPC+3
	BNE     BADPC
	LEA     FAKEESC,A0      GET RETURN ADDRESS
	MOVEA.L G_DOLLAR,A5
	MOVE.W  ACCUMD,ESCAPECODE(A5)   SET ESCAPE CODE
FAKEXIT MOVE.L  REGPC,PCTEMP    SAVE PC & SR
	MOVE.L  A0,REGPC        CONTROL THE RETURN
	MOVE.W  REGSR,SRTEMP
	MOVE.W  #$2700,REGSR
	BSR     INPUTCLR
	MOVE.W  #'G ',D0
	BRA     GOCMD
*
FAKEESC TST.B  M68KTYPE        GENERATE EXCEPTION INFO
	BEQ.S   FESC1
	MOVE.W  #$A8,-(SP)      FAKE VECTOR WORD
FESC1   MOVE.L  PCTEMP,-(SP)
	MOVE.W  SRTEMP,-(sp)
	ANDI.B  #$07,SRTEMP     MASK PRIORITY
	BSET    #5,SRTEMP       SET SUPER BIT
	MOVE    SRTEMP,SR
	JMP     TRAP10V JUMP TO TRAP #10 VECTOR

CALLCMD EQU     *               CALL COMMAND
	BSR     GETADDR         GET ROUTINE ADDRESS
	BTST    #0,3(A0)
	BNE     ADDRERROR
	MOVE.L  (A0),TEMPL4
	BTST    #0,REGPC+3      CHECK RETURN PC
	BNE     BADPC
	BSR     GETSP           CHECK STACK POINTER
	BTST    #0,3(A0)
	BNE     BADPC
	LEA     DOCALL,A0       SET RETURN ADDRESS
	BRA     FAKEXIT
*
DOCALL  MOVE    SRTEMP,SR
	MOVE.L  PCTEMP,-(SP)
	MOVE.L  TEMPL4,-(SP)
	RTS

*       CHECK FOR END OF BUFFER/COMMAND
IFTERM  BSR.S   IFEOI   CHECK FOR END OF INPUT
	BEQ.S   IFTRET
	CMPI.B  #';',(A2)   END OF COMMAND
IFTRET  RTS
*       CHECK FOR END OF INPUT
IFEOI   CMPA.L  A2,A3
	BNE.S   IFEOI0
	BSR.S   POPIN
	BNE     IFEOI
IFEOI0  RTS
*
*       ROUTINES TO HANDLE INPUT STACK
*       GET NEXT ENTRY
POPIN   MOVEA.L INSTACK,A2
	MOVEA.L A2,A3           COPY IN CASE IS END
	CMPA.L  INSTACKE,A2     JWS 6/12/85
	BEQ.S   POPEND          EMPTY
	MOVEQ   #0,D7
	MOVE.W  (A2)+,D7         SIZE  JWS 6/11/85
	MOVEA.L (A2)+,A3        END POINTER
	MOVE.L  A2,INSTACK      SAVE IN PTR.
	MOVEA.L A3,A2
	SUBA.L  D7,A2           FRONT POINTER
POPEND  RTS
*
*       PUT NEXT ENTRY
PUSHIN  MOVEA.L INSTACK,A0      STACK HAS MAX 4 ENTRIES
	CMPA.L  INSTACKB,A0
	BEQ.S   PUSHERR         OVERFLOW
	MOVE.L  A3,-(A0)        SAVE END
	MOVE.L  A3,D7           JWS 6/12/85
	SUB.L   A2,D7           JWS 6/12/85
	MOVE.W  D7,-(A0)        JWS 6/12/85 SAVE SIZE
	MOVE.L  A0,INSTACK
	RTS
PUSHERR LEA     PUSHEM,A0
	BRA     ESCAPE
PUSHEM  DC.B    'INPUT OVERFLOW',0
INPUTCLR MOVEA.L INSTACKE,A0     KILL FURTHER INPUT
	MOVE.L  A0,INSTACK
	MOVEA.L A2,A3
	RTS
	TTL     COMMAND EXECUTE CODE
	PAGE
*
* COMMAND EXECUTE CODE
*
SETBRKS EQU     *       SET TRAP15'S
	MOVEM.L A0-A1,-(SP)
	MOVEA.L IMFIRST,A0
SETBRKS1 CMPI.B #$11,(A0)       ADDRESS BREAK
	BNE.S   SETBRKS2
	MOVEA.L 2(A0),A1        CHG32   3/23/85
	MOVE.W  (A1),6(A0)      GET USER CODE/ CHG32 3/23
	MOVE.W  #T15OP,(A1)
	BRA.S   SETBRKS3
SETBRKS2 CMPI.B #$12,(A0)       LINE BREAK
	BNE.S   SETBRKS4
	BSET    #0,LTFLAGS
SETBRKS3 BSET   #5,(A0) MARK ACTIVE
SETBRKS4 ADDA.L #IMSIZE,A0      NEXT BREAK
	CMPA.L  IMLAST,A0
	BNE     SETBRKS1
	JSR     ASM_FLUSH_ICACHE
	MOVEM.L (SP)+,A0-A1
	RTS
*
CLRBRKS EQU   *       ROUTINE TO DISABLE IMPLANTS
	MOVEM.L A0/A1,-(SP)
	MOVEA.L IMFIRST,A0      CLEAR ACTIVE INST. BREAKS
CLRIB3  CMPI.B  #$31,(A0)       T15 BREAK ?
	BNE.S   CLRIB4
	MOVEA.L 2(A0),A1        CHG32  3/23/85
	MOVE.W  6(A0),(A1)      RESTORE USER CODE/CHG32
CLRIB4  BCLR    #5,(A0)         MARK INACTIVE
	ADDA.L  #IMSIZE,A0
	CMPA.L  IMLAST,A0
	BNE     CLRIB3
CLRBXIT MOVEM.L (SP)+,A0/A1
	BCLR    #0,LTFLAGS
	JSR     ASM_FLUSH_ICACHE
	RTS
	PAGE
*       SET/DISPLAY REGISTERS
*
SETA7   LEA     REGA7,A0
	BRA.S   SETREG
*
SETAREG CMPI.B  #'7',D0
	BHI     WHATERR
	LEA     AREGS,A0
REGOFSET ANDI.L #$F,D0
	LSL.L   #2,D0   * 4
	ADDA.L  D0,A0   REG ADDR
	BRA.S   SETREG
*
SETDREG CMPI.B  #'7',D0
	BHI     WHATERR
	LEA     DREGS,A0
	BRA     REGOFSET
*
SETPC   LEA     REGPC,A0
	BRA.S   SETREG
*
SETUS   LEA     REGUS,A0
	BRA.S   SETREG
*
SETSP   BSR     GETSP
*
SETREG  MOVE.L  A0,-(SP)        SAVE POINTER
	BSR     GETGVALUE       VALUE ?
	TST.B   ACCUMT
	BEQ.S   DUMPREG
	BSR     SIZE4           MAKE 4 BYTES
	BSR     AFETCH          GET DATA IF ADDRESS
	MOVEA.L (SP)+,A0        GET REG ADDRESS
	MOVE.L  ACCUMD,(A0)
	RTS
	PAGE
BLANK   DC.B    '  '
DUMPREG MOVE.W  #$0104,ACCUMT   ADDRESS TYPE 4 BYTES
	MOVE.L  (SP)+,ACCUMD    ADDRESS OF REG
DUMPR2  BSR     PUSHIN  SAVE CURRENT INPUT
	LEA     BLANK,A2
	LEA     1(A2),A3        BLANK FORMAT
	BSR     FORMAT  DUMP THE REGISTER
	BRA     OUTEOL  NEW LINE (IT DOES RTS)
*
SETSR   BSR     GETGVALUE
	TST.B   ACCUMT
	BNE.S   SETSR1
	MOVE.W  #$0402,ACCUMT   HEX 2 BYTES
	MOVE.W  REGSR,ACCUMD
	BRA     DUMPR2
SETSR1  BSR     UPKACCM
	CMPI.B  #1,D0   ADDRESS ?
	BNE.S   SETSR2
	BSR     AFETCH
	MOVE.B  #2,ACCUMS       SET SIZE2
SETSR2  BSR     SIZE2
	MOVE.W  ACCUMD,REGSR
	RTS
*
DRFMT   DC.B    ' D0:/,"D0=", D3:"D3=",'
	DC.B    ' D6:"D6=", D1:/,"D1=",'
	DC.B    ' D4:"D4=", D7:"D7=",'
	DC.B    ' D2:/,"D2=", D5:"D5=",'
DRFMTE  EQU     *
*
ARFMT   DC.B    ' A0:/,"A0=", A3:"A3=",'
	DC.B    ' A6:"A6=", A1:/,"A1=",'
	DC.B    ' A4:"A4=", SP:"SP=",'
	DC.B    ' A2:/,"A2=", A5:"A5=",'
ARFMTE  EQU     *
*
*       DUMP D REGS COMMAND
*
DUMPDD  BSR     PUSHIN
	LEA     DRFMT,A2
	LEA     DRFMTE,A3
	BRA.S   DCMD
*
*       DUMP A REGS COMMAND
*
DUMPAA  BSR     PUSHIN
	LEA     ARFMT,A2
	LEA     ARFMTE,A3       DROP TO DCMD
	PAGE
*
* DUMP / DISPLAY COMMAND
*
DCMD    EQU     *
DCMD0   BSR     INGVALUE
	TST.B   ACCUMT
	BEQ     OUTEOL  CR LF THEN EXIT
	BSR     IFTERM
	BEQ.S   DCMD1
	MOVE.B  (A2)+,D0
	CMPI.B  #' ',D0
	BEQ.S   DCMD2
	CMPI.B  #':',D0
	BNE     SYNTAXE
DCMD1   CLR.W   LINECOUNT       COUNT OUTPUT LINES
	BSET    #0,OUTFLAGS
	BSR     FORMAT          PRINT IT
	BCLR    #0,OUTFLAGS     DON'T COUNT LINES
	BRA     DCMD0
*
DCMD2   SUBQ.L  #1,A2   BACKUP
	BRA     DCMD1   BLANK FORMAT
*
	PAGE
*       DUMP EXCEPTION DATA
EXCPM   DC.B    11,'-EXCEPTION-'
EXFMT1  DC.B    '  EC:"ESCAPE CODE",I2 '
EXFMT1E EQU     *
EXFMT2  DC.B    '"INFO=",H2,"ADDRESS=",,"INSTR=",H2,/  '
EXFMT2E EQU     *
EXFMT3  DC.B    '"SR=",H2,"PC=",,2>,"LINE",I  '                 68000
EXFMT3E EQU     *
EXFMT4  DC.B    '"SR=",H2,"PC=",,"FMT=",H2,"LINE",I '           680xx
EXFMT4E EQU     *
EXFMT5  DC.B    '"INFO=",H2,"ADDRESS=",,2>,/,'
	DC.B    '"DATA OUT=",I2,2>,"IN=",I2,2>,"INSTR=",H2,/ '
EXFMT5E EQU     *
* EXFMT6 IS NO LONGER USED
* 68020 FORMATS
EXFMT7  DC.B    '"ERROR PC=",,/  '
EXFMT7E EQU     *
EXFMT8  DC.B    '"ERROR PC=",,4>,"ERROR EA=",,/  '
EXFMT8E EQU     *
EXFMT9  DC.B    '"INFO=",H4,8>,"ADDRESS=",,/,"DATA=",,/ '
EXFMT9E EQU     *
EXFMT10 DC.B    '"INFO=",H4,8>,"ADDRESS=",,/,"DATA OUT=",,16>," IN=",,/ '
EXFMT10E EQU    *
*
*       DUMP EXCEPTION INFO COMMAND
*
DECMD   BSR     OUTEOL
	LEA     EXCPM,A0        PRINT "-EXECPTION-"
	BSR     OUTMSTR
	MOVEA.L G_DOLLAR,A5
	CMPI.W  #-12,escapecode(A5)             (scs)
	BEQ     BUSEXCP
	CMPI.W  #-11,escapecode(A5)             (scs)
	BEQ     ADDEXCP
	CMPI.W  #-28,ESCAPECODE(A5)             (rdq)
	BEQ     PARITYEXCP
*                               MISC. ESCAPE CODES
DECMD_A BSR     PUSHIN
	LEA     EXFMT1,A2       DUMP ESCAPE CODE
	LEA     EXFMT1E,A3
	BSR     DCMD            DUMP WILL POP INPUT
*                               DECODE & DISPLAY FRAME DATA
DECMD_B TST.B   M68KTYPE
	BEQ.S   EXCPEND
	MOVE.B  EXCP_VOFFSET,D0 have 680xx
	ANDI.B  #$F0,D0
	TST.B   D0
	BEQ.S   EXCPEND         format 0000
	MOVE.W  #$0104,ACCUMT
	MOVE.L  #ERR_INFO,ACCUMD
	BSR     PUSHIN
	CMPI.B  #$80,D0         format 1000
	BNE.S   DECMD_D
	LEA     EXFMT5,A2       is 68010 long format
	LEA     EXFMT5E,A3
DECMD_C BSR     FORMAT          PRINT IT
	BSR     FINDNP          REPOSITION THE INPUT
	BRA.S   EXCPEND
*   68020 FORMAT STUFF
DECMD_D CMPI.B  #$20,D0
	BNE.S   DECMD_E
	LEA     EXFMT7,A2       format 0010
	LEA     EXFMT7E,A3
	BRA     DECMD_C

DECMD_E CMPI.B  #$90,D0
	BNE.S   DECMD_F
	LEA     EXFMT8,A2       format 1001
	LEA     EXFMT8E,A3
	BRA     DECMD_C

DECMD_F CMPI.B #$A0,D0          format 1010
	BNE.S   DECMD_G
	LEA     EXFMT9,A2
	LEA     EXFMT9E,A3
	BRA     DECMD_C

DECMD_G CMPI.B #$B0,D0          format 1011
	BNE.S   EXCPEND
	LEA     EXFMT10,A2
	LEA     EXFMT10E,A3
	BRA     DECMD_C

EXCPEND BSR     PUSHIN
	MOVE.W  #$0104,ACCUMT
	MOVE.L  #EXCP_STATUS,ACCUMD
	TST.B   M68KTYPE                        (rdq)
	BEQ.S   EXCPEND1                        (rdq)
	LEA     EXFMT4,A2       680xx           (rdq)
	LEA     EXFMT4E,A3                      (rdq)
	BRA.S   EXCPEND2                        (rdq)
EXCPEND1 LEA    EXFMT3,A2       68000
	LEA     EXFMT3E,A3
EXCPEND2 BSR    FORMAT
	BRA     OUTEOL

BUSEXCP LEA     MBUSERR,A0                      (rdq)
BEDUMPR BSR     OUTMSTR
	TST.B   M68KTYPE                        (rdq)
	BNE     DECMD_B       do 680xx          (rdq)
	MOVE.W  #$0104,ACCUMT     BUG FIX 3.0
	MOVE.L  #ERR_INFO,ACCUMD  BUG FIX 3.0
	BSR     PUSHIN            BUG FIX 3.0
	LEA     EXFMT2,A2     is 68000
	LEA     EXFMT2E,A3
BEDUMPR3 BSR    FORMAT
	BSR     FINDNP  REPOSITION INPUT
	BRA     EXCPEND

ADDMSG  DC.B    13,'ADDRESS ERROR'
ADDEXCP LEA     ADDMSG,A0
	BRA     BEDUMPR

PARITYMSG DC.B  16,'RAM PARITY ERROR',0
PARITYEXCP LEA  PARITYMSG,A0
	BSR     OUTMSTR
	TST.L   FAULT_ADDR
	BEQ     EXCPEND
	BRA     DECMD_B
	PAGE
*       FORMAT DEFAULT SETTING COMMAND
*
FCMD    LEA     SPECT,A0
	MOVEQ   #16,D1          CHECK FOR OCTAL
	CMP.B   16(A0),D0
	BEQ.S   FCMD2
	MOVEQ   #6,D1
FCMD1   CMP.B   0(A0,D1),D0     SCAN FOR MATCH
	DBEQ    D1,FCMD1
	BNE     WHATERR
	CMPI.B  #2,D1
	BLT     WHATERR
	CMPI.B  #3,D1
	BEQ     WHATERR DON'T ALLOW ALPHA
FCMD2   MOVE.B  D1,DSCODE       SET THE DEFAULT
	RTS
	PAGE
*
T0NORM  ANDI.B  #$81,LTFLAGS    OFF BITS 1..6
	RTS
T0FLASH BSET    #6,LTFLAGS
	ANDI.B  #$C1,LTFLAGS    OFF BITS 1..5
	RTS
*
*       GO COMMAND
*
GOCMD   BCLR    #6,DSTATUS2     CLEAR TRACE BIT
	BSET    #2,DSTATUS      SET GO BIT
	BSR     T0NORM  NORMAL TRAP 0
	CMPI.B  #' ',D0
	BEQ.S   GOCMDA
	CMPI.B  #'F',D0
	BEQ.S   GOCMDB
	CMPI.B  #'T',D0
	BEQ.S   GOCMDD
	BRA     WHATERR
*
GOCMDA  BSR     GETCOUNT        COUNT OR NOTHING
	BEQ.S   GOUSER  CONDITION SET BY GETCOUNT
	MOVE.L  ACCUMD,TCOUNT
	BSET    #2,LTFLAGS      SET COUNT FLAG
GOUSER  BSET    #5,DSTATUS      SET DONE FLAG
	BRA     INPUTCLR        DISCARD INPUT BUFFER
*                               AND GO
GOCMDB  BSR     T0FLASH HAVE F LOOK FOR T
	BSR     IFTERM
	BEQ     GOUSER
	CMPI.B  #'T',(A2)
	BNE     GOCMDA
*
GOCMDC  BSR     BRSET   SET BREAK POINT
	BRA     GOUSER
*
GOCMDD  BSR     IFTERM  HAVE T LOOK FOR F
	BEQ     GOCMDC
	CMPI.B  #'F',(A2)
	BNE     GOCMDC
	BSR     T0FLASH
	BRA     GOCMDC
	PAGE
*       ESCAPE TRAP COMMAND
*
ETCMD   BSR     IFTERM
	BEQ.S   ETONLY
	MOVE.B  (A2),D0
	CMPI.B  #' ',D0
	BEQ.S   ETONLY
	CMPI.B  #'C',D0
	BEQ     ETIMP
	CMPI.B  #'N',D0
	BNE     SYNTAXE
* ERROR TRAP NOT
	MOVE.W  #RTSOP,SAVEESC          DEFAULT
	BSR.S   ETLIST                  NO LIST
	TST.B   NUMET   ANY LIST ?
	BEQ.S   ETCMDX
	MOVE.W  #JMPOP,SAVEESC
	MOVE.L  #UEXCPE,SAVEESC+2
ETCMDX  RTS
*
ETLIST  CLR.B   NUMET   COUNT
	LEA     ETCODES,A0
GETECODES EQU   *
	MOVE.L  A0,-(SP)
	BSR     GETCOUNT
	TST     D0      DONE ?
	BEQ.S   GETEXITA
	CMPI.B  #4,NUMET
	BEQ.S   TOOMANY
	BSR     WSIZE   TRIM TO WORD SIZE
	MOVEA.L (SP)+,A0
	MOVE.W  ACCUMD,(A0)+
	ADDI.B  #1,NUMET
	BRA     GETECODES
GETEXITA MOVEA.L (SP)+,A0
	RTS
TOOMM   DC.B    'TOO MANY CODES',0
TOOMANY LEA     TOOMM,A0
	BRA     ESCAPE
*
* ERROR TRAP ONLY
ETONLY  MOVE.W  #JMPOP,SAVEESC          DEFAULT
	MOVE.L  #UEXCPA,SAVEESC+2       NO LIST
	BSR     ETLIST
	TST.B   NUMET   ANY LIST ?
	BEQ.S   ETEXIT
	MOVE.L  #UEXCPO,SAVEESC+2
ETEXIT  RTS
*
ETIMP   BSR     GETGVALUE
	BSR     UPKACCM
	CMPI.B  #3,D0
	BNE     SYNTAXE
	MOVE.W  #JMPOP,SAVEESC
	MOVE.L  #UEXCPIMP,SAVEESC+2
	MOVE.L  UEXCPI,-(SP)  ADDRESS OF VECTOR
	BRA     BRSETC

	PAGE
*       DUMP LINE/PC QUEUE
*
QCMD    CMPI.B  #' ',D0
	BEQ.S   DUMPQ
	CMPI.B  #'S',D0
	BEQ.S   STARTQ
	CMPI.B  #'E',D0
	BNE     WHATERR
ENDQ    MOVEQ   #4,D0
	BCLR    #7,LTFLAGS
	BCLR    #7,TFLAGS
	BEQ     ETEXIT  ALREADY ENDED
	BRA.S   MARKQ
STARTQ  MOVEQ   #2,D0
	BSET    #7,LTFLAGS
	BSET    #7,TFLAGS
	BNE     ETEXIT  ALREADY STARTED
MARKQ   MOVE.L  D0,LASTLINE
	BRA     QLINE
*
DUMPQ   MOVEA.L QLAST,A0
	CLR.L   (A0)
	MOVE.L  A0,TEMPL
	BSR     QBWD
	BEQ     QEMPTY
	MOVE.B  #1,ACCUMT       ADDRESS
	MOVE.B  #4,ACCUMS       SIZE
QCMD0   MOVE.B  #21,TCOUNT      LOOP COUNT
QCMD1   MOVEA.L TEMPL,A0
	CMPI.L  #2,(A0) PROG START
	BEQ     QPROGS
	CMPI.L  #4,(A0) PROG END
	BEQ     QPROGE
	BSR     PUSHIN  SAVE CURRENT INPUT
	LEA     QFMT2,A2
	LEA     QFMT2E,A3
	MOVEA.L ACCUMD,A1
	CMPI.W  #$4E40,(A1)     LINE # ?
	BNE.S   QCMD2
	LEA     QFMT1,A2
	LEA     QFMT1E,A3
QCMD2   BSR     FORMAT
	BSR     FINDNP
QCMD3   BSR.S   QBWD    BACK UP IN THE Q
	BEQ.S   QCMDRET
	SUBQ.B  #1,TCOUNT
	BNE     QCMD1
	MOVEQ   #0,D1
QCMD4   LEA     QPMSG,A0
	BSR.S   OUTMSTR
	BSR     DINPUT
	BTST    #5,DSTATUS      DONE FLAG ?
	BNE.S   QCMDRET
	BSR     A0A23
	BSR     IFEOI
	BEQ     QCMD0
	BSR     SNEWCMD START NEW COMMAND
QCMDRET RTS
QPMSG   DC.B    5,'MORE '
*       BACK UP IN THE QUEUE
QBWD    MOVEA.L TEMPL,A0
	CMPA.L  QSTART,A0
	BNE.S   QBWD1
	MOVEA.L QEND,A0
QBWD1   TST.L   -(A0)
	BEQ.S   QBWDR
	MOVE.L  A0,TEMPL
	MOVE.L  (A0),ACCUMD
QBWDR   RTS
*
QFMT1   DC.B    '4>,*,2<,U2,/  '
QFMT1E  EQU     *
QFMT2   DC.B    '*,/ '
QFMT2E  EQU     *
*
QEMPM   DC.B    6,'EMPTY '
QEMPTY  LEA     QEMPM,A0
*
OUTMSTR MOVEQ   #0,D1
	MOVE.B  (A0)+,D1
	BSR     OUTALPHA
	BRA     OUTEOL  (IT DOES RTS)
QSPM    DC.B    6,'START '
QEPM    DC.B    4,'END '
QPROGS  LEA     QSPM,A0
QOUTM   BSR     OUTMSTR
	BRA     QCMD3
QPROGE  LEA     QEPM,A0
	BRA     QOUTM
	TTL     EXECUTION UTILITIES
	PAGE
*
*       GET LINE # OR ADDRESS   (LINE # IS 0..65535)
GETLNA  BSR     GETGVALUE
	BSR     UPKACCM
	TST     D0      ANY INPUT ?
	BEQ.S   GETLRET
	CMPI.B  #1,D0   ADDRESS ?
	BEQ.S   GETLRET
	BSR     LSIZE   MAKE ACCUM. NUMERIC INTEGER
	TST.W   ACCUMD
	BNE     SIZEERROR
	MOVE.B  #2,ACCUMS       REDUCE TO TWO BYTES
	MOVE.W  ACCUMD+2,ACCUMD LEFT JUSTIFY IT
	MOVE.B  #6,ACCUMT       TYPE IS UNSIGNED INT
	BSR     UPKACCM
GETLRET RTS
*
GETADDR BSR     GETGVALUE       GET ADDRESS
	BSR     UPKACCM
	TST     D0
	BEQ     SYNTAXE
	CMPI.B  #1,D0   ADDRESS ?
	BNE     TYPEERROR
	RTS
*
*       MAKE ACCUMULATOR ANY THING SIZE 1
SIZE1   BSR.S   SIZE2   REDUCE TO SIZE 2
	BSR     UPKACCM
	MOVEQ   #0,D2   SIGN
	CMPI.B  #2,D0   SIGNED ?
	BNE.S   SIZE1A
	BTST    #7,1(A0) CHECK SIGN
	SNE     D2
SIZE1A  CMP.B   (A0)+,D2
	BNE.S   SIZEERROR
	MOVE.B  #1,ACCUMS
	MOVE.B  (A0),ACCUMD
	RTS
*
*       MAKE ACCUMULATOR ANY THING SIZE 2
SIZE2   BSR     UPKACCM
	TST.B   D0      NULL
	BEQ.S   TYPEERROR
	CMPI.B  #3,D0   ALPHA
	BNE.S   WSIZE2
	CMPI.B  #2,D1
	BHI.S   SIZEERROR
	BRA.S   WSIZE2  ANY THING SIZE 2
*
* MAKE ACCUMULATOR NUMERIC WORD (2 BYTES)
*
WSIZE   BSR     UPKACCM
	CMPI.B  #3,D0
	BEQ.S   TYPEERROR       ALPHA
	TST.B   D0
	BEQ.S   TYPEERROR       NULL
WSIZE2  MOVEQ   #0,D2   SIGN
	CMPI.B  #2,D1   SIZE CHECK
	BEQ.S   WSIZED
	BCS.S   WSIZEB
	CMPI.B  #2,D0   SIGNED ?
	BNE.S   WSIZEA
	BTST    #7,-2(A0,D1)
	SNE     D2      SET SIGN BYTE
WSIZEA  CMP.B   (A0),D2 SIGN CHECK
	BNE.S   SIZEERROR
	ADDQ.L  #1,A0
	SUBQ.L  #1,D1
	CMPI.B  #2,D1
	BNE     WSIZEA
WSIZED  MOVE.B  (A0)+,ACCUMD
	MOVE.B  (A0),ACCUMD+1
	BRA.S   WSIZEC
WSIZEB  MOVE.B  (A0),ACCUMD+1   BYTE
	CLR.B   ACCUMD  ASSUME BYTE IS UNSIGNED
WSIZEC  MOVE.B  #2,ACCUMS
	BRA.S   SIZEXIT
*
SIZEERROR LEA   SIZEM,A0
	BRA     ESCAPE
TYPEERROR LEA   TYPEM,A0
	BRA     ESCAPE
SIZEM   DC.B    'SIZE ERROR',0
TYPEM   DC.B    'TYPE ERROR',0
*
SIZE4   BSR     UPKACCM
	TST.B   D0      NULL
	BEQ     TYPEERROR
	CMPI.B  #3,D0   ALPHA
	BNE.S   LSIZE4
	CMPI.B  #4,D1
	BHI     SIZEERROR
	MOVEQ   #0,D2
	BRA.S   LSIZEB  ANY THING SIZE 4
*
* MAKE ACCUMULATOR NUMERIC LONG
*
LSIZE   BSR     UPKACCM
	CMPI.B  #3,D0   ALPHA
	BEQ     TYPEERROR
	TST     D0      NULL
	BEQ     TYPEERROR
LSIZE4  MOVEQ   #0,D2
	BTST    #7,(A0)
	BEQ.S   LSIZEB
	CMPI.B  #2,D0   SIGNED ?
	BNE.S   LSIZEB
	MOVEQ   #-1,D2
	BRA.S   LSIZEB
LSIZEA  LSL.L   #8,D2
	MOVE.B  (A0)+,D2
LSIZEB  DBRA    D1,LSIZEA
	MOVE.B  #4,ACCUMS
	MOVE.L  D2,ACCUMD
SIZEXIT MOVE.B  D0,ACCUMT
	RTS
	TTL     COMMAND EXECUTE CODE
	PAGE
*       BREAK POINT(IMPLANT) COMMANDS
*
BRCMDS  BCLR    #2,DSTATUS      CLEAR GO/BR FLAG
	CMPI.B  #' ',D0
	BEQ.S   BRDUMP
	CMPI.B  #'C',D0
	BEQ     BRKILL
	CMPI.B  #'S',D0
	BEQ     BRSET
	CMPI.B  #'A',D0
	BEQ     BRACT
	CMPI.B  #'D',D0
	BEQ     BRDAC
	BRA     WHATERR
BRHEADER DC.B   12,'BREAK POINTS'
BRULINE DC.B    12,'------------'
BRDUMP  LEA     BRHEADER,A0
	BSR     OUTMSTR PRINT THE HEADER
	LEA     BRULINE,A0
	BSR     OUTMSTR
	BSR     GETLNA  DUMP BREAK POINT(S)
	TST     D0
	BNE.S   BRDUMPC
	MOVEA.L IMFIRST,A0      DUMP ALL
BRDUMPA TST.B   (A0)
	BEQ.S   BRDUMPB
	BSR.S   OUTBR
BRDUMPB ADDA.L  #IMSIZE,A0
	CMPA.L  IMLAST,A0
	BNE     BRDUMPA
	RTS
BRDUMPC BSR.S   FINDACBR
	BEQ.S   OUTBR   A0 HAS BREAK ADDRESS
	RTS
*
FINDACBR EQU    *       ACCUM HAS BR REF
*                       FIND THE BR
	MOVEA.L IMFIRST,A0
	BSR.S   FINDBRV
FINDBRA CMP.L   2(A0),D2        VALUE COMPARE  CHG32
	BEQ.S   FINDBRC         CHG32
FINDBRB ADDA.L  #IMSIZE,A0      CHG32
	CMPA.L  IMLAST,A0       CHG32
	BNE     FINDBRA         CHG32
	ANDI    #$FFF0,SR       CHG32  SET NE IN CCR
FINDRET RTS                     CHG32
FINDBRV CMPI.B  #1,ACCUMT       CHG32  GET VALUE IN D2
	BNE.S   FINDBR1         CHG32
	MOVE.L  ACCUMD,D2       CHG32
	RTS                     CHG32
FINDBR1 MOVEQ   #0,D2           CHG32
	MOVE.W  ACCUMD,D2       CHG32
	RTS                     CHG32
FINDBRC MOVE.B  ACCUMT,D2       CHG32
	CMPI.B  #1,D2           CHG32  ADDRESS
	BEQ.S   FINDBRD         CHG32
	MOVE.B  #2,D2           CHG32  LINE #
FINDBRD OR.B    (A0),D2         CHG32
	CMP.B   (A0),D2         CHG32
	BEQ     FINDRET         CHG32
	BSR     FINDBRV         CHG32
	BRA     FINDBRB         CHG32
*
*       DUMP ONE BREAK POINT
*
OUTBR   MOVE.L  A0,-(SP)        SAVE POINTER
	MOVE.B  #'A',D0
	BTST    #4,(A0)
	BNE.S   OUTBR0
	MOVE.B  #'D',D0
OUTBR0  BSR     OUTBYTE
	BSR     OUTBLANK
	BTST    #0,(A0) LINE OR ADDRESS
	BEQ.S   OUTBRA
	MOVEQ   #4,D1            CHG32
	ADDQ.L  #2,A0            4/9/85  JWS FIX BKPT DISP
	BSR     OUTADDR
	BRA.S   OUTBRB
OUTBRA  MOVEQ   #2,D1
	ADDQ.L  #4,A0            CHG32
	BSR     OUTUINT
OUTBRB  BSR     OUTBLANK
	MOVEA.L (SP),A0 RECALL THE POINTER
	LEA     9(A0),A0         CHG32
	CMPI.B  #$FF,(A0)
	BEQ.S   OUTBRC
	MOVEQ   #0,D1   COMMAND BREAK
	MOVE.B  (A0)+,D1
	BSR     OUTALPHA
	BRA.S   OUTBRD
OUTBRC  ADDQ.L  #1,A0   COUNT BREAK
	MOVE.W  #4,D1
	BSR     OUTINT
OUTBRD  MOVEA.L (SP)+,A0        RECALL THE POINTER
	BRA     OUTEOL
*
BRKILL  BSR     GETLNA
	TST     D0
	BNE.S   BRKILLB
	MOVEA.L IMFIRST,A0      KILL ALL
BRKILLA CLR.B   (A0)
	ADDA.L  #IMSIZE,A0
	CMPA.L  IMLAST,A0
	BNE     BRKILLA
	RTS
BRKILLB BSR     FINDACBR
	BNE.S   *+4
	CLR.B   (A0)
	RTS
*
BRACT   BSR     GETLNA  ACTIVATE BREAKS
	TST     D0
	BNE.S   BRACTC
	MOVEA.L IMFIRST,A0
BRACTA  TST.B   (A0)
	BEQ.S   BRACTB
	BSET    #4,(A0)
BRACTB  ADDA.L  #IMSIZE,A0
	CMPA.L  IMLAST,A0
	BNE     BRACTA
BRARET  RTS
BRACTC  BSR     FINDACBR
	BNE     BRARET
	BSET    #4,(A0)
	RTS
*
BRDAC   BSR     GETLNA  DEACTIVATE BREAKS
	TST     D0
	BNE.S   BRDACC
BRDACA  MOVEA.L IMFIRST,A0
BRDACB  BCLR    #4,(A0)
	ADDA.L  #IMSIZE,A0
	CMPA.L  IMLAST,A0
	BNE     BRDACB
BRDRET  RTS
BRDACC  BSR     FINDACBR
	BNE     BRDRET
	BCLR    #4,(A0)
	RTS
*
BRERRM  DC.B    'DUPLICATE BREAK',0
BRERR   LEA     BRERRM,A0
	BRA     ESCAPE
*
BRSET   BSR     GETLNA  SET BREAKPOINT
	TST     D0
	BEQ     SYNTAXE
	BTST    #2,DSTATUS      GT or TT ?
	BEQ.S   BRSET0
	BSR     FINDACBR        WATCH FOR DOUBLE
	BEQ     BRERR
	MOVEA.L IMFIRST,A0
	BRA     BRSETA  USE TABLE ENTRY 0
*
BRSET0  BSR     FINDACBR        LOOK IN TABLE
	BEQ.S   BRSETA
*       FIND EMPTY TABLE ENTRY
	MOVEA.L IMFIRST,A0
FINDBR0 ADDA.L  #IMSIZE,A0
	CMPA.L  IMLAST,A0
	BEQ.S   BRFULL
	TST.B   (A0)
	BNE     FINDBR0
	BRA.S   BRSETA
BRFULL  LEA     BRFULLM,A0
	BRA     ESCAPE
BRFULLM DC.B    'BR TABLE FULL',0
BRSETA  CMPI.B  #1,D0
	BEQ.S   BRSETA1
	MOVE.W  #$1200,(A0)+
	MOVE.W  #0,(A0)+        CHG32
	MOVE.W  ACCUMD,(A0)+    LINE NUMBER
	BRA.S   BRSETA2
BRSETA1 BTST    #0,ACCUMD+3     DON'T ALLOW ODD
	BNE     ADDRERROR
	MOVE.W  #$1100,(A0)+    CHG32
	MOVE.L  ACCUMD,(A0)+    CHG32  MEMORY ADDRESS
BRSETA2 ADDQ.L  #3,A0   SKIP CODE & MAX SIZE
	MOVE.L  A0,-(SP)
	BSR     GETGVALUE       COUNT/COMMAND
	TST.B   ACCUMT
	BNE.S   BRSETB
	CLR.L   ACCUMD  DEFAULT COUNT 0
	BTST    #2,DSTATUS      TT or GT ?
	BEQ.S   BRSETB1
	MOVE.B  #1,ACCUMD+3     count 1
	BRA.S   BRSETB1
*
BRSETB  BSR     UPKACCM SUPPLIED VALUE
	CMPI.B  #1,D0   ADDRESS
	BEQ     TYPEERROR
	CMPI.B  #3,D0   ALPHA
	BEQ.S   BRSETC
	BSR     LSIZE   MAKE IT LONG
BRSETB1 MOVEA.L (SP)+,A0        RECOVER POINTER
	MOVE.B  #$FF,(A0)+      FLAG AS COUNT
	MOVE.L  ACCUMD,(A0)+    MOVE VALUE
	RTS
BRSETC  MOVEA.L (SP)+,A1        RECOVER POINTER
	CMP.B   -1(A1),D1       WILL IT FIT ?
	BHI     SIZEERROR
	MOVE.B  D1,(A1)+        PUT SIZE
	BRA.S   BRSETE
BRSETD  MOVE.B  (A0)+,(A1)+     MOVE THE STRING
BRSETE  DBRA    D1,BRSETD
	RTS
	PAGE
*               K0..K9 COMMANDS
*
UDKCMDS EQU     *
	ANDI.W  #$000F,D0       GET DIGIT
	MOVE.W  D0,D1           SAVE DIGIT
	MULU    #6,D0
	LEA     K0DATA,A0
	ADDA.L  D0,A0   HAVE ^ TO INFO VECTOR
	MOVE.L  A0,-(SP)        SAVE I.V. POINTER
	MULU    #UDKSIZE,D1
	MOVEA.L KDATAP,A0
	ADDA.L  D1,A0   HAVE DATA AREA POINTER
	MOVE.L  A0,-(SP)        SAVE D.A. POINTER
*
	BSR     GETGVALUE
	TST.B   ACCUMT
	BNE.S   UDKC_A
	MOVEA.L (SP)+,A0        SKIP D.A. POINTER
	MOVEA.L (SP)+,A0        POP I.V. POINTER
	BSR     OUTINFO         PRINT INFO
	BRA     OUTEOL
*
UDKC_A  BSR     AFETCH  FETCH DATA IF ADDRESS
	BSR     UPKACCM UNPACK ACCUMULATOR
	CMPI.B  #UDKSIZE,D1     CHECK SIZE
	BHI     SIZEERROR
	MOVEA.L (SP),A1 RECALL D.A. POINTER
	MOVE.L  D1,D2   COPY SIZE
	BRA.S   UDKC_C
UDKC_B  MOVE.B  (A0)+,(A1)+     MOVE THE DATA
UDKC_C  DBRA    D2,UDKC_B
	MOVEA.L (SP)+,A0        POP D.A. POINTER
	MOVEA.L (SP)+,A1        POP I.V. POINTER
	BSET    #7,D0           MARK INDIRECT
	MOVE.B  D0,(A1)+        TYPE
	MOVE.B  D1,(A1)+        SIZE
	MOVE.L  A0,(A1) ADDRESS
	RTS
	PAGE
*       OPEN MEMORY FOR CHANGES FROM KEYBOARD
*
OSIZES  DC.B    'L@WB@'
OPENCMD LEA     OSIZES,A0
	MOVEQ   #4,D2
OPCMDA  CMP.B   (A0)+,D0
	DBEQ    D2,OPCMDA
	BNE     WHATERR
OPENA   MOVE.L  D2,TEMPL        SAVE SIZE
	BSR     GETADDR         GET ADDRESS
	CMP.L   TEMPL,D0        CHECK SIZE
	BEQ.S   OPENB
	BTST    #0,3(A0)        MUST BE EVEN
	BNE     ADDRERROR       ADDRESSING ERROR
OPENB   MOVE.L  (A0),TEMPL2     SAVE ADDRESS
	BSR     GETGVALUE       ANY DATA ?
	TST.B   ACCUMT
	BEQ.S   OPENC
	BSR.S   OPENASG DO ASSIGN THEN DONE
OPRET   RTS
OPENC   EQU     * PROMPT FOR DATA TO ASSIGN
	BSR     OPENP   ISSUE PROMPT
	BSR     PDINPUT INPUT DATA
	BTST    #5,DSTATUS      CONTINUE/STEP ?
	BNE     OPRET
	BCLR    #2,DSTATUS2
	BEQ.S   OPENE
	BSR     OUTEOL
	MOVE.L  TEMPL,D0        GET SIZE
	BTST    #3,DSTATUS2     UP/DOWN ?
	BEQ.S   OPEND
	ADD.L   D0,TEMPL2       UP ADDRESS
	BRA     OPENC
OPEND   SUB.L   D0,TEMPL2       DOWN ADDRESS
	BRA     OPENC
*
OPENE   BSR     A0A23   CONVERT A0 TO A2 A3
	BSR     PUSHIN
	LEA     BLANK,A2        PUT LEADING BLANK
	LEA     1(A2),A3        SO GETGVALUE WILL
	BSR     GETGVALUE       PICK UP THE DATA
	TST.B   ACCUMT
	BEQ     OPRET   NO DATA SO DONE
	BSR.S   OPENASG ASSIGN THE DATA
	BRA     OPENC   DO NEXT PROMPT
*
OPENASG EQU     *       ASSIGN ACCUM TO MEMORY
	BSR     UPKACCM
	CMPI.B  #3,D0   ALPHA ?
	BNE.S   OPENA_E
*       ASSIGN ALPHA
	MOVEA.L TEMPL2,A1       DEST ADDR
	BRA.S   OPENA_B
OPENA_A MOVE.B  (A0)+,(A1)+
OPENA_B DBRA    D1,OPENA_A
*       ADJUST THE DESTINATION ADDRESS
	MOVE.L  A1,D0
	CMPI.B  #1,TEMPL+3      BYTES ?
	BEQ.S   OPENA_D
	BTST    #0,D0   WORD or LONG
	BEQ.S   OPENA_C
	ADDQ.L  #1,D0   EVEN ADDRESS
OPENA_C CMPI.B  #4,TEMPL+3      LONG ?
	BNE.S   OPENA_D
	BTST    #1,D0
	BEQ.S   OPENA_D
	ADDQ.L  #2,D0
OPENA_D MOVE.L  D0,TEMPL2       SAVE ADDRESS
	RTS
OPENA_E BSR     AFETCH  IF ADDRESS GET 4 BYTES
	CMPI.B  #1,TEMPL+3
	BNE.S   OPENA_F
	BSR     SIZE1   MAKE BYTE SIZE
	MOVEA.L TEMPL2,A1
	MOVE.B  ACCUMD,(A1)+
	BRA.S   OPENA_H
OPENA_F CMPI.B  #2,TEMPL+3
	BNE.S   OPENA_G
	BSR     SIZE2   MAKE WORD SIZE
	MOVEA.L TEMPL2,A1
	MOVE.W  ACCUMD,(A1)+
	BRA.S   OPENA_H
OPENA_G BSR     SIZE4   MAKE LONG SIZE
	MOVEA.L TEMPL2,A1
	MOVE.L  ACCUMD,(A1)+
OPENA_H MOVE.L  A1,TEMPL2
	RTS
*
OPENP   EQU     *       OPEN PROMPT
	MOVEQ   #4,D1
	LEA     TEMPL2,A0
	BSR     OUTADDR PROMPT WITH ADDR
	BSR     OUTBLANK
*               SET DEFAULT FORMAT SPECS
	MOVE.B  DSCODE,ACCUMT
	MOVE.B  TEMPL+3,ACCUMS
	MOVEA.L TEMPL2,A0
	CMPI.B  #1,ACCUMS
	BNE.S   OPENP_A
	MOVE.B  (A0),ACCUMD
	BRA.S   OPENP_C
OPENP_A CMPI.B  #2,ACCUMS
	BNE.S   OPENP_B
	MOVE.W  (A0),ACCUMD
	BRA.S   OPENP_C
OPENP_B MOVE.L  (A0),ACCUMD
OPENP_C BSR     PUSHIN
	LEA     BLANK,A2        MAKE BLANK FORMAT
	LEA     1(A2),A3
	BSR     FORMAT  PROMPT WITH DATA VALUE
	BRA     OUTBLANK        PUT BLANK & DO RTS
	PAGE
*       EXECUTE THRU CURRENT PROC.
*
PROCCMD MOVE.L  REGA6,OLDA6
	BCLR    #6,DSTATUS2     CLEAR TRACE BIT
	BSR     T0NORM          NORMAL TRAP0 OPS
	CMPI.B  #' ',D0
	BEQ.S   PROCXIT
	CMPI.B  #'X',D0
	BEQ.S   PROCXIT
	CMPI.B  #'N',D0
	BNE     WHATERR
	BSET    #4,LTFLAGS      SET NEXT PROC FLAG
PROCXIT BSET    #5,LTFLAGS      SET EXIT PROC FLAG
	BRA     GOUSER
	PAGE
*       STACK FRAME COMMANDS
*
*       RESET STACKFRAME POINTER
*
WRCMD   MOVE.L  REGA6,SFA6
	BCLR    #0,SFA6+3       FORCE EVEN ADDR
	RTS
*
*       WALK BACK THRU DYNAMIC LINKS
*
WCMD    EQU     *
	BSR.S   WSTART
	BEQ.S   WCMDX   A5=(A6) SO NOW IN MAIN PROG
	MOVEA.L SFA6,A0
	MOVE.L  (A0),SFA6       UNLINK A6
	BSR     WDUMP   DUMP THE CALLER
WCMDX   RTS
WSTART  MOVEA.L SFA6,A0 CHECK
	MOVEA.L REGUS,A1        USER
	BTST    #5,REGSR        USER OR SYSTEM STACK ?
	BEQ.S   WSCHK
	MOVEA.L REGA7,A1        SYSTEM
*                       SP MUST BE < A6
WSCHK   CMPA.L  A1,A0
	BLT.S   NOTCOMP
	BSR     WDUMP   DUMP CURRENT PROC INFO
	BCLR    #7,DSTATUS
	BNE.S   NOTCOMP
	MOVEA.L G_DOLLAR,A1
	MOVEA.L SFA6,A0
	CMPA.L  (A0),A1
	RTS
*
NOTCOMP LEA     NOTCOMPM,A0
	BRA     ESCAPE
NOTCOMPM DC.B   'NON STANDARD CALL',0
WFMT1   DC.B    'U2,S,2>,/,'
WFMT2   DC.B    '"PROC ADDRESS ",*,/ '
WFMT2E  EQU     *
WFMT3   DC.B    '"STATIC LINK  ",*,/ '
WFMT3E  EQU     *
WFMT4   DC.B    '"CALLED FROM  ",*,/ '
WFMT4E  EQU     *
WFMT5   DC.B    '"CALLED FROM SYSTEM",/ '
WFMT5E  EQU     *
WFMT6   DC.B    '"       LINE  ",2>,U2,/ '
WFMT6E  EQU     *
*
WDUMP   BSR     PUSHIN  SAVE INPUT PTRS
	BSR     WPROC   FIND PROC HEADER
	BCLR    #7,DSTATUS      ERROR ?
	BNE     NOTCOMP
	TST.W   TEMPL2+2        DEBUG HEADER ?
	BEQ.S   WDUMPA
	MOVEQ   #0,D0
	SUBQ.L  #1,A0           SKIP FLAG BYTE
	MOVE.B  -(A0),D0        GET NAME SIZE
	SUBA.L  D0,A0   FRONT OF NAME
	SUBQ.L  #2,A0   FRONT OF LINE #
	LEA     WFMT1,A2
	LEA     WFMT2E,A3
	BRA.S   WDUMPB
WDUMPA  LEA     WFMT2,A2
	LEA     WFMT2E,A3
WDUMPB  MOVE.W  #$0104,ACCUMT
	MOVE.L  A0,ACCUMD
	BSR     FORMAT  DUMPIT
	BSR     FINDNP  CLEAN UP INPUT
	BSR     WPROC   FIND PROC HEADER AGAIN
	TST.W   TEMPL2  STATIC LINK ?
	BEQ.S   WDUMPB1
	MOVEA.L SFA6,A0
	ADDQ.L  #8,A0
	MOVE.L  (A0),ACCUMD     LINK
	BSR     PUSHIN
	LEA     WFMT3,A2        ADDRESS OF FORMAT
	LEA     WFMT3E,A3
	BSR     FORMAT
	BSR     FINDNP  CLEAN UP
WDUMPB1 BSR     PUSHIN
	LEA     WFMT5,A2
	LEA     WFMT5E,A3
	MOVE.L  TEMPL,ACCUMD    RETURN ADDRESS
	BEQ.S   WDUMPB5
	LEA     WFMT4,A2
	LEA     WFMT4E,A3
WDUMPB2 BSR     FORMAT
	BSR     FINDNP  CLEAN UP
*
	MOVEA.L SFA6,A0         TEMP WALK BACK
	MOVE.L  A0,-(SP)
	MOVE.L  (A0),SFA6
*               DOES CALLER HAVE DEBUG ON ?
	BSR.S   WPROC
	MOVE.L  (SP)+,SFA6      RESTORE POINTER
	BCLR    #7,DSTATUS      CLEAR ERROR
	TST.W   TEMPL2+2        DEBUG ON ?
	BEQ.S   WDUMPBX
	BSR.S   WPROC           REPOSITION
	MOVEA.L TEMPL3,A1       GET JSR ADDR
	LEA     -2(A1),A1
WDUMPB3 CMPI.W  #$4E40,-(A1)    TRAP 0 ?
	BEQ.S   WDUMPB4
	CMPA.L  A1,A0   PAST HEADER ?
	BNE     WDUMPB3
WDUMPBX RTS
WDUMPB4 MOVE.L  A1,ACCUMD       ADDR OF TRAP0
	BSR     PUSHIN  DUMP CALLING LINE NO.
	LEA     WFMT6,A2
	LEA     WFMT6E,A3
WDUMPB5 BRA     FORMAT
*               FIND CURRENT PROC HEADER
WPROC   MOVEA.L SFA6,A0
	MOVEA.L G_DOLLAR,A1
	CLR.L   TEMPL           RETURN ADDRESS
	CLR.L   TEMPL2          STATIC LINK & DEBUG HDR
	CMPA.L  (A0),A1
	BNE.S   WPROCA
	MOVEA.L INITPC,A0       MAIN LINE
	BRA.S   WPROCC
*
WPROCA  MOVEA.L 4(A0),A1        GET RETURN ADDR
	MOVE.L  A1,TEMPL
	BTST    #0,TEMPL+3      DON'T ALLOW ODD ADDRESS
	BNE     ERRORX
	LEA     -4(A1),A1       FIND JSR
	CMPI.W  #$4EBA,(A1)     JSR PC rel
	BNE.S   WPROCB
	MOVEA.W 2(A1),A0
	LEA     2(A1,A0),A0     GET ENTRY ADDR
	BRA.S   WPROCC
WPROCB  SUBQ    #2,A1   TRY FOR LONG ABS
	CMPI.W  #$4EB9,(A1)     JSR Long Abs
	BNE     ERRORX
	MOVEA.L 2(A1),A0        GET ENTRY ADDR
WPROCC  MOVE.L  A1,TEMPL3       SAVE JSR ADDR
	MOVEA.L A0,A1   CHECK FOR HEADER
	MOVEQ   #0,D0
	MOVE.B  -(A1),D0
	CMPI.B  #2,D0   MUST BE 0 OR 1
	BCC.S   WPROCX
	MOVE.B  -(A1),D0       SIZE
	BEQ.S   WPROCD  GO CHECK STATIC LINK
	SUBA.L  D0,A1   SHOULD BE AT FRONT OF NAME
	MOVE.B  (A1),D0 GET STRING SIZE
	ADDA.L  D0,A1
	ADDQ.L  #3,A1
	CMPA.L  A0,A1   SHOULD BE SAME
	BNE.S   WPROCX
	NOT.B   TEMPL2+2        HAS DEBUG HEADER
WPROCD  CMPI.B  #1,-1(A0)
	BNE.S   WPROCX
	NOT.B   TEMPL2          HAS STATIC LINK
WPROCX  RTS
ADDRERROR LEA   ADDRERRM,A0
	BRA     ESCAPE
ADDRERRM DC.B   'ADDRESS ERROR',0
	PAGE
*
*       WALK BACK STATIC LINKS
*
WSCMD   EQU     *
	BSR     WSTART
	BEQ     WPROCX  A5=(A6) SO NOW IN MAIN PROG
*                       FOLLOW STATIC LINK
	BSR     WPROC
	BCLR    #7,DSTATUS      ERROR ?
	BNE     NOTCOMP
	TST.W   TEMPL2+2        DEBUG HEADER ?
	BEQ.S   NOSTATIC
	TST.W   TEMPL2          STATIC LINK ?
	BEQ.S   NOSTATIC
	MOVEA.L SFA6,A0 FOLLOW STATIC LINK
	MOVE.L  8(A0),SFA6
	BRA     WDUMP   DUMP THE CALLER
NOSTATICM DC.B  'NO STATIC LINK',0
NOSTATIC LEA    NOSTATICM,A0
	BRA     ESCAPE
	PAGE
*       TRACE --- SINGLE STEP CPU INSTRUCTIONS
*
TCMD    BSET    #6,DSTATUS2     SET TRACE BIT
	BSET    #2,DSTATUS      SET GO BIT
	ANDI.B  #$80,TFLAGS     LEAVE QUEUE
	ORI.B   #$03,TFLAGS     SET TD & STOP
	BSR     T0NORM  NORMAL TRAP 0
	CMPI.B  #' ',D0
	BEQ.S   TCMDA
	CMPI.B  #'Q',D0
	BEQ.S   TCMDB
	CMPI.B  #'T',D0
	BEQ.S   TCMDC
	BRA     WHATERR
*
TCMDA   BSR     GETCOUNT        COUNT OR NOTHING
	BEQ     GOUSER  CONDITION SET BY GETCOUNT
	MOVE.L  ACCUMD,TCOUNT
	BSET    #2,TFLAGS       SET COUNT FLAG
	BRA.S   TCMDD           CLEAR STOP FLAG
*                       TQ COMMAND
TCMDB   BCLR    #0,TFLAGS       CLEAR TD REQUEST
	BSR     IFTERM
	BEQ     GOUSER
	CMPI.B  #' ',(A2)
	BNE     WHATERR
	BRA     TCMDA   GET COUNT THEN GO
*                       TT COMMAND
TCMDC   BCLR    #0,TFLAGS       CLEAR TD REQUEST
	BSR     IFTERM
	BEQ     GOCMDC
	CMPI.B  #' ',(A2)
	BNE     WHATERR
*
	BSR     BRSET   SET BREAK POINT
TCMDD   BCLR    #1,TFLAGS       CLEAR STOP FLAG
	BRA     GOUSER
*
*       TRACE DISPLAY COMMAND
*
TDCMD   BSR     FINDNP          TD or TD I
	BEQ.S   DOTDCMD         IF END OF COMMAND THEN IS SIMPLE TD
	CMPI.B  #'I',(A2)+
	BSR     FINDNP
	BNE     SYNTAXE
	BRA     DINITK4         SET K4 (TD) TO INITIAL VALUE
DOTDCMD BSR     PUSHIN  INSERT COMMAND FROM K4
	LEA     K4DATA,A0
	BSR     UPKINFO
	CMPI.B  #3,D0   ALPHA TYPE ?
	BNE.S   TDCMDA
	MOVEA.L A0,A2   MAKE POINTERS
	MOVEA.L A2,A3
	ADDA.L  D1,A3
	BRA.S   SNEWCMD
TDCMDA  LEA     ONLYK,A2
	LEA     ONLYKE,A3
*
SNEWCMD BSR     PUSHIN  START NEW COMMAND
	LEA     SEMIC,A2
	LEA     SEMIC+1,A3
	RTS
SEMIC   DC.B    ';'
ONLYK   DC.B    'K4'
ONLYKE  EQU     *
*
DAGCMD  EQU     *       DUMP ALPHA/DUMP GRAPHICS COMMANDS
	BTST    #5,REGSR        ALLOWED ONLY IF USER MODE
	BNE.S   NAERR
	CMPI.B  #'A',D0
	BEQ.S   DACMD
	CMPI.B  #'G',D0
	BNE     WHATERR
	MOVEQ   #3,D0   DUMP GRAPHICS COMMAND
	BRA.S   DAGCMD1
DACMD   MOVEQ   #2,D0   DUMP ALPHA COMMAND
DAGCMD1 BRA     SYSCALL
NAERRM  DC.B    'NOT ALLOWED NOW',0
NAERR   LEA     NAERRM,A0
	BRA     ESCAPE
	TTL     PARSER UTILITIES
	PAGE
* DEBUGGER PARSER UTILITIES
*
GETCOUNT BSR.S  GETGVALUE
	BSR     UPKACCM
	CMP.B   #1,D0   CAN'T ALLOW ADDRESS
	BEQ     TYPEERROR
	TST.B   D0      SKIP NULL INPUT
	BNE     LSIZE
	RTS
GETGVALUE EQU   *
INGVALUE BSR     FINDNP
GVALUE  EQU     * GENERAL VALUE ' " OR LOCATION
	CLR.B   ACCUMT    EMPTY ACCUMULATOR
	BSR     IFTERM
	BEQ.S   GVEXIT
	CMPI.B  #34,(A2)
	BEQ.S   GVALA
	CMPI.B  #39,(A2)
	BEQ.S   GVALA
	BRA.S   LOCATION
*
GVALA   MOVE.B  (A2)+,D0
	MOVE.L  A2,ACCUMD       START ADDRESS
	MOVEQ   #0,D1   COUNTER
GVALB   BSR     IFEOI
	BEQ     SYNTAXE
	CMP.B   (A2)+,D0
	BEQ.S   GVALC
	ADDQ.B  #1,D1
	BRA     GVALB
GVALC   MOVE.B  #$83,ACCUMT     ALPHA TYPE
	MOVE.B  D1,ACCUMS       SIZE
GVEXIT  RTS
LOCATION EQU    *
	LEA     OPSTACKE,A0     CLEAR OP STACK
	MOVE.L  A0,OPSTACK
	CLR.W   ACCUMT          NULL ACCUMULATOR
	CLR.L   ACCUMD
	BSR.S   IFLTERM CHECK FOR END OF LOCATION
	BEQ.S   LOC_RET
	MOVE.W  #$0204,ACCUMT   ZERO ACCUMULATOR
	CLR.B   DATAT   MARK DATA EMPTY
	BSR     EXPRESSION
	BSR.S   IFNOP
	BNE     SYNTAXE
	BSR.S   IFLTERM
	BNE     SYNTAXE
LOC_RET RTS
*
*       CHECK FOR END OF LOCATION PARAM
IFLTERM BSR     IFEOI
	BEQ.S   TERMEND
IFLT_0  CMPI.B  #' ',(A2)       PARAM
	BEQ.S   TERMEND
	CMPI.B  #':',(A2)       FORMAT
	BEQ.S   TERMEND
	CMPI.B  #';',(A2)       COMMAND
TERMEND RTS
*
PUSHOP  MOVEA.L OPSTACK,A0
	CMPA.L  #OPSTACK+4,A0
	BEQ.S   CMPLEXE  OVERFLOW
	MOVE.W  D0,-(A0) PUSH OPERATOR
	CLR.W   -(A0)    FLAG AS OPERATOR
	MOVE.L  A0,OPSTACK
	RTS
*
CPLEXM  DC.B    'EXPRESSION TOO COMPLEX',0
CMPLEXE LEA     CPLEXM,A0
	BRA     ESCAPE
*
POPOP   BSR.S   IFNOP
	BEQ     SYNTAXE UNDERFLOW
	TST.W   (A0)+
	BNE     SYNTAXE         NOT OPR.
	MOVE.W  (A0)+,D0        GET OPR.
	MOVE.L  A0,OPSTACK
	RTS
*
IFNOP   MOVEA.L OPSTACK,A0
	CMPA.L  #OPSTACKE,A0
	RTS
*
POPACC  BSR     IFNOP
	BEQ     SYNTAXE UNDERFLOW
	TST.W   (A0)+
	BEQ     SYNTAXE NOT DATA
	MOVE.W  (A0)+,ACCUMT    MOVE TYPE & SIZE
	MOVE.L  (A0)+,ACCUMD    GET DATA
	MOVE.L  A0,OPSTACK
	RTS
*
PUSHACC MOVEA.L OPSTACK,A0
	CMPA.L  #OPSTACK+4,A0
	BEQ     CMPLEXE OVERFLOW
	MOVE.L  ACCUMD,-(A0)
	CMPA.L  #OPSTACK+4,A0
	BEQ     CMPLEXE OVERFLOW
	MOVE.W  ACCUMT,-(A0)
	MOVE.W  #1,-(A0)        FLAG AS DATA
	MOVE.L  A0,OPSTACK
	RTS
*
ACC_DATA MOVE.W ACCUMT,DATAT
	MOVE.L  ACCUMD,DATAD
	RTS
*
IFBINOP CMPI.B  #'+',(A2)
	BEQ.S   IFRET
	CMPI.B  #'-',(A2)
	BEQ.S   IFRET
	CMPI.B  #'*',(A2)
	BEQ.S   IFRET
	CMPI.B  #'/',(A2)
	BEQ.S   IFRET
	CMPI.B  #'=',(A2)
	BEQ.S   IFRET
	CMPI.B  #'<',(A2)
	BEQ.S   IFRET
	CMPI.B  #'>',(A2)
EXP_RET EQU     *
IFRET   RTS
*
EXPRESSION EQU  *
	BSR     IFLTERM IF TERMINATOR
	BEQ     SYNTAXE
	MOVEQ   #0,D0
	BSR     PUSHOP  ACC:=DATA
EXP_A   BSR     VALUE
	BSR.S   ACC_OP_DATA
	BSR     IFLTERM
	BEQ     EXP_RET
	CMPI.B  #')',(A2)
	BEQ     EXP_RET
	BSR     IFBINOP
	BNE     SYNTAXE
	BSR.S   CHECKROP
	BSR     PUSHOP
	BRA     EXP_A
*
CHECKROP MOVE.B (A2)+,D0
	CMPI.B  #'<',D0         IS IT RELATIONAL OP ?
	BCS.S   ROPXIT
	BSR     IFLTERM         MAY HAVE 2nd CHAR
	BEQ     SYNTAXE
	CMPI.B  #'=',D0
	BEQ.S   ROPXIT
	CMPI.B  #'<',D0
	BEQ.S   ROP2
	CMPI.B  #'>',D0
	BNE.S   ROPXIT
ROP0    CMPI.B  #'=',(A2)       HAVE > CHECK FOR =
	BNE.S   ROPXIT
ROP1    LSL.W   #8,D0           SHIFT THE FIRST CHARACTER
	MOVE.B  (A2)+,D0        PICK UP THE SECOND
ROPXIT  RTS
ROP2    CMPI.B  #'>',(A2)       CHECK FOR <>
	BEQ     ROP1
	BRA     ROP0            CHECK FOR <=
*
DATA_ACC MOVE.L DATAT,ACCUMT
	MOVE.L  DATAD,ACCUMD
	RTS
*       FETCH DATA POINTED TO BY ADDRESS TYPE
AFETCH  BSR     UPKACCM
	CMPI.B  #1,D0   ADDRESS ?
	BNE.S   AEXIT
	BSR     LSIZE   REMOVE ANY INDIRECT
	MOVE.B  DSCODE,ACCUMT   SET TO DEFAULT TYPE
	BSET    #7,ACCUMT       SET INDIRECT
	BSR     LSIZE   FETCH DATA
AEXIT   RTS
*
ACC_OP_DATA EQU *       ACC<=ACC OP DATA
*                       ACC<=DATA
	BSR     POPOP
	TST.B   D0
	BEQ     DATA_ACC        DO ASSIGNMENT
	MOVE.W  D0,-(SP)        SAVE OP
	BSR     AFETCH  GET DATA IF ADDRESS
	BSR     LSIZE   MAKE ACC. NUMERIC 4 BYTES
	BSR     EXGAD   EXCHANGE ACC AND DATA
	BSR     AFETCH  GET DATA IF ADDRESS
	BSR     LSIZE   MAKE SIZE 4
	BSR     EXGAD   EXCHANGE ACC AND DATA
	MOVE.L  DATAD,D0
	MOVE.W  (SP)+,D1        GET OPCODE
	CMP.B   #'+',D1
	BNE.S   ACC_OP1
	ADD.L   D0,ACCUMD       ADD
	BRA.S   ACC_OVCHK
ACC_OP1 CMP.B   #'-',D1
	BNE.S   ACC_OP2
	SUB.L   D0,ACCUMD       SUBTRACT
ACC_OVCHK BVS   OVERFE  CHECK FOR OVERFLOW
	RTS
*
ACC_OP2 CMPI.B  #'*',D1
	BNE.S   ACC_OP3
	BSR.S   SYSSET
	MOVE.L  ACCUMD,-(SP)
	MOVE.L  D0,-(SP)
	JSR     E@MPY
	BRA.S   ACC_EXIT
ACC_OP3 CMPI.B  #'/',D1
	BNE     ACC_OP4
	TST.L   D0
	BEQ.S   DIVERR
	BSR.S   SYSSET  SETUP
	MOVE.L  ACCUMD,-(SP)
	MOVE.L  D0,-(SP)
	JSR     E@DIV
ACC_EXIT MOVE.L (SP)+,ACCUMD
	MOVEA.L recoverblk(A5),SP                                        (scs)
	ADDQ.L  #4,SP   POP RECOVER ADDRESS
	MOVE.L  (SP)+,recoverblk(A5)   RESTORE RECOVER                   (scs)
	MOVE.W  (SP)+,escapecode(A5)                                     (scs)
	MOVEM.L (SP)+,D0-D7/A5
	RTS
*
DIVERR  LEA     DIVMSG,A0
	BRA     ESCAPE
DIVMSG  DC.B    'DIVIDE BY ZERO',0
SYSSET  MOVE.L  (SP)+,TEMPL3 SAVE RETURN
	MOVEM.L D0-D7/A5,-(SP)
	MOVEA.L G_DOLLAR,A5
	MOVE.W  escapecode(A5),-(SP)    SWITCH RECOVER                   (scs)
	MOVE.L  recoverblk(A5),-(SP)                                     (scs)
	PEA     OPERR
	MOVE.L  SP,recoverblk(A5)                                        (scs)
RECEXIT MOVEA.L TEMPL3,A0
	JMP     (A0)
*
OPERR   MOVE.L  (SP)+,recoverblk(A5)    RESTORE NORMAL                   (scs)
	MOVE.W  (SP)+,escapecode(A5)    ERROR CONTROL                    (scs)
	BRA     OVERFE  OVERFLOW ERROR
*
ACC_OP4 CMPI.B  #'N',D1 NEGATE
	BNE.S   ACC_OP5
	NEG.L   D0
	MOVE.L  D0,DATAD
	BRA     ACC_OP_DATA
*                               RELATIONAL OPERATORS
ACC_OP5 CMPI.W  #'<=',D1
	BNE.S   ACC_OP6
	CMP.L   ACCUMD,D0
	SGE     D0
ACC_ROPEXIT NEG.B D0
	CLR.L   ACCUMD
	MOVE.B  D0,ACCUMD+3
	RTS
ACC_OP6 CMPI.W  #'>=',D1
	BNE.S   ACC_OP7
	CMP.L   ACCUMD,D0
	SLE     D0
	BRA     ACC_ROPEXIT
ACC_OP7 CMPI.B  #'=',D1         EQUALITY
	BNE.S   ACC_OP8
	CMP.L   ACCUMD,D0
	SEQ     D0
	BRA     ACC_ROPEXIT
ACC_OP8 CMPI.W  #'<>',D1
	BNE.S   ACC_OP9
	CMP.L   ACCUMD,D0
	SNE     D0
	BRA     ACC_ROPEXIT
ACC_OP9 CMPI.B  #'<',D1
	BNE.S   ACC_OP10
	CMP.L   ACCUMD,D0
	SGT     D0
	BRA     ACC_ROPEXIT
ACC_OP10 CMPI.B #'>',D1
	BNE     SYNTAXE
	CMP.L   ACCUMD,D0
	SLT     D0
	BRA     ACC_ROPEXIT
*
*       GET SIGNED 4 BYTE INTEGER DATAD
*
DATAD4  BSR.S   EXGAD
	BSR     LSIZE
*                       SWITCH DATA AND ACCUM
EXGAD   MOVE.W  ACCUMT,-(SP)
	MOVE.L  ACCUMD,-(SP)
	BSR     DATA_ACC        DATA TO ACCM
	MOVE.L  (SP)+,DATAD
	MOVE.W  (SP)+,DATAT
	RTS
	PAGE
VALUE   BSR     IFLTERM
	BEQ     SYNTAXE
	CMPI.B  #'(',(A2)
	BNE.S   VALUE_A
	ADDQ.L  #1,A2           HAVE (EXPRESSION)
	BSR     PUSHACC
	BSR     EXPRESSION
	BSR     IFLTERM
	BEQ     SYNTAXE
	CMPI.B  #')',(A2)+
	BNE     SYNTAXE
	BSR     ACC_DATA        DATA:=ACC
	BSR     POPACC          ACC:=(STACK)+
	BRA.S   VALUE_D
*
VALUE_A BSR     IFBINOP         CHECK +-*/
	BNE.S   VALUE_C
	CMPI.B  #'+',(A2)       SIGN CHECK
	BEQ.S   VALUE_B         THROW AWAY +
	CMPI.B  #'-',(A2)
	BNE     SYNTAXE MUST BE * OR /
	MOVEQ   #'N',D0 SAVE -
	BSR     PUSHOP
VALUE_B ADDQ.L  #1,A2
	BRA     VALUE
*
VALUE_C BSR     SYMBOL
VALUE_D BSR     IFLTERM
	BEQ     RETURNA
	CMPI.B  #'^',(A2)
	BNE     RETURNA
	ADDQ.L  #1,A2
VALUE_E BSR     IFNOP   ANY THING ON STACK ?
	BEQ.S   VALUE_G
	TST.W   (A0)    OPERATOR ?
	BNE.S   VALUE_G
	BSR     POPOP   CHECK OP
	CMPI.B  #'N',D0
	BNE.S   VALUE_F
	BSR     DATAD4
	NEG.L   DATAD
	BRA     VALUE_E
VALUE_F BSR     PUSHOP  PUT IT BACK
*
VALUE_G BSR     DATAD4          MAKE DATA 4 BYTES
	MOVE.W  #$0104,D1       MAKE IT ADDRESS TYPE
	CMPI.B  #1,DATAT
	BNE.S   VALUE_H IF ALREADY ADDRESS THEN
	MOVE.W  #$8104,D1  SET INDIRECT BIT
VALUE_H MOVE.W  D1,DATAT
*                          CHECK FOR DATA REF
	BSR     IFLTERM IF END LOCATION
	BEQ     VALUE_D
	CMPI.B  #'I',(A2)       SIGNED INT
	BNE.S   VALUE_I
	BSR.S   VALUE_J
	BRA     VALUE_D
VALUE_I CMPI.B  #'U',(A2)       UNSIGNED INT
	BNE     VALUE_D
	BSR.S   VALUE_J
	MOVE.B  #6,DATAT
	BRA     VALUE_D
*
VALUE_J ADDQ.L  #1,A2
	BSR     EXGAD
	BSR     AFETCH  GET THE DATA
	BSR     EXGAD
	BSR     IFLTERM
	BEQ     SYNTAXE
	MOVE.B  (A2)+,D0
	BSR     GETHEX  DECODE THE DIGIT
	BCLR    #7,DSTATUS      ERROR CHECK
	BNE     SYNTAXE
	CMPI.B  #4,D0
	BGT     SYNTAXE
	MOVE.B  D0,DATAS
	RTS
	PAGE
SYMBOL  BSR     IFLTERM
	BEQ     SYNTAXE
	MOVE.B  (A2),D0
	CMPI.B  #'0',D0
	BCS.S   SYMB_01
	CMPI.B  #'9',D0
	BHI.S   SYMB_00
	BRA     DECIMAL DECIMAL INTEGER
SYMB_00 CMPI.B  #'A',D0
	BCS.S   SYMB_01
	CMPI.B  #'Z',D0
	BHI.S   SYMB_01
	BRA.S   SPECSYM DEBUGGER SYMBOL
SYMB_01 CMPI.B  #'$',D0
	BNE.S   SYMB_02
	ADDQ.L  #1,A2
	BRA     HEXNUM  HEX NUMBER
SYMB_02 CMPI.B  #'%',D0
	BNE.S   SYMB_03
	ADDQ.L  #1,A2
	BRA     OCTNUM  OCTAL NUMBER
SYMB_03 CMPI.B  #'!',D0
	BNE.S   SYMB_04
	ADDQ.L  #1,A2
	BRA     BINNUM  BINARY NUMBER
SYMB_04 EQU     *       HOOK FOR OTHER SYMBOLS
	BRA     TRY_SYS
*
SPECSYM BSR.S   SCAN_SYM        GET THE SYMBOL
	CMPI.B  #2,DATAS        CHECK THE SIZE
	BNE     SYS_SYM
	MOVEA.L DATAD,A0
	MOVE.B  (A0)+,D0        MOVE THE SYMBOL
	LSL.W   #8,D0           TO D0
	MOVE.B  (A0),D0
	LEA     SYMBOLS,A0
SPECS0  CMP.W   (A0)+,D0
	BEQ.S   SPECS1
	ADDQ.L  #6,A0
	TST.W   (A0)
	BNE     SPECS0
	BRA.S   SYS_SYM TRY SYSTEM SYMBOL TABLE
SPECS1  MOVE.W  (A0)+,DATAT TYPE AND SIZE
	MOVE.L  (A0),DATAD      DATA FIELD
	CMPI.B  #128,DATAT      NULL TYPE
	BNE.S   SYMRET
	MOVE.B  DSCODE,DATAT    DEFAULT
	BSET    #7,DATAT        SET IND. BIT
SYMRET  RTS
	PAGE
*       SCAN INPUT FOR A SYMBOL
SCAN_SYM MOVE.L A2,DATAD       SAVE START ADDRESS
	MOVEQ   #0,D1   LENGTH COUNTER
SCAN_0  BSR     IFLTERM
	BEQ.S   SCAN_1
	BSR     IFBINOP
	BEQ.S   SCAN_1
	BSR.S   IFDELIM
	BEQ.S   SCAN_1
	ADDQ.B  #1,D1
	ADDQ.L  #1,A2   SCANNED CHAR
	BRA     SCAN_0
SCAN_1  MOVE.B  D1,DATAS        START LOOKING
	BEQ     SYNTAXE NULL SYMBOL
	RTS
IFDELIM CMPI.B  #'(',(A2)
	BEQ.S   IFDRET
	CMPI.B  #')',(A2)
	BEQ.S   IFDRET
	CMPI.B  #'^',(A2)
IFDRET  RTS
*
SYMNFM  DC.B    ' IS UNDEFINED SYMBOL',0
** TRY TO FIND SYMBOL IN SYSTEM DEFS
TRY_SYS CMPI.B  #'&',D0
	BNE.S   SYS_SYM0
	ADDQ.L  #1,A2   SKIP &
SYS_SYM0 BSR    SCAN_SYM
*
*       TRY TO FIND SYMBOL IN SYSTEM TABLE
*
SYS_SYM MOVEQ   #0,D0   SET CONDITION CODE
	JSR     SYMBOLHOOK      GIVE HOOK FIRST SHOT
	BNE     IFDRET
	MOVEA.L G_DOLLAR,A0
	MOVEA.L SYSDEFS(A0),A0  MODP:=SYSDEFS
FSYS_2  MOVE.L  A0,D0
	BEQ.S   NOTSYM  END OF THE LIST ?
FSYS_21 MOVEA.L DEFADDR(A0),A1  PTR:=MODP.DEFADDR
	MOVE.L  A1,D7   TEMP:=DEFADDR+DEFSIZE
	ADD.L   DEFSIZE(A0),D7
	MOVE.L  A0,TEMPL3       SAVE MODP
FSYS_3  CMP.L   A1,D7  IF A1<=D7 THEN NEXT MODULE
	BLE.S   FSYS_6
*                       COMPARE SYMBOLS
	MOVEQ   #0,D0
	MOVE.B  (A1)+,D0
	CMP.B   DATAS,D0
	BNE.S   FSYS_5
	MOVEA.L DATAD,A0        RECALL ADDRESS
	SUBQ.W  #1,D0
FSYS_4  CMPM.B  (A1)+,(A0)+
	DBNE    D0,FSYS_4
	BNE.S   FSYS_5
*                       SYMBOL FOUND
	MOVE.W  A1,D0   BUMP PTR TO EVEN ADDRESS
	ANDI.W  #1,D0
	ADDA.W  D0,A1
	MOVE.L  2(A1),DATAD     GET VALUE
	MOVE.B  DSCODE,DATAT    DEFAULT TYPE
	MOVE.B  #4,DATAS        4 BYTES
	RTS
*
NOTSYM  MOVEQ   #0,D1
	MOVE.B  DATAS,D1
	MOVEA.L DATAD,A0
	BSR     OUTALPHA
	LEA     SYMNFM,A0
	BSR     OUTMSG
	BRA     CMDIN   NO MESSAGE ESCAPE
*
FSYS_5  ADDA.W  D0,A1   PTR TO END OF SYMBOL
	MOVE.W  A1,D0   BUMP TO EVEN ADDRESS
	ANDI.W  #1,D0
	ADDA.W  D0,A1

	MOVEQ   #0,D0
	MOVE.B  1(A1),D0
	ADDA.W  D0,A1   PTR:=PTR+SIZE OF GVR
	BRA     FSYS_3  TRY NEXT SYMBOL
*
FSYS_6  MOVEA.L TEMPL3,A0       RESTORE MODP
	MOVEA.L (A0),A0 MODP:=MODP.LINK
	BRA     FSYS_2  TRY NEXT MODULE
	PAGE
**  DECODE A NUMBER
*
DECIMAL MOVE.W  #10,BASE
	MOVEQ   #2,D0
	BRA.S   GETNUM
HEXNUM  MOVE.W  #16,BASE
	MOVEQ   #4,D0
	BRA.S   GETNUM
OCTNUM  MOVE.W  #8,BASE
	MOVEQ   #16,D0
	BRA.S   GETNUM
BINNUM  MOVE.W  #2,BASE
	MOVEQ   #5,D0
GETNUM  MOVE.B  D0,DATAT
	BSR.S   GETNUM0
	MOVE.B  #4,DATAS        SET SIZE
	TST.W   TEMPL3  ANY DIGITS ?
	BNE.S   GETNUMX
	CLR.B   DATAT   NULL VALUE
GETNUMX MOVE.L  D0,DATAD        SET DATA
	RTS
*
GETNUM0 MOVEM.L D1-D7/A4-A6,-(SP)   SAVE ALL
GETNUM1 MOVEQ   #0,D0    RESULTS IN D0 & D1
	MOVE.L  D0,D1
	MOVE.W  D0,TEMPL3 FLAG FOR CHARACTER HIT
NXTNUM  BSR     IFLTERM  SEE IF AT END OF BUFFER
	BEQ.S   EXITGN
	MOVE.B  (A2)+,D0 GRAB CHARACTER
	BSR.S   GETHEX   RETURNS WITH D0=BINARY
	BCLR    #7,DSTATUS  ERROR CHECK
	BEQ.S   NXTNUM0
* HIGH LEVEL WILL CHECK THE CHARACTER
	SUBQ.L  #1,A2    BACK IT UP
	BRA.S   EXITGN
NXTNUM0 CMP.W   BASE,D0  IS INPUT LARGER THAN BASE
	BPL.S   BASERR
	MOVE.W  #-1,TEMPL3 FLAG AS SOMETHING READ
	MOVE.L  D1,D2    GET READY TO MULTIPLY D1*BASE
	SWAP    D1
	MULU    BASE,D1  TOP PART
	SWAP    D1
	TST.W   D1       CHECK FOR OVERFLOW
	BNE.S   OVERFE   VALUE IS TOO LARGE
	MULU    BASE,D2  NOW WORK ON LOW WORD
	ADD.L   D2,D1    PUT IT BACK TOGETHER
	BVS.S   OVERFE   OVERFLOW
	ADD.L   D0,D1    ADD IN NEW STUFF
	BVS.S   OVERFE   ON OVERFLOW
	BRA     NXTNUM
EXITGN  MOVE.L  D1,D0   SET UP RESULT FOR RETURN
	MOVEM.L (SP)+,D1-D7/A4-A6   RESTORE ALL
	RTS
BASERR  LEA     BASEM,A0
	BRA     ESCAPE
BASEM   DC.B    'BAD DIGIT',0
OVERFM  DC.B    'OVERFLOW',0
OVERFE  LEA     OVERFM,A0
	BRA     ESCAPE
ERRORX  BSET    #7,DSTATUS      SET ERROR FLAG
	RTS
	PAGE
****GETHEX***  GET HEX (BINARY VALUE FROM ASCII)
*   D0.B HAS ASCII CHAR RETURNS $0-$F BINARY
*
GETHEX  ANDI.L  #$FF,D0  STRIP OFF ALL BUT BYTE
	CMPI.B  #$30,D0  IS IT LESS THAN ZERO
	BCS     ERRORX
	CMPI.B  #$39,D0  IS IT GREATER THAN 9
	BGT.S   GTHX2
GTHX1   ANDI.L  #$F,D0   SAVE ONLY LAST NIBBLE OTHER 28 B
	RTS
GTHX2   CMPI.W  #10,BASE IS BASE GREATER THAN 10
	BLE     ERRORX   ALLOWED ?
	CMPI.B  #$41,D0  IS IT LESS THAN 'A'
	BCS     ERRORX
	CMPI.B  #$46,D0  IS IT GT 'F'
	BGT     ERRORX
	SUBQ.B  #7,D0    MAKE IT SMALLER A=10
	BRA     GTHX1
	PAGE
* DEBUGGER PRE-DEFINED SYMBOLS
*
* BIT 7 =1, MEANS THAT VALUE IS POINTER TO THE TYPE
* SYMBOL TYPE CODE  0= EMPTY                    10      UNDEFINED
*                   1= ADDRESS                  11      UNDEFINED
*                   2= SIGNED INTEGER           12      UNDEFINED
*                   3= ALPHA                    13      UNDEFINED
*                   4= HEX                      14      INSTRUCTION
*                   5= BINARY                   15      REAL NUMBER
*                   6= UNSIGNED INTEGER         16      OCTAL NUMBER
*                   7= STRING                   17      SPECIAL  (
*                   8= TYPE POINTER  (POINTER TO DATA size type value)
*                   9= SPECIAL VALUE            18      SPECIAL  )
*
SYMBOLS DC.B    'PC',128,4    TYPE,SIZE
	DC.L    REGPC           VALUE
	DC.B    'SR',4+128,2
	DC.L    REGSR
	DC.B    'US',128,4
	DC.L    REGUS
	DC.B    'D0',128,4
	DC.L    DREGS
	DC.B    'D1',128,4
	DC.L    DREGS+4
	DC.B    'D2',128,4
	DC.L    DREGS+8
	DC.B    'D3',128,4
	DC.L    DREGS+12
	DC.B    'D4',128,4
	DC.L    DREGS+16
	DC.B    'D5',128,4
	DC.L    DREGS+20
	DC.B    'D6',128,4
	DC.L    DREGS+24
	DC.B    'D7',128,4
	DC.L    DREGS+28
	DC.B    'A0',128,4
	DC.L    AREGS
	DC.B    'A1',128,4
	DC.L    AREGS+4
	DC.B    'A2',128,4
	DC.L    AREGS+8
	DC.B    'A3',128,4
	DC.L    AREGS+12
	DC.B    'A4',128,4
	DC.L    AREGS+16
	DC.B    'A5',128,4
	DC.L    AREGS+20
	DC.B    'A6',128,4
	DC.L    AREGS+24
	DC.B    'A7',128,4
	DC.L    AREGS+28
	DC.B    'SF',128,4
	DC.L    SFA6    STACK FRAME
	DC.B    'SP',9,4
	DC.L    GETSP   STACK POINTER
	DC.B    'LN',9,4
	DC.L    LNSPCL  LINE NUMBER
	DC.B    'EC',9,4
	DC.L    ECSPCL  ESCAPE CODE
	DC.B    'IO',9,4
	DC.L    IORSPCL IO RESULT
	DC.B    'GB',9,4
	DC.L    GBSPCL  GLOBAL BASE
	DC.B    'RB',9,4
	DC.L    RBSPCL  RELOCATION BASE
*
KSYMBOLS DC.B   'K0',8,4
	DC.L   K0DATA
	DC.B    'K1',8,4
	DC.L    K1DATA
	DC.B    'K2',8,4
	DC.L    K2DATA
	DC.B    'K3',8,4
	DC.L    K3DATA
	DC.B    'K4',8,4
	DC.L    K4DATA
	DC.B    'K5',8,4
	DC.L    K5DATA
	DC.B    'K6',8,4
	DC.L    K6DATA
	DC.B    'K7',8,4
	DC.L    K7DATA
	DC.B    'K8',8,4
	DC.L    K8DATA
	DC.B    'K9',8,4
	DC.L    K9DATA
	DC.W    0       END OF SYMBOLS
	PAGE
FINDNP  BSR     IFTERM  FIND NEXT PARAMETER
	BEQ.S   FPRET
	CMPI.B  #' ',(A2)+      SKIP NON BLANKS
	BNE     FINDNP
FINDNP1 BSR     IFTERM
	BEQ.S   FPRET
	CMPI.B  #' ',(A2)+      SKIP BLANKS
	BEQ     FINDNP1
	SUBQ.L  #1,A2   BACK UP
FPRET   RTS
*
FINDCMD BSR     IFTERM  FIND END OF COMMAND
	BEQ     FPRET
	MOVE.B  (A2)+,D0
	CMPI.B  #39,D0          '
	BEQ.S   FINDCMD1
	CMPI.B  #34,D0          "
	BNE     FINDCMD
FINDCMD1 BSR    IFEOI   SKIP LITTERAL FIELDS
	BEQ     FPRET
	CMP.B   (A2)+,D0
	BNE     FINDCMD1
	BRA     FINDCMD
	TTL     FORMAT INTERPRETER
	PAGE
* FORMAT INTERPRETER
*---------------------------------------
* ESCAPE TRAP MUST BE SET BEFORE CALLING
*     INFO TO DUMP IS IN ACCUMV
* A2= INPUT SCANNER
*     POINTING TO JUST AFTER THE :
* A3= END OF INPUT
*---------------------------------------
*     SETS UP
* A4= DATA POINTER
* A5= END OF DATA
*---------------------------------------
*
FORMAT  EQU     *
	LEA     OPSTACKE,A0     CLEAR OPSTACK
	MOVE.L  A0,OPSTACK      FOR USE IN REPEAT FORMAT GROUP

	BSR     UPKACCM UNPACK ACCUMULATOR
*               RETURNS D0= TYPE
*                       D1= SIZE
*                       A0= DATA POINTER
	MOVE.L  D1,SSIZE
	MOVE.B  D0,SCODE        DEFAULT TYPE
	MOVE.L  A0,D3           SET START ADDR
*       AND.L   #$00FFFFFF,D3   CLEAR HI BYTE/ CHG32
	MOVEA.L D3,A4           START ADDR
	CMP.B   #1,D0   ADDRESS TYPE ?
	BNE.S   FMTO_0
	MOVE.B  DSCODE,SCODE    DEFAULT SPEC
	MOVE.L  #4,SSIZE        DEFAULT SIZE
	BSR     LSIZE
*       CLR.B   ACCUMD          REMOVED FOR RODIO SFB/JWS 7/10/85
	MOVEA.L ACCUMD,A4       START ADDR
	MOVEA.L #-1,A5   END ADDR   CHG32
	BRA.S   FMTO_1
FMTO_0  MOVEA.L A4,A5
	ADDA.L  SSIZE,A5        END ADDR
FMTO_1  EQU     *
*
FMTO_2  MOVEQ   #1,D0
	MOVE.L  D0,RCOUNT       DEFAULT REPEAT
	BSR     IFFEND  END OF FORMAT ?
	BEQ     FMTO_DUMP       NO SPECS SO USE DEFAULT
	BSR     IFSPEC  FORMAT SPEC ?
	BEQ.S   FMTO_3
	MOVE.W  #10,BASE        REPEAT COUNT ?
	BSR     GETNUM0
	TST.L   TEMPL3  ANYTHING READ ?
	BEQ     SYNTAXE
	TST.L   D0      NON ZERO
	BEQ     SYNTAXE
	MOVE.L  D0,RCOUNT       SET REPEAT COUNT
	BSR.S   IFFEND  END OF FORMAT ?
	BEQ     FMTO_DUMP
	BSR     IFSPEC  FORMAT SPEC ?
	BNE     SYNTAXE
FMTO_3  MOVEA.W FMTTAB(A0),A0
	JSR     FMTTAB(A0)      EXECUTE THE SPEC
	BSR     IFTERM
	BEQ.S   IFFRT
	BSR.S   IFFEND  MUST BE AT END OF SPEC
	BNE     SYNTAXE
	CMPI.B  #',',(A2)
	BNE     RETURNA
	ADDQ.L  #1,A2
	MOVE.L  #4,SSIZE        RESET DEFAULT SIZE
	BRA     FMTO_2  GET THE NEXT SPEC
	PAGE
FMTTAB  EQU     *
	DC.W    NULSPEC-FMTTAB
	DC.W    ADRSPEC-FMTTAB
	DC.W    IFMT-FMTTAB     SIGNED DECIMAL
	DC.W    AFMT-FMTTAB     ALPHA
	DC.W    HFMT-FMTTAB     HEX
	DC.W    BFMT-FMTTAB     BINARY
	DC.W    UFMT-FMTTAB     UNSIGNED DECIMAL
	DC.W    SSPEC-FMTTAB    STRING SPEC
	DC.W    AISPEC-FMTTAB
	DC.W    ARSPEC-FMTTAB
	DC.W    ALSPEC-FMTTAB
	DC.W    QSPEC-FMTTAB    LITERAL SPEC
	DC.W    Q2SPEC-FMTTAB
	DC.W    NLSPEC-FMTTAB   NEW LINE
	DC.W    XSPEC-FMTTAB    X REVERSE ASSEMBLE
	DC.W    RSPEC-FMTTAB    REAL NUMBER SPEC
	DC.W    OSPEC-FMTTAB    OCTAL SPEC
	DC.W    OPSPEC-FMTTAB   OPEN PAREN SPEC
	DC.W    CPSPEC-FMTTAB   CLOSE PAREN SPEC
*
*       CHECK END OF FORMAT SPEC
IFFEND  BSR     IFTERM  CHECK END OF COMMAND
	BEQ.S   IFFRT
	CMPI.B  #' ',(A2)
	BEQ.S   IFFRT
	CMPI.B  #',',(A2)
IFFRT   RTS
*
GETSIZE BSR     IFFEND
	BEQ.S   GETRET
	MOVE.W  #10,BASE
	BSR     GETNUM0
	TST.L   TEMPL3  ANYTHING READ ?
	BEQ.S   GETRET
	TST.L   D0
	BEQ     SYNTAXE RANGE CHECK IT
	MOVEA.L A4,A0
	ADDA.L  D0,A0
	CMPA.L  A5,A0
	BHI.S   BIGSC      CHG32  3/27/85
	MOVE.L  D0,SSIZE
GETRET  RTS
BIGSC   CMPA.L  #-1,A5   ADDRESS MODE ?
	BEQ     GETRET
BIGSE   LEA     BIGSM,A0
	BRA     ESCAPE
BIGSM   DC.B    'SIZE FIELD TOO BIG',0
*
*       CHECK FOR FORMAT SPEC CHARACTER
IFSPEC  MOVE.B  (A2),D0
	LEA     SPECT,A0
	MOVEQ   #0,D1
IFSP0   CMP.B   (A0),D0
	BEQ.S   IFSP1
	ADDQ.L  #2,D1   ADVANCE TABLE OFFSET
	TST.B   (A0)+
	BNE     IFSP0
	MOVEQ   #-1,D0
	RTS
IFSP1   MOVEA.L D1,A0
	ADDQ.L  #1,A2   ADVANCE SCANNER
	MOVEQ   #0,D0
	RTS
SPECT   DC.B    ' *IAHBUS^><',39,34,'/XRO()',0
*
NULSPEC RTS
*
ADRSPEC BSR     INVC    ADDRESS ONLY CHECK
	MOVEQ   #4,D1           SIZE  CHG32
	MOVE.L  A4,TEMPL2       DATA ADDR
	LEA     TEMPL2,A0       CHG32
	BSR     OUTADDR
	BRA.S   OUTBLANK
*
UFMT    LEA     OUTUINT,A1      UNSIGNED INT
	BRA.S   IFMT0
*
IFMT    LEA     OUTINT,A1       SIGNED INT
IFMT0   BSR     GETSIZE
	CMPI.L  #4,SSIZE
	BGT     BIGSE
*
FOUTLOOP MOVE.L SSIZE,D1
	MOVEA.L A4,A0
	ADDA.L  D1,A4   WILL THIS BE TOO BIG
	BSR     FMTERRC CHECK POSITION
	JSR     (A1)
	BSR.S   OUTBLANK
	MOVE.L  SSIZE,D0        INC DATA POINTER
	SUBQ.L  #1,RCOUNT
	BNE     FOUTLOOP
	RTS
*
HFMT    LEA     OUTHEX,A1       HEX OUTPUT
HFMT0   BSR     GETSIZE
	BRA     FOUTLOOP
*
OUTBLANK MOVEQ  #' ',D0
	BRA     OUTBYTE         OUTBYTE DOES RTS
*
BFMT    LEA     OUTBIN,A1       BINARY
	BRA     HFMT0
*
AFMT    LEA     OUTALPHA,A1     ALPHA
	BRA     HFMT0
*
SSPEC   EQU     *       STRING SPECIFIER
	MOVEQ   #0,D1
	MOVE.B  (A4)+,D1        GET ACTUAL SIZE
	BSR     FMTERRC CHECK POSITION
	MOVE.L  D1,SSIZE        DEFAULT SIZE
	BSR     GETSIZE GET SPECIFIED SIZE
	BNE.S   SSPEC00                          {3.0 BUG #20 3/13/84}
	CMPI.L  #1,RCOUNT                        {3.0 BUG #20 3/13/84}
	BNE     SYNTAXE                          {3.0 BUG #20 3/13/84}
SSPEC00 BSET    #0,SSIZE+3      MAKE IT ODD      {3.0 BUG #20 3/13/84}
SSPEC0  CMP.L   SSIZE,D1        GIVEN < ACTUAL ?
	BGT     SIZEERROR
	MOVEA.L A4,A0
	ADDA.L  SSIZE,A4
	BSR.S   FMTERRC CHECK POSITION
	BSR     OUTALPHA
	SUBQ.L  #1,RCOUNT
	BEQ.S   SPECRET
	MOVEQ   #0,D1
	MOVE.B  (A4)+,D1
	BSR.S   FMTERRC CHECK POSITION
	BRA     SSPEC0
*
ARSPEC  ADDA.L  RCOUNT,A4       > SPEC
	BRA.S   ADDRFMT CHECK POSITION
*
ALSPEC  SUBA.L  RCOUNT,A4       < SPEC
ADDRFMT BSR.S   INVC    ADDRESS OBJECT ONLY
	BRA.S   FMTERRC TRIM A4
*
AISPEC  BSR.S   INVC    ^ SPEC
AISPEC1 MOVEQ   #0,D0           CHG32  3/25/85
	MOVE.B  (A4)+,D0        CHG32  GET 4 BYTES
	LSL.L   #8,D0
	MOVE.B  (A4)+,D0
	LSL.L   #8,D0
	MOVE.B  (A4)+,D0
	LSL.L   #8,D0
	MOVE.B  (A4)+,D0
	MOVEA.L D0,A4
	SUBQ.L  #1,RCOUNT
	BNE     AISPEC1
	BRA.S   FMTERRC TRIM A4
SPECRET RTS
*
Q2SPEC  MOVEQ   #34,D1  "
	BRA.S   QSPEC0
QSPEC   MOVEQ   #39,D1  '
QSPEC0  BSR     IFEOI   CHECK FOR END OF INPUT
	BEQ     SYNTAXE
	MOVE.B  (A2)+,D0
	CMP.B   D1,D0   END '
	BEQ     SPECRET
	BSR     OUTBYTE
	BRA     QSPEC0
*
NLSPEC  BSR     OUTEOL  NEW LINE
	SUBQ.L  #1,RCOUNT
	BNE     NLSPEC
	RTS
*
*
FMTERRC TST.B   (A4)    BUG FIX 3.0   force bus error before syscall
	CMPA.L  A5,A4   CHECK A4<=A5
	BLE.S   SPECRET
*       MOVE.L  A4,-(SP)        TRIM HIGH BYTE   CHG32 3/25/85
*       CLR.B   (SP)
*       MOVEA.L (SP)+,A4
	CMPA.L  #-1,A5   ADDRESS MODE            CHG32
	BEQ.S   SPECRET
	LEA     FMTEM,A0
	BRA     ESCAPE
FMTEM   DC.B    'FORMAT REQUIRES MORE DATA',0
*
INVC    CMPA.L  #-1,A5 ADDRESS MODE ONLY
	BEQ.S   SPECRET
	LEA     INVCM,A0
	BRA     ESCAPE
INVCM   DC.B    'ADDRESS FORMAT NOT ALLOWED',0
*
FMTO_DUMP MOVEQ #0,D0   DUMP USING DEFAULT SPEC
	MOVE.B  SCODE,D0
	LSL.L   #1,D0   * 2
	MOVEA.L D0,A0   GET SPEC ROUTINE ADDR
	BRA     FMTO_3
	PAGE
*       REVERSE ASSEMBLER CALL
XSPEC   EQU     *
	MOVE.L  A4,TEMPL        PUT INSTRUCTION ADDRESS IN TEMP AREA
	BTST    #0,TEMPL+3      MUST BE EVEN ADDRESS
	BNE     ADDRERROR
	MOVEQ   #2,D1
	BSR     FMTERRC DO SIZE CHECK
	CLR.L   TEMPL3
	MOVE.B  DSCODE,TEMPL3+3 PASS DEFAULT FORMAT CODE
	MOVEQ   #5,D0   CALL SYSTEM CODE TO DO CONVERSION
	JSR     SYSCALL
	MOVEA.L TEMPL,A4        GET THE NEW INSTRUCTION ADDRESS
	MOVEA.L TEMPL2,A0       GET THE STRING ADDRESS
	MOVEQ   #0,D1   GET THE STRING LENGTH
	MOVE.B  (A0)+,D1
	BEQ.S   DODC    IF NOT INSTRUCTION, STRING WILL BE NILL
	BSR     OUTALPHA        DUMP IT
XSPECL  BSR     OUTBLANK
	SUBQ.L  #1,RCOUNT
	BNE     XSPEC
	RTS
DCM     DC.B    'DC.W ' IS DEFINE CONSTANT
DODC    LEA     DCM,A0
	MOVEQ   #5,D1
	BSR     OUTALPHA
	MOVEQ   #2,D1   SIZE (WORD)
	LEA     -2(A4),A4       DEW 10/21/88 FIX DEFECT FSDdt01674
	MOVEA.L A4,A0   ADDRESS
	ADDA.L  D1,A4
	BSR     OUTHEX
	BRA     XSPECL

*       REAL NUMBER CONVERSION CALL
RSPEC   EQU     *               REAL NUMBER FORMAT
	MOVE.L  A4,TEMPL        PUT OUTPUT ADDRESS IN TEMP AREA
	BTST    #0,TEMPL+3      MUST BE EVEN ADDRESS
	BNE     ADDRERROR
	MOVEQ   #8,D1
	BSR     FMTERRC DO SIZE CHECK
	MOVEQ   #4,D0   CALL SYSTEM CODE TO DO REAL TO STRING CONVERSION
	JSR     SYSCALL
	MOVEA.L TEMPL,A4
	ADDQ.L  #8,A4   INCREMENT THE ADDRESS
	MOVEA.L TEMPL2,A0
	MOVEQ   #0,D1   GET THE STRING LENGTH
	MOVE.B  (A0)+,D1
	BSR     OUTALPHA        DUMP IT
	BSR     OUTBLANK
	SUBQ.L  #1,RCOUNT
	BNE     RSPEC
	RTS

*       OCTAL NUMBER CONVERSION
OSPEC   EQU     *
	LEA     OUTOCT,A1
	BRA     IFMT0
OPSPEC  EQU     *       OPEN PAREN SPEC
	TST.W   RCOUNT  UPPER HALF MUST BE ZERO
	BNE     SIZEERROR
	MOVE.L  RCOUNT,D0
	BSR     PUSHOP  PUSH COUNT ON OPSTACK
	CMPI.W  #1,D0
	BEQ.S   OPSRET  DON'T PUSH INPUT IF COUNT IS 1
	BRA     PUSHIN  PUSH CURRENT POINTERS ON INPUT STACK
*                       ( IT DOES RTS )
CPSPEC  EQU     *       CLOSE PAREN SPEC
	MOVEQ   #1,D0
	CMP.L   RCOUNT,D0
	BNE     SYNTAXE
	BSR     POPOP   POP COUNT FROM OPSTACK
	SUBQ.W  #1,D0
	BEQ.S   OPSRET  IF COUNT WAS 1 THEN ALL DONE
	BSR     PUSHOP  PUT COUNT BACK
	BSR     POPIN   POP INPUT TO ORIGINAL
	BSR     IFEOI   CHECK END OF INPUT
	BEQ     SYNTAXE
	CMPI.W  #1,D0
	BEQ.S   OPSRET  ALL DONE IF COUNT IS 1
	BSR     PUSHIN  COPY INPUT POINTERS
OPSRET  RTS
*       INFO VECTOR INPUT/OUTPUT HANDLERS
*       AND CONVERSION UTILITIES
*
OUTINFO EQU     *       GIVEN INFO VECTOR IN A0
*                       OUTPUT THE DATA
*
OUTIF0  BSR     UPKINFO D0=TYPE,D1=SIZE,A0=>DATA
	LSL.W   #1,D0   * 2
	MOVEA.L D0,A1
	MOVEA.W OUTTYPE(A1),A1
	JMP     OUTTYPE(A1)
*
OUTTYPE EQU     *
	DC.W    RETURN-OUTTYPE   EMPTY    0
	DC.W    OUTADDR-OUTTYPE  ADDRESS  1
	DC.W    OUTINT-OUTTYPE   INTEGER  2
	DC.W    OUTALPHA-OUTTYPE ALPHA    3
	DC.W    OUTHEX-OUTTYPE   HEX      4
	DC.W    OUTBIN-OUTTYPE   BINARY   5
	DC.W    OUTUINT-OUTTYPE  UINTEGER 6
*       OTHER TYPES ARE RESOLVED BY UPKINFO
*
*                       ADDRESS
OUTADDR CMPI.B  #6,DSCODE
	BNE.S   OUTADDR1
	BSR.S   OUTUINT UNSIGNED INTEGER
	BRA.S   OUTADDR3
OUTADDR1 CMPI.B #4,DSCODE
	BNE.S   OUTADDR2
	BSR.S   OUTHEX  HEX
	BRA.S   OUTADDR3
OUTADDR2 BSR.S  OUTINT  SIGNED INTEGER
OUTADDR3 MOVEQ  #'^',D0
	BRA     OUTBYTE
*                       SIGNED INTEGER
OUTINT  MOVE.B  #' ',TEMPL3+1   LEADING BLANKS
OUTINTS MOVEQ   #0,D2   LEADING CHARACTER FLAG ALREADY SET
	MOVE.B  #'+',TEMPL3
	BTST    #7,(A0) SIGNCHECK
	BEQ.S   OUTI2
	MOVEQ   #-1,D2
	BRA.S   OUTI2
OUTINT1 ASL.L   #8,D2
	MOVE.B  (A0)+,D2
OUTI2   DBRA    D1,OUTINT1
	TST.L   D2
	BPL.S   OUTI3
	MOVE.B  #'-',TEMPL3
	NEG.L   D2
OUTI3   MOVE.L  D2,D0
	BRA     BIN2DEC CONVERSION
*
OUTUINT MOVEQ   #0,D0   UNSIGNED INTEGER
	MOVE.W  #'  ',TEMPL3    LEADING BLANKS
	BRA.S   OUTU2
OUTU1   ASL.L   #8,D0
	MOVE.B  (A0)+,D0
OUTU2   DBRA    D1,OUTU1
	BRA     BIN2DEC CONVERSION
*                       ALPHA OUTPUT
OUTA1   MOVE.B  (A0)+,D0
	BSR     OUTBYTE
OUTALPHA DBRA   D1,OUTA1
	RTS
*                       HEX
OUTHEX  MOVEQ   #'$',D0
	BSR     OUTBYTE
	BRA.S   OUTH2
OUTH1   MOVE.B  (A0)+,D0
	BSR.S   HBOUT   OUTPUT 2 DIGITS
OUTH2   DBRA    D1,OUTH1
	RTS
*
HBOUT   MOVE.B  D0,D2
	LSR.B   #4,D0
	BSR.S   HBOUT1
	MOVE.B  D2,D0
HBOUT1  ANDI.B  #$0F,D0
	ORI.B   #$30,D0
	CMPI.B  #$39,D0
	BLE.S   HBOUT2
	ADDQ.B  #7,D0
HBOUT2  BRA     OUTBYTE
*                       BINARY OUTPUT
OUTBIN  MOVEQ   #'!',D0
	BSR     OUTBYTE
	BRA.S   OUTB2
OUTB1   MOVE.B  (A0)+,D0
	BSR.S   BBOUT
OUTB2   DBRA    D1,OUTB1
	RTS
*               BINARY BYTE OUT
BBOUT   MOVE.B  D0,D3
	MOVEQ   #7,D2
BBOUT0  BTST    D2,D3
	BEQ.S   BBOUT1
	MOVEQ   #'1',D0
	BRA.S   BBOUT2
BBOUT1  MOVEQ   #'0',D0
BBOUT2  BSR     OUTBYTE
	DBRA    D2,BBOUT0
	RTS

*       OCTAL OUTPUT    D1 = SIZE A0^ DATA
OUTOCT  MOVEQ   #'%',D0
	BSR     OUTBYTE
	MOVEQ   #0,D2   UNSIGNED
	BRA.S   OUTO2
OUTO1   ASL.L   #8,D2
	MOVE.B  (A0)+,D2
OUTO2   DBRA    D1,OUTO1
	CLR.B   TEMPL3  CLEAR OUTPUT FLAG
	MOVEQ   #10,D1  MAX DIGITS TO OUTPUT
	ROL.L   #2,D2   ROTATE 2 HIGH BITS TO LOW END
	MOVE.L  D2,D0   MOVE TO OUTPUT REG
	ANDI.L  #3,D0   MASK OFF HIGH BITS
	BRA.S   OUTO4
OUTO3   ROL.L   #3,D2   ROTATE IN NEXT 3 BITS
	MOVE.L  D2,D0   MOVE TO OUTPUT REG
	ANDI.L  #7,D0   MASK OFF HIGH BITS
OUTO4   BNE.S   OUTO5   IF NON ZERO THEN DUMP IT
	TST.B   TEMPL3  SUPPRESS LEADING ZEROES
	BEQ.S   OUTO6
OUTO5   MOVE.B  D0,TEMPL3       DID OUTPUT SOMETHING
	ADDI.L  #48,D0  CHANGE TO ASCII DIGIT
	BSR     OUTBYTE
OUTO6   DBRA    D1,OUTO3
	TST.B   TEMPL3
	BNE.S   OUTO7
	MOVE.B  #'0',D0         OUTPUT AT LEAST ONE ZERO
	BSR     OUTBYTE
OUTO7   RTS

	TTL     SPECIAL DATA ROUTINES
	PAGE
*
* SPECIAL ROUTINES FOR
* LINE No.
* I/O RESULT
* ESCAPE CODE
* GLOBAL BASE
* STACK POINTER
*
LNSPCL  EQU     *
*       UNPACK LINE NO.
UNPKLN  BRA     GETLNUM
*
IORSPCL EQU     *
*       UNPACK  I/O RESULT
UNPKIOR MOVEA.L REGA5,A0
	LEA     ioresult(A0),A0                                         (scs)
	BRA.S   DEFWRD
*
ECSPCL  EQU     *
*       UNPACK  ESCAPE CODE
UNPEC   MOVEA.L REGA5,A0
	LEA     escapecode(A0),A0                                       (scs)
	MOVEQ   #2,D0   SIGNED INT
	MOVEQ   #2,D1   2 BYTES
	RTS
*
GBSPCL  EQU     *
*       UNPACK  GLOBAL BASE POINTER
UNPGB   MOVEA.L G_DOLLAR,A0
	LEA     GLOBALBASE(A0),A0
DEFWRD  MOVEQ   #0,D0
	MOVE.B  DSCODE,D0       DEFAULT TYPE
	MOVEQ   #4,D1           4 BYTES
	RTS
*
RBSPCL  EQU     *
*       UNPACK  RELOCATION BASE POINTER
UNPRB   MOVEA.L G_DOLLAR,A0
	LEA     RBASEPTR(A0),A0
	BRA     DEFWRD
*
GETSP   EQU     *
*       UNPACK  STACK POINTER
UNPSP   LEA     REGA7,A0
	BTST    #5,REGSR        USER/SYSTEM
	BNE     DEFWRD
	LEA     REGUS,A0
	BRA     DEFWRD
	TTL     FORMATTER BINARY TO DECIMAL
	PAGE
*       CONVERT BINARY TO DECIMAL CALL OUTBYTE
*       TEMPL3 CONTAINS SIGN CHARACTER
*       TEMPL3+1 CONTAINS LEADING PAD CHARACTER
*
BIN2DEC MOVEM.L D1-D4/A0,-(SP) SAVE REGS
	MOVEA.L D5,A0   SAVE D5 FOR OUTBYTE USE
	MOVE.L  D0,D5   SAVE VALUE HERE
	MOVEQ   #10,D4         COUNTER
	MOVE.L  #1000000000,D2 POWER OF TEN
	TST.L   D5
	BPL.S   BIN2DC2
	MOVEQ   #1,D0   AT LEAST HAVE 1*10^10
BIN2DECA SUB.L  D2,D5   HANDLE 2^31 .. 2^32-1
	BPL.S   BIN2DC22
	ADDQ.B  #1,D0   INC DIGIT
	BRA     BIN2DECA
BIN2DC0 MOVEQ   #1,D2          VALUE TO SUB
	MOVE.L  D4,D1          COUNTER
	SUBQ.L  #1,D1          ADJUST - FORM POWER OF TEN
	BEQ.S   BIN2DC2        IF POWER IS ZERO
BIN2DC1 MOVE.W  D2,D3          D3  = LOWER WORD
	MULU    #10,D3
	SWAP    D2             D2 = UPPER WORD
	MULU    #10,D2
	SWAP    D3             ADD UPPER TO UPPER
	ADD.W   D3,D2
	SWAP    D2             PUT UPPER IN UPPER
	SWAP    D3             PUT LOWER IN LOWER
	MOVE.W  D3,D2          D2= UPPER & LOWER
	SUBQ.L  #1,D1
	BNE     BIN2DC1
BIN2DC2 CLR.L   D0             HOLDS SUB AMT
BIN2DC22 CMP.L  D2,D5
	BLT.S   BIN2DC3        IF NO MORE SUB POSSIBLE
	ADDQ.L  #1,D0          BUMP SUBS
	SUB.L   D2,D5          COUNT DOWN BY POWERS OF TEN
	BRA.S   BIN2DC22       DO MORE
BIN2DC3 TST.B   TEMPL3         ANY VALUE?
	BEQ.S   BIN2DC4
	TST.B   D0
	BEQ.S   BIN2DC6
	MOVE.B  D0,TEMPL3+2     START OF DATA
	MOVE.B  TEMPL3,D0       GET SIGN
	BSR.S   BINOUT
	MOVE.B  TEMPL3+2,D0
	CLR.B   TEMPL3          MARK DATA STARTED
BIN2DC4 ADD.B   #$30,D0        BINARY TO ASCII
	BSR.S   BINOUT
BIN2DC5 SUBQ.L  #1,D4          NEXT POWER
	BNE     BIN2DC0
BIN2DCX MOVE.L  A0,D5   RESTORE D5
	MOVEM.L (SP)+,D1-D4/A0
	RTS                     JUST END ROUTINE
BIN2DC6 SUBQ.L  #1,D4
	BEQ.S   BIN2DC7
	MOVE.B  TEMPL3+1,D0     GET LEADING CHARACTER
	BEQ     BIN2DC0 NO LEADING CHARACTERS
	BSR.S   BINOUT          OUTPUT LEADING CHARACTER
	BRA     BIN2DC0
*
BINOUT  EXG     D5,A0   SWITCH IN D5
	BSR     OUTBYTE        DUMP IT
	EXG     D5,A0   SWITCH IT BACK
	RTS
*
BIN2DC7 MOVEQ   #' ',D0
	BSR     BINOUT         PRINT AT LEAST A ZERO
	MOVEQ   #'0',D0
	BSR     BINOUT
	BRA     BIN2DCX        END OF ROUTINE
	TTL     FORMATTER UTILITIES
	PAGE
* GIVEN A0 POINTS TO INFO VECTOR
* UNPACK TO D0=TYPE, D1=SIZE, A0 POINTS TO DATA
*
UPKACCM LEA     ACCUMV,A0       UNPACK ACCUMULATOR
UPKINFO MOVEQ   #0,D0
	MOVE.L  D0,D1
	MOVE.B  (A0)+,D0        TYPE
	MOVE.B  (A0)+,D1        SIZE
*                       A0 POINTS TO DATA
	BCLR    #7,D0   INDIRECT ?
	BEQ.S   UPKI1
	MOVEA.L (A0),A0
UPKI1   CMPI.B  #7,D0
	BLT.S   UPKRET
	BNE.S   UPKI2
	MOVE.B  (A0)+,D1  CHANGE STRING TO ALPHA
	MOVEQ   #3,D0
UPKRET  RTS
UPKI2   CMPI.B  #14,D0  INSTRUCTION FORMAT
	BEQ     UPKRET
	CMPI.B  #15,D0  REAL NUMBER
	BEQ     UPKRET
	CMPI.B  #16,D0  OCTAL NUMBER
	BEQ     UPKRET
	MOVEA.L (A0),A0 DATA IS POINTER
	CMP.B   #8,D0
	BEQ     UPKINFO TYPE POINTER
	JMP     (A0)    LET ROUTINE GET VALUE
	PAGE
** GET LINENUMBER D0=TYPE D1=SIZE A0=ADDRESS
*
GETLNUM MOVEQ   #6,D0   DEFAULT UNSIGNED INT
	MOVEQ   #4,D1   4 BYTES
	LEA     TEMPL4,A0
	CLR.L   (A0)    CLEAR LONG VALUE
	MOVEA.L LASTLINE,A1
	CMPI.W  #$4E40,(A1)+    CHECK FOR TRAP0
	BNE.S   GETLN2
	MOVE.W  (A1),2(A0)      IS LINE NO.
	RTS
GETLN2  MOVEQ   #2,D0   SIGNED INT
	NOT.L   (A0)    -1
	RTS
	TTL     EXCEPTION HANDLER
	PAGE
*------------------------------------------------
*------------------------------------------------
*       EXCEPTION HANDLER FOR PASCAL DEBUGGER
*------------------------------------------------
*------------------------------------------------
*
* TRAP 0   HANDLER
* rdq NOV 81
*
TRAP0   EQU     *       start of statement exception process
	MOVE    #$2700,SR       LOCKOUT INTERUPTS
	SUBQ.L  #2,2(SP)        BACKUP TO 4E40
	MOVE.L  2(SP),LASTLINE  save last line address
	ADDQ.L  #4,2(SP)        inc. PC past line #
	TST.B   LTFLAGS         anything to do ?
	BNE.S   TRAP0_0
	RTE             NO SO RETURN
*
TRAP0_0 MOVEM.L D5-D7/A0-A1,-(SP)  save scratch regs
	BCLR    #6,DSTATUS      CLEAR CALL FLAG
	MOVEQ   #0,D5   CLEAR IMPLANT FLAG
	MOVEQ   #0,D7   clear FLAGS reg.
	MOVE.B  LTFLAGS,D7      load reg.
	MOVEQ   #7,D6   set bit pointer
	LEA     TRAP0JV,A0      get jumptable address
*
TRAP0_1 BCLR    D6,D7   test & clear the next bit
	BEQ.S   TRAP0_2
	MOVEA.L (A0),A1
	JSR     (A1)    do the task
*
TRAP0_2 ADDQ.L  #4,A0   next jump entry
	TST.B   D7      all done ?
	DBEQ    D6,TRAP0_1      if not then check next task
	TST.L   D5
	BNE.S   TRAP0_4         IMPLANT DETECTED
	BCLR    #0,DSTATUS2     CHECK 2nd STRING
	BEQ.S   TRAP0_3
	MOVE.L  TEMPL2,D5       CHANGE 2nd STRING TO 1st
	BRA.S   TRAP0_4
TRAP0_3 MOVEM.L (SP)+,D5-D7/A0-A1  restore scratch regs
	BCLR    #6,DSTATUS      CHECK CALL FLAG
	BNE     DBUGCMD2        CALL INTERPRETER
	btst    #7,(sp)         trace bit on?                           (scs)
	bne     trace           trap immediately                        (scs)
	rte                     return to user                          (scs)

TRAP0_4 MOVE.L  D5,TEMPL
	MOVEM.L (SP)+,D5-D7/A0-A1  restore scratch regs
	BRA     DBUGOBEY
*
TRAP0JV DC.L    QLINE           7
	DC.L    LFLASH          6
	DC.L    T0CHKA6         5
	DC.L    T0NPROC         4
	DC.L    RETURN          3
	DC.L    TSTEPC          2
	DC.L    LSTEP           1
	DC.L    CHKIMPLANT      0
*========================
*
QLINE   EQU     *       enter LASTLINE into QUEUE
	MOVE.L  A1,-(SP)        save scratch reg
	MOVEA.L QLAST,A1
	MOVE.L  LASTLINE,(A1)+
	CMPA.L  QEND,A1
	BNE.S   QLINE_1
	MOVEA.L QSTART,A1
QLINE_1 MOVE.L  A1,QLAST
	MOVEA.L (SP)+,A1        restore scratch reg
	RTS
*
LFLASH  EQU     *       flash the line no. on the CRT
	MOVE.L  D0,-(SP)
	MOVEQ   #6,D0
	BSR     SYSCALL9        DISPLAY LASTLINE
	BTST    #1,D7   IF STOPPING DON'T WAIT
	BNE.S   LFLASH2
*                               wait a while
	MOVE.W  #$FFFF,D0
LFLASH1 MOVE.L  (SP),(SP)
	DBRA    D0,LFLASH1
LFLASH2 MOVE.L  (SP)+,D0
	RTS
*========================
*
T0CHKA6 CMPA.L  OLDA6,A6        CHECK A6
	BLS.S   EXECRET
	MOVE.L  #PROCEM,D5      SET COMMAND
T0PXIT  MOVEQ   #0,D7   KILL REST OF TRAP 0 OPS
EXECRET RTS
PROCEM  DC.B    17,'D "PROC EXITED";?'
*========================
*
T0NPROC CMPA.L  OLDA6,A6        CHECK A6
	BEQ.S   EXECRET
	MOVE.L  #PROCNM,D5      SET COMMAND
	BRA.S   T0PXIT
PROCNM  DC.B    15,'D "NEXT PROC";?'
*========================
*
CHKIMPLANT EQU  *       check for and execute any implants
	MOVEM.L D0/A0-A1,-(SP)
	MOVEA.L LASTLINE,A1     line address
	MOVE.W  2(A1),D0        get the line no.
	MOVEA.L IMFIRST,A0
CHKIM0  CMPI.B  #$32,(A0)       what type ?
	BNE.S   CHKIM1
	CMP.W   4(A0),D0        check the line number/CHG32
	BNE.S   CHKIM1
	LEA     9(A0),A0         CHG32
	CMPI.B  #$FF,(A0)        COUNT ?
	BNE.S   CHKIM0A
	TST.L   1(A0)   ZERO COUNT SO PERM BP
	BEQ.S   CHKIM3
	SUBI.L  #1,1(A0)         COUNT DOWN
	BNE.S   CHKIM2
	LEA     NATL,A0
CHKIM0A MOVE.L  A0,D5            SET STRING ADDR.
	BRA.S   CHKIM2
NATL    DC.B    28,'BC LN;D LN:"NOW AT LINE ",;?'
CHKIM1  ADDA.L  #IMSIZE,A0      next implant
	CMPA.L  IMLAST,A0       done yet ?
	BNE     CHKIM0
CHKIM2  MOVEM.L (SP)+,D0/A0-A1
	RTS
CHKIM3  LEA     NATLP,A0
	BRA     CHKIM0A
NATLP   DC.B    24,';D LN:"NOW AT LINE ",;? '
*========================
*
TSTEPC  EQU     *       check and decriment step counter
	TST.L   TCOUNT
	BNE.S   TSTOPC_0
STOPXIT BCLR    #2,LTFLAGS      kill count check
	BNE.S   TSTOPLT
	BSET    #1,D7   SET STOP FLAG
	BCLR    #2,TFLAGS       kill count check
	RTS
TSTOPC_0 SUBQ.L #1,TCOUNT
	BEQ     STOPXIT
*
FASTXIT ANDI.B  #1,D7   ignore remaining ops.
	RTS             except implants
TSTOPLT MOVE.L  #NATLP,TEMPL2
	BSET    #0,DSTATUS2     SET 2nd STRING FLAG
	BRA     FASTXIT
*=========================
LSTEP   EQU     *       wait for step key etc.
	MOVE.L  D0,-(SP)        save D0 for use by exchangerun
	MOVE.B  #'s',TEMPR      show waiting for step
	BSR     EXCHANGERUN
	BSET    #1,DSTATUS      set waiting for stepkey flag
	MOVE    #$2000,SR       enable keyboard interupts
LSTEP0  BTST    #1,DSTATUS      check flag
	BNE     LSTEP0
	MOVE    #$2700,SR       set priority backup     {rdq}
	BSR     RESTORERUN
	MOVE.L  (SP)+,D0
	RTS
	TTL     TRAP 15 (BREAK POINT)
	PAGE
*
* TRAP15 HANDLER
*
TRAP15  EQU     *
	MOVE    #$2700,SR       BLOCK ISR'S
	SUBQ.L  #2,2(SP)        BACKUP PC
	BSR     CLRBRKS         CLEANUP BREAK POINTS
	MOVE.L  2(SP),ACCUMV+2  GET PC
	MOVE.W  #$0104,ACCUMV   SET TYPE
	MOVEM.L A0/D2,-(SP)     SAVE WORK REGS
	BSR     FINDACBR        FIND BREAK POINT
	BNE.S   T15OPS5
	LEA     9(A0),A0        CHG32
	CMPI.B  #$FF,(A0)       COUNT
	BNE.S   T15OPS3A
	TST.L   1(A0)
	BEQ.S   T15OPS6 PERM BP
	SUBQ.L  #1,1(A0)        COUNT DOWN
	BNE.S   T15OPS7
	LEA     NATI,A0
T15OPS3A MOVE.L A0,TEMPL        SET ADDRESS
	MOVEM.L (SP)+,A0/D2     RESTORE WORK REGS
	BRA     DBUGOBEY        EXCUTE THE CMD(S)
NATI    DC.B    30,'BC PC^;D PC:"PC NOW AT ",;TD;?'
T15OPS5 LEA     UBREAK,A0
	BRA     T15OPS3A
T15OPS6 LEA     NATIP,A0
	BRA     T15OPS3A
NATIP   DC.B    23,'TD;D PC:"PC NOW AT ",;?'
UBREAK  DC.B    26,'D PC:"USER TRAP 15 AT ",;?'
*       EXECUTE THRU TRAP15
T15OPS7 MOVEM.L (SP)+,A0/D2     RESTORE WORK REGS
	BSET    #7,DSTATUS2     SET THRU BP FLAG
	BSET    #7,(SP) SET TRACE BIT
	RTE             EXECUTE ONE INSTRUCTION
	TTL     TRACE TRAP ROUTINE
	PAGE
TRACE   MOVE    #$2700,SR       LOCK OUT ISR'S
	BCLR    #7,DSTATUS2     THRU BP ?
	BEQ.S   TRACEA
	BSR     SETBRKS
TRACEA  BTST    #6,DSTATUS2     DEBUGGER TRACE ?
	BNE.S   TRACEC
TRACEB  BCLR    #7,(SP) KILL TRACE BIT
	RTE             BACK TO USER
TRACEC  TST.B   TFLAGS  ANYTHING TO DO ?
	BNE.S   TRACE_0
	RTE             BACK TO USER
*
TRACE_0 CMPI.L  #REALDEBUGGER,2(SP)
	BEQ     TRACEB  DON'T TRACE THRU DEBUGGER
	CMPI.L  #DEBUGESCAPE,2(SP)
	BEQ     TRACEB
	MOVE.L  2(SP),LASTLINE  SAVE PC
	MOVEM.L D5-D7/A0-A1,-(SP) save scratch regs
	MOVEQ   #0,D5   CLEAR IMPLANT FLAG
	MOVEQ   #0,D7   clear status reg.
	MOVE.B  TFLAGS,D7       load reg.
	BSET    #6,D7   FORCE TRAP CHK
	MOVEQ   #7,D6   set bit pointer
	LEA     TRACEJV,A0      get jumptable address
*
TRACE_1 BCLR    D6,D7   test & clear the next bit
	BEQ.S   TRACE_2
	MOVEA.L (A0),A1
	JSR     (A1)    do the task
*
TRACE_2 ADDQ.L  #4,A0   next jump entry
	TST.B   D7      all done ?
	DBEQ    D6,TRACE_1      if not then check next task
	MOVE.L  D5,TEMPL
	MOVEM.L (SP)+,D5-D7/A0-A1 restore scratch regs
	TST.L   TEMPL
	BNE     DBUGOBEY
	RTE
*
TRACEJV DC.L    TQLINE          7
	DC.L    TRAPCHK         6
	DC.L    RETURN          5
	DC.L    RETURN          4
	DC.L    RETURN          3
	DC.L    TSTEPC          2
	DC.L    TSTOP           1
	DC.L    TDO_TD          0
*================================
*
TQLINE  MOVEA.L LASTLINE,A1
	CMPI.W  #$4E40,(A1)
	BNE     QLINE
	RTS     IF TRAP 0 THEN DON'T QUEUE IT
*
TSTOP   MOVE.L  #STOPC,D5
TDONE   MOVEQ   #0,D7   CANCEL TRACE OPS
	RTS
STOPC   DC.B    4,'TD;?'
*
TDO_TD  MOVE.L  #DOTD,D5
	RTS
DOTD    DC.B    2,'TD'
*
*       DON'T TRACE EXECPTION VECTORS
*
TRAPCHK MOVE.L  LASTLINE,-(SP)
*       CLR.B   (SP)    CLEAR HIGH BYTE   CHG32
	CMPI.L  #$FFFFFEDA,(SP)+          CHG32
* changed 11/28/90 JWH :
*       BGE     TDONE
	BHI     TDONE
	RTS
	PAGE
*
*       ERROR TRAP 'EXCEPTION'
*
*       STOP ON ALL EXCEPT
UEXCPE  BSR.S   FINDEC
	BNE.S   UEXCPA
	RTS
*       STOP ON ONLY
UEXCPO  BSR.S   FINDEC
	BEQ.S   UEXCPA
	RTS
FINDEC  MOVEM.L A0/A5/D0/D1,-(SP)                                       (scs)
	LEA     ETCODES,A0
	MOVEA.L G_DOLLAR,A5                                             (scs)
	MOVE.W  escapecode(A5),D1       ESCAPE CODE                     (scs)
	MOVEQ   #0,D0
	MOVE.B  NUMET,D0
	BRA.S   FINDEC2
FINDEC1 CMP.W   (A0)+,D1
FINDEC2 DBEQ    D0,FINDEC1
	MOVEM.L (SP)+,A0/A5/D0/D1                                       (scs)
	RTS
*       STOP ON ALL
UEXCPA  MOVE.L  #ECDUMP,TEMPL   DUMP EXECPTION
UEXCPA1 TST.B   M68KTYPE                                (rdq)
	BEQ.S   UEXCPAA                                 (rdq)
	MOVE.W  (SP),-(SP)      MOVE PC DOWN 2 BYTES    (rdq)
	MOVE.W  4(SP),2(SP)                             (rdq)
	CLR.W   4(SP)           FAKE VECTOR WORD        (rdq)
UEXCPAA MOVE    EXCP_STATUS,-(SP)        PUSH SR
	MOVE    #$2700,SR       USE MAX PRIORITY
	BRA     DBUGOBEY
ECDUMP  DC.B    4,'DE;?'        DUMP EXCEPTION
*       STOP AND DO IMPLANT
UEXCPIMP MOVE.L UEXCPI,TEMPL
	BRA     UEXCPA1
	TTL     CRT & KEYBOARD DRIVERS
	PAGE
*------------------------------------------------
*------------------------------------------------
*  DEBUGGER DRIVERS FOR CRT AND KEYBOARD
*  rdq MAY 81 -- 24 AUG 81 -- 1 DEC 83
*------------------------------------------------
*------------------------------------------------
*
*  EQUATES FOR KEYBOARD & CRT DRIVERS
*
TRAP10V EQU     $FFFFFF58
*
PROMPT  MOVE.B  #4,OUTFLAGS     CRT
	BTST    #6,DSTATUS2     CHECK TRACE MODE
	BEQ.S   PROMPT0
	MOVEQ   #'T',D0 TRACE MODE PROMPT
	BSR     OUTBYTE
PROMPT0 MOVEQ   #'>',D0 PROMPT ">"
	BRA     OUTBYTE
*
* IF DONE FLAG IS SET THEN CURRENT COMMAND
* IS FROM BREAK POINT.  INPUT CANCELS THE
* AUTO RETURN TO USER CODE
*
PDINPUT BSET    #2,DSTATUS2     WANT UP/DOWN
DINPUT  EQU     *
	BCLR    #5,DSTATUS      CLEAR DONE FLAG
	BSR     INPUTCLR        CLEAR INPUT BUFFER
	LEA     DINBUF,A4       BUFFER ADDRESS
	MOVE.W  #DINBUFMAX,D7   BUFFER SIZE
	MOVEQ   #0,D6   CURRENT SIZE
	MOVE.W  D6,D5   CURRENT POSITION
	BSR     PROMPT
DINPUT1 BSR.S   INKEY
	MOVE.B  #4,OUTFLAGS     CRT ONLY
	TST     D1
	BNE.S   DINBAD
	BCLR    #2,DSTATUS2     NOT UP/DOWN ARROW
	MOVE.B  D6,DINSIZE
	BEQ.S   DINPUT1C        CHECK NO INPUT
*                       COPY TO RECALL BUFFER
	MOVEA.L RECALLV,A0      POINT A0 TO RECALL BUF.
	MOVE.W  D6,(A0)+        SET LENGTH  JS 4/29/85
	MOVEA.L A4,A1           FROM INPUT BUF.
	MOVE.W  D6,D1
	BRA.S   DINPUT1B
DINPUT1A MOVE.B (A1)+,(A0)+
DINPUT1B DBRA   D1,DINPUT1A
*
DINPUTX LEA     DINSIZE,A0
RETURN  RTS
*
DINPUT1C BTST   #6,DSTATUS2     TRACE MODE ?
	BEQ     DINPUTX
	MOVE.B  #1,DINSIZE      DEFAULT T COMMAND
	MOVE.B  #'T',DINBUF
	BRA     DINPUTX         RETURN
*
DINBAD  BTST    #2,DSTATUS2     ALLOW UP/DOWN ?
	BEQ.S   DINBAD1
	BCLR    #3,DSTATUS2
	CMPI.B  #$22,D0 DOWN ARROW
	BEQ     RETURN
	BSET    #3,DSTATUS2
	CMPI.B  #$23,D0 UP ARROW
	BEQ     RETURN
DINBAD1 BSR.S   KBEEP
	BRA     DINPUT1
*
KBEEP   MOVEQ   #6,D0
	BRA     SYSCALL         USE SYSTEM INTERFACE TO BEEP
*
INKEY   EQU     *
	MOVE.B  #6,OUTFLAGS     BUFFER AND CRT
GETKEY  BSR     READKEYS
	MOVE.B  KBDSTATREG,D1
	MOVE.B  KBDCHAR,D0
	TST.B   KBDTRANSCODE    0=ALPHA 1=SPECIAL
	BNE.S   KUDKSVC         SPECIAL
*       DROP THRU FOR ALPHA
* -----------------------------------------------
KPRNT0  EQU     *               HAVE ALPHA TEXT
	BSR     OUTBYTE         OUTPUT ONE CHARACTER
	BCLR    #7,DSTATUS      CLEAR ERROR FLAG
	BRA     GETKEY
KINTRT  RTS
*
FUNCTAB EQU     *
	DC.W    KINTRT-FUNCTAB  CAPS LOCK (KEYCODE 24)
	DC.W    KINTRT-FUNCTAB  TAB
	DC.W    UDK0-FUNCTAB    K0
	DC.W    UDK1-FUNCTAB    K1
	DC.W    UDK2-FUNCTAB    K2
	DC.W    UDK5-FUNCTAB    K5
	DC.W    UDK6-FUNCTAB    K6
	DC.W    UDK7-FUNCTAB    K7
	DC.W    UDK3-FUNCTAB    K3
	DC.W    UDK4-FUNCTAB    K4
	DC.W    UPDOWN-FUNCTAB  DOWN ARROW
	DC.W    UPDOWN-FUNCTAB  UP ARROW
	DC.W    UDK8-FUNCTAB    K8
	DC.W    UDK9-FUNCTAB    K9
	DC.W    LEFT-FUNCTAB    LEFT ARROW
	DC.W    RIGHT-FUNCTAB   RIGHT ARROW
	DC.W    KINTRT-FUNCTAB  INS LN
	DC.W    GTGL-FUNCTAB    DEL LN  ANOTHER WORT FOR THE 9816A KEYBOARD
	DC.W    RECALL-FUNCTAB  RECALL
	DC.W    INSERT-FUNCTAB  INS CHR
	DC.W    DELETE-FUNCTAB  DEL CHR
	DC.W    CLREND-FUNCTAB  CLR END
	DC.W    BACKSP-FUNCTAB  BACK SPACE
	DC.W    KINTRT-FUNCTAB  RUN
	DC.W    KINTRT-FUNCTAB  EDIT
	DC.W    ATGL-FUNCTAB    ALPHA
	DC.W    GTGL-FUNCTAB    GRAPHICS
	DC.W    STEPKEY-FUNCTAB STEP
	DC.W    CLEARLN-FUNCTAB CLR LN/CLR SCR
	DC.W    KINTRT-FUNCTAB  RESULT
	DC.W    KINTRT-FUNCTAB  PRT ALL
	DC.W    STOPKEY-FUNCTAB STOP
	DC.W    PAUSEKEY-FUNCTAB PAUSE
	DC.W    EXECKEY-FUNCTAB ENTER
	DC.W    CONKEY-FUNCTAB  CONTINUE
	DC.W    EXECKEY1-FUNCTAB EXECUTE
*
KUDKSVC EQU     * SPECIAL KEY SERVICE
	MOVEQ   #0,D2
	MOVE.B  KBDCHAR,D2
	CMPI.B  #$18,D2
	BCS     KINTRT  CAN'T HANDLE IT
	SUB.B   #$18,D2
	LSL.B   #1,D2
	LEA     FUNCTAB,A0
	ADDA.W  0(A0,D2),A0
	JMP     (A0)
*
* HANDLE ALPHA KEYS (CRTL / SHIFT)
*
ATGL    BTST    #5,D1   CNTRL
	BEQ.S   CRTSWAP
	BTST    #4,D1   SHIFT (DUMP ALPHA)
	BEQ     DODUMPA
*
ATGL1   BTST    #0,AONOFF       TEST ALPHA
	BNE.S   ATGL2
	BSR.S   ALONOFF         TURN ON ALPHA
	BRA     GETKEY
ATGL2   BTST    #0,GONOFF       TEST GRAPHICS
	BEQ     GETKEY
	BSR.S   GRONOFF         TURN OFF GRAPHICS
	BRA     GETKEY
*
ALONOFF MOVEQ   #8,D0           TOGGLE ALPHA CALL
	BRA     SYSCALL
*
CRTSWAP EQU     *
	BTST    #4,DSTATUS      CRT STATUS
	BEQ.S   MAKEDCRT
	BSR     UNSAVECRT
	BRA     GETKEY
MAKEDCRT BSR    SAVECRT
	BRA     GETKEY
*
* GRAPHICS KEY (SHIFT / CNTRL)
*
GTGL    BTST    #5,D1   CNTRL
	BEQ     KINTRT  CAN'T HANDLE CTRL GRAPHICS
	BTST    #4,D1   SHIFT (DUMP GRAPHICS)
	BEQ     DODUMPG
*                       BEQ     KINTRT  CAN'T HANDLE IT
	BTST    #0,GONOFF       TEST GRAPHICS
	BNE.S   GTGL1
	BSR.S   GRONOFF         TURN ON GRAPHICS
	BRA     GETKEY
GTGL1   BTST    #0,AONOFF       TEST ALPHA
	BEQ     GETKEY
	BSR     ALONOFF         TURN OFF ALPHA
	BRA     GETKEY
*
GRONOFF MOVEQ   #1,D0   TOGGLE GRAPHICS CALL
	BRA     SYSCALL
*
BLANKDCRT EQU   *       BLANK DEBUGGER "CRT"
	MOVE.L  D0,-(SP)
	BTST    #4,DSTATUS
	BEQ.S   DCRTM
	MOVEQ   #5,D0   "CRT" IS SCREEN
	BRA.S   DCRTM0
*
DCRTM   MOVEQ   #4,D0   "CRT" IS RAM
DCRTM0  BSR     SYSCALL0
	MOVE.L  (SP)+,D0
	RTS
*
*       OUTPUT A BYTE TO CRT/BUFFER
OUTBYTE EQU     *
	BTST    #7,DSTATUS      IF ERROR
	BNE.S   OUTXIT  DON'T DO ANYTHING
	BTST    #1,OUTFLAGS     BUFFER
	BEQ.S   OUTBYTE1
	BSR.S   BUFOUT
	BTST    #7,DSTATUS
	BNE.S   OUTXIT
OUTBYTE1 BTST   #2,OUTFLAGS     CRT
	BNE.S   CRTOUT
OUTXIT  RTS
*               PUT A CHARACTER IN THE BUFFER
BUFOUT  CMP.W   D7,D5
	BEQ.S   BUFERR  ALREADY AT END
	MOVE.B  D0,0(A4,D5)  PUT IN BUFFER
	CMP.W   D5,D6
	BNE.S   BUFOUT1
	ADDQ.W  #1,D6   NEW SIZE
BUFOUT1 ADDQ.W  #1,D5
BUFXIT  RTS
BUFERR  BSET    #7,DSTATUS      BUFFER OVERFLOW
	BRA     KBEEP
*
* SEND ONE CHARACTER TO CRT
*
CRTOUT  BSR     SAVECRT FORCE DEBUGGER CRT
CRTOUT1 MOVE.B  D0,CRTCHAR
	MOVEQ   #1,D0        PUT CHAR & ADVANCE CURSOR
	BSR     SYSCALL0
	BTST    #0,OUTFLAGS     CHECK COUNTER ?
	BEQ.S   CRTRET
	CMPI.W  #21,LINECOUNT
	BEQ.S   WAITPROMPT
CRTRET  RTS
*  TOO MUCH DATA FOR ONE SCREEN SO WAIT
*  FOR OPERATOR TO CONTINUE OR CANCEL.
*  IF EXECUTING BREAK POINT IMPLANT (DONE FLAG
*  SET) THEN CANCEL AUTO RETURN TO USER CODE
*
WAITPROMPT EQU  *
	BCLR    #5,DSTATUS      CLEAR DONE FLAG
	MOVEM.L D0-D2/A0,-(SP)
	CLR.W   LINECOUNT       RESET THE COUNTER
	MOVE.L  #'MORE',CRTPROMPT
	MOVE.B  #4,CRTPROMPTSIZE
	MOVEQ   #2,D0
	BSR     SYSCALL0        PRINT THE PROMPTSTRING
READAGAIN EQU   *
	BSR     READKEYS EXEC/ENTER TO CONTINUE
*                        SHIFT EXEC TO STOP
	MOVE.B  KBDSTATREG,D1
	ANDI.B  #$F0,D1 CHECK SHIFT/CTRL BITS
	CMPI.B  #$B0,D1 NORMAL ?
	BEQ.S   IFEXEC
	CMPI.B  #$A0,D1 SHIFT ?
	BNE     READAGAIN
	CMPI.B  #$3B,D0 SHIFT EXEC ?
	BNE     READAGAIN
	MOVEA.W LINECOUNT,A0 NO MESSAGE ESCAPE
	BRA     ESCAPE
IFEXEC  MOVE.B  KBDCHAR,D0
	CMPI.B  #$3B,D0 EXEC ?
	BEQ.S   READRET
	CMPI.B  #$39,D0 ENTER ?
	BNE.S   READAGAIN
READRET MOVEM.L (SP)+,D0-D2/A0
	RTS
*       MORE CRT INTERFACE
OUTEOL  MOVE.B  #3,-(SP)
JCALL0  MOVE.B  (SP)+,CRTOPCODE { MUST ALLWAYS JUMP HERE }
	MOVE.L  D0,-(SP)        { SAVE THEN RESTORE D0 }
	MOVEQ   #0,D0
	BSR     SYSCALL
	MOVE.L  (SP)+,D0
RETX    RTS
CBWD    MOVE.B  #8,-(SP)        { BACKUP THE CURSOR }
	BRA     JCALL0
CFWD    MOVE.B  #9,-(SP)        { CURSOR FORWARD }
	BRA     JCALL0
*
CONKEY  BSR     CLRBUF  KILL ANY INPUT
	BSR.S   CLRFLASH        CLEAR FLASH DISPLAY
	ANDI.B  #$B9,LTFLAGS    KILL STEP,FLASH,AND COUNT
RUNEXIT BCLR    #6,DSTATUS2     KILL TRACE MODE
	BSET    #5,DSTATUS      SET DONE FLAG
EXECKEY BSR     OUTEOL
ENDKEY  MOVEQ   #0,D1   NORMAL EOL
	RTS

EXECKEY1 BTST   #5,D1   THIS IS A WORT FOR THE 9816A KEYBOARD
	BEQ     CRTSWAP
	BRA     EXECKEY
*
CLRFLASH MOVEQ  #4,D0           CLEAR FLASH DISPLAY
	BRA     SYSCALL9        (SYSCALL9 DOES RTS)
*
UDK0    LEA     K0DATA,A0       GET INFO VECTOR
	BRA.S   DOUDK
UDK1    LEA     K1DATA,A0
	BRA.S   DOUDK
UDK2    LEA     K2DATA,A0
	BRA.S   DOUDK
UDK3    LEA     K3DATA,A0
	BRA.S   DOUDK
UDK4    LEA     K4DATA,A0
	BRA.S   DOUDK
UDK5    LEA     K5DATA,A0
	BRA.S   DOUDK
UDK6    LEA     K6DATA,A0
	BRA.S   DOUDK
UDK7    LEA     K7DATA,A0
	BRA.S   DOUDK
UDK8    LEA     K8DATA,A0
	BRA.S   DOUDK
UDK9    LEA     K9DATA,A0
DOUDK   ANDI.B  #$30,D1 NO SHIFT OR CTRL
	CMPI.B  #$30,D1
	BNE.S   BEEPEND
	BSR     OUTINFO
	BCLR    #7,DSTATUS      CLEAR ERROR FLAG
	BRA     GETKEY
*
*       UP/DOWN ARROW KEYS
UPDOWN  ANDI.B  #$30,D1 NO CTRL OR SHIFT
	CMPI.B  #$30,D1
	RTS
*
BEEPEND BSR     KBEEP
	BRA     GETKEY
*                               PAUSE KEY OPS                           {rdq}
PAUSEKEY MOVE.B REGSR,D1
	ANDI.B  #$0F,D1 DISALLOW PAUSE IF
	BNE     BEEPEND PRIORITY NON ZERO
	BSR     CLRBUF
	MOVE.L  REGPC,PCTEMP    SAVE PC AND SR
	MOVE.W  REGSR,SRTEMP
	MOVE.L  #WAITSET,REGPC  SET TO GAIN
	MOVE.W  #$2700,REGSR    CONTROL AS USER
	BRA     RUNEXIT

WAITSET MOVE.L  D0,-(SP)        SWITCH RUNLIGHT THEN GOTO WAITContinue
	MOVE.B  #'p',TEMPR
	BSR     EXCHANGERUN
	MOVE.L  (SP)+,D0
	BSET    #1,DSTATUS      SET WAITING FLAG
	BRA     WAITC

*       STOP AND CLR I/O
STOPKEY MOVE.B  REGSR,D1        CHECK PRIORITY
	BTST    #5,D1   IF USER MODE THEN OK    {RQ}
	BEQ.S   STOPK1
	ANDI.B  #$0F,D1 DISALLOW STOP IF
	BNE     BEEPEND PRIORITY NON ZERO
STOPK1  BSR     CLRBUF
	MOVE.W  #RTSOP,SAVEESC  KILL ET TRAPS
	MOVE.L  REGPC,PCTEMP    SAVE PC AND SR
	MOVE.W  REGSR,SRTEMP
	MOVE.L  #FAKESTOP,REGPC SET TO GAIN
	MOVE.W  #$2700,REGSR    CONTROL THE RETURN
	BRA     RUNEXIT
*
FAKESTOP TST.B  M68KTYPE        GENERATE EXCEPTION INFO                 (rdq)
	BEQ.S   FS1                                                     (rdq)
	MOVE.W  #$A8,-(SP)      FAKE VECTOR WORD                        (rdq)
FS1     MOVE.L  PCTEMP,-(SP)
	move    initsr,-(sp)                                            (scs)
	move    #$2000,sr                                               (scs)
	MOVEA.L G_DOLLAR,A5     GENERATE ESC -20
	MOVE.W  #-20,escapecode(A5)     ESC CODE                        (scs)
	MOVE.L  INITRECOVER,recoverblk(A5) RECOVER TO SYS               (scs)
	JMP     TRAP10V JUMP TO TRAP #10 VECTOR
*
STEPKEY BTST    #4,D1   SHIFT
	BEQ     BEEPEND
	BSR     CLRBUF  KILL INPUT BUFFER
	BTST    #5,D1   CRTL
	BEQ.S   SFLASH
	ORI.B   #$42,LTFLAGS    SET FLASH & STEP
	BCLR    #2,LTFLAGS      CLEAR COUNT
	MOVEQ   #'s',D0
	BSR     SHOWSTAT0
	BRA     RUNEXIT
*
SFLASH  BSET    #6,LTFLAGS      SET FLASH FLAG
	ANDI.B  #$F9,LTFLAGS    CLEAR STEP & COUNT
	MOVEQ   #'f',D0
	BSR     SHOWSTAT0
	BRA     RUNEXIT
*
LEFT    TST.W   D5      LEFT CURSOR
	BEQ     BEEPEND AT END ALREADY
	BTST    #5,D1   CTRL ?
	BEQ     BEEPEND
	BTST    #4,D1   SHIFT (TO BOL)
	BNE.S   LEFT1
	BSR.S   MOVBOL  RETURN TO BOL
	BRA     GETKEY
LEFT1   BSR     CBWD    BACKUP CURSOR
	SUBQ.W  #1,D5
	BRA     GETKEY
*
MOVBOL  TST.W   D5      CURSOR AND POINTER TO BOL
	BEQ     RETX
	BSR     CBWD
	SUBQ.W  #1,D5
	BRA     MOVBOL
*
MOVEOL  CMP.W   D5,D6   CURSOR AND POINTER TO EOL
	BEQ     RETX
	BSR     CFWD
	ADDQ.W  #1,D5
	BRA     MOVEOL
*
RIGHT   CMP.W   D5,D6   RIGHT CURSOR
	BEQ     BEEPEND AT END ALREADY
	BTST    #5,D1   CTRL ?
	BEQ     BEEPEND
	BTST    #4,D1   SHIFT (TO EOL)
	BNE.S   RIGHT1
	BSR     MOVEOL  ADVANCE TO EOL
	BRA     GETKEY
RIGHT1  BSR     CFWD    ADVANCE CURSOR
	ADDQ.W  #1,D5
	BRA     GETKEY
*
CLEARLN BTST    #5,D1   CTRL ?
	BEQ     BEEPEND
	BSR.S   CLRBUF
	BTST    #4,D1   SHIFT (CLR SCR)
	BNE     GETKEY
	BSR     BLANKDCRT       CLEAR DEBUG CRT
	BSR     PROMPT  REPLACE PROMPT
	BRA     INKEY   SET OUTFLAGS THEN GETKEY
*
DELLN   BSR.S   CLRBUF  CLEAR THE LINE
	BRA     GETKEY
*
CLRXIT  RTS
CLRBUF  TST.W   D6
	BEQ.S   CLRXIT
	BSR     MOVBOL
CALLCLREND MOVE.W  D5,D6           SET SIZE
	MOVE.B  #6,-(SP)     CLEAR LINE TO END OF LINE
	BRA     JCALL0  (XCALL0 DOES RTS)
*
RECALL  BTST    #4,D1   SHIFT
	BEQ     ATGL1   ALPHA KEY WORT FOR THE 9816A KEYBOARD
	BSR     CLRBUF
	MOVEA.L RECALLV,A0
	MOVEQ   #0,D1
	MOVE.W  (A0)+,D1     PICK UP LENGTH   JS 4/29/85
	BRA.S   RECALL_B
RECALL_A MOVE.B (A0)+,D0
	BSR     OUTBYTE
RECALL_B DBRA   D1,RECALL_A
	BRA     GETKEY
*
INSERT  CMP.W   D5,D6
	BEQ     BEEPEND AT END
	CMP.W   D6,D7
	BEQ     BEEPEND NO ROOM
	MOVE.W  D5,D4   SAVE CURSOR
	MOVEQ   #' ',D0
INS1    MOVE.B  0(A4,D5),D1
	BSR     OUTBYTE
	MOVE.B  D1,D0   SHIFT CHARACTER
	CMP.W   D5,D6
	BNE     INS1
	BSR     OUTBYTE PUT LAST ONE
INS2    BSR     CBWD    RE POSITION CURSOR
	SUBQ.W  #1,D5
	CMP.W   D5,D4
	BNE     INS2
	BRA     GETKEY
*               DELETE CHARACTER
DELETE  CMP.W   D5,D6
	BEQ     BEEPEND AT END
	MOVE.W  D5,D4   SAVE D5 (CURSOR)
DEL1    MOVE.B  1(A4,D5),D0
	BSR     OUTBYTE
	CMP.W   D5,D6
	BNE     DEL1
	BSR.S   DOBAKSP BLANK LAST CHR
DEL2    CMP.W   D5,D4   RE POSITION CURSOR
	BEQ     GETKEY
	BSR     CBWD
	SUBQ.W  #1,D5
	BRA     DEL2
*
CLREND  CMP.W   D5,D6   CLEAR TO END OF LINE
	BEQ     BEEPEND AT END
	BSR     CALLCLREND
	BRA     GETKEY
*
BACKSP  BSR.S   DOBAKSP
	BRA     GETKEY
DOBAKSP TST.W   D5
	BEQ.S   DBAKXIT
	BSR     CBWD    BACK ONE
	SUBQ.W  #1,D5
	MOVEQ   #' ',D0 BLANK
	BSR     OUTBYTE
	BSR     CBWD    BACK AGAIN
	CMP.W   D5,D6
	BNE.S   DBAK1
	SUBQ.W  #1,D6
DBAK1   SUBQ.W  #1,D5
DBAKXIT RTS
	PAGE
*
READKEYS EQU    *
	MOVEQ   #7,D0   CALL SYSTEM INTERFACE
	BRA.S   SYSCALL TO READ & TRANSLATE A KEY
*
SYSCALL0 EQU    *       CRT INTERFACE CALLS
	MOVE.B  D0,CRTOPCODE
	MOVEQ   #0,D0
	BRA.S   SYSCALL
*
RESTORERUN MOVEQ #1,D0
	BRA.S   SYSCALL9
EXCHANGERUN MOVEQ #0,D0
SYSCALL9 MOVE.B D0,LASTLINEOP
	MOVEQ   #9,D0
*       CALL SYSTEM RESIDENT PROCEDURES
SYSCALL MOVEM.L A0-A6/D1-D7,-(SP)
	MOVEA.L G_DOLLAR,A5     SET GLOBALBASE
	MOVE.W  IORESULT(A5),-(SP)      SAVE AND RESTORE
	MOVE.W  ESCAPECODE(A5),-(SP)    IORESULT AND ESCAPE CODE
	MOVE.L  D0,-(SP)        PUSH THE ARGUMENT
	JSR     SYSBUG_CALLSYSCODE
	MOVE.W  (SP)+,ESCAPECODE(A5)
	MOVE.W  (SP)+,IORESULT(A5)
	MOVEM.L (SP)+,A0-A6/D1-D7
	RTS

DODUMPA MOVEQ   #2,D0
	BRA.S   DODUMP0
DODUMPG MOVEQ   #3,D0
DODUMP0 BTST    #5,REGSR        ALLOW ONLY IF USER MODE
	BNE     BEEPEND
	BSR     SYSCALL
	BRA     GETKEY
*
	TTL     DEBUGGER/SYSTEM COMMON
	PAGE
*------------------------------------------------
*------------------------------------------------
* DEBUGGER COMMON DECLARATIONS
* rdq MAY 81
*------------------------------------------------
*------------------------------------------------
*
TRAP0V  EQU     $FFFFFF94
TRAP15V EQU     $FFFFFF3A
TRACEV  EQU     $FFFFFFD0
HIGHMEM EQU     $FFFFFB00       START ALLOCATION OF FIXED DATA AREA
* SEE ALSO INITBUG, POWERUP AND ASM WHEN CHANGES ARE MADE
* TO THE FOLLOWING DATA STRUCTURE
*------------------------------------------------
*
* THE FOLLOWING DATA MAY COVER THE BOOTER STACK
*
ERR_INFO        EQU     HIGHMEM
FAULT_ADDR      EQU     HIGHMEM         { PARITY ERROR }
*                                       68000
BE_SSW          EQU     HIGHMEM         SPECIAL STATUS WORD
BE_FAULT_ADDR   EQU     BE_SSW+2        FAULT ADDRESS
BE_INSTR        EQU     BE_FAULT_ADDR+4 INSTRUCTION BUFFER
*
*                                       68010
*BE_SSW         2 BYTES                 VECTOR TYPE 1000
*BE_FAULT_ADDR  4 BYTES
BE_PAD1_10      EQU     BE_FAULT_ADDR+4
BE_DATAO_10     EQU     BE_PAD1_10+2    DATA INPUT BUFFER
BE_PAD2_10      EQU     BE_DATAO_10+2
BE_DATAI_10     EQU     BE_PAD2_10+2    DATA OUTPUT BUFFER
BE_PAD3_10      EQU     BE_DATAI_10+2
BE_INSTR_10     EQU     BE_PAD3_10+2    INSTRUCTION BUFFER
BE_MISC_10      EQU     BE_INSTR_10+2   16 WORDS
BE_END_10       EQU     BE_MISC_10+32
*
*                                       68020
ERR_PC          EQU     HIGHMEM         VECTOR TYPE 0010
*ERR_PC         4 BYTES                 VECTOR TYPE 1001
ERR_WRD1        EQU     ERR_PC+4
ERR_WRD2        EQU     ERR_WRD1+2
ERR_EA          EQU     ERR_WRD2+2      EVALUATED ADDRESS
*BE_SSW         4 BYTES                 VECTOR TYPE 1010 (SHORT BUS ERROR)
BE_IPSC         EQU     BE_SSW+4        I PIPE C
BE_IPSB         EQU     BE_IPSC+2       I PIPE B
BE_PAD2_20      EQU     BE_IPSB+2
BE_FAULT_ADDR20 EQU     BE_PAD2_20+4
BE_DATA_20      EQU     BE_FAULT_ADDR20+4     DATA BUFFER
BE_MISCS_20     EQU     BE_DATA_20+4    4 BYTES
BE_END_S_20     EQU     BE_MISCS_20+4
*
*BE_SSW         4 BYTES                 VECTOR TYPE 1011 (LONG BUS ERROR)
*BE_IPSC        2 BYTES
*BE_IPSB        2 BYTES
*BE_PAD         4 BYTES
*BE_FAULT_ADDR  4 BYTES
*BE_DATAO       4 BYTES
BE_PAD3_20      EQU     BE_DATA_20+4            16 BYTES
BE_DATAI_20     EQU     BE_PAD3_20+16
BE_MISC20_20    EQU     BE_DATAI_20+4           40 BYTES
BE_END_L_20     EQU     BE_MISC20_20+44
BE_END          EQU     BE_END_L_20
*-----------------------------------------------------------------------------
EXCP_STATUS     EQU     BE_END
EXCP_PC         EQU     EXCP_STATUS+2
EXCP_VOFFSET    EQU     EXCP_PC+4       VECTOR WORD FOR 680xx
EXCP_LINE       EQU     EXCP_VOFFSET+2  EXCEPTION LINE #
LASTLINE        EQU     EXCP_LINE+4
*                       LASTLINE IS POINTER TO LAST LINE # OR PC
ESCAPEV         EQU     LASTLINE+4      VECTOR TO COMMON ESCAPE HANDLER
PCTEMP          EQU     ESCAPEV+6
SRTEMP          EQU     PCTEMP+4
INITSTACK       EQU     SRTEMP+2        INITIAL USER SP
INITPC          EQU     INITSTACK+4     INITIAL USER PC
INITRECOVER     EQU     INITPC+4        SYSTEM RECOVER
G_DOLLAR        EQU     INITRECOVER+4   SYSTEM GLOBALS
CTL_RESETV      EQU     G_DOLLAR+4      CTL SHIFT PAUSE VECTOR
DEBUGESCAPE     EQU     CTL_RESETV+6    SYS ESCAPE HOOK
BESPTEMP        EQU     DEBUGESCAPE+6   USED IN IGNOREBUS
AONOFF          EQU     BESPTEMP+4      ALPHA ON OFF
GONOFF          EQU     AONOFF+1        GRAPHICS ON OFF
GRAPHICSBASE    EQU     GONOFF+1        GRAPHICS BASE ADDRESS           (rdq)
INITSR          EQU     GRAPHICSBASE+4  STATUS REGISTER FOR STOP
M68KTYPE        EQU     INITSR+2        PROCESSOR TYPE 0=68000 else 680xx
MSYSFLAGS       EQU     M68KTYPE+1      MORE SYSTEM FLAGS bit0 = CACHE
FLTPTHWD        EQU     MSYSFLAGS+1     FLOAT CARD PRESENT
FILLER          EQU     FLTPTHWD+1
		TTL     DEBUGGER GLOBAL SPACE
		PAGE
		ORG     FILLER+1
*
SAVEBUS         DS.B 6  SAVE BUS ERROR FOR DEBUGGER
SAVEESC         DS.B 6  SAVE DEBUG ESCAPE VECTOR
*
LTFLAGS         DS.B 1  TRACE (TRAP0) FLAGS
TFLAGS          DS.B 1  TRACE (TRACE VECTOR) FLAGS
DSTATUS         DS.B 1  DEBUGGER CONTROL FLAGS
DSTATUS2        DS.B 1  DEBUGGER CONTROL FLAGS
*
* LTFLAGS              BIT     INTERPRETATION
*                       0       ACTIVE IMPLANTS
*                       1       WAIT FOR (step,ctrl step,continue)
*                       2       CHECK & DECRIMENT THE COUNT
*                       3       NO_OP
*                       4       CHECK A6 (PNEXT COMMAND)
*                       5       CHECK A6 (P COMMAND)
*                       6       FLASH THE LINE NUMBER
*                       7       QUEUE THE LINE NUMBER
*
* TFLAGS               BIT     INTERPRETATION
*                       0       TD CONTINUE
*                       1       TD & STOP
*                       2       CHECK & DECRIMENT THE COUNT
*                       3       NO_OP
*                       4       NO_OP
*                       5       NO_OP
*                       6       TRAP CHECK
*                       7       QUEUE THE PC
*
* DSTATUS              BIT     INTERPRETATION
*                       0       USER REGISTERS SAVED
*                       1       WAITING FOR CONTINUE TYPE COMMAND
*                       2       GO/BR COMMAND
*                       3       RECOVERY IN PLACE FLAG
*                       4       USER CRT SAVED
*                       5       DONE FLAG
*                       6       CALL DEBUGGER FROM WAIT STATE
*                       7       ERROR FLAG
*
* DSTATUS2             BIT     INTERPRETATION
*                       0       DBUGOBEY TEMPL2 ALSO HAS COMMAND
*                       1       DEBUGGER RUNNING
*                       2       HAVE UP/DOWN ARROW
*                       3       1=UP, 0=DOWN
*                       4       RESET INTERUPT OCCURED
*                       5       DO / DON'T EXECUTE CURRENT COMMAND
*                       6       TRACE MODE FLAG
*                       7       EXECUTE THRU TRAP 15
*
		PAGE
QSTART          DS.B 4  POINTER TO Q START
QEND            DS.B 4  POINTER TO Q END
QLAST           DS.B 4  POINTER TO NEXT ENTRY IN QUEUE
TCOUNT          DS.B 4  TRACE COUNTER
OLDA6           DS.B 4  OLD A6 FOR PCMD
SFA6            DS.B 4  A6 FOR WCMD
IMFIRST         DS.B 4  IMPLANT TABLE START
IMLAST          DS.B 4  IMPLANT TABLE END
IMSIZE          EQU     90                              CHG32
*                       FLAGS DS.W 1 STATUS BITS        CHG32
*                       ADDR  DS.L 1 ADDRESS/LINE NUMBER
*                       UCODE DS.W 1 STORAGE FOR USER CODE WORD
*                             DS.B 1 MAX SIZE OF STRING (80)
*                             DS.B 1 $FF FOR BREAK COUNT
*                                    STRING LENGTH FOR IMPLANTED COMMAND
KDATAP          DS.B 4  POINTER TO K0..K9 DATA AREA
K0DATA          DS.B 6  TYPE DS.B SIZE DS.B VALUE DS.L
K1DATA          DS.B 6
K2DATA          DS.B 6
K3DATA          DS.B 6
K4DATA          DS.B 6
K5DATA          DS.B 6
K6DATA          DS.B 6
K7DATA          DS.B 6
K8DATA          DS.B 6
K9DATA          DS.B 6
*
REGPC           DS.B 4  user register storage during command xqt
REGSR           DS.B 2  STATUS REGISTER
REGUS           DS.B 4  USER MODE STACK POINTER
REGS            EQU     *
DREGS           DS.B 32 REGISTERS D0 .. D7
AREGS           DS.B 28 REGISTERS A0 .. A6
REGA7           DS.B 4
*
CRTOPCODE       DS.B 1  CRT OPCODE FOR SYSCALL0
*                       0=EXCHANGE CRT          6=CLEAR LINE & HOME ON LINE
*                       1=PUTCHAR & ADVANCE CURSOR
*                       2=WRITE CRTPROMPT       7=CURSOR TO LINE START
*                       3=DO CR LF              8=BACKUP CURSOR
*                       4=INIT(CLEAR) RAM       9=ADVANCE CURSOR
*                       5=CLEAR CRT & HOME CURSOR
CRTCHAR         DS.B 1
CRTPADDING1     DS.B 1  UN USED
CRTPROMPTSIZE   DS.B 1
CRTPROMPT       DS.B 4  CRT PROMPT CHARS
CRTPADDING2     DS.B 4  UN USED
LASTLINEOP      DS.B 1  0=EXG RUNLIGHT&TEMPR
*                       1=TEMPR->RUNLIGHT
*                       2='d'->RUNLIGHT
*                       3=CLEAR FLASH & TEMPD->RUNLIGHT
*                       4=CLEAR FLASH
*                       5=SHOW STAT0CHAR
*                       6=DISPLAY LASTLINE
STAT0CHAR       DS.B 1
CRTPADDING3     DS.B 2  UN USED
*
KBDSTATREG      DS.B 1  KEYBOARD STATUS REG
KBDCHAR         DS.B 1  DATA REG/ASCII CHARACTER
KBDDUMMY        DS.B 1  UN USED
KBDTRANSCODE    DS.B 1  TRANSLATION CODE 0=ASCII 1=SPECIAL
*
UEXCPI          DS.B 4  ADDRESS OF ERROR TRAP IMPLANT
SYMBOLHOOK      DS.B 6  SYMBOLTABLE HOOK
ACCUMV          DS.B 6  ACCUMULATOR
DATAV           DS.B 6  DATA VALUE
BASE            DS.B 2  INPUT NUMBER BASE 16 10 8 2
SSIZE           DS.B 4  FORMAT SIZE
RCOUNT          DS.B 4  FORMAT REPEAT COUNT
ETCODES         DS.B 8  ESCAPE CODE LIST
NUMET           DS.B 1  No. OF ESCAPE CODES
SCODE           DS.B 1  FORMAT CODE
DSCODE          DS.B 1  DEFAULT FORMAT CODE
TEMPD           DS.B 1  TEMP FOR DEBUGGER COMMAND RUNLIGHT
TEMPR           DS.B 1  TEMP FOR DEBUGGER/TRAP0 RUNLIGHT
OUTFLAGS        DS.B 1
*              BIT      INTERPRETATION
*               0       CHECK LINE COUNTER
*               1       OUTPUT TO BUFFER
*               2       OUTPUT TO CRT
*
LINECOUNT       DS.W 1  LINECOUNTER FOR DUMPING
RECALLV         DS.B 4  RECALL VECTOR
TEMPL           EQU     RECALLV+4       SCRATCH WORDS
TEMPL2          EQU     TEMPL+4
TEMPL3          EQU     TEMPL2+4
TEMPL4          EQU     TEMPL3+4
SAVEHOOK        EQU     TEMPL4+4        SAVED ESCAPEHOOK FOR RESET      (rdq)
INSTACK         EQU     SAVEHOOK+6      INPUT STACK                     (rdq)
INSTACKB        EQU     INSTACK+4       JWS 6/12/85
INSTACKE        EQU     INSTACKB+4      JWS 6/12/85
INFILLER        EQU     INSTACKE+4      JWS 6/12/85
OPSTACK         EQU     INFILLER+4      JWS 6/12/85      PARSER STACK
OPSTACKE        EQU     OPSTACK+48
DINBUFMAX       EQU     80
RECALLMAX       EQU     DINBUFMAX+2     ADDED WORD FOR LENGTH  JS 4/29/85
UDKSIZE         EQU     DINBUFMAX
DINSIZE         EQU     OPSTACKE        CURRENT SIZE OF INPUT BUFFER
DINBUF          EQU     DINSIZE+1       INPUT BUFFER (80 BYTES)
*                                       SAVE HOOK MUST BE ON AN EVEN ADDRESS
HIBUGRAM        EQU     DINBUF+DINBUFMAX
*
REGA6   EQU     REGA7-4
REGA5   EQU     REGA6-4
*
DATAT   EQU     DATAV   0=EMPTY,1=ADDRESS,2=DECIMAL,3=ALPHA,4=HEX etc
DATAS   EQU     DATAV+1
DATAD   EQU     DATAV+2
*
ACCUMT  EQU     ACCUMV
ACCUMS  EQU     ACCUMV+1
ACCUMD  EQU     ACCUMV+2
*
	END
