Directory of image this file is from
This file as a plain text file

/ ODT/8 TASK FOR RTS/8 V2B-A			9/1/77

	VERS=	1

/
/EDIT HISTORY
/
/21-DEC-67: (LHN)
/	1)  CREATED THIS DATE



	IFNDEF	ODTFLD	<ODTFLD=30>
	IFNDEF	ODTLOC	<ODTLOC=200>
	IFNDEF	ODT	<ODT=10>	/FOR TEST




	TASK=	ODT
	CUR=	ODTFLD
	INIWT=	RUNWT		/START UP IN RUN WAIT




	ODTDEV=	TTY		/USER TERMINAL HANDLER
	CLB=	CLL CLA
/
/
/ NOTATION USED TO EXPRESS ODT/8 COMMANDS
/
/
/ FOR CONSISTENCY, THE FOLLOWING NOTATION HAS BEEN ADOPTED
/ TO FACILITATE THE EXPRESSION AND UNDERSTANDING OF USER
/ KEYBOARD INTERACTION WITH ODT/8.
/
/
/ SYMBOL			MEANING
/
/   A		REPRESENTS AN ARGUMENT THAT IS USED TO
/		DEFINE AN ADDRESS, UP TO 5 OCTAL DIGITS LONG.
/		"A" MAY BE THE RESULT OF AN ARITHMETIC
/		EXPRESSION.
/
/   K		REPRESENTS AN OCTAL NUMBER UP TO 5 DIGITS IN
/		LENGTH, WITH A MAXIMUM VALUE OF 77777(8), OR
/		AN EXPRESSION WHICH REDUCES TO SUCH A VALUE.
/		"K" MAY BE PROCEEDED BY A MINUS SIGN, IN 
/		WHICH CASE THE 2'S COMPLEMENT OF THE NUMBER
/		IS TAKEN BY ODT/8.
/
/   M		REPRESENTS AN OCTAL NUMBER UP TO 4 DIGITS IN
/		LENGTH, WITH A MAXIMUM VALUE OF 7777(8), OR
/		AN EXPRESSION WHICHS REDUCES TO SUCH A VALUE.
/		"M" MAY BE PROCEEDED BY A MINUS SIGN, IN
/		WHICH CASE THE 2'S COMPLEMENT OF THE NUMBER
/		IS USED BY ODT/8.
/
/   N		REPRESENTS AN OCTAL INTEGER IN THE RANGE OF
/		0 TO 7.
/
/   T (OR Y)	REPRESENTS A TASK NUMBER, IN THE RANGE OF 1
/		TO 177 OCTAL.
/
/
/
/ FORMS OF ARITHMENTIC EXPRESSIONS
/
/
/
/
/ ODT/8 COMMAND CHARACTERS AND SYMBOLS
/
/
/ FORMAT			MEANING
/
/   +		ARITHMETIC OPERATOR. SUM THE PRECEDING 
/ (OR SPACE)	ARGUMENT AND THE FOLLOWING ARGUMENT TO FORM
/		THE CURRENT EXPRESSION.
/
/   -		ARITHMETIC OPERATOR. SUBTRACT THE FOLLOWING
/		ARGUMENT FROM THE PRECEDING ARGUMENT TO FORM
/		THE CURRENT EXPRESSION.
/
/   ,		RELOCATION REGISTER OPERATOR. USE THE
/		PRECEDING 1-DIGIT OCTAL VALUE TO REFERENCE
/		ONE OF ODT'S EIGHT RELOCATION REGISTERS, AND
/		TAKE THE CONTENTS OF THIS REGISTER AND THE
/		VALUE OF THE ARGUMENT FOLLOWING THE COMMA TO
/		FORM THE CURRENT ARGUMENT. THUS, IN ODT/8
/		KEYBOARD COMMANDS, A COMMA SEPARATES A
/		RELOCATION REGISTER SPECIFIER FROM AN
/		ABSOLUTE VALUE, THE COMBINATION OF WHICH IS
/		NORMALLY USED TO SPECIFY RELOCATABLE
/		ADDRESS VALUES IN ODT COMMAND SEQUENCES.
/
/   .		CURRENT LOCATION OPERATOR. CAUSES THE ADDRESS
/		OF THE LAST EXPLICITLY-OPENED LOCATION TO BE
/		USED AS THE CURRENT ADDRESS FOR ODT/8
/		OPERATIONS. THIS IS THE ADDRESS ASSUMED BY
/		THE LEFT ANGLE BRACKET (<) COMMAND TO RETURN
/		TO THE PREVIOUS SEQUENCE OF OPENED LOCATIONS.
/		THIS ADDRESS IS ALSO IMPLIED IN THE USE OF
/		THE SLASH (/), SINGLE QUOTE ('), DOUBLE QUOTE
/		("), AND LINE FEED (LF) COMMANDS.
/
/   ;		ARGUMENT SEPARATOR. SEPARATES MULTIPLE
/		ARGUMENTS, CAUSING AN ADDRESS EXPRESSION OR
/		ODT REGISTER VALUE TO BE FOUND.
/
/
/ ODT/8 COMMAND CHARACTERS AND SYMBOLS
/
/
/ FORMAT			MEANING
/
/   /		WORD MODE OCTAL OPERATOR. REPRINT THE 
/  A/		CONTENTS OF THE LAST WORD LOCATION OPENED,
/		AND STORE THIS OCTAL WORD IN THE QUANTITY 
/		REGISTER ($Q). IF "/" IS PRECEDED BY "A", THE
/		VALUE "A" IS TAKEN AS THE ADDRESS OF A WORD 
/		LOCATION TO BE OPENED AND PRINTED.
/
/   "		WORD MODE ASCII OPERATOR. INTERPRET AND PRINT
/  A"		THE CONTENTS OF THE CURRENTLY-OPEN (OR LAST
/		PREVIOUSLY-OPENED) LOCATION AS TWO ASCII
/		CHARACTERS, AND STORE THIS WORD IN THE 
/		QUANTITY REGISTER ($Q). IF " IS PRECEDED
/		BY "A", THE VALUE "A" IS TAKEN AS THE ADDRESS
/		OF THE LOCATION TO BE INTERPRETED AND PRINTED.
/
/   '		BYTE MODE ASCII OPERATOR. INTERPRET AND PRINT
/  A'		THE CONTENTS OF THE CURRENTLY-OPEN (OR LAST
/		PREVIOUSLY-OPENED) LOCATION AS ONE ASCII
/		CHARACTER, AND STORE THIS WORD IN THE
/		QUANTITY REGISTER ($Q). IF ' IS PRECEDED BY
/		"A", THE VALUE "A" IS TAKEN AS THE ADDRESS OF
/		THE LOCATION TO BE INTERPRETED AND PRINTED.
/
/   K=		INTERPRET AND PRINT THE EXPRESSION VALUE "K"
/		AS FIVE OCTAL DIGITS AND STORE THIS VALUE IN
/		THE QUANTITY REGISTER ($Q).
/
/
/ ODT/8 COMMAND CHARACTERS AND SYMBOLS
/
/
/ FORMAT			MEANING
/
/   (CR)	CLOSE THE CURRENTLY-OPEN LOCATION AND ACCEPT
/  M(CR)	THE NEXT COMMAND. IF (CR) IS PRECEDED BY
/		"M", THE VALUE "M" REPLACES THE CONTENTS OF
/		THE CURRENTLY-OPEN LOCATION BEFORE IT IS
/		CLOSED.
/
/   (LF)	CLOSE THE CURRENTLY-OPEN LOCATION, OPEN THE
/  M(LF)	NEXT SEQUENTIAL LOCATION AND PRINT ITS
/		CONTENTS. IF (LF) IS PRECEDED BY "M", THE 
/		VALUE "M" REPLACES THE CONTENTS OF THE 
/		CURRENTLY-OPEN LOCATION BEFORE IT IS CLOSED.
/
/*-*
	FIELD ODTFLD%10
	*ODTLOC
/
/
/	RESIDENT PAGE OF  O D T / 8
/
/
/
/ CHARACTER INPUT ROUTINE
/
/
/ COME HERE TO GET THE NEXT INPUT CHARACTER FROM THE 
/ USER'S DEVICE IN CHARACTER MODE.
/
/ ON CALL: IF THE ACCUMULATOR = 0, ECHO THE LAST INPUT
/  CHARACTER. IF THE ACCUMULATOR IS NOT ZERO, IT
/  CONTAINS A 7 BIT ASCII CHARACTER TO OUTPUT BEFORE
/  REQUESTING AN INPUT CHARACTER.
/
/ ON RETURN: THE NEW INPUT CHARACTER IS IN THE
/  ACCUMULATOR, READY TO USE.
/
/
GETCHR,	0
	SNA		/AC CONTAIN A CHARACTER TO OUTPUT ?
	TAD ECHOCR	/NO, ECHO THE LAST INPUT CHARACTER.
	DCA OUTCHR
	DCA INCHAR	/DELETE THE OLD INPUT CHARACTER.
	DCA ECHOCR	/DELETE THE OLD ECHO CHARACTER.

	DCA CHRMSG	/FIRST CLEAR THE MESSAGE EVENT FLAG,
	CAL		/ THEN GO REQUEST ANOTHER USER INPUT
	SEND		/ CHARACTER.
	ODTDEV
	CHRMSG
	JMP I (EFWAIT	/NOW, GO WAIT FOR THE USER.

GETCRT,	ISZ CHRMSG	/SET THE #@% EVENT FLAG NOW TO AVOID
			/ THE CONFUSION LATER - IN "EFWAIT".
	TAD INCHAR	/GET THE NEW INPUT CHARACTER,
	AND (0177)	/ STRIP OFF THE PARITY BIT THEN
	TAD (200)	/ FORCE IT BACK ON SO THAT THE
	DCA INCHAR	/ CHARACTER LOOKS LIKE 8 BIT ASCII.

	TAD INCHAR	/IS THE NEW CHARACTER A LINE FEED ?
	TAD (-212)
	SZA
	TAD (-3)	/OR A CARRIAGE RETURN ?
	SNA CLA
	JMP GETC1	/YES, WE DON'T ECHO EITHER OF THEM.
/
	TAD INCHAR	/CHECK FOR ALTMODE - ALL 3 FLAVORS !
	AND (0177)
	TAD (-176)	/176
	SMA SZA		/IF .GT. 176, MUST BE A RUBOUT, SKIP
	JMP GETC2	/ THE REST OF THE CHARACTER CHECKS.
	SZA
	IAC		/175
	SZA
	TAD (175-33)	/033
	SZA CLA
	JMP .+3		/NOT ALTMODE, GO ON.
	TAD (244)	/CONVERT ALTMODE TO DOLLAR SIGN.
	DCA INCHAR
	TAD INCHAR
GETC1,	DCA ECHOCR	/SAVE CHARACTER TO ECHO TO USER.

	TAD INCHAR	/IS THE INPUT CHARACTER A SPACE ?
	TAD (-240)
	SZA
	JMP .+3
	TAD (253)	/YES, CONVERT IT TO A "+".
	DCA INCHAR

	TAD (240-341)	/INPUT CHARACTER IN LOWER CASE ?
	SPA
	JMP .+3
	TAD (301)	/YES, MAP IT TO UPPER CASE !
	DCA INCHAR
GETC2,	CLB

	TAD INCHAR	/PUT THE NEW CHARACTER IN THE AC,
	JMP I GETCHR	/ AND RETURN.


CHRMSG, 1; 0; 0
	6401		/NOCR+UNPACK+CHAR+1
	INCHAR
OUTCHR,	0
INCHAR,	0
ECHOCR,	0		/CHARACTER TO ECHO TO USER.
/*-*
/
/ PUT A CHARACTER IN THE OUTPUT STRING BUFFER.
/
/
/ ON CALL: IF THE AC IS ZERO, OUTPUT "ECHOCR". IF THE
/  AC IS NOT ZERO, IT CONTAINS THE CHARACTER TO OUTPUT.
/
/
PUTCHR,	0
	SNA		/AC = 0 ?
	TAD ECHOCR	/YES, THEN USE CURRENT "ECHOCR".
	SNA
	JMP I PUTCHR	/DO NOT PUT ZEROES IN THE BUFFER.

	DCA I SPTR	/PUT THE CHARACTER IN THE BUFFER.
	ISZ SPTR	/INCREMENT THE BUFFER POINTER.
	DCA ECHOCR	/KILL ANY OLD ECHO CHARACTER.
	JMP I PUTCHR	/NOW BACK TO OUR CALLER.

SPTR,	PUTS1		/OUTPUT STRING BUFFER POINTER.
/
/
/ OUTPUT THE STRING BUFFER
/
/
/ SEND THE TEXT STRING BUFFER TO THE USER'S OUTPUT
/ DEVICE WITHOUT A CARRIAGE RETURN OR LINE FEED.
/
/ ON CALL: THE AC MAY CONTAIN A CHARACTER TO ADD TO 
/  THE STRING BUFFER BEFORE OUTPUT.
/
/
PUTBUF,	0
	JMS PUTCHR	/PUT THE LAST CHARACTER TO THE
	DCA I SPTR	/ BUFFER AND ADD A ZERO WORD FOR
			/ THE BUFFER TERMINATOR.

	DCA PUTMSG	/FIRST CLEAR THE MESSAGE EVENT FLAG,
	CAL		/ THEN GO SEND THE MESSAGE.
	SEND
PUTDEV,	ODTDEV
	PUTMSG
	JMP I (EFWAIT	/NOW GO WAIT UNTIL THE MESSAGE
			/ OUTPUT IS COMPLETED.

PUTBRT,	ISZ PUTMSG	/SET THE #@% EVENT FLAG NOW TO AVOID
			/ THE CONFUSION LATER - IN "EFWAIT".
	TAD (PUTS1)	/RESET THE OUTPUT STRING BUFFER
	DCA SPTR	/ POINTER.
	JMP I PUTBUF	/NOW RETURN TO CALLER.
/
PUTMSG,	1; 0; 0
	6000		/UNPACKED ASCII + NO CR-LF.
	0
PUTS1,	ZBLOCK 13	/THE OUTPUT STRING BUFFER ITSELF.
/
/
/ START A NEW INPUT LINE WITH OUR NAME
/
/
LOGONM,	0
	JMS PRNTCR	/DO A CR-LF AND RESET THE BUFFER.
	TAD ("O)	/NOW PUT OUR NAME IN THE BUFFER.
	JMS PUTCHR
	TAD ("D)
	JMS PUTCHR
	TAD ("T)
	JMS PUTCHR
	TAD (">)
	JMS PUTBUF	/FINALLY OUTPUT THE BUFFER.
	JMP I LOGONM	/ALL DONE, RETURN.

	PAGE
/
/
/	MAIN BODY OF ODT/8
/
/
START,	CLB
	CDF 0		/THE FIRST THING WE DO IS CHECK THE
	TAD I (ODTBKF	/ ODT BREAKPOINT "EVENT FLAG" TO SEE
	CDF CUR		/ IF A BREAKPOINT NEEDS SERVICING.
	SZA CLA
	JMP DECODE	/NOPE, SEE WHAT'S ON THE USERS MIND.

	CDF 0		/GOT A BREAKPOINT TO LOOK AT. FIRST
	TAD (4000+TASK)	/ WE BETTER RESET OUR EVENT FLAG.
	DCA I (ODTBKF	/ (THAT SAVES A LOT OF GRIEF LATER.)
	CDF CUR
	JMS I (BKPSER	/THEN WE GO SERVICE THE BREAKPOINT.
	JMP ODTXIT	/NOW EXIT ODT SINCE THE BREAKPOINT
			/ EVENT FLAG WOKE US UP. (THERE IS A
			/ VERY SMALL CHANCE THE USER WOKE US
			/ AT THE SAME TIME A BREAKPOINT CAME
			/ ALONG, SO HE'LL HAVE TO TRY AGAIN.
			/ FORCING THE USER TO WAKE US AGAIN
			/ IS BETTER THAN LEAVING ODT ACTIVE
			/ AFTER A BREAKPOINT IS SERVICED, IF
			/ WE WERE ASLEEP WHEN THE BREAKPOINT
			/ OCCURRED.)
/
/
/ START A NEW COMMAND LINE FROM SCRATCH
/
/
DECODE,	CLB
	TAD (ODTDEV)	/RESET THE OUTPUT DEVICE TO THE 
	DCA I (PUTDEV	/ CONSOLE.

	JMS I (LOGONM	/START A NEW OUTPUT LINE.

	DCA I (OPN	/CLEAR THE "LOCATION OPEN" FLAG.
	DCA I (INTRNL	/CLEAR THE "INTERNAL REGISTER OPEN"
			/ FLAG.
/
/
/ MAINTAIN OPENED LOCATION, RE-INITIALIZE INPUT
/
/
NEWCMD,	AC7775		/RESET THE SEMI-COLON FLAG/COUNT.
	DCA I (SMFD
	DCA I (ARG2FD	/CLEAR THE "SECOND ARGUMENT FOUND"
			/ FLAG.
	DCA I (ARG2	/CLEAR THE SECOND ARGUMENT STORAGE.
	DCA I (ARG2+1
	DCA I (ARG3	/CLEAR THE THIRD ARGUMENT STORAGE.
/
/
/ START NEW SUB-EXPRESSION
/
/
NEWEXP,	DCA I (OP	/CLEAR THE "OPERATOR FOUND" FLAG.
	DCA I (ARGFD	/CLEAR THE "ARGUMENT FOUND" FLAG.
	DCA I (ARG	/ZERO THE "EXPRESSION SO FAR"
	DCA I (ARG+1	/ LOCATIONS.
/
/
/ GET THE NEXT USER ENTRY
/
/
NEWNUM,	JMS I (GETNUM	/GO GET A NUMERIC ARGUMENT.
/
/
/ NON-OCTAL CHARACTER ENTERED, WHAT ARE WE TO DO ?
/
/
CLGL,	JMS I (PUTBUF	/FIRST ECHO THE COMMAND CHARACTER.

	JMS I (LOOKUP	/GO COMPARE THE INPUT CHARACTER TO
	  COMTAB	/ LIST OF VALID COMMANDS.
	  COMDIS-COMTAB
	JMP ERROR	/RETURN HERE IF ILLEGAL ENTRY.
	DCA .+2		/SAVE THE ADDRESS OF THE COMMAND
			/ SERVICE ROUTINE.
	JMP I .+1	/NOW GO SERVICE THE USER'S COMMAND.
	HLT
/
/
/ TELL THE USER HE GOOFED
/
/
ERROR,	JMS GOOFED	/OUTPUT A "?", THEN
	JMP DECODE	/ LET THE USER TRY AGAIN.
/
/
/ CLEAR THE CURRENT ARGUMENT
/
/
RUBOUT,	JMS GOOFED	/OUTPUT A "?", THEN
	JMP NEWEXP	/ RESTART THE CURRENT EXPSSION.
/
/
/ OUTPUT A QUESTION MARK TO SHOW ERROR
/
/
GOOFED,	0
	CLB
	JMS I (PUTCHR	/TRY TO ECHO THE BAD CHARACTER.
	JMS I (PSPACE	/NOW OUTPUT A SPACE,
	TAD (277)	/ AND A "?", THEN
	JMS I (PUTCHR
	JMS I (PSPACE	/ ANOTHER SPACE.
	JMS I (PUTBUF	/PRINT THE OUTPUT BUFFER AND
	JMP I GOOFED	/ EXIT.
/
/
/ EXIT ODT, LEAVING US IN RUN WAIT.
/
/
ODTXIT,	CLB
	JMS I (PRNTCR	/DO A CR-LF FIRST.
	CAL		/NOW SUSPEND 'TIL NEEDED.
	SUSPND
	JMP START	/ALIVE AGAIN, WHAT TO DO ?
/
/
/
/
/
EFWAIT,	CIF CUR		/WE NEED INTERRUPTS OFF FOR THIS !!
	CDF 0
	TAD I (ODTBKF
	SZA CLA
	JMP EFW1

	TAD (4000+TASK)
	DCA I (ODTBKF
	CDF CUR
	JMS I (BKPSER
	JMP EFWAIT

EFW1,	CDF CUR
	TAD I (CHRMSG	/CHARACTER INPUT EVENT FLAG FIRE ?
	SNA CLA
	JMP I (GETCRT	/YES, GO PROCESS THE INPUT.
	TAD (4000+TASK)	/NO, RESET THE EVENT FLAG TO A
	DCA I (CHRMSG	/ WAITING STATE.

	TAD I (PUTMSG	/BUFFER OUTPUT EVENT FLAG FIRE ?
	SNA CLA
	JMP I (PUTBRT	/YES, GO FINISH THE OUTPUT.
	TAD (4000+TASK)	/NO, RESET THE EVENT FLAG TO A
	DCA I (PUTMSG	/ WAITING STATE.

	CIF 0		/NOTHING TO DO, SO WE'LL JUST GO
	WAITM		/ WAIT FOR SOMETHING TO HAPPEN.
	EFWT
	JMP EFWAIT	/GO SEE WHO RANG OUR CHIME.
	JMP EFWAIT
/

	PAGE
/*-*
/
/ BUILD AN OCTAL NUMBER FROM THE USER'S INPUT
/
/
/ ON RETURN:
/  NUM	  =	NUMERIC ENTRY, IF ANY
/  NUM+1  =	FIELD DIGIT, IF ANY
/  ARGFD  =	NON ZERO, IF NUMERIC DATA WAS ENTERED
/
/
GETNUM,	0
	CLB
	DCA NUM		/CLEAR THE NUMERIC ARGUMENT WORD.
	DCA NUM+1	/CLEAR THE FIELD ENTERED WORD.
	TAD (-6)	/RESET THE LOOP COUNTER.
	DCA GETNA

GETN1,	JMS I (GETCHR	/GO GET A CHARACTER FROM THE USER.
	TAD (-"7)	/TEST FOR NUMERIC INPUT.
	SMA SZA
	JMP GETN2	/.GT. NUMBER, GO CHECK FOR COMMAND.
	TAD (7)		/COULD STILL BE NUMERIC.
	SPA
	JMP GETN2	/NOPE, GO CHECK FOR A COMMAND.

	DCA ARGFD	/SAVE THE NEW DIGIT.
	TAD NUM		/EXTRACT WHAT WILL BE THE FIELD
	CLL RTL		/ BITS - IF THE USER ENTERS A 5
	RTL		/ DIGIT NUMBER,
	AND (0007)
	DCA NUM+1	/ AND SAVE THEM.

	TAD NUM		/SHIFT THE DEVELOPING NUMBER LEFT TO
	CLL RAL		/ ACCEPT THE NEW DIGIT.
	CLL RAL
	CLL RAL
	TAD ARGFD	/ADD IN THE NEW DIGIT,
	DCA NUM		/ AND SAVE IT AWAY.

	ISZ ARGFD	/SET THE "ARGUMENT FOUND" FLAG.
	ISZ GETNA	/DO WE HAVE TOO MANY DIGITS ?
	JMP GETN1	/NO, TRY FOR ANOTHER.
	JMP I (ERROR	/TOO MANY DIGITS, DO ERROR.

GETN2,	CLB		/NOW ACCUMULATE THE NEW ARGUMENT
	JMS EXPCOM	/ INTO THE CURRENT EXPRESSION.
	NUM
	ARG		/(ADDRESS OF THE EXPRESSION BUCKET.)
	ARG
	JMP I GETNUM	/ AND RETURN.

GETNA,	0		/LOCAL TEMPORARY.
/*-*
/
/ EXPRESSION COMPUTATION ROUTINE
/
/
/ COME HERE TO ADD OR SUBTRACT 2 DOUBLE PRECISION NUMBERS.
/ THE ARGUMENTS WHICH FOLLOW THE CALL SPECIFY THE LOCATION
/ OF THE DATA TO USE AND WHERE THE RESULT SHOULD GO. NOTE
/ THAT THE FIRST ARGUMENT IS ADDED TO OR SUBTRACTED FROM
/ THE SECOND ARGUMENT. NOTE ALSO THAT WHEN WE ARE CALLED
/ THE CONTENTS OF THE ACCUMULATOR IS ADDED TO THE CURRENT
/ ARITHMETIC OPERATOR FLAG (IN "OP"), WHICH ALLOWS THE
/ CALLER TO FORCE SUBTRACTION WITHOUT SETTING "OP" FIRST.
/
/ ON CALL:
/  AC		IF NOT ZERO, FORCES SUBTRACTION MODE !!
/  OP	=	THE OPERATOR (+ OR -)
/
/ ON RETURN:
/  OP	=	RESET TO "+" OPERATOR
/
/ CALLING SEQUENCE:
/
/	JMS EXPCOM
/	  AAAA		ADDRESS OF THE FIRST ARGUMENT
/	  BBBB		ADDRESS OF THE SECOND ARGUMENT
/	  CCCC		ADDRESS FOR THE RESULT (C = B +- A)
/
/
EXPCOM,	0
	TAD OP		/COMBINE THE CONTENTS OF THE AC WITH
	DCA OP		/ THE CURRENT ARITHMETIC OPERATOR.
	CLB		/NEED THE LINK CLEAR !

	TAD I EXPCOM	/GET THE ADDRESS OF THE DATA PAIR TO
	ISZ EXPCOM	/ ADD OR SUBTRACT (LOW ORDER WORD).
	DCA EXPCA
	TAD I EXPCOM	/GET THE ADDRESS OF THE SECOND DATA
	ISZ EXPCOM	/ PAIR TO USE.
	DCA EXPCB
	TAD I EXPCOM	/GET THE ADDRESS WHERE WE WILL STORE
	ISZ EXPCOM	/ THE RESULT.
	DCA EXPCC

	TAD OP		/ADD OR SUBTRACT ?
	SZA CLA
	JMP EXPC1	/ARGUMENT SAYS DO SUBTRACTION.

	TAD I EXPCA	/ADD LOW ORDER WORDS
	ISZ EXPCA
	TAD I EXPCB
	DCA I EXPCC	/PUT RESULT WHERE IT BELONGS.
	RAL		/PROPAGATE THE CARRY, IF ANY, AND
	TAD I EXPCA	/ ADD HIGH ORDER WORDS.
	JMP EXPC2	/GO USE SOME COMMON CODE.
/
EXPC1,	TAD I EXPCA	/SUBTRACT LOW ORDER WORDS.
	ISZ EXPCA
	CLL CIA
	TAD I EXPCB
	DCA I EXPCC	/PUT RESULT WHERE IT BELONGS.
	CML RAL		/PROPAGATE BORROW, IF ANY, AND
	TAD I EXPCA	/ SUBTRACT THE HIGH ORDER WORDS.
	CIA

EXPC2,	ISZ EXPCB
	TAD I EXPCB	/FINISH THE HIGH ORDER WORDS.
	ISZ EXPCC
	DCA I EXPCC	/PUT RESULT WHERE IT BELONGS.

	DCA OP		/RESET THE OPERATOR TO "ADD",
	JMP I EXPCOM	/ AND RETURN.

EXPCA,	0		/LOCAL TEMPORARIES
EXPCB,	0
EXPCC,	0
/
/
/ (;)	PUSH MULTIPLE USER ARGUMENTS DOWN THE "STACK"
/
/
SEMI,	ISZ SMFD	/COUNT THE USER'S SEMI COLONS ON
	SKP		/ THIS LINE.
	JMP I (ERROR	/TOO MANY SEMI COLONS, SAY SO.
	TAD ARG2	/MOVE THE SECOND ARGUMENT SET INTO 
	DCA ARG3	/ THE THIRD ARGUMENT SLOT.
	
	TAD ARG		/NOW PUT THE CURRENT EXPRESSION INTO
	DCA ARG2	/ SECOND ARGUMENT SLOT.
	TAD ARG+1
	DCA ARG2+1
	TAD ARGFD	/ALSO MOVE THE "ARGUMENT FOUND"
	DCA ARG2FD	/ FLAG.
	DCA ARGFD	/NOW CLEAR THE FIRST ARGUMENT FLAG.

	JMP I (NEWEXP	/GO CONTINUE EXPRESSION INPUT.
/*-*
/
/ (-)	SET EXRESSION OPERATOR TO SUBTRACT
/
/
MINUS,	CLB IAC
/
/
/ (+)	SET EXPRESSION OPERATOR TO ADDITION
/
/
PLUS,	DCA OP
	JMP I (NEWNUM	/LET'S GO AROUND AGAIN.
/
/
/ (C)	GET THE CONSTANT REGISTER
/
/
CHRCEE,	TAD (CNST)	/GO ADD THE CONSTANT REGISTER INTO
	JMP CHR1	/ THE CURRENT EXPRESSION.
/
/
/ (Q)	GET THE QUANTITY REGISTER CONTENTS
/
/
CHRQUE,	TAD (QUAN)	/GO ADD THE QUNATITY REGISTER INTO
	JMP CHR1	/ THE CURRENT EXPRESSION.
/
/
/ (.)	GET LAST OPENED LOCATION'S ADDRESS
/
/
CHRDOT,	TAD (DOT)	/GO ADD THE ADDRESS OF THE LAST
CHR1,	DCA .+2		/ EXPLICITY-OPENED LOCATION TO THE
	JMS EXPCOM	/ CURRENT EXPRESSION.
	  0000		/(WILL BE ADDRESS OF DATA TO USE)
	  ARG		/ACCUMULATE RESULT IN THE CURRENT
	  ARG		/ EXPRESSION BUCKET.

	ISZ ARGFD	/SAY WE HAVE AN ACTIVE EXPRESSION.
	JMP I (NEWNUM	/NOW GET THE REST OF THE EXPRESSION.
/*-*
/
/ USER ARGUMENT STORAGE
/
/
/ "ARG" AND "ARG+1" ARE USED TO ACCUMULATE THE CURRENT 
/ NUMERIC ARGUMENT EXPRESSION.
/
/
ARGFD,	0		/FIRST ARGUMENT FOUND FLAG.
ARG,	0		/LAST NUMERIC ARGUMENT ENTERED.
	0		/LAST FIELD DIGIT ENTERED.

ARG2FD,	0		/SECOND ARGUMENT FOUND FLAG.
ARG2,	0; 0		/SECOND ARGUMENT STORAGE.

ARG3,	0		/THIRD ARGUMENT STORAGE.

NUM,	0; 0		/LAST NUMERIC INPUT FROM "GETNUM".

OP,	0		/CURRENT ARITHMETIC OPERATOR.

SMFD,	0		/SEMI COLON COUNTER.

ONE,	1; 0		/THE CONSTANT "1".

	PAGE
/*-*
/
/ TEST A LIST FOR A VALID COMMAND CHARACTER
/
/
/ COME HERE TO SEARCH A TABLE FOR THE INPUT CAHRACTER
/ IN "INCHAR".
/
/ ON CALL: THE CHARACTER TO SEARCH FOR IS IN "INCHAR"
/
/ ON RETURN: IF A CHARACTER MATCH WAS FOUND, THE AC
/  CONTAINS THE ADDRESS ASSOCIATED WITH THAT CHARACTER
/
/ CALLING SEQUENCE:
/
/	JMS LOOKUP
/	  COMMAND TABLE ADDRESS
/	  DISPATCH TABLE ADDRESS - COMMAND TABLE ADDRESS
/	ERROR RETURN
/	COMMAND FOUND RETURN
/
/
LOOKUP,	0
	CLB CMA
	TAD I LOOKUP	/SET UP A POINTER INTO THE COMMAND
	ISZ LOOKUP	/ TABLE TO SEARCH.
	DCA LOOKA

LOOK1,	ISZ LOOKA
	TAD I LOOKA	/GET A COMMAND LIST CHARACTER.
	SMA		/END OF TABLE ?
	JMP LOOK2	/YES, TAKE THE ERROR EXIT.
	TAD I (INCHAR	/DOES IT MATCH USER'S ENTRY ?
	SZA CLA
	JMP LOOK1	/NO, TRY AGAIN.

	TAD LOOKA	/YES, GET THE ADDRESS OF THE COMMAND
	TAD I LOOKUP	/ AND ADD IN THE OFFSET INTO THE 
	ISZ LOOKUP	/ MATCHING DISPATCH TABLE.
	DCA LOOKA
	TAD I LOOKA	/NOW GET THE ADDRESS OF THE COMMAND
			/ SERVICE ROUTINE FROM THE DISPATCH
			/ TABLE AND RETURN IT TO THE CALLER.
LOOK2,	ISZ LOOKUP	/INCREMENT OVER THE ERROR RETURN.
	JMP I LOOKUP	/ AND RETURN TO THE CALLER.

LOOKA,	0		/LOCAL TEMPORARY.
/*-*
/
/ TABLE OF DEFINED COMMAND CHARACTERS.
/
/
/ USED WITH "COMDIS"
/
/
COMTAB,
	-377	/RUBOUT CANCEL CURRENT INPUT

	-257	/ /	OPEN OCTAL WORD
	-242	/ "	OPEN UNPACKED ASCII WORD
	-247	/ '	OPEN PACKED ASCII WORD

	-215	/ (CR)	CLOSE, NO SUCCESSIVE OPEN
	-212	/ (LF)	CLOSE, OPEN NEXT LOCATION
	-336	/ ^	CLOSE, OPEN PREVIOUS LOCATION
	-300	/ @	CLOSE, OPEN INDIRECT
	-337	/ _	CLOSE, OPEN PAGE RELATIVE
	-274	/ <	CLOSE, OPEN OLD SEQUENCE

	-244	/ $	INTERNAL REGISTER REFERENCE
	-275	/ =	PRINT EXPRESSION IN OCTAL
	-303	/ C	CONSTANT REGISTER CONTENTS
	-321	/ Q	QUANTITY REGISTER CONTENTS
	-256	/ .	LAST OPENED LOCATION'S ADDRESS

	-273	/ ;	MULTIPLE ARGUMENT DELIMITER
	-255	/ -	ARGUMENT SUBTRACTION OPERATOR
	-253	/ +	ARGUMENT ADDITION OPERATOR
	-254	/ ,	RELOCATION REGISTER OPERATOR

	-301	/ A	LIST REGISTER ASSIGNMENTS
	-302	/ B	SET / RESET BREAKPOINTS
	-304	/ D	LIST THE TASKS IN DEBUG WAIT
	-305	/ E	EFFECTIVE ADDRESS SEARCH
	-306	/ F	FILL MEMORY
	-307	/ G	SET BREAKPOINTS AND GO
	-313	/ K	KOMPUTE AND PRINT RELOCATION DATA
	-314	/ L	LIST MEMORY
	-316	/ N	NOT THIS WORD SEARCH
	-320	/ P	PROCEED WITH USER PROGRAM
	-322	/ R	SET / RESET RELOCATION REGISTERS
	-323	/ S	SINGLE STEP
	-324	/ T	DISPLAY TASK STATE REGISTERS
	-327	/ W	THIS WORD SEARCH
	-330	/ X	EXIT ODT TO RTS/8

	0	/END OF TABLE TERMINATOR.
/*-*
/
/ TABLE OF THE ADDRESSES OF THE SERVICE ROUTINES FOR
/ THE COMMANDS LISTED IN THE COMMAND TABLE "COMTAB".
/
/ NOTE: THE ORDER OF "COMDIS" AND "COMTAB" MUST MATCH !
/
/
COMDIS,
	RUBOUT	/RUBOUT CANCEL CURRENT INPUT

	OPENWD	/ /	OPEN OCTAL WORD
	OPENUA	/ "	OPEN UNPACKED ASCII WORD
	OPENPA	/ '	OPEN PACKED ASCII WORD

	CLCRET	/ (CR)	CLOSE, NO SUCCESSIVE OPEN
	CLLNFD	/ (LF)	CLOSE, OPEN NEXT LOCATION
	CLUPAR	/ ^	CLOSE, OPEN PREVIOUS LOCATION
	CLATSG	/ @	CLOSE, OPEN INDIRECT
	CLBACK	/ _	CLOSE, OPEN PAGE RELATIVE
	CLLSTH	/ <	CLOSE, OPEN OLD SEQUENCE

	INREGT	/ $	INTERNAL REGISTER REFERENCE
	EQUALS	/ =	PRINT EXPRESSION IN OCTAL
	CHRCEE	/ C	CONSTANT REGISTER CONTENTS
	CHRQUE	/ Q	QUANTITY REGISTER CONTENTS
	CHRDOT	/ .	LAST OPENED LOCATION'S ADDRESS

	SEMI	/ ;	MULTIPLE ARGUMENT DELIMITER
	MINUS	/ -	ARGUMENT SUBTRACTION OPERATOR
	PLUS	/ +	ARGUMENT ADDITION OPERATOR
	RELOP	/ ,	RELOCATION REGISTER OPERATOR

	ASLIST	/ A	LIST REGISTER ASSIGNMENTS
	BREAKP	/ B	SET / RESET BREAKPOINTS
	DBLIST	/ D	LIST THE TASKS IS DEBUG WAIT
	SERCHE	/ E	EFFECTIVE ADDRESS SEARCH
	FILLCR	/ F	FILL MEMORY
	GOTOIT	/ G	SET BREAKPOINTS AND GO
	KOMPUT	/ K	KOMPUTE AND PRINT RELOCATION DATA
	LISTCR	/ L	LIST MEMORY
	SERCHN	/ N	NOT THIS WORD SEARCH
	PROCED	/ P	PROCEED WITH USER PROGRAM
	RELOCT	/ R	SET / RESET RELOCATION REGISTERS
	SINGLE	/ S	SINGLE STEP
	TASKST	/ T	DISPLAY TASK STATE REGISTERS
	SERCHW	/ W	THIS WORD SEARCH
	ODTXIT	/ X	EXIT ODT TO RTS/8
/*-*
/
/ MOVE 2 CONSECUTIVE WORDS OF DATA
/
/
/ CALLING SEQUENCE:
/
/	JMS MOVEDAT
/	  ADDRESS TO MOVE DATA FROM
/	  ADDRESS TO MOVE DATA TO
/
/
MOVEDAT,0
	TAD I MOVEDAT	/GET THE "FROM" ADDRESS FOR AN
	ISZ MOVEDAT	/INDIRECT POINTER.
	DCA MOVDA
	TAD I MOVEDAT	/DO THE SAME FOR THE "TO" ADDRESS.
	ISZ MOVEDAT
	DCA MOVDB

	TAD I MOVDA	/GET THE LOW ORDER WORD OF THE PAIR,
	ISZ MOVDA
	DCA I MOVDB	/AND PUT IT SOMEWHERE ELSE.
	ISZ MOVDB
	TAD I MOVDA	/NOW DO THE HIGH ORDER WORD.
	DCA I MOVDB

	JMP I MOVEDAT	/THAT'S ALL FOLKS, RETURN.

MOVDA,	0		/LOCAL TEMPORARIES
MOVDB,	0
/
/
/ MOVE ARGUMENT DATA IF PRESENT
/
/
MOVEARG,0
	TAD I MOVEARG	/GET THE ADDRESS OF THE "ARGUMENT 
	ISZ MOVEARG	/ FOUND" FLAG TO TEST.
	DCA MOVAA
	TAD I MOVEARG	/GET THE DATA DESTINATION ADDRESS.
	ISZ MOVEARG
	DCA MOVAB

	TAD I MOVAA	/IS THERE DATA TO MOVE ?
	SNA CLA
	JMP I MOVEARG	/NO, JUST RETURN.

	ISZ MOVAA	/INCREMENT POINTER TO DATA.
	JMS MOVEDAT	/GO MOVE THE DATA FOR THE CALLER.
MOVAA,	  0000
MOVAB,	  0000
	JMP I MOVEARG	/ALL DONE, RETURN.
/
/
/ ODT/8 INTERNAL REGISTERS
/
/
FORM,	0		/ADDRESS FORMAT REGISTER.

LOW,	0100; 2		/LOW MEMORY LIMIT REGISTER.
HIGH,	0110; 2		/HIGH MEMORY LIMIT REGISTER.
CNST,	0; 0		/CONSTANT REGISTER.

 	PAGE
/*-*
/
/ OPEN THE CURRENT ADDRESS
/
/
/ ON CALL: "CADDR" CONTAINS THE DATA ADDRESS TO USE.
/
/ ON RETURN: AC HAS THE DATA WE WANT.
/
/
GETCAD,	0
	CLB
	TAD CADDR+1	/GET THE HIGH ORDER DATA WORD,
	AND (0007)	/ (WE ONLY WANT THE FIELD BITS !)
	CLL RTL		/ AND CONVERT IT INTO A CDF
	RAL		/ INSTRUCTION.
	TAD (CDF 0)
	DCA CFLD

CFLD,	CDF 0
	TAD I CADDR	/GET THE REAL DATA.
	CDF CUR
	ISZ OPN		/MARK THE LOCATION OPEN.
	JMP I GETCAD	/RETURN WITH THE DATA IN THE AC.

CADDR,	0; 0		/ADDRESS OF CURRENT OPEN LOCATION.
OPN,	0		/LOCATION OPEN FLAG, 0 = NOT OPEN.
/*-*
/
/ PUT DATA IN THE CURRENT OPEN ADDRESS
/
/
/ IF A LOCATION IS OPEN AND IF AN ARGUMENT WAS ENTERED, PUT
/ THE DATA IN "ARG" IN THE CURRENT OPEN ADDRESS. ELSE DO
/ NOTHING.
/
/
PUTCAD,	0
	TAD OPN		/IS A LOCATION OPEN ?
	SNA CLA
	JMP PUTC1	/NO, JUST EXIT.
	TAD I (ARGFD	/HAS A NUMERIC ARGUMENT BEEN
	SNA CLA		/ ENTERED ?
	JMP PUTC1	/NO, NOTHING TO PUT AWAY, EXIT.

	TAD CFLD	/GET THE CDF TO THE OPEN ADDRESS
	DCA .+2		/ AND SET IT UP TO USE.
	TAD I (ARG	/GET THE DATA FROM "ARG", AND
	HLT
	DCA I CADDR	/ PUT IN THE OPEN LOCATION.
	CDF CUR

	DCA OPN		/MARK THE LOCATION CLOSED.
	DCA I (ARGFD	/MARK THE ARGUMENT USED.
	TAD INTRNL	/ARE WE DOING AN INTERNAL REGISTER ?
	SNA
	JMP I PUTCAD	/NO, WE CAN EXIT NOW.

	SMA CLA		/4 OR 5 DIGIT INTERNAL REGISTER ?
	JMP PUTC1	/WAS A 4 DIGIT REGISTER, ALL DONE.

	CLB IAC		/CREATE THE ADDRESS OF THE HIGH
	TAD CADDR	/ ORDER WORD FOR THIS REGISTER.
	DCA INTRNL
	TAD I (ARG+1	/AS WE MOVE THE HIGH ORDER WORD, WE
	AND (0007)	/ LIMIT THE DATA TO STAY WITHIN
	DCA I INTRNL	/ FIELDS 0 TO 7 !

PUTC1,	TAD INTRNL	/DID WE CLOSE AN INTERNAL REGISTER ?
	SNA CLA
	JMP I PUTCAD	/NO, JUST RETURN TO THE CALLER.
	JMP I (DECODE	/YES, GO START A NEW COMMAND.

INTRNL,	0		/INTERNAL REGISTER OPEN FLAG.
/*-*
/
/ OPEN AND TYPE CONTENTS COMMAND PROCESSOR
/
/
/ FOR: (/) (") (')
/
/
/ SYNTAX:
/ X		TYPE LAST OPENED LOCATION IN MODE "X".
/ AX		OPEN LOCATION "A" IN MODE "X".
/
/
OPENPA,	IAC		/OPEN AND PRINT AS PACKED ASCII.
OPENUA,	IAC		/OPEN AND PRINT AS UNPACKED ASCII.
OPENWD,			/OPEN AND PRINT AS AN OCTAL WORD.
	DCA FM		/SET THE OUTPUT FORMAT.
	TAD I (ARGFD	/WAS A NUMERIC ARGUMENT ENTERED ?
	SNA CLA
	JMP OPEN1	/NO, REOPEN THE CURRENT ADDRESS.

	JMS I (MOVEDAT	/YES, USE IT TO UPDATE THE CURRENT
	  ARG		/ ADDRESS.
	  CADDR
	JMS I (MOVEDAT	/ALSO UPDATE THE STORAGE FOR THE
	  ARG		/ "LAST EXPLICIT OPEN" ADDRESS.
	  DOT

OPEN1,	JMS GETCAD	/GET THE DATA POINTED TO BY "CADDR"
	JMS I (PRNTWD	/ AND PUT IT IN THE OUTPUT BUFFER.
	JMP I (NEWCMD	/NOW GO GET THE NEXT COMMAND.

DOT,	0		/STORAGE FOR ADDRESS OF THE LAST
	0		/ EXPLICIT OPEN.
FM,	0		/OUTPUT FORMAT (MODE) SWITCH.
/
/
/ (,)	RELOCATION REGISTER OPERATOR
/
/
RELOP,	JMS I (ARGTST	/GO GET THE RELOCATION REGISTER
	CLL RAL		/ NUMBER AND COMPUTE THE ADDRESS OF
	TAD (RELT)	/ THE REQUESTED REGISTER.
	DCA .+2
	JMS I (MOVEDAT	/MOVE THE CONTENTS OF THE
	  0000		/ RELOCATION REGISTER TO WHERE WE
	  ARG		/ CAN USE IT.
	JMP I (NEWNUM	/NOW GET THE REST OF THE EXPRESSION.
/*-*
/
/ CLOSE AND OPEN COMMAND PROCESSORS
/
/
/ FOR: (CR) (LF) (^) (@) (_)
/
/
/ SYNTAX:
/ X		CLOSE AND OPEN ANOTHER VIA COMMAND "X".
/ MX		UPDATE OPEN LOCATION WITH "M", CLOSE AND
/		  OPEN ANOTHER VIA COMMAND "X".
/
/
/
/ (CR)	CLOSE THE CURRENT LOCATION
/
/
CLCRET,	JMS PUTCAD	/GO CLOSE THE CURRENT LOCATION.
	JMP I (DECODE	/NOW RETURN TO COMMAND INPUT.
/
/
/ (<)	CLOSE AND OPEN OLD SEQUENCE
/
/
CLLSTH,	JMS PUTCAD	/GO CLOSE THE CURRENT LOCATION.
	JMS I (MOVEDAT	/RESET THE CURRENT ADDRESS TO THE 
	  DOT		/ ADDRESS OF THE LAST EXPLICIT OPEN.
	  CADDR
	JMP CLLN2
/
/
/ (LF)	CLOSE AND OPEN NEXT LOCATION
/
/
CLLNFD,	JMS PUTCAD	/GO CLOSE THE CURRENT LOCATION.

CLLN1,	JMS I (EXPCOM	/FORCE ADDITION (SUBTRACTION) MODE.
	  ONE		/ADD (OR SUBTRACT) ONE TO (FROM) THE
	  CADDR		/ CURRENT ADDRESS.
	  CADDR
	JMS I (MOVEDAT	/ALSO UPDATE THE STORAGE FOR THE
	  CADDR		/ "LAST EXPLICIT OPEN" ADDRESS.
	  DOT

CLLN2,	JMS I (PRNTCR	/FINISH THIS LINE WITH A CR-LF.
	JMS I (PRTADR	/GO OUTPUT THE CURRENT ADDRESS, AND
			/ MAYBE USE ONE OF THE RELOCATION
			/ REGISTERS.
	JMS I (PRNTMD	/GO PRINT THE MODE CHARACTER.
	JMP OPEN1	/NOW WE SIMPLY OPEN THIS LOCATION.
/*-*
/
/ (^)	CLOSE AND OPEN PREVIOUS LOCATION
/
/
CLUPAR,	JMS PUTCAD	/GO CLOSE THE CURRENT LOCATION.
	CLB IAC
	JMP CLLN1	/NOW GO THRU (LF) CODE WITH "EXPCOM"
			/ SET TO SUBTRACTION MODE.
/
/
/ (@)	CLOSE AND OPEN INDIRECT 
/
/
CLATSG,	JMS PUTCAD	/GO CLOSE THE CURRENT LOCATION.
	JMS GETCAD	/GET THE DATA AT THE CURRENT
			/ ADDRESS.
	JMP CLBA1	/NOW GO USE SOME COMMON CODE.
/
/
/ (_) 	CLOSE AND OPEN PAGE RELATIVE
/
/
CLBACK,	JMS PUTCAD	/GO CLOSE THE CURRENT LOCATION.
	JMS GETCAD
	AND (0177)	/GENERATE A PAGE RELATIVE ADDRESS
	DCA FM		/ FROM THE CURRENT ADDRESS.
	TAD CADDR
	AND (7600)
	TAD FM

CLBA1,	DCA CADDR	/AND SAVE IT AS THE CURRENT ADDRESS.
	DCA FM		/FORCE OUTPUT MODE TO OCTAL !
	JMP CLLN2	/GO USE SOME SHARED CODE.

	PAGE
/*-*
/
/ PRINT THE CURRENT ADDRESS IN THE CORRECT FORMAT
/
/
PRTADR,	0
	JMS PSPACE	/FIRST OUTPUT A SPACE.
	TAD I (FORM	/CAN WE USE A RELOCATION REGISTER ?
	SZA CLA
	JMP PRTA1	/NO, USER WANTS STRAIGHT OCTAL.
	TAD I (INTRNL	/IS AN INTERNAL REGISTER OPEN ?
	SZA CLA
	JMP PRTA1	/YES, USE STRAIGHT OCTAL.

	JMS I (LOCATE	/GO FIND THE CLOSEST RELOCATION
			/ REGISTER AND USE IT, OR AT LEAST
			/ OUTPUT THE CURRENT ADDRESS.
	JMP I PRTADR	/ALL DONE, RETURN TO CALLER.

PRTA1,	JMS PRNTN5	/GO OUTPUT THE CURRENT ADDRESS IN
	  CADDR		/ 5 DIGIT OCTAL.
	JMP I PRTADR	/NOW WE'RE FINISHED, RETURN.
/
/
/ COME HERE TO OUTPUT A 5 DIGIT OCTAL VALUE.
/
/
PRNTN5,	0
	TAD I PRNTN5	/GET THE ADDRESS OF THE DATA PAIR
	ISZ PRNTN5	/ TO OUTPUT.
	DCA PRN1
	TAD I PRN1	/GET THE LOW ORDER DATA WORD AND
	ISZ PRN1	/ SAVE IT FOR "PRNTN4".
	DCA QUAN

	TAD I PRN1	/NOW GET THE HIGH ORDER DATA WORD,
	JMS PRNTN1	/ AND SEND IT TO THE OUTPUT BUFFER.
	TAD QUAN	/GO PUT THE LOW ORDER WORD IN THE 
	JMS PRNTN4	/ OUTPUT BUFFER.
	TAD I PRN1	/RESET THE FIELD DIGIT IN "QUAN",
	DCA QUAN+1	/ SINCE "PRNTN4" ZEROED IT.
	JMP I PRNTN5	/LASTLY EXIT.
/*-*
/
/ PRINT THE CONTENTS OF THE AC IN THE CURRENT OUTPUT FORMAT
/
/
PRNTWD,	0
	DCA QUAN	/SAVE THE DATA WORD TO OUTPUT.
	DCA QUAN+1	/CLEAR THE HIGH ORDER QUANTITY WORD.
	TAD I (FM	/WHICH MODE FOR OUTPUT ?
	SZA		/MODE = 0 ?
	JMP .+4
	TAD QUAN	/YES, JUST GO OUTPUT THE DATA AS
	JMS PRNTN4	/ 4 OCTAL DIGITS,
	JMP I PRNTWD	/ AND RETURN.

	CLL RAR		/MODE IS ASCII, UNPACKED ?
	SZL CLA
	JMP .+4
	TAD QUAN	/YES, JUST PUT THE CHARACTER IN THE
	JMS I (PUTCHR	/ OUTPUT STRING BUFFER,
	JMP PRNW1	/NOW FINISH OUR WORK.

	TAD QUAN	/MODE IS PACKED ASCII, GET THE HIGH
	RTR		/ ORDER 6 BITS OF THE DATA WORD,
	RTR
	RTR
	JMS PRNW2	/ AND GO MAKE IT INTO FULL ASCII.
	TAD QUAN	/NOW DO THE LOW ORDER 6 BITS.
	JMS PRNW2
PRNW1,	JMS PSPACE	/ADD A SPACE AND
	JMS I (PUTBUF	/PRINT THE OUTPUT BUFFER.
	JMP I PRNTWD	/TIME TO EXIT.

PRNW2,	0
	AND (0077)	/MAKE 6 BITS INTO A FULL ASCII
	TAD (240)	/ TYPE CHARACTER.
	AND (0077)
	TAD (240)
	JMS I (PUTCHR	/SEND IT TO THE OUTPUT BUFFER,
	JMP I PRNW2	/ AND RETURN.

PRN1,	0		/LOCAL TEMPORARY LOCATIONS
PRN2,	0
QUAN,	0; 0		/THE QUANTITY REGISTER IN THE FLESH.
/*-*
/
/ PRINT THE CONTENTS OF THE AC IN OCTAL
/
/
PRNTN4,	0
	CLL RAL		/SAVE DATA AS THE LOW ORDER WORD OF
	DCA QUAN	/ THE "QUANTITY" REGISTER.
	DCA QUAN+1	/CLEAR THE HIGH ORDER "QUANTITY"
			/ WORD.
	TAD (-4)	/SET UP A LOOP COUNTER FOR 4 DIGITS.
	DCA PRN2

PRN41,	TAD QUAN	/GET THE NEXT OCTAL DIGIT.
	RTL
	RAL		/(THE DATA WILL BE CORRECT IN "QUAN"
	DCA QUAN	/ WHEN WE'RE DONE WITH ALL THIS.)
	TAD QUAN
	JMS PRNTN1	/ AND SEND IT OT THE OUTPUT BUFFER.

	ISZ PRN2	/HAVE WE DONE 4 DIGITS ?
	JMP PRN41	/NO, DO ANOTHER.
	JMS PSPACE	/NOW ADD A SPACE AND
	JMS I (PUTBUF	/PRINT THE OUTPUT BUFFER.
	JMP I PRNTN4	/ALL DONE, RETURN.
/
/
/ PUT 1 OCTAL DIGIT IN THE OUTPUT BUFFER IN ASCII
/
/
PRNTN1,	0
	AND (0007)	/CLEAN IT UP,
	TAD (260)	/ MAKE IT ASCII,
	JMS I (PUTCHR	/ AND PUT IT IN THE OUTPUT BUFFER.
	JMP I PRNTN1	/RETURN FOR ANOTHER.
/
/
/ PRINT THE CURRENT MODE CHARACTER
/
/
PRNTMD,	0
	TAD I (FM	/COMPUTE THE ADDRESS OF THE MODE
	TAD (MODTBL+1)	/ CHARACTER.
	DCA MODTBL
	TAD I MODTBL	/PUT THE MODE CHARACTER IN THE
	JMS I (PUTCHR	/ OUTPUT BUFFER.
	JMP I PRNTMD	/THEN BACK TO CALLER.

MODTBL,	0
	257		/ /	OCTAL WORD MODE
	242		/ "	PACKED ASCII MODE
	247		/ '	UNPACKED ASCII MODE
/*-*
/
/ PUT A SPACE IN THE OUTPUT BUFFER
/
/
PSPACE,	0
	TAD (240)
	JMS I (PUTCHR	/PUT A SPACE IN THE OUTPUT BUFFER,
	JMP I PSPACE	/RETURN.
/
/
/ (=)	PRINT THE CURRENT EXPRESSION IN OCTAL
/
/
EQUALS,	JMS PRNTN5	/PRINT THE CONTENTS OF "ARG".
	  ARG
	JMP I (DECODE	/GO GET THE NEXT COMMAND.
/
/
/ CARRIAGE RETURN - LINE FEED
/
/
/ ADD A CARRIAGE RETURN AND LINE FEED TO THE OUTPUT
/ STRING BUFFER AND OUTPUT IT.
/
/
PRNTCR,	0
	TAD (215)	/GO PUT A CARRIAGE RETURN IN THE 
	JMS I (PUTCHR	/ OUTPUT STRING BUFFER.
	TAD (212)	/NOW ADD A LINE FEED TO THE BUFFER
	JMS I (PUTBUF	/ AND SEND IT TO THE OUTPUT DEVICE.
	JMP I PRNTCR	/RETURN.

	PAGE
/*-*
/
/ $	(ALT MODE) INTERNAL REGISTER PROCESSOR
/
/
/ SYNTAX:
/  $X		OPEN INTERNAL REGISTER "X"
/  $NX		OPEN INTERNAL REGISTER "N" OF SET "X"
/
/
INREGT,	JMS I (GETNUM	/TRY TO GET AN OCTAL ARGUMENT.
	TAD (CUR%10)	/RESET THE HIGH ORDER DATA WORD (THE
	DCA REGADR+1	/ FIELD) TO HERE!
	JMS ARGTST	/WAS AN ARGUMENT ENTERED ?
	SZL
	JMP INRE1	/YES, LOOK AT THE INDEXED REGISTERS.
/
/
/ DISPLAY 4 DIGIT NON-INDEXED REGISTERS
/
/
	DCA REGADR	/CLEAR, USED AS THE DATA INDEX. 
	JMS I (LOOKUP	/GO LOOK FOR (A) (M) (F) (T).
	  NISREG
	  NISTBL-NISREG
	SKP		/NOT HERE, TRY THE NEXT TABLE.
	JMP INRE2	/FOUND IT, GO SET UP THE OUTPUT.
/
/
/ DISPLAY 5 DIGIT NON-INDEXED REGISTERS
/
/
	JMS I (LOOKUP	/GO LOOK FOR (L) (H) (C) (Q).
	  NILREG
	  NILTBL-NILREG
	JMP INRE1	/NOT HERE, TRY THE NEXT TABLE.

	JMS GETSLH	/GO GET THE REST OF OUR DATA.
	ISZ REGADR	/NOW GET THE HIGH ORDER WORD OF THE 
	TAD I REGADR	/ DATA PAIR AND PUT THE 5TH DIGIT IN
	JMS I (PRNTN1	/ IN THE OUTPUT BUFFER - "OPENWD"
			/ WILL DO THE REST FOR US.
	CLB CMA		/GO SET THE INTERNAL REGISTER OPEN
	JMP INRE3	/ TO SAY 5 DIGITS TO SAVE.
/
/
/ DISPLAY 4 DIGIT INDEXED REGISTERS
/
/
INRE1,	DCA REGADR	/SAVE ARG AS THE DATA INDEX.
	JMS I (LOOKUP	/GO LOOK FOR (P) (I) (U).
	  IXSREG
	  IXSTBL-IXSREG
	JMP I (ERROR	/CAN'T FIND IT ANYWHERE, ERROR TIME.

INRE2,	JMS GETSLH	/GO GET THE REST OF OUR DATA.
	CLB IAC		/SET THE INTERNAL REGISTER OPEN FLAG
INRE3,	DCA I (INTRNL	/ FOR 4 DIGIT DATA.
	JMP I (OPENWD	/NOW, GO DIRECTLY TO "OPENWD", DO
			/ NOT PASS GO, DO NOT...
/
/
/ USEFUL COMMON SUBROUTINE TO READ AND PROCESS "/"
/
/
GETSLH,	0
	TAD REGADR	/ADD IN THE DATA OFFSET, IF ANY,
	DCA REGADR	/ AND SAVE THE ADDRESS POINTER.

	JMS I (GETCHR	/GET THE NEXT INPUT CHARACTER.
	TAD (-257)	/IS IT A "/" ?
	SZA CLA
	JMP I (ERROR	/NO, GO TELL THE USER HE GOOFED.

	JMS I (PUTCHR	/PUT THE "/" IN THE OUTPUT BUFFER.
	JMS I (MOVEDAT	/MOVE THE DATA ADDRESS POINTER INTO
	  REGADR	/ THE CURRENT ADDRESS LOCATION.
	  CADDR
	DCA I (ARGFD	/CLEAR THE "ARGUMENT FOUND" FLAG.
	JMP I GETSLH	/RETURN.

REGADR,	0; 0		/LOCAL TEMPORARY
/*-*
/
/ DISPLAY TASK STATE REGISTERS
/
/
/ SYNTAX:
/ TE		LIST ALL 4 STATE WORDS FOR THE ACTIVE TASK
/ YTE		LIST ALL 4 STATE WORDS FOR TASK "Y", "Y"
/		  BECOMES THE ACTIVE TASK NUMBER.
/
/ TX/		OPEN REGISTER "X" OF THE ACTIVE TASK
/ YTX/		OPEN REGISTER "X" OF TASK "Y", "Y" BECOMES
/		  THE ACTIVE TASK NUMBER.
/
/
TASKST,	JMS I (MOVEARG	/GO UPDATE THE ACTIVE TASK NUMBER,
	  ARGFD		/ IF THE USER ENTERED ONE.
	  ACTTSK
	TAD ACTTSK	/KEEP THE ACTIVE TASK NUMBER WITHIN
	AND (0177)	/ 0 AND 177(8).
	DCA ACTTSK

	JMS I (GETCHR	/GET THE NEXT INPUT CHARACTER AND
	JMS I (LOOKUP	/ SEE WHAT REGISTER THE USER WANTS.
	  TSKREG
	  TSKTBL-TSKREG
	JMP I (ERROR	/CAN'T FIND IT, GO SAY SO.

	SZA		/IS THE DESCRIPTOR WORD = 0 ?
	JMP TSKS1	/NO, LOOK ON.
	JMS I (PUTCHR	/FIRST ECHO THE "E".
	TAD ACTTSK	/USER WANTS TO SEE ALL THE STATE
	JMS TSKLST	/ DATA FOR THE CURRENT TASK.
	JMP I (DECODE	/GO GET THE NEXT COMMAND
	
TSKS1,	DCA TSKSA	/SAVE THE REGISTER DESCRIPTOR WORD.
	TAD TSKSA	/GET THE REGISTER OFFSET AND SAVE
	AND (0007)	/ IT.
	DCA REGADR
	DCA REGADR+1	/FORCE THE HIGH ORDER DATA WORD (THE
			/ FIELD) TO FIELD 0!

	TAD TSKSA	/GET THE NUMBER OF THE REQUESTED
	AND (6000)	/ STATE TABLE.
	SZA
	JMP TSKS2

	TAD ACTTSK	/FOR (TF), USE THE FLAG TABLE.
	TAD (TFTABL)
	JMP INRE2	/GO USE SOME COMMON CODE.
/
TSKS2,	SPA CLA
	JMP TSKS3
	TAD ACTTSK	/FOR (TQ), USE THE MESSAGE TABLE.
	CLL RAL
	TAD (MSGTBL)
	JMP INRE2	/GO USE SOME COMMON CODE.

TSKS3,	TAD ACTTSK	/FOR (TS) (TP) (TA) (TM), USE THE
	CLL RTL		/ TASK STATE TABLE.
	TAD (TSTABL)
	JMP INRE2	/GO FINISH WITH SOME COMMON CODE.

ACTTSK,	0		/ACTIVE TASK REGISTER.
TSKSA,	0		/ORDER IS IMPORTANT
/

	PAGE
/
/
/ MORE ODT/8 INTERNAL REGISTERS
/
/
BKADDR,	ZBLOCK 20	/BREAKPOINT ADDRESS REGISTERS
RELT,	ZBLOCK 20	/RELOCATION REGISTERS

BKPROC,	ZBLOCK 10	/BREAKPOINT PROCEED COUNT REGISTERS
BKUINT,	ZBLOCK 10	/BREAKPOINT INSTRUCTION REGISTERS
UTASKS,	ZBLOCK 10	/USER TASK ASSIGNMENT REGISTERS
/
/
/ 4 DIGIT NON-INDEXED DATA REGISTERS
/
/
NISREG,
	-301	/ A	SEARCH ARGUMENT REGISTER
	-315	/ M	SEARCH MASK REGISTER
	-306	/ F	ADDRESS FORMAT REGISTER
	-324	/ T	ACTIVE TASK REGISTER
	0		/END OF TABLE TERMINATOR
/
/
/ DISPATCH TABLE FOR "NISREG"
/
/
NISTBL,
	SARG	/ A	SEARCH ARGUMENT REGISTER
	SMASK	/ M	SEARCH MASK REGISTER
	FORM	/ F	ADDRESS FORMAT REGISTER
	ACTTSK	/ T	ACTIVE TASK REGISTER
/
/
/ 5 DIGIT NON-INDEXED DATA REGISTERS
/
/
NILREG,
	-314	/ L	LOW MEMORY LIMIT REGISTER
	-310	/ H	HIGH MEMORY LIMIT REGISTER
	-303	/ C	CONSTANT REGISTER
	-321	/ Q	QUANTITY REGISTER
	0		/END OF TABLE TERMINATOR
/
/
/ DISPATCH TABLE FOR "NILREG"
/
/
NILTBL,
	LOW	/ L	LOW MEMORY LIMIT REGISTER
	HIGH	/ H	HIGH MEMORY LIMIT REGISTER
	CNST	/ C	CONSTANT REGISTER
	QUAN	/ Q	QUANTITY REGISTER
/
/
/ 4 DIGIT INDEXED DATA REGISTERS
/
/
IXSREG,
	-311	/ I	BREAKPOINT INSTRUCTION REGISTERS
	-320	/ P	BREAKPOINT PROCEED COUNT REGISTERS
	-325	/ U	USER TASK BREAKPOINT ASSIGNMENTS
	0		/END OF TABLE TERMINATOR
/
/
/ DISPATCH TABLE FOR "IXSREG"
/
/
IXSTBL,
	BKUINT	/ I	BREAKPOINT INSTRUCTION REGISTERS
	BKPROC	/ P	BREAKPOINT PROCEED COUNT REGISTERS
	UTASKS	/ U	USER TASK BREAKPOINT ASSIGNMENTS
/
/
/ TASK STATE REGISTERS
/
/
TSKREG,
	-305	/ E	PRINT ALL THE STATE REGISTERS.
	-306	/ F	TASK FLAG WORD
	-323	/ S	TASK STATUS REGISTER
	-320	/ P	TASK PROGRAM COUNTER
	-301	/ A	TASK ACCUMULATOR
	-315	/ M	TASK M/Q REGISTER
	-321	/ Q	MESSAGE QUEUE HEADER
	0		/END OF TABLE TERMINATOR
/
/
/ DISPATCH TABLE FOR "TSKREG"
/
/
TSKTBL,
	0000	/ E	PRINT ALL THE STATE REGISTERS
	1000	/ F	TASK FLAG WORD
	4000	/ S	TASK STATUS REGISTER
	4001	/ P	TASK PROGRAM COUNTER
	4002	/ A	TASK ACCUMULATOR
	4003	/ M	TASK M/Q REGISTER
	2000	/ Q	MESSAGE QUEUE HEADER

	PAGE
/*-*
/
/ EXECUTE THE SEARCH COMMANDS
/
/
/ SYNTAX:
/ E		EFFECTIVE ADDRESS SEARCH - USE CURRENT DATA
/ ME		"M" TO SARG, THEN SEARCH
/ M;E		"M" TO SMASK, THEN SEARCH
/ M1;M2E	"M1" TO SMASK, "M2" TO SARG, THEN SEARCH
/
/ W		MATCHING SEARCH - USE CURRENT DATA
/ MW		"M" TO SARG, THEN SEARCH
/ M;W		"M" TO SMASK, THEN SEARCH
/ M1;M2W	"M1" TO SMASK, "M2" TO SARG, THEN SEARCH
/
/ N		NOT MATCHING SEARCH - USE CURRENT DATA
/ MN		"M" TO SARG, THEN SEARCH
/ M;N		"M" TO SMASK, THEN SEARCH
/ M1;M2N	"M1" TO SMASK, "M2" TO SARG, THEN SEARCH
/
/
SERCHE,	TAD (0177)	/ENTRY FOR EFFECTIVE ADDRESS SEARCH.
	DCA SMASK
SERCHW,	TAD (SZA-SNA)	/ENTRY FOR MATCHING SEARCH.
SERCHN,	TAD (SNA CLA)	/ENTRY FOR NON MATCHING SEARCH.
	DCA SERC6

	JMS I (MOVEARG	/GO UPDATE THE SEARCH ARGUMENT, IF
	  ARGFD		/ THE USER ENTERED A NEW ONE.
	  SARG

	JMS I (MOVEARG	/GO UPDATE THE SEARCH MASK, IF THE
	  ARG2FD	/ USER ENTERED A NEW ONE.
	  SMASK

SERC2,	TAD SARG	/PREPARE THE USER'S SEARCH ARGUMENT
	AND SMASK	/ FOR USE,
	DCA SERCA	/ AND SAVE IT.
	JMS RANGEC	/GO COMPUTE THE RANGE TO SEARCH.

SERC5,	JMS GETNXA	/GET THE NEXT WORD OF DATA.
	JMP I (DECODE	/ALL DONE, GO FOR ANOTHER COMMAND.
	DCA SERCB	/SAVE THE NEW DATA, THEN
	TAD SERCB	/ GET IT BACK AGAIN.
	AND SMASK	/MASK OFF DON'T CARE BITS.
	CIA
	TAD SERCA	/COMPARE TO THE USER'S ARGUMENT.
SERC6,	HLT		/(CORRECT SKIP PUT HERE ON ENTRY.)
	JMP SERC5	/NOT WHAT WE WANT, TRY AGAIN.
/
	JMS I (PRNTCR	/DO A CR-LF TO START A NEW LINE.
	JMS I (PRTADR	/GO PRINT THE CURRENT ADDRESS, AND
			/ MAYBE USE ONE OF THE RELOCATION
			/ REGISTERS.
	TAD (257)	/PUT A "/" IN THE OUTPUT BUFFER.
	JMS I (PUTCHR

	TAD SERCB	/GET THE CURRENT DATA AGAIN AND
	JMS I (PRNTN4	/ PRINT IT AS 4 OCTAL DIGITS.
	JMP SERC5	/DONE WITH THIS ONE, TRY ANOTHER.

SARG,	0		/SEARCH ARGUMENT REGISTER.
SERCA,	0		/ORDER IS IMPORTANT

SMASK,	7777		/SEARCH MASK REGISTER.
SERCB,	0		/ORDER IS IMPORTANT
/*-*
/
/ FILL MEMORY WITH A CONSTANT
/
/
/ SYNTAX:
/  F		FILL MEMORY - USE CURRENT DATA
/  MF		"M" TO SARG, THEN FILL MEMORY
/
/
FILLCR,	JMS I (MOVEARG	/GO MOVE THE USER'S NEW CONSTANT, IF
	  ARGFD		/ ANY, TO THE SEARCH ARGUMENT SLOT.
	  SARG
	JMS RANGEC	/GO INITIALIZE "RANGE" FOR "GETNXA".
	TAD SARG	/PUT THE CONSTANT TO USE IN FILLING
	DCA I (ARG	/ MEMORY WHERE "PUTCAD" CAN FIND IT.

FILL1,	JMS GETNXA	/GO OPEN THE NEXT LOCATION.
	JMP I (DECODE	/ALL DONE, GO GET ANOTHER COMMAND.
	ISZ I (ARGFD	/SAY "ARGUMENT FOUND" FOR "PUTCAD".
	JMS I (PUTCAD	/LET "PUTCAD" STORE THE DATA FOR US.
	JMP FILL1	/GO AROUND 'TIL DONE.

	PAGE
/*-*
/
/ COMPUTE THE RANGE FOR LOOPING COMMANDS
/
/
/ USED BY (E) (F) (L) (N) (W)
/
/
RANGEC,	0
	CLB IAC		/FORCE "EXPCOM" TO SUBTRACT.
	JMS I (EXPCOM	/SET THE CURRENT ADDRESS TO "LOW"-1.
	  ONE
	  LOW
	  CADDR

	CLB IAC		/FORCE "EXPCOM" TO SUBTRACT.
	JMS I (EXPCOM	/COMPUTE MINUS THE NUMBER OF WORDS
	  HIGH		/ WE NEED TO LOOK AT AND SAVE THIS
	  CADDR		/ VALUE IN "RANGE".
	  RANGE

	TAD RANGE+1	/IS "HIGH" .GE. "LOW" ?
	SMA CLA
	JMP I (ERROR	/NO, TELL THE USER HE GOOFED AGAIN.
	JMP I RANGEC	/ALL READY FOR "GETNXA", RETURN.
/
/
/ GET THE NEXT CONSECUTIVE MEMORY DATA WORD
/
/
/ USED BY (D) (E) (F) (L) (N) (W)
/
/ CALLING SEQUENCE:
/
/	JMS GETNXA
/	  RETURN WHEN RANGE" IS EXHAUSTED
/	  NORMAL RETURN, DATA IN AC
/
/
GETNXA,	0
	ISZ RANGE	/INCREMENT THE LOW ORDER COUNTER.
	SKP
	ISZ RANGE+1	/INCREMNET THE HIGH ORDER AS NEEDED.
	SKP
	JMP I GETNXA	/RANGE EXHAUSTED, TAKE FIRST EXIT.

	ISZ I (CADDR	/INCREMENT THE CURRENT ADDRESS.
	SKP
	ISZ I (CADDR+1	/INCREMENT THE FIELD WORD AS NEEDED.
	JMS I (GETCAD	/GO GET THE DATA AT THE CURRENT 
	ISZ GETNXA	/ ADDRESS, AND TAKE THE SECOND EXIT
	JMP I GETNXA	/ WITH THE DATA IN THE AC.

RANGE,	0; 0		/LOOP COUNTER FOR "GETNXA".
/*-*
/
/ LIST MEMORY DATA
/
/
/ SYNTAX:
/ L		LIST MEMORY - USE CURRENT DATA
/ AL		"A" TO HIGH LIMIT REGISTER, THEN LIST
/ A;L		"A" TO LOW LIMIT REGISTER, THEN LIST
/ A1;A2L	"A1" TO LOW LIMIT, "A2" TO HIGH LIMIT
/ N;A1;A2L	"N" IS THE OUTPUT DEVICE, IF N=0, USE THE
/		"ODTDEV" DEVICE, IF N=1, USE THE "LPT"
/		HANDLER - IF IT EXISTS IN THE SYSTEM. ALSO
/		"A1" TO LOW LIMIT, "A2" TO HIGH LIMIT.
/
/
LISTCR,	JMS I (MOVEARG	/GO UPDATE THE HIGH LIMIT, IF THE
	  ARGFD		/ USER ENTERED A NEW ONE.
	  HIGH
	
	JMS I (MOVEARG	/GO UPDATE THE LOW LIMIT, IF THE 
	  ARG2FD	/ USER ENTERED A NEW ONE.
	  LOW

	IFDEF	LPT <	/ONLY IF "LPT" HANDLER IS DEFINED.
	TAD I (ARG3	/IS THE 3RD ARGUMENT = 1 ?
	SNA CLA
	JMP LIST1	/NO, JUST USE "ODTDEV" FOR OUTPUT.
	TAD (LPT)	/YES, SET THE OUTPUT ROUTINES TO USE
	DCA I (PUTDEV	/ THE "LPT" TASK.
	TAD (214)	/FOR THE "LPT" DEVICE, START WITH A
	JMS I (PUTBUF	/ FORM FEED.
	>

LIST1,	JMS RANGEC	/GO INITIALIZE "RANGE" FOR "GETNXA".
	JMS I (GETNXA	/GO GET THE FIRST WORD OF DATA.
	JMP I (DECODE	/NOTHING TO DO, TRY THE NEXT COMMAND.
	DCA LISTA	/SAVE THE MEMORY DATA FOR LATER.
	JMP LIST3	/NOW WE'RE READY, JUMP INTO IT.

LIST2,	ISZ LISTC	/HAVE WE LISTED 8 LINES ?
	JMP LIST4
	JMS I (PRNTCR	/YES, ADD A CR-LF FOR SEPARATION.
LIST3,	TAD (-10)	/RESET THE LINE COUNTER.
	DCA LISTC

LIST4,	JMS I (PRNTCR	/DO A CR-LF TO START A NEW LINE.
	JMS I (PRTADR	/GO OUTPUT THE CURRENT ADDRESS, AND
			/ MAYBE USE A RELOCATION REGISTER.
	JMS I (PRNTMD	/ADD THE OUTPUT MODE CHARACTER.
	TAD (-10)	/RESET THE LOOP COUNTER, WE DO 8
	DCA LISTB	/ WORDS PER LINE.
/
LIST5,	JMS I (PSPACE	/ADD A SPACE AND OUTPUT THE BUFFER,
	TAD LISTA	/NOW ADD THE MEMORY DATA TO THE
	JMS I (PRNTWD	/ OUTPUT BUFFER.

	JMS I (GETNXA	/GO GET THE NEXT WORD OF DATA.
	JMP LIST6	/ALL DONE, GO CLEAN UP AND EXIT.
	DCA LISTA	/SAVE THE MEMORY DATA FOR A BIT.
	ISZ LISTB	/IS THIS LINE DONE (FULL) ?
	JMP LIST5	/NO, DO ANOTHER WORD OF DATA.
	JMP LIST2	/YES, GO START ANOTHER LINE.

LIST6,	JMS I (PRNTCR	/FINISH WITH A CR-LF.
	JMP I (DECODE	/NOW GO TRY FOR ANOTHER COMMAND.

LISTA,	0		/LOCAL TEMPORARIES.
LISTB,	0
LISTC,	0

	PAGE
/*-*
/
/ PROCESS RELOCATION AND BREAKPOINT REGISTERS
/
/
/ SYNTAX:
/ B		CLEAR ALL BREAKPOINTS
/ NB		CLEAR BREAKPOINT "N"
/ A;B		PUT "A" IN THE NEXT AVAILABLE SLOT
/ A;NB		PUT "A" IN BREAKPOINT SLOT "N"
/ T;A;NB	USE "T" AS THE ACTIVE TASK NUMBER, PUT "A"
/		  IN BREAKPOINT SLOT "N".
/
/ R		CLEAR ALL RELOCATION REGISTERS
/ NR		CLEAR RELOCATION REGISTER "N"
/ A;R		PUT "A" IN THE NEXT AVAILABLE REGISTER
/ A;NR		PUT "A" IN REGISTER "N"
/
/
BREAKP,	ISZ RELOD	/ENTRY TO SET/RESET BREAKPOINTS.
	TAD (BKADDR-RELT)
	SKP
RELOCT,	DCA RELOD	/ENTRY FOR RELOCATION REGISTERS.
	TAD (RELT)
	DCA RELOA	/SAVE THE TABLE BASE ADDRESS.

	TAD I (ARG2FD	/WAS THE "A" ARGUMENT ENTERED ?
	SZA CLA	
	JMP RELO4	/NO, GO LOAD A REGISTER.
/
/
/ CLEAR A REGISTER, OR MAYBE ALL OF THEM
/
/
	JMS ARGTST	/DID THE USER SPECIFY A REGISTER ?
	SNL
	JMP RELO1	/NO, GO DO FOR ALL.
	CLL RAL		/YES, COMPUTE THE ADDRESS OF THE 
	TAD RELOA	/ REGISTER TO CLEAR.
	DCA RELOA
	AC7777		/SET UP TO CLEAR 2 WORDS.
	SKP

RELO1,	TAD (-10)	/CLEAR ALL 20 WORDS OF THE TABLE.
	DCA RELOB
RELO2,	TAD RELOD	/ARE WE DOING A BREAKPOINT REGISTER?
	SNA CLA
	JMP RELO3	/NO, GO ON.
/
	TAD RELOA	/COMPUTE THE INDEX FOR THIS BREAK-
	TAD (-BKADDR)	/ POINT REGISTER.
	CLL RAR
	DCA RELOD
	TAD RELOD	/GET THE INDEX AND GO REMOVE THIS
	JMS REMABK	/ BREAKPOINT, IF IT'S STILL IN PLACE.

	TAD RELOD	/NOW USE THE BREAKPOINT INDEX TO 
	TAD (UTASKS)	/ COMPUTE THE CORRESPONDING ADDRESS
	DCA RELOD	/ IN THE USER TASK ASSIGNMENT TABLE.

	TAD I RELOD	/GET THE TASK NUMBER ASSOCIATED WITH
	CAL		/ THIS BREAKPOINT, AND ASK THE EXEC 
	UNBARG		/ TO TAKE THE TASK OUT OF DEBUG WAIT.
	DEBWT

RELO3,	DCA I RELOA	/CLEAR THE FIRST WORD OF THE 
	ISZ RELOA	/ REGISTER PAIR, AND
	DCA I RELOA	/ NOW CLEAR THE SECOND WORD.
	ISZ RELOA
	ISZ RELOB	/CLEARED ENOUGH WORDS ?
	JMP RELO2	/NO, DO ANOTHER PAIR.
	JMP I (DECODE	/ALL DONE, GO FOR THE NEXT COMMAND.
/
/
/ SET/RESET A REGISTER
/
/
RELO4,	JMS ARGTST	/DID THE USER SPECIFY A REGISTER ?
	SZL
	JMP RELO6	/YES, USE THE USER'S CHOICE.

	TAD (-10)	/FIND AN UNUSED ONE.
	DCA RELOB
RELO5,	TAD I RELOA	/IS THIS REGISTER FREE ?
	ISZ RELOA
	TAD I RELOA	/(CHECK BOTH WORDS.)
	ISZ RELOA
	SNA CLA
	JMP RELO7	/YES, GO USE IT.
	ISZ RELOB	/TABLE EXHAUSTED ?
	JMP RELO5	/NO, LOOK AGAIN.
	JMP I (ERROR	/NO MORE TABLE, SAY ERROR.

RELO6,	CLL RAL		/COMPUTE THE OFFSET FOR THE 
	SKP		/ REQUESTED REGISTER.
RELO7,	AC7776		/BACK THE POINTER UP 2.
	TAD RELOA
	DCA RELOA

	TAD RELOD	/ARE WE DOING A BREAKPOINT REGISTER?
	SNA CLA
	JMP RELO8	/NO, GO FINISH A RELOCATION REGISTER.
/
	TAD I (ARG3	/DID THE USER ENTER A TASK NUMBER ?
	SNA
	JMP .+3	
	AND (0177)	/YES, CLAMP IT BETWEEN 0 - 177 THEN
	DCA ACTTSK	/ UPDATE THE ACTIVE TASK REGISTER.

	TAD RELOA	/COMPUTE THE INDEX WE'RE USING FOR
	TAD (-BKADDR)	/ THE BREAKPOINT REGISTER AND USE
	CLL RAR		/ IT TO COMPUTE THE CORRESPONDING
	TAD (UTASKS)	/ ADDRESS IN THE USER TASK
	DCA RELOD	/ ASSIGNMENT TABLE.

	TAD ACTTSK	/IS THERE AN ACTIVE TASK DEFINED ?
	SNA
	JMP I (ERROR	/NO, BUT WE NEED ONE, SAY SO.
	DCA I RELOD	/YES, PUT IT IN THE USER TASK 
			/ ASSIGNMENT TABLE.

	TAD RELOD	/NOW CONVERT THE ADDRESS TO THE 
	TAD (BKPROC-UTASKS) / CORRESPONDING PLACE IN THE
	DCA RELOD	/ BREAKPOINT PROCEED COUNTER TABLE,
	CLB CMA		/ AND SET THIS PROCEED COUNTER TO -1.
	DCA I RELOD

	AC4000		/MARK THE DATA TO SHOW THIS BREAK-
	TAD I (ARG2+1	/ POINT IS ACTIVE.
	DCA I (ARG2+1

RELO8,	JMS MOVEDAT	/NOW LOAD THE REGISTER.
	  ARG2
RELOA,	  0000
	JMP I (DECODE	/NO, ALL DONE, ON TO SOMETHING ELSE.

RELOB,	0		/LOCAL TEMPORARIES
RELOD,	0

	PAGE
/*-*
/
/ KOMPUTE AND PRINT RELOCATION DISTANCE
/
/
/ SYNTAX:
/  K		COMPUTE THE DISTANCE BETWEEN THE CURRENT
/		ADDRESS AND THE CLOSEST RELOCATION REGISTER
/  NK		COMPUTE THE DISTANCE BETWEEN THE CURRENT
/		ADDRESS AND RELOCATION REGISTER "N"
/  A;NK		MOVE "A" TO THE CURRENT ADDRESS, THEN DO AS
/		FOR "NK" ABOVE.
/
/
KOMPUT,	JMS I (MOVEARG	/GO MOVE THE ENTERED ADDRESS, IF ANY
	  ARG2FD	/ TO THE CURRENT ADDRESS.
	  CADDR
	TAD (275)	/PUT A "=" IN THE OUTPUT BUFFER.
	JMS I (PUTCHR

	JMS ARGTST	/DID THE USER SPECIFY A RELOCATION
	SNL		/ REGISTER ?
	JMP KOMP1	/NO, WE CAN USE OUR OWN CHOICE.
	CLL RAL		/YES, FORCE THE SIGN BIT ON TO SAY
	STL RAR		/ A REGISTER WAS SPECIFIED.
KOMP1,	JMS LOCATE	/NOW GO DO OUR THING.
	JMP I (DECODE	/GO GET ANOTHER COMMAND.
/*-*
/
/ PRINT THE CURRENT ADDRESS USING THE RELOCATION REGISTERS
/
/
/ COME HERE TO FIND THE RELOCATION REGISTER WHICH IS NEAREST
/ TO, BUT STILL LESS THAN, THE CURRENT ADDRESS. IF WE FIND
/ ONE, OUTPUT THE REGISTER NUMBER FOLLOWED BY THE OFFSET TO
/ THE CURRENT ADDRESS. IF NO USEABLE RELOCATION REGISTER IS
/ FOUND, JUST OUTPUT THE CURRENT ADDRESS AS AN ABSOLUTE
/ ADDRESS.
/
/
LOCATE,	0
	DCA LOCE	/IF NOT ZERO, THE AC SPECIFIES THE
			/ RELOCATION REGISTER TO USE.
	TAD LOCE	/COMPUTE THE ADDRESS OF THE FIRST
	CLL RAL		/ RELOCATION REGISTER TO LOOK AT,
	TAD (RELT)
	DCA LOC2	/ AND PUT IT WHERE WE NEED IT.

	CLB CMA		/PRESET "LOCA" TO THE MAXIMUM
	DCA LOCA	/ POSSIBLE DISTANCE.
	TAD (7)
	DCA LOCA+1
	TAD LOCE	/ADD IN THE CALLER'S INDEX WHEN WE
	TAD (-10)	/ SET UP A LOOP COUNTER.
	DCA LOCC
	DCA LOCD	/CLEAR THE FOUND REGISTER NUMBER.

LOC1,	CLB IAC		/FORCE "EXPCOM" TO SUBTRACT.
	JMS I (EXPCOM
LOC2,	  0		/COMPARE THIS RELOCATION REGISTER TO
	  CADDR		/ THE CURRENT ADDRESS.
	  LOCB		/(THE RESULT GOES HERE.)
	TAD LOCB+1	/IF THIS REGISTER .GT. THE CURRENT
	SPA CLA		/ ADDRESS, THE RESULT IS NEGATIVE.
	JMP LOC3	/IS NEGATIVE, TRY ANOTHER REGISTER.

	CLB IAC		/FORCE "EXPCOM" TO SUBTRACT.
	JMS I (EXPCOM
	  LOCA		/COMPARE THE NEW OFFSET WITH THE 
	  LOCB		/ CURRENT SMALLEST OFFSET.
	  ARG
	TAD I (ARG+1	/IF THIS RESULT IS NEGATIVE, THE NEW
	SMA CLA		/ OFFSET IS CLOSER THAN WHAT WE HAD.
	JMP LOC3	/NOPE, TRY ANOTHER REGISTER.

	TAD LOCB	/UPDATE THE SMALLEST OFFSET STORAGE
	DCA LOCA	/ WITH THE NEW FOUND VALUE.
	TAD LOCB+1
	DCA LOCA+1
	TAD LOCC	/SAVE THE NUMBER OF THIS REGISTER.
	DCA LOCD
/
LOC3,	TAD LOCE	/DID THE CALLER SPECIFY WHICH
	SZA CLA		/ RELOCATION REGISTER TO USE ?
	JMP LOC4	/YES, GO USE WHAT WE HAVE.
	ISZ LOC2	/NO, INCREMENT THE REGISTER POINTER,
	ISZ LOC2	/ TWICE.
	ISZ LOCC	/ANY MORE REGISTERS TO LOOK AT ?
	JMP LOC1	/YES, LOOK AGAIN.

LOC4,	TAD LOCD	/DID WE FIND A USEABLE RELOCATION
	SZA		/ REGISTER ?
	JMP LOC5	/YES, GO OUTPUT AS RELOCATED.
	JMS I (PRNTN5	/NO, JUST OUTPUT THE CURRENT ADDRESS
	  CADDR		/ AS A 5 DIGIT ABSOLUTE ADDRESS.
	JMP I LOCATE	/ALL DONE, BACK TO OUR CALLER.

LOC5,	TAD (270)	/REFORM THE RELOCATION REGISTER
	JMS I (PUTCHR	/ NUMBER AND OUTPUT IT,
	TAD (254)	/ FOLLOWED BY A COMMA.
	JMS I (PUTCHR
	JMS I (PRNTN5	/NOW OUTPUT THE DISTANCE BETWEEN THE
	  LOCA		/ RELOCATION REGISTER AND THE
			/ CURRENT ADDRESS.
	JMP I LOCATE	/ AND RETURN FROM WHENCE WE CAME.

LOCA,	0; 0		/CURRENT SMALLEST ADDRESS OFFSET.
LOCB,	0; 0		/TRIAL OFFSET GOES HERE.
LOCC,	0		/LOOP COUNTER.
LOCD,	0		/NUMBER OF THE CLOSEST REGISTER.
LOCE,	0		/REGISTER THE CALLER ASKED FOR, IF
			/ IF HE SPECIFIED ONE.
/*-*
/
/ TEST FOR A VALID REGISTER ARGUMENT
/
/
/ CHECK THAT THE LAST ARGUMENT ENTERED WAS IN THE 
/ RANGE OF 0 TO 7.
/
/ ON CALL: ARGUMENT DATA, IF ANY, IS IN "ARG".
/
/ ON RETURN: ARGUMENT IS IN THE AC.
/
/
ARGTST,	0
	CLB
	TAD I (ARGFD	/WAS AN ARGUMENT ENTERED ?
	SNA CLA
	JMP I ARGTST	/NONE THERE, JUST RETURN.

	TAD I (ARG	/GET THE LOW ORDER ARGUMENT DATA.
	AND (7770)	/IS IT .GT. 7 ?
	SZA CLA
	JMP I (ERROR	/YES, SAY THE USER GOOFED.

	STL		/SET THE LINK TO SAY WE HAVE DATA,
	TAD I (ARG	/ PUT THE ARGUMENT IN THE AC, AND
	JMP I ARGTST	/ RETURN FROM WHENCE WE CAME.

	PAGE
/*-*
/
/ PRINT THE STATE DATA FOR THE SPECIFIED TASK
/
/
/ ON CALL: THE ACCUMULATOR CONTAINS THE NUMBER OF THE 
/	     TASK TO DO.
/
/
TSKLST,	0
	DCA TSKLA	/SAVE THE DESIRED TASK NUMBER.
	TAD (-4)	/SET UP A LOOP COUNTER.
	DCA TSKLB
	JMS I (PSPACE	/ADD A SPACE.
	TAD TSKLA	/FIRST OUTPUT THE TASK NUMBER,
	JMS I (PRNTN4
	JMS I (PSPACE	/ THEN AN EXTRA SPACE.

	TAD TSKLA	/COMPUTE THE STARTING ADDRESS OF THE
	CLL RTL		/ TASK STATE DATA FOR THIS TASK.
	TAD (TSTABL)
	DCA TSKLA

TSKL1,	JMS I (PSPACE	/OUTPUT A SPACE.
	CDF 0
	TAD I TSKLA	/GET THE NEXT WORD IN THE STATE
	CDF CUR		/ TABLE,
	ISZ TSKLA
	JMS I (PRNTN4	/AND ADD IT TO THE OUTPUT BUFFER.
	ISZ TSKLB	/FINISHED ALL 4 STATE WORDS ?
	JMP TSKL1	/NO, DO ANOTHER.
	JMP I TSKLST	/RETURN FROM WHENCE WE CAME.

TSKLA,	0		/LOCAL TEMPORARIES.
TSKLB,	0
/
/
/ LIST THE TASKS IN "DEBUG" WAIT AND THEIR STATE
/
/
DBLIST,	CLB IAC		/SET THE AC TO SAY REINITIALIZE THE
			/ SEARCH ON THE FIRST CALL.
DBL1,	JMS FINDDB	/GO LOOK FOR A TASK IN DEBUG WAIT.
	JMP I (DECODE	/ALL DONE, GO SEE WHAT'S NEXT.
	DCA DBLIA
	JMS I (PRNTCR
	TAD DBLIA
	JMS TSKLST	/GO OUTPUT THE STATUS DATA FOR THIS
			/ TASK.
	JMP DBL1	/GO AROUND AGAIN.

DBLIA,	0		/LOCAL TEMPORARY.
/
/
/ FIND A TASK IN DEBUG WAIT
/
/
/ ON CALL:
/		IF THE AC .NE. 0, INITIALIZE THEN SEARCH
/		IF AC .EQ. 0, CONTINUE SEARCH FROM HERE
/
/
/ CALLING SEQUENCE:
/
/	JMS FINDDB
/	  EXIT HERE WHEN THE TABLE IS EXHAUSTED
/	  EXIT HERE WITH TASK NUMBER IN THE AC
/
/
FINDDB,	0
	SNA CLA		/IS THE ACCUMULATOR = 0 ?
	JMP FIND1	/YES, JUST LOOK FOR THE NEXT TASK.
	TAD (TFTABL+1)	/REINITIALIZE THE TABLE POINTER,
	DCA FINDA
	DCA FINDB	/ AND CLEAR THE LOOP COUNTER.

FIND1,	CDF 0
	TAD I FINDA	/GET THE NEXT TASK FLAG WORD.
	ISZ FINDA
	ISZ FINDB	/INCREMENT THE LOOP COUNTER.
	AND (DEBWT)	/IS THE TASK IN DEBUG WAIT ?
	SZA CLA
	JMP FIND2	/YES, 
	
	TAD FINDB	/HAVE WE SEARCHED THE WHOLE TABLE ?
	TAD (-NTASKS)
	SPA CLA
	JMP FIND1	/NO, LOOK AGAIN.
	CDF CUR
	JMP I FINDDB	/THE TABLE EXHAUSTED, TAKE THE FIRST 
			/EXIT.

FIND2,	CDF CUR
	TAD FINDB
	ISZ FINDDB
	JMP I FINDDB

FINDA,	0		/LOCAL TEMPORARIES.
FINDB,	0
/*-*
/
/ PRINT THE ASSIGNED REGISTER SETS
/
/
/ OUTPUT A TABLE CONTAINING THE USER TASK ASSIGNMENTS,
/ AND THE BREAKPOINT ADDRESS, RELOCATION, AND BREAKPOINT
/ PROCEED COUNTER REGISTERS.
/
/
ASLIST,	TAD (-10)	/SET UP A LOOP COUNTER.
	DCA ASLA
	TAD (UTASKS)	/CREATE A POINTER FOR THE USER TASK
	DCA ASLB	/ ASSIGNMENT TABLE.
	TAD (BKADDR)	/SET UP THE ADDRESS OF THE
	DCA ASL2	/ BREAKPOINT REGISTER TABLE.

	TAD (RELT)	/DO THE SAME FOR THE RELOCATION 
	DCA ASL3	/ REGISTER TABLE.
	TAD (BKPROC)	/AND FINALLY SET UP A POINTER FOR
	DCA ASLC	/ THE  BREAKPOINT PROCEED COUNTER
			/ TABLE.
	DCA ASLD	/CLEAR THE LINE COUNTER.

ASL1,	JMS I (PRNTCR	/START A NEW LINE WITH A CR-LF.
	JMS I (PSPACE	/FIRST PUT A SPACE IN THE BUFFER.
	TAD ASLD	/THEN OUTPUT THE LINE COUNTER.
	ISZ ASLD
	JMS I (PRNTN1
	JMS I (PSPACE	/ADD 2 SPACES.
	JMS I (PSPACE

	TAD I ASLB	/GET THE NEXT ENTRY IN THE USER TASK
	ISZ ASLB	/ ASSIGNMENT TABLE,
	JMS I (PRNTN4	/ AND OUTPUT IT.
	JMS I (PSPACE	/ADD A SPACE.

	JMS I (PRNTN5	/OUTPUT THE NEXT BREAKPOINT
ASL2,	  0000		/ ASSIGNMENT.
	ISZ ASL2
	ISZ ASL2
	JMS I (PSPACE	/AND A SPACE.

	JMS I (PRNTN5	/NOW OUTPUT THE NEXT RELOCATION
ASL3,	  0000		/ REGISTER.
	ISZ ASL3
	ISZ ASL3
	JMS I (PSPACE	/ANOTHER SPACE.

	TAD I ASLC	/FINALLY OUTPUT THE NEXT BREAKPOINT
	ISZ ASLC	/ PROCEED COUNTER.
	JMS I (PRNTN4
	ISZ ASLA	/HAVE WE FINISHED THE LIST ?
	JMP ASL1	/NO, DO ANOTHER LINE.
	JMP I (DECODE	/ALL DONE, BACK TO COMMAND INPUT.
/
ASLA,	0		/LOCAL TEMPORARIES.
ASLB,	0
ASLC,	0
ASLD,	0
/
/
/ RELEASE A TASK FROM DEBUG WAIT
/
/
/ ON CALL: THE ACCUMULATOR CONTAINS THE NUMBER OF THE
/	     TASK TO RELEASE
/
/
RELEASE,0
	TAD (TFTABL)	/COMPUTE THE ADDRESS OF THE FLAG
	DCA RELEA	/ WORD FOR THE SPECIFIED TASK.
	CDF 0		/THE TASK FLAG TABLE IS IN FIELD 0.
	CIF CUR		/WE NEED INTERRUPTS OFF FOR THIS !

	TAD I RELEA	/GET THE TASK'S FLAG WORD,
	AND (-DEBWT-1)	/ AND OUT THE DEBUG WAIT BIT,
	DCA I RELEA	/ AND PUT THE FLAG WORD BACK WHERE
	CDF CUR		/ THE EXEC CAN FIND IT.
	JMP I RELEASE	/NOW THAT WAS EASY, WASN'T IT ?

RELEA,	0		/LOCAL TEMPORARY.

	PAGE
/
/
/ SET BREAKPOINTS AND GO TO THE USER'S TASKS
/
/
/ SYNTAX:
/ G		SET BREAKPOINTS AND RELEASE THE TASKS
/ MG		SET BREAKPOINTS AND RELEASE THE TASKS IN 
/		  WAIT STATE "M"
/
/
GOTOIT,	TAD BKPACT	/IS THERE AN ACTIVE BREAKPOINT ?
	SZA CLA
	JMP I (ERROR	/YES, THIS COMMAND IS ILLEGAL ONCE
			/ BREAKPOINTS ARE SET IN PLACE.

	DCA STEPFG	/CLEAR THE SINGLE STEP FLAG.
	JMS SETBKP	/GO SET THE BREAKPOINTS.
	TAD BKPACT	/DID WE SET ANY BREAKPOINTS ?
	SNA CLA
	JMP I (ERROR	/NO, THAT'S A COMMAND ERROR.

	JMS ARGTST
	SNL
	CLB CMA
/	DCA

	JMP DECODE

BKPACT,	0		/BREAKPOINT ACTIVE FLAG.
STEPFG,	0		/SINGLE STEP FLAG.
/
/
/ PROCEED FROM A BREAKPOINT
/
/
/ SYNTAX:
/ P		PROCEED FROM BREAKPOINTS ONCE
/ MP		PROCEED FROM BREAKPOINTS "M" TIMES
/ N;MP		PROCEED FROM BREAKPOINT "N", "M" TIMES
/
/
PROCED,

	JMS REMBKP

	JMP DECODE


	TAD ARG2FD
	SZA CLA
	JMP
/
/
/ EXECUTE A SINGLE INSTRUCTION IN A TASK
/
/
/ SYNTAX:
/ S		EXECUTE ONE INSTRUCTION AT THE CURRENT 
/		  BREAKPOINT
/ MS		EXECUTE "M" INSTRUCTIONS AT THE CURRENT
/		  BREAKPOINT
/
/
SINGLE,

	JMS SETBKP

	JMP EFWAIT


	PAGE
/
/
/ SET ALL THE ACTIVE BREAKPOINTS IN THE USER'S TASKS
/
/
SETBKP,	0
	TAD (-10)	/SET UP A LOOP COUNTER.
	DCA SETBA
	TAD (BKADDR)	/PRESET THE ADDRESS OF THE BREAK-
	DCA SETB2	/ POINT TABLE FOR "MOVEDAT".
	TAD (BKUINT)	/SET UP A POINTER TO THE BREAKPOINT
	DCA SETBB	/ INSTRUCTION TABLE.
	TAD (CALODT)	/PRESET "ARG" WITH THE BREAKPOINT
	DCA I (ARG	/ HOOK SO "PUTCAD" CAN FIND IT.

SETB1,	JMS I (MOVEDAT	/PUT THE ADDRESS OF THE NEXT BREAK-
SETB2,	  0000		/ POINT REGISTER IN "CADDR".
	  CADDR

	ISZ SETB2
	TAD I SETB2	/IS THIS BREAKPOINT REGISTER ACTIVE?
	SMA CLA
	JMP SETB3	/NO, CONTINUE ON DOWN THE LIST.

	JMS I (GETCAD	/GET THE USER'S INSTRUCTION AND
	TAD (-CALODT)	/ MAKE SURE IT'S NOT THE BREAKPOINT
	SNA		/ INSTRUCTION.
	JMP SETB3	/IT IS, DON'T SET IT AGAIN !!
	TAD (CALODT)	/REFORM THE USER'S INSTRUCTION, AND
	DCA I SETBB	/ SAVE IT IN THE BKP INSTRUCTION
			/ TABLE.
	ISZ I (ARGFD	/SET THE "ARGUMENT FOUND" FLAG AND
	JMS I (PUTCAD	/ THEN LET "PUTCAD" DO IT'S THING.
	ISZ BKPACT	/INCREMENT THE ACTIVE BKP COUNTER.

SETB3,	ISZ SETB2	/MOVE THE POINTERS ALONG.
	ISZ SETBB
	ISZ SETBA	/FINISHED ALL 8 BREAKPOINTS ?
	JMP SETB1	/NO, GO AROUND AGAIN.
	JMP I SETBKP	/ALL DONE, RETURN.

SETBA,	0		/LOCAL TEMPORARIES
SETBB,	0
/
/
/ REMOVE ALL BREAKPOINTS FROM THE USER'S TASKS
/
/
REMBKP,	0
	TAD (-10)	/SET UP A LOOP COUNTER.
	DCA REMBA

REMB1,	TAD REMBA	/FORM AN INDEX FOR THIS BREAKPOINT
	TAD (10)	/ FROM THE LOOP COUNTER,
	JMS REMABK	/ AND GO REMOVE IT.
	ISZ REMBA	/FINISHED ALL 8 OF THEM ?
	JMP REMB1	/NO, TRY ANOTHER.
	JMP I REMBKP	/YES, RETURN FROM WHENCE WE CAME.

REMBA,	0		/LOCAL TEMPORARY.
/
/
/ REMOVE A SPECIFIED BREAKPOINT 
/
/
/ ON CALL: THE AC CONTAINS THE INDEX OF THE BREAKPOINT TO DO
/
/
REMABK,	0
	DCA REMAA	/SAVE THE BREAKPOINT INDEX.
	TAD REMAA	/COMPUTE THE ADDRESS OF THE BREAK-
	CLL RAL		/ POINT IN THE BREAKPOINT TABLE, AND
	TAD (BKADDR)	/ SAVE IT FOR "MOVEDAT" TO USE.
	DCA REMA1
	TAD REMAA	/USE THE CALLER'S INDEX AGAIN TO SET
	TAD (BKUINT)	/ UP A POINTER TO THE INSTRUCTION
	DCA REMAA	/ WE  WANT TO PUT BACK IN THE USER'S
			/ TASK.

	JMS I (MOVEDAT	/MOVE THE BREAKPOINT ADDRESS TO
REMA1,	  0000		/ "CADDR".
	  CADDR
	JMS I (GETCAD	/GET THE INSTRUCTION AT THE BREAK-
	TAD (-CALODT)	/ POINT, AND CHECK THAT IT IS THE
	SZA CLA		/ BREAKPOINT INSTRUCTION !
	JMP I REMABK	/IT WASN'T, WE CAN'T REMOVE IT IF
			/ WE DID NOT SET IT !!

	TAD I REMAA	/NOW GET THE INSTRUCTION AND PUT IT
	DCA I (ARG	/ WHERE "PUTCAD" CAN FIND IT.
	ISZ I (ARGFD	/SET THE "ARGUMENT FOUND" FLAG SO
	JMS I (PUTCAD	/ "PUTCAD" CAN DO IT'S THING FOR US.
	CLB CMA		/DECREMENT THE ACTIVE BKP COUNTER.
	TAD BKPACT
	DCA BKPACT
	JMP I REMABK	/'TIS DONE, RETURN TO OUR CALLER.

REMAA,	0		/LOCAL TEMPORARY.
/

	PAGE
/
/
/ BREAKPOINT SERVICE ROUTINE
/
/
BKPSER,	0
	TAD BKPACT	/IS THERE A BREAPOINT ACTIVE ?
	SNA CLA
	JMP I BKPSER	/NO, NOTHING TO DO, JUST RETURN.

	CLB IAC
BKPS1,	JMS FINDDB	/FIND THE NEXT TASK IN DEBUG WAIT.
	JMP I BKPSER	/ALL DONE, RETURN TO THE CALLER.
	DCA BKPSA
	TAD BKPSA	/SET UP A POINTER TO THE PROGRAM
	CLL RTL		/ COUNTER WORD FOR THIS TASK.
	TAD (TSTABL+1)
	DCA BKPSB

	CLB CMA		/NOW A POINTER TO THE STATUS WORD
	TAD BKPSB	/ FOR THE TASK.
	DCA BKPSC
	TAD (BKADDR)	/AND A POINTER TO THE BREAKPOINT
	DCA BKPSD	/ TABLE.
	TAD (-10)	/LASTLY, SET UP A LOOP COUNTER.
	DCA BKPSE

BKPS2,	TAD I BKPSD	/TEST IF THE TASK'S PROGRAM COUNTER
	ISZ BKPSD	/ MATCHES THIS BREAKPOINT ADDRESS.
	CMA
	CDF 0
	TAD I BKPSB
	SZA CLA
	JMP BKPS3	/NO, TRY ANOTHER BREAKPOINT.
	
	TAD I BKPSC	/THE PROGRAM COUNTER MATCHES, DOES
	CLL RTR		/ THE MEMORY FIELD MATCH ?
	STL RAR
	AND (4007)	/(BIT 0 IS SET HERE TO MATCH THE 
	CIA		/ "ACTIVE" BIT IN THE BREAKPOINT
	CDF CUR		/ REGISTER TABLE.)
	TAD I BKPSD
	SNA CLA
	JMP BKPS4	/WE FOUND THE BREAKPOINT FOR THIS 
			/ TASK, GO CHECK THE PROCEED COUNTER.

BKPS3,	CDF CUR
	ISZ BKPSD	/MOVE THE BREAKPOINT POINTER ALONG.
	ISZ BKPSE	/LOOKED AT ALL 8 BREAKPOINTS ?
	JMP BKPS2	/NO, TRY THE NEXT BREAKPOINT.
	JMP BKPS1	/BREAKPOINT TABLE EXHAUSTED, TRY THE
			/ NEXT TASK IN DEBUG WAIT. THIS IS
			/ ACTUALLY AN ERROR, AND SHOULD NOT
			/ HAPPEN, BUT ....
/
BKPS4,	CDF CUR
	TAD BKPSE	/COMPUTE THE ADDRESS OF THE PROCEED
	TAD (10)	/ COUNTER FOR THIS BREAKPOINT.
	TAD (BKPROC)
	DCA BKPSD

	ISZ I BKPSD	/INCREMENT THE PROCEED COUNTER.
	SKP
	JMP BKPS5	/
/
/	JMS SIM
/
	TAD BKPSA
	JMS RELEASE
	JMP BKPS1
/
/
/ LOG THE COMPLETED BREAKPOINT
/
/
BKPS5,	JMS I (PRNTCR	/START THE LINE WITH A CR-LF.
	JMS I (PSPACE	/AND A SPACE.
	TAD BKPSE	/COMPUTE THE BREAKPOINT INDEX, AND
	TAD (10)	/ OUTPUT IT.
	JMS I (PRNTN1
	TAD ("B)	/ADD A "B" TO SAY BREAKPOINT.
	JMS I (PUTCHR
	JMS I (PSPACE	/ANOTHER SPACE.

	TAD BKPSE	/
	TAD (10)
	JMS REMABK

	TAD BKPSA	/NOW GO OUTPUT THE ACTIVE REGISTER
	JMS TSKLST	/ DATA FOR THIS TASK.

	TAD BKPACT
	SZA CLA
	JMP BKPS1	/ALL DONE WITH THIS TASK, GO LOOK
			/ FOR ANOTHER TASK TO DO.
	JMP DECODE

BKPSA,	0		/LOCAL TEMPORARIES.
BKPSB,	0
BKPSC,	0
BKPSD,	0
BKPSE,	0
/

	PAGE