*         title    RUNTIME3.TXT
*         page
*
*
RFOR:	EQU    *
	LDD    FORSTACK     ; GET FOR STACK POINTER.
	SUBD   #10          ; ALLOCATE NEW FOR-NEXT DESCRIPTOR BLOCK.
	CPD    EFORSTK      ; HAVE WE RUN OUT OF FOR-NEXT STACK SPACE?
	BHS    RFOR1        ; NO. CONTINUE.
	LDAA   #FORNXERR    ; YES. ERROR.
	JMP    RPTRERR      ; REPORT ERROR.
RFOR1:	STD    FORSTACK     ; SAVE NEW STACK POINTER.
	PSHY                ; SAVE IP ON STACK.
	JSR    RVARPTR      ; GET POINTER TO ASIGNMENT VARIABLE.
	PULY                ; RESTORE IP.
	LDX    FORSTACK     ; GET FOR STACK POINTER.
	STD    0,X          ; PUT POINTER TO CONTROL VARIABLE IN STACK.
	LDD    CURLINE      ; GET CURRENT LINE NUMBER.
	STD    8,X          ; SAVE CURRENT LINE NUMBER IN STACK.
	JSR    RLET         ; GO DO ASIGNMENT PART OF FOR.
	JSR    RSKIPSPC     ; SKIP SPACES.
	INY                 ; SKIP PAST "TO" TOKEN.
	JSR    RSKIPSPC     ; SKIP SPACES.
	JSR    DONEXP       ; CALCULATE THE TERMINATING LOOP VALUE.
	JSR    PULNUM       ; GET NUMBER OFF OF THE STACK.
	LDX    FORSTACK     ; GET STACK POINTER.
	STD    4,X          ; PUT VALUE IN STACK BLOCK.
	LDD    #1           ; ASSUME A "STEP" VALUE OF 1.
RFOR3:	STD    2,X          ; PUT IT IN THE STACK.
	JSR    RSKIPSPC     ; SKIP SPACES.
	LDAA   0,Y          ; GET NEXT TOKEN.
	CMPA   #STEPTOK     ; IS THE STEP CLAUSE PRESENT?
	BEQ    RFOR2        ; YES. GO GET THE "STEP" VALUE.
	STY    6,X          ; PUT TERMINATING CHARACTER OF "FOR" STATEMENT ON.
	RTS                 ; EXECUTE NEXT STATEMENT.
RFOR2:	INY                 ; SKIP PAST THE "STEP" TOKEN.
	JSR    RSKIPSPC     ; SKIP SPACES.
	JSR    DONEXP       ; GO CALCULATE THE "STEP" VALUE.
	JSR    PULNUM       ; GET VALUE OFF OPERAND STACK.
	LDX    FORSTACK     ; GET POINTER TO FOR STACK.
	BRA    RFOR3        ; GO PUT VALUE IN STACK.
*
*
RNEXT:	EQU    *
	JSR    RVARPTR      ; GET POINTER TO LOOP INDEX VARIABLE.
	LDX    FORSTACK     ; GET "FOR" STACK POINTER.
	CPD    0,X          ; IS THE LOOP VARIABLE THE SAME?
	BEQ    RNEXT1       ; YES. CONTINUE.
	LDAA   #MFRNXERR    ; NO. ERROR.
	JMP    RPTRERR      ; GO REPORT IT.
RNEXT1:	PSHY                ; SAVE IP.
	LDY    0,X          ; GET POINTER TO CONTROL VARIABLE.
	LDD    0,Y          ; GET CONTROL VARIABLE VALUE.
	ADDD   2,X          ; ADD THE STEP VALUE TO IT.
	STD    0,Y          ; SAVE THE RESULT.
	TST    2,X          ; IS THE STEP VALUE NEGATIVE?
	BMI    RNEXT2       ; YES. GO DO TEST.
	CPD    4,X          ; NO. ARE WE DONE?
	BLE    RNEXT3       ; NO. GO DO THE LOOP AGAIN.
RNEXT4:	PULY                ; RESTORE THE CURRENT IP.
	XGDX                ; PUT "FOR - NEXT" STACK POINTER IN D.
	ADDD   #10          ; REMOVE DESCRIPTOR FROM STACK.
	STD    FORSTACK     ; SAVE NEW STACK VALUE.
	JSR    RSKIPSPC     ; SKIP SPACES AFTER CONTROL VARIABLE.
	RTS                 ; DO THE STATEMENT AFTER THE NEXT.
RNEXT2:	CPD    4,X          ; ARE WE DONE?
	BLT    RNEXT4       ; YES. CONTINUE.
RNEXT3:	PULY                ; CLEAN Y OFF OF STACK.
	LDY    6,X          ; GET NEW IP.
	LDD    8,X          ; GET LINE NUMBER OF FOR STATEMENT.
	STD    CURLINE      ; MAKE IT THE CURRENT LINE.
	RTS         
*
*
*
*
RINPUT:	EQU    *
	BSR    CHCKDEV      ; CHECK FOR ALTERNATE INPUT DEVICE.
	LDAA   0,Y          ; GET A TOKEN.
	CMPA   #SCONTOK     ; IS THERE A PROMPT TO PRINT?
	BNE    RINPUT1      ; NO JUST GO GET THE DATA.
	PSHY                ; YES. SAVE POINTER.
	LDAB   #2           ; COMPENSATE FOR CONSTANT & LENGTH BYTE.
	ADDB   1,Y          ; ADD IN LENGTH BYTE.
	ABY                 ; POINT BEYOND PROMPT.
	PULX                ; GET POINTER INTO X.
	INX                 ; POINT TO LENGTH BYTE.
	LDAB   0,X          ; GET IT.
	SUBB   #2           ; SUBTRACT OUT THE DELIMETER COUNT.
	INX                 ; POINT TO STRING.
	INX
	JSR    OUTSTR       ; GO PRINT THE STRING.
	INY                 ; BYPASS COMMA.
	JSR    RSKIPSPC     ; SKIP SPACES AFTER COMMA.
	BRA    RINPUT6
RINPUT1:	JSR    NL
RINPUT6:	EQU    *
	LDX    #QSP         ; POINT TO PROMPT.
	JSR    PL           ; PRINT IT.
	JSR    GETLINE      ; GET THE DATA IN THE INPUT BUFFER.
	BSR    RINRDC
	BCS    RINPUT1
	JSR    NL
	CLR    DEVNUM       ; SET DEVICE NUMBER BACK TO 0.
	RTS
*
*
QSP:	FCC    "? "
	FCB    0
*
*
CHCKDEV:	LDAA   0,Y          ; GET A TOKEN.
	CMPA   #PNUMTOK     ; IS AN ALTERNATE DEVICE SPECIFYED?
	BEQ    CHCKDEV1     ; YES. CONTINUE.
	RTS                 ; NO. RETURN.
CHCKDEV1:	INY                 ; YES. PASS THE '#' TOKEN.
	JSR    RSKIPSPC     ; SKIP SPACES.
	JSR    DONEXP       ; GO EVALUATE THE NUMERIC EXPRESSION.
	JSR    PULNUM       ; GET THE NUMBER OFF THE STACK.
	BPL    CHCKDEV2     ; NEGATIVE NUMBERS NOT ALLOWED.
CHCKDEV3:	LDAA   #ILLIOERR    ; REPORT THE ERROR.
	JMP    RPTRERR
CHCKDEV2:	CPD    #$0007       ; IS IT LARGER THAN 7?
	BHI    CHCKDEV3
	STAB   DEVNUM       ; MAKE IT THE NEW DEVICE NUMBER.
	JSR    RSKIPSPC     ; SKIP SPACES.
	CMPA   #EOLTOK      ; IF THIS IS A PRINT STATEMENT, IS IT EOL?
	BEQ    CHCKDEV4     ; YES. DON'T BUMP THE IP.
	INY                 ; BYPASS THE COMMA.
	JSR    RSKIPSPC     ; SKIP SPACES.
CHCKDEV4:	RTS                 ; RETURN.
*
*
*
RINRDC:	JSR    SKIPSPCS
	CMPA   #EOL
	BNE    RINRDC1
	SEC
	RTS
RINRDC1:	BSR    INNUMD
	JSR    RSKIPSPC
	LDAA   0,Y
	CMPA   #EOLTOK
	BEQ    RINRDC2
	CMPA   #MEOLTOK
	BEQ    RINRDC2
	INY                 ; BUMP PAST THE COMMA.
	JSR    RSKIPSPC
	BRA    RINRDC 
RINRDC2:	CLC
	RTS
*
*
INNUMD:	EQU    *
	CMPA   #'$'
	BNE    INNUM2
	JSR    INCIBP
	JSR    GETHEX
	BRA    INNUM3
INNUM2:	JSR    INDECI
INNUM3:	EQU    *
*        PSHD
	PSHB
	PSHA
	JSR    SKIPSPCS
	CMPA   #COMMA
	BEQ    INNUM4
	CMPA   #EOL
	BEQ    INNUM7
	LDAA   #MCOMAERR
	JMP    RPTRERR
INNUM4:	JSR    INCIBP
INNUM7:	JSR    RVARPTR
	XGDX
	PULA
	PULB
	STD    0,X
	RTS
*
OUTSTR   EQU    *
	TSTB
	BEQ    OUTSTR2
OUTSTR1  LDAA   0,X
	INX
	JSR    OUTBYTE
	DECB
	BNE    OUTSTR1
OUTSTR2  RTS
*
*
INDECI:	EQU    *
	JSR    GETCHR       ; GET A CHARACTER.
	CMPA   #'-'	; IS IT A NEGATIVE NUMBER?
	BNE    INDECI1      ; NO. GO GET POSITIVE NUMBER.
	JSR    INCIBP       ; YES. BUMP INPUT BUFFER PAST IT.
	JSR    GETDECI      ; GET THE NUMBER.
	COMA		; NEGATE IT.
	COMB
	ADDD   #1
	RTS		; RETURN.
INDECI1:	JSR    GETDECI
	RTS
*
*
RREAD:	EQU    *
	LDX    DATAPTR      ; GET POINTER TO DATA. IS IT POINTING TO DATA?
	BNE    RREAD1       ; YES. CONTINUE TO READ DATA.
	BSR    RRESTOR      ; NO. GO GET POINTER TO FIRST DATA STATEMENT.
	LDX    DATAPTR      ; GET POINTER TO DATA.
RREAD1:	STX    IBUFPTR      ; PUT IT IN THE INPUT BUFFER POINTER.
	JSR    RINRDC       ; GO USE INPUT/READ COMMON CODE.
	BCS    RREAD2       ; IF CARRY SET, MORE DATA TO READ.
	LDX    IBUFPTR      ; GET POINTER TO DATA LINE.
	STX    DATAPTR      ; SAVE DATA POINTER FOR NEXT READ.
	RTS                 ; RETURN.
RREAD2:	PSHY                ; SAVE Y.
	LDY    IBUFPTR      
	INY
	INY
	BSR    RESTOR4      ; GO FIND NEXT "DATA" STATEMENT.
	PULY                ; RESTORE Y.
	BRA    RREAD        ; KEEP READING DATA.
*
*
RRESTOR:	EQU    *
	PSHY                ; SAVE Y.
	LDY    BASBEG       ; START SEARCH FOR "DATA" STATEMENTS AT THE BEGIN.
RESTOR2:	PSHY                ; SAVE POINTER TO THIS LINE.
	LDAB   2,Y          ; GET LINE LENGTH.
	ABY                 ; GET START OF NEXT LINE.
	STY    DATAPTR      ; SAVE IN "DATAPTR".
	PULY                ; RESTORE POINTER.
	LDAB   #3
	ABY                 ; POINT TO FIRST TOKEN IN LINE.
	JSR    RSKIPSPC     ; SKIP SPACES.
	LDAA   0,Y          ; GET THE KEYWORD.
	CMPA   #DATATOK     ; IS IT A DATA LINE?
	BEQ    RESTOR1      ; YES. GO SET UP POINTER.
	LDY    DATAPTR      ; GET ADDRESS OF NEXT LINE.
RESTOR3:	CPY    BASEND       ; ARE WE AT THE END OF THE PROGRAM?
	BNE    RESTOR2      ; NO. KEEP LOOKING.
	LDAA   #ODRDERR     ; OUT OF DATA ERROR.
	JMP    RPTRERR      ; REPORT THE ERROR.
RESTOR1:	INY                 ; POINT PAST DATA TOKEN & THE DATA LENGTH.
	INY
	STY    DATAPTR      ; SAVE POINTER TO DATA.
	PULY                ; RESTORE Y.
	RTS                 ; RETURN.
*
*
RESTOR4:	PSHY                ; CALL TO COMPENSATE FOR PULL OF Y ON RETURN.
	BRA    RESTOR3
*
*
RIF:	EQU    *
	JSR    DONEXP       ; GO DO A NUMERIC EXPRESSION.
	JSR    RSKIPSPC     ; SKIP SPACES.