	.BYTE	0
	.EVEN
;
; RUN - START PROGRAM EXECUTION
;	REGISTERS USED - R5
;
RUN00:	CLRUSR			;CLEAR ANY REMAINING USER AREA
	CLR	LINENO		;CLEAR LINE NUMBER POINTER
	MOV	USR,R1		;PUT START OF USER AREA
	INC	R1		; PLUS ONE IN R1
	MOV	#13507,M.I	;RESET RANDOM NUMBER GENERATOR
	MOV	#1,RUNF		;TURN ON RUN FLAG
	JMP	INIT03		;GO BACK AND LOOK FOR LINE TO DO
;
; GOSB00 - GOSUB STATEMENT, PUSH CLASS 1 ITEM ON STACK THEN DO A GOTO
;	REGISTERS USED - R0,R1,R2,R3,R4
;
GOSB00:	MOV	LINENO,R0	;GET CURRENT LINE NUMBER
	BIS	#020000,R0	;SET CLASS 1 FLAG
	PUSH			;PUSH ITEM ON STACK
;
; GOTO00 - GOTO STATEMENT - RESET LINENO TO NEW EXECUTION POINT
;	REGISTERS USED - R0,R1,R2,R3,R4
;
GOTO00:	ATOI			;ASCII FROM R1 LIST TO INTEGER IN R0
	FINDLN
	BNE	GOTO01		;LINE DOESN'T EXIST
GOTO02:	MOV	#1,RUNF		;SET THE RUN FLAG JUST IN CASE HE'S
				;TRYING TO START AGAIN
	JMP	INIT13
GOTO01:	GOERR			;ILLEGAL GOTO OR GOSUB
;
; RES00 - RESTORE STATEMENT - CLEAR THE DATA POINTER
;	REGISTERS USED - NONE
;
RES00:	CLR	DATI
	BR	DIM05		;CLEAR DATA FLAG AND GO AWAY
;
; RET00 - RETURN STATEMENT - FIND LAST GOSUB ITEM IN LIST,
;	GET ITS LINE NUMBER, PLACE IN LINENO, AND DELETE THE ITEM.
;	REGISTERS USED - R0,R1,R2,R3,R4,R5
;
RET00:	CLR	-(SP)		;SET UP TEMPORARY POINTER
	MOV	#020000,R4	;LOOK FOR CLASS 1
	TXTADR			;GET ADDRESS OF LIST
	BEQ	RET03		;ERROR IF NO LIST
	MOV	#017777,R0	;SET SEARCH MASK
RET01:	SRLST			;FIND A CLASS 1 ITEM
	BEQ	RET02		;JUMP IF DONE LOOKING
	MOV	R3,@SP		;SAVE LOCATION
	TST	(R3)+		;SKIP OVER CURRENT ONE
	BR	RET01		;LOOK AGAIN UNTIL LAST IS FOUND
RET02:	MOV	(SP)+,R3	;GET LAST ADDRESS
	BEQ	RET03		;ERROR
	MOV	@R3,R0		;GET ITEM
	BIC	R4,R0		;CLEAR OUT CLASS MARK
	INC	R0
	MOV	#2,R4		;SCRUNCH TWO BYTES
	SCRNCH			;DELETE ITEM FROM USER AREA
	CMP	R0,#1		;IS THE RETURN TO LINE #1?
	BEQ	STOP02		;YES IT CAME FROM COMMAND MODE
	FINDLN
	BR	GOTO02
RET03:	RETERR
;
; DIM STATEMENT - GENERATE DIMENSIONED TABLE ENTRY
;	REGISTERS USED - R0,R1,R2,R3,R4.
;
DIM00:	GETADR			;GET A TRUNCATED VARIABLE
DIM01:	BVS	DIM99		;ERROR IF NG.
	BNE	DIM97		;PREVIOUSLY DECLARED VARIABLE FOUND
	MOV	R4,-(SP)
	SKIP			;GET NEXT CHARACTER
	CMP	R2,#'(		;IS IT A LEFT PAREN
	BNE	DIM99		;NO, ERROR
	ATOI			;YES, GET FIRST DIMENSION
	DIMCHK			;CHECK FOR DIMENSION WITHIN BOUNDS
	BNE	DIM99		;NOT IN BOUNDS
	MOV	R0,-(SP)	;PUT AWAY FIRST DIMENSION
	SWAB	@SP		;IN UPPER HALF WORD
	SKIP			;GET LAST CHARACTER SCANNED
	CMPB	R2,#',		;IS IT A COMMA?
	BNE	DIM03		;NO
	ATOI			;GET SECOND DIMENSION
	DIMCHK			;IS IT IN RANGE?
	BNE	DIM99		;NO
	BIS	R0,@SP		;YES, PACK IT IN
	SKIP			;GET A CHARACTER
DIM03:	CMP	R2,#')		;NO IS IT A RIGHT PAREN?
	BEQ	DIM04		;YES, GET NEXT CHARACTER
DIM99:	DIMERR			;BAD DIMENSION
DIM04:	MOV	(SP)+,R2	;GET PACKED DIMENSIONS
	MOV	(SP)+,R0	;GET HEADER
	MOV	R1,-(SP)	;SAVE TEXT POINTER
	PUSH			;PUSH HEADER ON LIST
	MOV	R2,R0		;
	PUSH			;PUSH PACKED DIMENSIONS ON LIST
	MOV	R2,R1
	SWAB	R1		;GET FIRST DIMENSION AGAIN
	ARYLG			;COMPUTE NUMBER OF ITEMS TO SKIP
	BVS	DIM98
	TSTOK			;OVERFLOW?
	BLO	DIM98		;YES
	ADD	R0,R5		;NO, UPDATE POITER
	MOV	(SP)+,R1	;RESTORE TEXT POINTER
	SKIP			;GET A CHARACTER
	CMP	R2,#',		;COMMA?
	BEQ	DIM00		;YES LOOK FOR NEXT ITEM
	DEC	R1		;BACK UP OVER TERMINATOR
DIM05:	JMP	INIT02		;NOW GOAWAY
DIM98:	DMVERR			;OVERFLOW
DIM97:	DMDERR			;PREVIOUSLY USED OR DECLARED
;
; DEFINE STATEMENTS ARE DONE HERE - ONE TABLE ENTRY IS MADE, CONFLICTS
;	ARE NOT CHECKED.  REGISTERS USED - R1,R2,R4.
;
DEF00:	TWOCHR			;LOOK FOR "FN"
	CMP	R4,#"NF		;IS IT AN "FN"?
	BNE	DEF99		;NO, BAD STATEMENT
	SKIP			;GET FUNCTION NAME
	TSTCH			;IS IT ALPHABETIC?
	BEQ	DEF99		;NO
	BVS	DEF99		;NO
	BIS	#060000,R2	;YES, SET CLASS TO 3
	MOV	R2,R0
	PUSH			;PUT AWAY THE HEADER
	SKIP
	CMP	R2,#'(		;IS THE REQUIRED LEFT PAREN PRESENT?
	BNE	DEF99		;NO
	GETVAR			;GET THE VARIABLE NAME
	BVS	DEF99		;ERROR IF BAD VARIABLE
	MOV	R4,R0
	PUSH			;PUT AWAY THE NAME IN WORD 2
	CMP	R2,#')		;CLOSING PAREN PRESENT?
	BNE	DEF99		;NO
	SKIP
	CMP	R2,#'=		;EQUAL SIGN?
	BNE	DEF99
	MOV	R1,R0
	PUSH			;PUT AWAY ADDRESS OF DEFINITION
	JUNKIT			;SKIP OVER REST OF DEFINITION
	BR	DIM05
DEF99:	DEFERR			;HORRIBLE ERROR!!!
;
; EVAL - EVAL00, EVALUATE AN ARITHMETIC EXPRESSION.  UPON ENTRY, R1
;	POINTS TO THE CURRENT TEXT POSITION.  ON EXIT, R2,R3, AND R4
;	CONTAIN THE NUMERIC VALUE OF THE EXPRESSION.  REGISTERS USED - ALL.
;
EVAL00:	CLR	R0
	PUSH			;CLEAR THE PAREN COUNT
	MOV	#-1,-(SP)	;PUSH NULL (-1) ON STACK
EVAL02:	TSTOK	
	BLO	EVAL18
	SKIP			;GET A NON-BLANK CHARACTER
	CMP	R2,#'+		;IS THIS A UNARY PLUS?
	BEQ	EVAL03		;YES, IGNORE IT
	CMP	R2,#'-		;IS IT A UNARY MINUS?
	BNE	EVAL01		;NO
	MOV	R2,R0		;YES, SET OPERAND2=0
	CLR	R2		;AND PUT THE
	CLR	R3		; OPERATOR IN R0
	CLR	R4
	BR	EVAL05
EVAL03:	SKIP			;GET ACHARACTER
EVAL01:	CMP	R2,#'(		;IS OPERAND AN OPEN PAREN?
	BNE	EVAL04		;NO, GET A REAL OPERAND
	CLR	-(SP)		;PUSH A NULL ON THE STACK
	INC	-2(R5)		;INCREMENT THE PAREN COUNT
	BR	EVAL02		;GO BACK AND DO IT AGAIN
EVAL05:	MOVSTK			;PUSH OPERAND ON THE STACK
	MOV	R0,-(SP)	;   OPERATOR ON STACK
	BR	EVAL03		;AND GO BACK AROUND
EVAL04:	DEC	R1		;MOVE CHARACTER POINTER BACK ONE
	MOV	-(R5),-(SP)	;SAVE PAREN COUNT
	JSR	PC,GTP00	;GET AN OPERAND
	MOV	(SP)+,(R5)+	;RESTORE THE PAREN COUNT
EVAL12:	MOV	R2,-(SP)	;SAVE R2
	SKIP			;GET A CHARACTER
	MOV	#EVAL07+7,R0	;GET ADDRESS OF LIST
GTPR01:	CMPB	-(R0),R2	;IS IT A LEGAL OPERATOR?
	BEQ	GTPR02		;JUMP IF LEGAL
	CMP	R0,#EVAL07+1	;HAS SEARCH FAILED?
	BHI	GTPR01		;NO
	CLR	R0		;YES - SET ZERO AND BACK UP POINTER
	DEC	R1		; TO POINT AT FAILURE
GTPR03:	MOV	(SP)+,R2	;RESTORE R2
	BR	EVAL19		;AND CONTINUE
GTPR02:	MOV	R2,R0		;PUT A CHARACTER IN R0
	BR	GTPR03
EVAL19:	TST	@SP		;IS STACK NULL?
	BLE	EVAL17
EVAL06:	MOV	R1,-(SP)	;SAVE THE TEXT POINTER
	MOV	#EVAL07+7,R1	;GET THE TABLE ADDRESS
EVAL08:	CMPB	-(R1),R0		;FIND OPERATOR2
	BNE	EVAL08		;IT MUST BE FOUND
	ASR	R1		;GET RID OF THE BYTE POINTER
	MOV	R1,(R5)+	;PUT RESULT ON USER LIST FOR A WHILE
	MOV	#EVAL07+7,R1	;GET TABLE ADDRESS AGAIN
EVAL09:	CMPB	-(R1),2(SP)	;FIND OPERATOR1
	BNE	EVAL09		;IT MUST BE THERE
	ASR	R1		;CLEAR LOW ORDER BIT
	MOV	R1,(R5)+	;SAVE IT FOR NOW
	MOV	(SP)+,R1	;RESTORE TEXT POINTER
	CMP	-(R5),-(R5)	;COMPARE OPERATOR1 WITH OPERATOR2
	BLT	EVAL05		;GO BACK IF PRECEDENCE IS WRONG
	MOV	R0,(R5)+	;SAVE OPERATOR2 FOR NOW
	MOV	#EVAL07+7,R0
EVAL10:	CMPB	-(R0),@SP	;FIND APPROPRIATE OPERATOR IN LIST
	BNE	EVAL10		;IT MUST BE FOUND
	SUB	#EVAL07+2,R0	;GET DISPLACEMENT
	ASL	R0
	ADD	#EVAL11,R0	;WE NOW HAVE THE ROUTINE ADDRESS
	MOV	R0,(R5)+	;SAVE IT
	TST	(SP)+		;DISCARD OLD OPERATOR1
	MOV	SP,R0		;GET DESTINATION ADDRESS
	MOVSTK			;PUT SOURCE ON THE STACK
	MOV	R1,-(SP)	;SAVE TEXT POINTER
	MOV	SP,R1		;GET
	TST	(R1)+		;SOURCE ADDRESS
	MOV	-(R5),R2	;ROUTINE ADDRESS
	MOV	-(R5),-(SP)	;SAVE OPERATOR2
	JSR	PC,@(R2)		;GO COMPUTE VALUE
	MOV	(SP)+,R0	;RESTORE OPERATOR2
	MOV	(SP)+,R1	;RESTORE TEXT POINTER
	ADD	#6,SP		;DISCARD SOURCE
	MOV	(SP)+,R2	;PLACE RESULT
	MOV	(SP)+,R3	; IN
	MOV	(SP)+,R4	;  OPERAND2
	TST	@SP		;IS STACK NULL?
	BGT	EVAL06		;NO, TAKE CARE OF REST OF STACK
EVAL17:	CMP	R0,#')		;IS OPERATOR2 A CLOSED PAREN?
	BEQ	EVAL14		;YES
	TST	R0		;NO, IS IT NULL?
	BGT	EVAL05		;NOT NULL - GO BACK
	TST	-(R5)		;IS THE PAREN COUNT ZERO?
	BNE	EVAL13		;NO
	TST	(SP)+		;POP NULL
	CCC
	RTS	PC		;RETURN WITH RESULT IN R2,R3,R4.
EVAL13:	PARERR			;PAREN COUNT BAD
EVAL14:	TST	-(R5)		;IS PAREN COUNT ZERO?
	BNE	EVAL15		;NO
EVAL16:	TST	(SP)+		;POP NULL
	SEV			;YES, ERROR - BUT DON'T TELL USER YET
	RTS	PC
EVAL15:	TST	@SP		;JUMP
	BLT	EVAL16		;IF NULL = -1
	TST	(SP)+		;POP NULL
	DEC	(R5)+		;DECREMENT PAREN COUNT
	BR	EVAL12		;AND DO IT AGAIN
EVAL18:	OVFERR
EVAL07:	.BYTE	0,')		;DO NOT
	.BYTE	'+,'-		; CHANGE
	.BYTE	'*,'/		;  THE ORDER
	.BYTE	'^		;   OF THIS TABLE
	.EVEN
EVAL11:	ADDF00			;THIS
	SUBF00			; TABLE
	MULF00			;  PARALLELS THE ONE
	DIVF00			;   ABOVE, SO DO NOT
	PWRF00			;    CHANGE ITS ORDER
;
; GETOP - GTP00, GET AN OPERAND. 
;	UPON ENTRY, R1 POINTS TO THE START OF
;	AN OPERAND.  UPON EXIT, R2,R3,AND R4 CONTAIN THE VALUE OF THE
;	OPERAND IF LEGAL.  IF NOT LEGAL, A FATAL ERROR CALL IS MADE.  ON
;	LEGAL OR ILLEGAL EXITS, R1 WILL ALWAYS POINT ONE CHARACTER AFTER
;	THE SCAN WAS ENDED.  NOTE:  THIS ROUTINE MUST BE RE-ENTRANT,
;	SINCE IT MAY, BY WAY OF CALLS TO "EVAL", RE-ENTER
;	ITSELF BEFORE COMPLETION.  REGISTERS USED - ALL.
;
GTP06:	ILFERR
GTP00:	MOV	R1,-(SP)	;SAVE TEXT BACKUP POINTER
	SKIP			;GET FIRST CHARACTER
	TSTCH
	BVS	GTP15		;JUMP IF BAD OPERAND
	BNE	GTP02		;JUMP IF NOT NUMERIC
GTP18:	MOV	(SP)+,R1	;RESTORE CHARACTER POINTER
	SUB	#6,SP		;RESERVE SOME SPACE
	MOV	SP,R0		;  FOR THE DESTINATION
	ATOF			;CONVERT THE NUMBER, IGNORING ERROR FLAGS
	BVS	GTP06
	MOV	(SP)+,R2	;GET
	MOV	(SP)+,R3	; THE
	MOV	(SP)+,R4	;  RESULT
	RTS	PC
GTP01:	MOV	(R0)+,R2	;GET
	MOV	(R0)+,R3	; THE
	MOV	(R0)+,R4	;  NUMBER
	RTS	PC		;AND RETURN
GTP15:	CMP	R2,#'.		;DOES THE NUMBER START WITH "."?
	BEQ	GTP18		;YES
	BR	GTP19		;NO
GTP02:	CMP	R2,#'F		;IS THIS A "DEF"INED FUNCTION?
	BEQ	GTP07		;YES - SINCE NO STANDARD FUNCTION BEGINS WITH "F"
	MOV	#177700,-(SP)
	BIC	@SP,R2		;MASK OFF EXTRA BITS
	MOV	R2,R0
	MULSIX			;MULTIPLY
	MULSIX			; BY 36 HERE
	SKIP			;GET SECOND CHAR HERE
	TSTCH
	BVS	GTP11		;GO TRY FOR A VARIABLE
	BEQ	GTP11		;IF NOT A FUNCTION
	BIC	@SP,R2		;MAKE 8 BITS INTO 6
	ADD	R2,R0		;ADD IT IN MODULO 36
	MULSIX			;MULTIPLY BY
	MULSIX			; 36 AGAIN
	SKIP			;GET THIRD CHARACTER
	TSTCH			;CHECK WHAT IT IS
	BVS	GTP11		;TRY FOR A
	BEQ	GTP11		;VARIABLE IF NOT A FUNCTION
	BIC	(SP)+,R2
	ADD	R2,R0		;THIS IS THE FUNCTION NAME MOD 36
	MOV	#GTP16,R3	;START OF LIST
GTP04:	CMP	(R3)+,R0	;IS THIS A GOOD FUNCTION NAME?
	BEQ	GTP05		;YES
	CMP	R3,#GTP17	;SEARCH FAILURE?
	BLO	GTP04		;NO
	BR	GTP09		;YES, GO TRY A VARIABLE
GTP05:	SKIP
	CMP	R2,#'(		;IS THIS FUNCTION LEGAL?
	BNE	GTP09		;NO, GO TRY FOR AVARIABLE
	MOV	GTP17-GTP16-2(R3),-(SP)	;SAVE ADDRESS OF FUNCTION
	EVAL
	BVC	GTP22		;THERE MUST BE A PAREN FOUND
GTP23:	MOV	(SP)+,R0	;RESTORE JUMP ADDRESS
	MOVSTK			;PUT AWAY VALUE
	MOV	R0,R2
	MOV	SP,R0		;SOURCE ADDRESS
	MOV	R1,-(SP)	;SAVE TEXT POINTER
	MOV	R0,R1
	SUB	#6,SP
	MOV	SP,R0		;DESTINATION ADDRESS
	JSR	PC,@R2		;GO DO THE FUNCTION
	MOV	(SP)+,R2	;GET
	MOV	(SP)+,R3	; THE
	MOV	(SP)+,R4	;  VALUE
	MOV	(SP)+,R1	;RESTORE TEXT POINTER
GTP24:	ADD	#10,SP		;GET RID OF ALL THE JUNK
	RTS	PC
GTP11:	TST	(SP)+		;POP MASK FROM STACK
GTP19:	BR	GTP09
GTP22:	CMP	@SP,#EXF00	;IS THIS AN EXF?
GTP26	=	.-2		;ADDRESS TO CHANGE
	BNE	GTP21		;NO
	BR	GTP23
GTP07:	SKIP			;GET SECOND CHARACTER
	CMP	R2,#'N		;LOOK FOR AN "N"
	BNE	GTP09		;GO FOR AVARIABLE IF SOMETHING ELSE
	SKIP			;GET THIRD CHARACTER
	TSTCH
	BVS	GTP09		;IF NOT ALPHABETIC THEN
	BEQ	GTP09		;  GO TRY FOR A VARIABLE
	TXTADR			;GET ADDRESS OF USER STORAGE
	BEQ	GTP12		;ERROR IF NO USER LIST
	CLR	R0		;SET ZERO MASK FOR THE SEARCH
	BIS	#060000,R2	;SET CLASS 3
	MOV	R2,R4		; WITH FUNCTION NAME TO FIND
	SRLST			;SEARCH THE LIST FOR THE ITEM
	BEQ	GTP09		;JUMP IF FAILURE, NOW TRY A VARIABLE
	TST	(R3)+
	MOV	(R3)+,R4	;GET NAME OF FORMAL PARAMETER
	MOV	(R3)+,-(SP)	;SAVE ADDRESS OF FUNCTION DEFINITION
	TXTADR			;GET BEGINNING OF LIST AGAIN
	SRLST			;SEARCH LIST FOR THE VARIABLE
	BNE	GTP08		;JUMP IF FOUND
	SKIP
	CMP	R2,#'(
	BNE	GTP11		;JUMP IF BADNESS
	MOV	R4,-(SP)	;SAVE NAME OF FORMAL PARAMETER
	EVAL			;EVALUATE ACTUAL PARAMETER
	BVS	GTP20		;CLOSED PAREN MUST BE PRESENT HERE
GTP21:	PARERR
GTP20:	MOV	(SP)+,R0
	MOV	R5,-(SP)
	PUSH			;PUT AWAY
	CLR	R0		;THE
	PUSH			;VALUE
	PUTAWY			;FOR THE FORMAL PARAMETER HERE
	MOV	R1,-(SP)	;SAVE TEXT POINTER
	MOV	4(SP),R1	;TEMPORARY POSITION
	EVAL			;EVALUATE THE FUNCTION
	BVS	GTP21		;NO EXTRA PARENS ALLOWED HERE
	MOV	(SP)+,R1	;TEXT POINTER TO R0
	MOV	(SP)+,R5	;ADDRESS OF DUMMY TO R5 - DELETE F.P.
	CMP	(SP)+,(SP)+	;POP DEF'N ADDRESS AND REMEMBER CHAR. POINTER
	RTS	PC
GTP08:	CMP	(R3)+,(R3)+	;FOUND VARIABLE - POINT TO VALUE
	MOV	(SP)+,R0	;GET ADDRESS OF PROTOTYPE CODE
	MOV	(R3)+,-(SP)	;SAVE
	MOV	(R3)+,-(SP)	;THE REAL
	MOV	(R3)+,-(SP)	; VALUE
	MOV	R3,-(SP)	;AND THE ADDRESS
	MOV	R0,-(SP)	;AND THE PROTOTYPE POINTER
	SKIP
	CMP	R2,#'(		;IS IT LEGAL?
	BNE	GTP13		;NO
	EVAL			;GET VALUE OF REAL PARAMETER
	BVC	GTP21		;CLOSED PAREN MUST BE PRESENT
	MOV	R1,R0		;SAVE TEXT POINTER
	MOV	2(SP),R1	;GET ADDRESS OF VARIABLE
	MOV	R4,-(R1)	;PUT AWAY
	MOV	R3,-(R1)	; PARAMETER
	MOV	R2,-(R1)	;  THERE
	MOV	(SP)+,R1	;GET PROTOTYPE TEXT
	MOV	R0,-(SP)	;SAVE TEXT POINTER ON STACK
	EVAL			;EVALUATE FUNCTION
	BVS	GTP21		;NO EXTRA PARENS ALLOWED HERE
	MOV	(SP)+,R1	;RESTORE TEXT POINTER
	MOV	(SP)+,R0	;GET VARIABLE ADDRESS
	MOV	(SP)+,-(R0)	;PUT
	MOV	(SP)+,-(R0)	; REAL
	MOV	(SP)+,-(R0)	;  VARIABLE BACK WHERE IT BELONGS
	TST	(SP)+		;DISCARD OLD TEXT POINTER
	RTS	PC		;AND RETURN
GTP09:	MOV	(SP)+,R1	;VARIABLE, BACK UP POINTER TO TRY AGAIN
	GETADR			;GET ADDRESS OF VARIABLE
	BVS	GTP12		;NON-EXISTENT
	BEQ	GTP12		; VARIABLE HERE
	JMP	GTP01		;GO AWAY AGAIN
GTP12:	NXVERR			;NON-EXISTENT VARIABLE ERROR - ZERO ASSUMED
	CLR	R2		;SET
	CLR	R3		;VARIABLE
	CLR	R4		;TO ZERO
	RTS	PC
GTP13:	ADD	#12,SP		;GET RID OF ANY JUNK ON THE STACK
	BR	GTP09
;
GTP16:	.WORD	60602	;SIN
BAS99	=	GTP16
BAS98:	.WORD	10537	;COS
BAS97:	.WORD	03756	;ATN
BAS94:	.WORD	16300	;EXP
BAS93:	.WORD	37343	;LOG
	.WORD	02553	;ABS
BAS96:	.WORD	61246	;SQR
	.WORD	27634	;INT
	.WORD	56434	;RND
	.WORD	60472	;SGN
BAS91:	.WORD	16266	;EXF
GTP17:	SINE00
	COS00
	ATN00
	EXPF00
	LOG00
	ABS00
	SQRT00
	INT00
	RND00
	SGN00
GTP25:	EXF00
;
; GETADR - GTDR00, GET ADDRESS OF VARIABLE/ARRAY ELEMENT - DATA
;	ADDRESS RETURNED IN R0.  REGISTERS USED - R0,R1,R2,R3,R4.
;
GTDR00:	GETVAR			;GET A VARIABLE NAME
	BVS	GTDR03		;EXIT IF IN ERROR
	DEC	R1		;BACK UP CHARACTER POINTER
	CLR	R0		;SET ZERO SEARCH MASK
	TXTADR			;GET ADDRESS OF USER STORAGE
	BEQ	GTDR02		;JUMP IF NOT FOUND
	SRLST			;FIND THE ITEM
	BEQ	GTDR02		;JUMP IF NOT THERE
	CMP	@SP,#DIM01	;SKIP THE REST IF
	BEQ	GTDR04		;   CALLED FROM DIM
	TST	(R3)+		;POINT TO SUBSCRIPTS
	CMPB	@R1,#'(		;IS THERE A SUBSCRIPT EXPRESSION?
	BNE	GTDR01		;NO
	INC	R1		;SKIP OVER OPEN PAREN
	MOV	R4,-(SP)	;SAVE SEARCH OBJECT
	SUBSCR			;COMPUTE THE SUBSCRIPT
	MOV	(SP)+,R4
GTDR02:	TST	R0		;SET FLAGS
GTDR03:	RTS	PC		;RETURN WHEN DONE
GTDR01:	TST	(R3)+		;POINT TO DATA ADDRESS
GTDR04:	MOV	R3,R0		;PUT RESULT IN R0
	RTS	PC		;AND RETURN
;
; LET00 - LET STATEMENT, EVALUATE EXPRESSION AND ASSIGN A VALUE TO A
;	VARIABLE.  REGISTERS USED - ALL.
;
LET00:	GETADR			;GET VARIABLE ADDRESS
	BVS	LET99		;JUMP IF BAD VARIABLE
	BNE	LET01
	MOV	R4,R0		;GET NAME
	PSHNAM			;PUSH VARIABLE ON THE LIST
LET01:	MOV	R0,-(SP)	;SAVE DATA ADDRESS
	SKIP
	CMP	R2,#'=		;IS THE "LET" OK?
	BNE	LET99		;NO
	EVAL			;YES, EVALUATE EXPRESSION
	BVS	LET98		;ERROR IF MISMATCHED PARENS
	MOV	(SP)+,R0	;GET DATA ADDRESS
	MOV	R2,(R0)+	;PUT
	MOV	R3,(R0)+	; RESULT
	MOV	R4,(R0)+	;  AWAY
	JMP	INIT02		;GO BACK FOR NEXT LINE
LET99:	LETERR			;ILLEGAL LET STATEMENT
LET98:	PARERR			;MISMATCHED PARENS
;
; IF <EXPRESSION><REL-OP><EXPRESSION> THEN <STMT>.  COMPARE TWO
;	EXPRESSIONS AND ACT ACCORDINGLY.  REGISTERS USED - ALL.
;
IF00:	EVAL			;EVALUATE THE FIRST PART OF THE STATEMENT
	BVS	LET98		;ILLEGAL PAREN
	MOVSTK			;PUT RESULT ON THE STACK
	TWOCHR			;GET THE REL-OP HERE
	CMP	R2,#'>		;IS IT LEGAL?
	BEQ	IF01		;YES
	CMP	R2,#'=
	BEQ	IF01		;YES
	DEC	R1		;NO, BACK UP TEXT POINTER
	CLRB	R4		;CLEAR ILLEGAL CHARACTER
IF01:	MOV	#IF03,R2	;GET LIST OF LEGAL FORMS
IF02:	CMP	R4,(R2)+	;IS IT LEGAL?
	BEQ	IF05		;YES
	CMP	R2,#IF04	;DID SEARCH FAIL?
	BLO	IF02		;NO
	OPRERR			;YES - FATAL ERROR
IF05:	ADD	#-IF03-2,R2	;GET ADDRESS
	ASL	R2		;OF THE
	ADD	#IF04,R2	;REQUIRED TEST
	MOV	R2,-(SP)	;AND SAVE IT
	EVAL			;GET NEXT PART OF EXPRESSION
	BVS	LET98		;ILLEGAL PAREN
	MOV	R1,-(SP)	;SAVE TEXT POINTER
	MOV	SP,R1		;GET
	CMP	(R1)+,(R1)+	; ADDRESS OF SOURCE
	MOVSTK			;PUT DESTINATION ON STACK
	MOV	SP,R0		;DESTINATION ADDRESS
	CMPF			;COMPARE FLOATING
	JMP	@10(SP)		;DO RESULTING TEST
IF03:	.WORD	"><		; .NE.
	.WORD	"=<		; .LE.
	.BYTE	0,'<		; .LT.
	.WORD	"=>		; .GE.
	.BYTE	0,'>		; .GT.
	.BYTE	0,'=		; .EQ.
IF04:	BNE	IF07		;  .NE.
	BR	IF06
	BLE	IF07		;  .LE.
	BR	IF06
	BLT	IF07		;  .LT.
	BR	IF06
	BGE	IF07		;  .GE.
	BR	IF06
	BGT	IF07		;  .GT.
	BR	IF06
	BEQ	IF07		;  .EQ.
IF06:	ADD	#6,SP		;POP DESTINATION
	MOV	(SP)+,R1	;RESTORE TEXT POINTER
	ADD	#10,SP		;POP SOURCE
REM00:	SRCHLF			;SKIP OVER REST OF LINE
	DEC	R1		;AND BACK UP THE POINTER
	JMP	INIT02		;AND GO AWAY (HANDLE REMARK HERE TOO)
IF07:	ADD	#6,SP		;POP DESTINATION
	MOV	(SP)+,R1	;RESTORE TEXT POINTER
	ADD	#10,SP		;POP SOURCE
	TWOCHR			;GET TWO CHARACTERS
	CMP	R4,#"HT		;IS THIS A "THEN"?
	BNE	IF09		;NO
	TWOCHR
	CMP	R4,#"NE		;MAKE SURE SPELLING IS OK
	BNE	IF99		;BAD IF STATEMENT
	SKIP			;SKIP OVER BLANKS
	DEC	R1		;POINT AT CHARACTER
	TSTCH			;CHECK NUMERIC
	BVS	IF08		;MUST BE A CODE .GT. 140
	BNE	IF99		;ERROR IF ALPHABETIC
IF10:	JMP	GOTO00		;MAKE IT A GO TO
IF08:	JMP	INIT10		;GO BACK TO FIGURE OUT THE REST
IF09:	CMP	R4,#"OG		;IS THIS A "GO"?
	BNE	IF99		;NO, ERROR
	TWOCHR
	CMP	R4,#"OT		;ERROR
	BEQ	IF10		; IF NOT A "GOTO"
IF99:	IFERR			;ILLEGAL IF

	.EOT			;END OF TAPE 4
