;
;	PR00 - PRINT STATEMENT
;
;		REGISTERS USED 0,1,2,3,4-OR ALL FOR SHORT
;
PR00:	CLR	-(SP)		;A SWITCH TO FORCE A DELIMITER
PR01:	MOV	#34,R0		;MAKE SURE THIS MAY BYTES ARE AVAILABLE
	TSTOK			;AND FIND OUT FOR SURE
	BLO	PR02		;JUMP IF NOT AVAILABLE
	SKIP			;GET THE NEXT CHARACTER
	CMPB	R2,#',		;CHECK FOR A VALID DELIMITER
	BEQ	PR04		;IS IT A COMMA?
	CMPB	R2,#';
	BEQ	PR09		;IS IT A SEMI-COLON?
	CMPB	R2,#'"
	BEQ	PR12		;IS IS A QUOTE?
	CMPB	R2,#':
	BEQ	PR13		;IS IT A COLON?
	CMPB	R2,#012
	BEQ	PR13		;IS IT A <LF>?
	TST	(SP)		;IT'S NOT A DELIMITER
	BLT	PR11		;IF NEGATIVE THEN WE WANTED ONE!
	DEC	R1		;BACK UP TO THE START OF THE EXPRESSION
	EVAL			;GO FIND THE VALUE
	BVS	PR11		;OVERFLOW IS AN ERROR
	MOV	R1,-(SP)	;SAVE THE TEXT POINTER
	JSR	PC,FTOA00
	MOV	SP,R0		;THE OUTPUT AREA WAS LEFT ON THE STACK
	PRINTL
	ADD	#24,SP		;REMOVE THE OUTPUT AREA
	MOV	(SP)+,R1	;RESTORE THE TEXT POINTER
	MOV	#-1,(SP)	;FORCE A DELIMITER
	BR	PR01

PR04:	MOV	POSITN,R0	;GET THE POSITION
	CMP	R0,#56.		;WE'VE FOUND A COMMA
	BLT	PR05		;SEE IF THERE'S ANY MORE ROOM
	CRLF
	BR	PR09
PR05:	NEG	R0		;CALCULATE THE MOD 14 COUNT
PR06:	BGT	PR07		;ADD 14 UNTIL A POSITIVE RESULT
	ADD	#14.,R0		;ADD AND GO AGAIN
	BR	PR06
PR07:	MOVB	#040,R2		;OUTPUT SPACES
PR08:	PRINTC
	DEC	R0		;DECREMENT THE MOD 14 COUNTER
	BGT	PR08		;LOOP IF MORE TO DO
PR09:	MOV	#1,(SP)	;SET DELIMITER FOUND SWITCH
	BR	PR01

PR11:	PRNERR			;ISSUE FATAL ERROR

PR12:	MOVB	(R1)+,R2	;START TO OUTPUT THE LITERAL STRING
	PRINTC
	CMPB	@R1,#012	;TRY TO FIND THE OTHER END OF THIS MESS
	BEQ	PR11		;LINE FEED BEFORE MATCHING " IS AN ERROR
	CMPB	@R1,#'"
	BNE	PR12		;IF NOT <LF> OR " GO AGAIN
	INC	R1		;SKIP THE "
	CLR	@SP		;SHOW A QUOTE FIELD EXISTS
	BR	PR01

PR13:	TST	(SP)+		;CHECK FOR TRAILING DELIMITER
	BGT	PR14		;NEGATIVE OR ZERO MEANS CRLF
	CRLF
PR14:	DEC	R1		;BACK UP TO THE TERMINATOR
	JMP	INIT02		;BACK TO THE INTERPRETER
PR02:	OVFERR			;STORAGE OVERFLOW IN PRINT
INP00:	
	CLR	-(SP)		;SET UP A LAND MARK
	JSR	PC,COM00	;GET VARIABLE
	BVC	INP02		;IT IS OK
	INPERR			;ISSUE FATAL ERROR
INP02:	CLR	-(SP)		;SET THE LIMITS OF ADDRESSES
	MOV	R1,-(SP)	;SAVE THE TEXT POINTER
INP10:	MOV	#'?,R2		;TELL HIM TO GET WITH IT
	PRINTC
	PACK			;GET A LINE
	JSR	PC,FILL00	;TRY TO SATISFY THE REQUEST
	BVS	INP06		;OVERFLOW IS BACK DATA
	BGT	INP04		;TOO MUCH INPUT TYPED
	BLT	INP05		;NOT ENOUGH INPUT TYPED
	MOV	(SP)+,R1	;RECOVER THE TEST ADDRESS
	TST	(SP)+		;REMOVE FIRST 0
	TST	(SP)+		;REMOVE A WORD AND CHECK FOR THE END
	BNE	.-2		;LOOP FOR MORE
	DEC	R1		;BACK UP CHARACTER POINTER
	TST	RUNF		;CHECK FOR IMMEDIATE MODE
	BNE	INP03		;OMIT THIS LITTLE BIT IF RUNNING
	MOVB	#012,@R1
INP03:	JMP	INIT02

INP04:	IN1ERR			;HE TYPED TOO MUCH
	BR	INP10		;TRY AGAIN
INP05:	IN2ERR			;HE DIDN'T TYPE ENOUGH
	BR	INP10		;TRY AGAIN
INP06:	IN3ERR			;HE IS A LOUSY TYPIST
	BR	INP10		;TRY AGAIN

FILL00:	MOV	SP,R4		;USE R4 FOR A WHILE
	CMP	(R4)+,(R4)+	;POINTS TO THE LAST ZERO NOW
	TST	(R4)+		;POINTS TO THE LAST ADDRESS
	TST	(R4)+		;GO FIND THE FIRST 0
	BNE	.-2		;LOOP TILL FOUND
	TST	-(R4)		;R4 POINTS TO THE FIRST 0
FILL01:	MOV	-(R4),R0	;PICK UP A VARIABLE ADDRESS
	BEQ	FILL06		;NOT ENOUGH DATA
	MOV	R4,-(SP)	;SAVE THE LIST POINTER
	ATOF
	BVS	FILL99		;I WISH HE COULD TYPE
	MOV	(SP)+,R4	;RESTORE LIST POINTER
	CMPB	@R1,#',		;CHECK THE SEPARATOR
	BEQ	FILL02		;IT'S A COMMA
	CMPB	@R1,#':
	BEQ	FILL03		;IT'S A COLON
	CMPB	@R1,#012
	BEQ	FILL03		;IT'S A <LF>
FILL05:	SEV			;SET OVERFLOW
FILL04:	RTS	PC		;RETURN
FILL02:	INC	R1		;SKIP THE SEPARATOR
	BR	FILL01		;TAKE ANOTHER CONVERSION
FILL03:	MOV	-(R4),R0	;SEE IF THE NEXT ONE IS VALID
	BEQ	FILL04		;EXIT IF OK
	SEN			;TELL HIM NOT ENOUGH DATA
	RTS	PC		;RETURN
FILL06:	CCC			;MAKE MORE DATA THAN VAR.
	RTS	PC		;AND EXIT
FILL99:	TST	(SP)+		;REMOVE LIST POINTER
	BR	FILL05		;AND EXIT
;
; COMMON EXPRESSION HANDLER FOR READ AND INPUT
;
COM00:	GETADR			;GET NAME
	BVS	COM99		;BAD NAME
	BNE	COM01		;OK IF FOUND
	MOV	R4,R0		;SET UP THE NAME
	PSHNAM			;PUSH VARIABLE ON LIST
COM01:	MOV	(SP)+,R2	;SAVE RETURN ADDRESS
	MOV	R0,-(SP)	;SAVE THE VARIABLE ADDRESS
	MOV	#4,R0		;SEE IF FOUR
	TSTOK			; BYTES ARE AVAILABLE
	BLO	COM03		;     OVERFLOW IF NOT AVAILABLE
	MOV	R2,-(SP)	;REPLACE THE RETURN ADDRESS ON THE STACK
	SKIP
	CMPB	R2,#',		;CHECK FOR A GOOD SEPARATOR
	BEQ	COM00		;COMMAS ARE OK
	CMPB	R2,#':		;SO IS A SEMI-COLON
	BEQ	COM02
	CMPB	R2,#12		;SO IS A <LF>
	BEQ	COM02
COM99:	SEV			;SET BADNESS
COM02:	RTS	PC
COM03:	OVFERR			;OVERFLOW
READ00:	MOV	#1,-(SP)	;A BACK STOP FOR THE LANDMARK
	CLR	-(SP)		;A LANDMARK
	JSR	PC,COM00
	BVC	READ02
READ99:	REAERR
READ02:	CLR	-(SP)
	MOV	R1,-(SP)
	MOV	DATI,R1		;PICK UP THE CURRENT POINTER
	BNE	READ03		;START NOW IF WE ARE SOME WHERE
	MOV	USR,R1		;START FROM THE BEGINING
	BR	READ05		;AND LOOK FOR A DATA STATEMENT
READ03:	CMPB	@R1,#12		;NEXT
	BEQ	READ05		;DATA STATEMENT
	JSR	PC,FILL00	;GO GET DATA
	BVS	READ07		;OH NO AN ERROR
	BLT	READ04		;BRANCH ON NOT ENOUGH DATA
	MOV	R1,DATI		;SAVE THE POINTER FOR NEXT TIME
	MOV	(SP)+,R1	;GET BACK THE TEXT POINTER
	TST	(SP)+		;POP THE TOP 0
	TST	(SP)+		;POP TO THE LANDMARK
	BNE	.-2		;LOOP FOR MAORE
	TST	(SP)+		;THEN GO TO THE BACK STOP
	BEQ	.-2		;LOOP FOR MORE IF ANY
	DEC	R1
	JMP	INIT02		;BACK TO THE BOSS
READ04:	TST	(R4)+		;R4 POINTS TO THE LAST GOOD VARIABLE
	CLR	(R4)+		;CLEAR IT AND ANY OTHERS TO THE
	TST	@R4		;LAND MARK WE LAID DOWN BEFORE
	BNE	.-4		;LOOP TIL WE FIND THAT 0
READ05:	TXTADR			;FIND THE UPPER LIMIT
READ06:	CMPB	#147,(R1)+	;IS WE AT A DATA STATEMENT??
	BEQ	READ03		;IF SO GO FINISH WHAT WE STARTED
	CMP	R1,R3		;SEE IF IT'S ALL OVER
	BLO	READ06		;BRANCH IF MORE TEXT
	RE1ERR			;FATAL ERROR
READ07:	RE2ERR			;FATAL ERROR
;
; FOR <VARIABLE> = <FORMULA> TO <FORMULA> STEP <FORMULA>.  SET UP
;	AND EXECUTE THE "FOR"STATEMENT.  REGISTERS USED - ALL.
;
FOR00:	GETVAR			;GET THE CONTROL VARIABLE
	CMP	R2,#'=		;IS IT A SIMPLE VARIABLE?
	BNE	FOR99		;NO
	CLR	R0		;ZERO MASK
	MOV	R4,-(SP)	;SAVE CONTROL VARIABLE ADDRESS
	TXTADR			;GET ADDRESS OF LIST
	SRLST			;FIND THE VARIABLE
	BNE	FOR01		;FOUND IT
	MOV	R4,R0		;PUT THE VARIABLE
	PSHNAM			;AWAY
	BR	FOR02		;DATA ADDRESS IN R0
FOR01:	MOV	R3,R0
	CMP	(R0)+,(R0)+	;GET DATA ADDRESS IN R0
FOR02:	MOV	R0,-(SP)	;PUT IT AWAY
	CLR	R0		;ZERO MASK
	TXTADR
	BIS	#040000,R4	;LOOK FOR THE "FOR" ITEM
	SRLST
	BEQ	FOR03		;NONE THERE
	MOV	R4,-(SP)	;SAVE NEW HEADER
	MOV	R1,-(SP)	;SAVE TEXT POINTER
	MOV	#20,R4		;DELETE 16 BYTES FROM THE LIST
	SCRNCH
	MOV	(SP)+,R1	;RESTORE TEXT POINTER
	MOV	(SP)+,R4		;RESTORE HEADER
FOR03:	MOV	R4,R0
	PUSH			;PLACE HEADER ON THE LIST
	MOV	LINENO,R0
	PUSH			;LINE NUMBER GOES SECOND
	EVAL			;GET THE STARTING FORMULA
	MOV	@SP,R0		;DESTINATION
	MOV	R2,(R0)+	;PUT
	MOV	R3,(R0)+	; AWAY THE
	MOV	R4,(R0)+	;  VALUE
	TWOCHR			;GET TWO BYTES
	CMP	R4,#"OT		;IS IT A "TO"?
	BNE	FOR99		;NO
	EVAL			;YES
	PUTAWY			;PUT ENDING VALUE AWAY
	CMPB	@R1,#'S		;IS THIS A "STEP"?
	BNE	FOR05		;NO
	TWOCHR			;YES
	CMP	R4,#"TS		;LOOK FOR "ST"
	BNE	FOR99		;NOT FOUND
	TWOCHR
	CMP	R4,#"PE		;AND "EP"
	BNE	FOR99		;NOT FOUND
	EVAL			;EVALUATE THE STEP VALUE
FOR04:	PUTAWY			;PUT THE VALUE AWAY
	BR	FOR06
FOR05:	CLR	R2		;DEFAULT
	MOV	#040000,R3	; STEP
	MOV	#100001,R4	;  IS ONE
	BR	FOR04
FOR06:	MOV	@SP,R0		;CONTROL VARIABLE ADDRESS
	MOV	R1,-(SP)	;SAVE TEXT POINTER
	MOV	R5,R1
	SUB	#14,R1		;ADDRESS OF END VALUE
FOR14:	MOV	R1,-(SP)	;SAVE ADDRESS
	CMPF
	BEQ	FOR07		;GO DO LOOP IF VARIABLE = END VALUE
	BLT	FOR08		;END LESS THAN CONTROL
	MOV	(SP)+,R1	;GET ADDRESS OF END VALUE
	TST	10(R1)		;IS THE STEP > 0
	BLT	FOR09		;NO, LOOP IS ALL WASHED UP
	BR	FOR13
FOR07:	TST	(SP)+		;POP END VALUE ADDRESS
FOR13:	MOV	(SP)+,R1	;STEP IS OK, GO DO LOOP
	CMP	(SP)+,(SP)+	;REMOVE START VALUE AND HEADER
FOR12:	JMP	INIT02		;GO DO NEXT STATEMENT
FOR99:	FORERR
FOR08:	MOV	(SP)+,R1
	TST	10(R1)		;IS STEP < 0?
	BLT	FOR13		;YES, ALL IS OK
FOR09:	MOV	(SP)+,R1	;RESTORE TEXT POINTER
	TST	(SP)+		;POP CONTROL VARIABLE ADDRESS
	TXTADR			;STEP IS WRONG OR LOOP IS DONE
FOR10:	CMPB	(R1)+,#157	;LOOK FOR A NEXT
	BEQ	FOR11
	CMP	R1,R3		;DONE?
	BLO	FOR10		;NO
	NXTERR			;YES, NO MATCHING NEXT
FOR11:	GETVAR
	CMP	R4,@SP		;IS VARIABLE CORRECT?
	BNE	FOR10		; LOOP UNTIL FOUND OR FAILURE
	TST	(SP)+		;WE-UNS IS HERE BOSS
FOR15:	DEC	R1
	BR	FOR12		;AND IS DONE
;
; NEXT <SIMPLE VARIABLE> - TERMINATE THE "FOR" LOOP
;	REGISTERS USED - ALL.
;
NEXT00:	CLR	R0		;ZERO MASK
	GETVAR			;GET THE CONTROL VARIABLE
	MOV	R4,-(SP)	;SAVE CONTROL VARIABLE NAME
	TXTADR
	SRLST			;FIND THE VARIABLE
	BEQ	NEXT99		;NEXT WITHOUT FOR
	MOV	R3,-(SP)	;SAVE ADDRESS OF VARIABLE
	BIS	#040000,R4
	TXTADR			;FIND
	SRLST			;THE CORRESPONDING "FOR" ELEMENT
	BEQ	NEXT99		;NOT FOUND
	MOV	R1,-(SP)	;SAVE TEXT POINTER
	CMP	(R3)+,(R3)+	;ADDRESS OF END VALUE
	MOV	R3,R1
	ADD	#6,R1		;GET THE STEP
	MOV	2(SP),R0	;ADDRESS
	MOV	R3,-(SP)
	CMP	(R0)+,(R0)+	; OF CONTROL VARIABLE
	MOV	R0,-(SP)	;SAVE C.V. ADDR. TEMPORARILY
	ADDF			;ADD THE STEP TO IT
	MOV	(SP)+,R0
	MOV	@SP,R3
	MOV	R3,R1
	TST	10(R3)		;CHECK SIGN OF STEP
	BPL	NEXT02		;POSITIVE, DO NORMAL COMPARE
	CMPF			;DO THE COMPARE
	BGT	NEXT01		; BACKWARDS
	BR	NEXT03
NEXT02:	CMPF			;EQUAL?
	BLT	NEXT01		;YES, ALL DONE
NEXT03:	MOV	(SP)+,R0	;"FOR" ADDRESS
	TST	(SP)+		;DISCARD TEXT POINTER
	MOV	R0,-(SP)	;SAVE "FOR" ADDRESS
	TST	-(R0)
	MOV	@R0,R0		;GET LINE NUMBER
	FINDLN			;FIND WHERE IT BELONGS
	JUNKIT			;SKIP TO NEXT STATEMENT
	MOV	R1,R4		;TEXT POINTER TO TEMPORARY
	MOV	(SP)+,R1	;GET END VALUE ADDRESS
	MOV	@SP,R0		;CONTROL VARIABLE ADDRESS
	MOV	R4,-(SP)	;TEXT POINTER
	CMP	(R0)+,(R0)+
	BR	FOR14		;GO BACK TO CHECK THINGS OUT
NEXT99:	NXMERR			;NEXT WITHOUT FOR
NEXT01:	MOV	(SP)+,R1	;GET STEP SIZE
	ADD	#6,R1		; HERE
	MOV	2(SP),R0	;AND CONTROL VARIABLE ADDRESS
	CMP	(R0)+,(R0)+	; HERE
	SUBF			;THEN SUBTRACT STEP TO MAKE IT RIGHT AGAIN
	MOV	(SP)+,R1	;NEXT IS TEXT POINTER
	CMP	(SP)+,(SP)+	;DISCARD TWO MORE WORDS
	BR	FOR15
	.EOT			;END OF TAPE 5
