;*********
;        *
; BASIC2 *
;        *
;*********
;
;
;	STOP00 - STOP AND END STATEMENTS
;	REGISTERS USED - R0,R1,R2,R3,R4
;
;	RUN00 - START PROGRAM EXECUTION
;	REGISTERS USED - R5
;
;	GOSB00 - GOSUB STATEMENT
; GOSB00 - GOSUB STATEMENT, PUSH CLASS 1 ITEM ON STACK THEN DO A GOTO
;	REGISTERS USED - R0,R1,R2,R3,R4
;
;	GOTO00 - GOTO STATEMENT
;
; GOTO00 - GOTO STATEMENT - RESET LINENO TO NEW EXECUTION POINT
;	REGISTERS USED - R0,R1,R2,R3,R4
;
;	RES00 - RESTORE STATEMENT
; RES00 - RESTORE STATEMENT - CLEAR THE DATA POINTER
;	REGISTERS USED - NONE
;
;	RET00 - RETURN STATEMENT
; 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
;
;
; STFIND: STATEMENT FIND ROUTINE TO POSITION OURSELVES TO PROPER STATEMENT
; IN A LINE (USED FOR RETURN AND NEXT STATEMENTS)
; ON ENTRY:
;	R0 HAS LINE NUMBER
;	R5 HAS LINE HEADER
;	R1 POSITIONED TO START OF LINE
;	R2 HAS COUNT OF STATEMENTS TO SKIP
;
; ON EXIT:
;	R0 -> LINENO
;	R5 -> LINEHD
;	R1 AT START OF R2+1 STATEMENT
;	R2 UNDEFINED
;
;
;	DIM00 - DIM STATEMENT
; DIM STATEMENT - GENERATE DIMENSIONED TABLE ENTRY
;	REGISTERS USED - R0,R1,R2,R3,R4.
;
; SUBROUTINE STRGLN FOR USE WITH DIM STATEMENT
; ON ENTRY:
;	R1 POINTS JUST PAST '$'
; ON EXIT:
;	R1 POINTS JUST PAST LEN INFO [IF THERE]
;	R0 HAS LEN (+ FOR FIXED, - FOR VAR)
;	'V' SET IF SYNTAX ERROR
; OTHER REGISTERS USED: R2

;
; SUBROUTINE SUBSUB TO RETURN SUBSCRIPT VALUES FOR DIM
; ON ENTRY:
;	R1 POINTS TO START OF INFO [OPEN PAREN]
; ON EXIT:
;	R1 POINTS PAST END OF SUBSCRIPT INFO [PAST CLOSE PAREN]
;	R3 HAS FIRST SUBSCRIPT VALUE
;	R4 HAS 2ND SUBSCRIPT VALUE (0 IF NONE SPEC'D)
;	'V' SET IF SYNTAX ERROR
; OTHER REGISTERS USED: R2,R0
;
;
; SUBROUTINE SUBONE
; TO GET SUBSCRIPTS VIA SUBSUB AND CHECK
; THEM FOR IMMEDIATE (NON-VIRTUAL) USE.
; ON ENTRY:
;	R1 = TEXT PTR
; ON EXIT:
;	R1 POINTS PAST CLOSE PAREN
;	R3 HAS 1ST SUBSCRIPT
;	R4 HAS 2ND SUBSCRIPT
;	R0 HAS PACKED SUBSCRIPTS
;	'V' SET IF ERROR
; OTHER REGISTERS USED: R2
;
;	DEF00 - DEFINE FUNCTION STATEMENT
; DEFINE STATEMENTS ARE DONE HERE - ONE TABLE ENTRY IS MADE, CONFLICTS
;	ARE NOT CHECKED.  REGISTERS USED - R1,R2,R4.
;
;	EVAL00 - EVALUATE AN ARITHMETIC EXPRESSION
;
; EVAL - EVAL00, EVALUATE AN ARITHMETIC EXPRESSION.  UPON ENTRY, R1
;	POINTS TO THE CURRENT TEXT POSITION.  ON EXIT AC0 CONTAINS
;	THE NUMERIC VALUE OF THE EXPRESSION.  REGISTERS USED - ALL.
;	V-BIT WILL BE SET IF EXPRESSION TERMINATED BY ')', CLEAR OTHERWISE.
;	ON V SET, R1 POINTS PAST CLOSE PAREN
;	ON V CLEAR, R1 POINTS TO TERMINATING CHAR
;
;	GTP00 - GET AN OPERAND
;
; GETOP - GTP00, GET AN OPERAND. 
; ON ENTRY:
;	R1 POINTS TO START OF OPERAND
;
; ON EXIT:
;	R1 POINTS TO NEXT CHAR AFTER SCAN ENDED
;	AC0 HAS VALUE OF OPERAND
;
; OTHER REGISTERS USED: POTENTIALLY ALL
;
; NOTE: THIS ROUTINE MUST BE RE-ENTRANT SINCE IT MAY RE-ENTER ITSELF
;	VIA CALLS TO "EVAL".

;	LEN00 - LENGTH OF STRING FUNCTION
;	FNSET - PARAM SETUP FOR USER FCN
;
; FNSET - SET UP PARAMS FOR FUNCTION CALL
; RETURN ADDRESS IS PULLED FROM STACK AND STACK IS USED
; TO STORE INFO ON ALREADY DEFINED DUMMY PARAMS. ENTRIES
; FOR DUMMY PARAMS ARE PUT INTO USER AREA AND NAMES FOR
; PREVIOUSLY DEFINED DUMMY PARAMS ARE ZEROED.
; ON CALL:
;	R3 POINTS TO FCN ENTRY
;	R1 POINTS TO FIRST ACTUAL ARG IN LIST
; ON EXIT:
;	R1 POINTS PAST CLOSING ')'
;	R0 POINTS PAST = SIGN FOR FCN DEF
;
;
; FNCLR:	SUBROUTINE TO RESET DATA ITEMS AFTER
; FUNCTION EVALUATION.
; REGISTERS USED: R2,R0
;
;	EVLS00 - EVALUATE A STRING EXPRESSION
;
; EVALS, EVLS00 - EVALUATE A STRING EXPRESSION OF THE FORM:
;	STRE1 + [STRE2 + ...]
;	WHERE:
;		STRE1 AND STRE2 ARE STRING ELEMENTS
;	A STRING ELEMENT MAY BE:
;		A STRING CONSTANT (IN DOUBLE QUOTES)
;		A STRING VARIABLE (ENDING IN '$')
;		A STRING FUNCTION (SYSTEM OR USER DEFINED)
; ON ENTRY:
;	R1 POINTS TO START OF PROGRAM TEXT WITH STRING EXPRESSION
;
; ON EXIT:
;	R1 POINTS TO FIRST CHAR PAST END OF EXPRESSION
;	R3 HAS ADDRESS (IN FREE SPACE)
;	R4 HAS LEN
;	'V' SET FOR BAD STRING EXPRESSION AND R1 AS ON ENTRY
;
;	GSTR00 - GET A STRING OPERAND
;
; GSTR, GSTR00 - GET A STRING OPERAND
;
;	AT END OF SUCCESSFUL COMPLETION OF THIS ROUTINE,
;	R3 CONTAINS AN INDIVIDUAL STRING ADDRESS AND R4
;	CONTAINS ITS LENGTH
;
;

;	GETHDR - GET ADDRESS OF DATA ELEMENT HEADER
;
; ON ENTRY:
;	R1 IS TEXT PTR WHICH SHOULD POINT TO VAR NAME START
;
; ON EXIT:
;	R1 POINTS TO CHAR FOLLOWING VAR NAME
;	R3 HAS HEADER ADDRESS
;	R0 HAS RETURN CODE (FOR USE AS JUMP INDEX)
;		0 = SINGLE PRECISION FLOATING
;		2 = INTEGER
;		4 = BYTE
;		6 = DOUBLE PRECISION
;		10= STRING VARIABLE
;	R4 HAS HEADER TYPE AND VAR NAME
;	'Z' SET IF VAR NOT DEFINED, CLEAR OTHERWISE
;		IN THIS CASE R3 IS NOT DEFINED
;	'V' SET IF NO VAR IN TEXT (SYNTAX ERROR)
;		IN THIS CASE R4, R3 AND R0 ARE NOT DEFINED
;
; NOTE: ON RETURN, 'V'-BIT SHOULD BE TESTED FIRST AND THEN 'Z' BIT
;
;
;	GTOFFS - GET OFFSET OF ACTUAL DATA
;
; ON ENTRY:
;	R3 POINTS TO DATA ITEM HEADER
;	R1 POINTS TO TEXT FOLLOWING VAR NAME (OPEN PAREN IF THERE)
;
; ON EXIT:
;	R3 AS ABOVE
;	R1 POINTS PAST CLOSE PAREN (IF SUBSCRIPT USED)
;	AC0 HAS:
;		1) FOR STANDARD VAR, OFFSET FROM STUDAT
;			(R0 HAS ABSOLUTE ADDRESS IN THIS CASE)
;		2) FOR VIRTUAL ARRAY, OFFSET FROM FILE START (IN BYTES)
;
; OTHER REGISTERS USED: R2, R0, R4, AC1, AC2
;
;
; SUBROUTINE VIRACC
; TO GET NEEDED DISK BLOCK IN MEMORY GIVEN AN
; OFFSET INTO THE FILE. THIS ROUTINE ALSO TAKES
; CARE OF WRITING OUT AN EXITSING BLOCK IF NECESSARY.
; ON ENTRY:
;	R3 IS PTR TO VIRTUAL DATA HEADER
;	AC0 HAS OFFSET (IN BYTES) FROM FILE START
;	R5 HAS WRITE FLAG (1 TO INDICATE WRITE TO BE PERFORMED
;		AFTER ACCESS)
;
; ON EXIT:
;	R3 AS ABOVE
;	AC0 AS ABOVE
;	R0 HAS ADDRESS OF BLOCK BUFFER
;	R2 HAS OFFSET INTO BLOCK (IN BYTES)
;
; OTHER REGISTERS USED: AC1, AC2
;
;

; SUBROUTINE WRITBK
; TO WRITE OUT BLOCK BUFFER ON BLOCK ACCESS FILE IF NEEDED
; AND SET UP FDB FOR BLOCK OPERATIONS
;
; ON ENTRY:
;	R3 POINTS TO BASIC FILE CONTROL BLOCK HEADER
; ON EXIT:
;	R0 POINTS TO FDB PROPER
;	F.BKDS AND F.BKDS+2 SET UP
;	F.BKVB(R0) SET UP WITH BLOCK NUMBER OF WRITTEN BLOCK IF WRITE DONE
;	14(R3) ZEROED (NO UNRECORDED WRITES TO THIS BLOCK)
;	F.ERR(R0) SET WITH IO STATUS CODE IF WRITE DONE
;	'C' SET IF ERROR IN WRITE, CLEAR OTHERWISE
; OTHER REGISTERS USED:R2
;
;	GETNUM - TO RETURN NUMBER -> AC0, GIVEN INFO FROM GTOFFS
;
; ON ENTRY:
;	R3 IS PTR TO DATA ITEM HEADER
;	AC0 HAS OFFSET
;		1) FOR STANDARD VAR, OFFSET FROM STUDAT
;		2) FOR VIRTUAL ARRAY, OFFSET FROM FILE START
; ON EXIT:
;	R3 AS ABOVE
;	AC0 HAS NUMERIC VALUE
; OTHER REGISTERS USED: R0, R2
;
;
;	NUMSUB: COMMON CODE FOR READ AND WRITE OF NUMERIC DATA
;
; ON ENTRY:
;	R3 IS PTR TO DATA ITEM HEADER
;	AC0 HAS OFFSET
;		1) FOR STANDARD VAR, OFFSET FROM STUDAT
;		2) FOR VIRTUAL ARRAY, OFFSET FROM FILE START
;	R5 HAS READ/WRITE FLAG (0=READ, 1=WRITE)
; ON EXIT:
;	R3,AC0,R5 AS ABOVE
;	R2 HAS ADDRESS OF DATA
;	R0 HAS TYPE INDICATOR
;		0 = FLOATING (REAL*4)
;		2 = INTEGER*2
;		4 = BYTE (LOGICAL*1)
;		6 = DOUBLE (REAL*8)
;
;
;	STONUM - STORE A NUMBER FROM AC0 INTO VARIABLE
;
; ON ENTRY:
;	R3 POINTS TO DATA ITEM HEADER
;	AC0 HAS VALUE
;	AC1 HAS OFFSET
;		1) FOR STANDARD VAR, OFFSET FROM STUDAT
;		2) FOR VIRTUAL ARRAY, OFFSET FROM FILE START
; ON EXIT:
;	R3 AS ABOVE
;	AC0 AS ABOVE
;	AC1 AS ABOVE
; OTHER REGISTERS USED: R0, R2

;
;	GETSTR - TO RETURN STRING ELEMENT DESCRIPTOR IN R3,R4
;
; ON ENTRY:
;	R0 IS PTR TO DATA ITEM HEADER
;	AC0 HAS OFFSET
;		1) FOR STANDARD VAR, OFFSET FROM STUDAT
;		2) FOR VIRTUAL ARRAY, OFFSET FROM FILE START
;
; ON EXIT:
;	R0, AC0 AS ABOVE
;	R3 HAS STRING ADDRESS
;	R4 HAS STRING LENGTH
;	'V' SET IF ERROR, CLEAR OTHERWISE
;
; OTHER REGISTERS USED:
;
;
;
;	STRADD: COMMON CODE FOR STRING READ AND WRITE
;
; ON ENTRY:
;	R0 IS PTR TO DATA ITEM HEADER
;	AC0 HAS OFFSET
;		1) FOR STANDARD VAR, OFFSET FROM STUDAT
;		2) FOR VIRTUAL ARRAY, OFFSET FROM FILE START
;	R5 HAS READ/WRITE FLAG (0=READ, 1=WRITE)
;
; ON EXIT:
;	R0,AC0,R5 AS ABOVE
;	R3 HAS ADDRESS OF STRING
;
; OTHER REGISTERS USED: R0,R2
;
;	STOSTR - STORE STRING IN MEMORY (REAL OR VIRTUAL)
;
; ON ENTRY:
;	R0 IS PTR TO DATA ITEM HEADER
;	AC0 HAS OFFSET
;		1) FOR STANDARD VAR, OFFSET FROM STUDAT
;		2) FOR VIRTUAL ARRAY, OFFSET FROM FILE START
;	R3 HAS STRING ADDRESS
;	R4 HAS STRING LENGTH
;
; ON EXIT:
;	R0, AC0 AS ABOVE
;	R3 HAS ADDRESS PAST END OF USED PORTION OF SOURCE STRING
;	R4 = 0

;
;
;
; FILSTR
; TO FILL IN A STRING VARIABLE
;
; ON ENTRY:
;	R3 HAS ADDRESS OF SOURCE
;	R4 HAS LEN OF SOURCE
;	R2 HAS ADDRESS OF VARIABLE
;	R5 HAS FILL COUNT
;	R0 HAS FILL CHAR
;
; ON EXIT:
;	R4 = 0
;	R5 = 0
;	R3 HAS ADDRESS PAST END OF USED SOURCE
;	R2 HAS ADDRESS PAST END OF FILLED VARIABLE
;	R0 HAS FILL CHAR
;
;	NEWVAR - TO CREATE A SIMPLE VARIABLE OF R0 TYPE
;
; ON ENTRY:
;	R0 HAS TYPE INDICATOR
;		0 = REAL*4
;		2 = INTEGER
;		4 = BYTE
;		6 = REAL*8
;		10= STRING
;	R4 HAS VARIABLE HEADER
;		LOWER 12 BITS HAVE VAR. NAME
;		TOP 3 BITS ARE DATA TYPE
;
; ON EXIT:
;	R0 AND R4 AS ABOVE
;	R3 POINTS TO DATA ITEM HEADER
;	ENUDAT UPDATED
;
; OTHER REGISTERS USED: R5
;
;	LET00 - LET STATEMENT
;  REGISTERS USED - ALL.
;
;
;	EVALC0 - EVALUATE LOGICAL CONDITION
;
; THIS CODE EVALUATES A COMPOUND CONDITION, ALLOWING FOUR LOGICAL
; OPERATORS: NOT, AND, XOR, OR.
;
; ON ENTRY:
;	R1 POINTS TO START OF CONDITION TEXT
; ON EXIT:
;	R1 POINTS TO NEXT CHAR OF TEXT
;	R0 HAS CONDITION -1 = TRUE, 0 = FALSE
;	'N' SET IF TRUE
;	'Z' SET IF FALSE

;	IF00 - IF STATEMENT
; REGISTERS USED - ALL.
;
;	PR00 - PRINT STATEMENT
;		REGISTERS USED 0,1,2,3,4-OR ALL FOR SHORT
;
;	INP00 - INPUT STATEMENT PROCESSOR
;
; STRCMP - STRING COMPARISON ROUTINE
; ON CALL:
;	R3 CONTAINS ADDRESS OF FIRST STRING
;	R2 CONTAINS ADDRESS OF SECOND STRING
;	R4 CONTAINS LEN FOR COMPARISON
;
; ON RETURN:
;	Z BIT CONDITION CODE CONTAINS RESULT
;	BEQ WILL BRANCH IF STRINGS ARE EQUAL
;
; REGISTERS USED : PROBABLY ALL
;
;
;
;	FILL00 - COMMON DATA ELEMENT FILL ROUTINE
;
; ON ENTRY:
;	R1 POINTS TO START OF DATA
;	LINELN HAS LENGTH OF DATA FOR BINARY OR INPUT LINE
;	STACK AS ON EXIT FROM COM00 PLUS TEXT PTR AND SUBROUTINE LINK
;
; ON EXIT:
;	R1 POINTS PAST END OF DATA USED (TO EOL CHAR IF ASCII)
;	LINELN = REMAINING CHAR COUNT (USUALLY 0) ON BINARY
;	'V' SET ON BAD DATA		(ASCII ONLY)
;	BGT TRUE IF TOO MUCH DATA	(ASCII ONLY)
;	BLT TRUE IF NOT ENOUGH DATA	(ASCII AND BINARY NUMERIC)
;
; NOTE: CONDITION CODES ONLY RELEVANT FOR ASCII DATA AND BINARY NUMERIC
;
; OTHER REGISTERS USED: R0 THROUGH R5, AC0 AND AC1
;
;
;	FILL1: INDIVIDUAL ITEM FILL PROCESSOR
;
; ON ENTRY:
;	R5 POINTS TO 4 WORD ITEM DESCRIPTOR ON STACK
;	R1 HAS START OF TEXT WITH INPUT INFO
;
; ON EXIT:
;	R5 AS ABOVE
;	R1 POINTS PAST END OF THIS ITEM'S TEXT
;
; OTHER REGISTERS USED:

;	COM00 - COMMON EXPRESSION HANDLER FOR READ AND INPUT
;
; ON ENTRY:
;	R1 IS TEXT PTR
; ON EXIT:
;	R1 POINTS PAST END OF STATEMENT
;	'V' SET IF ERROR IN VARIABLE LIST
; STACK ON EXIT:
;	DATA PTR	(1 WORD)
;	DATA TYPE	(1 WORD)
;	OFFSET		(2 WORDS)
;	DATA PTR
;	DATA TYPE
;	OFFSET
;	  .
;	  .
;	  .
;	NULL
; SP -> PTR TO START OF LIST
; OTHER REGISTERS USED: POTENTIALLY ALL (INCL FLOATING PT.)
;
;
;
; ROUTINE EOSCHK
; TO CHECK FOR LEGIT END OF STATEMENT
;
; ON ENTRY:
;	R2 HAS CHAR TO BE CHECKED
; ON EXIT:
;	'Z' SET IF END
;	'Z' CLEAR IF NOT END CHAR
; OTHER REGISTERS USED: NONE
;
;	READ00 - READ STATEMENT PROCESSOR
;	FOR00 - FOR STATEMENT
;  REGISTERS USED - ALL.
;
;	NEXT00 - NEXT STATEMENT TO TERMINATE FOR LOOP
;	REGISTERS USED - ALL.
;
;
;	SCHFOR: ROUTINE TO SEARCH FOR A GIVEN FOR/NEXT CTRL BLOCK
; ON ENTRY:
;	R4 HAS SIXBIT NAME
; ON EXIT:
;	R4 UNCHANGED
;	'Z' SET IF NOT FOUND, R3 = 0
;	'Z' CLEAR IF FOUND, R3 = ADDRESS OF CTRL BLOCK
; OTHER REGISTERS USED: NONE
;
;
;	DELFOR: ROUTINE TO DELETE A FOR/NEXT CTRL BLOCK
; ON ENTRY:
;	R3 POINTS TO CTRL BLOCK TO BE DELETED
; ON EXIT:
;	R3 UNDETERMINED
; OTHER REGISTERS USED: R0,R2

;
;
;	CHKFOR: ROUTINE TO CHECK ON FINISHED/NOT FINISHED CONDITION
; OF FOR/NEXT LOOP.
; ON ENTRY:
;	R3 POINTS TO FOR/NEXT CTRL BLOCK
; ON EXIT:
;	R3 UNCHANGED
;	'Z' SET IF CTRL VARIABLE AT END VALUE, CLEAR OTHERWISE
;	'N' SET IF CTRL VARIABLE PAST END VALUE, CLEAR OTHERWISE
;	R0 HAS ACTUAL STORAGE ADDRESS OF CONTROL VARIABLE
; REGISTERS USED:
;	AC0
;
;