;DDT22 FOR RSX11M MAPPED, NO FANCY VIRTUAL MEMORY STUFF.
TCBREG=20
TCBDSP=12
TCBISP=10 ;INITIAL SP IN BSX0
D.MCRO=0 ;ALLOW MACROS
;D.INLU=5
;D.OUTU=6
;DULMOD DEFINED ALLOWS DDT TO RUN IN ONE MODE (E.G. KNL) AND PGM IN ANOTHER
;D.MCRO DEEFINED TURNS ON MACROS
;DEFINE D.INLU AND D.OUTU FOR TERMINAL INPUT,OUTPUT LUNS
;TO GET THIS BEAST TO RUN.
$$RSX=0 ;SOME RSX FORM...
$RSXMM=0 ;I.E. RSX11M MAPPED
	.IF	DF,R$XMDB
$VMEM=0	;FORCE $VMEM DEFINED FOR RSX11M INTERTASK DEBUGGING
	.MCALL	TCBDF$,HDRDF$,PCBDF$
	TCBDF$	
	HDRDF$
	PCBDF$
	.ENDC
	.IF	DF,$$RSX
.IIF NDF,D.INLU, D.INLU=5
.IIF NDF,D.OUTU, D.OUTU=5
	.ENDC
	.IF	EQ,1
;THIS VERSION OF DDT PERMITS .PSECT .SYMS. TO CONTAIN ADDITIONAL SYMBOLS
;TO ADD TO DDT. A DDT SYMBOL IS OF THE FORM
	.RAD50	/SYMNAM/ ;2 WORD RAD50 NAME
	.WORD	SYMADR	 ;1 WORD SYMBOL ADDRESS

THE SYMBOLS MUST BE TERMINATED BY 3 ZERO WORDS, I.E.,
	.WORD	0,0,0	;SYMBOL TABLE TERMINATOR
BUT MAY BE ADDED BY A SEPARATELY ASSEMBLED MODULE WITH .PSECT
DECLARED AS
	.PSECT	.SYMS.,RW,CON
WITH SYMBOLS IN IT. TO ENABLE THE ADDITIONAL SYMBOLS, FILL IN THE
2 WORDS AT "SYMEND" WITH -1'S WITH DDT.
	DDT CONDITIONS
D.KSR	DEFINE ALWAYS; SETS TTY MODE I/O
TTYASR	DEFINE FOR DIRECT DDT CONTROL OF NON-CONSOLE TTY
$$DOS	DEFINE FOR DOS-11 DDT
$$RSX	DEFINE FOR ALL RSX DDT'S (11-M OR 11-D).
$RSXM	DEFINE IF RSX11M ON MACHINE WITHOUT RTT
$RSXMM	DEFINE IF RSX11M ON MACHINE WITH RTT
XTCOM	DEFINE WHERE DDT IS TO OPERATE DIRECTLY ON TTY HARDWARE.
	(OTHERWISE USES LUNS 5 AND 6, EVENT FLAGS 22 AND 23.)
$VMEM	USE PSEUDO MAP FOR MEMORY MAPPED DDT. ALL ADDRESSES AND INSTRUCTIONS
	ARE IN A PSEUDO MAP WITH APR'S CONTROLLED BY WORDS "PAR0" THROUGH
	"PAR7", WHICH ARE INITIALIZED TO VALUES OF DDT STARTUP.
DULMOD	ALLOWS DDT TO RUN IN KERNEL MODE WITH USER MODE PROGRAMS IF DEFINED.
	(NOT FOR RSX VERSIONS).
D.MCRO	IF DEFINED, ENABLES MACROS TO WORK IN DDT (ENTER MACROS WITH UF
	CONSTRUCT; USE VIA UC CONSTRUCT.)
D.INLU AND D.OUTU ARE LUNS FOR RSX TERMINAL I/O. THEY MAY BE THE SAME IF
	DESIRED, BUT THIS WILL MESS UP SEARCH OPERATIONS IN RSX11D/IAS
	VERSIONS WITHOUT XTCOM. RSX11M V3.1 AND EARLIER TT HANDLER MESSES
	SEARCHES ANYHOW. AN -11M CONDITIONAL (V3.2) ALLOWS THIS CODE
	TO LOOK MORE LIKE -11D BUT RSX11D-ONLY CALLS HAVE BEEN REPLACED
	BY COMPATIBLE ONES SO THE RSX11D VERSION MAY BE USED WITH RSX11M
	V3.2 AND LATER.
$DDBSX	ALLOWS USE OF MAP PRESETS FOR BSX STANDALONE SYSTEM
$VPAT	ALLOWS DDT TO PATCH A FILE ON A PATCH LUN (SEE THE CODE)
	D.PLUN (EV IS D.PEV, BOTH GLOBAL). IT ASSUMES IT PATCHES
	A SYSTEM IMAGE ON A CONTIGUOUS FILE STARTING AT  A BASE BLOCK
	AND CONVERTS ADDRESSES TO BLOCKS+OFFSETS TO DO SO. DDT HAS
	NO OPEN CODE HOWEVER, SO THIS MUST BE TO A FOREIGN-MOUNTED
	(OR UNMOUNTED IN RSX11M) DEVICE.
$FORM$	ALLOWS FORMATION INTERRUPT VECTOR (IN STANDALONE VERSIONS) TO
	ACT LIKE A PSEUDO SINGLE-INSTRUCTION BREAKPOINT AND JUMPS
	TO D.BRK AFTER SETTING SINGLE INSTRUCTION MODE ON.
	D.FFPN IS INTERRUPT VECTOR LOCATION; DDT DOES NOT INITIALIZE IT.
	.ENDC
	.IIF	DF,$FORM$, .GLOBL D.FFPN
;$$RSX=0	;RSX11D VERSION
D.KSR=0;ASR33 DEFAULT NOW
	.IF DF,$$DOS
 .PRINT ;DDT-11 FOR DOS-11 SYSTEM
	.ENDC
	.IF DF,$$RSX
	.IF DF,$VMEM
.PRINT ;DDT-11 ASSEMBLED FOR VIRTUAL APR MAPPING
.PRINT ; (MUST RUN ON A CPU WITH MAPPING ON)
 .IIF DF,R$XMDB, .PRINT ;DDT ALLOWS RSX11M INTERTASK EXAM/MODS
	.ENDC
	MMM11=0
	.IIF DF,$RSXM,MMM11=MMM11+1
	.IIF DF,$RSXMM,MMM11=MMM11+2
	.IF EQ,MMM11
 .IIF DF,R$XMDB, .ERROR ;RSX11M TASK DEBUG BAD FOR RSX11D/IAS!
 .PRINT ;DDT-11 FOR RSX-11D ON 11/45 CPU
	.ENDC
	.IF EQ,<MMM11-1>
 .PRINT ;DDT-11 FOR RSX11M ON 11/05 OR 11/20 CPU
 .IIF DF,$VMEM, .ERROR ;MAPPING DDT ILLEGAL IN UNMAPPED RSX11M
 .IIF DF, R$XMDB, .ERROR ;RSX11M DEBUG ASSUMES MAPPED!
	.ENDC
	.IF GT,<MMM11-1>
 .PRINT ;DDT-11 FOR MAPPED RSX11M (11/40 CPU ASSUMED)
	.ENDC
	.IF DF,XTCOM
 .PRINT ;HARDWARE CONTROLLED DIRECTLY BY DDT
	.IFF
 .PRINT ;CONSOLE I/O VIA LUNS 5 AND 6, EVENT FLAGS 22. , 23.
.PRINT D.INLU ;INPUT LUN DISPLAYED
.PRINT D.OUTU ;OUTPUT LUN DISPLAYED
	.ENDC
	.ENDC
UPAR0=177640
UPDR0=177600	;USER PAR,PDR
KPAR0=172340	;KERNEL PAR 0
; THIS IS DDT: DYNAMIC DEBUGGING TECHNIQUE FOR A PDP-11.
; IT RESEMBLES DDT FOR A PDP-10 IN AS MANY WAYS AS POSSIBLE
; AND FALLS SHORT ONLY SLIGHTLY DUE TO THE VARIETY OF PDP-11
; CONFIGURATIONS AVAILABLE.  IT WAS MODIFIED DRASTICALLY
; FROM DEC'S ODT (JUST TRY TO FIND ANY ODT CODE!)
;
; AUTHOR: STEVEN M. RUBIN (SR12@CMU)
;MODIFIED 10/1975 BY G. C. EVERHART, MIT.
;
;
; THIS VERSION MAY BE CONDITIONED FOR USE WITH DOS-11 BY DEFINING
; "$$DOS" AT ASSEMBLY TIME OR FOR RSX11-D BY DEFINING "$$RSX".
; THE DOS VERSION IS NOT VERY DIFFERENT FROM THE USUAL DDT.
; THE RSX VERSION IS INTENDED TO REPLACE ODT HOWEVER, AND IT
; HAS TO USE THE FOLLOWING KLUDGES TO WORK AT ALL:
; 1. IT GAINS CONTROL BY SETTING A TABLE OF TRAPS AND LETTING
;    RSX PASS TASK TRAPS TO IT AS ODT DOES.
; 2. IT DOES A SIMPLE QIO$ TO TI: TO DO ITS CONSOLE I/O
;    (IMPLEMENTED AS A 1-FOR-1 REPLACEMENT OF THE LOW-LEVEL
;    INTERNAL CALL TO GRAB CHARACTERS OFF THE CONSOLE), AND
;    HANDLES CONSOLE OUTPUT IN LIKE FASHION. THE INTERNAL
;    ASSUMPTION IS THAT LUN 6 IS RESERVED FOR TI:, THOUGH THIS
;    WILL BE MODIFIABLE FROM SOURCES WHERE DESIRED. IT IS
;    INTERNALLY EXPECTED THIS IS DONE AT TKB TIME.
;    (IO.RVB AND IO.WVB WILL BE USED FOR I/O IN CASE SOME IDIOT
;    HAS LUN 6 ASSIGNED TO A DISK!)
; 3. APPROPRIATE RSX CALLS WILL BE MADE TO FIND OUT TASK STARTING
;    ADDRESS SO A SIMPLE <ALTMODE>G WILL START THE TASK.
;    EXIT WILL BE DONE VIA ANOTHER G COMMAND VIZ:
;    DDTXIT<ALTMODE>G
;    WHICH WILL SIMPLY EXECUTE AN EXIT$S AND SCRAM. (THE DOS
;    VERSION CAN EXIT VIA "$$DOS<ALTMODE>G").
	.CSECT	DDTRSX
	.GLOBL	DDT,JOBSA,D.SYMT

; THE NEXT THREE DEFINES DESCRIBE THE MAIN OUTPUT DEVICE THAT
; DDT WILL USE.  ONLY 1 MAY BE DEFINED AND THE REST MUST BE
; COMMENTED OUT.
;D.GDP	=	1 		; TTY IS GRAPHICS DISPLAY PROCESSOR
;D.KSR	=	1 		; TTY IS KSR-33
;D.GT40	=	1 		; TTY IS DEC GT40

	.MCALL	DSAR$S,ENAR$S
	D.OKTTY=-1
	.IF DF,D.GDP
	 D.OKTTY=D.OKTTY+1
	 .TITLE	D.GDP
.PRINT	 ; *****DDT for a GDP*****
D.RDB	 =	165202		; READER DATA BUFFER
D.RCSR	 =	165200		; READER STATUS REGISTER
D.PRIO	 =	0		; RUN AT PRIORITY ZERO
	.ENDC
	.IF DF,D.GT40
	 D.OKTTY=D.OKTTY+1
	 .TITLE	D.GT40
.PRINT	 ; *****DDT for a GT40*****
D.RCSR	 =	177560		; READER STATUS REGISTER
D.RDB	 =	177562		; READER DATA BUFFER
D.PRIO	 =	200		; RUN AT PRIORITY FOUR
	.ENDC
	.IF DF,D.KSR
	 D.OKTTY=D.OKTTY+1
	 .TITLE	D.KSR
	.IF	NDF,TTYASR	;IF NOT NONSTD TTY DEVICE
.PRINT	 ; *****DDT for a TTY*****
D.RCSR	 =	177560		; READER STATUS REGISTER
D.RDB	 =	177562		; READER DATA BUFFER
D.TCSR	 =	177564		; PRINTER STATUS REGISTER
D.TDB	 =	177566		; PRINTER DATA BUFFER
	.IF	NDF,$$RSX	;DOS OR S/A VERSIONS
D.PRIO	 =	340		; RUN AT PRIORITY SEVEN
	.IFF			;$$RSX
D.PRIO	=	0		;RUN AT PRIO 0 IN RSX11D
	.ENDC			;$$RSX
	.IFF			;TTYASR
D.RCSR=175410	;RDR STATUS. DEFINE FOR YOUR TERMINAL.
D.RDB=D.RCSR+2
D.TCSR=D.RDB+2
D.TDB=D.TCSR+2
D.PRIO=340;PRI7 DEFAULT
.PRINT	;****DDT FOR A NONSTANDARD TERMINAL****(TTY-LIKE!)**
	.ENDC
	.ENDC

.IIF NE,D.OKTTY,.ERROR	; INVALID OUTPUT DEVICE FOR DDT

D.BKP	=	8.		; NUMBER OF BREAKPOINTS
D.SYML	=	10.		; MAX NUMBER CHARS IN A SYMBOL
R0	=	%0
R1	=	%1
R2	=	%2
R3	=	%3
R4	=	%4
R5	=	%5
SP	=	%6
PC	=	%7
PS	=	177776		; PROCESSOR STATUS

.IF NE,0

	DDT/11 - Dynamic Debugging Technique on the PDP-11

Each  command in DDT/11  is identical to the  PDP-10 version whenever
possible.   In some cases,  DDT/10 commands have been  omitted in the
interest  of saving core and  making good sense.  The  following is a
list of the DDT/11 commands:
 n/	Open word n.  Type contents in current mode
  /	Open word pointed to by last typed value
 n<CR>	Modify currently open word to be n.  Close word.
 n<LF>	Modify, close, open next word
 n^	Modify, close, open previous word
 n<TAB>	Modify, close, open word pointed to by last typed address
 n\	Modify, close, examine word n
  \	Examine word pointed to by last typed value
n?	Type word n in RAD50 format (forces even address)
@	Types out location absolutely addressed by the open
	location (the same convention as <tab>, and the
	same as the DEC ODT convention for @ sign.
  $S	Change current mode to instruction type out
  $A	Addresses will be typed as absolute numbers
  $R	Addresses will be typed relative to symbols
  $C	Change current mode to numeric type out
 $nR	Change current radix for $C to n (n read in decimal)
  $T	Change current mode to ASCII text output
 $5T	Change current mode to Radix-50 text output
 $nO	Change current mode to n bit byte typeout
  $H	Change to halfword (byte) mode (reset by $5T and $S)
	Note that the initial modes are $S and $8R.  These can be
	temporarily changed by the above commands and will return
	to the permanent setting by a carriage return.  The settings
	can be permanently changed by using two altmodes before the
	mode setting command ($$T sets permanent ASCII mode)
 n[	Open location n, type as a numeric
 n]	Open location n, type as instruction
 n!	Open location n, do not type value
  ;	Retype currently open word
  =	Retype currently open word as number
 n=	Type value of n as a number
  _	Retype currently open word as instruction
 $_	Retype currently open word symbolically
  i$X	Execute instruction i (cannot execute branches or jumps)
  n$G	Start executing program at location n.  Default is to
	start executing at address in JOBSA (start of program)
  v$nB	Set breakpoint n at address v (n from 1 to 8 or can be omitted)
a,v$nB	Same as above but open address a at breakpoint
	If two altmodes are used, automatic proceding is enabled.  The
	breakpoint will cause the message to be typed and the program
	resumed.  If you type a character, the automatic proceding will stop.
  0$nB	Remove breakpoint n
   $B	Remove all breakpoints
   $P	Procede from breakpoint
  n$P	Procede from breakpoint n times (without halting)
	If two altmodes are used, the breakpoint will be proceded from automatically
  n$UW	Set offset limit to n (used when typing addresses)
   $1UT	Turn on single stepping (break at each instruction)
  a$1UT	Turn on single stepping and open location a at each break
	If two altmodes are used, the single stepping will be done automatically
   $UT	Turn off single stepping
  a:	Make current location have symbolic name a
v<a:	Make symbolic name a have value v
  a$$K	Delete symbolic name a
  a$K	Delete symbolic name a from typeout only
   $D	Perform an $K on the last symbol coloned (:)
l<u$$Z	Zero memory from l to u ;Location D.FILV Contains number filled in
  n$M	Set mask for searches (below) to n
l<u>s$W	Search core from l to u for word s.
l<u>s$E	Search core from l to u for effective address s.
l<u>s$N	Search core from l to u for word not equal to s.
 <CALL>	Soft restart at address 1004 (Graphics DDT only)
   $UG	Turn on user display when in DDT (Graphics DDT only)
$UM	Turn on use of virtual map. Variables PAR0 through PAR7 will be used
	as APR's for all number entry or displays in any format.
$UR	Turn virtual mapping back off. Mapping of APR's will be as it
	was when DDT was started.
$UU	Turn on virtual mapping and copy current User APR's into maps
	used by DDT. All addressing will be done via those virtual
	APR's.
$UK	Turn on virtual mapping and copy current Kernel APR's into
	maps used by DDT. All mapping will be done via these APR's.
$UV	Use standard DDT virtual mapping (no pseudo maps). This differs from
	the other commands in that no APR's are used; the others use the
	APR's that DDT is intialized with, which may be inadequate if the
	task is checkpointed and moved. DDT initializes in this mode and
	can, in it, access whatever a normal DDT can access (and conversely).
n<addr$UB  Set APR number n (0 to 7) to value at location "addr". This
	value will be used for virtual mapping if enabled and allows
	symbolic setting of any APR. Note that the PAR number is a number
	and not an address, and the "addr" parameter is the location
	containing the value to place in the pseudo-PAR used for the
	DDT mapping.
addr<data$UP  Evaluates addr in virtual space using virtual map and
	inserts the word "data" at that address on bulk storage
	in the appropriate block. The program in core is assumed to be
	stored on a contiguous file on a bulk storage device with
	its zeroth block at (PBASEL,PBASEH) (initially 1,0) on the
	logical unit D.PLUN and DDT uses D.PEF for its event flag
	for the QIOW$. If the address is odd, only a byte will be
	patched. No size checking is done by DDT. This function and
	the $UH function are enabled by conditional assembly parameter
	$VPAT. Data may be an expression.
addr<data$UH  Evaluates addr in virtual space using the virtual map
	and inserts the byte "data" there on bulk storage, as $UP.
	Note that both $UP and $UH require rather strict format
	correctness. The virtual map is used by these functions even
	if it is not in use for actual memory examination; this allows
	DDT to convert a virtual address into a block number relative
	to the start of a memory image with 256 word blocks.
par<data$UD Set par named to value data. This is like the $UB form
	except that the data is data, not an address.
	Note that the $UD mode retrieves symbols from DDT space.
addr$UA	Treat addr as the address in the current DDT space of
	a BSX Task Control Block (i.e., in BX.TBL) and load from it
	all registers and APRs of that BSX task as the new DDT
	user registers and space mappings. This option is enabled
	only for the assembly conditional $DDBSX defined, which should
	be the case only for the stand-alone version of BSX.
$UE	Turn on echoing of macros. Macros are stored in DDT space
	at address D.KBBF as ASCII text using the standard DDT
	text storage syntax, up to 80 characters. Macros should
	end with negative bytes of data or the $US command to return
	to standard input, though they should eventually return
	with possible junk commands if this is omitted.
$UN	No echo of macros at the console.
$UC	Use core for input. Enables macros at D.KBBF to be read and
	executed as though they came from the console.
$US	Use Standard input device (console) for command input.
$UF<delim>text<delim> Fill in text of macro (up to 80 char) with any
	characters. Text is always read from console and the command
	terminates, filling in a legal end sentinel, after buffer
	full or recognition of the second delimiter character, which may
	be any ASCII character not in the text string.

	These macros are enabled by the D.MCRO assembly conditional
	defined. The conditional DULMOD allows a DDT that can run
	in one space and debug programs in the other (another...).

		NOTE
	DDT mapping does not affect program execution; only displays
	are affected. Modifications to memory will use the current
	APR's, but breakpoints will not be put into arbitrary memory
	locations.
		The $UM, $UR, $UU and $UK commands only exist where the
	assembly conditional $VMEM was defined and DDT is linked to
	a common in the I/O page at APR 7.
$UL<delim>TSKNAM<delim>  Read a task name (6 characters maximum) from
	the console (or macro) and locate its header and mapping
	information inside RSX11M. Then compute the APR mappings for
	that task and move them into the locations used by DDT for
	its pseudo mapping. This option requires that R$XMDB be defined
	and that DDT be assembled with $VMEM defined and with the
	appropriate RSX macros (normally [1,1]EXEMC) available for
	header, TCB, and window block offset definitions. Also, the
	task using such a version of DDT must have access to the I/O
	page via APR 7. This option only makes sense on fixed tasks
	or in systems without checkpointing, but may be useful in
	those systems for examining or modifying other tasks.

Note that numbers can be as any combination of the following:

	<Octal number>
	<Decimal number> .
	<Program symbol>
	" <Delimeter> <Two ASCII Characters> <Delimeter>
	"$ <Delimeter> <Three Radix-50 Characters> <Delimeter>
	<Instruction>

The operators +  (addition), - (subtraction), * (multiplication), and
' (division) are evaluated  from left to right unless parenthesis are
included.  The space is treated like a plus except after instructions
when  it is merely a  separator.   All input is  accepted in lower or
upper case and is folded (except for text.)

If you  are not  in DDT,  you can  re-enter with  a Meta-BREAK  on  a
graphics or  a restart  at DDT  (location typed  out initially).   In
addition to program symbols, the following are also defined for you:

 R0-R5	are the user registers.  R1/ would open register 1.
 SP	is the user's stack pointer
 PC	is the user's program counter
 $I	is the user status
 $2I	is the status of DDT
 $M	is the mask for searches
 $Q	is the value at the current address
 $V	is the value at the current address with the bytes switched
 $nB	is the address of breakpoint n
 JOBSA	is the starting address of your program.
RSXEXT IS RSX-11-M or -D EXIT$S call
$$DOS is DOS-11 EXIT call
DDTODD is DDT odd addr SST table entry (RSX DDT only)
DDTIOT is DDT IOT table entry
DDTTRP is TRAP entry
DDTRES is RESERVED INST entry
DDTEMT is non-RSX EMT entry
D.FILV is number filled in by $Z command (initially 0)
(TASK NAME) is start address of task
BYE is equivalent to RSXEXT in RSX DDT
DDTBGN is the start address of DDT itself
PAR0 Is the current virtual memory APR 0. (PDR is always 4K R/W)
PAR1	is the current virtual APR 1
PAR2	is current APR 2
PAR3	is current APR 3
PAR4	is current APR 4 (all these are in virtual ($UM) space
PAR5	is current APR 5
PAR6	is current APR 6
PAR7	is current APR 7 (must be I/O page for this to work)
UP TO 160. USER SYMBOLS MAY BE ENTERED.
  .	represents the current location.  Thus .$1B puts
	breakpoint 1 at the currently opened location.

When  your program is  executing, the following  unexpected traps may
occur.  NXM! is  caused when  your  program requests  a  non-existant
memory or does a word operation on an odd address.  ILG! is caused by
an  illegal instruction.  BPT! is  caused by an entry  to DDT that is
unexpected (i.e. executing the BPT instruction or setting the T-bit).



	To include DDT with your task, just include on the input side
  of the taskbuild. thus, whn your normal TKB would be
  TKB MYFILE,MYFILE=MYFILE
  make it look like this:
  TKB MYFILE,MYFILE=MYFILE,[1,1]DDT/DA
    DDT will gain control at startup. To start your program, type
  <ESC>G where you type the ESC key, not the 5 characters "<ESC>".
  To exit prematurely, type  BYE<ESC>G (again the ESC key).
  Note that D.INLU and D.OUTU are the console input and output LUNs
  and that these must be assigned to TI: for DDT to work properly.
.ENDC

; MAIN LOOP OF DDT

DDT:	BR	D.DDT3		; HARD ENTRY ADDRESS TO DDT
	.IF	NDF,$$RSX
		;		;SAVE STATUS ONLY IF NOT MAPPED.
	MOV	@#PS,D.USTA	; GET USER'S STATUS
	.ENDC
	MOV	(SP)+,D.UR7	; SOFT ENTRY ASSUMES STACK HAS RETURN ADDRESS
	JSR	PC,D.SAVE	; SAVE REGISTERS
	BR	D.DDT2		; FINISH INITIALIZATION
D.DDT3:
	.IF	DF,$VMEM	;FOR VIRTUAL DDT ONLY...
DD.SVV:	MOV	R1,-(SP)	;SAVE A REG
	MOV	#UPAR0,R1	;SET UP TO SAVE INITIAL MAP
	MOV	R2,-(SP)	;
	MOV	#VKPAR0,R2	;ADDR OF SAVE AREAS FOR PARS
	MOV	R3,-(SP)
	MOV	#10,R3		;NUMBER OF PARS
1$:	MOV	(R1),<ORGPAR-VKPAR0>(R2) ;SAVE APR LISTS WITH INITIAL MAP
	MOV	(R1)+,(R2)+	;TWICE. BOTH MAPPINGS INITIALLY ALIKE.
	SOB	R3,1$		;DO ALL
	MOV	(SP)+,R3
	MOV	(SP)+,R2	;RESTORE REGS
	MOV	(SP)+,R1
	.ENDC
	.IF	NDF,$$RSX
	MOV	@#PS,D.USTA	; SAVE USER'S STATUS
	.ENDC
	.IF	DF,$$RSX	;RSX GET START ADDRESS JUNK
	MOV	R0,JOBSA	;TKB STASHES START ADDR IN ENTRY R0
	MOV	R0,NMH+2
	MOV	R2,NMH
	MOV	R1,NAMLO	;R1 HAS 1ST HALF OF TASK NAME
	MOV	R2,NAMHI	;...AND R2 2ND HALF
	.IF	NDF,XTCOM
	.MCALL	QIOW$S
;ATTACH TERMINAL TO PREVENT MCR NONSENSE IN -11M...
	QIOW$S	#IO.ATT,#D.INLU,#26.,,#III.II
	BR	III.IJ
III.II:	.WORD	0,0;I/O STAT
III.IJ:
	.ENDC
	MOV	#000,D.USTA	;SET USER STATUS, PRI 0
	.ENDC
		;END SPECIAL RSX INITIALIZATION
	.IF	DF,$$DOS	;DOS VERSION ONLY
	MOV	@#40,-(SP)	;GET System Vector Table address
	ADD	#22,@SP		;POINT TO PGM START ADDR
	MOV	@(SP)+,JOBSA	;SAVE IN JOBSA
	.ENDC
	.IF	NDF,$$RSX	;FOR RSX, WE USE SST VECTORS, NOT THIS
	MOV	#D.NOSP,@#4	; SET FOR INVALID STACK INTERRUPT
	MOV	#340,@#6	; SET HIGH STATUS
	MOV	#D.ILGT,@#10	; SET FOR ILLEGAL INSTRUCTIONS
	MOV	#340,@#12	; SET HIGH STATUS
	.ENDC
	.IF	DF,$$RSX
	.MCALL	SVDB$S,QIO$S,WTSE$S	;I/O TO TI: AND SST DEFINING
	SVDB$S	#DDTODD,#11	;SET UP SST'S
	.ENDC
	MOV	SP,D.XXX	; SAVE HIS STACK
	MOV	#D.STK,SP	; USE OURS TEMPORARILY
	TST	@D.XXX		; DOES HIS STACK EXIST?
	MOV	D.XXX,SP	; GIVE HIM BACK HIS STACK
D.FIX: .IIF NDF,$$RSX,	MOV	#D.NXMT,@#4	; RESTORE FOR EXTERNAL NXMS
	MOV	JOBSA,D.UR7	; ASSUME HE CAME FROM STARTING ADDRESS
	JSR	PC,D.SAVE	; SAVE REGISTERS
	.IF	DF,D.GDP
	 MOV	#DDT+2,R0	; ADDRESS OF RESTART FOR MONITOR
	 TRAP	133		; DDTCAL
	.ENDC
	CLRB	D.NOTY		; ALLOW TYPEOUT
	MOV	#D.GRET,R4	; TELL YOU ARE HERE
	MOV	#D.GRND,R3	; END OF MESSAGE
	JSR	PC,D.STYP	; TYPE MESSAGE
	.IF	NDF,D.GDP
	 MOV	#DDT,R0		; ADDRESS OF RESTART
	 JSR	PC,D.TYPN	; TYPE RESTART ADDRESS
	.ENDC
D.DDT2:	JSR	PC,D.CRLF	; TYPE CARRIAGE RETURN-LINE FEED
	CLR	D.SD.T		; NOT IN SINGLE STEP OR TRACE
	MOVB	#-1,D.P		; DISALLOW PROCEDE
	BR	D.DCD0		; GET INTO MAIN LOOP
D.ERR:	MOV	#' ,R0		; TYPE A SPACE
	.IIF DF,D.MCRO, CLR D.CHSW ;USE CONSOLE INPUT IF ERROR.
	JSR	PC,D.TYPE
	MOV	#'?,R0		; ? TO BE TYPED
D.ERRO:	JSR	PC,D.TYPE	; TYPE CHARACTER
D.DCD:	JSR	PC,D.TTAB	; TYPE TAB
D.DCD0:	CLR	D.COMA		; NO , PARAMETER.  RETURN FROM <CR>HCTSAR>
	CLRB	D.FWAF		; NO < PARAMETER
	.IF	NDF,$$RSX
	MOV	D.DSTA,@#PS	; SET DDT STATUS
	.ENDC
	MOV	#NOP,D.PARS	; FILL $X AREA WITH NOPS
	MOV	#NOP,D.PARS+2	;  IN CASE OF SHORT INSTRUCTIONS
	CLR	D.PARO		; NO OFFSET
	CLR	D.PARO+2	; NO OFFSET
D.DCD2:	CLR	D.SVR2		; RETURN FROM ,<
	CLR	D.SVR4		; D.SVR4 IS A SAVE REGISTER FOR R4
	CLR	D.OFST		; TALLY
	CLR	R2		; NUMBER TYPED FLAG
D.DCD3:	CLRB	D.ALTF		; RETURN FROM B"MVQI
D.DCD1:	CLRB	D.LEVL		; RETURN FROM $
	CLRB	D.INPA		; NOT IN INSTRUCTION TYPE-IN
	MOV	D.CAD,D.CADC	; KEEP A CURRENT COPY FOR INST TYPE-IN
	MOV	#D.STK,SP	; RESET STACK POINTER
	JSR	PC,D.EXPR	; GET EXPRESSION (R2,R4,R1)
	TST	R2		; NEED OPERANDS FOR INSTRUCTION?
	BPL	D.DCD4		; BRANCH IF NOT
	JSR	PC,D.GETI	; GET OPERANDS
D.DCD4:	TST	R2		; ANY VALUE TYPED?
	BEQ	D.DCD5		; BRANCH IF NOT
	MOV	R4,D.LASV	; STORE LAST TYPED VALUE
	MOV	R4,D.LASW	; STORE LAST TYPED WORD TOO
D.DCD5:	ASL	R1		; MULTIPLY BY TWO
	JSR	PC,@D.LGDR(R1)	; GO TO PROPER ROUTINE
	BR	D.DCD		; GET NEXT COMMAND
D.NOSP:	MOV	#D.STK,SP	; SET OWN STACK PERMANENTLY FOR USER
	BR	D.FIX		; RETURN

; ROUTINE TO GET A PRIMARY INTO R1 (COMMAND DECODER)

D.PRIM:				; PRIMARY READING SUBROUTINE
	CLR	R4		; R4 CONTAINS THE CONVERTED OCTAL
	CLR	D.DECN		; CLEAR DECIMAL NUMBER
	CLRB	D.USED		; CLEAR USE-DECIMAL NUMBER INDICATOR
	JSR	PC,D.CLSM	; CLEAR SYMBOL
D.PRI1:	JSR	PC,D.GET	; GET A CHAR, RETURN IN R0
	CMP	#'0,R0		; COMPARE WITH ASCII 0
	BHI	D.PRI3		; CHECK LEGALITY IF NON-NUMERIC
	CMP	#'9,R0		; COMPARE WITH ASCII 9
	BLO	D.PRI3		; CHECK LEGALITY IF NOT OCTAL
	CMP	D.POS,#D.SYM	; IN THE MIDDLE OF A SYMBOL?
	BNE	D.PRI6		; YES, PUT DIGIT IN SYMBOL
	SUB	#'0,R0		; CONVERT TO BCD
	ASL	R4		; MAKE ROOM
	ASL	R4		;  IN
	ASL	R4		;    R4
	ADD	R0,R4		; PACK THREE BITS IN R4
	MOV	D.DECN,R1	; GET DECIMAL NUMBER
	ASL	R1		; MULTIPLY BY 2
	ADD	R1,R0		; ADD 2X
	ASL	R1		; MULTIPLY BY 4
	ASL	R1		; MULTIPLY BY 8
	ADD	R0,R1		; ADD IN NEW DIGIT
	MOV	R1,D.DECN	; STORE IN DECIMAL NUMBER
	INC	R2		; R2 HAS NUMERIC FLAG
	BR	D.PRI1		;   AND TRY AGAIN
D.PRI2:	MOV	#'U,R0		; UNDEFINED MESSAGE
	.IIF DF,D.MCRO, CLR D.CHSW ;USE CONSOLE INPUT IF ERROR.
	BR	D.ERRO		; ERROR OUTPUT
D.PRI3:	CMPB	R0,#'.		; DOT FOUND?
	BEQ	D.PRI7		; BRANCH IF SO
	CLR	R1		; BASE OF CHARACTER TABLE
D.PRI4:	CMPB	D.LGCH(R1),R0	; MATCH?
	BEQ	D.PRI5		; YES
	INC	R1		; NEXT CHARACTER
	CMP	R1,#D.CLGT	; ANY MORE?
	BLT	D.PRI4		; LOOP IF SO
D.PRI6:	TST	R4		; NUMBER ALREADY?
	BNE	D.ERR		; ERROR TO START SYMBOL
	JSR	PC,D.PTSM	; PUT SYMBOL IN D.SYM
	BR	D.PRI1		; DECODE MORE CHARACTERS
D.PRI7:	TST	R4		; NUMBER BEING TYPED?
	BEQ	D.PRI6		; BRANCH IF NOT
	INCB	D.USED		; IT IS, MAKE IT DECIMAL
	BR	D.PRI1		; CONTINUE SCANNING
D.PRI5:	TSTB	D.ALTF		; ALTMODE FOUND?
	BNE	D.PRI8		; YES, DO IT
	CMP	R1,#D.LETR	; IS IT A LETTER?
	BGE	D.PRI6		; YES
D.PRI8:	CMPB	#' ,D.SYM	; ANY SYMBOL?
	BEQ	D.PRIB		; NO, RETURN
	CMP	#". ,D.SYM	; IS SYMBOL A DOT?
	BNE	D.PRI9		; BRANCH IF NOT
	MOV	D.DOT,R4	; USE VALUE OF D.DOT
	INC	R2		; NOTE THAT IT IS A NUMBER
	BR	D.PRIB		; DO THE REST
D.PRI9:	MOV	#D.SYM,R0	; ADDRESS OF SYMBOL
	JSR	PC,D.GTAD	; GET ADDRESS
	CMP	R1,#D.COLO	; COLON?
	BEQ	D.PRIC		; RETURN IF SO
	TST	R0		; CHECK SYMBOL ADDRESS
	BEQ	D.PRID		; BRANCH IF NOT AN ADDRESS
	MOV	(R0),R4		; GET SYMBOL VALUE
D.PRIA:	INC	R2		; MARK R2 AS A NUMBER
D.PRIB:	TSTB	D.USED		; USE DECIMAL NUMBER?
	BEQ	D.PRIC		; BRANCH IF NOT
	MOV	D.DECN,R4	; USE DECIMAL NUMBER
D.PRIC:	RTS	PC		; RETURN
D.PRID:	MOV	#D.COUS,R0	; ADDRESS OF OFFSET TABLE
D.PRIE:	CMP	R0,#D.ECNT	; END OF LIST?
	BHIS	D.PRI2		; YES, LOSE
	MOV	#D.SYM,R5	; SCAN THE SYMBOL
	MOV	(R0)+,R3	; GET OFFSET OF CHARACTERS
	BIC	#177400,R3	; TURN OFF EXTRA CRUFT
	CMPB	R3,(R0)		; NULL STRING?
	BEQ	D.PRIE		; YES, IGNORE IT
D.PRIF:	CMPB	D.STRS(R3),(R5)+; IS IT A CHARACTER MATCH?
	BNE	D.PRIE		; BRANCH IF NOT
	INC	R3		; NEXT CHARACTER
	CMPB	R3,(R0)		; END OF STRING?
	BNE	D.PRIF		; BRANCH IF NOT
	MOV	D.TOPS-D.COUS-2(R0),R4	;GET THE INSTRUCTION-1
	MOVB	-1(R0),R3	; GET LEGALITY BYTE
	CMPB	R3,#10		; IS IT A CONDITION CODE SET/CLEAR?
	BEQ	D.PRIK		; MAY BE
	INC	R4		; FIX INSTRUCTION
D.PRIG:	CMPB	#' ,(R5)	; BLANK AT END OF SYMBOL?
	BNE	D.PRII		; NO, HOW ABOUT "B"?
	BIC	#177774,R3	; STRIP TO MACHINE TYPE
	CMPB	R3,D.MACH	; VALID ON THIS MACHINE?
	BGT	D.PRI2		; UNDEFINED SYMBOL
D.PRIH:	MOVB	-(R0),R3	; RE-FETCH LEGALITY BYTE
	CMP	R1,#D.SPAC	; IS INSTRUCTION TERMINATED WITH SPACE?
	BNE	D.PRIA		; DON'T GET OPERANDS IF NOT
	MOV	#-2,R2		; MARK INSTRUCTION
	BR	D.PRIA		; ALL DONE
D.PRII:	CMPB	#'B,(R5)+	; BYTE INSTRUCTION MUST TERMINATE WITH "B"
	BNE	D.PRIE		; NOT AN INSTRUCTION
	TSTB	R3		; TEST LEGALITY BYTE
	BPL	D.PRIE		; NO
	ADD	#100000,R4	; ADD IN BYTE OFFSET
	BCC	D.PRIG		; AND CONTINUE, UNLESS THAT WAS A SECOND "B"
	BR	D.PRIE		; IN WHICH CASE WE LOSE

D.PRIJ:	BITB	(SP),R4		; BIT ALREADY ON?
	BNE	D.PRIN		; YES, LOSE
	BISB	(SP),R4		; SET IT
	CMPB	(SP)+,(R5)+	; BUMP SP BY 2, R5 BY 1
	CMPB	#' ,(R5)	; SPACE YET?
	BEQ	D.PRIH		; YES, ALL DONE.
D.PRIK:	MOVB	#10,-(SP)	; SET UP MAGIC BIT
	MOV	#D.NZVC+4,R3	; CHARACTER POINTER
D.PRIL:	CMPB	(R5),-(R3)	; MATCH?
	BEQ	D.PRIJ		; BRANCH IF SO
	ASRB	(SP)		; MOVE BIT
	BNE	D.PRIL		; AND LOOP
D.PRIN:	TSTB	(SP)+
	BR	D.PRIE		; ELSE NOT THE RIGHT INSTRUCTION

; ROUTINES TO HANDLE THE SYMBOL TABLE

D.GTAD:	MOV	R0,-(SP)	; SAVE CHARACTER ADDRESS
	.IIF DF,$VMEM, MOV PARMAP,-(SP) ;NO VIRTUAL MAP HERE
	.IIF DF,$VMEM, CLR PARMAP
	JSR	PC,D.RD50	; CONVERT FIRST 3 TO RAD50
	MOV	R0,D.RAD1	; SAVE VALUE
	.IIF DF,$VMEM,MOV (SP)+,PARMAP
	MOV	(SP)+,R0	; GET CHARACTER ADDRESS
	ADD	#3,R0		; POINT TO LAST 3 CHARACTERS
	.IIF DF,$VMEM, MOV PARMAP,-(SP) ;NO VIRTUAL MAP HERE
	.IIF DF,$VMEM, CLR PARMAP
	JSR	PC,D.RD50	; CONVERT TO RAD50
	.IIF DF,$VMEM,MOV (SP)+,PARMAP
	MOV	R0,D.RAD2	; STORE IT AWAY
D.GTAC:	MOV	#D.SYMA-2,R0	; ADDRESS OF SYMBOL TABLE
D.GTA2:	TST	(R0)+		; BUMP R0 BY 2
	CMP	(R0)+,(R0)	; BUMP R0 BY 2 MORE, CHECK IF END OF TABLE
	BNE	D.GTA6
	TST	(R0)		; WERE BOTH SYMBOL HALVES 0?
	BNE	D.GTA6		; NO, KEEP LOOKING
	CLR	R0		; NOT FOUND...MARK RETURN REGISTER
	RTS	PC		; RETURN
D.GTA6:	CMP	D.RAD2,(R0)+	; DO SECOND THREE CHARACTERS MATCH?
	BNE	D.GTA2		; NO, GO TO NEXT SYMBOL
	CMP	-4(R0),D.RAD1	; YES, HOW ABOUT THE FIRST THREE?
	BNE	D.GTA2		; NO, GO TO NEXT SYMBOL
	RTS	PC		; RETURN

D.GTSM:	CLR	-(SP)		; SPACE FOR TEMPORARIES
	MOV	D.FENC,R2	; FIND CLOSEST SYMBOL <= R0
	MOV	D.RFNL,R1	; WHICH IS ALSO >= R0-D.RFNL
D.GTS1:	CMP	(R2)+,(R2)+	; SKIP OVER THE NAME
	BEQ	D.GTS3
D.GTS2:	MOV	R0,R3		; SET A TEMPORARY
	SUB	(R2)+,R3	; OBTAIN DIFERENCE
	BLO	D.GTS1		; IF SYMBOL HIGHER THAN R0, NO GO
	SUB	R1,R3		; ARE WE CLOSER THAN BEFORE?
	BHI	D.GTS1		; NO, FURTHER
	MOV	R2,(SP)		; SAVE POINTER TO SYMBOL
	ADD	R3,R1		; SAVE DIFFERENCE
	BR	D.GTS1		; AND LOOK FOR ONE CLOSER
D.GTS3:	TST	-2(R2)		; AT END OF TABLE?
	BNE	D.GTS2		; NO, KEEP GOING
	MOV	(SP)+,R1	; GET SYMBOL PTR
	BEQ	D.GTS4		; BRANCH IF NOT FOUND.
	CMP	-(R1),#400	; IGNORE SMALL SYMBOLS
	BLO	D.GTS4
	SUB	(R1),R0		; RECOMPUTE DIFFERENCE
	MOV	R0,-(SP)	; SAVE DIFFERENCE
	MOV	-(R1),-(SP)	; GET LAST THREE CHARACTERS
	MOV	-(R1),R0	; GET FIRST THREE
	MOV	#D.SYM,R1	; ADDRESS TO PUT CHARACTERS
	.IIF DF,$VMEM, MOV PARMAP,-(SP) ;NO VIRTUAL MAP HERE
	.IIF DF,$VMEM, CLR PARMAP
	JSR	PC,D.CHAR	; CONVERT TO ASCII
	.IIF DF,$VMEM,MOV (SP)+,PARMAP
	MOV	(SP)+,R0	; GET FIRST RAD50 WORD
	.IIF DF,$VMEM, MOV PARMAP,-(SP) ;NO VIRTUAL MAP HERE
	.IIF DF,$VMEM, CLR PARMAP
	JSR	PC,D.CHAR	; CONVERT TO ASCII
	.IIF DF,$VMEM,MOV (SP)+,PARMAP
	MOV	(SP)+,R0	; RESTORE DIFFERENCE
	MOV	#D.SYM,R1	; POINT TO CHARACTERS
	RTS	PC		; RETURN
D.GTS4:	CLR	R1		; NOT FOUND...MARK IT SO
	RTS	PC		; RETURN

; ROUTINE TO GET AN EXPRESSION (VALUE IN R4, FLAG IN R2, TERMINATOR IN R1)

D.CEXP:	INCB	D.INPA		; NOT IN INSTRUCTION
	CLR	D.OFST		; START OUT FRESH
D.EXPR:	MOV	#D.ADD,D.OPER	; INITIAL FUNCTION
D.EXP7:	JSR	PC,D.PRIM	; GET PRIMARY EXPRESSION
	TST	R2		; INSTRUCTION?
	BMI	D.EXP1		; EXIT IF SO
	CMP	R1,#D.OPAR	; OPEN PARENTHESIS OR OPERATOR?
	BLT	D.EXP1		; BRANCH IF NEITHER
	BEQ	D.EXP2		; BRANCH IF OPEN PARENTHESIS
	CMP	R1,#D.CPAR	; CLOSE PARENTHESIS OR OPERATOR?
	BLT	D.EXP3		; BRANCH IF OPERATOR
	BEQ	D.EXP4		; BRANCH IF CLOSE PARENTHESIS
D.EXP1:	TSTB	D.LEVL		; TERMINATOR FOUND...AT UPPER LEVEL?
	BEQ	D.EXP5		; BRANCH IF SO
	BR	D.ERRD		; ERROR
D.EXP2:	TSTB	D.INPA		; IN AN INSTRUCTION TYPE-IN?
	BNE	D.EXP5		; BRANCH IF SO (INSTRUCTION FORMAT)
	INCB	D.LEVL		; GO DOWN TO NEXT PARENTHESIS LEVEL
	MOV	D.OFST,-(SP)	; SAVE TALLY
	MOV	D.OPER,-(SP)	; SAVE OPERATION
	CLR	D.OFST		; CLEAR TALLY
	JSR	PC,D.EXPR	; RECURSION!
	MOV	(SP)+,D.OPER	; RESTORE OPERATION
	MOV	(SP)+,D.OFST	; RESTORE TALLY
	JSR	PC,@D.OPER	; COMBINE THEM
	BR	D.EXPR		; LOOP
D.EXP4:	DECB	D.LEVL		; UP TO HIGHER PARENTHESIS LEVEL
	BMI	D.ERRD		; ERROR IF NONE HIGHER
D.EXP5:	JSR	PC,@D.OPER	; DO OPERATION
	MOV	D.OFST,R4	; GET TALLY AS RETURN PARAMETER
	RTS	PC		; RETURN (POSSIBLY TO SELF)
D.EXP3:	JSR	PC,@D.OPER	; DO OPERATION
	ASL	R1		; AND GET
	MOV	D.LGDR(R1),D.OPER ;   THE NEXT
	BR	D.EXP7		; LOOP

; ROUTINE TO HANDLE PARAMETERS FOR INSTRUCTION TYPE-IN

D.GETI:	ASR	R3		; PARAMETER CODE
	BIC	#177741,R3	; MASK OUT OTHER BITS
	MOV	R4,-(SP)	; SAVE OPERATION MASK
	JSR	PC,@D.PARG(R3)	; GET PARAMETERS
	BIS	(SP)+,R4	; PUT OPERATION MASK INTO OPERANDS
	MOV	#1,R2		; MARK A GOOD NUMBER
	RTS	PC		; RETURN

D.GR:	JSR	PC,D.PRIM	; GET PRIMARY
D.REDR:	SUB	#D.UR0,R4	; GET REGISTER ADDRESS
	ASR	R4		; MAKE INTEGER FROM ADDRESS
	BIT	#177770,R4	; ANY HIGH BITS ON?
	BNE	D.ERRD		; ERROR IF NOT A REGISTER
D.NONE:	RTS	PC		; RETURN

D.GGET:	MOV	R0,-(SP)	; SAVE WHAT MUST BE READ
D.GGE2:	JSR	PC,D.GET	; GET LETTER
	CMP	R0,(SP)		; EQUAL?
	BEQ	D.GGE1		; YES, RETURN
D.ERRD:	JMP	D.ERR		; ERROR
D.GGE1:	TST	(SP)+		; FIX STACK
	RTS	PC		; RETURN

D.PSAV:	MOV	(SP),-(SP)	; PUSH RETURN ADDRESS DOWN
	SWAB	R4		; MOVE
	ASR	R4		;  TO
	ASR	R4		;   HIGH POSITION
	MOV	R4,2(SP)	; PUT PARAMETERS IN
	CMP	R1,#D.COMM	; COMMA IN-BETWEEN?
	BNE	D.ERRD		; ERROR IF NOT
	RTS	PC		; RETURN

D.DISP:	JSR	PC,D.CEXP	; GET EXPRESSION
	SUB	D.DOT,R4	; COMPUTE OFFSET
	ASR	R4		; SHIFT
	DEC	R4		; POINTS TO PROPER WORD
	BIC	#177400,R4	; CLEAR HIGH BITS
	RTS	PC		; RETURN

D.GRNN:	JSR	PC,D.GR		; GET REGISTER
	JSR	PC,D.PSAV	; SAVE PARAMETERS
	JSR	PC,D.DISP	; GET ADDRESS
	BIC	#177700,R4	; REDUCE TO 6-BITS
D.GGE3:	BIS	(SP)+,R4	; ADD IN REGISTER
	RTS	PC		; RETURN
D.GSD:	JSR	PC,D.GDD	; GET 6-BIT OPERAND
D.GGE4:	JSR	PC,D.PSAV	; SAVE PARAMETER
	JSR	PC,D.GDD	; GET OTHER PARAMETER
	BR	D.GGE3		; DO THE REST
D.GRSS:	JSR	PC,D.GR		; GET REGISTER
	BR	D.GGE4		; DO THE REST
D.GDDR:	JSR	PC,D.GDD	; GET 6-BIT-OPERAND
	MOV	R4,-(SP)	; SAVE OPERAND
	JSR	PC,D.GR		; GET REGISTER
	SWAB	R4		; SHIFT
	ASR	R4		;  INTO
	ASR	R4		;   HIGH PLACE
	BR	D.GGE3		; DO THE REST

D.NEXP:	MOV	D.CADC,R0	; GET CAD COPY
	TST	(R0)+		; BUMP TO NEXT
	MOV	R0,D.CADC	; RESTORE NEW VALUE
	TST	(R0)+		; INCREMENT AGAIN
	RTS	PC		; RETURN

D.GDD:	CLR	R2		; NO PARAMETERS YET
	JSR	PC,D.CEXP	; GET EXPRESSION
	CMP	R1,#D.OPAR	; OPEN PARENTHESIS?
	BEQ	D.G02		; BRANCH IF SO
	CMP	R1,#D.HASH	; HASH MARK?
	BEQ	D.G05		; BRANCH IF SO
	BLO	D.G03		; BRANCH IF AT-SIGN
	CMP	R4,#D.UR0	; REGISTER?
	BLO	D.NOTR		; BRANCH IF NOT
	CMP	R4,#D.UR7	; REGISTER?
	BHI	D.NOTR		; BRANCH IF NOT
	SUB	#D.UR0,R4	; NORMALIZE
	ASR	R4
	RTS	PC		; RETURN
D.NOTR:	JSR	PC,D.NEXP	; POINT TO NEXT PARAMETER
	MOV	R0,-(SP)	; SAVE RELOCATION
	SUB	D.CAD,R0	; GET PARAMETER OFFSET
	MOV	(SP)+,D.PARO-4(R0) ; PUT IN OFFSET
	MOV	R4,D.PARS-4(R0)	; PUT VALUE IN
	MOV	#67,R4		; RELATIVE PC ADDRESSING
	RTS	PC		; DONE
D.G05:	JSR	PC,D.CEXP	; GET EXPRESSION
D.G014:	JSR	PC,D.NEXP	; NEXT PARAMETER
	SUB	D.CAD,R0	; GET PARAMETER OFFSET
	CLR	D.PARO-4(R0)	; NO RELOCATION
	MOV	R4,D.PARS-4(R0)	; PUT VALUE IN
	MOV	#27,R4		; IMMEDIATE ADDRESSING
	RTS	PC		; RETURN
D.G02:	TST	R2		; "(" FOUND, ANY OFFSET?
	BNE	D.G013		; BRANCH IF SO (INDEX ADDRESSING)
	CMP	D.OPER,#D.SUBT	; "-(R)" ?
	BNE	D.G016		; BRANCH IF NOT
	JSR	PC,D.GR		; GET REGISTER
	ADD	#40,R4		; ADD IN AUTO-DECR OFFSET
	BR	D.G09		; SKIP TO COMMAND AND RETURN
D.G016:	JSR	PC,D.GR		; GET REGISTER..."(R)" OR "(R)+"
	JSR	PC,D.G09	; SKIP TO NEXT PARAMETER
	CMP	R1,#D.ADDS	; PLUS SIGN?
	BNE	D.G012		; BRANCH IF NOT
	ADD	#20,R4		; ADD IN AUTO-INCR OFFSET
	BR	D.G09		; SKIP TO COMMAND AND RETURN
D.G013:	JSR	PC,D.G014	; PUT PARAMETER IN
	JSR	PC,D.GR		; GET REGISTER
	ADD	#60,R4		; ADD IN INDEX OFFSET
	BR	D.G09		; SKIP TO COMMAND AND RETURN
D.G03:	CLR	R2		; "@" FOUND, MARK NO NUMBER FOUND YET
	JSR	PC,D.CEXP	; AN "@" WAS FOUND, LOOK TO NEXT
	CMP	R1,#D.HASH	; "@#" MEANS ABSOLUTE ADDRESSING
	BEQ	D.G06		; BRANCH IF SO
	CMP	R1,#D.OPAR	; COULD BE "@(" OR "@X("
	BEQ	D.G07		; BRANCH IF EITHER
	CMP	R4,#D.UR0	; IS IT @R?
	BLO	D.G08		; BRANCH IF NOT
	CMP	R4,#D.UR7	; TEST UPPER RANGE
	BHI	D.G08		; BRANCH IF NOT
	JSR	PC,D.REDR	; REDUCE TO REGISTER NUMBER
D.G012:	ADD	#10,R4		; ADD IN REG-DEFERRED OFFSET
	RTS	PC		; THATS ALL...RETURN
D.G08:	JSR	PC,D.NOTR	; PERFORM NORMAL RELOCATION
	MOV	#77,R4		; MARK RELATIVE DEFERRED ADDRESSING
	RTS	PC		; RETURN
D.G07:	TST	R2		; ANY NUMBER THERE?
	BEQ	D.G010		; BRANCH IF "@("
	JSR	PC,D.G014	; GET OFFSET INTO PARAMETER
	JSR	PC,D.GR		; NOW GET REGISTER
	ADD	#70,R4		; ADD IN INDEX DEFERRED OFFSET
D.G09:	MOV	R4,-(SP)	; SAVE VALUE
	JSR	PC,D.PRIM	; SKIP TO NEXT COMMAND
	MOV	(SP)+,R4	; RESTORE VALUE
	RTS	PC		; RETURN
D.G010:	CMP	D.OPER,#D.SUBT	; "@-(" ?
	BNE	D.G015		; BRANCH IF NOT
	JSR	PC,D.GR		; GET REGISTER
	ADD	#50,R4		; ADD IN AUTO-DECR DEFERRED OFFSET
	BR	D.G09		; SKIP TO COMMAND AND RETURN
D.G015:	JSR	PC,D.GR		; GET REGISTER
	MOV	#'+,R0		; FORM IS "@(R)+"
	JSR	PC,D.GGET	; GET THE PLUS
	ADD	#30,R4		; ADD IN AUTO-INCR DEFERRED OFFSET
	BR	D.G09		; SKIP TO COMMAND AND RETURN
D.G06:	JSR	PC,D.G05	; GET ABSOLUTE ADDRESS
	MOV	#37,R4		; MARK ABSOLUTE MODE
	RTS	PC		; DONE
D.GNUM:	JMP	D.PRIM		; GET NUMBER AND RETURN

; SYMBOL MANIPULATION SUBROUTINES

D.PTSM:	MOV	D.POS,R1	; GET POSITION ADDRESS
	CMP	R1,#D.SYM+D.SYML; NO MORE ROOM?
	BHIS	D.PTS1		; EXIT IF SO
	MOVB	R0,(R1)+	; PUT CHARACTER IN
	MOV	R1,D.POS	; RESTORE POINTER
D.PTS1:	RTS	PC		; RETURN

D.CLSM:	MOV	#D.SYM+D.SYML,R0
D.CLS3:	MOVB	#' ,-(R0)
	CMP	R0,#D.SYM
	BHI	D.CLS3
	MOV	R0,D.POS
	RTS	PC		; RETURN

; ADDITION, SUBTRACTION, MULTIPLICATION, DIVISION FOR DECODER

D.ADD:	ADD	R4,D.OFST	; ADD OPERANDS
	RTS	PC		; RETURN
D.SUBT:	SUB	R4,D.OFST	; SUBTRACT OPERANDS
	RTS	PC		; RETURN
D.MULT:	CLR	R0		; MULTIPLY THEM
	MOV	#16.,-(SP)	; LOOPER
D.MUL1:	ASR	R4		; GET BOTTOM BIT
	BCC	D.MUL2		; SKIP IF OFF
	ADD	D.OFST,R0	; ADD IN OPERAND
D.MUL2:	ASL	D.OFST		; SHIFT OPERAND
	DEC	(SP)		; MORE TO LOOP?
	BGT	D.MUL1		; LOOP IF SO
	MOV	R0,D.OFST	; RESULT IN D.OFST
	TST	(SP)+		; FIX STACK
	RTS	PC		; RETURN
D.DIV:	MOV	R1,-(SP)	; SAVE R1
	MOV	D.OFST,R0	; GET OPERAND
	MOV	R4,R2		; GET OTHER OPERAND
	JSR	PC,D.DIVD	; DIVIDE THEM
	MOV	R0,D.OFST	; GET RESULT
	MOV	(SP)+,R1	; RESTORE R1
	RTS	PC		; RETURN

	.IF	DF,D.MCRO
D.UE:	MOV	#1,D.ECSW	;UE  TURN ON MACRO ECHO MODE
	RTS	PC
D.UN:	CLR	D.ECSW		;UN TURN OFF MACRO ECHO MODE
	RTS	PC
;	UC PROCESSING -- TURN ON CORE PSEUDO INPUT
D.UDAT:
	MOV	#1,D.CHSW	;SET CORE INPUT MODE
	MOV	#<33*400+33>,D.KBFE-2 ;PUT IN ALTMODES AT BUF END
	MOV	#-1,D.KBFE	;AND GUARANTEE A FENCE
	RTS	PC
;	US PROCESSING -- TURN OFF CORE INPUT MODE (USE STANDARD INPUT)
D.UKOT:	CLR	D.CHSW
	RTS	PC
	.ENDC
	.IF	DF,$VMEM	;VIRTUAL DDT ONLY...
;	UV	USE VIRTUAL MAP UNALTERED
O.VVIR:	CLR	PARMAP
	RTS	PC		;FORGET MAPPING
;
	.IF	DF,$DDBSX	;IF BSX HOOK FOR READING TCB STATES...
;
;	UP	SET UP PROGRAM STATUS FROM TCB ENTRY IN BSX
;		( ADDR$UP    WHERE ADDR = BSX TCB ADDRESS)
;
;	UP  SET UP REGS AND VIRTUAL APR'S FROM AN AREA OF MEMORY
;	POINTED TO BY ADDRESS IN ADDR$UP.  NOTE THAT ALL PARS ARE
;	SET UP AS ARE REGS 0-7 IN SAVE AREA. THE SAVE AREA FORMAT
;EXPECTED IS APR0 THROUGH APR7 FIRST, THEN R5 THROUGH R0. THE SP
;IS EXPECTED AT ADDRESS TCBDSP AND THE SAVE AREA AT TCBREG RELATIVE
;TO THE GIVEN ADDRESS.
;
O.PVIR:
	MOV	R0,-(SP)	;SAVE US A LITTLE CONTEXT
	MOV	R1,-(SP)	;TO GET REGS HERE
	MOV	R2,-(SP)
	MOV	R3,-(SP)
	MOV	R4,-(SP)
	MOV	R5,-(SP)	;ALL REGS SHOULD BE FREE
	SUB	#40,SP	;GET A SAVE AREA ON THE STACK
	MOV	SP,R5	;R5 INDEXES IT (ALLOWS US TO UPDATE
			;LOCAL "APR" INFO ALL AT ONCE)
	MOV	D.BW,-(SP) ;SAVE BYTE/WORD MODE
	MOV	D.CAD,-(SP) ;SAVE "CURRENT ADDR"
	MOV	#2,D.BW	;SET FOR FULLWORDS
	MOV	D.FWA,R3	;GET ADDRESS
	BIC	#1,R3	;EVENIZE JUST IN CASE.
	MOV	R3,D.CAD	;GET USER PS,PC
	ADD	#34,D.CAD	;TCB OFFSET OF TASK PC
	JSR	PC,GETCAD	;GET IT (IF ANY)
	MOV	R0,D.UR7	;THE FILL IT IN
	ADD	#2,D.CAD	;POINT AT USER STATUS IN TASK
	JSR	PC,GETCAD	;LOAD IT
	MOV	R0,D.USTA	;FILL IN
	MOV	R3,D.CAD	;GET USER SP
	ADD	#TCBDSP,D.CAD	;FROM TCB OF DYNAM.
	JSR	PC,GETCAD	;LOAD TO R0
	MOV	R0,D.UR6	;SAVE
	BNE	1$		;IF NONZERO ALL IS WELL
	ADD	#<TCBISP-TCBDSP>,D.CAD	;ELSE GET START SP
	JSR	PC,GETCAD	;LOAD
	MOV	R0,D.UR6	;TO DDT SP
1$:	ADD	#TCBREG,R3	;NOW POINTER THE SAVE AREA
;HERE HAVE SAVED R0-R5, THEN APR0-7 IN ORDER SO COPY HERE
	MOV	#6,R2		;COUNT REGS
	MOV	#D.UR0,R1	;DDT COPIES HERE
2$:	MOV	R3,D.CAD	;POINT AT SAVE AREA
	ADD	#2,R3		;BUMP FOR NEXT
	JSR	PC,GETCAD	;LOAD THE VALUE
	MOV	R0,(R1)+	;SAVE IN DDT AREA
	DEC	R2
	BGT	2$		;DO ALL REGS
	MOV	#10,R2		;COUNT APR'S
	MOV	R5,R1		;WHERE TO SAVE FOR NOW...
3$:	MOV	R3,D.CAD	;GET EM
	ADD	#2,R3
	JSR	PC,GETCAD	;GET AN APR
	MOV	R0,(R1)+	;PUT IN OUR SAVE AREA
	DEC	R2
	BGT	3$		;DO ALL APR'S
;AT THIS POINT ALL APR VALUES MAY BE LOCALLY MOVED TO DDT
;AREA STARTING AT VKPAR0, IGNORING PSEUDO MAP THE WHILE.
	MOV	#10,R2
	MOV	#VKPAR0,R1	;POINT AT DDT PSEUDO MAP
4$:	MOV	(R5)+,(R1)+	;COPY AN APR
	DEC	R2		;
	BGT	4$		;DO ALL 8.
	MOV	(SP)+,D.CAD
	MOV	(SP)+,D.BW	;RESTORE
	ADD	#40,SP		;REMOVE SAVE AREA
	MOV	(SP)+,R5	;GET BACK OUR REGS
	MOV	(SP)+,R4
	MOV	(SP)+,R3
	MOV	(SP)+,R2
	MOV	(SP)+,R1
	MOV	(SP)+,R0
	RTS	PC
	.ENDC
;	UB  SET BASE ; SYNTAX IS PAR<ADDR$UB TO SET PAR TO
;			VALUE AT ADDR.
O.BVIR:
;	TST	R2	;ANY PARAMETER?
;	BNE	1$	;YES, GO AHEAD
;2$:	RTS	PC	;NO, RETURN NOW
1$:	MOV	R0,-(SP)
	MOV	R1,-(SP)
	MOV	D.FWA,R0 ;GET APR NUMBER
	BIT	#177770,R0 ;TEST RANGE
	BNE	3$	;ESCAPE IF ILLEGAL
	MOV	D.SVR4,R1	;GET SYMBOLIC ADDRESS
	;LOAD APR BASE FROM SYMBOLS IN ANY SPACE
	MOV	D.BW,-(SP)
	MOV	D.CAD,-(SP)
	MOV	R0,-(SP)
	MOV	#2,D.BW
	MOV	R1,D.CAD
	BIC	#1,D.CAD ;EVENIZE ADDRESS
	JSR	PC,GETCAD ;GET ADDRESS
	MOV	R0,R1
	MOV	(SP)+,R0 ;APR NUMBER
	ASL	R0 ;ENWORD
	MOV	R1,VKPAR0(R0) ;BASH "PAR"
	MOV	(SP)+,D.CAD
	MOV	(SP)+,D.BW
3$:	MOV	(SP)+,R1
	MOV	(SP)+,R0
	RTS	PC
;	UD  SET BASE ; SYNTAX IS PAR<DATA$UB TO SET PAR TO
;			VALUE OF DATA.
O.DVIR:
;	TST	R2	;ANY PARAMETER?
;	BNE	1$	;YES, GO AHEAD
;2$:	RTS	PC	;NO, RETURN NOW
1$:	MOV	R0,-(SP)
	MOV	R1,-(SP)
	MOV	D.FWA,R0 ;GET APR NUMBER
	BIT	#177770,R0 ;TEST RANGE
	BNE	3$	;ESCAPE IF ILLEGAL
	MOV	#D.SVR4,R1	;GET SYMBOLIC ADDRESS
	;LOAD APR BASE FROM SYMBOLS IN ANY SPACE
	MOV	PARMAP,-(SP)	;$UD SHOULD GET DDT SYMBOLS ALWAYS
	CLR	PARMAP		;SO FORCE IT TO...
	MOV	D.BW,-(SP)
	MOV	(SP)+,PARMAP	;RESTORE STATE OF VIRTUAL MAPPING
	MOV	D.CAD,-(SP)
	MOV	R0,-(SP)
	MOV	#2,D.BW
	MOV	R1,D.CAD
	BIC	#1,D.CAD ;EVENIZE ADDRESS
	JSR	PC,GETCAD ;GET ADDRESS
	MOV	R0,R1
	MOV	(SP)+,R0 ;APR NUMBER
	ASL	R0 ;ENWORD
	MOV	R1,VKPAR0(R0) ;BASH "PAR"
	MOV	(SP)+,D.CAD
	MOV	(SP)+,D.BW
3$:	MOV	(SP)+,R1
	MOV	(SP)+,R0
	RTS	PC
;
;
;
;	UM	TURN ON VIRTUAL MAPPING
O.OVIR:	MOV	#VKPAR0,PARMAP	;GET MAP APR'S FROM VIRTUAL MAP
	RTS PC
;	UR	RESTORE INITIAL MAPPING
O.EVIR:	MOV	#ORGPAR,PARMAP	;RESTORE INITIAL MAP
	RTS PC
;	UU	USE USER PARS FOR MAPPING (READ CURRENT ONES...)
O.UVIR:	MOV	#UPAR0,R0 ;SET UP USER PARS FOR MAP
O.KUC:	MOV	#VKPAR0,PARMAP	;(IMPLIES VIRTUAL MAP ON)
	MOV	#VKPAR0,R1	;NOW SET THE THING
	MOV	#10,R2		;NUMBER OF APR'S IS 8
1$:	MOV	(R0)+,(R1)+	;COPY AN APR
	SOB	R2,1$		;AND REPEAT FOR ALL OF THEM
	RTS PC
;	UK	USE KERNEL APR'S FOR VIRTUAL MAP
O.KVIR:	MOV	#KPAR0,R0	;SET UP TO READ KERNEL APR'S
	BR	O.KUC		;AND DO COMMON CODE
	.ENDC

; MANIPULATION OF THE SYMBOL TABLE

D.SWAP:	MOV	#3,R2		; COUNTER
D.SWA1:	MOV	-(R1),-(SP)	; GET WORD
	MOV	(R0),(R1)	; PUT OTHER WORD IN
	MOV	(SP)+,(R0)	; AND FINISH SWAP
	TST	-(R0)		; MOVE WORD
	DEC	R2		; LOOPER
	BGT	D.SWA1		; LOOP IF MORE
	RTS	PC		; RETURN

; PROCESS : - DEFINE SYMBOL

D.COLN:	CMPB	D.SYM,#' 	; NULL SYMBOL?
	BEQ	D.ERRB		; ERROR IF SO
	MOV	D.DOT,R4	; ASSUME DOT ADDRESS
	TSTB	D.FWAF		; REAL VALUE GIVEN?
	BEQ	D.COL1		; BRANCH IF NOT
	MOV	D.FWA,R4	; GET REAL VALUE
D.COL1:	TST	R0		; IN SYMBOL TABLE?
	BNE	D.COL2		; BRANCH IF SO
	MOV	D.RAD1,-(SP)	; SAVE RAD50 OF NAME
	MOV	D.RAD2,-(SP)	; BOTH HALVES
	MOV	#-1,D.RAD1	; ASSUME NULL RAD50 LABEL
	MOV	#-1,D.RAD2	; IN BOTH HALVES
	JSR	PC,D.GTAC	; LOOK IT UP
	TST	R0		; FOUND?
	BEQ	D.ERRB		; ERROR IF NOT
	MOV	(SP)+,-(R0)	; FILL LABEL IN
	MOV	(SP)+,-(R0)	;  BY SETTING BOTH WORDS
	CMP	(R0)+,(R0)+	; NOW FIX POSITION
D.COL2:	MOV	R4,(R0)		; AND SET VALUE
	MOV	R0,D.LASC	; SET LAST COLONED WORD
	MOV	D.FENC,R1	; GET FENCE
	CMP	R0,R1		; BEHIND FENCE?
	BHI	D.COL5		; DONE IF NOT
	JSR	PC,D.SWAP	; SWAP SYMBOLS
	MOV	R1,D.FENC	; STORE IN FENCE
D.COL5:	RTS	PC		; RETURN
D.ERRB:	JMP	D.ERR		; ERROR

; PROCESS D - DELETE LAST COLONED SYMBOL

D.DELE:	MOV	D.LASC,R0	; GET LAST COLONED SYMBOL
	BEQ	D.ERRB		; ERROR IF NONE
	CLR	D.LASC		; LAST TIME TO COLON IT
	BR	D.KIL3		; NOW KILL IT

; PROCESS K - KILL SYMBOL

D.KILL:	JSR	PC,D.GTAC	; GET ADDRESS OF SYMBOL
	TST	R0		; ANY SYMBOL?
	BEQ	D.ERRB		; ERROR IF NOT
	CMPB	D.ALTF,#1	; HOW MANY ALTMODES?
	BGT	D.KIL1		; BRANCH IF 2
D.KIL3:	MOV	D.FENC,R1	; GET FENCE
	CMP	R0,R1		; SYMBOL BEHIND FENCE?
	BLO	D.KIL4		; BRANCH IF ALREADY KILLED
	ADD	#6,R1		; PUSH UP FENCE
	MOV	R1,D.FENC	; AND STORE IT
	JMP	D.SWAP		; SWAP SYMBOLS AND RETURN
D.KIL1:	CLR	(R0)		; CLEAR ADDRESS
	MOV	#-1,-(R0)	; PUT IN NULL SYMBOL
	MOV	#-1,-(R0)	; IN BOTH WORDS
D.KIL4:	RTS	PC		; RETURN

; PROCESS ALTMODE

D.ALTM:	TSTB	D.ALTF		; ALREADY AN ALTMODE TYPED?
	BNE	D.ALT1		; BRANCH IF SO
	MOV	R2,D.SVR2	; AN ALTMODE HAS BEEN RECEIVED
	MOV	R4,D.SVR4	; NUMERIC FLAG TO D.SVR2, CONTENTS TO D.SVR4
D.ALT1:	CLR	R2		; NO ARGS TYPED YET
	CLR	D.OFST		; CLEAR OFFSET
	INCB	D.ALTF		; COUNT NUMBER OF ALTMODES
	JMP	D.DCD1		; RETURN

; PROCESS / - OPEN WORD

D.WRD:	MOV	D.CURM,D.OMOD	; TEMP COPY OF ROUTINE ADDRESS
D.WRD1:	TST	R2		; NUMBER THERE?
	BNE	D.WRD3		; BRANCH IF SO
D.WRD4:	MOV	D.LASV,D.CAD	; SET LAST ADDRESS
	BR	D.SEMI		; DO IT
D.WRD3:	MOV	R4,D.DOT	; SET DOT
D.WRD5:	MOV	D.DOT,D.CAD	; SET CURRENT ADDRESS

; PROCESS ; - RETYPE WORD

D.SEMI:	JMP	@D.OMOD		; TYPE WORD AND RETURN

; PROCESS <TAB> - OPEN INDIRECT

D.ORAB:	JSR	PC,D.CLSE	; CLOSE WORD
	MOV	D.LASV,D.DOT	; INDIRECT REFERENCE
	BR	D.OP2		; OPEN IT AND RETURN

; PROCESS ! - OPEN WORD SILENTLY

D.EXCL:	MOV	#D.RTS,D.OMOD	; NULL ROUTINE FOR TYPING
	BR	D.WRD1		; OPEN WORD

; PROCESS \ - OPEN LAST REFERENCED WORD

D.BKSL:	TST	R2		; ANY PARAMETER?
	BEQ	D.WRD4		; BRANCH IF NOT
	JSR	PC,D.CLSE	; CLOSE WORD
	BR	D.WRD4		; OPEN INDIRECT

; PROCESS <LF> - OPEN NEXT WORD

D.OP1:	JSR	PC,D.CLSE	; CLOSE WORD
	ADD	D.BW,D.DOT	; ADD IN BYTE/WORD INCREMENT
	ADD	D.LFIN,D.DOT	; ADD IN LINE-FEED INCREMENT
D.OP2:
	.$$..=0
	.IF	DF,$$RSX
	.IF	GT,MMM11
	.$$..=1
	.ENDC
	.IIF DF,XTCOM,.$$..=0
	.ENDC ;$$RSX
	.IF	EQ,.$$..
	JSR	PC,D.CRLF	; TYPE CRLF
	.IFF
	MOV	R0,-(SP)
	MOV	#15,R0	;EMIT C.R. ONLY
	MOVB	#71.,D.CPOS ;RESET CHAR POINTER
	JSR	PC,D.TYP3
	MOV	(SP)+,R0
	.ENDC
D.OP3:	MOV	D.DOT,R0	; GET WORD
	JSR	PC,D.RFND	; TYPE ADDRESS
	MOV	#'/,R0		; SLASH
	JSR	PC,D.TYPE	; TYPE IT
	BR	D.WRD5		; TYPE CONTENTS

; PROCESS [ - OPEN WORD AS NUMERIC

D.OPBR:	MOV	#D.CADV,D.OMOD	; NUMBER ROUTINE
	BR	D.WRD1		; DO ROUTINE

; PROCESS ] - OPEN WORD AS INSTRUCTION

D.CLBR:	MOV	#D.INST,D.OMOD	; INSTRUCTION ROUTINE
	BR	D.WRD1		; DO IT

; PROCESS ^ - OPEN PREVIOUS WORD

D.BACK:	JSR	PC,D.CLSE	; CLOSE WORD
	SUB	D.BW,D.DOT	; SUBTRACT BYTE/WORD INCREMENT
	BR	D.OP2		; OPEN WORD

; PROCESS _ - TYPE WORD SYMBOLICALLY

D.ORPC:	MOV	D.LASW,R0	; GET LAST TYPED WORD
	CLR	D.LFIN		; NO LINE-FEED INCREMENT
	TSTB	D.ALTF		; IS IT AN $_ ?
	BEQ	D.ORP1		; BRANCH IF NOT
	JMP	D.RFND		; TYPE SYMBOLICALLY AND RETURN
D.ORP1:	JMP	D.INST		; TYPE INSTRUCTION AND RETURN

; PROCESS = - TYPE WORD AS NUMBER

D.EQAL:	MOV	D.LASW,R0	; GET LAST TYPED WORD
	CLR	D.LFIN		; NO LINE-FEED INCREMENT
	JMP	D.TYPN		; TYPE AS A NUMBER

; PROCESS , - COMMA PARAMETER

D.DCOM:	TST	R2		; ANY PARAMETER?
	BEQ	D.FWA1		; BRANCH IF NOT
	MOV	R4,D.COMA	; PUT IN PARAMETER AREA
	BR	D.FWA1		; RETURN

; PROCESS < - STORE FIRST WORD ADDRESS FOR SEARCH

D.FWAS:	MOV	R4,D.FWA	; SET FIRST WORD
	INCB	D.FWAF		; MARK FIRST WORD FOUND
D.FWA1:	JMP	D.DCD2		; RETURN

; PROCESS Z - ZERO CORE

D.ZERO:	MOV	D.FWA,R0	; FIRST WORD
D.ZER1:	CMP	R0,D.SVR4	; AT LAST WORD?
	BHI	D.ONE1		; DONE IF SO
	MOV	D.FILV,(R0)+	;FILL WORD WITH PATTERN
	BR	D.ZER1		; LOOP

; PROCESS U - SECOND SET OF INSTRUCTIONS

D.SNGL:	CLR	R5		; OFFSET
	JSR	PC,D.GET	; GET CHARACTER
D.SNG2:	CMPB	D.UTAB(R5),R0	; MATCH?
	BNE	D.SNG1		; NO
	ASL	R5		; MULTIPLY BY 2
	JMP	@D.UADD(R5)	; DO THIS ROUTINE
D.SNG1:	INC	R5		; NEXT CHARACTER
	CMP	R5,#D.ENUT	; END OF LIST?
	BLT	D.SNG2		; LOOP IF NOT
D.ERRE:	JMP	D.ERR		; RETURN

; PROCESS UT - SET SINGLE INSTRUCTION

D.ONES:	MOVB	R4,D.S		; SET INDICATOR
	.IIF DF,$FORM$, BNE 1$
	.IIF DF,$FORM$, CLR D.FFPC ;CLEAR HDWR INT FLG ON $UT
	.IIF DF,$FORM$ 1$: ;SKIP MOD ON SGL STEP SET
	CLR	D.CT		; SET FOR AUTOMATIC PROCEDE
	CMPB	D.ALTF,#1	; TWO ALTMODES?
	BGT	D.ONE2		; FINISH UP IF SO
	INC	D.CT		; SET NORMAL PROCEDE
D.ONE2:	MOV	D.SVR4,D.OPEN	; SET ADDRESS TO OPEN AT BREAK
D.ONE1:	RTS	PC		; RETURN

; PROCESS UW - SET RFND LIMIT

D.WULF:	MOV	D.SVR4,D.RFNL	; SET LIMIT
	RTS	PC		; RETURN

; PROCESS UG - RETURN USER DISPLAY

	.IF	DF,D.GDP
D.GRAP:	 TRAP	144
	 MOV	#104544,D.SAV9	; UG! SELF MODIFYING-CODE
	 RTS	PC
	.ENDC

;GENERALIZED-MAPPING READ/WRITE ROUTINES
;USED TO IMPLEMENT PSEUDO-22 BIT MAPPING.
; REQUIRE THAT $VMEM BE DEFINED AND THAT I/O COMMON IN APR7 BE THERE...
;GET CONTENTS OF ADDRESS IN THE MODE		JSR PC,GETCAD

;NEEDS--
;D.BW		THE MODE 1=BYTE, 2=WORD
;D.CAD		THE ADDRESS
;O.DEVI		THE DEVICE CODE

;RETURNS--
;R0		HAS THE DATA YOU ASKED FOR

GETCAD:
	MOV	R3,-(SP)	;SAVE R3 ACROSS THE CALL
	MOV	D.BW,R0		; LOAD D.BW HERE FOR UNIFORMITY
	MOV	D.CAD,R3	; GET CORE ADDRESS
	.IF	DF,$VMEM	;IF I/O PAGE COMMON...
	TST	PARMAP		;USING PSEUDO MAP OF ANY KIND?
	BEQ	GC001		;NO, USE REAL ONE
	MOV	R2,-(SP)
	MOV	R3,-(SP)
	MOV	R4,-(SP)
	MOV	R5,-(SP)	;SAVE REGS WE NEED
	MOV	#4,R2		;DEFAULT IS USE PAR 2 FOR MAP
	.WORD	20727	;HAND ASSEMBLE THE FOLLOWING "CMP PC,#24000"
	.WORD	24000	;TO AVOID A Z ERROR
;	CMP	PC,#24000	;BUT SEE IF WE ARE IN PAR 0
	BLOS	1$		;IF SO USE DEFAULT
	CLR	R2		;OTHERWISE MAP THROUGH PAR 0
1$:	MOV	R2,R5		;SAVE PAR OFFSET FOR LATER
	MOV	R3,R4		;GET COPY OF DATA
	CMP	R3,#157776	;SEE IF IN PAR 7 (IF NOT, GUARANTEE NO ERR)
	BHI	X2$		;IF IN PAR 7 JUST LET IT THROUGH
	ASH	#-12.,R4	;GENERATE PAR OFFSET
	BIC	#^C16,R4	;AND ISOLATE OFFSET BITS
	ADD	PARMAP,R4	;R4 NOW POINTS TO PAR CONTENTS DESIRED
	BIC	#160000,R3	;R3 NOW GETS PAR OFFSET
	MOV	@#-2,-(SP)	;SAVE PSW
	BIS	#30340,@#-2	;SET PREV USER MODE, PRIO 7
	MOV	UPAR0(R2),-(SP)	;SAVE OLD PAR BEING USED FOR MAPPING
	MOV	UPDR0(R2),-(SP)	;SAVE OLD PDR ALSO
	MOV	@R4,UPAR0(R2)	;FILL IN PAR AS WE WANT IT NOW
	MOV	#77406,UPDR0(R2)	;SET 4K R/W PDR ALSO
	MOV	R3,R5		;GET OFFSET
	BIC	#1,R3
	TST	R2		;ARE WE USING PAR 0 FOR MAP?
	BEQ	2$		;IF SO ALL IS OK NOW
	BIS	#40000,R3	;ELSE SET PAR 2 BITS IN
2$:	MFPI	(R3)		;GRAB THE DATA (WHOLE WORD)
	MOV	(SP)+,R3	;STORE IN R3 A MOMENT
	MOV	(SP)+,UPDR0(R2)	;RESTORE OUR PDR
	MOV	(SP)+,UPAR0(R2)	;AND OUR PAR
	MOV	(SP)+,@#-2	;RESTORE PSW
	ASR	R0		;WANT WORD OR BYTE?
	BCC	3$		;WORD SO BRANCH
	BIT	#1,R5		;WAS THE ADDRESS ODD?
	BEQ	4$		;IF NOT LOW BYTE OK NOW
	SWAB	R3		;ELSE SWAP BYTES
4$:	MOVB	R3,R0		;GET THE DATA
	BIC	#177400,R0	;ZERO SIGN EXTENSION!
	BR	GC002		;THEN BUG OUT
3$:	MOV	R3,R0		;GET FULL WORD
GC002:	MOV	(SP)+,R5
	MOV	(SP)+,R4
	MOV	(SP)+,R3
	MOV	(SP)+,R2	;RESTORE REGS
	MOV	(SP)+,R3	;RESTORE R3 TO CALL STATE
	RTS	PC		;BYPASS REST OF CODE
X2$:	MOV	(SP)+,R5
	MOV	(SP)+,R4
	MOV	(SP)+,R3
	MOV	(SP)+,R2
	.ENDC
GC001:	ASR	R0		;PUSH BW FLAG INTO CARRY BIT
	BCC	10$		;2 WON'T FIT SO IS WORD
	MOVB	(R3),R0		;ACCESS BYTE
	BR	GETC99
10$:	MOV	(R3),R0		;ACCESS WORD
GETC99:
	MOV	(SP)+,R3	;RESTORE R3 TO CALL STATE
	RTS	PC		;STACK ACCESS

;PUT R4 INTO ADDRESS IN THE MODE		JSR PC,PUTCAD

;NEEDS--
;R4		THE DATA
;D.BW		THE MODE FLAG, IF 0 THEN NO LOCATION OPEN

PUTCAD:
	MOV	D.BW,R0		;PICK UP MODE AN CC'S
	MOV	R3,-(SP)	; SAVE CALLER'S R3
	MOV	D.CAD,R3	; GET CORE ADDRESS
	.IF	DF,$VMEM	;IF I/O PAGE COMMON...
	TST	PARMAP		;SEE IF ANY VIRT. MAPS
	BEQ	PC001	;NO, SKIP
	MOV	R2,-(SP)
	MOV	R3,-(SP)
	MOV	R4,-(SP)
	MOV	R5,-(SP)	;SAVE REGS WE NEED
	MOV	#4,R2		;DEFAULT IS USE PAR 2 FOR MAP
	.WORD	20727	;HAND ASSEMBLE THE FOLLOWING "CMP PC,#24000"
	.WORD	24000	;TO AVOID A Z ERROR
;	CMP	PC,#24000	;BUT SEE IF WE ARE IN PAR 0
	BLOS	1$		;IF SO USE DEFAULT
	CLR	R2		;OTHERWISE MAP THROUGH PAR 0
1$:	MOV	R4,R5		;SAVE PAR OFFSET FOR LATER
	MOV	R3,R4		;GET COPY OF DATA
	CMP	R3,#157776	;SEE IF IN PAR 7 (IF NOT, GUARANTEE NO ERR)
	BHI	YX2$		;IF IN PAR 7 JUST LET IT THROUGH
	ASH	#-12.,R4	;GENERATE PAR OFFSET
	BIC	#^C16,R4	;AND ISOLATE OFFSET BITS
	ADD	PARMAP,R4	;R4 NOW POINTS TO PAR CONTENTS DESIRED
	BIC	#160000,R3	;R3 NOW GETS PAR OFFSET
	MOV	@#-2,-(SP)	;SAVE PSW
	BIS	#30340,@#-2	;SET PREV USER MODE, PRIO 7
	MOV	UPAR0(R2),-(SP)	;SAVE OLD PAR BEING USED FOR MAPPING
	MOV	UPDR0(R2),-(SP)	;SAVE OLD PDR ALSO
	MOV	@R4,UPAR0(R2)	;FILL IN PAR AS WE WANT IT NOW
	MOV	#77406,UPDR0(R2)	;SET 4K R/W PDR ALSO
	MOV	R3,R4		;GET OFFSET
	BIC	#1,R3
	TST	R2		;ARE WE USING PAR 0 FOR MAP?
	BEQ	2$		;IF SO ALL IS OK NOW
	BIS	#40000,R3	;ELSE SET PAR 2 BITS IN
2$:	MFPI	(R3)		;GRAB THE DATA (WHOLE WORD)
	BIT	#1,R0		;BYTE ADDRESSING IN EFFECT?
	BEQ	5$		;NO, BASH WORD
	BIT	#1,R4		;YES, IS IT THE ODD BYTE?
	BEQ	6$		;NO, THE EVEN ONE  --  BRANCH
	MOVB	R5,1(SP)	;YES, BASH ODD BYTE OF DATA
	BR	7$		;THEN DO IT
6$:	MOVB	R5,(SP)		;BASH EVEN BYTE ONLY
	BR	7$		;THEN DO IT
5$:	MOV	R5,(SP)		;BASH WORD
7$:	MTPI	(R3)		;PUT BACK MODIFIED DATA WHERE WE GOT IT FROM.
	MOV	(SP)+,UPDR0(R2)	;RESTORE OUR PDR
	MOV	(SP)+,UPAR0(R2)	;AND OUR PAR
	MOV	(SP)+,@#-2	;RESTORE PSW
PC002:	MOV	(SP)+,R5
	MOV	(SP)+,R4
	MOV	(SP)+,R3
	MOV	(SP)+,R2	;RESTORE REGS
	MOV	(SP)+,R3	;RESTORE R3 TO CALL STATE
	RTS	PC		;BYPASS REST OF CODE
YX2$:	MOV	(SP)+,R5
	MOV	(SP)+,R4
	MOV	(SP)+,R3
	MOV	(SP)+,R2
	.ENDC
PC001:	BIT	#177776,R0	;CHECK MODE
	BNE	10$		;WORD MODE
	MOVB	R4,(R3)		;BYTE MODE
	BR	12$		;BRANCH MODE
10$:	MOV	R4,(R3)		;WORD MODE
12$:
X12$:
	MOV	(SP)+,R3	;RESTORE R3 TO CALL STATE
	RTS	PC

; PROCESS E, N AND W - SEARCHES

D.EFF:	MOV	#1,R1		; SET EFFECTIVE SEARCH
	BR	D.WDS		; DO SEARCH
D.NSCH:	MOV	#-1,R1		; SET NON-SEARCH
	BR	D.WDS		; DO SEARCH
D.WSCH:	CLR	R1		; SET WORD SEARCH
D.WDS:	TST	D.SVR2		; NUMBER TO SEARCH FOR?
;	BEQ	D.ERRE		; ERROR IF NOT
	BNE	1$
	JMP	D.ERR
1$:
	MOV	D.FWA,R2	; SET ORIGIN
D.WDS2:	.IF	NDF,D.KSR
	 TSTB	@#D.RCSR	; CHARACTER TYPED?
	 BMI	D.WDS6		; BRANCH IF SO
	.ENDC
	.IF	DF,D.KSR
	 JSR	PC,D.POLL	; CHECK FOR TYPED CHARACTER
	 CMP	D.INPU,D.OUTP	; ANY CHARACTERS IN BUFFER?
	 BNE	D.WDS6
	.ENDC
	CMP	R2,D.LWA	; IS THE SEARCH ALL DONE?
	BHI	D.WDS6		;  YES
	MOV	D.SVR4,R5	; GET NUMBER TO SEARCH FOR
	MOV	D.MASK,R4	; GET MASK
	COM	R4		; COMPLEMENT IT
	MOV	D.BW,-(SP)	; SAVE OLD BYTE FLAG
	MOV	#2,D.BW		;SET WORD MODE
	MOV	R2,D.CAD	;SAVE CURRENT ADDRESS
	JSR	PC,GETCAD	;LOAD CURRENT ADDR TO R0 IN ANY SPACE
	MOV	(SP)+,D.BW	;RESTORE BYTE/WORD FLAG TO OF YORE
;	MOV	(R2),R0		; GET OBJECT
;	MOV	R2,D.CAD	; THIS IS CURRENT ADDRESS
	BIC	R4,R0		; TURN OFF BITS NOT BEING SEARCHED FOR
	BIC	R4,R5		; TURN OFF BITS NOT BEING SEARCHED FOR
	MOV	R1,-(SP)	; STORE AND TEST
	BMI	D.WDS5		; BRANCH IF NON-SEARCH
	BGT	D.WDS7		; BRANCH IF EFFECTIVE SEARCH
	CMP	R0,R5		; EQUALITY?
D.WDS3:	BNE	D.WDS4		; RE-LOOP IF NO MATCH
D.WDS1:	JSR	PC,D.CRLF	; TYPE CRLF
	MOV	D.CAD,R0	; GET READY TO TYPE
	JSR	PC,D.RFND	; RELOCATE
D.SLST:	MOV	#'/,R0		; SLASH TO R0
	JSR	PC,D.TYPE	; TYPE IT
	JSR	PC,@D.CURM	; TYPE CONTENTS
D.WDS4:	MOV	(SP)+,R1	; RESTORE R1
	MOV	D.CAD,R2	; RESTORE R2
	TST	(R2)+		; INCREMENT TO NEXT CELL AND
	BR	D.WDS2		;    RETURN
D.WDS7:	MOV	#1,D.BOTH	; MARK NOTHING FOUND AND DON'T TYPE INSTRUCTION
	JSR	PC,D.INST	; "TYPE" THE INSTRUCTION
	DEC	D.BOTH		; ALLOW TYPEOUT AND TEST FOUND INDICATOR
D.WDS9:	BEQ	D.WDS4		; BRANCH IF NOT FOUND
	BR	D.WDS1		; BRANCH IF FOUND
D.WDS5:	CMP	R0,R5		; EQUALITY?
	BR	D.WDS9		; BRANCH TO DECIDE
D.WDS6:	RTS	PC		; RETURN


;PROCESS ? - RAD50 TYPEOUT

D.RDT1:	MOV	#D.RADC,D.OMOD	;SET RAD50 MODE
	BIC	#1,D.CAD	;FORCE EVEN ADDRESS!!
	JMP	D.WRD1		;GO TYPE OUT IN RAD50

; PROCESS H - HALF WORD TYPEOUT

D.INHA:	MOV	#1,D.BW		; SET HALF WORD MODE

; PROCESS C - SET NUMERIC TYPEOUT

D.INNM:	MOV	#D.CADV,D.CURM	; SET NUMERIC MODE
D.INN3:	MOV	D.CURM,D.OMOD	; SET LF AND ^ TYPEOUT MODE
D.INN2:	CMPB	D.ALTF,#2	; TWO ALTMODES TYPED?
	BLT	D.CRE1		; RETURN IF NOT
	MOV	#D.CURM,R0	; ADDRESS OF TEMPORARY TABLE
	MOV	#D.PERM,R1	; ADDRESS OF PERMANENT TABLE

D.SWAM:	MOV	#4,R2		; SWAP MODES: WORD COUNTER IN R2
D.SWA2:	MOV	(R0)+,(R1)+	; MOVE A WORD
	DEC	R2		; DECREMENT COUNTER
	BGT	D.SWA2		; LOOP TILL DONE
	RTS	PC		; RETURN

; PROCESS T - TEXT TYPEOUT

D.INTX:	MOV	#D.ASCI,D.CURM	; DEFAULT TO ASCII
	CMP	R4,#5		; RAD50?
	BNE	D.INN3		; RETURN IF NOT
	MOV	#D.RADC,D.CURM	; RAD50
	BR	D.INM1		; RETURN

; PROCESS O - BYTE TYPEOUT

D.BYTE:	MOV	#D.PART,D.CURM	; IN BYTE TYPEOUT MODE
	MOV	D.DECN,D.SIZE	; SET BYTE SIZE
	BR	D.INM1		; RETURN

; PROCESS S - INSTRUCTION TYPEOUT

D.INMD:	MOV	#D.INST,D.CURM	; IN INSTRUCTION MODE
D.INM1:	MOV	#2,D.BW		; MUST BE FULLWORD MODE
	BR	D.INN3		; RETURN

; PROCESS A - ABSOLUTE ADDRESS TYPEOUT

D.ABS:	MOV	#1,D.IFMT	; SET ABSOLUTE ADDRESSING
	BR	D.INN2		; RETURN

; PROCESS R - SET RADIX

D.INRD:	TST	R2		; RADIX SPECIFIED?
	BEQ	D.INR1		; BRANCH IF NOT
	CMP	D.DECN,#2	; MUST BE GREATER THAN 1
	BLT	D.ERRC		; BRANCH IF NOT
	MOV	D.DECN,D.DVTB	; ALWAYS DECIMAL RADIX
	BR	D.INN2		; RETURN
D.INR1:	CLR	D.IFMT		; TURN ON RELATIVE ADDRESSING
	BR	D.INN2		; RETURN

; PROCESS <CR> - CLOSE WORD AND RESET PERMANENT MODES

D.CRET:	JSR	PC,D.CLSE	; CLOSE LOCATION
	MOV	#D.PERM,R0	; ADDRESS OF PERMANENT TABLE
	MOV	#D.CURM,R1	; ADDRESS OF TEMPORARY TABLE
	JSR	PC,D.SWAM	; SWAP MODES
	MOV	D.CURM,D.OMOD	; SET LF AND ^ TYPEOUT MODE
D.CRE1:	JMP	D.DCD0		; RETURN

; PROCESS > - STORE LAST WORD ADDRESS FOR SEARCH

D.LWAS:	MOV	R4,D.LWA	; SET LAST WORD
	TST	R2		; ANY WORD THERE?
	BNE	D.CRE1		; BRANCH IF NOT
	MOV	#DDT-2,D.LWA	; SET HIGH LAST WORD
	BR	D.CRE1		; RETURN

; PROCESS B - SET AND REMOVE BREAKPOINTS

D.BKPT:	TST	D.SVR2		; DID HE GIVE A FIRST ARG?
	BEQ	D.BKP9
	ASL	R4		; MULTIPLY NUMBER BY TWO
	MOV	D.SVR4,R5	; GET FIRST NUMBER
	BEQ	D.BKP4		; REMOVE BREAK IF FIRST ARG 0
	TST	(R5)		; VALID ADDRESS? NXM IF NOT
	TST	R4		; SPECIFIC CELL REQUESTED?
	BNE	D.BKP1		; JUMP IF SO
	MOV	#2,R4
D.BKP3:	MOV	D.BKTB-2(R4),R0	; IS THIS CELL FREE?
	BEQ	D.BKP2		; JUMP IF YES
	CMP	R0,R5		; IS BREAK ALREADY SET FOR THIS ADDRESS?
	BEQ	D.BKP2		; BRANCH IF YES
	TST	(R4)+		; INCREMENT BY TWO
	CMP	R4,#D.BKP*2	; ARE WE AT THE END OF OUR ROPE?
	BLOS	D.BKP3		; NO, KEEP LOOKING
D.BKP1:	CMP	R4,#D.BKP*2	; REQUESTED NUMBER TOO LARGE?
	BHI	D.ERRC		; ERROR IF TOO LARGE
D.BKP2:	MOV	R5,D.BKTB-2(R4)	; SET BREAKPOINT
	.IF	DF,$BSXMU	;SPECIAL M/U BSX TYPE DEBUG
; READ BREAKPOINT INSTRUCTION NOW AND DO NOT READ AT STARTUP
; OF PROGRAM (ALLOWS SAME ROUTINE TO BE HANDLED BY MULTIPLE
; COPIES OF DDT)
	MOV	R0,-(SP)	;USE GETCAD TO LOAD INSTRUCTION
	MOV	D.BW,-(SP)
	MOV	D.CAD,-(SP)
	MOV	#2,D.BW		;GET A USER INST. WORD
	MOV	R5,D.CAD	;AT R5 ADDR
	JSR	PC,GETCAD	;GO GET IT
	MOV	R0,D.UIN-2(R4)	;SAVE INSTRUCTION
	MOV	(SP)+,D.CAD	;RESTORE SAVED CONTEXT
	MOV	(SP)+,D.BW
	MOV	(SP)+,R0
	.ENDC
	MOV	D.COMA,D.OPEN(R4) ; SET WORD TO OPEN AT BREAKPOINT
	CLR	D.CT(R4)	; SET CONTINUE COUNT
	CMPB	D.ALTF,#1	; TWO ALTMODES?
	BGT	D.BKP8		; BRANCH IF NOT
	INC	D.CT(R4)	; DO NOT SET AUTOMATIC PROCEDE
D.BKP8:	RTS	PC		; RETURN
D.BKP4:	TST	R2		; IF NO NUMBER WAS TYPED...
	BEQ	D.BKP6		; GO REMOVE ALL
	CMP	R4,#D.BKP*2	; WAS THE TYPED NUMBER VALID?
	BHI	D.ERRC		; JUMP IF NOT
	CLR	D.BKTB-2(R4)	; CLEAR BREAKPOINT
	RTS	PC		; RETURN
D.BKP5:	ASL	R4
D.BKP6:	MOV	#D.BKTB+<D.BKP*2>,R4
D.BKP7:	CLR	-(R4)
	CMP	R4,#D.BKTB
	BHI	D.BKP7
	RTS	PC		; RETURN
D.BKP9:	TST	R2
	BEQ	D.BKP5
	DEC	R4
	CMP	R4,#D.BKP	; WAS THE TYPED NUMBER VALID?
	BHIS	D.ERRC		; JUMP IF NOT
	ADD	#D.BKTB-2+1,R4
	BR	D.MAS2
D.ERRC:	JMP	D.ERR		; INTERMEDIATE HELP

; PROCESS M - TYPE AND SET MASK

D.MAST:	MOV	#D.MASK,-(SP)	; GET MASK
	TST	D.SVR2		; NUMBER THERE?
	BNE	D.MAS3		; BRANCH IF SO
D.MAS1:	MOV	(SP)+,R4	; ADDRESS TO OPEN
D.MAS2:	JSR	PC,@D.OPER	; COMBINE VALUE WITH CURRENT EXPRESSION
	INC	R2		; MARK A TYPED NUMBER
	JMP	D.DCD3		; CONTINUE SCANNING
D.MAS3:	MOV	D.SVR4,@(SP)+	; SET MASK
	RTS	PC		; RETURN

; PROCESS V - GET CONTENTS OF D.DOT SWABBED

D.ALTV:
	MOV	R0,-(SP)	;SAVE OLD R0
	MOV	D.BW,-(SP)
	MOV	D.CAD,-(SP)	;SAVE CONTEXT FOR GETCAD
	MOV	D.DOT,D.CAD	;COPY CURRENT ADDR
	MOV	#2,D.BW		;WORD MODE
	JSR	PC,GETCAD	;LOAD D.CAD CONTENT IN ANY SPACE
	MOV	R0,R4		;COPY DATA TO R4
	MOV	(SP)+,D.CAD
	MOV	(SP)+,D.BW
	MOV	(SP)+,R0	;RESTORE JUNK
;	MOV	@D.DOT,R4	; CONTENTS OF WORD
	SWAB	R4		; SWAB IT
	BR	D.MAS2		; RETURN

; PROCESS Q - GET CONTENTS OF D.DOT

D.ALTQ:
	MOV	R0,-(SP)	;SAVE OLD R0
	MOV	D.BW,-(SP)
	MOV	D.CAD,-(SP)	;SAVE CONTEXT FOR GETCAD
	MOV	D.DOT,D.CAD	;COPY CURRENT ADDR
	MOV	#2,D.BW		;WORD MODE
	JSR	PC,GETCAD	;LOAD D.CAD CONTENT IN ANY SPACE
	MOV	R0,R4		;COPY DATA TO R4
	MOV	(SP)+,D.CAD
	MOV	(SP)+,D.BW
	MOV	(SP)+,R0	;RESTORE JUNK
;	MOV	@D.DOT,R4	; CONTENTS OF WORD
	BR	D.MAS2		; RETURN

; PROCESS I - GET ADDRESS OF USER STATUS

D.ALTI:	MOV	#D.USTA,R4	; ADDRESS OF STATUS
	BR	D.MAS2		; RETURN

; PROCESS " - GET TEXT

D.TEXT:	JSR	PC,D.GET	; GET NEXT CHARACTER
	CLR	R2		; RAD50/ASCII INDICATOR
	CMP	R0,#33		; ALTMODE?
	BNE	D.TEX1		; BRANCH IF NOT
	INC	R2		; SET INDICATOR
	JSR	PC,D.GET	; GET NEXT CHARACTER
D.TEX1:	MOV	R1,R5		; DELIMETER (EXACT CHARACTER)
D.TEX2:	JSR	PC,D.GET	; GET CHARACTER
	CMP	R1,R5		; DELEMETER?
	BEQ	D.TEX3		; BRANCH IF SO
	MOV	R1,R0		; PUT IN ARGUMENT PLACE
	JSR	PC,D.PTSM	; PUT IN SYMBOL
	BR	D.TEX2		; LOOP
D.TEX3:	TST	R2		; ASCII?
	BNE	D.TEX4		; BRANCH IF NOT
	MOV	D.SYM,R4	; GET ASCII CHARACTERS
	BR	D.MAS2		; RETURN
D.TEX4:	MOV	#D.SYM,R0	; ADDRESS OF FIRST THREE CHARACTERS
	.IF DF,$VMEM
	MOV	PARMAP,-(SP)
	CLR	PARMAP
	.ENDC
	JSR	PC,D.RD50	; CONVERT TO RAD50
	.IIF DF,$VMEM, MOV (SP)+,PARMAP
	MOV	R0,R4		; NOW CURRENT VALUE
	BR	D.MAS2		; RETURN

; PROCESS <CALL> - SOFT RESTART

	.IF	DF,D.GDP
D.SOFT:	 MOV	#1004,R5	; ADDRESS OF SOFT RESTART
	 BR	D.GO3		; GO THERE
	.ENDC
;
; PROCESS ADDR<DATA$UP - PATCH FILE (WORDS) AND
;  ADDR<DATA$UH - PATCH FILE (BYTES)
	.IF	DF,$VMEM
	.IF	DF,$VPAT ;CONTITION THIS JUNK SO ONLY GET IT WHERE IT MAKES
			;SENSE FOR FILE STRUCTURE...
;
O.PATW:	MOV	D.BW,-(SP)	;SAVE OLD MODE
	MOV	#2,D.BW
	BR	O.PATC
O.PATB:	MOV	D.BW,-(SP)	;SAVE OLD MODE
	MOV	#1,D.BW		;SET BYTE PATCH MODE
O.PATC:				;COMMON CODE MERGED HERE
	MOV	R5,-(SP)	;SAVE REGS WE'LL USE
	MOV	R4,-(SP)
	MOV	R3,-(SP)	;
	MOV	R2,-(SP)
	MOV	R1,-(SP)
	MOV	R0,-(SP)
;D.FWA HAS ADDRESS TO PATCH IN VIRTUAL SPACE
;D.SVR4 HAS DATA
	MOV	D.FWA,R0	;FIRST TRANSLATE VIRTUAL ADDRESS TO PHYSICAL
	MOV	R0,R1		;COPY VIRTUAL ADDRESS
	BIT	#1,R1		;IS IT ODD? IF SO MUST BE BYTE ADDRESS
	BEQ	1$		;NO, HE SEEMS TO BE OK FOR EITHER
	MOV	#1,D.BW		;YES. ODD ADDRESSES ARE BYTES!
1$:	ASH	#-12.,R1	;GET PAR NUMBER
	BIC	#^C16,R1	;(SHIFTED OVER 1 AS WORDS.) REMOVE CRUFT.
	MOV	VKPAR0(R1),R2	;GET OUR VIRTUAL PAR MAP VALUE
	MOV	#6.,R5		;GET SHIFT COUNT
	CLR	R3		;INITIALIZE R3 FOR TOP PART OF WORD
2$:	ASL	R2		;SHIFT UP 6 PLACES IN R2,R3
	ROL	R3		;MOVE C BIT INTO R3
	DEC	R5		;DO LOOP
	BGT	2$		;BE SURE OF POSITIVITY
	BIC	#160000,R0	;MAKE R0 INTO OFFSET
	ADD	R0,R2		;ADD IN DISPLACEMENT IN BLOCK
	ADC	R3		;FIX UP HIGH ORDER
	MOV	R2,R0		;R0 GETS OFFSET WITHIN PATCH FILE BLOCK
	BIC	#177000,R0	;BY LEAVING ONLY BYTE WITHIN BLOCK OF
				;256. WORDS (RSX AND (MOSTLY) DOS STANDARD)
	MOV	#9.,R5		;NOW SHIFT THE ADDRESS DOWN TO GET A RELATIVE
				;BLOCK NUMBER
3$:	CLC			;GUARANTEE NO C BIT IN H.O
	ROR	R3		;DOWN WITH THE ADDR
	ROR	R2		;EACH LOOP SHIFTS 32 BITS DOWN 1
	DEC	R5		;DO 9 LOOPS ALL TOLD
	BGT	3$
;NOTE: ON BULK STORAGE, A BOOTSTRAP WILL NORMALLY OCCUPY BLOCK 0
;AND IT MAY BE OF UNKNOWN SIZE. THEREFORE ADD THE 32 BIT
;QUANTITY AT "D.BASE" (INITIALLY 0,1) TO THE BLOCK NUMBER IN R2,R3 NOW.
	ADD	D.BASE,R2		;ADD IN LOW 16 BITS
	ADC	R3		;ADD CARRY TO HIGH ORDER BLK NO.
	ADD	D.BASE+2,R3	;ADD HIGH ORDER D.BASE BLK NO.
;NOW HAVE DATA AT D.SVR4, AND H.O. BLK NO. AT R3, L.O. BLK NO. IN R2
;SO READ A BLOCK OF DATA INTO THE BUFFER AT D.PBUF.
	.MCALL	QIOW$S
	QIOW$S	#IO.RVB,#D.PLUN,#D.PEV,,#D.IOSP,,<#D.PBUF,#512.,,R3,R2>
;
;D.PBUF NOW HAS CONTENTS OF BLOCK WITH DATA DESIRED.
; PATCH IT NOW.
	BIT	#1,D.BW		;BYTE PATCH?
	BNE	4$		;YES, PATCH BYTES
	MOV	D.SVR4,D.PBUF(R0) ;NO, BASH DATA AS WORDS
	BR	5$
4$:	MOVB	R4,D.PBUF(R0)	;YES, BASH BYTES
5$:	QIOW$S	#IO.WVB,#D.PLUN,#D.PEV,,#D.IOSP,,<#D.PBUF,#512.,,R3,R2>
;	WRITE BUFFER BACK OUT
	MOV	(SP)+,R0
	MOV	(SP)+,R1
	MOV	(SP)+,R2
	MOV	(SP)+,R3
	MOV	(SP)+,R4
	MOV	(SP)+,R5	;RESTORE DDT REGS
	MOV	(SP)+,D.BW	;RESTORE BYTE/WORD MODE
	RTS	PC		;BACK TO CALLER
D.BASE::
	.WORD	1,0
D.PBUF:	.BLKW	256.
D.IOSP:	.WORD	0,0	;I/O STATUS BLK FOR QIO$
	.ENDC
	.ENDC

; PROCESS UF - FILL MACRO WITH TEXT
;
	.IF	DF,D.MCRO
D.UF:	MOV	R5,-(SP)
	MOV	R4,-(SP)
	MOV	R0,-(SP)
	CLR	D.CHSW		;ALWAYS FILL MACRO FROM CONSOLE
	; SYNTAX IS UF<DELIM>TEXT<DELIM>
	; WHERE DELIM IS ANY CHARACTER AND TEXT IS UP TO 80
	; BYTES LONG.
	JSR	PC,D.GET	;READ A CHARACTER AS DELIM.
	MOV	R0,R4		;SAVE IN R4
	MOV	#D.KBBF,R5	;POINT AT BUFFER TO FILL
1$:	JSR	PC,D.GET	;LOAD A CHARACTER
	CMP	R5,#D.KBBF+82.	;PAST LEGAL END?
	BHI	3$		;YES, SKIP IT
	CMP	R0,R4		;TERMINATOR CHARACTER?
	BEQ	3$		;YES, DONE
	MOVB	R0,(R5)+	;LOOKS OK TO FILL IN THIS ONE
	BR	1$		;GET ANOTHER.
3$:	MOVB	#-1,@R5		;STASH TERMINATOR FOR MACRO
	MOV	(SP)+,R0
	MOV	(SP)+,R4
	MOV	(SP)+,R5	;RESTORE REGS
	RTS	PC		;BACK TO WHEREVER...
	.ENDC
	.IF	DF,R$XMDB

;	PROCESS UL - LOOK UP RSX11M TASK AND MAP TO IT

D.UUL:
;	SYNTAX IS UL<DELIM>TASKNAME<DELIM>
;
	MOV	R0,-(SP)
	MOV	R1,-(SP)
	MOV	R2,-(SP)
	MOV	R3,-(SP)
	MOV	R4,-(SP)
	MOV	R5,-(SP)	;DBG11M BASHES ALL REGS...
	MOV	PARMAP,-(SP)
	CLR	PARMAP	;SET NO VIRTUAL MAPPING HERE
;
;	HERE READ IN THE TASK NAME WITH DELIMITERS...
;NOTE WE ONLY WILL BASH MAP IF HDRADR IS SET NONZERO ON RETURN
;FROM DBG11M
;
	JSR	PC,D.GET	;READ DELIMITER
	MOV	R0,R4		;SAVE IN R4
; 20040 = ASCII SPACE,SPACE
	MOV	#20040,D.TNAM
	MOV	#20040,D.TNAM+2	;CLEAR BUFFER OF OLD JUNK
	MOV	#20040,D.TNAM+4
	MOV	#D.TNAM,R5	;TEXT IN D.TNAM BUFFER
1$:	JSR	PC,D.GET	;GET A BYTE
	CMP	R5,#D.TNAM+5	;PAST LEGAL END?
	BHI	3$		;YES, BUG OUT
	CMP	R0,R4		;TERMINATOR?
	BEQ	3$		;YES, DONE
	MOVB	R0,(R5)+	;NO,SAVE CHARACTER
	BR	1$		;AND GET ANOTHER
3$:				;NOW CONVERT TO RAD50
	MOV	#D.TNAM,R0	;POINT AT 1ST 3 CHARS
	JSR	PC,D.RD50	;GET RAD50
	MOV	R0,D.RTNM	;SAVE 1ST 3 CHARS
	MOV	#D.TNAM+3,R0
	JSR	PC,D.RD50
	MOV	R0,R1		;SET TSK NAME
	MOV	R1,D.RTNM+2	;SAVE RAD50 NAME FOR DEBUGGING
	MOV	D.RTNM,R0	;INTO R0,R1
	JSR	PC,DBG11M	;CALL RSX LOOKUP PROGRAM
	TST	HDRADR		;DID IT FIND A HEADER IN CORE?
	BNE	7$		;IF YES, ALL WELL
	JMP	D.ERR		;ELSE TELL USER WE LOST!
7$:	MOV	#10,R0
	MOV	#TSKAPR,R1
	MOV	#VKPAR0,R2	;SET UP TO COPY APR INFO
10$:	MOV	(R1)+,(R2)+
	DEC	R0
	BGT	10$		;COPY ALL 8
	MOV	(SP)+,PARMAP	;STAY MAPPED IF WE WERE BEFORE...
	MOV	(SP)+,R5
	MOV	(SP)+,R4	;GET BACK REGS BASHED
	MOV	(SP)+,R3
	MOV	(SP)+,R2
	MOV	(SP)+,R1
	MOV	(SP)+,R0
	RTS	PC
D.TNAM:	.BLKW	4		;TASK NAME STORAGE (ASCII)
D.RTNM:	.BLKW	2		;RAD50 NAME SAVE
	.ENDC

; PROCESS G - GO

D.GO:	MOV	D.SVR4,R5	; GET STARTING ADDRESS
	TST	D.SVR2		; STARTING ADDRESS SPECIFIED?
	BNE	D.GO3		; IF NOT, USE USER SA
	MOV	JOBSA,R5	; GET STARTING ADDRESS
D.GO3:	TST	(R5)		; VALID ADDRESS? NXM IF NOT
	JSR	PC,D.CRLF
D.GO5:	TST	D.SD.T		; SHOULD THE T-BIT BE ON?
	BEQ	D.GO2		; BRANCH IF NO
D.GO4:	BIS	#20,D.USTA	; SET T-BIT
D.GO2:	MOV	R5,D.UR7
	JSR	PC,D.REST	; RESTORE REGISTERS
	MOV	D.USTA,-(SP)	;    AND STATUS
	MOV	D.UR7,-(SP)	;    AND PC
D.GO1:	RTI			; THIS IS "RTT" IF 11/40...

; PROCESS P - PROCEED 

D.PROC:	TST	R2		; CHECK FOR ILLEGAL COUNT
	BNE	D.ERRA		; JUMP IF ILLEGAL
	MOV	D.UR7,R5	; GET PC
	TST	(R5)		; VALID ADDRESS? NXM IF NOT
	MOVB	D.P,R0		; DID WE ENTER VIA A BREAK?
	BLT	D.PRO3		; NO, RETURN TO CALLER
	MOV	D.SVR4,R4	; GET COUNT
	TST	D.SVR2		; WAS COUNT SPECIFIED?
	BNE	D.PRO1		; NO
	MOV	#1,R4		; SET COUNT OF 1
D.PRO1:	CMPB	D.ALTF,#1	; AUTOMATIC PROCEDE?
	BLE	D.PRO6		; BRANCH IF NOT
	NEG	R4		; SET TO AUTOMATIC
D.PRO6:	MOV	R4,D.CT(R0)	; PUT AWAY COUNT
D.PRO7:	JSR	PC,D.CRLF	; CARRIAGE RETURN LINE FEED
D.PRO2:	INCB	D.T		; SET SPECIAL BIT TO 1
	MOV	R5,D.TPC	; SAVE PC FOR 11/40 KLUDGE
	BR	D.GO5
D.PRO3:	TST	D.SVR2		; COUNT SPECIFIED?
	BEQ	D.GO3		; NO, OK, RETURN TO CALLER OF DDT
D.ERRA:	JMP	D.ERR		; ELSE ERROR
D.PRO4:	TSTB	D.MACH		; 11/40,45?
	BEQ	D.PRO5		; NO, DON'T NEED TO KLUDGE
	CMP	R5,D.TPC	; DID WE NOT EXECUTE THE BROKEN INSTRUCTION?
	BEQ	D.GO4		; YES, TRY IT AGAIN
D.PRO5:	CLRB	D.T		; WE CAN CONTINUE NORMALLY
	TSTB	D.S		; UNLESS WE ARE SINGLE STEPPING
	BEQ	D.GO5
	BR	D.BRK2		; IN WHICH CASE WE BREAK IMMEDIATELY

; PROCESS X - EXECUTE INSTRUCTION

D.EXEC:	TST	D.SVR2		; ANY INSTRUCTION?
	BEQ	D.ERRA		; ERROR IF NOT
	.IF	NDF,$$RSX
	MOV	#D.SVR4,R5	; INSTRUCTION STARTING ADDRESS
	.IFF
	MOV	DDTODD,D.SVOD	;SAVE OLD ODD ADDRESS TRAP (MOD HERE A SEC)
	MOV	#D.XGO,R5	;FOR RSX, SPECIAL JUNK TO GET PSW
	.ENDC
	TST	D.PARO		; RELOCATE FIRST WORD?
	BEQ	D.EXE1		; BRANCH IF NOT
	SUB	#D.PARS+2,D.PARS; RELOCATE FIRST WORD
D.EXE1:	TST	D.PARO+2	; RELOCATE SECOOND WORD?
	BEQ	D.EXE3		; BRANCH IF NOT
	SUB	#D.PARS+4,D.PARS+2 ; RELOCATE SECOND WORD
D.EXE3:	MOV	D.UR7,D.SVR7	; SAVE PC
	BR	D.GO5		; EXECUTE INSTRUCTION

D.EXE2: .IIF NDF,$$RSX,	MOV	@#PS,D.USTA	; GET PS
	MOV	D.SVR7,D.UR7	; RESTORE CORRECT PC
	JSR	PC,D.SAVE	; SAVE ALL REGISTERS
	JMP	D.BRK8		; RETURN

; ERROR TRAPS

D.TRAV:	MOV	#D.TRA,D.ERF	; TRAP INSTRUCTION SERVICE
	.IIF DF, $$RSX, TST (SP)+ ;FLUSH EXTRA RSX WORD
	BR	D.BRK
D.EMTV:	MOV	#D.EMT,D.ERF	;EMT INSTRUCTION
	.IIF DF, $$RSX, TST (SP)+ ;FLUSH EXTRA RSX WORD
	BR	D.BRK
D.SEGV:	MOV	#D.SEG,D.ERF	;SEGMENT FAULT
	BR	D.BRK
D.IOTV:	MOV	#D.IOT,D.ERF	;IOT INSTRUCTION
	BR	D.BRK
D.NXMT:	MOV	#D.NM,D.ERF	; NXM TRAP SERVICE
	BR	D.BRK		; HANDLE BREAKPOINT
D.ILGT:	MOV	#D.IM,D.ERF	; ILLEGAL INSTRUCTION

	.IF	DF,$FORM$
	BR	D.BRK		; FALL THROUGH $X
D.FFPN:	MOVB	#1,D.S		; SET SINGLE MODE
	MOV	#1,D.CT		;SET PROCEED COUNT TO 1 FOR THIS INT
	INC	D.FFPC		; BUMP COUNT SAYING IN FORMATION INT.
; FALL THROUGH TO HANDLE BREAKPOINT AS IF SINGLE MODE...
;	N.B. D.REST BETTER RESTORE USER INSTRUCTIONS!
	.ENDC
; BREAKPOINT HANDLER

D.BRK:	MOV	(SP)+,D.UR7	; SAVE PC AND STATUS
	BIC	#20,(SP)	; TURN OFF T-BIT
	MOV	(SP)+,D.USTA	; SAVE PS
	JSR	PC,D.SAVE	; SAVE VARIOUS REGISTERS
	MOV	D.UR7,R5	; GET PC, IT POINTS TO THE INSTRUCTION
	TST	D.ERF		; TEST ADDRESS OF ERROR MESSAGE
	BNE	D.BRK7		; BRANCH IF ERROR
	TSTB	D.T		; WERE WE PROCEEDING AFTER A BREAK?
	BGT	D.PRO4		; YES, FIX IT UP
D.BRK2:	MOV	#D.BKP*2,R4	; GET A COUNTER
	TSTB	D.S		; DID WE ENTER VIA BPT?
	BNE	D.BRK3
	TST	-(R5)		; YES, BACK UP A WORD
D.BRK3:	CMP	R5,D.BKTB-2(R4)	; IS THIS THE BPT?
	BEQ	D.BRK4		; BRANCH IF YES
	SUB	#2,R4
	BHI	D.BRK3		; LOOP, UNLESS DONE
	TSTB	D.S		; SINGLE STEP MODE?
	BEQ	D.BRK6		; NO, WE SHOULDN'T HAVE BEEN CALLED.
D.BRK4:
	MOV	R5,D.UR7	; UPDATE THE PC, IF WE DECREMENTED IT
	MOVB	R4,D.P		; AND SET THE BREAKPOINT FLAG
	TST	D.CT(R4)	; AUTOMATIC PROCEDE?
	BMI	D.BRK9		; BRANCH IF GETTING THERE
	BEQ	D.BRKA		; BRANCH IF AUTOMATIC PROCEDE
	DEC	D.CT(R4)	; TEST REPEAT COUNT
	BLE	D.BRKC		; BRANCH IF NO REPEAT
D.BRKD:	JMP	D.PRO2		; PROCEDE
D.BRKC:	MOV	#1,D.CT(R4)	; RESET COUNT TO 1
D.BRKA:
	;NOTHING SPECIAL IS NEEDED FOR AUTO PROCEED ON SINGLE
	;INST. MODE EXCEPT ACCESS TO D.CT FOR REPEAT COUNT NEG.
	MOV	D.CT(R4),-(SP)	; SAVE COUNT
	ASR	R4		; FIX IT
	ADD	#'0,R4		; MAKE IT ASCII
	MOVB	R4,D.BMES+1	; PUT IN STRING
	JSR	PC,D.CRLF	; PREVENT OVERPRINTING
	MOV	#D.BMES,R4	; REST OF MESSAGE
	MOV	#D.BMES+6,R3	; END OF MESSAGE
	JSR	PC,D.STYP	; TYPE IT
	MOV	R5,R0		; GET ADDRESS OF BREAK
	MOV	R5,-(SP)	; AND SAVE IN CASE OF AUTO REPEAT
	JSR	PC,D.RFND	; RELOCATE
	MOVB	D.P,R4		; PROCEED ALLOWED?
	BMI	D.BRK8		; NO
	MOV	D.OPEN(R4),R0	; ANY WORD TO OPEN AT BREAKPOINT?
	BEQ	D.BRKB		; BRANCH IF NOT
	MOV	R0,D.DOT	; PUT IN CURRENT WORD
	JSR	PC,D.TTAB	; TYPE A TAB
	JSR	PC,D.OP3	; OPEN IT
D.BRKB:	MOV	(SP)+,R5	; RESTORE R5
	TST	(SP)+		; AUTOMATIC PROCEDE?
	BNE	D.BRK8		; RETURN IF NOT
	XX.XXX=0
	.IF	DF,$$RSX
	.IF	DF,XTCOM
	XX.XXX=1 ;OK TO TEST COMMON
	.ENDC
	.IFF	;NOT RSX
	XX.XXX=1 ;OK IF STAND ALONE
	.IFT
	.IF	EQ,MMM11	;IF RSX11D, WE CAN USE FULL DUPLEX
	XX.XXX=2 ;SPECIAL CROCK CODE FOR 11D MAPPED
	.ENDC
	.IF	DF,MV3.2 ;11M V3.2 MAY HAVE FULL DUPLEX TERMINAL FOR KROCK
	XX.XXX=2
	.ENDC
	.ENDC
	.IF	EQ,<XX.XXX-1>
	TSTB	@#D.RCSR	; CHARACTER TYPED?
	BMI	D.BRK8		; EXIT IF SO
	.ENDC
	.IF	EQ,<XX.XXX-2>
	.MCALL	RDAF$S
	MOV	R5,-(SP) ;IF CAN GET AWAY WITH EF 23 READ...
	SUB	#12,SP	;READ EV FLGS TO STACK
	MOV	SP,R5	;AVOID MORE Z ERRS
	RDAF$S	R5	;FLAGS TO STACK
	BIT	#100,2(R5)	;EVENT FLAG 23. SET?
	BEQ	1$	;IF SO, READIN OF KB OVER
	ADD	#12,SP	;ELSE NOT SO GO ON
	MOV	(SP)+,R5	;RESTORE R5 THEN
	BR	D.BRK8	;HERE READ WAS OVER SO STOP
1$:	ADD	#12,SP	;HERE READ STILL PENDS SO GO ON
	MOV	(SP)+,R5	;AFTER STACK FIXUP
	.ENDC
	JMP	D.PRO7		; CONTINUE BREAKPOINT
D.BRK9:
	TST	R4		; THIS THE SINGLE INST. BKPT?
	BNE	1$		; NO, NORMAL TREATMENT
	CMP	D.CT(R4),#-1	;-1 MEANS INFINITE REPEATS
	BEQ	D.BRKD		;SO JUST PROCEED & NEVER BREAK
1$:
	INC	D.CT(R4)	; COUNT 'EM OFF
	BMI	D.BRKD		; PROCEDE IF STILL NEGATIVE
	BR	D.BRKA		; DO THE BREAK
D.BRK6:	MOV	#D.BE,D.ERF	; ERROR: UNEXPECTED BREAK
D.BRK7:	MOV	D.UR7,R0	; GET ADDRESS OF BREAK
	JSR	PC,D.RFND	; RELOCATE
	MOV	D.ERF,R3	; GET CODE
	MOV	R3,R4		; OBTAIN END
	ADD	#4,R3		; BY ADDING 4 TO BEGIN
	JSR	PC,D.STYP	; TYPE MESSAGE
	CLR	D.ERF		; REMOVE TRACES OF THIS ENTRY
	MOVB	#-1,D.P		; DISALLOW PROCEED
	CLRB	D.T		; TURN OFF BIT
D.BRK8:	JMP	D.DCD		; RETURN

; CONVERT 3 ASCII CHARACTERS AT (R0) TO RAD50 WORD IN R0

D.RD50:	MOV	R2,-(SP)	; SAVE R2
	MOV	R5,-(SP)	; SAVE R5 AS SCRATCH
	MOV	R1,-(SP)	; SAVE R1 ALSO
	MOV	#-3,-(SP)	; CHARACTER LOOPER
	CLR	R2		; NOW CLEAR IT
D.RD51:	CLR	R1		; OFFSET OF CHARACTERS
	MOV	D.BW,-(SP)	;SAVE CONTENTS OF D.BW
	MOV	R0,-(SP)	;AND ADDR
	MOV	D.CAD,-(SP)	;AND CAD
	MOV	R0,D.CAD	;SET TO LOCATE CONTENT OF R0
	MOV	#1,D.BW		;BYTE MODE
	JSR	PC,GETCAD	;DO THE LOOKUP IN ANY SPACE
	MOV	R0,R5		;RESULT IN R0
	MOV	(SP)+,D.CAD
	MOV	(SP)+,R0
	MOV	(SP)+,D.BW
D.RD52:
	CMPB	D.RDTB(R1),R5	; CHARACTER MATCH?
	BEQ	D.RD53		; BRANCH IF SO
	INC	R1		; NEXT CHARACTER
	CMP	R1,#D.ENTB	; AT END OF TABLE
	BLT	D.RD52		; BRANCH IF NOT
D.ERRF:	JMP	D.ERR		; BAD CHARACTERS
D.RD53:	ASL	R2		; MULTIPLY BY 2
	ASL	R2		; MULTIPLY BY 4
	ASL	R2		; MULTIPLY BY 8
	MOV	R2,-(SP)	; STORE AWAY
	ASL	R2		; MULTIPLY BY 16
	ASL	R2		; MULTIPLY BY 32
	ADD	(SP)+,R2	; ADD 8X TO MAKE IT 40X
	ADD	R1,R2		; PUT IN NEW CHARACTER
	INC	R0		; POINT TO NEXT CHARACTER
	INC	(SP)		; INCREMENT LOOPER
	BMI	D.RD51		; BRANCH IF MORE
	TST	(SP)+		; RESET STACK
	MOV	R2,R0		; RESULT IN R0
	MOV	(SP)+,R1	; RESTORE R1
	MOV	(SP)+,R5
	MOV	(SP)+,R2	; RESTORE R2
	RTS	PC		; RETURN

; CONVERT RAD50 WORD IN R0 TO THREE ASCII CHARACTERS AT (R1)

D.CHAR:	MOV	R1,R3		; INDEX HERE SINCE D.DIVD WILL USE R1
	MOV	#1600.,R2	; OTHER OPERAND
	JSR	PC,D.DIVD	; DIVIDE THEM
	MOV	D.CAD,-(SP)
	MOV	D.BW,-(SP)
	MOV	R0,-(SP)
	MOV	R4,-(SP)	;SAVE ARGS
	MOV	#1,D.BW		;SET BYTE MODE
	MOV	R3,D.CAD	;SET OUT ADDRESS
	MOVB	D.RDTB(R0),R4	;GET DATA
	INC	R3		;BUMP R3
	JSR	PC,PUTCAD	;STASH THE DATA BYTE
	MOV	(SP)+,R4	;RESTORE R4
	MOV	(SP)+,R0	;AND R0
	MOV	(SP)+,D.BW
	MOV	(SP)+,D.CAD	;THEN GLOBAL VRBLS.
;	MOVB	D.RDTB(R0),(R3)+; MOVE A CHARACTER IN
	MOV	#40.,R2		; OPERAND
	MOV	R1,R0		; GET NEW NUMERATOR
	JSR	PC,D.DIVD	; DIVIDE THEM
	MOV	D.CAD,-(SP)
	MOV	D.BW,-(SP)
	MOV	R0,-(SP)
	MOV	R4,-(SP)	;SAVE ARGS
	MOV	#1,D.BW		;SET BYTE MODE
	MOV	R3,D.CAD	;SET OUT ADDRESS
	MOVB	D.RDTB(R0),R4	;GET DATA
	INC	R3		;BUMP R3
	JSR	PC,PUTCAD	;STASH THE DATA BYTE
	MOV	(SP)+,R4	;RESTORE R4
	MOV	(SP)+,R0	;AND R0
	MOV	(SP)+,D.BW
	MOV	(SP)+,D.CAD	;THEN GLOBAL VRBLS.
;	MOVB	D.RDTB(R0),(R3)+; MOVE ANOTHER CHARACTER IN
	MOV	D.CAD,-(SP)
	MOV	D.BW,-(SP)
	MOV	R0,-(SP)
	MOV	R4,-(SP)	;SAVE ARGS
	MOV	#1,D.BW		;SET BYTE MODE
	MOV	R3,D.CAD	;SET OUT ADDRESS
	MOVB	D.RDTB(R1),R4	;GET DATA
	INC	R3		;BUMP R3
	JSR	PC,PUTCAD	;STASH THE DATA BYTE
	MOV	(SP)+,R4	;RESTORE R4
	MOV	(SP)+,R0	;AND R0
	MOV	(SP)+,D.BW
	MOV	(SP)+,D.CAD	;THEN GLOBAL VRBLS.
;	MOVB	D.RDTB(R1),(R3)+; MOVE LAST CHARACTER IN
	MOV	R3,R1		; RESTORE FOR THE USER
	RTS	PC		; RETURN

; SAVE THE WORLD

	.IF	DF,$$RSX
D.ASTF:	.WORD	0	;AST DISABLED FLAG
	.ENDC
D.SAVE:	MOV	(SP)+,D.XXX	; PICK UP RETURN ADDRESS FROM STACK
	.IIF DF,$$RSX, MOV $DSW,DDTDSW ;SAVE DSW IF RSX VERSION
	.IIF DF,$$RSX, DSAR$S ;DISABLE AST RECOGNITION
	.IIF DF,$$RSX, MOV @#$DSW,D.ASTF
	.IF	NDF,DULMOD	; DULMOD DEFINED ALLOWS DDT TO RUN IN
				;KERNEL TO DEBUG USER MODE
	MOV	SP,D.UR6	; SAVE USER STACK ADDRESS
	.IFF
	MFPI	SP		; GET SP FROM OLD SPACE
	MOV	(SP)+,D.UR6	; GET USER SP FOR EXAMINING
	.ENDC
	MOV	#D.UR6,SP	; SET TO INTERNAL STACK
	MOV	R5,-(SP)	; SAVE
	MOV	R4,-(SP)	; REGISTERS
	MOV	R3,-(SP)	; 0
	MOV	R2,-(SP)	;  THRU
	MOV	R1,-(SP)	;      5
	MOV	R0,-(SP)	; HERE
	.IF	DF,D.GDP
	 TRAP	72		; USECLR
D.SAV9:	 NOP			; MAY HAVE USERET
	 TRAP	107		; SCRUNB
	.ENDC
	.IF	DF,$FORM$
	TST	D.FFPC		;SEE IF FORMATION INTERRUPT
	BNE	1$		;IF SO ALWAYS SAVE BREAKPOINTS
	.ENDC
	TST	D.SD.T		; TEST D.S AND D.T
	BNE	D.SAV3		; SKIP BREAKPOINTS IF SO
1$:	CLR	R4		; REMOVE ALL BREAKPOINTS
D.SAV1:	MOV	D.BKTB(R4),R5	; GET ADDRESS OF BREAKPOINT
	BEQ	D.SAV2		; BRANCH IF NOT FILLED
	.IF	NDF,DULMOD
	MOV	D.UIN(R4),(R5)	; RESTORE USER'S INSTRUCTION
	.IFF
	MOV	D.UIN(R4),-(SP)	;RESTORE...
	MTPI	(R5)		;...USER'S INSTRUCTION
	.ENDC
D.SAV2:	TST	(R4)+		; LOOP
	CMP	R4,#D.BKP*2	; AT END?
	BLT	D.SAV1		; RE-LOOP UNTIL DONE
D.SAV3:	MOV	#340,R1		; PS
	.IF	NDF,$$RSX
	MOV	#4,R0		; START FILLING AT WORD 4
	MOV	(R0),-(SP)	; 4
	MOV	#D.SAV5,(R0)+	; INTERNAL NXMS
	MOV	(R0),-(SP)	; 6
	MOV	R1,(R0)+	; SET VECTOR PS

	MOV	(R0),-(SP)	; 10
	MOV	#D.SAV5,(R0)+	; INTERRUPT FOR ILLEGAL INSTRUCTION
	MOV	(R0),-(SP)	; 12
	MOV	R1,(R0)+	; SET VECTOR PS

	MOV	#D.BRK,(R0)+	; BPT VECTOR
	MOV	R1,(R0)		; SET VECTOR PS
	MOV	@#D.RCSR,-(SP)	; SAVE KEYBOARD STATUS
	CLR	@#D.RCSR	; TURN OFF ALL INTERRUPTS
	.IF	DF,D.KSR
	 MOV	@#D.TCSR,-(SP)	; SAVE PRINTER STATUS
	 CLR	@#D.TCSR	; REMOVE ALL ENABLES
	.ENDC
	MOVB	#2,D.MACH	; SET MACHINE TO 11/45
	SXT	R1		; 11/40,45 INSTRUCTION
	CMPB	D.MACH,#1	; 11/15?
	BEQ	D.SAV4		; BRANCH IF NOT
	.IFTF
	.IF	NDF,$RSXM
	MOV	#RTT,D.GO1	; USE RTT INSTRUCTION
	.ENDC
	.IFT
D.SAV4:	TST	@#177772	; WORD ONLY EXISTS ON 11/45
	MOV	#D.ERR,@#4	; RESET NXM ADDRESS
	MOV	#D.ILGT,@#10	; ILLEGAL INSTRUCTION
	.IFF		;$$RSX DEFINED
	.IF	DF,XTCOM; IF EXTERNAL PAGE COMMON
	MOV	@#D.RCSR,-(SP);SAVE KBD CSR7S
	CLR	@#D.RCSR
	MOV	@#D.TCSR,-(SP)
	.ENDC
	MOVB	#2,D.MACH ;SET 11/45 STANDARD CPU TYPE.
	.IIF DF,$RSXM, MOVB #0,D.MACH ;SET 11/05 IF RSX11M UNMAPPED
	.IIF DF,$RSXMM, MOVB #1,D.MACH ;SET 11/40 IF MAPPED
	.ENDC
	.IF	DF,$$RSX
;SET INTERNAL ERROR FORMS
	SVDB$S	#D.TINS,#11	;SET INTERNAL DEBUG TRAPS
	.ENDC
	JMP	@D.XXX		;RETURN TO CALLER
	.IF	DF,$$RSX
D.TINS:	.WORD	D.ERR		;INTERNAL DDT TRAPS
	.REPT	8.
	.WORD	D.ERR
	.ENDR
DDTODD:	.WORD	D.NXMT		;ODD ADDRESS ERROR TRAPPER
	.WORD	D.SEGV		;SEGMENT FAULT
	.WORD	D.BRK		;BPT OR T-BIT SET
DDTIOT:	.WORD	D.IOTV	;IOT INSTRUCTION
DDTRES:	.WORD	D.ILGT	;ILLEGAL INSTRUCTION
DDTEMT:	.WORD	D.EMTV	;NON-RSX EMT
DDTTRP:
	.IF	NDF,MSX11D
	.WORD	D.TRAV	;TRAP INSTRUCTION
	.IFF
	.WORD	0
	.ENDC
DDTFPP:	.WORD	D.ILGT	;11/40 FPP FAULT
	.WORD	D.SEGV	;MEMORY PARITY ERROR
	.WORD	0	;SAFETY WORD
;END OF SST TABLE USED FOR RSX DDT SST VECTORING.
	.IF	EQ,MMM11
	.MCALL	RDEF$S,CLEF$S,SETF$S	;READ/CLR/SET SINGLE EVENT FLAGS
	.IFF
	.MCALL	CLEF$S,SETF$S
	.ENDC
	.ENDC
;	JMP	@D.XXX		; RETURN

D.SAV5:	DECB	D.MACH		; IT FAILED, DIFFERENT MACHINE
	RTI			; RETURN

; RESTORE THE WORLD AS WE FOUND IT

D.REST:	MOV	(SP)+,D.XXX	; GET RETURN ADDRESS FROM STACK
	TST	D.SD.T		; TEST D.S AND D.T
	BNE	D.RES3		; SKIP BREAKPOINTS IF SO
	MOV	#<D.BKP*2>-2,R4	; RESTORE ALL BREAKPOINTS
D.RES1:	MOV	D.BKTB(R4),R5	; GET ADDRESS OF BREAKPOINT
	BEQ	D.RES2		; BRANCH IF NO BREAKPOINT
	.IF	NDF,DULMOD
	MOV	(R5),D.UIN(R4)	; SAVE CONTENTS OF USER LOCATION
	MOV	#BPT,(R5)	; PUT BREAKPOINT THERE
	.IFF
	.IF	NDF,$BSXMU	;IF BKPT SET DIDNT SAVE INST DO HERE
	MFPI	(R5)
	MOV	(SP)+,D.UIN(R4)	;SAVE USER'S INSTRUCTION
	.ENDC
	MOV	#BPT,-(SP)	;SHOVE BPT THERE
	MTPI	(R5)
	.ENDC
D.RES2:	SUB	#2,R4		; DECREMENT
	BGE	D.RES1		; RE-LOOP UNTIL DONE
D.RES3:	MOV	#D.STK,SP	; SET STACK POINTER TO BASE
	.IF	NDF,$$RSX
.IIF DF,D.KSR,MOV (SP)+,@#D.TCSR; PUT TELETYPE STATUS BACK
	MOV	(SP)+,@#D.RCSR	; PUT KEYBOARD STATUS BACK
	MOV	#12,R0		; RESTORE HIS VECTORS
	MOV	(SP)+,(R0)	; 12
	MOV	(SP)+,-(R0)	; 10
	MOV	(SP)+,-(R0)	; 6
	MOV	(SP)+,-(R0)	; 4
	.ENDC
	.IF	DF,$$RSX
	.IF	DF,XTCOM
	MOV	(SP)+,@#D.TCSR
	MOV	(SP)+,@#D.RCSR
	.ENDC
	.ENDC
; WE DO NOT ALTER SST TABLE FOR RSX, SO NO SAVE/RESTORE
;OF VECTORS IS NEEDED OR DESIRABLE.
.IIF DF,D.GDP,TRAP 144		; USERET
	MOV	(SP)+,R0	; RESTORE
	MOV	(SP)+,R1	; USER
	MOV	(SP)+,R2	; REGISTERS
	MOV	(SP)+,R3	;  0
	MOV	(SP)+,R4	;  THRU
	MOV	(SP)+,R5	;    5
	.IF	NDF,DULMOD
	MOV	(SP),SP		; RESTORE USER STACK
	.IFF
	MOV	(SP),-(SP)	; GET STACK
	MTPI	SP		;AND SAVE IN USER STACK
	.ENDC
	.IF	DF,$$RSX
	SVDB$S	#DDTODD,#11	; SET PROGRAM TYPE TRAP CATCHER
	TSTB	D.ASTF		; ANY AST'S DISABLED?
	BMI	10$		; IF NOT, LEAVE THEM ALONE
	ENAR$S			; IF SO, TURN THEM BACK ON
10$:
	.ENDC
	.IIF	DF,$$RSX, MOV DDTDSW,@#$DSW ;RESTORE DSW IF IN RSX
	JMP	@D.XXX		; AND RETURN

; TYPE R0 IN ADDRESS FORM

D.RFND:	MOV	R1,-(SP)	; SAVE R1
	MOV	R0,-(SP)	; SAVE ADDRESS FOR LATER
	CMP	R0,D.SVR4	; IS IT THE ADDRESS WE ARE LOOKING FOR?
	BNE	D.RFN2		; BRANCH IF NOT
	INCB	D.FIND		; MARK IT FOUND
D.RFN2:	TST	D.IFMT		; ABSOLUTE ADDRESSING?
	BNE	D.RFN7		; BRANCH IF SO
	JSR	PC,D.GTSM	; GET SYMBOL (IF ANY)
	TST	R1		; ANY SYMBOL?
	BNE	D.RFN8		; BRANCH IF SO
	CMP	4(SP),#D.SLST	;COME FROM SEARCH ROUTINE?
	BNE	D.RFN7		;NO, DON'T DO ANYTHING UNUSUAL
	TST	D.IFMT		;SEE IF NEGATIVE (PSEUDO-ASSEMBLY MODE)
	BMI	D.RFN1		;IF SO, FORGET THIS STUFF
	BR	D.RFN7
D.RFN8:				;CONTINUE IF FOUND SYMBOL
;	BEQ	D.RFN7		; BRANCH IF NOT
	MOV	R0,-(SP)	; SAVE OFFSET VALUE
	MOV	#6,-(SP)	; REPEAT COUNT
D.RFN5:	MOVB	(R1)+,R0	; GET CHARACTER
	CMPB	R0,#40		; IS IT A BLANK?
	BEQ	D.RFN6		; DONE IF SO
	JSR	PC,D.TYPE	; TYPE IT
	DEC	(SP)		; DECREMENT COUNT
	BGT	D.RFN5		; LOOP IF MORE
D.RFN6:	TST	(SP)+		; RESET STACK
	MOV	(SP)+,R1	; GET OFFSET
	BEQ	D.RFN1		; BRANCH IF NONE
	MOV	#'+,R0		; MAKE A PLUS
	JSR	PC,D.TYPE	; TYPE IT
	MOV	R1,R0		; GET OFFSET
D.RFN7:	JSR	PC,D.TYPN	; TYPE THE NUMBER
D.RFN1:	MOV	(SP),D.LASW	; LAST TYPED WORD
	MOV	(SP)+,D.LASV	; LAST TYPED ADDRESS
	MOV	(SP)+,R1	; RESTORE R1
	RTS	PC		; RETURN

; CLOSE WORD OR BYTE

D.CLSE:	TST	R2		; IF NO NUMBER WAS TYPED THERE IS
	BEQ	D.CLS1		; NOTHING TO CLOSE
	CMP	D.CAD,#177776	; ANY OPEN WORD?
	BEQ	D.CLS1		; BRANCH IF NOT
	CLR	D.LFIN		; NO LINE FEED INCREMENT
	CMP	#1,D.BW		; BYTE MODE?
	BEQ	D.CLS2		; JUMP IF BYTE MODE
	MOV	D.CAD,R2	; WORD ADDRESS
	MOV	R0,-(SP)	;SAVE R0 AROUND CALL TO PUTCAD
	ADD	#2,R2		;"AUTOINCREMENT" R2
	JSR	PC,PUTCAD	;STASH DATA IN R4 AT D.CAD
	MOV	(SP)+,R0	;BACK WITH R0
;	MOV	R4,(R2)+	; STORE VALUE
	MOV	R2,R4		; PUT INTO R4 FOR COMPUTATION
	SUB	D.CADC,R4	; SUBTRACT COPY
	BGT	D.CLS1		; BRANCH IF NO MORE
	MOV	#2,D.LFIN	; LINE FEED INCREMENT
;	MOV	D.PARS,(R2)	; MOVE ANOTHER WORD (2 OR 3 WORD INST)
;	SUB	D.PARO,(R2)+	; RELOCATE WORD
	MOV	R4,-(SP)
	MOV	D.PARS,R4	;MAKE DATA UP IN R4
	SUB	D.PARO,R4
	MOV	D.CAD,-(SP)	;SAVE D.CAD
	MOV	R0,-(SP)	;ALSO R0
	MOV	R2,D.CAD	;SAVE ADDR
	JSR	PC,PUTCAD
	ADD	#2,R2
	MOV	(SP)+,R0
	MOV	(SP)+,D.CAD
	MOV	(SP)+,R4	;BACK WITH DATA
	TST	R4		; THIRD PARAMETER?
	BEQ	D.CLS1		; BRANCH IF NOT
	MOV	#4,D.LFIN	; LINE FEED INCREMENT
	MOV	R4,-(SP)
	MOV	D.PARS+2,R4	;MAKE DATA UP IN R4
	SUB	D.PARO+2,R4
	MOV	D.CAD,-(SP)	;SAVE D.CAD
	MOV	R0,-(SP)	;ALSO R0
	MOV	R2,D.CAD	;SAVE ADDR
	JSR	PC,PUTCAD
	MOV	(SP)+,R0
	MOV	(SP)+,D.CAD
	MOV	(SP)+,R4	;BACK WITH DATA
;	MOV	D.PARS+2,(R2)	; PUT THIRD WORD IN
;	SUB	D.PARO+2,(R2)	; RELOCATE WORD
	BR	D.CLS1		; FINISH UP
D.CLS2:
	MOV	R0,-(SP)
	JSR	PC,PUTCAD	;STORE BYTE IN R4 AT D.CAD
	MOV	(SP)+,R0	;RESTORE R0
;	MOVB	R4,@D.CAD	; STORE BYTE
D.CLS1:	MOV	#177776,D.CAD	; CLOSE WORD
	RTS	PC		; RETURN

; SUBROUTINE TO TYPE @D.CAD IN NUMBER FORM

D.CADV:	CMP	#1,D.BW		; BYTE MODE?
	BEQ	D.CAD1		; BRANCH IF SO
	JSR	PC,GETCAD	; GET OPERAND.
;	MOV	@D.CAD,R0	; GET OPERAND
	JSR	PC,D.RFND	; TYPE NUMBER
	BR	D.ASC2		; RETURN
D.CAD1:
	JSR	PC,GETCAD	; GET OPERAND
;	MOVB	@D.CAD,R0	; GET OPERAND
	BIC	#177400,R0	; CLEAR HIGH BITS
	JSR	PC,D.TYPN	; TYPE IT
	BR	D.ASC2		; RETURN

; SUBROUTINE TO TYPE @D.CAD IN ASCII FORM

D.ASCI:	MOV	D.CAD,R5	; GET ADDRESS
	MOV	D.BW,-(SP)
	MOV	#1,D.BW
	JSR	PC,GETCAD	;LOAD BYTE
	MOV	(SP)+,D.BW
	INC	R5
;	MOVB	(R5)+,R0	; GET FIRST CHARACTER
	BIC	#177400,R0	; CLEAR HIGH BITS
	MOV	R0,D.LASV	; LAST TYPED DATA
	MOV	R0,D.LASW	; LAST TYPED WORD TOO
	JSR	PC,D.TYPE	; TYPE IT
	MOV	D.BW,-(SP)
	MOV	D.CAD,-(SP)
	MOV	#1,D.BW
	MOV	R5,D.CAD
	JSR	PC,GETCAD
	MOV	(SP)+,D.CAD
	MOV	(SP)+,D.BW	;GET BYTE
;	MOVB	(R5),R0		; GET NEXT CHARACTER
	ROR	R5		; EXAMINE LOW BIT
	BCC	D.ASC2		; BRANCH IF CLEAR
	JSR	PC,D.TYPE	; TYPE IT
D.ASC3:
	MOV	D.BW,-(SP)	; SAVE BYTE/WORD FLAG
	MOV	R0,-(SP)	;ALSO SAVE R0
	MOV	#2,D.BW		;SET TO LOAD WORD
	JSR	PC,GETCAD	;LOAD TO R0
	MOV	R0,D.LASV
	MOV	R0,D.LASW	;SAVE DATA
	MOV	(SP)+,R0
	MOV	(SP)+,D.BW	;RESTORE OLD STUFF
;	MOV	@D.CAD,D.LASV	; LAST TYPED DATA
;	MOV	@D.CAD,D.LASW	; LAST TYPED WORD TOO
D.ASC2:	CLR	D.LFIN		; TURN OFF LINE-FEED SKIPPING
D.RTS:	RTS	PC		; RETURN

; SUBROUTINE TO TYPE @D.CAD IN MULTI-BYTE FORM

D.PART:
	MOV	D.BW,-(SP)	;SAVE BYTE/WORD
	MOV	R0,-(SP)
	MOV	#2,D.BW
	JSR	PC,GETCAD	;GET CURRENTLY ADDRESSED WORD
	MOV	R0,R5		;INTO R5
	MOV	(SP)+,R0
	MOV	(SP)+,D.BW	;RESTORE D.BW
;	MOV	@D.CAD,R5	; GET WORD
	MOV	#16.,-(SP)	; BIT COUNT
D.PAR5:	MOV	R5,R0		; ACCUMULATOR FOR BYTE
	MOV	#177777,R3	; MASK FOR BYTE
	MOV	D.SIZE,R2	; BYTE SIZE
D.PAR1:	ASR	R5		; REMOVE ONE BIT
	ASL	R3		; ONE MORE BIT IN MASK
	DEC	(SP)		; ONE LESS BIT IN WORD
	BLE	D.PAR2		; EXIT IF DONE
	DEC	R2		; ONE LESS BIT IN BYTE
	BGT	D.PAR1		; LOOP IF NOT DONE
D.PAR2:	BIC	R3,R0		; MASK WORD
	JSR	PC,D.TYPN	; TYPE BYTE
	TST	(SP)		; ALL DONE?
	BLE	D.PAR4		; BRANCH IF SO
	MOV	#',,R0		; COMMA
	JSR	PC,D.TYPE	; TYPE IT
	BR	D.PAR5		; GET NEXT BYTE
D.PAR4:	TST	(SP)+		; FIX STACK
	BR	D.ASC3		; RETURN

; SUBROUTINE TO TYPE @D.CAD IN RAD50 FORM

D.RADC:
	MOV	D.BW,-(SP)
	MOV	#2,D.BW
	JSR	PC,GETCAD	;GET @D.CAD TO R0 IN ANY SPACE
	MOV	(SP)+,D.BW
;	MOV	@D.CAD,R0	; PUT VALUE IN R0
	MOV	#D.SYM,R1	; ADDRESS FOR RESULT
	.IIF DF,$VMEM, MOV PARMAP,-(SP) ;NO VIRTUAL MAP HERE
	.IIF DF,$VMEM, CLR PARMAP
	JSR	PC,D.CHAR	; MAKE CHARACTERS OF IT
	.IIF DF,$VMEM,MOV (SP)+,PARMAP
	MOV	#D.SYM,R4	; ADDRESS OF FIRST CHARACTER
	MOV	#D.SYM+2,R3	; ADDRESS OF LAST CHARACTER
	JSR	PC,D.STYP	; TYPE THEM
	BR	D.ASC3		; DONE

; SUBROUTINE TO TYPE @D.CAD IN INSTRUCTION FORMAT

D.INST:	MOV	D.CAD,R5	; PUT CURRENT ADDRESS INTO DECODE
	JSR	PC,D.TTAB	; TYPE TAB
	JSR	PC,D.DC49	; DECODE IT
	SUB	D.CAD,R5	; GET INSTRUCTION LENGTH
	TST	-(R5)		; DECREMENT TO BE OFFSET OF INSTR
	CMP	D.DOT,D.CAD	; ARE WE AT THE DOT?
	BNE	D.INS2		; DON'T SET INCREMENT IF NOT
	MOV	R5,D.LFIN	; PUT IN LINE-FEED INCREMENT
D.INS2:	ASR	R5		; DIVIDE BY TWO
	BEQ	D.INS4		; BRANCH IF NOT ZERO
	ADD	#'1,R5		; ASCIIZE
	MOVB	R5,D.WAMS+1	; FILL IN NUMBER OF WORDS
	MOV	#D.WAMS,R4	; BEGIN WARNING MESSAGE
	MOV	#D.WAMS+7,R3	; END WARNING MESSAGE
	JSR	PC,D.TTAB	; TYPE A TAB
	JSR	PC,D.STYP	; TYPE IT
D.INS4:
	MOV	D.BW,-(SP)
	MOV	R0,-(SP)
	MOV	#2,D.BW
	JSR	PC,GETCAD	;GET @D.CAD
	MOV	R0,D.LASW
	MOV	(SP)+,R0
	MOV	(SP)+,D.BW
;	MOV	@D.CAD,D.LASW	; LAST TYPED WORD
	RTS	PC		; RETURN

; GET A CHARACTER INTO R0

D.GET:
	.IF	DF,D.MCRO	;IF CORE BUFFER MAY BE USED ALLOW THIS
	TST	D.CHSW		;USING CORE BUFFER?
	BEQ	1$		;NO, SKIP TO NORMAL CONSOLE IN
	MOV	#-1,D.KBFE	;ENSURE WE TERMINATE THE READ SOMETIME
	MOVB	@D.KBPT,R0	;LOAD CHAR. FROM BUFFER INTO R0
	INC	D.KBPT
	TST	R0		;SEE WHAT WE GOT IF ANYTHING
	BMI	3$		;IF AT END SKIP OUT
	BEQ	D.GET		;IGNORE NULLS
	TST	D.ECSW		;ECHOING THIS STUFF?
	BEQ	2$		;NO, SKIP ECHO
	JSR	PC,D.TYPE	;YES, ECHO IT
2$:	RTS	PC		;SCRAM IF HERE
3$:	CLR	D.CHSW		;NOT CORE IN NOW...
	MOV	#D.KBBF,D.KBPT	;RESET IN POINTER
1$:	;NORMAL COMMANDS HERE
	.ENDC
	.IF	NDF,D.KSR
	 TSTB	@#D.RCSR	; CHARACTER TYPED?
	 BPL	D.GET		; LOOP UNTIL FOUND
	 MOVB	@#D.RDB,R0	; GET A CHARACTER
	.ENDC
	.IF	DF,D.KSR
	 JSR	PC,D.POLL	; CHECK FOR CHARACTERS IN I/O BUFFER
;
;FOR RSX11 "NORMAL" I/O, ISSUE A WAIT HERE TO LET OTHER
;TASKS HAVE THE CPU UNTIL I/O DONE.
	.IF	NDF,XTCOM
	.IF	DF,$$RSX
	WTSE$S	#23.		;USE E.F. #23. AS I/O SEMAPHORE FOR INPUT
	CMPB	TIOST,#IE.EOF	; CHECK INPUT FOR CTL-Z
	BNE	17$		; IF NOT SKIP OUT
	JMP	RSXEXT		; IF SO, LEAVE...
17$:
	.ENDC
	.ENDC
	 CMP	D.INPU,D.OUTP	; ANY CHARACTERS TYPED?
	 BEQ	D.GET		; LOOP IF BUFFER EMPTY
	 MOVB	@D.OUTP,R0	; GET CHARACTER FROM BUFFER
	 INC	D.OUTP		; POINT TO NEXT CHARACTER
	 CMP	D.OUTP,#D.ENDB	; AT END OF BUFFER?
	 BNE	D.GET9		; BRANCH IF NOT
	 MOV	#D.BUFR,D.OUTP	; WRAP-AROUND
D.GET9:	.ENDC
.IIF DF,D.GDP,TRAP	64	; KEYASC
	BIC	#177600,R0	; CLEAR META, CNTL AND SHIFT STUFF
	MOV	R0,R1		; EXACT (UNFOLDED COPY IN R1)
	BEQ	D.GET		; IGNORE NULLS
	CMPB	R0,#15		; SEE IF A <CR>
	BNE	D.GET2		; BRANCH IF NOT
	MOV	#12,R0		; LINE FEED
	JSR	PC,D.TYPE	; TYPE IT
	MOV	#15,R0		; RESET TO CR
D.GET2:	CMPB	R0,#177		; IS IT A BACKSPACE
	BEQ	D.GET5		; GUARANTEED TO GET A ?
	CMP	R0,#12		; IS IT A LINE FEED?
	BEQ	D.GET1		; IF SO, SAVE THE PAPER
	CMPB	R0,#33		; IS IT AN ESCAPE?
	BEQ	D.GET4		; TYPE DOLLAR SIGN IF SO
	.IF	DF,D.KSR
	 CMPB	R0,#175		; IS IT AN ALTMODE?
	 BGE	D.GET4		; TYPE DOLLAR SIGN IF SO
	.ENDC
	.IF	DF,$$RSX
	.IF	DF,XTCOM
	JSR	PC,D.TYPE
	.ENDC
	.ENDC
	.IF	NDF,$$RSX
	JSR	PC,D.TYPE	; ECHO CHARACTER
	.ENDC
	CMPB	#'a,R0		; FOLD TO UPPER CASE
	BGT	D.GET1		; BRANCH IF NOT A LETTER
	CMPB	#'z,R0		; IS IT IN ALPHABET?
	BLT	D.GET1		; BRANCH IF STILL NOT
	SUB	#'a-'A,R0	; FOLD DOWN
D.GET1:	RTS	PC		; RETURN
D.GET4:	MOV	#'$,R0		; DOLLAR SIGN
	JSR	PC,D.TYPE	; TYPE IT
	MOV	#33,R0		; RESTORE R0
	RTS	PC		; RETURN
D.GET5:	MOV	#'X,R0		; TYPE "XXX"
	JSR	PC,D.TYPE	; TYPE FIRST
	JSR	PC,D.TYPE	; TYPE SECOND
	JMP	D.ERRO		; JUMP TO LAST
	.IF	DF,D.KSR
;
; RSX11 DDT-- DO I/O BY QIO$S INTO SHORT BUFFER HERE.USE 2 WORDS
; AS FLAGS, 1 THAT I/O IS IN PROGRESS AND ANOTHER THAT SERVES
; AS TEMPORARY BUFFER. EVENTUALLY PUT THESE INTO SEPARATE PSECT FROM CODE.
	.IF	NDF,XTCOM
	.IF	DF,$$RSX
TOOST:	.WORD	0,0
TIOST:	.WORD	0,0	;I/O STATUS BLOCK
TIOFLG:	.WORD	0	;0==>NO I/O GOING, >0 ==>I/O UNDERWAY
TIBUF:	.WORD	0	;I/O "BUFFER"
D.POLL:			;ENTRY FOR READING OR TRYING TO READ CHARS
	TST	TIOFLG	;I/O BEGUN?
	BNE	1$	;YES
	MOV	#1,TIOFLG	;NO, BEGIN IT NOW
	CLR	TIOST
	QIO$S	#IO.RAL,#D.INLU,#23.,,#TIOST,,<#TIBUF,#1,#0>
;STARTS UP I/O ON LUN 6, EVENT FLG 23.
1$:
	;NOW SEE IF I/O ALREADY DONE
	.IIF DF,$RSXM,RSX11M=0
	.IIF DF,$RSXMM,RSX11M=0
	.IF	NDF,RSX11M	;RSX11D/IAS VERSION
	RDEF$S	#23.	;SEE IF FLAG SET (READ EVENT FLAG)
	TSTB	@#$DSW	;SEE IF 0 OR 2
;IF 0, FLAG NOT SET--JUST EXIT. IF 2, GET DATA.
	BLE	D.POL1	;IF 0 (OR NEGATIVE) KEEP WAITING
	.IFF ;RSX11M VERSION
	WTSE$S	#23.	;WAIT FOR EVENT FLAG
	.ENDC
	BICB	#200,TIBUF	;SET 7 BIT ASCII ONLY
	MOVB	TIBUF,@D.INPU	;SAVE DATA
	CLR	TIOFLG	;SET NO MORE I/O GOING
2$:
	.ENDC
	.ENDC
	.IF	DF,$$RSX
	.IF	DF,XTCOM
D.POLL:	TSTB	@#D.RCSR
	BPL	D.POL1
	MOVB	@#D.RDB,@D.INPU
	.ENDC
	.ENDC
	.IF	NDF,$$RSX
D.POLL:	 TSTB	@#D.RCSR	; ANY CHARACTER TYPED?
	 BPL	D.POL1		; BRANCH IF NOT
	 MOVB	@#D.RDB,@D.INPU	; PUT CHARACTER IN BUFFER
	.ENDC
	.IF	DF,$$DOS
	.IF	NDF,TTYASR
	MOVB	@D.INPU,-(SP)	;PREPARE...
	BIC	#177600,@SP	;...ELABORATE PARITY CALCULATION
	CMPB	(SP)+,#3	;TEST FOR CTL-C
	BEQ	D.POL2		;GO TO DOS IF SO...
	.ENDC
	.ENDC
	 INC	D.INPU		; NEXT
	 CMP	D.INPU,#D.ENDB	; AT END OF BUFFER?
	 BNE	D.POL1		; BRANCH IF NOT
	 MOV	#D.BUFR,D.INPU	; WRAP-AROUND
D.POL1:	 RTS	PC		; RETURN
	.IF	DF,$$DOS
	.IF	NDF,TTYASR
D.POL2:	MOV	D.UR6,SP	;RESTORE USER STACK
	CLR	-(SP)
	CLC			;INPUT INTERRUPT
	MOV	#D.POL3,-(SP)	;SETUP LOOP WHILE DOS WORKS
	MOVB	#200,@#-2	;SPL 4
	BIS	#100,@#D.RCSR	;INPUT INTERRUPT ON
	MOV	@#60,PC		;GO TO DOS SVC. ROUTINE
D.POL3:	BR	D.POL3
	.ENDC
	.ENDC
	.ENDC

; TYPE A TAB

D.TTAB:
.IIF	NDF,D.KSR,MOV	#11,R0	; TAB
	.IF	DF,D.KSR
	 TSTB	D.NOTY		; IN NON-TYPEOUT MODE?
	 BNE	D.TYP8		; EXIT IF SO
	 MOV	#40,R0		; SPACE
	 JSR	PC,D.TYPE	; TYPE IT
	 BITB	#7,D.CPOS	; ON A MULTIPLE OF 8?
	 BNE	D.TTAB		; LOOP ON SPACES IF NOT
	 RTS	PC		; RETURN
	.ENDC

; TYPE THE CHARACTER IN R0

D.TYPE:	TSTB	D.NOTY		; SHOULD WE TYPE?
	BNE	D.TYP8		; BRANCH IF NOT
.IIF	DF,D.GDP,TRAP	120	; SCRRTN
.IIF	DF,D.GT40,EMT	0
	.IF	DF,D.KSR
	CMPB	#33,R0		; WAS THIS AN ESCAPE? (DON'T TYPE ESCAPES)
	BNE	17$		;NO, NORMAL
	MOVB	#'$,R0		; ECHO AS DOLLAR SIGN
	JSR	PC,D.TYP3	;PRINT THE DOLLAR SIGN
	MOV	#33,R0		;REPLACE THE ESCAPE
	BR	18$
17$:
	 JSR	PC,D.TYP3	; TYPE CHARACTER
18$:	 CMPB	R0,#15		; CARRIAGE RETURN?
	 BEQ	D.TYP2		; ZERO POSITION COUNTER IF SO
	 BITB	#140,R0		; CONTROL CHARACTER?
	 BEQ	D.TYP1		; RETURN IF SO
         CMPB   R0,#12		; LINE FEED? **** NEW/ GCE ***
	 BEQ    D.TYP2		; YES, RESET CHAR. POSITION. **** NEW/ GCE ***
	 DECB	D.CPOS		; INCREMENT CHARACTER POSITION
	 BPL	D.TYP1		; RETURN IF NOT
	 MOV	R0,-(SP)	; SAVE CHARACTER
	 MOV	#15,R0		; YES, GENERATE CARRIAGE RETURN
	 JSR	PC,D.TYP3	; TYPE IT
	 MOV	#12,R0		; AND A LINE FEED
	 JSR	PC,D.TYP3	; TYPE IT
	 MOV	(SP)+,R0	; RESTORE CHARACTER
D.TYP2:	 MOVB	#71.,D.CPOS	; CLEAR CHARACTER POSITION
D.TYP1:	 RTS	PC		; RETURN
	.IF	NDF,$$RSX
D.TYP3:	 TSTB	@#D.TCSR	; PRINTER READY FOR CHARACTER?
	 BPL	D.TYP3		; LOOP IF NOT
	 MOVB	R0,@#D.TDB	; PUT OUT CHARACTER
	.IFF
D.TYP3:
	.IF	DF,XTCOM
	TSTB	@#D.TCSR
	BPL	D.TYP3
	MOVB	R0,@#D.TDB
	.ENDC
	.IF	NDF,XTCOM
;ISSUE I/O VIA RSX HANDLER USING LUN 5, E.F. #22.
	MOVB	R0,TIBUF+1	;USE 2ND BYTE OF INPUT WORD AS BUFFER
	BICB	#200,TIBUF+1
	CLR	TOOST
	CMPB	TIBUF+1,#33	;THIS AN ESCAPE? (NO TYPE THEN)
	BNE	14$
	MOVB	#'$,TIBUF+1	;SPECIAL ECHO ESC AS DOLLAR SIGN
14$:	QIO$S	#IO.WAL,#D.OUTU,#22.,,#TOOST,,<#TIBUF+1,#1,#0>
	WTSE$S	#22.		;JUST DO I/O AND WAIT ONCE PER CHAR
	.ENDC
	.ENDC
	.IF	NDF,$$RSX	;DON'T NEED THIS WHERE RSX HAS TYPE-AHEAD
	 JSR	PC,D.POLL	; CHECK FOR TYPED-IN CHARACTERS
	.ENDC
	.ENDC
D.TYP8:	RTS	PC		; RETURN

; TYPE CARRIAGE RETURN LINE FEED

D.CRLF:	MOV	#D.CR+1,R3	; LWA <CR,LF>
	MOV	#D.CR,R4	; FWA

; TYPE A STRING STARTING AT R4 AND ENDING AT R3

D.STYP:	CMP	R3,R4		; CHECK FOR COMPLETION
	BHIS	1$
	JMP	D.GET1		; EXIT WHEN DONE
1$:
	MOVB	(R4)+,R0	; GET A CHARACTER
	JSR	PC,D.TYPE	; TYPE ONE CHARACTER
	BR	D.STYP		; LOOP UNTIL DONE

; SUBROUTINE TO TYPE R0 IN CURRENT RADIX

D.TYPN:	MOV	R0,D.LASV	; MARK LAST NUMBER TYPED
	MOV	R0,D.LASW	; LAST TYPED WORD TOO
	MOV	D.DVTB,R2	; GET RADIX
	CMP	R2,#10.		; DECIMAL?
	BEQ	D.TYP4		; YES
D.TYP5:	JSR	PC,D.DIVD	; DIVIDE IT.
	ADD	#60,R1		; CONVERT REMAINDER TO ASCII
	MOV	R1,-(SP)	; AND SAVE IT.
	TST	R0		; DONE?
	BEQ	D.TYP7		; YES, TYPE THE DIGIT AND RETURN
D.TYP6:	JSR	PC,D.TYP5	; CALL OURSELF RECURSIVELY
D.TYP7:	MOV	(SP)+,R0	; RESTORE THE DIGIT
	BR	D.TYPE		; PRINT IT, AND RETURN

D.TYP4:	MOV	#'.,-(SP)	; PUT A . AT THE END OF THE NUMBER
	MOV	R0,R3		; GET THE NUMBER
	BPL	D.TYP6		; AND TYPE IF POSITIVE
	MOV	#'-,R0		; ELSE PRINT A -
	JSR	PC,D.TYPE
	MOV	R3,R0		; RESTORE NUMBER
	NEG	R0		; BUT TAKE ABSOLUTE VALUE
	BR	D.TYP6

; DIVISION ROUTINE - R1 (HIGH) AND R0 (LOW)/R2=R0 REMAINDER R1

D.DIVD:	MOV	#16.,-(SP)	; SHIFT COUNT
	CLR	R1		; ASSUME NO HIGH PART
D.DIV1:	ASL	R0		; DOUBLE PRECISON SHIFT
	ROL	R1
	CMP	R2,R1		; WILL DIVISOR GO IN?
	BHI	D.DIV2
	SUB	R2,R1
	INC	R0
D.DIV2:	DEC	(SP)
	BGT	D.DIV1		; SOB?
	TST	(SP)+
	RTS	PC

; TYPE WORD(S) AT R5 IN INSTRUCTION FORMAT

D.DC49:
	MOV	D.BW,-(SP)
	MOV	D.CAD,-(SP)
	MOV	#2,D.BW		;USE GETCAD TO FIND INSTRUCTION
	MOV	R5,D.CAD	;
	JSR	PC,GETCAD
	MOV	(SP)+,D.CAD
	ADD	#2,R5
	MOV	(SP)+,D.BW
;	MOV	(R5)+,R0	; GET INSTRUCTION INTO R0
	MOV	#D.TOPS+2,R1	; POINT TO ARRAY OF INSTRUCTION VALUES
	MOV	R0,R4		; SAVE INSTRUCTION
	CLR	R3		; DON'T TYPE A "B"
	BIC	#100000,R0	; START OUT LOOKING FOR INS. WITHOUT "B"
D.LOOP:	CMP	R0,(R1)+	; DOES INSTRUCTION FALL IN HERE?
	BHI	D.LOOP		; NO, LOOP
	CMP	R4,R0		; DID WE GET REAL INSTRUCTION MATCH?
	BEQ	D.FOUN		; YES
	MOV	R4,R0		; NO, BUT DO SO NEXT TIME
	TSTB	D.LEGS-D.TOPS-4(R1)	; BYTE INSTRUCTION?
	BPL	D.LOOP		; NO!
	DEC	R3		; PRINT A  "B"
D.FOUN:	MOVB	D.LEGS-D.TOPS-4(R1),R2	; GET LEGAL CONSIDERATION BYTE
	BIC	#177774,R2	; CLEAR HIGH BITS
	CMPB	R2,D.MACH	; MACHINE TYPE RIGHT?
	BGT	D.N16		; TYPE NUMBER IF BAD
	ADD	#D.COUS-D.TOPS-4,R1	; ADD IN ADDRESS OF STRING
	MOV	(R1)+,R2	; GET OFFSET OF CHARACTERS
	BIC	#177400,R2	; TURN OFF EXTRA CRUFT
D.DC6:	CMPB	R2,(R1)		; AT END?
	BEQ	D.DC3		; BRANCH IF SO
	MOVB	D.STRS(R2),R0	; GET A CHARACTER
	JSR	PC,D.TYPE	; TYPE IT
	INC	R2		; NEXT CHARACTER
	BR	D.DC6		; LOOP
D.DC3:	TST	R3		; BYTE INSTRUCTION?
	BEQ	D.DONE		; BRANCH IF NOT
	MOV	#'B,R0		; BYTE INSTRUCTION: TYPE "B"
	JSR	PC,D.TYPE	; TYPE IT
D.DONE:	MOVB	-(R1),R3	; RE-GET LEGALITY BYTE
	BIC	#177703,R3	; GET LEGAL CONSIDERATION
	CMP	R3,#10		; TYPE A SPACE AFTER OP-CODE?
	BLE	D.NOBL		; BRANCH IF NOT
	MOV	#' ,R0		; SPACE
	JSR	PC,D.TYPE	; TYPE IT
D.NOBL:	MOV	R4,R0		; GET INSTRUCTION BACK
	ASL	R4		; GET OPERAND THAT STARTS AT BIT 6
	ASL	R4		; WITH TWO SHIFTS AND...
	SWAB	R4		; A SWAB
	ASR	R3
	JMP	@D.PARM(R3)	; TYPE PARAMETERS

D.DC7:	MOV	R0,R1		; GET R1 FOR D.DC5
	ADD	#D.MOD7,R1	; DISPLACEMENT OF OPENING CHARACTERS
	MOVB	(R1),R2		; GET OFFSET OF CHARACTERS
	CMPB	D.FIRS(R2),#'?	; IS IT LEGAL?
	BEQ	D.DC50		; BRANCH IF NOT
	JSR	PC,D.DC5	; TYPE THEM
;	CMP	R0,#6		; RELATIVE ADDRESSING?
	MOV	R0,-(SP)	; SAVE R0 FOR REL ADDRESSING CHK
	MOV	D.BW,-(SP)
	MOV	D.CAD,-(SP)
	MOV	#2,D.BW		;USE GETCAD TO FIND INSTRUCTION
	MOV	R5,D.CAD	;
	JSR	PC,GETCAD
	MOV	(SP)+,D.CAD
	ADD	#2,R5
	MOV	(SP)+,D.BW
;	MOV	(R5)+,R0	; NOTE THAT THIS LEAVES CARRY ALONE
	CMP	(SP)+,#6	; RELATIVE ADDRESSING?
	BCS	D.N16		; BRANCH IF IMMEDIATE
D.N17:	ADD	R5,R0		; FUDGE FOR RELATIVE.
D.N16:	JMP	D.RFND		; TYPE IN CURRENT ADDRESSING MODE

D.SSDD:	MOV	R0,-(SP)	; SAVE SECOND PARAMETER
	MOV	R4,R0		; GET FIRST ONE
	JSR	PC,D.DD		; TYPE IT
	BR	D.SS		; DO THE REST
D.CZVN:	MOV	#D.NZVC,R1	; LOOP ON BITS OF CODE
	MOV	R0,R2		; SAVE OPERATION IN R2
	JSR	PC,(PC)		; DO WHAT FOLLOWS TWICE
	JSR	PC,(PC)		; NO, I MEAN 4 TIMES
	MOVB	(R1)+,R0	; GET CHARACTER
	ROR	R2		; TEST A BIT
	BCC	D.RTS2		; BRANCH IF NOT ON
	JMP	D.TYPE		; TYPE IT AND RETURN

D.N3:	BIC	#177770,R0	; MASK OUT ALL BUT LOW 3 BITS
D.N6:	BIC	#177700,R0	; MASK OUT ALL BUT LOW 6 BITS
D.N8:	BIC	#177400,R0	; MASK OUT ALL BUT LOW 8 BITS
	JMP	D.TYPN		; TYPE THE NUMBER
D.RN6:	MOV	R0,-(SP)	; SAVE R0
	MOV	R4,R0		; GET FIRST PARAMETER
	JSR	PC,D.R		; TYPE AS REGISTER
	MOV	#',,R0		; INSERT COMMA BETWEEN PARAMETERS
	JSR	PC,D.TYPE	; TYPE IT
	MOV	(SP)+,R0	; GET SECOND PARAMETER
	BIS	#300,R0		; TURN ON HIGH TWO BITS IN LOW BYTE
D.X8:	MOVB	R0,R0		; SIGN EXTEND
	ASL	R0		; MULTIPLY BY 2
	BR	D.N17		; DO THE REST AND RETURN
D.RDD:	MOV	R0,-(SP)	; SAVE SECOND PARAMETER
	MOV	R4,R0		; GET FIRST ONE
	JSR	PC,D.R		; TYPE AS A REGISTER
D.SS:	MOV	#',,R0		; PUT COMMA...
	JSR	PC,D.TYPE	; ... INBETWEEN PARAMETERS
	MOV	(SP)+,R0	; GET SECOND PARAMETER

D.DD:				; THIS ROUTINE TYPES A MODE/REGISTER OPERAND IN R0
	MOV	R0,R3		; LOW 6 BITS OF R0 HAVE MODE/REG
	BIC	#177770,R3	; R3 HAS REGISTER
	ASR	R0		; GET MODE
	ASR	R0		; BY SHIFTING
	ASR	R0		; INTO LOW BITS
	BIC	#177770,R0	; R0 HAS MODE
	CMP	R3,#7		; PC ADDRESSING?
	BEQ	D.DC7		; BRANCH IF SO
D.DC50:	MOV	R0,-(SP)	; MAKE THIS SAVED DATA
	MOV	R0,R1		; PUT IN R1 FOR D.DC5
	ADD	#D.OPCH,R1	; ADD IN DISPLACEMENT OF SPECIAL CHARACTERS
	JSR	PC,D.DC5	; TYPE PRECEDING CHARACTERS
	MOV	R3,-(SP)	; SAVE R3
	CMP	R0,#6		; IS THERE AN INDEX?
	BLT	D.DC8		; BRANCH IF NOT
	MOV	D.BW,-(SP)
	MOV	D.CAD,-(SP)
	MOV	#2,D.BW		;USE GETCAD TO FIND INSTRUCTION
	MOV	R5,D.CAD	;
	JSR	PC,GETCAD
	MOV	(SP)+,D.CAD
	ADD	#2,R5
	MOV	(SP)+,D.BW
;	MOV	(R5)+,R0	; PUT ADDRESS IN R0
	JSR	PC,D.RFND	; TYPE ADDRESS AND OFFSET
	MOV	#'(,R0		; PUT "(" IN OUTPUT
	JSR	PC,D.TYPE	; TYPE IT
D.DC8:	MOV	(SP)+,R0	; GET REGISTER
	JSR	PC,D.R		; TYPE REGISTER NUMBER
	MOV	(SP)+,R1	; RESTORE MODE
	ADD	#D.CLOS,R1	; ADD IN CLOSING CHARACTERS

D.DC5:				; THIS ROUTINE TYPES A STRING INDEXED BY R1
	MOV	R0,-(SP)	; SAVE R0
	MOVB	(R1)+,R2	; GET OFFSET OF CHARACTERS
D.DC62:	MOVB	D.FIRS(R2),R0	; GET CHARACTER
	BEQ	D.DC4		; SKIP IF NULL CHARACTER
	JSR	PC,D.TYPE	; TYPE IT
D.DC4:	INC	R2		; NEXT CHARACTER
	CMPB	R2,(R1)		; AT END?
	BLO	D.DC62		; BRANCH IF NOT
	MOV	(SP)+,R0	; RETURN R0
D.RTS2:	RTS	PC		; RETURN

D.DDR:	MOV	R4,-(SP)	; SAVE FIRST PARAMETER
	JSR	PC,D.DD		; TYPE SECOND PARAMETER
	MOV	#',,R0		; COMMA
	JSR	PC,D.TYPE	; TYPE IT
	MOV	(SP)+,R0	; RESTORE REGISTER

D.R:				; THIS ROUTINE TYPES A REGISTER
	BIC	#177770,R0	; CLEAR HIGH BITS
	CMP	R0,#6		; R5 OR LOWER?
	BLO	D.DC9		; BRANCH IF SO
	BHI	D.DC19		; BRANCH IF PC
	MOV	#D.SP,R1	; "SP"
	BR	D.DC5		; TYPE IT AND RETURN

D.DC19:	MOV	#D.SP+1,R1	; "PC"
	BR	D.DC5		; TYPE IT AND RETURN
D.DC9:	MOV	R0,-(SP)	; SAVE R0
	MOV	#'R,R0		; "R"
	JSR	PC,D.TYPE	; TYPE IT
	MOV	(SP)+,R0	; RESTORE R0
	ADD	#60,R0		; ASCIIZE IT
	JMP	D.TYPE		; TYPE IT AND RETURN
	.IF	DF,R$XMDB	;RSX11M DEBUGGING
;	.TITLE	DBG11M
	;ROUTINE TO LOAD RSX11M DEBUGGING INFORMATION INTO DDT
;
;	OPERATION:
;		THIS ROUTINE IS PASSED THE RAD50 TASK NAME OF A TASK
;THAT IS ASSUMED TO BE SOMEWHERE IN MEMORY. THE TASK IN WHICH THIS
;ROUTINE RUNS IS ASSUMED TO HAVE ACCESS TO THE I/O PAGE ON THE PDP11
;AND WILL HAVE TO BE LINKED WITH THE RSX11M SYMBOL TABLE TO WORK.
;	IT WILL LOOK UP THE TASK ON THE SYSTEM TASK LIST AND RETURN
;THE HEADER ADDRESS AND WILL COMPUTE THE TASK'S APR VALUES USING THE
;WINDOWS IN KERNEL SPACE. THESE WILL BE RETURNED IN GLOBAL LOCATIONS
;HDRADR (FOR THE HEADER) AND TSKAPR (AN 8 WORD ARRAY, FOR APRS 0-7).
;
;	ENTRY TASK NAME IS ASSUMED TO BE IN R0,R1
;	ALL REGISTERS ARE DESTROYED HEREIN...
;
;	GLENN C. EVERHART
;	VIII JUNE  MDCCCCLXXVIIII
;
;
	.GLOBL	HDRADR,TSKAPR
HDRADR:	.WORD	0	;TASK HEADER ADDRESS 9WHEN WE FIND IT
TSKAPR:	.WORD	0,0,0,0,0,0,0,0	;TASL'S COMPUTED APRS
	.WORD	0,0	;GUARDS...
	.GLOBL	DBG11M
;CALL:
;	SET 1ST 3 CHARS OF TASKNAME (RAD50) INTO R0
;	SET 2ND 3 CHARS OF TASKNAME (RAD50) INTO R1
;	JSR PC,DBG11M
;
DBG11M:
;
;	MUST GO TO PRIO 7 DURING ALL THIS TO PREVENT ANY CONTEXT
;SWITCHES
	MOV	@#PS,-(SP)	;SAVE PSW FIRST
	MOV	#140340,@#PS	;SET PRI 7, PREVIOUS KERNEL MODE
;NOW THE FUN PART TO FIND STUFF IN RSX. SET UP A MACRO TO
;MAKE IT A LITTLE EASIER TO READ
	.MACRO	KMOV	SRC,DST
	MFPI	SRC
	MOV	(SP)+,DST	;ALWAYS MOVE FROM KERNEL...
	.ENDM
	KMOV	$ACTHD,R2	;GET ATL HEADER IN R2
	;
	CLR	HDRADR		;HDRADR = 0 ON RETURN IF NO TASK
1$:	TST	R2		;BE SURE NOT AT END OF ATL
	BEQ	2$		;SKIP IF SO
	KMOV	T.NAM+2(R2),R3	;GET 2ND 3 CHARS OF TSK NAME
	CMP	R3,R1	;COMPARE WITH THE ONE WE WANT
	BNE	3$		;IF NOT THERE GET NEXT
	KMOV	T.NAM(R2),R3	;IF 2ND 3 OK TRY 1ST
	CMP	R3,R0	;CHECK
	BNE	3$		;IF NE THEN NOT OUR TASK
	BR	4$		;AT THIS POINT WE HAVE OUR TSK SO PROCESS
3$:	KMOV	T.ACTL(R2),R2	;GET NEXT LIST ELEMENT (OR 0)
	BR	1$		;GO BACK, TRY AGAIN
4$:
;HERE HAVE FOUND THE DESIRED TASK
	;NOTE THAT R2 NOW HOLDS THE TCB OF THE TASK WE WANT
;	R0 AND R1 ARE NOW FREE
;	(CONFOUNDED RSX11M LISTS ARE HARD TO TRACK DOWN...
; LOOKS LIKE TCB POINTS TO PCB POINTS TO TASK HEADER POINTS TO
; WINDOW BLOCKS WHICH ARE WHAT WE NOW NEED...)
	KMOV	T.PCB(R2),R0	;DE TCB CONNECTS TO DE PCB...
	KMOV	P.HDR(R0),R1	;..DE PCB CONNECTS TO DE HEADER..
	MOV	R1,HDRADR	;SAVE TASK HEADER ADDRESS FOR CALLER
	KMOV	H.WND(R1),R3	;GET WINDOW BLOCK ADDRESES
	KMOV	(R3)+,R4	;R4 = NUMBER OF WINDOWS NOW
;R3 NOW POINTS TO THE FIRST WINDOW BLOCK.
;	TO FIND THE PAR NUMBERS WE WILL CHEAT AND USE THE
;PDR ADDRESS AND NUMBER OF PDR'S. SINCE THERE IS ONE PAR PER PDR
;AND THE PHYSICAL MEMORY START IS IN THE WINDOW BLOCK, WE HAVE
;ALL THAT WE NEED...
10$:	KMOV	W.BFPD(R3),R1	;FIRST PDR ADDRESS
	MOVB	R1,R2		;(1ST PDR ADDR=BYTE)
	BIS	#177600,R2	;(GUARANTEE RANGE IS OK)
	SWAB	R1		;GET # OF PDRS (=> # APRS)
	BIC	#177770,R1	;ZAP HI BYTE OF JUNK
	BEQ	16$		;SKIP PAST FILLIN IF NO APRS TO FILL
	SUB	#177600,R2	;SUBTRACT OFFSET TO USER I PDR 0
	BLT	2$		;NEGATIVE # HERE IS BAD NEWS
	BIC	#177761,R2	;FORCE R2 TO BE LEGAL ALWAYS
	KMOV	W.BOFF(R3),R5	;GET NUMBER FOR FIRST PAR
11$:	KMOV	W.BPCB(R3),R0	;GET PCB ADDRESS OF WINDOW
	MFPI	P.REL(R0)	;GET BASE OF PRTTN
	ADD	(SP)+,R5	;FORM APR CONTENT FOR WINDOW START
12$:	MOV	R5,TSKAPR(R2)	;FILL IN APR NUMBER
	TST	(R2)+		;PASS THAT APR NUMBER
	BIC	#177761,R2	;BE SURE R2 STAYS IN BOUNDS...
	ADD	#200,R5		;BUMP PHYS ADDR
	DEC	R1		;BE SURE NOT DONE ALL
	BGT	12$		;IF DONE, SAY SO
16$:	ADD	#W.BLGH,R3	;PASS THIS WINDOW BLOCK
	DEC	R4
	BGT	10$		;DO ALL WINDOWS
2$:
	MOV	(SP)+,@#PS	;RESTORE ORIGINAL PSW
	RTS	PC
	.ENDC	;R$XMDB

; INSTRUCTION DECODE/ENCODE TABLE

	.MACRO	INSTRS
; THE FIVE PARAMETERS TO THE CODE OP-CODE DESCRIBE AN INSTRUCTION:
; THE FIRST PARAMETER IS THE LOWER LIMIT OF VALUES THAT WILL FALL
;  INTO THAT OP-CODE (THE TABLE MUST BE SCANNED SEQUENTIALLY)
; THE SECOND PARAMETER IS THE OP-CODE TEXT
; THE THIRD PARAMETER TELLS THE MACHINE SUITABILITY
;  0 MEANS ANY MACHINE HAS THIS INSTRUCTION.  1 MEANS
;  11/40 AND UP ONLY, 2 MEANS 11/45 ONLY.
; THE FOURTH PARAMETER TELLS HOW TO DECODE THE PARAMETERS:
;   0 MEANS NO PARAMETERS
;   1 MEANS "NNNNNN" (16 BIT NUMBER)
;   2 MEANS DECODE CONDITION CODE BITS (NZVC)
;   3 MEANS "N" (3 BIT NUMBER)
;   4 MEANS "XXX" (8 BIT DISPLACEMENT)
;   5 MEANS "R,DD"
;   6 MEANS "NN" (6 BIT NUMBER)
;   7 MEANS "SS,DD" (OR "DD,SS")
;  10 MEANS "R"
;  11 MEANS "R,NN" (6 BIT DISPLACEMENT)
;  12 MEANS "NNN" (8 BIT NUMBER)
;  13 MEANS "DD" (OR "SS")
;  14 MEANS "SS,R"
; THE FIFTH PARAMETER IS 1 IF THIS INSTRUCTION IS LEGAL IN BYTE MODE
	CODE	0,HALT,0,0,0
	CODE	1,WAIT,0,0,0
	CODE	2,RTI,0,0,0
	CODE	3,BPT,0,0,0
	CODE	4,IOT,0,0,0
	CODE	5,RESET,0,0,0
	CODE	6,RTT,1,0,0
	CODE	7,,0,1,0
	CODE	100,JMP,0,13,0
	CODE	200,RTS,0,10,0
	CODE	210,,0,1,0
	CODE	230,SPL,2,3,0
	CODE	240,NOP,0,0,0
	CODE	241,CL,0,2,0
	CODE	257,CCC,0,0,0
	CODE	260,,0,1,0
	CODE	261,SE,0,2,0
	CODE	277,SCC,0,0,0
	CODE	300,SWAB,0,13,0
	CODE	400,BR,0,4,0
	CODE	1000,BNE,0,4,0
	CODE	1400,BEQ,0,4,0
	CODE	2000,BGE,0,4,0
	CODE	2400,BLT,0,4,0
	CODE	3000,BGT,0,4,0
	CODE	3400,BLE,0,4,0
	CODE	4000,JSR,0,5,0
	CODE	5000,CLR,0,13,1
	CODE	5100,COM,0,13,1
	CODE	5200,INC,0,13,1
	CODE	5300,DEC,0,13,1
	CODE	5400,NEG,0,13,1
	CODE	5500,ADC,0,13,1
	CODE	5600,SBC,0,13,1
	CODE	5700,TST,0,13,1
	CODE	6000,ROR,0,13,1
	CODE	6100,ROL,0,13,1
	CODE	6200,ASR,0,13,1
	CODE	6300,ASL,0,13,1
	CODE	6400,MARK,1,6,0
	CODE	6500,MFPI,1,13,0
	CODE	6600,MTPI,1,13,0
	CODE	6700,SXT,1,13,0
	CODE	7000,,0,1,0
	CODE	10000,MOV,0,7,1
	CODE	20000,CMP,0,7,1
	CODE	30000,BIT,0,7,1
	CODE	40000,BIC,0,7,1
	CODE	50000,BIS,0,7,1
	CODE	60000,ADD,0,7,0
	CODE	70000,MUL,1,14,0
	CODE	71000,DIV,1,14,0
	CODE	72000,ASH,1,14,0
	CODE	73000,ASHC,1,14,0
	CODE	74000,XOR,1,5,0
	CODE	75000,FADD,1,10,0
	CODE	75010,FSUB,1,10,0
	CODE	75020,FMUL,1,10,0
	CODE	75030,FDIV,1,10,0
	CODE	75040,,0,1,0
	CODE	77000,SOB,1,11,0
	CODE	100000,BPL,0,4,0
	CODE	100400,BMI,0,4,0
	CODE	101000,BHI,0,4,0
	CODE	101400,BLOS,0,4,0
	CODE	102000,BVC,0,4,0
	CODE	102400,BVS,0,4,0
	CODE	103000,BCC,0,4,0
	CODE	103000,BHIS,0,4,0
	CODE	103400,BCS,0,4,0
	CODE	103400,BLO,0,4,0
	CODE	104000,EMT,0,12,0
	CODE	104400,TRAP,0,12,0
	CODE	105000,,0,1,0
	CODE	106500,MFPD,2,13,0
	CODE	106600,MTPD,2,13,0
	CODE	106700,,0,1,0
	CODE	160000,SUB,0,7,0
	CODE	170000,,0,1,0
	CODE	177777,,0,1,0
	.ENDM

; WORD ALIGNED CONSTANTS

D.UADD:	D.WULF			;  UW  WULF COMMAND
	D.ONES			;  UT  SINGLE STEP MODE
.IIF DF,D.GDP,D.GRAP		;  UG  RETURN USER DISPLAY
	.IF	DF,$VMEM
	.WORD	O.OVIR	;UM	MAP VIRTUAL MAPPING
	.WORD	O.KVIR	;UK	MAP WITH KERNEL APR'S
	.WORD	O.UVIR	;UU	MAP WITH USER APR'S
	.WORD	O.EVIR	;UR	REMOVE VIRTUAL MAPPING
	.WORD	O.VVIR	;UV	REMOVE VIRTUAL USE ALTOGETHER
	.WORD	O.BVIR	;UB	SET VIRTUAL BASE ("PAR,ADDR$UB")
	.IF	DF,$VPAT
	.WORD	O.PATW	;addr<data$UP PATCH WORD
	.WORD	O.PATB	;addr<data$UH PATCH BYTE
	.ENDC
	.WORD	O.DVIR	;UD SET VIRTUAL BASE (PAR<DATA$UD)
	.IIF DF,$DDBSX, .WORD O.PVIR ;UP SET UP CONTEXT (ADDR$UP) FROM TCB
	.ENDC
	.IF	DF,D.MCRO	; IF MACRO CAPABILITY EXISTS
	.WORD	D.UE		;UE ENABLE ECHO
	.WORD	D.UN		;UN NO ECHO OF MACRO
	.WORD	D.UDAT		;UC USE CORE BUFFER FOR CONSOLE MACRO
	.WORD	D.UKOT		;US USE STANDARD INPUT (CONSOLE)
	.WORD	D.UF		;UF'TEXT FOR MACRO' FILL IN MACRO AREA TEXT
	.ENDC
	.IIF DF,R$XMDB, .WORD D.UUL ;UL LOOK UP RSX11M TASK,MAP TO IT
D.LGDR:				; COMMAND DISPATCH TABLE
	D.ORAB			;  @  OPEN RELATED, ABSOLUTE--AS ODT
	D.ERR			;  #  ERROR
	D.ERR			;  (  ERROR
	D.ADD			;  +   
	D.ADD			;  <SP>
	D.MULT			;  *  MULTIPLICATION
	D.DIV			;  '  DIVISION
	D.SUBT			;  -  SUBTS SIGN
	D.ERR			;  )  ERROR
	D.TEXT			;  "  MAKE ASCII
	D.LWAS			;  >
	D.FWAS			;  <  SET FIRST WORD OF SEARCH
	D.EQAL			;  =  
	D.ALTM			;  $  ALTMODE
	D.COLN			;  :  DEFINES SYMBOL
	D.SEMI			;  ;  RE-TYPE WORD
	D.WRD			;  /  OPEN WORD
	D.BKSL			;  \  STORE AND REFERENCE
	D.DCOM			;  ,  COMMA PARAMETER
	D.CRET			;  <CR>  CLOSE
	D.OP1			;  <LF>  MODIFY, CLOSE, OPEN NEXT
	D.ORPC			;  _  TYPE WORD AS INSTRUCTION
	D.BACK			;  ^  OPEN PREVIOUS
.IIF DF,D.GDP,D.SOFT		;  <CALL>  SOFT RESTART AT 1004
	D.ORAB			;  <TAB>  OPEN RELATED, ABSOLUTE
	D.OPBR			;  [  OPEN WORD AS NUMERIC
	D.CLBR			;  ]  OPEN WORD AS INSTRUCTION
	D.RDT1			; ? OPEN WORD IN RAD50
	D.EXCL			;  !  OPEN WORD SILENTLY
	D.ERR			;  <SP> SECOND SPACE (ERROR)
	D.ABS			;  A  ABSOLUTE ADDRESSES
	D.BKPT			;  B  BREAKPOINTS
	D.INNM			;  C  IN NUMERICS
	D.DELE			;  D  KILL LAST SYMBOL
	D.EFF			;  E  SEARCH EFFECTIVE ADDRESS
	D.ERR			;  F  ERROR
	D.GO			;  G  GO TO ADDRESS K
	D.INHA			;  H  IN HALF WORDS
	D.ALTI			;  I  STATUS ADDRESS
	D.ERR			;  J  ERROR
	D.KILL			;  K  SYMBOL TABLE DELETION
	D.ERR			;  L  ERROR
	D.MAST			;  M  SET MASK
	D.NSCH			;  N  NON-SEARCH
	D.BYTE			;  O  TYPEOUT IN BYTES
	D.PROC			;  P  PROCEED
	D.ALTQ			;  Q  CURRENT WORD
	D.INRD			;  R  SET RADIX
	D.INMD			;  S  IN INSTRUCTION MODE
	D.INTX			;  T  IN TEXT
	D.SNGL			;  U  SECOND SET OF ROUTINES
	D.ALTV			;  V  SWAB OF CURRENT WORD
	D.WSCH			;  W  SEARCH WORD
	D.EXEC			;  X  EXECUTE INSTRUCTION
	D.ERR			;  Y  ERROR
	D.ZERO			;  Z  ZERO CORE
D.PARM:	D.RTS
	D.N16
	D.CZVN
	D.N3
	D.X8
	D.RDD
	D.N6
	D.SSDD
	D.R
	D.RN6
	D.N8
	D.DD
	D.DDR
D.PARG:	D.NONE			; NO PARAMETERS
	D.NONE			; 16-BIT NUMBER NOT AN INSTRUCTION
	D.NONE			; CONDITION CODE ALREADY DECODED
	D.NONE			; 3 BIT OPERAND ADDED IN AUTOMATICALLY
	D.DISP			; GET 8-BIT DISPLACEMENT
	D.GRSS			; GET "R,SS"
	D.GNUM			; GET 6-BIT NUMBER (MARK OPERAND)
	D.GSD			; GET "SS,DD"
	D.GR			; GET "R"
	D.GRNN			; GET "R,NN"
	D.GNUM			; GET 8-BIT OPERAND
	D.GDD			; GET "DD" (OR "SS")
	D.GDDR			; GET "DD,R"

	.MACRO	CODE	TOP,STR,LEG,PARM,BYT
	.WORD	TOP-1
	.ENDM
D.TOPS:	INSTRS
	.WORD	-1

	.MACRO	CODE	TOP,STR,LEG,PARM,BYT
	.BYTE	<BYT*200>+<PARM*4>+LEG
	.NCHR	D.LEN,STR
	D.ADDR=D.ADDR+D.LEN
	.BYTE	D.ADDR
	.ENDM
	D.ADDR=0
D.COUS:	.BYTE	D.ADDR
D.LEGS:	INSTRS
D.ECNT=.-1

	.MACRO	CODE	TOP,STR,LEG,PARM,BYT
	.ASCII	"STR"
	.ENDM
D.STRS:	INSTRS

; BYTE ALIGNED CONSTANTS

D.FIRS:	.ASCII	<0> "((@(-(@-(" <0> "@" <0> "))+)+))))??#@#??" <0> "@SPPC"
D.NZVC:	.ASCII	"CVZN"
D.OPCH:	.BYTE	0,1,2,3,5,7,12,13
D.CLOS:	.BYTE	14,15,16,20,22,23,24,25
D.MOD7:	.BYTE	26,27,30,31,33,34,35,36
D.SP:	.BYTE	37,41,43
D.GRET:	.ASCII	<15><12>"DDT EXECUTION"
.IIF NDF,D.GDP,.ASCII "; MANUAL RESTART = "
D.GRND	=.-1
D.BE:	.ASCII	";BPT!"
D.NM:	.ASCII	";NXM!"
D.IM:	.ASCII	";ILG!"
D.TRA:	.ASCII	";TRP!"
D.EMT:	.ASCII	";EMT!"
D.SEG:	.ASCII	";SEG!"
D.IOT:	.ASCII	";IOT!"
	.EVEN
D.UTAB:	.BYTE	'W		;  W
	.BYTE	'T		;  T
.IIF DF,D.GDP,.BYTE 'G		;  G
	.IIF DF,$VMEM, .ASCII /MKURVB/ ;VIRTUAL MAPPING COMMANDS
	.IF	DF,$VMEM
	.IF	DF,$VPAT
	.ASCII	/PH/ ;PATCHING FUNCTIONS
	.ENDC
	.ASCII	/D/
	.IIF DF,$DDBSX, .ASCII /A/
	.ENDC
	.IIF DF,D.MCRO, .ASCII /ENCSF/
	.IIF DF,R$XMDB, .ASCII /L/
D.ENUT	=.-D.UTAB
D.LGCH:				; FIRST CHARACTERS MUST BE "@#(+ *'-)"
	.BYTE	'@		;  @
D.HASH	=.-D.LGCH
	.BYTE	'#		;  #
D.OPAR	=.-D.LGCH
	.BYTE	'(		;  (
D.ADDS	=.-D.LGCH
	.BYTE	'+		;  +
D.SPAC	=.-D.LGCH
	.BYTE	' 		;  <SP>
	.BYTE	'*		;  *
	.BYTE	''		;  '
D.DASH	=.-D.LGCH
	.BYTE	'-		;  -
D.CPAR	=.-D.LGCH
	.BYTE	')		;  )
	.BYTE	'"		;  "
	.BYTE	'>		;  >
	.BYTE	'<		;  <
	.BYTE	'=		;  =
	.BYTE	33		;  <ALT>
D.COLO	=.-D.LGCH
	.BYTE	':		;  :
	.BYTE	';		;  ;
	.BYTE	'/		;  /
	.BYTE	'\		;  \
D.COMM	=.-D.LGCH
	.BYTE	',		;  ,
D.CR:	.BYTE	15		;  <CR>
	.BYTE	12		;  <LF>
	.BYTE	'_		;  _
	.BYTE	'^		;  ^
.IIF DF,D.GDP,.BYTE	3	;  <CALL>
	.BYTE	11		;  <TAB>
	.BYTE	'[		;  [
	.BYTE	']		;  ]
	.BYTE	'?		;  ?
	.BYTE	'!		;  !
D.LETR	=.-D.LGCH
D.RDTB:	.ASCII	" ABCDEFGHIJKLMNOPQRSTUVWXYZ"
D.CLGT	=.-D.LGCH		; COMMAND TABLE END
	.ASCII	"$.*0123456789"
D.ENTB	=.-D.RDTB

; BYTE ALIGNED VARIABLES

	.IF	DF,D.KSR
D.CPOS:	 .BYTE	71.		; CHARACTER POSITION FOR TTY
D.BUFR:	 .BLKB	25.		; 25 CHARACTER INPUT BUFFER
D.ENDB:
	.ENDC
D.USED:	.BYTE	0		; IF ZERO, USE OCTAL NUMBER
D.MACH:	.BYTE	1		; 0=11/15  1=11/40  2=11/45
D.LEVL:	.BYTE	0		; PARENTHESIS LEVEL
D.FWAF:	.BYTE	0		; MARKER OF < PARAMETER
D.INPA:	.BYTE	0		; NON-ZERO IF IN AN INSTRUCTION TYPE-IN
D.P:	.BYTE	-1		; PROCEED FLAG = <1-8>*2 IF NORMAL BREAK
				;		0 IF SINGLE STEP BREAK
				;		-1 IF NOT ENTERED BY BREAK
D.ALTF:	.BYTE	0		; ALTMODE FOUND
D.WAMS:	.ASCII	";  WORDS"
	;NOTE FOLLOWING 2 BYTES MUST PRECEDE D.BMES IMMEDIATELY:
	.BYTE	15,12		;CR, LF
D.BMES:	.ASCII	"$ B >> "

; WORD ALIGNED VARIABLES
	.EVEN

	.IF	DF,D.MCRO ;IF MACROS ARE ENABLED
D.KBPT:	.WORD	D.KBBF		;CORE INPUT ADDRESS
D.ECSW:	.WORD	0		;ECHO FLAG. 0=NO,1=YES
D.CHSW:	.WORD	0		;CORE IN SWITCH  0=KB, 1=CORE IN
D.KBBF:	.BLKW	66.		;CORE INPUT BUFFER. NEG. CODE TERMINATES.
	.BYTE	33,33		;ESCAPES
D.KBFE:	.WORD	-1,-1		;FENCES
	.ENDC
	.IF	DF,D.KSR
D.INPU:	 D.BUFR			; INPUT BUFFER POINTER
D.OUTP:	 D.BUFR			; OUTPUT BUFFER POINTER
	.ENDC
.IIF DF,$FORM$, D.FFPC: .WORD 0 ;INT COUNTER FOR  FORMATION PANEL
 .IIF DF, $FORM$, .GLOBL D.FFPC
 .IIF DF, $$RSX, DDTDSW: .WORD 0 ;DSW STORAGE FOR RSX DDT
D.SYM:	.BLKW	<D.SYML+1>/2	; HOLDS SYMBOL TYPED
D.SD.T:				; WORD ADDRESS OF D.S AND D.T
D.S:	.BYTE	0		; SINGLE STEP FLAG
D.T:	.BYTE	0		; T-BIT FLAG
D.BOTH:				; WORD ADDRESS OF D.NOTY AND D.FIND
D.NOTY:	.BYTE	0		; DON'T TYPE OUT IF EQUALS 1
D.FIND:	.BYTE	0		; ADDRESS FOUND (EFF SEARCH) IF EQUALS 1
D.TPC:	0			; PC OF LAST BPT WE PROCEEDED
D.LFIN:	0			; LINE FEED INCREMENT
; THE NEXT 4 WORDS FORM THE TEMPORARY MODE TABLE AND MUST BE IN ORDER********
D.CURM:	D.INST			; TYPEOUT MODE ADDRESS			*****
D.DVTB:	8.			; CURRENT RADIX				*****
D.BW:	2			; BYTE-WORD INDICATOR (1=BYTE, 2=WORD)	*****
D.IFMT:	0			; (1=ABSOLUTE, 0=RELATIVE)		*****
; END OF CRITICAL ORDERING***************************************************
; THE NEXT 4 WORDS FORM THE PERMANENT MODE TABLE AND MUST BE IN ORDER********
D.PERM:	D.INST			; PERMANENT TYPEOUT MODE		*****
D.PERN:	8.			; PERMANENT RADIX			*****
D.PEBW:	2			; PERMANENT BYTE-WORD INDICATOR		*****
D.PEFM:	0			; PERMANENT ADDRESS TYPEOUT INDICATOR	*****
; END OF CRITICAL ORDERING***************************************************
D.OMOD:	D.INST			; MODE TO OPEN WORDS IN
D.OPER:	0			; OPERATION
D.DECN:	0			; DECIMAL NUMBER
D.SVR2:	0			; SAVE FOR R2
	.IIF DF,$$RSX,D.XGO: MOV #D.TMP,DDTODD ;SET UP ODD ADDR TRAP
; THE NEXT THREE LINES MUST BE IN THAT ORDER FOR $X INST.********************
D.SVR4:	0			; SAVE FOR R4				*****
D.PARS:	0,0			; PARAMETERS FOR INSTR. TYPE-IN		*****
	.IIF DF,$$RSX,JMP @#3	;CAUSE TRAP THRU ODD ADDR
	JMP	D.EXE2		; RETURN IN CASE INSTRUCTION FINISHES	*****
; END OF CRITICAL ORDERING***************************************************
D.SVR7:	0			; SAVE FOR PC DURING $X
D.PARO:	0,0			; RELOCATIOON FOR D.PARS
D.OFST:	0			; OFFSET FROM COMMA
D.RFNL:	127.			; RFND OFFSET
D.LASV:	0			; LAST TYPED NUMBER
D.LASW:	0			; LAST TYPED WORD
D.DOT:	0			; CURRENT LOCATION
D.CADC:	0			; COPY OF D.CAD FOR TYPE-IN
D.ERF:	0			; ADDRESS OF ERROR MESSAGE
D.CAD:	0			; CURRENT ADDRESS
D.XXX:	0			; TEMPORARY STORAGE
D.COMA:	0			; ADDRESS BEFORE COMMA
D.SIZE:	0			; BYTE SIZE FOR "O" TYPEOUT
D.RAD1:	0			; FIRST WORD OF RAD50 SYMBOL
D.RAD2:	0			; SECOND WORD OF RAD50 SYMBOL
D.LASC:	0			; LAST COLONED WORD
D.FILV:	.WORD	0	;FILLER VALUE FOR $Z COMMAND

	.IF	DF,$$RSX
D.SVOD:	.WORD	D.NXMT		;ADDR OF ODD ERR TRAP
D.TMP:	MOV	D.SVOD,DDTODD	;RESTORE ODD ADDR TRAP TO USUAL
	TST	(SP)+		;FLUSH OLD PC
	MOVB	(SP),D.USTA	;SAVE USER PS (LO BYTE ONLY)
	TST	(SP)+	;POP OFF OLD STACK
	JMP	D.EXE2		;FINISH $X INSTRUCTION
	.ENDC
D.FENC:	D.SYMA			; ADDRESS OF FENCE SYMBOL TABLE
D.POS:	D.SYM			; ADDRESS OF CHARACTER IN D.SYM
D.FWA:	0			; LOW LIMIT
D.LWA:	DDT-2			; HIGH LIMIT
D.MASK:	177777			; MASK

D.BKTB:	.REPT	D.BKP
	0			; ADDRESS OF BREAKPOINTS
	.ENDR
D.CT:	.BLKW	D.BKP+1		; EXTRA LOCATION FOR SINGLE STEP
D.UIN:	.BLKW	D.BKP
D.OPEN:	.BLKW	D.BKP+1		; EXTRA LOCATION FOR SINGLE STEP

; THE DDT STACK, INCLUDING SOME VARIABLES AT ITS BASE (HIGH ADDRESSES)
; WHICH DESCRIBE THE USER'S PROGRAM STATE:

; THE FOLLOWING VARIABLES ARE CRITICALLY ORDERED FOR VARIOUS REASONS.********
	.BLKW	100.
	.BLKW	40.		; ACTIVE STACK AREA			*****
D.STK:				; BASE OF ACTIVE DDT STACK		*****
	.IF	NDF,$$RSX	;IN RSX, NO SAVE/RESTORE EXTRA STUFF
.IIF DF,D.KSR,	0		; SAVE CELL - R C/SR			*****
	0			; SAVE CELL - T C/SR			*****
	0,0,0,0			; USER LOCATION 12,10,6,4		*****
	.ENDC
	.IF	DF,$$RSX
	.IF	DF,XTCOM
	.WORD	0,0
	.ENDC
	.ENDC
D.UR0:	0			; USER REGISTER 0			*****
D.UR1:	0			; USER REGISTER 1			*****
D.UR2:	0			; USER REGISTER 2			*****
D.UR3:	0			; USER REGISTER 3			*****
D.UR4:	0			; USER REGISTER 4			*****
D.UR5:	0			; USER REGISTER 5			*****
D.UR6:	0			; USER SP				*****
D.UR7:	0			; USER PC				*****
JOBSA:	DDT			; USER START ADDRESS			*****
; END OF CRITICALLY ORDERED VARIABLES****************************************

	.IF	DF,$VMEM
VKPAR0:	.WORD	0
VKPAR1:	.WORD	0	;VIRTUAL PARS
VKPAR2:	.WORD	0
VKPAR3:	.WORD	0
VKPAR4:	.WORD	0
VKPAR5:	.WORD	0
VKPAR6:	.WORD	0
VKPAR7:	.WORD	0
ORGPAR:	.BLKW	8.
PARMAP:	.WORD	0	;INITIALLY USE ORGPAR TABLE FOR MAPPING.
	.ENDC
	.IF	DF,$$RSX
	.MCALL	EXIT$S
RSXEXT:	EXIT$S
	.ENDC
.IIF DF,$$DOS,DOSEXT: EMT 60 ;EXIT TO DOS
D.USTA:	0			; USER STATUS
D.DSTA:	D.PRIO			; DDT'S STATUS
	.PSECT	.SYMS.,RW,CON	;ALLOW SYMBOL .PSECT TO BE EXTENDED BY USERS
D.SYMA:	.RAD50	/R0    /	; THIS SYMBOL TABLE MUST APPEAR
	D.UR0			; AT THE END OF DDT SINCE IT IS
	.RAD50	/R1    /	; EXTENDED MAGICALLY BY THE LINKER
	D.UR1			; STARTING AT ADDRESS D.SYMT
	.RAD50	/R2    /
	D.UR2
	.RAD50	/R3    /
	D.UR3
	.RAD50	/R4    /
	D.UR4
	.RAD50	/R5    /
	D.UR5
	.RAD50	/SP    /
	D.UR6
	.RAD50	/PC    /
	D.UR7
	.RAD50	/D.CNT/		;IF -, REPEAT -N TIMES.
				;IF 0, AUTO REPEAT WITH TYPING
				;IF +, REPEAT N TIMES
 	;IF +, RESETS REPEAT TO 1 WHEN BACK TO 0. IF - LETS
	;COUNT GO TO 0 AND STAY THERE.
	.WORD	D.CT		;1ST WORD IS FOR SINGLE STEP MODE BKPT
	.RAD50	/D.UIN/		;USER INST. VALUES FOR REAL BKPTS
	.WORD	D.UIN
	.RAD50	/D.IFMT/
	D.IFMT			;DDT INSTRUCTION FORMAT.
				;(NEGATIVE==> PSEUDO-ASSEMBLY MODE)
	.IF	DF,R$XMDB
	.RAD50	/HDRADR/
	.WORD	HDRADR
	.RAD50	/TSKAPR/
	.WORD	TSKAPR
	.RAD50	/DBG11M/
	.WORD	DBG11M
	.ENDC
	.RAD50	/DDTGO/
	.WORD	DDT
	.RAD50	/JOBSA /
	JOBSA		;START ADDR OF JOB
	.IF	DF,$$DOS
	.RAD50	/$$DOS /	;GO HERE TO EXIT
	DOSEXT
	.RAD50	/BYE   /
	.WORD	DOSEXT
	.ENDC
	.IF	DF,$$RSX
	.RAD50	/D.ASTF/
	.WORD	D.ASTF		;AST FLAG, CONTROLS AST REENABLE
	.RAD50	/RSXEXT/
	.WORD	RSXEXT
	.RAD50	/$DSW  /
	.WORD	DDTDSW		;SAVE $DSW HERE AT EACH D.SAVE CALL
	.RAD50	/DDTODD/
	.WORD	DDTODD
	.IFTF
	;ALWAYS...
	.RAD50	/D.FILV/
	.WORD	D.FILV
	.IF	DF,$FORM$
	.RAD50	/PNLINT/
	.WORD	D.FFPC
	.ENDC
	.IFT
	.RAD50 /DDTIOT/
	.WORD DDTIOT
	.RAD50 /DDTRES/
	.WORD DDTRES
	.RAD50 /DDTEMT/
	.WORD DDTEMT
	.RAD50 /DDTTRP/
	.WORD DDTTRP
	.RAD50 /DDTFPP/
	.WORD DDTFPP
	.RAD50 /BGN/
NMH:	.WORD	0,0
	.RAD50	/BYE   /
	.WORD	RSXEXT
	.RAD50	/DDTBGN/
	.WORD	DDT
	.RAD50	/DDTRST/
	.WORD	DDT+2
NAMLO:	.WORD	0	;TASK NAME AS START ADDR
NAMHI:	.WORD	0
	.WORD	JOBSA
	.ENDC
	.IF	DF,$VMEM
	.MACRO	SYMBL NAME,ADDR
	.RAD50 /NAME/
	.WORD	ADDR
	.ENDM
	SYMBL	PAR0,VKPAR0
	SYMBL	PAR1,VKPAR1
	SYMBL	PAR2,VKPAR2
	SYMBL	PAR3,VKPAR3
	SYMBL	PAR4,VKPAR4
	SYMBL	PAR5,VKPAR5
	SYMBL	PAR6,VKPAR6
	SYMBL	PAR7,VKPAR7
	.IF	DF,D.MCRO
	SYMBL	D.KBPT,D.KBPT ;CORE IN ADDR
	SYMBL	D.ECSW,D.ECSW	;ECHO SWITCH
	SYMBL	D.CHSW,D.CHSW	;CORE IN SWITCH
	SYMBL	D.KBBF,D.KBBF	;CORE INPUT BUFFER
	.ENDC
	.IF	DF,$VPAT
	SYMBL	PBASEL,D.BASE
	SYMBL	PBASEH,D.BASE+2
	.ENDC
	.ENDC
	.REPT 160.	;ALLOW 160. USER-DEFINED SYMBOLS
	.WORD	-1,-1,0
	.ENDR		;BY ADDING NULL SYMBOLS.
	.RAD50	/SYMEND/	;ALLOW D.SYMT TO BE PATCHED SMBOLICALLY
	.WORD	D.SYMT		;AND TERMINATED IN THE USER'S CODE
	.GLOBL	D.SYMT	;GLOBALIZE TO ALLOW GBLPAT TO WORK
; GBLPAT=D.SYMT:177777:177777 ; TO MAKE EXTENSION OF PSECT AUTOMATIC
D.SYMT:	.WORD 0,0,0			; TABLE TERMINATED BY NULL SYMBOL NAME
;
	.END	DDT
;	;DDT=START ADDR