.TITLE FODT
.IDENT /V01H/
 
;*************************************************
;**						**
;**	  FORTRAN IV ON-LINE DEBUGGER		**
;**						**
;*************************************************
 
;	WRITTEN BY:
;		DAVE BECKWITH
;		LILLY RESEARCH LABS - DEPT MC304
;		ELI LILLY & CO.
;		731 S. ALABAMA ST.
;		INDIANAPOLIS, IN 46206
 
.PSECT $FODT$
 
;THIS OBJECT MODULE CAN BE LINKED INTO A FORTRAN
;  PROGRAM BY THE TASK BUILDER TO ALLOW DEBUGGING
;  FORTRAN WITH MANY OF THE SAME FEATURES THAT
;  ODT PROVIDES FOR DEBUGGING MACRO PROGRAMS.
;
;THE FOLLOWING GLOBAL SYMBOLS USED BY FORTRAN IV
;  ARE DEFINED IN THIS MODULE AND ARE USED IN PLACE
;  OF THE FORTRAN OTS MODULES CONTAINING THE SAME
;  SYMBOLS:
;	$OTIS  - SETUP ENTRY TO FORTRAN SUBROUTINE
;	RET$L  - RETURN FROM LOGICAL*1 FUNCTION
;	RET$F  - RETURN FROM REAL FUNCTION
;	RET$I  - RETURN FROM INTEGER FUNCTION
;	RET$   - RETURN FROM SUBROUTINE
;	ISN$   - INCREMENT SEQUENCE NUMBER
;	LSN$   - LOAD NEW SEQUENCE NUMBER
 
;THE FOLLOWING GLOBALS ARE I/O FORMAT CONVERSION
;  MODULES WHICH ARE REQUIRED BY "FODT".
.GLOBL RCI$,LCI$,ICI$
 
.MCALL DIR$,QIO$,WTSE$		;CHANGE FROM QIOW$ TO QIO$
 
.GLOBL STP$,ENC$,EOL$,TVI$,TVF$,REL$	;EXTERNAL
 
W.NAM=	2	;OFFSET TO CURRENT NAME POINTER

;THIS MACRO PROVIDES A SIMPLE METHOD OF PRINTING
;  FIXED MESSAGES ON THE USER TERMINAL.
.MACRO	.PRINT TEXT,?LBL1,?LBL2
	JSR R5,PRINT
	.WORD LBL2-LBL1
LBL1:	.ASCII TEXT
LBL2:	.EVEN
.ENDM	.PRINT
 
 
 
;THIS ROUTINE SETS UP THE ERROR TRACEBACK INFORMATION
;  UPON ENTRY INTO A FORTRAN SUBROUTINE.  IT REPLACES
;  THE FORTRAN IV OTS ROUTINE BY THE SAME NAME.
;ADDITIONS TO THE OTS CODE ARE MARKED BY AN ASTERISK
;  (*) IN THE COMMENT.  ADDITIONAL INFORMATION IS
;  SAVED TO LOCATE VARIABLES AND PARAMETERS IN THE
;  SUBROUTINE BEING ENTERED.
;UPON ENTRY TO $OTIS THE FOLLOWING REGISTERS CONTAIN:
;	R0 - ADDR OF START OF SUBROUTINE
;	R4 - ADDR OF ADDR OF POLISH CODE
;	R5 - ADDR OF SUBR ARG LIST ON STACK
;
;THE FORMAT OF A SUBROUTINE GENERATED BY THE
;  FORTRAN COMPILER IS:
;
;	JSR R4,$OTIS			<--R0
;	(ADDR OF POLISH CODE)		<--R4
;	(RAD50 NAME - 1ST HALF)
;	(RAD50 NAME - 2ND HALF)
;	(NO. OF PARAMS FOR SUBROUTINE - N)
;	(PTR TO 1ST PARAM)	
;	....	THESE POINTERS ARE SETUP BY $OTIS
;	(PTR TO NTH PARAM)
;	**				<--PARLIM
;	**	THIS AREA CONTAINS THE VARIABLES
;	**	AND CONSTANTS USED INTERNALLY BY
;	**	THE SUBROUTINE (SEE COMPILER MEMORY
;	**	MAP FOR ADDRESSES REL. TO R0)
;	**
;	(START OF POLISH THREADED CODE)	<--VARLIM
;
;A FORTRAN TASK HAS A WORK AREA WHICH CONTAINS
;  A VARIETY OF INFORMATION ABOUT THE TASK.
;  THE ADDRESS OF THE WORK AREA IS IN $OTSV
;  AND CONTAINS THE FOLLOWING PIECES OF
;  INFORMATION USED BY FODT:
;	@$OTSV+0  SEQUENCE NO. OF CURRENT FORTRAN LINE
;	@$OTSV+2  ADDRESS OF 2-WORD RAD50 SUBROUTINE
;		NAME OR ZERO FOR MAIN PROGRAM
;
$OTIS::	TST (SP)+	;POP OLD R4 OFF STACK
	MOV BASE,-(SP)	;* SAVE OLD BASE ADDR
	MOV PARLIM,-(SP);* SAVE OLD PARAM LIMIT
	MOV VARLIM,-(SP);* SAVE OLD VARIABLE LIMIT
	MOV R0,BASE	;* GET NEW BASE ADDR
	MOV @R4,VARLIM	;* GET CODE START ADDR
	MOV 12(R0),R3	;* GET PARAM COUNT
	ASL R3		;* GET LENGTH OF ADDR TABLE
	ADD #14,R3	;* ADD OFFSET FROM BASE
	ADD R0,R3	;* GET ABS ADDR OF LIMIT
	MOV R3,PARLIM	;* SAVE PARAM LIMIT
	MOV (R4)+,R0	;GET ADDR OF POLISH CODE
	MOV $OTSV,R3	;GET PTR TO WORK AREA
	MOV 2(R3),-(SP)	;SAVE OLD PTR TO ROUTINE NAME
	MOV @R3,-(SP)	;SAVE OLD SEQ NO.
	MOV (R4)+,-(SP)	;SAVE NAME OF SUBROUTINE
	MOV (R4)+,-(SP)	;  BEING ENTERED
	CLR @R3		;ZERO SEQ NO.
	MOV SP,2(R3)	;SAVE PTR TO SUBR NAME
	MOV (R5)+,R1	;GET PARAM COUNT
	BEQ 40$		;GO ON IF NO PARAMS
	MOV (R4)+,R2	;GET # EXPECTED BY SUBR
	BEQ 40$		;GO ON IF NONE EXPECTED
20$:	MOV (R5)+,(R4)+	;MOVE ADDR TO LOCAL TABLE
	DEC R1		;COUNT PARAMS AVAILABLE
	BEQ 40$		;QUIT IF THAT'S ALL
	DEC R2		;COUNT PARAMS EXPECTED
	BNE 20$		;LOOP IF MORE EXPECTED
40$:	MOV R0,R4	;SETUP POLISH POINTER
	JMP @(R4)+	;ENTER POLISH CODE

;THIS SET OF ROUTINES PROVIDE RETURNS FROM SUBROUTINES
;  AND VARIOUS KINDS OF FUNCTIONS.  THE MODIFICATIONS
;  (*) SIMPLY RESTORE THE INFORMATION SAVED ON THE
;  STACK BY THE MODIFICATIONS IN $OTIS.
;
RET$L::	MOVB @(R4)+,R0	;RETURN BYTE IN R0
	BR RET$
 
RET$F::	MOV @R4,R3	;GET PTR TO REAL NO.
	MOV 2(R3),R1	;GET 2ND WORD OF REAL IN R1
 
RET$I::	MOV @(R4)+,R0	;RETURN INTEGER IN R0
 
RET$::	MOV $OTSV,R3	;GET PTR TO WORK AREA
	TST 2(R3)	;ZERO IF WE ARE IN MAIN
	BEQ 40$		;JUST STOP IF IN MAIN
	CMP (SP)+,(SP)+	;CLEAR OLD NAME OFF STACK
	MOV (SP)+,@R3	;RESTORE OLD SEQ NO.
	MOV (SP)+,2(R3)	;RESTORE OLD NAME POINTER
	MOV (SP)+,VARLIM;* RESTORE OLD VAR LIMIT
	MOV (SP)+,PARLIM;* RESTORE OLD PARAM LIMIT
	MOV (SP)+,BASE	;* RESTORE OLD BASE ADDRESS
	RTS PC		;RETURN TO CALLER
40$:	JMP STP$	;END OF MAIN, STOP
 
 
;ONE OF THE FOLLOWING ROUTINES IS ENTERED BEFORE
;  EACH FORTRAN STATEMENT IS EXECUTED.  THEY ARE
;  EXACTLY THE SAME AS THE FORTRAN IV OTS ROUTINES
;  EXCEPT THAT THEY ENTER THE DEBUGGER INSTEAD OF
;  GOING ON TO THE NEXT POLISH ROUTINE.
;
ISN$::	INC @$OTSV		;INCREMENT THE SEQUENCE #
	BR FODT		;ENTER DEBUGGER
 
LSN$::	MOV (R4)+,@$OTSV	;LOAD NEW SEQUENCE NUMBER
			;FALL THRU TO "FODT" ENTRY

;THIS IS THE START OF THE "FODT" CODE.  THE "ISN$"
;  AND "LSN$" BRING US HERE JUST BEFORE EACH
;  FORTRAN STATEMENT IS EXECUTED.  THIS GIVES US
;  THE OPPORTUNITY TO CHECK TO SEE IF THERE IS A
;  BREAKPOINT OR OTHER REASON TO STOP AND LET THE
;  USER LOOK AROUND AT THE CURRENT STATE OF HIS
;  VARIABLES.
;
FODT:	MOV R0,-(SP)	;SAVE REGISTERS
	MOV R1,-(SP)
	MOV R2,-(SP)
	MOV R3,-(SP)
	MOV R4,-(SP)
	MOV R5,-(SP)
	ADD MODE,PC	;DISPATCH TO ROUTINE
	BR INIT		;M=0, FIRST TIME ENTERED
	BR CKSTEP	;M=2, CHECK FOR "STEP" STOP
	BR CKBRK	;M=4, CHECK FOR "BREAKPT" STOP
 
 
;WE COME HERE THE FIRST TIME "FODT" IS ENTERED TO
;  IDENTIFY OURSELVES TO THE USER.  THIS WILL
;  HAPPEN BEFORE THE FIRST FORTRAN STATEMENT IS
;  EXECUTED BUT AFTER THE "$OTI" ROUTINE HAS
;  INITIALIZED THE FORTRAN WORK AREA AND I/O.
;WE USE THE STACK POINTER TO FIND OUT WHERE WE
;  ARE AND CALCULATE THE MAIN PROGRAM BASE ADDRESS.
;
INIT:	DIR$ #TTOUT	;PRINT THE IDENT STRING
	DIR$ #TTWT
	MOV SP,R0	;USE THE STACK POINTER TO
	ADD #16,R0	;  CALC THE BASE ADDRESS OF
	MOV R0,BASE	;  THE MAIN PROGRAM.
	MOV @4(R0),VARLIM ;ALSO LIMIT OF VARIABLES
	MOVB	#'I,R3	;**MJ IDENTIFY INITIAL BPT
	BR IDENT	;GO SHOW MAIN LINE NO.
 
 
;WE COME HERE WHEN WE ARE LOOKING FOR A BREAKPOINT.
;  AS EACH FORTRAN STATEMENT IS EXECUTED, WE CHECK
;  THE SEQUENCE NUMBER AND ROUTINE NAME TO SEE IF
;  IT HAS BEEN SPECIFIED AS A BREAKPOINT.  IF IT
;  HAS NOT, WE SIMPLY RESUME.
;THE WORK AREA POINTER TO THE CURRENT ROUTINE
;  NAME (RAD50) WILL BE ZERO IF WE ARE IN THE
;  MAIN PROGRAM.
;
CKBRK:	MOV	#BTAB,R3	;**MJ BPT TABLE ADDRESS
	MOV	$OTSV,R2	;**MJ GET WORK AREA POINTER
3$:	TST	@R3		;**MJ CHECK SEQ NUM OF BPT ENTRY
	BMI	RESUME		;**MJ -1=>END OF TABLE, SO NO MATCH
	BEQ	1$		;**MJ 0=> UNUSED ENTRY, SO SKIP IT
	CMP	@R2,@R3		;**MJ SEQUENCE NUMBERS MATCH??
	BEQ	2$		;**MJ YES, GO CHECK ROUTINE
1$:	ADD	#8.,R3		;**MJ NO, MOVE TO NEXT ENTRY
	BR	3$
;
; CHECK ROUTINE NAME
;
2$:	TST	(R3)+		;**MJ MOVE PTR TO NAME WORD
	MOV	W.NAM(R2),R2	;**MJ GET NAME POINTER
	BNE	10$		;**MJ BR IF NOT MAINLINE
	TST	@R3		;**MJ BPT IN MAINLINE??
	BNE	RESUME		;**MJ NOPE, BACK TO FORTRAN
	BR	100$		;**MJ YES, DECREMENT COUNT
;
10$:	CMP	2(R2),(R3)	;**MJ MATCH FIRST PART?
	BNE	RESUME		;**MJ NO, BACK TO FORTRAN
	CMP	(R2),2(R3)	;**MJ MATCH SECOND PART?
	BNE	RESUME		;**MJ NO, BACK TO FORTRAN
;
; THIS IS A BREAKPOINT
;
100$:	ADD	#4,R3		;**MJ MOVE TO COUNT WORD
	DEC	@R3		;**MJ PAST HERE ENOUGH?
	BNE	RESUME		;**MJ NOPE, BACK TO FORTRAN
	MOV	R3,BCUR		;**MJ SHOW CURRENT BREAKPOINT
	SUB	#BTAB+6,R3	;**MJ GET OFFSET
	ASH	#-3,R3		;**MJ CONVERT TO NUMBER
	ADD	#60,R3		;**MJ THEN TO CHARACTER
	BR	IDENT		;**MJ AND SHOW OURSELVES.
 
 
;WE COME HERE WHEN WE ARE STEPPING THROUGH THE CODE
;  ONE (OR SEVERAL) STATEMENT AT A TIME.  WE SIMPLY
;  CHECK TO SEE IF THE STEP COUNT GOES TO ZERO AND
;  IF SO WE STOP AND PRINT THE LOCATION.
;
CKSTEP:	DEC REPCNT	;MORE STEP BEFORE STOP?
	BNE RESUME	;YES, JUST COUNT DOWN
	MOVB	#'S,R3	;**MJ SHOW SINGLE STEP BPT.
 
 
;WE COME HERE TO PRINT OUT THE NAME OF THE ROUTINE
;  AND THE SEQUENCE NUMBER OF THE STATEMENT WE
;  HAVE STOPPED AT.  WE HAVE TO CONVERT THE RAD50
;  ROUTINE NAME TO ASCII AND ALSO ENCODE THE
;  SEQUENCE NUMBER IN ASCII.
;
IDENT:	MOV #ABUF,R5	;POINT TO ASCII BUFFER
	MOV #5015,(R5)+	;INSERT CR, LF
;INSERT BREAKPOINT ID
	MOVB	R3,(R5)+	;BPT ID
	MOVB	#'B,(R5)+	;BPT
	MOV	#": ,(R5)+
;
	JSR PC,NAME	;ENCODE ROUTINE NAME
	MOVB #'-,(R5)+	;INSERT "-" AFTER NAME
	MOV @$OTSV,R0	;GET SEQUENCE #
	JSR R5,DECNUM	;ENCODE # IN ASCII
	.WORD 3		;  3 DECIMAL DIGITS
	JSR PC,PRINTB	;PRINT THE BUFFER
			;FALL THRU TO PROMPT
 
 
;WE COME HERE TO INDICATE THAT WE ARE READY FOR
;  A NEW COMMAND.  WE SIMPLY PRINT THE PROMPT
;  AND INITIALIZE THE ARGUMENTS.
;
PROMPT:	.PRINT <<15><12><137>> ;CR, LF, PROMPT
	MOV #ARG3+2,R0	;POINT PAST ARG3
	CLR -(R0)	;ZERO ARG3
	CLR -(R0)	;ZERO ARG2
	CLR -(R0)	;ZERO ARG1
	MOV R0,ARGPTR	;FILL ARG1 FIRST
	CLR	ARGCNT	;**MJ ZERO ARGS TO START
	BIC #FL.OCT+FL.NEW,FLAGS ;DEFAULT TO DECIMAL ARGS
				;**MJ AND SHOW NO CHARS.
			;FALL THRU TO INWAIT
 
 
;WE COME HERE TO WAIT FOR THE USER TO TYPE A
;  CHARACTER ON THE TERMINAL.  INPUT IS PROCESSED
;  ONE CHARACTER AT A TIME.  IF THE CHARACTER
;  IS VALID, WE DISPATCH TO THE PROPER PRO-
;  CESSING ROUTINE THRU "COMTBL".
;
INWAIT:	DIR$ #TTIN	;WAIT FOR CHAR
	DIR$ #TTWT
	TST IOCNT	;DID HE TYPE TERMINATOR?
	BEQ PROMPT	;YES, JUST RE-PROMPT
	MOV INBUF,R0	;NO, GET CHAR CODE
	BIC #177600,R0	;MASK 7-BIT ASCII
	MOV R0,R1	;SAVE A COPY
	CMP R0,#12	;IS IT A LINE FEED?
	BNE 40$		;NO, GO CHECK IT
	JMP NXTVAR	;YES, OPEN NEXT VARIABLE
40$:	SUB #40,R0	;IS IT A PRINTING CHAR?
	BMI BAD		;NO, DON'T ACCEPT IT
	CMP R0,#77	;IS IT IN RANGE?
	BGT BAD		;NO, BAD COMMAND
	ASL R0		;YES, GET WORD INDEX
	JMP @COMTBL(R0)	;DISPATCH TO ROUTINE
 
 
;WE COME HERE TO LEAVE THE DEBUGGER AND RE-ENTER
;  THE FORTRAN THREADED CODE.
;
RESUME:	MOV (SP)+,R5	;RESTORE REGISTERS
	MOV (SP)+,R4
	MOV (SP)+,R3
	MOV (SP)+,R2
	MOV (SP)+,R1
	MOV (SP)+,R0
GOBACK:	JMP @(R4)+	;RE-ENTER FORTRAN
 
 
;WE COME HERE IF THE USER TYPES ANYTHING THAT IS
;  ILLEGAL OR UNRECOGNIZABLE.
;
BAD:	.PRINT </ ???/>	;SHOW PUZZLEMENT
	BR PROMPT	;GO TRY AGAIN
 
 
;WE COME HERE WHEN THE USER TYPES A DIGIT.  WE
;  ENTER AT "OCDIG" FOR VALID OCTAL DIGITS (0-7)
;  AND AT "DECDIG" FOR 8 AND 9.  THUS WE CAN
;  CHECK FOR INVALID DIGITS IN OCTAL MODE.
;WE MULTIPLY THE OLD VALUE OF ARG BY 8 OR 10
;  DEPENDING ON THE CURRENT RADIX MODE, AND
;  ADD THE NEW DIGIT TO IT.
;
DECDIG:	BIT #FL.OCT,FLAGS ;EXPECTING OCTAL?
	BNE BAD		;YES, REJECT 8 OR 9
 
OCDIG:	SUB #60,R1	;CONVERT ASCII TO BINARY
	MOV @ARGPTR,R3	;GET CURRENT ARG
	BIT #FL.OCT,FLAGS ;ARE WE IN OCTAL MODE?
	BNE 80$		;YES, MULT BY 8
	MUL #10.,R3	;NO, MULT BY 10
	BR 100$		;SKIP OCTAL
80$:	ASH #3,R3	;FAST MULT BY 8
100$:	ADD R1,R3	;ADD IN NEW DIGIT
	MOV R3,@ARGPTR	;STORE NEW VALUE
	BIT	#FL.NEW,FLAGS	;**MJ FIRST CHAR?
	BNE	INWAIT		;**MJ NO, WAIT FOR MORE
	BIS	#FL.NEW,FLAGS	;**MJ YES, SHOW WE SAW IT
	INC	ARGCNT		;**MJ AND COUNT AN ARGUMENT
	BR INWAIT	;GO WAIT FOR MORE
 
 
;WE COME HERE WHEN THE USER TYPES AN ARGUMENT
;  SEPARATOR (; OR ,).  WE PREPARE TO ACCEPT
;  A NEW ARGUMENT BY BUMPING THE POINTER TO
;  POINT TO THE NEXT ONE AND RESET THE "FL.OCT"
;  FLAG SO THE FOLLOWING INPUT WILL DEFAULT
;  TO DECIMAL.
;
NXTARG:	BIT	#FL.NEW,FLAGS	;**MJ ANY CHARS FOR THE LAST ARG?
	BNE	1$		;**MJ YES, WE'VE COUNTED IT
	INC	ARGCNT		;**MJ NO CHARS, COUNT THE ARG ANYWAY.
1$:	BIC #FL.OCT+FL.NEW,FLAGS ;DEFAULT TO DECIMAL
				;**MJ AND SHOW NO CHARS YET
	ADD #2,ARGPTR	;POINT TO NEXT ARG
	CMP ARGPTR,#ARG3 ;DO WE HAVE 3 ALREADY?
	BHI BAD		;YES, TELL HIM NO GO
	CLR @ARGPTR	;NO, INIT NEW ARG
	BR INWAIT	;GO WAIT FOR MORE
 
 
;WE COME HERE WHEN HE TYPES "S" TO STEP THRU
;  HIS PROGRAM.  WE SET THE MODE TO REMEMBER
;  THAT WE ARE STEPPING AND SET THE REPETITION
;  COUNT FROM ARG1.
;
STEP:	MOV #2,MODE	;STEP THRU STATEMENTS
	MOV	ARG1,REPCNT	;**MJ GET NUMBER OF STEPS
	BNE	RESUME		;**MJ ANY NUMBER IS OK
	INC	REPCNT		;**MJ 0=> 1 STEP
	BR	RESUME
 
 
;WE COME HERE TO PROCEED FROM THE CURRENT STOP.
;  IT'S JUST LIKE "STEP" ABOVE EXCEPT THAT THE
;  MODE IS DIFFERENT.
;
PROCED:	MOV #4,MODE	;LOOKING FOR BREAKPOINT
;
; SET ALL BPT COUNTERS TO 1 (IE. STOP IF WE HIT ONE)
;
	MOV	#BTAB+6,R3	;**MJ COUNT WORD OF FIRST ENTRY
	MOV	#8.,R2		;**MJ NUMBER OF ENTRIES
1$:	MOV	#1,@R3		;**MJ SET COUNT TO 1
	ADD	#8.,R3		;**MJ MOVE TO NEXT ENTRY
	SOB	R2,1$		;**MJ CONTINUE FOR ALL ENTRIES
;
; PUT COUNT (IF ANY) IN CURRENT BPT
;
	MOV	ARG1,@BCUR	;**MJ INSERT COUNT
	BNE	RESUME		;**MJ POS NUM OK
	INC	@BCUR		;**MJ 0=> 1
	BR	RESUME
 
 
;WE COME HERE WHEN THE USER TYPES THE "B" COMMAND
;  TO SET OR REMOVE A BREAKPOINT.  ARG1 IS USED
;  AS THE SEQUENCE NUMBER OF THE STATEMENT TO
;  BE TRAPPED.  IF ARG1 IS ZERO, WE ASSUME HE
;  WANTS TO REMOVE THE BREAKPOINT.
;IF ARG1 IS NONZERO, WE USE IT AND ASK HIM FOR
;  THE NAME OF THE ROUTINE IN WHICH THIS BREAK-
;  POINT IS TO BE SET.  WE HAVE NO WAY TO CHECK
;  THAT THE NAME IS THAT OF A VALID ROUTINE, SO
;  HE HAD BETTER TYPE IT CORRECTLY OR THE
;  PROGRAM WILL NEVER HIT THE BREAKPOINT.
;
BRKPT:	DEC	ARGCNT	;**MJ ANY ARGS?
	BEQ	2$	;**MJ ONE, DELETE SPECIFIC BPT
	BPL	3$	;**MJ TWO, ADD A BPT
;
; NO ARGS => B COMMAND
;		DELETE ALL BREAKPOINTS.
	MOV	#BTAB,R3	;**MJ TABLE ADDRESS
	MOV	#8.,R2		;**MJ NO. OF ENTRIES
1$:	CLR	@R3		;**MJ REMOVE THE BPT
	ADD	#8.,R3		;**MJ MOVE TO NEXT
	SOB	R2,1$		;**MJ REPEAT UNTIL DONE
	JMP	PROMPT		;**MJ NEXT COMMAND
;
; ONE ARG => NB COMMAND
;		DELETE SPECIFIC BREAKPOINT.
2$:	MOV	ARG1,R3		;**MJ GET BPT NUMBER
	CMP	R3,#7		;**MJ LEGIT BPT NUMBER??
	BGT	BAD		;**MJ NOPE.
	ASH	#3,R3		;**MJ YEP, CONVERT TO OFFSET
	CLR	BTAB(R3)	;**MJ AND REMOVE IT.
	JMP	PROMPT		;**MJ NEXT COMMAND?
;
; TWO ARGS => S,NB COMMAND
;		SET A BREAKPOINT.
3$:	MOV	ARG2,R3		;**MJ GET BPT NUMBER
	CMP	R3,#7		;**MJ LEGIT?
	BGT	BAD		;**MJ NOPE.
	ASH	#3,R3		;**MJ YEP, CONVERT TO OFFSET
	ADD	#BTAB,R3	;**MJ THEN TO POINTER TO BPT ENTRY
	MOV	ARG1,(R3)	;**MJ SET SEQUENCE NUMBER
	BGT	4$		;**MJ MUST BE GT ZERO
	CLR	(R3)		;**MJ ELSE REJECT
	BR	BAD
4$:	CMP	(R3)+,#999.	;**MJ ALSO NOT TOO BIG
	BLT	GETNAM		;**MJ
	CLR	-(R3)		;**MJ
	BR	BAD
GETNAM:	.PRINT </   SUBROUTINE:/>
	DIR$ #NAMIN	;ASK FOR ROUTINE NAME
	DIR$ #TTWT
	MOV IOCNT,R0	;GET INPUT COUNT
	BNE 80$		;BRANCH IF NOT NULL
	CLR (R3)	;NULL MEANS THE BREAK-
	BR PRMT1	;  POINT IS IN "MAIN"
80$:	CMPB ABUF,#'-	;IS IT A DASH?
	BNE	77$	;NO, GET NEW NAME
	MOV	BNAM1,(R3)+	;YES, USE LAST ROUTINE NAME
	MOV	BNAM2,(R3)
	BR	PRMT1
77$:	ADD #ABUF,R0	;POINT PAST STRING
100$:	CLRB (R0)+	;CLEAR UNFILLED BYTE
	CMP R0,#ABUF+6	;ARE WE PAST NAME?
	BLOS 100$	;NO, CLEAR ANOTHER BYTE
	MOV #ABUF,R2	;POINT TO ASCII NAME
RTOA:	MOV #2,R0	;INIT WORD COUNT
20$:	MOV #3,R1	;INIT CHAR/WD COUNT
	CLR R5		;INIT RAD50 WORD
30$:	MOVB (R2)+,R4	;GET NEXT ASCII CHAR
	BEQ 120$	;NULL BECOMES NULL
	SUB #100,R4	;IS IT A LETTER?
	BGT 100$	;MAYBE, GO CHECK
	ADD #20,R4	;NO, CHECK DIGITS
	BMI 40$		;TOO LOW FOR DIGIT
	CMP R4,#11	;IS IT 60-71?
	BGT BADNAM	;NO, NOT RAD50 CHAR
	ADD #36,R4	;YES, GET RAD50 CODE
	BR 120$		;GO INSERT IT
 
	;HERE WE KNOW THE ASCII CODE IS <60
40$:	ADD #2,R4	;IS IT 56(.)?
	BNE 60$		;NO, KEEP CHECKING
	MOV #34,R4	;YES, GET RAD50 CODE
	BR 120$		;GO INSERT IT
60$:	ADD #12,R4	;IS IT 44($)?
	BNE BADNAM	;NO, NOT RAD50 CHAR
	MOV #33,R4	;YES, GET RAD50 CODE
	BR 120$		;GO INSERT IT
100$:	CMP R4,#32	;IS IT ABOVE 132?
	BGT BADNAM	;YES, NOT RAD50
120$:	MUL #50,R5	;PREVIOUS X 50(8)
	ADD R4,R5	;INSERT NEW CODE
	SOB R1,30$	;3-CHAR LOOP
	MOV R5,(R3)+	;DEPOSIT RAD50 WORD
	SOB R0,20$	;2-WORD LOOP
	MOV	-(R3),BNAM2	;**MJ SAVE OLD NAME
	MOV	-(R3),BNAM1	;**MJ
PRMT1:	JMP PROMPT	;GET NEXT COMMAND
 
 
BADNAM:	.PRINT <<15><12>/INVALID NAME..../>
	BR GETNAM	;GO TRY AGAIN
;
;WE COME HERE WHEN THE USER TYPES THE "D" COMMAND
; TO DISPLAY ONE OR ALL BREAKPOINT LOCATIONS.
;
DISBPT:	TST	ARGCNT	;ALL OR ONE?
	BEQ	1$		;ALL, BRANCH
	MOV	ARG1,R3		;GET BPT NUMBER
	CMP	R3,#7		;LEGIT BPT NUM?
	BLE	11$		;YES, LEGIT
	JMP	BAD		;NO, THEN COMPLAIN
11$:	ASH	#3,R3		;CONVERT TO OFFSET
	ADD	#BTAB,R3	;POINT AT ENTRY IN TABLE
	JSR	PC,SHOBPT	;DISPLAY BPT INFO
3$:	JMP	PROMPT		;GET NEXT COMMAND
;
1$:	MOV	#BTAB,R3	;FIRST ENTRY
5$:	TST	@R3		;TEST ENTRY
	BMI	3$		;-1 INDICATES END OF TABLE
	JSR	PC,SHOBPT	;DISPLAY THE ENTRY
	ADD	#8.,R3		;MOVE TO NEXT
	BR	5$
;
;THIS SUBROUTINE SHOWS ONE BREAKPOINT ENTRY
; FORMAT: NB: RRRRRR-SSS
;
SHOBPT:	MOV	#ABUF,R5	;ADDRESS OF OUTPUT BUF
	MOV	#5015,(R5)+	;INSERT CR,LF
	MOV	R3,R2		;ADDR OF ENTRY
	SUB	#BTAB,R2	;OFFSET OF ENTRY
	ASH	#-3,R2		;NUMBER OF ENTRY
	ADD	#60,R2	;CONVERT TO CHARACTER
	MOVB	R2,(R5)+	;INSERT IN LINE
	MOVB	#'B,(R5)+	;BPT IDENTIFIER
	MOV	#": ,(R5)+	;SEPARATOR
	TST	@R3		;IS THIS ENTRY USED?
	BNE	1$		;YES, JUMP TO ROUTINE NAME OUTPUT
	MOV	#UNUSED,R2	;NO, PREPARE TO COPY MESSAGE
2$:	MOVB	(R2)+,(R5)+	;ONE CHAR AT A TIME
	BNE	2$		;CONTINUE UNTIL NULL
	DEC	R5		;BACK TO LAST CHAR
	BR	3$
;
1$:	MOV	2(R3),R1	;GET FIRST HALF OF NAME
	BNE	4$		;IF NON-ZERO, THEN NAME
	MOV	DEFNAM,4(R3)	;ELSE, USE DEFAULT
	MOV	DEFNAM+2,R1
4$:	JSR	PC,R50ASC
	MOV	4(R3),R1
	JSR	PC,R50ASC
	MOVB	#'-,(R5)+
	MOV	@R3,R0		;GET SEQUENCE NUMBER
	JSR	R5,DECNUM
	.WORD	3		;THREE DIGITS
3$:	JMP	PRINTB
UNUSED:	.ASCIZ	/UNUSED./
	.EVEN
 
 
;WE COME HERE WHEN THE USER TYPES THE "L" COMMAND
;  TO CHANGE THE LUN ON WHICH "FODT" DOES I/O.
;
LUNSET:	MOVB ARG1,R0	;GET NEW LUN #
	BLE 50$		;BRANCH IF UNREASONABLE
	MOV TTOUT+Q.IOLU,R1 ;SAVE OLD LUN #
	MOV R0,TTOUT+Q.IOLU ;SET NEW OUTPUT LUN #
	.PRINT <<12>\FODT I/O TERMINAL\<15>>
	TST $DSW		;DID QIO SUCCEED?
	BMI 40$		;NO, CHANGE BACK
	TSTB IOSTAT	;DID OUTPUT SUCCEED?
	BPL 60$		;YES, FINISH CHANGING
40$:	MOV R1,TTOUT+Q.IOLU ;NO, BACK TO OLD LUN #
50$:	JMP BAD		;GO SHOW ERROR CONDITION
60$:	MOV R0,TTIN+Q.IOLU ;FIX INPUT QIO
	MOV R0,NAMIN+Q.IOLU ;FIX NAME INPUT QIO
	BR PRMT1	;GO PROMPT ON NEW LUN
 
 
;WE COME HERE WHEN THE USER TYPES "O" TO SIGNIFY
;  THAT THE FOLLOWING ARGUMENT IS TO BE INTER-
;  PRETED AS OCTAL DIGITS.  WE SET A FLAG WHICH
;  IS TESTED EACH TIME A DIGIT IS TYPED.
;
OMODE:	BIS #FL.OCT,FLAGS ;SET "OCTAL" FLAG
	JMP INWAIT	;GO GET MORE INPUT
 
 
;WE COME HERE WHEN THE USER INDICATES HE WANTS
;  TO GET OUT OF THE TASK ALTOGETHER BY TYPING
;  "X".
;
EXIT:	JMP STP$	;EXIT THROUGH FORTRAN
 
 
;WE COME HERE IF THE USER WANTS A REAL VARIABLE
;  OPENED.  WE USE A COMMON SUBROUTINE TO SETUP
;  FOR REAL VARIABLES AND GET THE ACTUAL ADDRESS.
;
REAL:	JSR R5,VARADR	;SETUP "OPNXXX" PARAMS
	.WORD 4,RVAR
	BR OPEN
 
 
;WE COME HERE IF THE USER WANTS TO OPEN AN
;  INTEGER VARIABLE.
;
INTEGR:	JSR R5,VARADR	;SETUP "OPNXXX" PARAMS
	.WORD 2,IVAR
	BR OPEN		;GO OPEN IT
 
 
;WE COME HERE IF HE WANTS TO HAVE AN INTEGER
;  VARIABLE PRINTED IN OCTAL FORMAT.
;
OCTAL:	JSR R5,VARADR	;SETUP OPNXXX FOR OCTAL
	.WORD 2,OVAR
	BR OPEN		;GO PRINT OCTAL
 
 
;WE COME HERE IF HE TYPES "A" TO HAVE A 16-BIT
;  WORD DISPLAYED AS ONE ASCII CHARACTER.
;
ASCII:	BIS	#FL.ASC,FLAGS	;***MN SET ASCII FLAG
	JSR R5,VARADR	;SETUP OPNXXX FOR ASCII
	.WORD 2,AVAR
	BR OPEN		;GO DISPLAY ASCII
 
 
;WE COME HERE WHEN HE TYPES LINE FEED TO OPEN THE
;  NEXT VARIABLE.  WE ASSUME IT IS THE SAME TYPE
;  AS THE LAST VARIABLE OPENED.
;
NXTVAR:	ADD OPNSIZ,OPNADR ;POINT TO NEXT VARIABLE
	BR OPEN		;GO PRINT CONTENTS
 
 
;WE COME HERE WHEN HE TYPES UP ARROW (^) TO OPEN
;  THE VARIABLE PRECEDING THE LAST ONE OPENED.
;
LASVAR:	SUB OPNSIZ,OPNADR ;BACK UP TO LAST VAR
			;FALL THRU TO OPEN
 
 
;THIS ROUTINE OPENS A VARIABLE AND DISPAYS THE
;  CONTENTS FOR THE USER.  IT USES THE "OPNXXX"
;  VARIABLES FOR ALL INFORMATION ABOUT THE
;  VARIABLE.
;
OPEN:	MOV OPNTYP,R0	;GET PTR TO PARAM STRING
	BNE 20$		;SKIP IF IT HAS BEEN SETUP
	JMP BAD		;NOT SET, GIVE ERROR
20$:	MOV @0(R0),TTOUT+Q.IOPL+2 ;SET QIO LENGTH
	MOV (R0)+,-(SP)	;PUSH BYTE CNT ADDR
	MOV (R0)+,-(SP)	;PUSH FORMAT ADDR
	MOV (R0)+,ENCTV	;SET CORRECT CONVERSION
	MOV OPNADR,ENCVAR ;SET VARIABLE ADDR
	MOV #ENC,R4	;SETUP POLISH THREAD
	JMP @(R4)+	;ENTER THREADED CODE
 
;THIS IS THREADED CODE TO ENCODE THE OPENED VARIABLE
;  INTO "ABUF".
;
ENC:	REL$	;PUSH THE FOLLOWING ADDR
	ABUF	;ADDR OF ASCII BUFFER
	ENC$	;ENCODE
	REL$	;PUSH THE FOLLOWING ADDR
ENCVAR: 0	;ADDR OF VAR TO ENCODE
ENCTV:	0	;GOTO CORRECT CONVERSION ROUTINE
	EOL$	;FINISH THE ENCODE
	.+2	;EXIT THREADED CODE
 
	MOV #ABUF,TTOUT+Q.IOPL ;SET BUF ADDR
	DIR$ #TTOUT	;PRINT THE VARIABLE
	DIR$ #TTWT
PRMT2:	JMP PROMPT	;GO WAIT FOR MORE
 
 
;THIS SUBROUTINE IS USED TO SETUP THE "OPNXXX"
;  PARAMETERS DESCRIBING A VARIABLE TO BE OPENED.
;THE FORMAT OF THE CALL IS:
;	JSR R5,VARADR
;	.WORD (LENGTH OF VARIABLE IN BYTES)
;	.WORD (ADDR OF PARAM LIST FOR VARIABLE TYPE)
;
VARADR:	MOV ARG2,R1	;GET ELEMENT #
	BEQ 40$		;OK IF ZERO
	DEC R1		;ELSE ADJUST FOR ZERO ORIGIN
40$:	MOV @R5,OPNSIZ	;SAVE VAR SIZE
	MUL (R5)+,R1	;GET OFFSET FROM ELMT 1
	MOV (R5)+,OPNTYP ;SAVE PTR TO PARAM STRING
	MOV ARG1,R0	;GET RELATIVE VAR ADDR
	TST ARG3	;DID HE GIVE ABSOLUTE BASE?
	BEQ 50$		;NO, USE CURRENT ROUTINE BASE
	ADD ARG3,R0	;YES, ADD BASE TO OFFSET
	BR 60$		;SKIP ROUTINE OFFSET
50$:	ADD BASE,R0	;MAKE IT ABS ADDR
	CMP R0,PARLIM	;IS IT A PARAMETER?
	BHIS 60$	;NO, LOCAL VARIABLE
	MOV @R0,R0	;YES, GET ACTUAL ADDR
60$:	ADD R1,R0	;ADD OFFSET TO ELEMENT
	BIT	#FL.ASC,FLAGS	;***MN ASCII FLG SET?
	BNE	61$		;***MN YES, DON'T OFFSET TO WORDS.
	BIC #1,R0	;FORCE IT TO BE EVEN
61$:	MOV R0,OPNADR	;SAVE ABS ADDR OF ELMT
	RTS R5		;ALL SET TO OPEN

	.NLIST BEX
 
;THESE ARE THE PARAMETERS NEEDED TO OPEN THE
;  VARIOUS TYPES OF VARIABLES AND ENCODE THEM
;  INTO A SUITABLE FORMAT FOR OUTPUT TO THE
;  USER'S TERMINAL.
 
;***** REAL *****
RVAR:	RSIZ	;ADDR OF REAL FIELD SIZE
	RFMT	;ADDR OF REAL FORMAT
	TVF$	;ADDR OF REAL CONVERSION ROUTINE
 
RSIZ:	.WORD 14.	;SIZE CONSTANT
RFMT:	.BYTE 34,16,7,6 ;COMPILED G14.7 FORMAT
	.EVEN
 
 
;***** INTEGER *****
IVAR:	ISIZ	;ADDR OF INTEGER FIELD SIZE
	IFMT	;ADDR OF INTEGER FORMAT
	TVI$	;ADDR OF INTEGER CONV ROUTINE
 
ISIZ:	.WORD 10.	;SIZE CONSTANT
IFMT:	.BYTE 22,10.,6	;COMPILED I10 FORMAT
	.EVEN
 
 
;***** OCTAL *****
OVAR:	OSIZ	;ADDR OF OCTAL FIELD SIZE
	OFMT	;ADDR OF OCTAL FORMAT
	TVI$	;ADDR OF INTEGER CONV ROUTINE
 
OSIZ:	.WORD 10.	;OCTAL FIELD SIZE
OFMT:	.BYTE 24,10.,6	;COMPILED O10 FORMAT
	.EVEN
 
 
;***** ASCII *****
AVAR:	ASIZ	;ADDR OF ASCII FIELD SIZE
	AFMT	;ADDR OF ASCII FORMAT
	TVI$	;ADDR OF INTEGER CONV ROUTINE
 
ASIZ:	.WORD 6	;ASCII FIELD SIZE
AFMT:	.BYTE 246,3,20,1,6 ; FORMAT(4X,A1)
	.EVEN
	.LIST BEX

;THIS SUBROUTINE WILL CONVERT A NUMBER IN R0 TO ITS
;  ASCII REPRESENTATION IN A BUFFER POINTED TO BY
;  R5.  THE NUMBER CAN BE CONVERTED TO A REPRESENTATION
;  IN ANY RADIX FROM 1 TO 10.
;THREE DIFFERENT ENTRY POINTS ARE PROVIDED.
;  THE "OCNUM" AND "DECNUM" ENTRY POINTS ARE PROVIDED
;  FOR ENCODING NUMBERS INTO OCTAL AND DECIMAL
;  RESPECTIVELY.  THEY SET THE RADIX AUTOMATICALLY
;  AND EXPECT TO BE CALLED WITH "JSR R5" AND HAVE
;  THE WORD SPECIFYING THE NUMBER OF DIGITS IN
;  THE WORD FOLLOWING THE JSR.
;
;	JSR R5,OCNUM (OR DECNUM)
;	.WORD 3      (OR 100003 FOR LEADING ZEROES)
;
;THE THIRD ENTRY POINT IS "ENCOD".  IT IS A GENERAL
;  PURPOSE ENTRY WHICH ALLOWS SETTING BOTH THE
;  NUMBER OF DIGITS AND THE RADIX.  THESE TWO
;  PARAMETERS MUST BE PUSHED ON THE STACK AND
;  THEN THE SUBROUTINE IS CALLED WITH "JSR PC".
;
;	MOV #DIGITS,-(SP)	;PUSH # OF DIGITS
;	MOV #RADIX,-(SP)	;PUSH RADIX
;	JSR PC,ENCOD
;
;FOR ALL THREE ENTRY POINTS R0 MUST CONTAIN THE
;  NUMBER TO BE ENCODED, AND R5 MUST POINT TO THE
;  BUFFER WHERE THE ASCII STRING IS TO BE BUILT.
;ALL REGISTERS ARE UNCHANGED EXCEPT THAT UPON
;  RETURN R5 WILL POINT TO THE NEXT BYTE AFTER
;  THE ENCODED NUMBER STRING.
;LEADING ZEROES WILL BE SUPPRESSED IN THE
;  ASCII REPRESENTAION UNLESS THE SIGN BIT
;  OF THE WORD SPECIFYING THE NUMBER OF DIGITS
;  IS A ONE.
;	SUPPRESS LEADING ZEROES - 3
;	MAINTAIN LEADING ZEROES - 100003
;
OCNUM:	MOV (R5)+,-(SP)	;GET # OF DIGITS
	MOV #8.,-(SP)	;PUSH THE RADIX
	BR DN40		;GO SHARE CODE
 
 
DECNUM:	MOV (R5)+,-(SP)	;GET # OF DIGITS
	MOV #10.,-(SP)	;PUSH RADIX
DN40:	MOV 4(SP),-(SP)	;SAVE OLD R5
	MOV R5,6(SP)	;SAVE PC RETURN ADDR
	MOV (SP)+,R5	;GET OLD R5 BACK
 
 
ENCOD:	MOV R2,-(SP)	;SAVE R2
	MOV 4(SP),R2	;GET DIGIT COUNT IN R2
	MOV R0,4(SP)	;SAVE R0
	MOV R3,-(SP)	;SAVE R3
	MOV 4(SP),R3	;GET RADIX IN R3
	MOV R1,4(SP)	;SAVE R1
	MOV R4,-(SP)	;SAVE R4
	MOV R2,R4	;GET COPY OF DIGIT COUNT
20$:	MOV R0,R1	;GET DIVIDEND IN R1
	CLR R0		;CLEAR HIGH DIVIDEND
	DIV R3,R0	;DIVIDE BY RADIX
	MOV R1,-(SP)	;SAVE REMAINDER ON STACK
	DECB R4		;COUNT # OF DIGITS
	BNE 20$		;LOOP IF NOT DONE
40$:	MOV (SP)+,R0	;GET DIGIT OFF STACK
	BNE 60$		;PROCESS NORMALLY IF NONZERO
	TST R2		;IS IT A LEADING ZERO?
	BMI 60$		;NO, MAKE IT A ZERO
	MOVB #40,(R5)+	;YES, MAKE IT A SPACE
	BR 80$		;GO TO END OF LOOP
60$:	ADD #60,R0	;CONVERT # TO ASCII DIGIT
	MOVB R0,(R5)+	;INSERT DIGIT IN STRING
	BIS #100000,R2	;REMEMBER NONZERO DIGIT
80$:	DECB R2		;COUNT # OF DIGITS
	BNE 40$		;LOOP IF NOT DONE
	CMPB -1(R5),#40	;WAS # ALL ZEROES?
	BNE 100$	;NO, IT'S OK
	MOVB #60,-1(R5)	;YES, MAKE LAST DIGIT ZERO
100$:	MOV (SP)+,R4	;RESTORE REGISTERS
	MOV (SP)+,R3
	MOV (SP)+,R2
	MOV (SP)+,R1
	MOV (SP)+,R0
	RTS PC		;DIGITS ARE IN STRING
 

;THIS SUBROUTINE WILL SEND A MESSAGE TO THE
;   TERMINAL WHERE THE USER IS RUNNING.  IT
;   IS CALLED BY "JSR R5,PRINT".  THUS, UPON ENTRY
;   R5 IS POINTING TO THE WORD FOLLOWING THE CALL
;   WHICH CONTAINS THE NO. OF BYTES IN THE MESSAGE.
;   THAT WORD IS FOLLOWED BY THE MESSAGE ITSSELF.
;IT RETURNS TO THE 1ST EVEN ADDRESS PAST THE END
;   OF THE MESSAGE STRING.
PRINT:	MOV (R5)+,TTOUT+Q.IOPL+2 ;SET BYTE COUNT FOR TTOUT
	MOV R5,TTOUT+Q.IOPL ;SETUP BUFFER ADDRESS
	DIR$ #TTOUT	;SEND THE MESSAGE
	DIR$ #TTWT
	ADD -2(R5),R5	;POINT TO 1 PAST STRING
	INC R5		;BUMP IN CASE ITS ODD
	BIC #1,R5	;FORCE IT TO BE EVEN
	RTS R5		;RETURN FROM PRINTING
 
 
;THIS SUBROUTINE WILL GET THE NAME OF THE ROUTINE
;  WE ARE CURRENTLY IN AND CONVERT IT FROM RAD50
;  TO ASCII IN THE BUFFER POINTED TO BY R5.
;IT USES R0-R5 AND LEAVES R5 POINTING PAST THE
;  NAME STRING IN THE BUFFER.
;
NAME:	MOV $OTSV,R3	;GET WORK AREA POINTER
	MOV W.NAM(R3),R2 ;GET NAME POINTER
	BNE 40$		;BRANCH IF NOT NULL
	MOV #DEFNAM,R2	;NULL, USE ".MAIN."
40$:	ADD #4,R2	;POINT PAST RAD50
	MOV #2,-(SP)	;INIT WORD COUNTER
60$:	MOV -(R2),R1	;GET RAD50 WORD
	JSR	PC,R50ASC	;**MJ CONVERT THE WORD
	DEC @SP		;COUNT WORDS
	BNE 60$		;GET NEXT WORD
	TST (SP)+	;CLEAR STACK
120$:	RTS PC		;NAME IS IN "ABUF"
 
DEFNAM:	.RAD50 /IN./	;DEFAULT NAME OF MAIN
	.RAD50 /.MA/	;  PROGRAM
;
; THIS ROUTINE CONVERTS ONE RAD50 WORD (IN R1) TO
;	THREE ASCII CHARACTERS (AT R5)
;
R50ASC:	MOV	R2,-(SP)	;SAVE WORK REGISTER
	MOV	#3,R2		;CHARACTER COUNT
	ADD	R2,R5		;MOV TO LAST CHARACTER
80$:	CLR R0		;CLEAR HIGH DIVIDEND
	DIV #50,R0	;DIVIDE BY RADIX
	MOVB RTBL(R1),-(R5) ;LOOKUP ASCII CHAR
	MOV R0,R1	;MAKE QUOTIENT LOW DIV
	SOB R2,80$	; 3 CHAR LOOP
	ADD #3,R5	;POINT PAST CHARS
	MOV	(SP)+,R2	;RESTORE WORK REG
	RTS	PC
 
	.NLIST BEX
;THIS IS A RAD50 TO ASCII LOOKUP TABLE
RTBL:	.BYTE ' ,'A,'B,'C,'D,'E,'F,'G
	.BYTE 'H,'I,'J,'K,'L,'M,'N,'O
	.BYTE 'P,'Q,'R,'S,'T,'U,'V,'W
	.BYTE 'X,'Y,'Z,'$,'.,' ,'0,'1
	.BYTE '2,'3,'4,'5,'6,'7,'8,'9
	.LIST BEX
 
 
;THIS SUBROUTINE WILL PRINT A STRING WHICH HAS
;  BEEN BUILT IN "ABUF".  THE POINTER PAST THE
;  END OF THE STRING MUST BE IN R5.
;
PRINTB:	SUB #ABUF,R5	;GET BYTE COUNT
	MOV R5,TTOUT+Q.IOPL+2 ;SET QIO COUNT
	MOV #ABUF,TTOUT+Q.IOPL ;SET BUF ADDR
	DIR$ #TTOUT	;PRINT THE BUFFER
	DIR$ #TTWT
	RTS PC		;IT'S PRINTED
 
 
;THIS IS THE DISPATCH TABLE FOR ALL VALID ASCII
;  CHARACTERS THE USER MIGHT TYPE IN
;
COMTBL:	INWAIT	;SPACE
	BAD	; !
	BAD	; "
	BAD	; #
	BAD	; $
	BAD	; %
	BAD	; &
	BAD	; '
	BAD	; (
	BAD	; )
	BAD	; *
	BAD	; +
	NXTARG	; ,
	BAD	; -
	BAD	; .
	OPEN	; /
	OCDIG	; 0
	OCDIG	; 1
	OCDIG	; 2
	OCDIG	; 3
	OCDIG	; 4
	OCDIG	; 5
	OCDIG	; 6
	OCDIG	; 7
	DECDIG	; 8
	DECDIG	; 9
	OMODE	; :
	NXTARG	; ;
	BAD	; <
	BAD	; =
	BAD	; >
	BAD	; ?
	BAD	; @
	ASCII	; A
	BRKPT	; B
	BAD	; C
	DISBPT	; D
	BAD	; E
	BAD	; F
	PROCED	; G
	BAD	; H
	INTEGR	; I
	BAD	; J
	BAD	; K
	LUNSET	; L
	BAD	; M
	BAD	; N
	OCTAL	; O
	PROCED	; P
	BAD	; Q
	REAL	; R
	STEP	; S
	BAD	; T
	BAD	; U
	BAD	; V
	BAD	; W
	EXIT	; X
	BAD	; Y
	BAD	; Z
	BAD	; [
	BAD	; \
	BAD	; ]
	LASVAR	; ^
	BAD	; _
 
 

.NLIST BEX
 
;THESE ARE INTERNAL VARIABLES USED BY FODT
;
MODE:	.WORD 0		;DETERMINE ACTION UPON ENTRY
 
BASE:	.WORD 0		;BASE ADDR OF CURRENT ROUTINE
 
PARLIM:	.WORD 0		;UPPER LIMIT OF PARAMETER LIST
 
VARLIM:	.WORD 0		;UPPER LIMIT OF VARIABLES
 
REPCNT:	.WORD 0		;NUMBER OF TIMES REMAINING TO
			;  REPEAT THE CURRENT OPERATION
 
FLAGS:	.WORD 0		;INTERNAL OPERATIONAL FLAGS
FL.OCT=	40000		;SET FOR OCTAL INPUT
FL.NEW= 20000		;**MJ SET IF A CHARACTER HAS BEEN TYPED
FL.ASC=10000		;**MN SET IF ONLY ONE BYTE IS TO BE SHOWN
 
ARGCNT:	.WORD	0	;**MJ NUMBER OF ARGS SEEN
ARGPTR:	.WORD ARG1	;POINT TO CURRENT ARG
ARG1:	.WORD 0		;ARGUMENTS ENTERED BY THE USER
ARG2:	.WORD 0		;  ARE CONSTRUCTED HERE
ARG3:	.WORD 0
 
BNAM1:	.WORD 0		;2-WORD RAD50 NAME OF
BNAM2:	.WORD 0		;  LAST ROUTINE ENTERED
 
OPNADR:	.WORD 0		;ABS ADDR OF OPEN VARIABLE
OPNSIZ:	.WORD 0		;SIZE OF OPEN VAR IN BYTES
OPNTYP:	.WORD 0		;POINTER TO FORMAT PARAMS
 
 
;
; BREAKPOINT TABLE.
;
; EACH ENTRY IN THE TABLE CONSISTS OF 4 WORDS:
; 	WORD 1 - SEQUENCE NUMBER OF BREAKPOINT STATEMENT
;		 	0=>ENTRY IS NOT USED
;			-1 => END OF TABLE
;	WORD 2 - NAME OF ROUTINE
;			0=> MAIN ROUTINE
;	WORD 3 - SECOND PART OF NAME
;	WORD 4 - BREAKPOINT COUNT (SET BY P COMMAND)
;
BTAB:	.BLKW	4*8.
	.WORD	-1	;TABLE TERMINATOR
BCUR:	.WORD	BTAB+6	;POINTS TO COUNT ENTRY OF CURRENT BPT
;
;
;BUFFERS AND DPB'S
;NOTE - THE BYTE COUNT FOR TTOUT IS MODIFIED BY
;  THE "PRINTB" AND "PRINT" SUBROUTINES.
TTOUT:	QIO$ IO.WVB,5,30.,,IOSTAT,,<ABUF,16.,0>
TTWT:	WTSE$ 30.
 
TTIN:	QIO$ IO.RVB,5,30.,,IOSTAT,,<INBUF,1>
 
NAMIN:	QIO$ IO.RVB,5,30.,,IOSTAT,,<ABUF,20.>
 
IOSTAT:	.WORD 0		;TERMINAL I/O STATUS
IOCNT:	.WORD 0		;TERMINAL I/O BYTE COUNT
 
ABUF:	.ASCII <15><12>/FODT DEBUGGER/
	.BLKB ABUF+30.-.
	.EVEN
 
INBUF:	.WORD 0		;TERMINAL 1-CHAR INPUT BUF
 
	.END