.TITLE	LINE_TYPE EVALUATION
	.ENABLE	DEBUG
	.PSECT	IMPURE_DATA,RD,WRT,NOSHR,NOEXE,GBL,CON,LONG
ARG:	.LONG	2
	.ADDRESS	ARG1,ARG2
ARG1:	.LONG	0
ARG2:	.LONG	0
PARREN_LEVEL:
	.LONG	0
TEMPORARY:
	.LONG	0
RETRY_SCANNER_REGESTERS:
	.LONG	0,0,0	;R9,R10,R11	;SAVE R9,R10,R11 FOR RETRY AS ARITH
	.PSECT	CODE,RD,NOWRT,SHR,EXE,GBL,CON
	.PAGE
	.SUBTITLE	GET_LINE_TYPE
;
;	CALL	GET_LINE_TYPE
;
;	CONVERTS THE TEXT IN SOURCE_LINE TO A QUEUE OF TOKENS
;	IN LINE_TOKEN_QUEUE
;
;	BASED ON THE FIRST SYMBOL FOUND-MAKES A GUESS OF THE LINE
;	TYPE AND ATTEMPTS TO BUILD THE QUEUEOF TOKENS BASED ON THAT ASSUMPTION.
;	IF AN ERROR OCCOURS,  A REEVALUATION IS MADE OF THE LINE TYPE
;	AND A CHECK IS DONE TO CONFIRM THAT TYPE.
;	THE OUTPUTS OF THIS ROUTINE ARE:
;		LINE_TYPE_MNEMONIC	STRING DESCRIBEING LINE TYPE
;		EVALUATION_ROUTINE_POINTER
;
	.ENTRY	GET_LINE_TYPE,^M<R2,R3,R4,R5,R6,R7,R8,R9,R10,R11>
;
;	ENTRY POINT-SAVE ALL REGESTERS
;
;	LINE TOKEN QUEUE IS EMPTY
;
;	SET UP POINTERS FOR SCANNING SOURCE_LINE
	MOVL	#<SOURCE_LINE-136>,R11	;POINTER TO CURRENT SOURCE LINE
	MOVL	R11,R10			;POINTER TO COL 73 OF CURR LINE
	MOVL	R10,R9			;POINTER TO POSITION TO START SCAN
					;FOR NEXT CHAR
	BRB	LOOP_IF_ENTRY
	.ENTRY	LOGICAL_IF_ENTRY_POINT,^M<R2,R3,R4,R5,R6,R7,R8,R9,R10,R11>
LOOP_IF_ENTRY:
	PUSHR	#^M<R9,R10,R11>
	CALLG	NOIO_ARG,SCANNER		;LOAD FIRST IDENTIFYER IN LINE
	MOVL	LINE_TOKEN_QUEUE,R6
	CVTWL	14(R6),R7
	SUBL2	#16,R7
	.PAGE
;
;	AT THIS POINT WE HAVE THE FIRST SYMBOL AND IT IS TIME TO
;	MAKE A GUESS AS TO THE TYPE OF LINE WE HAVE
;
;	DURING THIS PART THE FOLLOWING REGESTERS ARE SAVED UNCHANGED
;	R11	POINTER TO CURRENT SOURCE_LINE
;	R10	POINTER TO CURRENT LINE COLL 73
;	R9	POINTER TO NEXT POS TO START SCANNING FOR CHAR
;	R7	LENGTH OF STRING IN TKEN PACKET
;	R6	POINTER TO TOP OF PACKET
;
;	PACKET HAS FOLLOWING FORMAT
;	.ADDRESS	POINTER TO NEXT QUEUE ELEMENT
;	.ADDRESS	POINTER TO PREVIOUS QUEUE ELEMENT
;	.LONG		LINE NUMBER
;	.WORD		TOKEN NUMBER
;	.WORD		TOKEN LENGTH(16 + STRING SIZE)
;	.BLKB		STRING STROAGE AREA (CAN BE ZERO LENGTH
;
	PUSHR	#^M<R9,R10,R11>	;SAVE TO FREE UP REGESTERS FOR LOCAL USE
	MOVAL	KEY_WORD_TABLE,R11	;POINT TO KEY WORD TABLE
	MOVL	#NUMBER_OF_KEY_WORDS,R10
KEY_WORD_CHECK_LOOP:
	CVTWL	(R11),R9	;GET LENGTH
	CMPL	R9,R7		;CHECK LENGTHS
	BGTR	1$		;IF KEY WORD LONGER THAN STRING-FORGET IT
	CMPC3	R9,@4(R11),16(R6);COMPARE TO KEY WORD
	BEQL	2$		;IT MATCHES
1$:	ADDL2	#8,R11		;NEXT KY WORD
	SOBGTR	R10,KEY_WORD_CHECK_LOOP
;	RAN OUT OF KEY WORDS-ASSUME TO BE ARITHMETIC
	MOVW	#TOKEN_ARITHMETIC,12(R6)	;LOAD TOKEN
	POPR	#^M<R9,R10,R11>
	BRW	7$
2$:	MOVW	2(R11),12(R6)		;LOAD TOKEN
	.PAGE
;
;	TIME TO DO A LITTLE CLEANING UP. THE LINE_TOKEN QUEUE
;	SHOULD BE CORRECTED TO CONTAIN A TOKEN ELEMENT
;	OF THE TYPE OF KEY WORD JUST FOUND
;	THE SCANNER POINTERS ARE RESET TO
;	JUST AFTER THE KEY WORD FOUND
;
;	R11	POINTS TO KEY WORD DESCRIPTER
;	R6	POINTS TO IDENTIFYER QUEUE ELEMENT
;
;	REMOVE ELEMENT FROM QUEUE
	REMQUE	@LINE_TOKEN_QUEUE,R6
;	ALLOCATE A NEW ELEMENT FOR JUST THE KEY WORD FOUND
	CVTWL	12(R6),R0
	CALLG	NULL,INSERT_SIMPLE_TOKEN
	MOVL	LINE_TOKEN_QUEUE,R7	;GET THE NEW ELEMENT
	MOVL	8(R6),8(R7)		;PUT IN CORRECT LINE NUMBER
;
;	FREE OLD ELEMENT
;
5$:	MOVL	R6,ARG2
	CVTWL	14(R6),ARG1
	CALLG	ARG,FREE	;FREE OLD ELEMENT
3$:
	CVTWL	(R11),R2	;GET LENGTH OF KEY WORD
	POPR	#^M<R9,R10,R11>		;RESTORE SCANNING DATA
	POPR	#^M<R9,R10,R11>		;ORIGINAL SET
	MOVL	R9,RETRY_SCANNER_REGESTERS
	MOVL	R10,RETRY_SCANNER_REGESTERS+4
	MOVL	R11,RETRY_SCANNER_REGESTERS+8
;	SKIP TO END OF KEY WORD IN SOURCE LINE
15$:	CALLG	NULL,GET_NON_BLANK_CHR
	CMPB	#^A/!/,R0
	BNEQ	16$
	MOVL	R0,R9
	BRB	15$
16$:	INCL	R9
	SOBGTR	R2,15$
7$:
	.PAGE
;
;	PROCEED TO INDIVIDUAL SCANNING/DOUBLE CHECK ROUTINES
;	WITH THE FOLLOWING REGESTER ALLOCATIONS
;	R11	POINTER TO CURRENT SOURCE_LINE
;	R10	POINTER TO COLL 73 IN CURRENT SOURCE LINE
;	R9	POINTER TO LOC IN CURRENT SOURCE LINE TO START
;		SCANNING FOR NEXT CHR
;
;	GO GET THE TOKEN BEING WORKED ON
	MOVL	LINE_TOKEN_QUEUE,R7
	MOVW	12(R7),R8		;GOT IT
	CASEW	R8,#0,#NUMBER_OF_KEY_WORDS
DC_OFFSET:
	.MACRO	DBLCHK	ITEM
	.WORD	DC_'ITEM'-DC_OFFSET
	.ENDM	DBLCHK
	DBLCHK	ARITHMETIC	;0*
	DBLCHK	ACCEPT		;1*
	DBLCHK	ASSIGN		;2*
	DBLCHK	BACKSPACE	;3*
	DBLCHK	BLOCKDATA	;4*
	DBLCHK	BYTE		;5*
	DBLCHK	CALL		;6*
	DBLCHK	CHARACTER	;7*
	DBLCHK	CLOSE		;8*
	DBLCHK	COMMON		;9*
	DBLCHK	COMPLEX		;10*
	DBLCHK	CONTINUE	;11*
	DBLCHK	DATA		;12*
	DBLCHK	DECODE		;13*
	DBLCHK	DEFINEFILE	;14*
	DBLCHK	DELETE_COMPLEX	;15*
	DBLCHK	DIMENSION	;16*
	DBLCHK	DOUBLECOMPLEX	;17*
	DBLCHK	DOUBLEPRECISION	;18*
	DBLCHK	DO		;19*
	DBLCHK	ELSEIF		;20*
	DBLCHK	ELSE		;21*
	DBLCHK	ENCODE		;22*
	DBLCHK	ENDDO		;23*
	DBLCHK	ENDFILE		;24*
	DBLCHK	ENDIF		;25*
	DBLCHK	END		;26*
	DBLCHK	ENTRY		;27*
	DBLCHK	EQUIVALENCE	;28*
	DBLCHK	EXTERNAL	;29*
	DBLCHK	FIND_COMPLEX	;30*
	DBLCHK	FORMAT		;31*
	DBLCHK	FUNCTION	;32*
	DBLCHK	GOTO		;33*
	DBLCHK	IF		;34*
	DBLCHK	IMPLICITNONE	;35*
	DBLCHK	IMPLICIT	;36*
	DBLCHK	INCLUDE		;37*
	DBLCHK	INTEGER		;38*
	DBLCHK	INTRINSIC	;39*
	DBLCHK	INQUIRE		;40*
	DBLCHK	LOGICAL		;41*
	DBLCHK	NAMELIST	;42*
	DBLCHK	OPEN		;43*
	DBLCHK	OPTION		;44*
	DBLCHK	PARAMETER	;45*
	DBLCHK	PAUSE		;46*
	DBLCHK	PRINT		;47*
	DBLCHK	PROGRAM		;48*
	DBLCHK	READ_COMPLEX	;49*
	DBLCHK	REAL		;50*
	DBLCHK	RETURN		;51*
	DBLCHK	REWIND		;52*
	DBLCHK	REWRITE_COMPLEX	;53*
	DBLCHK	SAVE		;54*
	DBLCHK	STOP		;55*
	DBLCHK	SUBROUTINE	;56*
	DBLCHK	TYPE		;57*
	DBLCHK	UNLOCK		;58*
	DBLCHK	VIRTUAL		;59*
	DBLCHK	WRITE_COMPLEX	;60*
;	ERROR FALL THROUGH-SHOULD NOT GET HERE
UNKNOWN_LINE_TYPE:
	MOVAL	EVAL_ERROR,R6
	CVTWL	2(R6),EVALUATION_ROUTINE_TOKEN
	CVTWL	(R6),R7
	MOVC5	R7,@4(R6),#0,#31,LINE_MNEMONIC
	RET
	.PAGE
	.SUBTITLE	ASSUMED TYPE IN ERROR-TRY ARITHMETIC
RESET_ARITH:
;
;	CLEAR THE ENTIRE LINE_TOKEN_QUEUE AND RESET SCANNING
;	WITH FIRST IDENTIFIER ONLY IN QUEUE
;
1$:	REMQUE	@LINE_TOKEN_QUEUE,R6
	BVS	2$			;IF DONE-GO TO NEXT STEP
	MOVL	R6,ARG2			;GET DATA ON ELEMENT
	CVTWL	14(R6),ARG1		;FOR RELEASE TO HEAP
	CALLG	ARG,FREE
	BRB	1$
2$:	MOVL	RETRY_SCANNER_REGESTERS,R9	;RESET SCANNER POINTERS FOR
	MOVL	RETRY_SCANNER_REGESTERS+4,R10	;RETRY
	MOVL	RETRY_SCANNER_REGESTERS+8,R11
	CALLG	NOIO_ARG,SCANNER		;GET IDENTIFIER
	MOVL	LINE_TOKEN_QUEUE,R0	;SET UP FOR RESET OF TYPE TOKEN
	MOVW	#TOKEN_ARITHMETIC,12(R0)
	JMP	DC_ARITHMETIC		;RETRY AS ARITHMETIC STATEMENT
	.PAGE
	.SUBTITLE	HANDLE ARITHMETIC ROUTINES
DC_ARITHMETIC:
	CLRL	PARREN_LEVEL
;
;	BEFORE ZERO PARREN LEVEL "=" SIGN LOOP
;
ARITH_BEFORE_EQ_LOOP:
	CALLG	NOIO_ARG,SCANNER
;
;	THIS SHOULD BE  EITHER "(" OR "=". ANYTHING ELSE IS AN ERROR
;
	CMPW	#TOKEN_END_OF_LINE,R0
	BNEQ	1$
	JMP	UNKNOWN_LINE_TYPE
1$:	CMPW	#TOKEN_LEFT_PARREN,R0
	BNEQ	2$
	INCL	PARREN_LEVEL
	BRB	ARITH_BEFORE_EQ_LOOP
2$:	CMPW	#TOKEN_RIGHT_PARREN,R0
	BNEQ	3$
	DECL	PARREN_LEVEL
	BRB	ARITH_BEFORE_EQ_LOOP
3$:	TSTL	PARREN_LEVEL
	BGTR	ARITH_BEFORE_EQ_LOOP
	BEQL	4$
	JMP	UNKNOWN_LINE_TYPE	;PARREN LEVEL ERROR
4$:	CMPW	#TOKEN_EQUAL,R0
	BEQL	ARITH_EQUAL_FOUND
	BRW	ARITH_BEFORE_EQ_LOOP
;	DEFFINATELY ARITHMETIC-IGNORE OTHER POSSABLE SYNTAX ERRORS
ARITH_EQUAL_FOUND:
;	JUST LOOP UNTILL ALL TOKENS IN LINE PARSED
	CALLG	NOIO_ARG,SCANNER
	CMPW	#TOKEN_END_OF_LINE,R0
	BNEQ	ARITH_EQUAL_FOUND
;	LOAD LINE MNEMONIC AND EVALUATION ROUTINE TOKEN
	MOVAL	EVAL_ARITH,R6
	CVTWL	2(R6),EVALUATION_ROUTINE_TOKEN
	CVTWL	(R6),R7
	MOVC5	R7,@4(R6),#0,#31,LINE_MNEMONIC
;	SET THE PROPER PROGRAM LEVEL (COULD BE EITHER 5 OR 6 AT THIS POINT)
	CMPL	#5,PROGRAM_LEVEL
	BLEQ	1$
	MOVL	#5,PROGRAM_LEVEL
1$:	RET
	.PAGE
	.SUBTITLE	ACCEPT,TYPE,PRINT STATEMENT'S PLUS SIMPLE READ/WRITE
DC_ACCEPT:
	MOVAL	EVAL_ACCEPT,R6
	BRB	SIMPLE_IO
DC_TYPE:
	MOVAL	EVAL_TYPE,R6
	BRB	SIMPLE_IO
DC_PRINT:
	MOVAL	EVAL_PRINT,R6
	BRB	SIMPLE_IO
DC_READ_SIMPLE:
	MOVAL	EVAL_READ_SIMPLE,R6
	BRB	SIMPLE_IO
DC_WRITE_SIMPLE:
	MOVAL	EVAL_WRITE_SIMPLE,R6
	BRB	SIMPLE_IO
SIMPLE_IO:
	CVTWL	2(R6),EVALUATION_ROUTINE_TOKEN
	CVTWL	(R6),R7
	MOVC5	R7,@4(R6),#0,#31,LINE_MNEMONIC
	CALLG	NOIO_ARG,SCANNER
;	THIS NEXT TOKEN SHOULD BE EITHER
;	TOKEN_ASTERISK
;	TOKEN_IDENTIFIER
;	TOKEN_NUMBER
	CMPW	#TOKEN_ASTERISK,R0
	BEQL	1$		;GOOD
	CMPW	#TOKEN_IDENTIFIER,R0
	BEQL	1$
	CMPW	#TOKEN_NUMBER,R0
	BEQL	1$
;	ERROR-NONE OF THE ABOVE-ASSUME ARITHMETIC-RESET AND FORCE ARITHMETIC
;	CHECK ROUTINE
	JMP	RESET_ARITH
1$:	CLRL	PARREN_LEVEL
;	A ZERO PARREN LEVEL '=' IS ERROR
2$:	CALLG	NOIO_ARG,SCANNER
	CMPW	#TOKEN_END_OF_LINE,R0	;SEE IF DONE
	BEQL	50$
	CMPW	#TOKEN_LEFT_PARREN,R0
	BNEQ	3$
	INCL	PARREN_LEVEL
	BRB	2$
3$:	CMPW	#TOKEN_RIGHT_PARREN,R0
	BNEQ	4$
	DECL	PARREN_LEVEL
	BRB	2$
4$:	TSTL	PARREN_LEVEL
	BGTR	2$
	CMPW	#TOKEN_EQUAL,R0
	BNEQ	2$
	JMP	RESET_ARITH
50$:	MOVL	#6,PROGRAM_LEVEL	;ONLY AT LEVEL 6
	RET
	.PAGE
	.SUBTITLE	COMPLEX I/O ROUTINES
DC_READ_COMPLEX:
	MOVAL	EVAL_READ_COMPLEX,R6
	BRB	COMPLEX_IO
DC_WRITE_COMPLEX:
	MOVAL	EVAL_WRITE_COMPLEX,R6
	BRB	COMPLEX_IO
DC_REWRITE_COMPLEX:
	MOVAL	EVAL_REWRITE_COMPLEX,R6
	BRB	COMPLEX_IO
DC_FIND_COMPLEX:
	MOVAL	EVAL_FIND_COMPLEX,R6
	BRB	COMPLEX_IO
DC_DELETE_COMPLEX:
	MOVAL	EVAL_DELETE_COMPLEX,R6
	BRB	COMPLEX_IO
COMPLEX_IO:
	CVTWL	2(R6),EVALUATION_ROUTINE_TOKEN
	CVTWL	(R6),R7
	MOVC5	R7,@4(R6),#0,#31,LINE_MNEMONIC
1$:	CALLG	NULL,GET_NON_BLANK_CHR	;NEXT CHR MUST BE '('
	CMPB	#^A/!/,R0
	BNEQ	2$
	MOVL	R10,R9
	BRB	1$
2$:	CMPB	#^A/(/,R0
	BEQL	3$	;FOUND IT-CONTINUE WITH COMPLEX IO
	CMPL	#TOKEN_EVAL_READ_COMPLEX,EVALUATION_ROUTINE_TOKEN
	BEQL	4$
	JMP	DC_WRITE_SIMPLE
4$:	JMP	DC_READ_SIMPLE
3$:	MOVL	#1,PARREN_LEVEL
	INCL	R9
	MOVL	#TOKEN_LEFT_PARREN,R0
	CALLG	NULL,INSERT_SIMPLE_TOKEN
;	USE OLD FORM UNTILL FIND IO KEY WORD THEN GO TO NEW FORM
;
;	GET THE UNIT NUMBER
LOOP_UNIT_NUMBER:
	CMPL	#1,PARREN_LEVEL
	BLSS	27$
28$:	CALLG	NULL,GET_NON_BLANK_CHR
	CMPB	#^A/!/,R0
	BNEQ	29$
	MOVL	R10,R9
	BRB	28$
29$:	CMPB	#^A/'/,R0
	BNEQ	27$
	INCL	R9
	MOVL	#TOKEN_QUOTE,R0
	CALLG	NULL,INSERT_SIMPLE_TOKEN
	JMP	GET_REC
27$:	CALLG	IO_ARG,SCANNER
	CMPW	#TOKEN_END_OF_LINE,R0
	BNEQ	21$
	JMP	UNKNOWN_LINE_TYPE
21$:	CMPL	#4000,R0	;SEE IF IO KEY WORD TOKEN
	BGTR	20$
	CMPL	#5000,R0
	BLEQ	20$
;	FOUND IO KEY WORD
	JMP	IO_COMPLEX_KEY_WORD
20$:	CMPW	#TOKEN_RIGHT_PARREN,R0	;TERMINATE INSIDE I/O SPECS-GOTO I/O LIST
	BNEQ	23$
	DECL	PARREN_LEVEL
	BGTR	LOOP_UNIT_NUMBER
	JMP	COMPLEX_LIST
23$:	CMPW	#TOKEN_LEFT_PARREN,R0
	BNEQ	26$
	INCL	PARREN_LEVEL
	JMP	LOOP_UNIT_NUMBER
26$:	CMPW	#TOKEN_COMMA,R0	;SEE IF AT END OF UNIT EXPRESSION
	BNEQ	25$
	JMP	GET_FMT
25$:;	HAVE COMPLEX UNIT NUMBER EXPRESSION, CONTINUE UNTILL SPERATOR FOUND
	JMP	LOOP_UNIT_NUMBER
GET_REC:CALLG	IO_ARG,SCANNER	;GET THE RECORD TOKEN
	CMPW	#TOKEN_END_OF_LINE,R0
	BNEQ	21$
	JMP	UNKNOWN_LINE_TYPE
21$:	CMPL	#4000,R0	;SEE IF IO KEY WORD TOKEN
	BGTR	20$
	CMPL	#5000,R0
	BLEQ	20$
;	FOUND IO KEY WORD
	JMP	IO_COMPLEX_KEY_WORD
20$:	CMPW	#TOKEN_LEFT_PARREN,R0
	BNEQ	22$
	INCL	PARREN_LEVEL
	BRB	GET_REC
22$:	CMPW	#TOKEN_RIGHT_PARREN,R0	;TERMINATE INSIDE I/O SPECS-GOTO I/O LIST
	BNEQ	23$
	DECL	PARREN_LEVEL
	BGTR	GET_REC
	JMP	COMPLEX_LIST
23$:	CMPL	#1,PARREN_LEVEL
	BGEQ	24$
	JMP	GET_REC
24$:	CMPW	#TOKEN_COMMA,R0	;SEE IF AT END OF UNIT EXPRESSION
	BEQL	GET_FMT
;	HAVE COMPLEX UNIT NUMBER EXPRESSION, CONTINUE UNTILL SPERATOR FOUND
	JMP	GET_REC
GET_FMT:
	CALLG	IO_ARG,SCANNER	;GET THE RECORD TOKEN
	CMPW	#TOKEN_END_OF_LINE,R0
	BNEQ	21$
	JMP	UNKNOWN_LINE_TYPE
21$:	CMPL	#4000,R0	;SEE IF IO KEY WORD TOKEN
	BGTR	20$
	CMPL	#5000,R0
	BLEQ	20$
;	FOUND IO KEY WORD
	JMP	IO_COMPLEX_KEY_WORD
20$:	CMPW	#TOKEN_RIGHT_PARREN,R0	;TERMINATE INSIDE I/O SPECS-GOTO I/O LIST
	BNEQ	23$
	DECL	PARREN_LEVEL
	BGTR	GET_FMT
	JMP	COMPLEX_LIST
23$:	CMPW	#TOKEN_LEFT_PARREN,R0
	BNEQ	26$
	INCL	PARREN_LEVEL
	JMP	GET_FMT
26$:	CMPL	#1,PARREN_LEVEL
	BGEQ	24$
	JMP	GET_FMT
24$:	CMPW	#TOKEN_COMMA,R0	;SEE IF AT END OF UNIT EXPRESSION
	BEQL	IO_COMPLEX_KEY_WORD_LOOP	;PASSED THE FORMAT-ALL IS KEY WORD FORM
;	HAVE COMPLEX UNIT NUMBER EXPRESSION, CONTINUE UNTILL SPERATOR FOUND
	JMP	GET_FMT
IO_COMPLEX_KEY_WORD_LOOP:
	CALLG	IO_ARG,SCANNER	;GET NEXT I/O KEY WORD
	CMPW	#TOKEN_END_OF_LINE,R0
	BNEQ	1$
	JMP	UNKNOWN_LINE_TYPE	;BAD ERROR HERE
1$:	CMPW	#TOKEN_RIGHT_PARREN,R0	;END OF CONTROLL LIST
	BNEQ	2$
	JMP	COMPLEX_LIST		;GET COMPLEX LIST
2$:;	SEE IF IT IS REALLY IO KEY WORD
	CMPL	#4000,R0
	BGTR	10$		;OOPS-ERROR
	CMPL	#5000,R0
	BGTR	IO_COMPLEX_KEY_WORD	;YES IT IS-CHECK ARGUMENT IF ANY
10$:	;GO A NON IO KEY WORD HERE-BAD ERROR
	JMP	UNKNOWN_LINE_TYPE
IO_COMPLEX_KEY_WORD:
	CALLG	NOIO_ARG,SCANNER
	CMPW	#TOKEN_END_OF_LINE,R0
	BNEQ	1$
	JMP	UNKNOWN_LINE_TYPE
1$:	CMPW	#TOKEN_LEFT_PARREN,R0
	BNEQ	2$
	INCL	PARREN_LEVEL
	BRB	IO_COMPLEX_KEY_WORD
2$:	CMPW	#TOKEN_RIGHT_PARREN,R0
	BNEQ	3$
	DECL	PARREN_LEVEL
	BEQL	COMPLEX_LIST
	BRW	IO_COMPLEX_KEY_WORD
3$:	CMPL	#1,PARREN_LEVEL
	BLSS	IO_COMPLEX_KEY_WORD
	CMPW	#TOKEN_COMMA,R0
	BEQL	IO_COMPLEX_KEY_WORD_LOOP
	BRW	IO_COMPLEX_KEY_WORD
COMPLEX_LIST:
	CLRL	PARREN_LEVEL
;
;	KEY TEST HERE IS THAT NO ZERO PARREN LEVEL '=' OCCOURS
;
COMPLEX_LIST_LOOP:
	CALLG	NOIO_ARG,SCANNER	;GET THE NEXT TOKEN
	CMPW	#TOKEN_END_OF_LINE,R0	;CHECK FOR END OF LINE
	BNEQ	1$
	MOVL	#6,PROGRAM_LEVEL	;ONLY AT LEVEL 6
	RET				;IS END-EXIT
1$:	CMPW	#TOKEN_LEFT_PARREN,R0	;CJECK PARREN LEVEL
	BNEQ	2$
	INCL	PARREN_LEVEL		;DEEPER AND DEEPER
	BRB	COMPLEX_LIST_LOOP
2$:	CMPW	#TOKEN_RIGHT_PARREN,R0	;SHALLOWER
	BNEQ	3$
	DECL	PARREN_LEVEL
	BRB	COMPLEX_LIST_LOOP
3$:	TSTL	PARREN_LEVEL		;CHECK FOR ZERO LEVEL '='
	BGTR	COMPLEX_LIST_LOOP	;ONLY IF AT ZERO PARREN LEVEL
	CMPW	#TOKEN_EQUAL,R0
	BNEQ	COMPLEX_LIST_LOOP
	JMP	RESET_ARITH
	.PAGE
	.SUBTITLE	AUX FILE ROUTINES REWIND,BACKSPACE,ENDFILE,UNLOCK,OPEN,CLOSE
DC_REWIND:
	MOVAL	EVAL_REWIND,R6
	BRB	AUX_1_FILE
DC_BACKSPACE:
	MOVAL	EVAL_BACKSPACE,R6
	BRB	AUX_1_FILE
DC_ENDFILE:
	MOVAL	EVAL_ENDFILE,R6
	BRB	AUX_1_FILE
DC_UNLOCK:
	MOVAL	EVAL_UNLOCK,R6
	BRB	AUX_1_FILE
DC_OPEN:
	MOVAL	EVAL_OPEN,R6
	BRB	AUX_1_FILE
DC_CLOSE:
	MOVAL	EVAL_CLOSE,R6
	BRB	AUX_1_FILE
DC_INQUIRE:
	MOVAL	EVAL_INQUIRE,R6
	BRB	AUX_1_FILE
AUX_1_FILE:
	CVTWL	2(R6),EVALUATION_ROUTINE_TOKEN	;GET TOKEN
	CVTWL	(R6),R7		;GET LENGTH OF MNEMONIC
	MOVC5	R7,@4(R6),#0,#31,LINE_MNEMONIC
	CLRL	PARREN_LEVEL
	CALLG	NOIO_ARG,SCANNER	;GET FIRST TOKEN
	CMPW	#TOKEN_END_OF_LINE,R0
	BNEQ	1$
	JMP	UNKNOWN_LINE_TYPE	;WRONG-HAVE TO HAVE AT LEAST ONE ARG
1$:	CMPW	#TOKEN_LEFT_PARREN,R0	;START INTO COMPLEX FORM ??
	BEQL	101$
	JMP	SIMPLE_AUX_1_FILE
101$:	INCL	PARREN_LEVEL
	CALLG	IO_ARG,SCANNER		;GET FIRST ARGUEMNT
	CMPW	#TOKEN_END_OF_LINE,R0
	BNEQ	2$
	JMP	UNKNOWN_LINE_TYPE
2$:;NOW SEE IF GO IO TYPE KEY WORD
	CMPL	#4000,R0
	BGTR	3$		;NO
	CMPL	#5000,R0
	BLEQ	3$		;NO
	JMP	AUX_1_COMPLEX_ARG	;GO GET ARGUMENT TO COMPLEX FORM
3$:
;	HERE WE ARE IN A COMPLEX FORM INSIDE PARRENS, GO FIRST PART OF
;	FIRST ARG AND IT IS NOT A KEY WORD SO IT IS PART OF UNIT
;	NUMBER SPEC-CHECK ON PARREN NESTING
AUX_1_UNIT_LOOP:
	CMPW	#TOKEN_LEFT_PARREN,R0
	BNEQ	1$
	INCL	PARREN_LEVEL
	BRB	AUX_1_NEXT_ARG
1$:	CMPW	#TOKEN_RIGHT_PARREN,R0
	BNEQ	2$
	DECL	PARREN_LEVEL
	BGTR	AUX_1_NEXT_ARG
	JMP	END_AUX_1
2$:	CMPL	#1,PARREN_LEVEL
	BLSS	AUX_1_NEXT_ARG
	CMPW	#TOKEN_COMMA,R0
	BEQL	AUX_1_GET_COMPLEX_ARG
AUX_1_NEXT_ARG:
	CALLG	NOIO_ARG,SCANNER
	BRW	AUX_1_UNIT_LOOP
AUX_1_GET_COMPLEX_ARG:
	CALLG	IO_ARG,SCANNER	;GET NEXT ARGUMENT
	CMPW	#TOKEN_END_OF_LINE,R0
	BNEQ	1$
	JMP	UNKNOWN_LINE_TYPE
1$:	CMPL	#4000,R0
	BGTR	50$
	CMPL	#5000,R0
	BGTR	2$
50$:	JMP	UNKNOWN_LINE_TYPE
2$:
AUX_1_COMPLEX_ARG:
	CALLG	IO_ARG,SCANNER
	CMPW	#TOKEN_END_OF_LINE,R0
	BNEQ	11$
	JMP	UNKNOWN_LINE_TYPE
11$:	CMPW	#TOKEN_LEFT_PARREN,R0
	BNEQ	1$
	INCL	PARREN_LEVEL
	BRB	AUX_1_COMPLEX_ARG
1$:	CMPW	#TOKEN_RIGHT_PARREN,R0
	BNEQ	2$
	DECL	PARREN_LEVEL
	BLEQ	END_AUX_1
	BRB	AUX_1_COMPLEX_ARG
2$:	CMPL	#1,PARREN_LEVEL
	BLSS	AUX_1_COMPLEX_ARG
	CMPW	#TOKEN_COMMA,R0
	BEQL	AUX_1_GET_COMPLEX_ARG
	BRW	AUX_1_COMPLEX_ARG
END_AUX_1:
;	SHOULD ONLY GET END OF LINE HERE-ELSE ERROR
	CALLG	NOIO_ARG,SCANNER
	CMPW	#TOKEN_END_OF_LINE,R0
	BNEQ	1$
	MOVL	#6,PROGRAM_LEVEL
	RET
1$:	JMP	RESET_ARITH
SIMPLE_AUX_1_FILE:
;THIS IS THE SIMPLE FORM-REPEAT UNTILL END OF LINE
	CLRL	PARREN_LEVEL
1$:	CALLG	NOIO_ARG,SCANNER
	CMPW	#TOKEN_END_OF_LINE,R0
	BNEQ	2$
	MOVL	#6,PROGRAM_LEVEL
	RET
2$:	CMPW	#TOKEN_LEFT_PARREN,R0
	BNEQ	3$
	INCL	PARREN_LEVEL
	BRB	1$
3$:	CMPW	#TOKEN_RIGHT_PARREN,R0
	BNEQ	4$
	DECL	PARREN_LEVEL
	BRB	1$
4$:	TSTL	PARREN_LEVEL
	BGTR	1$
	CMPW	#TOKEN_EQUAL,R0
	BNEQ	1$
	JMP	RESET_ARITH
	.PAGE
	.SUBTITLE	ENCODE/DECODE
DC_ENCODE:
	MOVAL	EVAL_ENCODE,R6
	BRB	DC_CODE
DC_DECODE:
	MOVAL	EVAL_DECODE,R6
	BRB	DC_CODE
DC_CODE:
	CVTWL	2(R6),EVALUATION_ROUTINE_TOKEN	;GET TOKEN
	CVTWL	(R6),R7		;GET LENGTH OF MNEMONIC
	MOVC5	R7,@4(R6),#0,#31,LINE_MNEMONIC
	CALLG	NOIO_ARG,SCANNER	;THIS MUST BE "("
	CMPW	#TOKEN_LEFT_PARREN,R0
	BEQL	1$
	JMP	RESET_ARITH
1$:	MOVL	#1,PARREN_LEVEL
;	FIRST ARGUMENT IS INTEGER EXPRESSION
CODE_LOOP_1:
	CALLG	NOIO_ARG,SCANNER
	CMPW	#TOKEN_END_OF_LINE,R0
	BNEQ	1$
	JMP	UNKNOWN_LINE_TYPE
1$:	CMPW	#TOKEN_LEFT_PARREN,R0
	BNEQ	2$
	INCL	PARREN_LEVEL
	BRB	CODE_LOOP_1
2$:	CMPW	#TOKEN_RIGHT_PARREN,R0
	BNEQ	3$
	DECL	PARREN_LEVEL
	BRB	CODE_LOOP_1
3$:	CMPL	#1,PARREN_LEVEL
	BLSS	CODE_LOOP_1
	BEQL	4$
	JMP	UNKNOWN_LINE_TYPE
4$:	CMPW	#TOKEN_COMMA,R0
	BNEQ	CODE_LOOP_1
;	GET SECOND ARGUMENT-FORMAT SPECIFIER
	CALLG	NOIO_ARG,SCANNER
	CMPW	#TOKEN_END_OF_LINE,R0
	BNEQ	5$
	JMP	UNKNOWN_LINE_TYPE
5$:	CALLG	NOIO_ARG,SCANNER	;MUST BE ","
	CMPW	#TOKEN_COMMA,R0
	BEQL	6$
	JMP	UNKNOWN_LINE_TYPE
6$:;	GET ARRAY NAME
	CALLG	NOIO_ARG,SCANNER
	CMPW	#TOKEN_IDENTIFIER,R0
	BEQL	7$
	JMP	UNKNOWN_LINE_TYPE
7$:	CALLG	NOIO_ARG,SCANNER	;EITHER "," OR ")" OR "("               ;V1.7
	CMPW	#TOKEN_END_OF_LINE,R0                                           ;V1.7
	BNEQ	10$                                                             ;V1.7
	JMP	UNKNOWN_LINE_TYPE                                               ;V1.7
10$:	CMPL	#1,PARREN_LEVEL                                                 ;V1.7
	BNEQ	9$                                                              ;V1.7
	CMPW	#TOKEN_COMMA,R0                                                 ;V1.7
	BEQL	CODE_COMPLEX_LOOP                                               ;V1.7
9$:	CMPW	#TOKEN_RIGHT_PARREN,R0                                          ;V1.7
	BNEQ	8$                                                              ;V1.7
	DECL	PARREN_LEVEL                                                    ;V1.7
	BLEQ	CODE_COMPLEX_LIST_LOOP                                          ;V1.7
	BRB	7$                                                              ;V1.7
8$:	CMPW	#TOKEN_LEFT_PARREN,R0                                           ;V1.7
	BNEQ	7$                                                              ;V1.7
	INCL	PARREN_LEVEL                                                    ;V1.7
	BRB	7$                                                              ;V1.7
CODE_COMPLEX_LOOP:                                                              ;**-6
	CALLG	IO_ARG,SCANNER		;MUST BE IO KEY WORD
	CMPL	#4000,R0
	BGTR	1$
	CMPL	#5000,R0
	BGTR	2$
1$:	JMP	UNKNOWN_LINE_TYPE
2$:	CALLG	NOIO_ARG,SCANNER	;GET THE ARGUMENT
	CALLG	NOIO_ARG,SCANNER	;GET "," OR ")"
	CMPW	#TOKEN_COMMA,R0
	BEQL	CODE_COMPLEX_LOOP
	CMPW	#TOKEN_RIGHT_PARREN,R0
	BEQL	CODE_COMPLEX_LIST_LOOP
	JMP	UNKNOWN_LINE_TYPE
CODE_COMPLEX_LIST_LOOP:
	CLRL	PARREN_LEVEL
;	SKIP THROUGH I/O LIST
CODE_COMPLEX_LIST_LOOP_1:
	CALLG	NOIO_ARG,SCANNER	;GET THE NEXT TOKEN
	CMPW	#TOKEN_END_OF_LINE,R0	;CHECK FOR END OF LINE
	BNEQ	1$
	MOVL	#6,PROGRAM_LEVEL
	RET				;IS END-EXIT
1$:	CMPW	#TOKEN_LEFT_PARREN,R0	;CJECK PARREN LEVEL
	BNEQ	2$
	INCL	PARREN_LEVEL		;DEEPER AND DEEPER
	BRB	CODE_COMPLEX_LIST_LOOP_1
2$:	CMPW	#TOKEN_RIGHT_PARREN,R0	;SHALLOWER
	BNEQ	3$
	DECL	PARREN_LEVEL
	BRB	CODE_COMPLEX_LIST_LOOP_1
3$:	TSTL	PARREN_LEVEL		;CHECK FOR ZERO LEVEL '='
	BGTR	CODE_COMPLEX_LIST_LOOP_1;ONLY IF AT ZERO PARREN LEVEL
	CMPW	#TOKEN_EQUAL,R0
	BNEQ	CODE_COMPLEX_LIST_LOOP_1
	JMP	RESET_ARITH
	.PAGE
	.SUBTITLE	DEFINE FILE
DC_DEFINEFILE:
	MOVAL	EVAL_DEFINEFILE,R0
	CVTWL	2(R0),EVALUATION_ROUTINE_TOKEN
	CVTWL	(R0),R1
	MOVC5	R1,@4(R0),#0,#31,LINE_MNEMONIC
DEFINE_FILE_LOOP:
	CALLG	NOIO_ARG,SCANNER	;GET UNIT NUMBER
	CMPW	#TOKEN_IDENTIFIER,R0	;MUST BE IDENTIFIER OR NUMBER
	BEQL	1$
	CMPW	#TOKEN_NUMBER,R0
	BEQL	1$
	JMP	RESET_ARITH
1$:	CALLG	NOIO_ARG,SCANNER	;GET "("
	CMPW	#TOKEN_LEFT_PARREN,R0
	BEQL	2$
	JMP	RESET_ARITH
2$:	CALLG	NOIO_ARG,SCANNER	;GET FIRST ARG
	CMPW	#TOKEN_IDENTIFIER,R0	;MUST BE IDENTIFIER OR NUMBER
	BEQL	3$
	CMPW	#TOKEN_NUMBER,R0
	BEQL	3$
	JMP	RESET_ARITH
3$:	CALLG	NOIO_ARG,SCANNER	;GET ","
	CMPW	#TOKEN_COMMA,R0
	BEQL	4$
	JMP	RESET_ARITH
4$:	CALLG	NOIO_ARG,SCANNER	;GET SECOND ARG
	CMPW	#TOKEN_IDENTIFIER,R0	;MUST BE IDENTIFIER OR NUMBER
	BEQL	5$
	CMPW	#TOKEN_NUMBER,R0
	BEQL	5$
	JMP	RESET_ARITH
5$:	CALLG	NOIO_ARG,SCANNER	;GET ","
	CMPW	#TOKEN_COMMA,R0
	BEQL	6$
	JMP	RESET_ARITH
6$:	CALLG	NULL,GET_NON_BLANK_CHR	;GET "U"
	CMPB	#^A/!/,R0
	BNEQ	77$
	MOVL	R0,R9
	BRB	6$
77$:	CMPB	#^A/U/,R0
	BEQL	7$
	JMP	RESET_ARITH
7$:	INCL	R9
	MOVL	#TOKEN_U,R0
	CALLG	NULL,INSERT_SIMPLE_TOKEN
	CALLG	NOIO_ARG,SCANNER
	CMPW	#TOKEN_COMMA,R0	;MUST BE COMMA
	BEQL	8$
	JMP	RESET_ARITH
8$:	CALLG	NOIO_ARG,SCANNER	;GET LAST ARG
	CMPW	#TOKEN_IDENTIFIER,R0	;MUST BE IDENTIFIER OR NUMBER
	BEQL	9$
	CMPW	#TOKEN_NUMBER,R0
	BEQL	9$
	JMP	RESET_ARITH
9$:	CALLG	NOIO_ARG,SCANNER	;GET ")"
	CMPW	#TOKEN_RIGHT_PARREN,R0
	BEQL	10$
	JMP	RESET_ARITH
10$:	CALLG	NOIO_ARG,SCANNER	;SEE IF REPEAT
	CMPW	#TOKEN_COMMA,R0
	BNEQ	11$
	JMP	DEFINE_FILE_LOOP
11$:	CMPW	#TOKEN_END_OF_LINE,R0	;OR END OF LINE
	BEQL	12$
	JMP	RESET_ARITH
12$:	MOVL	#6,PROGRAM_LEVEL
	RET
	.PAGE
	.SUBTITLE	LINES WITH ONLY KEY WORD
;	R8 CONTAINS TARGET PROGRAM LEVEL IF PROPER KEYWORD
DC_CONTINUE:
	MOVL	#6,R8
	MOVAL	EVAL_CONTINUE,R6
	BRB	DC_BLANK
DC_ELSE:
	MOVL	#6,R8
	MOVAL	EVAL_ELSE,R6
	BRB	DC_BLANK
DC_END:
	MOVL	#7,R8
	MOVAL	EVAL_END,R6
	BRB	DC_BLANK
DC_ENDDO:
	MOVL	#6,R8
	MOVAL	EVAL_ENDDO,R6
	BRB	DC_BLANK
DC_ENDIF:
	MOVL	#6,R8
	MOVAL	EVAL_ENDIF,R6
	BRB	DC_BLANK
DC_IMPLICITNONE:
	CMPL	#2,PROGRAM_LEVEL	;CAN ONLY OCCOUR IF AT PROGRAM
					;LEVELS 0-2
	BGEQ	1$
	JMP	RESET_ARITH
1$:	MOVL	#3,R8
	MOVAL	EVAL_IMPLICITNONE,R6
	BRB	DC_BLANK
DC_BLANK:
	CVTWL	2(R6),EVALUATION_ROUTINE_TOKEN
	CVTWL	(R6),R7
	MOVC5	R7,@4(R6),#0,#31,LINE_MNEMONIC
	CALLG	NOIO_ARG,SCANNER
	CMPW	#TOKEN_END_OF_LINE,R0
	BEQL	1$
	JMP	RESET_ARITH
1$:	MOVL	R8,PROGRAM_LEVEL
	RET
	.PAGE
	.SUBTITLE	SIMPLE LISTS WITH NO ZERO PAREN LEVEL "="
;	R8 CONTAINS TARGET PROGRAM LEVEL
DC_DIMENSION:
	CMPL	#4,PROGRAM_LEVEL
	BGEQ	1$
	JMP	RESET_ARITH
1$:	MOVL	#4,R8
	MOVAL	EVAL_DIMENSION,R6
	BRW	DC_SIMPLE_LIST
DC_VIRTUAL:
	CMPL	#4,PROGRAM_LEVEL
	BGEQ	1$
	JMP	RESET_ARITH
1$:	MOVL	#4,R8
	MOVAL	EVAL_VIRTUAL,R6
	BRW	DC_SIMPLE_LIST
DC_EQUIVALENCE:
	CMPL	#4,PROGRAM_LEVEL
	BGEQ	1$
	JMP	RESET_ARITH
1$:	MOVL	#4,R8
	MOVAL	EVAL_EQUIVALENCE,R6
	BRW	DC_SIMPLE_LIST
DC_EXTERNAL:
	CMPL	#4,PROGRAM_LEVEL
	BGEQ	1$
	JMP	RESET_ARITH
1$:	MOVL	#4,R8
	MOVAL	EVAL_EXTERNAL,R6
	BRW	DC_SIMPLE_LIST
DC_IMPLICIT:
	CMPL	#3,PROGRAM_LEVEL
	BGEQ	1$
	JMP	RESET_ARITH
1$:	MOVL	#3,R8
	MOVAL	EVAL_IMPLICIT,R6
	BRW	DC_SIMPLE_LIST
DC_NAMELIST:
	MOVL	PROGRAM_LEVEL,R8
	CMPL	#2,R8
	BLEQ	1$
	MOVL	#2,R8
1$:	MOVAL	EVAL_NAMELIST,R6
	BRW	DC_SIMPLE_LIST
DC_INTRINSIC:
	CMPL	#4,PROGRAM_LEVEL
	BGEQ	1$
	JMP	RESET_ARITH
1$:	MOVL	#4,R8
	MOVAL	EVAL_INTRINSIC,R6
	BRW	DC_SIMPLE_LIST
DC_SAVE:
	CMPL	#4,PROGRAM_LEVEL
	BGEQ	1$
	JMP	RESET_ARITH
1$:	MOVL	#4,R8
	MOVAL	EVAL_SAVE,R6
	BRW	DC_SIMPLE_LIST
DC_DATA:
	MOVL	PROGRAM_LEVEL,R8
	CMPL	#4,R8
	BLEQ	1$
	MOVL	#4,R8
1$:	MOVAL	EVAL_DATA,R6
	BRW	DC_SIMPLE_LIST
DC_CALL:
	MOVL	#6,R8
	MOVAL	EVAL_CALL,R6
	BRW	DC_SIMPLE_LIST
DC_SUBROUTINE:
	CMPL	#1,PROGRAM_LEVEL
	BGEQ	1$
	JMP	RESET_ARITH
1$:	MOVL	#2,R8
	MOVAL	EVAL_SUBROUTINE,R6
	BRB	DC_SIMPLE_LIST
DC_FUNCTION:
	CMPL	#1,PROGRAM_LEVEL
	BGEQ	1$
	JMP	RESET_ARITH
1$:	MOVL	#2,R8
	MOVAL	EVAL_FUNCTION,R6
	BRB	DC_SIMPLE_LIST
DC_ENTRY:
	MOVL	#6,R8
	MOVAL	EVAL_ENTRY,R6
	BRB	DC_SIMPLE_LIST
DC_PROGRAM:
	CMPL	#1,PROGRAM_LEVEL
	BGEQ	1$
	JMP	RESET_ARITH
1$:	MOVL	#2,R8
	MOVAL	EVAL_PROGRAM,R6
	BRB	DC_SIMPLE_LIST
DC_BLOCKDATA:
	CMPL	#1,PROGRAM_LEVEL
	BGEQ	1$
	JMP	RESET_ARITH
1$:	MOVL	#2,R8
	MOVAL	EVAL_BLOCKDATA,R6
	BRB	DC_SIMPLE_LIST
DC_COMMON:
	CMPL	#4,PROGRAM_LEVEL
	BGEQ	1$
	JMP	RESET_ARITH
1$:	MOVL	#4,R8
	MOVAL	EVAL_COMMON,R6
	BRB	DC_SIMPLE_LIST
DC_RETURN:
	MOVAL	EVAL_RETURN,R6
	BRB	DC_SIMPLE_LIST
DC_SIMPLE_LIST:
	CLRL	PARREN_LEVEL
	CVTWL	2(R6),EVALUATION_ROUTINE_TOKEN
	CVTWL	(R6),R7
	MOVC5	R7,@4(R6),#0,#31,LINE_MNEMONIC
DC_SIMPLE_LIST_LOOP:	;NO ZERO LEVEL "=" TO BE FOUND
	CALLG	NOIO_ARG,SCANNER
	CMPW	#TOKEN_END_OF_LINE,R0
	BNEQ	1$
	MOVL	R8,PROGRAM_LEVEL
	RET
1$:	CMPW	#TOKEN_LEFT_PARREN,R0
	BNEQ	2$
	INCL	PARREN_LEVEL
	BRB	DC_SIMPLE_LIST_LOOP
2$:	CMPW	#TOKEN_RIGHT_PARREN,R0
	BNEQ	3$
	DECL	PARREN_LEVEL
	BRB	DC_SIMPLE_LIST_LOOP
3$:	TSTL	PARREN_LEVEL
	BGTR	DC_SIMPLE_LIST_LOOP
	CMPW	#TOKEN_EQUAL,R0
	BNEQ	DC_SIMPLE_LIST_LOOP
	JMP	RESET_ARITH
	.PAGE
	.SUBTITLE	PAUSE/STOP/INCLUDE HAVE AT MOST ONE ARGUMENT
DC_PAUSE:
	MOVAL	EVAL_PAUSE,R6
	MOVL	#6,TEMPORARY
	BRB	DC_ONE_ARG
DC_STOP:
	MOVAL	EVAL_STOP,R6
	MOVL	#6,TEMPORARY
	BRB	DC_ONE_ARG
DC_INCLUDE:
	MOVAL	EVAL_INCLUDE,R6
	MOVL	PROGRAM_LEVEL,TEMPORARY
	BRB	DC_ONE_ARG
DC_ONE_ARG:
	CVTWL	2(R6),EVALUATION_ROUTINE_TOKEN
	CVTWL	(R6),R7
	MOVC5	R7,@4(R6),#0,#31,LINE_MNEMONIC
	CALLG	NOIO_ARG,SCANNER
	CMPW	#TOKEN_END_OF_LINE,R0
	BNEQ	1$
	MOVL	TEMPORARY,PROGRAM_LEVEL
	RET
1$:	CMPW	#TOKEN_EQUAL,R0
	BNEQ	2$
	JMP	RESET_ARITH
2$:	CALLG	NOIO_ARG,SCANNER
	CMPW	#TOKEN_END_OF_LINE,R0
	BNEQ	3$
	MOVL	TEMPORARY,PROGRAM_LEVEL
	RET
3$:	JMP	RESET_ARITH
	.PAGE
	.SUBTITLE	SIMPLE TYPE OR TYPE FUNCTION STATEMENTS
DC_BYTE:
	MOVAL	EVAL_BYTE,R6
	BRB	DC_SIMPLE_TYPE
DC_LOGICAL:
	MOVAL	EVAL_LOGICAL,R6
	BRB	DC_SIMPLE_TYPE
DC_DOUBLEPRECISION:
	MOVAL	EVAL_DOUBLE_PRECISION,R6
	BRB	DC_SIMPLE_TYPE
DC_DOUBLECOMPLEX:
	MOVAL	EVAL_DOUBLE_COMPLEX,R6
	BRB	DC_SIMPLE_TYPE
DC_INTEGER:
	MOVAL	EVAL_INTEGER,R6
	BRB	DC_SIMPLE_TYPE
DC_SIMPLE_TYPE:
	CVTWL	2(R6),EVALUATION_ROUTINE_TOKEN
	CVTWL	(R6),R7
	MOVC5	R7,@4(R6),#0,#31,LINE_MNEMONIC
;	SEE IF AT LEAST AT LEVEL 4
	CMPL	#4,PROGRAM_LEVEL
	BGEQ	1$
	JMP	RESET_ARITH	;NO-REDO AS ARITHMETIC STATEMENT
1$:	CALLG	NULL,GET_NON_BLANK_CHR	;FOR CASE OF LOGICAL AND INTEGER
					;CHECK FOR LENGTH SPECIFIER
	CMPB	#^A/!/,R0
	BNEQ	101$
	MOVL	R10,R9
	BRB	1$
101$:	CMPB	#^A/*/,R0
	BNEQ	2$		;NO SPEC
	CALLG	NOIO_ARG,SCANNER	;GET TOKEN FOR LENGTH
2$:	CMPL	#1,PROGRAM_LEVEL	;IS IT WORTH CHECKING FOR "FUNCTION"
	BGEQ	102$
	JMP	SIMPLE_TYPE_ONLY
102$:
;	FOR BACKUP-SAVE SCANNER POINTER REGESTERS
	PUSHR	#^M<R9,R10,R11>
	.MACRO	CKF	LET,?AAA,?BBB,?CCC
CCC:	CALLG	NULL,GET_NON_BLANK_CHR
	CMPB	#^A/!/,R0
	BNEQ	BBB
	MOVL	R10,R9
	BRB	CCC
BBB:	CMPB	#^A/'LET'/,R0
	BEQL	AAA
	BRW	SIMPLE_TYPE_NOT_FUNCTION
AAA:
	INCL	R9
	.ENDM
	CKF	<F>
	CKF	<U>
	CKF	<N>
	CKF	<C>
	CKF	<T>
	CKF	<I>
	CKF	<O>
	CKF	<N>
;	POSSABLY A FUNCTION BUT NOT CONCLUSIVE
	MOVL	#TOKEN_FUNCTION,R0
	CALLG	NULL,INSERT_SIMPLE_TOKEN
	CALLG	NOIO_ARG,SCANNER	;GET THE NEXT IDENTIFIER
	CMPL	#TOKEN_IDENTIFIER,R0
	BEQL	3$
	JMP	RESTORE_SIMPLE_TYPE_NOT_FN
3$:	CALLG	NOIO_ARG,SCANNER	;GET E.O.L.,LENGTH SPEC,OR LEFT PARREN
	CMPW	#TOKEN_COMMA,R0		;SEE IF FUNCTION IS PART OF NAME
	BNEQ	103$
	JMP	RESTORE_SIMPLE_TYPE_NOT_FN
103$:	CMPW	#TOKEN_ONE_BYTE,R0		;SEE IF LENGTH SPEC
	BEQL	3$
	CMPW	#TOKEN_TWO_BYTES,R0
	BEQL	3$
	CMPW	#TOKEN_FOUR_BYTES,R0
	BEQL	3$
	CMPW	#TOKEN_OCTAL_BYTES,R0
	BEQL	3$
	CMPW	#TOKEN_HEX_BYTES,R0
	BEQL	3$
	CMPW	#TOKEN_END_OF_LINE,R0
	BNEQ	4$
	;SIMPLE FUNCTION WITH NO ARGUMENTS
	BRW	9$
4$:	CMPW	#TOKEN_LEFT_PARREN,R0	;START OF ARGUMENT LIST
	BEQL	5$
;	ANYTHING ELSE IS AN ERROR-ASSUME SIMPLE TYPE
	JMP	RESTORE_SIMPLE_TYPE_NOT_FN
5$:	MOVL	#1,PARREN_LEVEL
;	SKIP THROUGH ARGUMENT LIST UNTILL TO ZERO LEVEL PARREN
6$:	CALLG	NOIO_ARG,SCANNER
	CMPW	#TOKEN_END_OF_LINE,R0
	BNEQ	7$
	JMP	RESTORE_SIMPLE_TYPE_NOT_FN
7$:	CMPW	#TOKEN_LEFT_PARREN,R0
	BNEQ	8$
	INCL	PARREN_LEVEL
	BRB	6$
8$:	CMPW	#TOKEN_RIGHT_PARREN,R0
	BNEQ	6$
	DECL	PARREN_LEVEL
	BGTR	6$
;	NOW BACK AT ZERO PARREN LEVEL-MUST BE NOTHING MORE ON LINE
	CALLG	NOIO_ARG,SCANNER
	CMPW	#TOKEN_END_OF_LINE,R0
	BEQL	9$
;	FOUND SOMETHING ELSE ON LINE-AN ERROR
	JMP	RESTORE_SIMPLE_TYPE_NOT_FN
9$:	MOVL	#2,PROGRAM_LEVEL
;	RESET EVALUATION ROUTINE AND MENMONIC
	CMPW	#TOKEN_EVAL_BYTE,EVALUATION_ROUTINE_TOKEN
	BNEQ	11$
	MOVAL	EVAL_BYTE_FUNCTION,R6
	BRW	20$
11$:	CMPW	#TOKEN_EVAL_LOGICAL,EVALUATION_ROUTINE_TOKEN
	BNEQ	12$
	MOVAL	EVAL_LOGICAL_FUNCTION,R6
	BRW	20$
12$:	CMPW	#TOKEN_EVAL_DOUBLE_PRECISION,EVALUATION_ROUTINE_TOKEN
	BNEQ	13$
	MOVAL	EVAL_DOUBLE_PRECISION_FN,R6
	BRW	20$
13$:	CMPW	#TOKEN_EVAL_DOUBLE_COMPLEX,EVALUATION_ROUTINE_TOKEN
	BNEQ	14$
	MOVAL	EVAL_DOUBLE_CPLX_FUNCTION,R6
	BRW	20$
14$:	MOVAL	EVAL_INTEGER_FUNCTION,R6
20$:	CVTWL	2(R6),EVALUATION_ROUTINE_TOKEN
	CVTWL	(R6),R7
	MOVC5	R7,@4(R6),#0,#31,LINE_MNEMONIC
	RET
RESTORE_SIMPLE_TYPE_NOT_FN:
;	POP OFF END OF LINE TOKEN QUEUE UNTILL TOKEN_FUNCTION ELEIMINATED
	REMQUE	@LINE_TOKEN_QUEUE+4,R6
	BVC	1$
	JMP	RESET_ARITH
1$:	CVTWL	12(R6),R7
	CVTWL	14(R6),ARG1
	MOVL	R6,ARG2
	CALLG	ARG,FREE
2$:	CMPW	#TOKEN_FUNCTION,R0
	BNEQ	RESTORE_SIMPLE_TYPE_NOT_FN
SIMPLE_TYPE_NOT_FUNCTION:
	POPR	#^M<R9,R10,R11>
SIMPLE_TYPE_ONLY:
	CLRL	PARREN_LEVEL
;	LOOP THROUGH TOKENS-LOOK FOR NO ZERO LEVEL "="
11$:	CALLG	NOIO_ARG,SCANNER
	CMPW	#TOKEN_END_OF_LINE,R0
	BNEQ	1$
	MOVL	#4,PROGRAM_LEVEL
	RET
1$:	CMPW	#TOKEN_LEFT_PARREN,R0
	BNEQ	2$
	INCL	PARREN_LEVEL
	BRB	11$
2$:	CMPW	#TOKEN_RIGHT_PARREN,R0
	BNEQ	3$
	DECL	PARREN_LEVEL
	BRB	11$
3$:	TSTL	PARREN_LEVEL
	BGTR	11$
	CMPW	#TOKEN_EQUAL,R0
	BNEQ	11$
	JMP	RESET_ARITH
	.PAGE
	.SUBTITLE	IF/ELSEIF
DC_IF:	MOVAL	EVAL_IF,R6
	BRB	DC_IF_ELSEIF
DC_ELSEIF:
	MOVAL	EVAL_ELSEIF,R6
	BRB	DC_IF_ELSEIF
DC_IF_ELSEIF:
	CVTWL	2(R6),EVALUATION_ROUTINE_TOKEN
	CVTWL	(R6),R7
	MOVC5	R7,@4(R6),#0,#31,LINE_MNEMONIC
;	NEXT CHR MUST BE "("
	CALLG	NOIO_ARG,SCANNER
	CMPW	#TOKEN_LEFT_PARREN,R0
	BEQL	101$
	JMP	RESET_ARITH
101$:	MOVL	#1,PARREN_LEVEL
;	LOOP UNTILL BACK TO ZERO PARREN LEVEL
11$:	CALLG	NOIO_ARG,SCANNER
	CMPW	#TOKEN_END_OF_LINE,R0
	BNEQ	1$
	JMP	RESET_ARITH
1$:	CMPW	#TOKEN_LEFT_PARREN,R0
	BNEQ	2$
	INCL	PARREN_LEVEL
	BRB	11$
2$:	CMPW	#TOKEN_RIGHT_PARREN,R0
	BNEQ	11$
	DECL	PARREN_LEVEL
	BGTR	11$
;	FOR ELSEIF-ONLY DO CHECK FOR "THEN"
	CMPW	#TOKEN_EVAL_ELSEIF,EVALUATION_ROUTINE_TOKEN
	BEQL	CHECK_FOR_ELSEIF_THEN
;	SEE IF NUMBER FORM OF IF- IF()1,2,3
31$:	CALLG	NULL,GET_NON_BLANK_CHR
	CMPB	#^A/!/,R0
	BNEQ	30$
	MOVL	R10,R9
	BRB	31$
30$:	CMPB	#^A/0/,R0
	BGTR	CHECK_FOR_THEN
	CMPB	#^A/9/,R0
	BLSS	CHECK_FOR_THEN
;	WE HAVE THE THREE WAY ARITHMETIC FORM OF IF
;	LOOP UNTILL END OF LINE
20$:	CALLG	NOIO_ARG,SCANNER
	CMPW	#TOKEN_END_OF_LINE,R0
	BNEQ	20$
	MOVL	#6,PROGRAM_LEVEL
	RET
CHECK_FOR_ELSEIF_THEN:
	CALLG	NULL,GET_NON_BLANK_CHR
	CMPB	#^A/!/,R0
	BNEQ	CHECK_FOR_THEN
	MOVL	R10,R9
	BRB	CHECK_FOR_ELSEIF_THEN
CHECK_FOR_THEN:
	PUSHR	#^M<R9,R10,R11>
	CMPB	#^A/T/,R0
	BEQL	102$
	JMP	LOGICAL_FORM
102$:	INCL	R9
2$:	CALLG	NULL,GET_NON_BLANK_CHR
	CMPB	#^A/!/,R0
	BNEQ	1$
	MOVL	R10,R9
	BRB	2$
1$:	CMPB	#^A/H/,R0
	BNEQ	LOGICAL_FORM
	INCL	R9
3$:	CALLG	NULL,GET_NON_BLANK_CHR
	CMPB	#^A/!/,R0
	BNEQ	4$
	MOVL	R10,R9
	BRB	3$
4$:	CMPB	#^A/E/,R0
	BNEQ	LOGICAL_FORM
	INCL	R9
5$:	CALLG	NULL,GET_NON_BLANK_CHR
	CMPB	#^A/!/,R0
	BNEQ	6$
	MOVL	R10,R9
	BRB	5$
6$:	CMPB	#^A/N/,R0
	BNEQ	LOGICAL_FORM
	INCL	R9
;	TO BE CORRECT-NO MORE TO BE FOUND ON LINE
7$:	CALLG	NULL,GET_NON_BLANK_CHR
	CMPB	#^A/!/,R0
	BNEQ	8$
	MOVL	R10,R9
	BRB	7$
8$:	TSTB	R0
	BNEQ	LOGICAL_FORM
;	IT IS THE IF()THEN OR ELSEIF()THEN FORM
	MOVL	#TOKEN_THEN,R0
	MOVL	#6,PROGRAM_LEVEL
	JMP	ADD_SIMPLE_TOKEN
LOGICAL_FORM:
	POPR	#^M<R9,R10,R11>
	CMPL	#EVAL_ELSEIF,EVALUATION_ROUTINE_TOKEN
	BNEQ	1$
	JMP	RESET_ARITH
1$:;	AT THIS POINT WE HAVE A LOGICAL IF PARTIALLY PARSED.
;	THE PROGRAM MUST BE FAKED OUT TO THINK IT IS
;	DOING A NEW LINE TYPE
;	INIT TEMP STORAGE OF QUEUE TOKENS
	MOVAL	IF_TOKEN_QUEUE,IF_TOKEN_QUEUE
	MOVAL	IF_TOKEN_QUEUE,IF_TOKEN_QUEUE+4
;	MOVE LINE TOKES TO TEMP STORAGE
3$:	REMQUE	@LINE_TOKEN_QUEUE,R6
	BVS	2$
	INSQUE	(R6),IF_TOKEN_QUEUE
	BRB	3$
;	PARSE THE REST OF THE LINE
2$:	CALLG	NULL,LOGICAL_IF_ENTRY_POINT
;	RESTORE IF STUFF TO BEGINNING OF LINE TOKEN QUEUE
4$:	REMQUE	@IF_TOKEN_QUEUE,R6
	BVS	5$
	INSQUE	(R6),LINE_TOKEN_QUEUE
	BRB	4$
5$:	CMPL	#TOKEN_EVAL_ERROR,EVALUATION_ROUTINE_TOKEN
	BNEQ	6$
	RET
6$:	MOVL	EVALUATION_ROUTINE_TOKEN,LOGICAL_IF_ROUTINE_TOKEN
	MOVC3	#31.,LINE_MNEMONIC,LOGICAL_IF_MNEMONIC
	MOVAL	EVAL_IF,R6
	CVTWL	2(R6),EVALUATION_ROUTINE_TOKEN
	CVTWL	(R6),R7
	MOVC5	R7,@4(R6),#0,#31,LINE_MNEMONIC
	RET
	.PAGE
	.SUBTITLE	DO [S[,]] I=E1,E2[,E3] OR DO [S[,]] WHILE(E)
DC_DO:	MOVAL	EVAL_DO,R6
	CVTWL	2(R6),EVALUATION_ROUTINE_TOKEN
	CVTWL	(R6),R7
	MOVC5	R7,@4(R6),#0,#31,LINE_MNEMONIC
;	CHECK NEXT CHR-MAY BE A NUMBER
11$:	CALLG	NULL,GET_NON_BLANK_CHR
	CMPB	#^A/!/,R0
	BNEQ	12$
	MOVL	R10,R9
	BRB	11$
12$:	CMPB	#^A/0/,R0
	BGTR	DO_NO_LABEL
	CMPB	#^A/9/,R0
	BLSS	DO_NO_LABEL
;	HAVE A LABEL NUMBER HERE
	CALLG	NOIO_ARG,SCANNER
;	HAVE LABEL IN-CHECK ON PRESENCE OF COMMA NEXT
13$:	CALLG	NULL,GET_NON_BLANK_CHR
	CMPB	#^A/!/,R0
	BNEQ	14$
	MOVL	R10,R9
	BRB	13$
14$:	CMPB	#^A/,/,R0
	BNEQ	1$
	INCL	R9	;HANDEL SKIPPING COMMA AND PUTTING IN TOKEN QUEUE
	MOVL	#TOKEN_COMMA,R0
	CALLG	NULL,INSERT_SIMPLE_TOKEN
1$:
DO_NO_LABEL:
;	HER WE HAVE TO DIFFRENTIATE BETWEEN
;	DO N V=E1,E2
;	DO N WHILE()
;	WHERE THE FORM
;	DO N WHILE()=E1,E2
;	USEING AN ELEMENT OF THE DEFINED ARRAY WHILE() IS NOT ACCEPTABLE
;
;	LOOK FOR THE STRING "WHILE("
	PUSHR	#^M<R9,R10,R11>	;SAVE SCANNING DATA FOR BACK UP
18$:	CALLG	NULL,GET_NON_BLANK_CHR
	CMPB	#^A/!/,R0
	BNEQ	19$
	MOVL	R10,R9
	BRB	18$
19$:	CMPB	#^A/W/,R0
	BEQL	119$
	JMP	DO_INDEX_FORM
119$:	INCL	R9
20$:	CALLG	NULL,GET_NON_BLANK_CHR
	CMPB	#^A/!/,R0
	BNEQ	21$
	MOVL	R10,R9
	BRB	20$
21$:	CMPB	#^A/H/,R0
	BEQL	121$
	JMP	DO_INDEX_FORM
121$:	INCL	R9
22$:	CALLG	NULL,GET_NON_BLANK_CHR
	CMPB	#^A/!/,R0
	BNEQ	23$
	MOVL	R10,R9
	BRB	22$
23$:	CMPB	#^A/I/,R0
	BEQL	123$
	JMP	DO_INDEX_FORM
123$:	INCL	R9
24$:	CALLG	NULL,GET_NON_BLANK_CHR
	CMPB	#^A/!/,R0
	BNEQ	25$
	MOVL	R10,R9
	BRB	24$
25$:	CMPB	#^A/L/,R0
	BEQL	125$
	JMP	DO_INDEX_FORM
125$:	INCL	R9
26$:	CALLG	NULL,GET_NON_BLANK_CHR
	CMPB	#^A/!/,R0
	BNEQ	27$
	MOVL	R10,R9
	BRB	26$
27$:	CMPB	#^A/E/,R0
	BEQL	127$
	JMP	DO_INDEX_FORM
127$:	INCL	R9
28$:	CALLG	NULL,GET_NON_BLANK_CHR
	CMPB	#^A/!/,R0
	BNEQ	29$
	MOVL	R10,R9
	BRB	28$
29$:	CMPB	#^A/(/,R0
	BEQL	129$
	JMP	DO_INDEX_FORM
129$:	INCL	R9
	POPR	#^M<R0,R1,R2>	;DUMP STACK-NO NEED TO BACK UP
	MOVL	#TOKEN_WHILE,R0
	CALLG	NULL,INSERT_SIMPLE_TOKEN
	MOVL	#TOKEN_LEFT_PARREN,R0
	CALLG	NULL,INSERT_SIMPLE_TOKEN
	MOVL	#1,PARREN_LEVEL
;	LOOP TILL ZERO PAREN LEVEL
11$:	CALLG	NOIO_ARG,SCANNER
	CMPW	#TOKEN_END_OF_LINE,R0
	BNEQ	1$
	JMP	RESET_ARITH
1$:	CMPW	#TOKEN_LEFT_PARREN,R0
	BNEQ	2$
	INCL	PARREN_LEVEL
	BRB	11$
2$:	CMPW	#TOKEN_RIGHT_PARREN,R0
	BNEQ	11$
	DECL	PARREN_LEVEL
	BGTR	11$
;	NOTHING MORE SHOULD BE IN LINE
	CALLG	NOIO_ARG,SCANNER
	CMPW	#TOKEN_END_OF_LINE,R0
	BEQL	3$
	JMP	RESET_ARITH
3$:	MOVL	#6,PROGRAM_LEVEL
	RET
DO_INDEX_FORM:
	POPR	#^M<R9,R10,R11>
	CLRL	PARREN_LEVEL
;	GET INDEX IDENTIFIER
11$:	CALLG	NOIO_ARG,SCANNER
	CMPW	#TOKEN_IDENTIFIER,R0
	BEQL	11$
	CMPW	#TOKEN_END_OF_LINE,R0
	BNEQ	1$
	JMP	RESET_ARITH
1$:	CMPW	#TOKEN_LEFT_PARREN,R0
	BNEQ	2$
	INCL	PARREN_LEVEL
	BRB	11$
2$:	CMPW	#TOKEN_RIGHT_PARREN,R0
	BNEQ	3$
	DECL	PARREN_LEVEL
	BRB	11$
3$:	TSTL	PARREN_LEVEL
	BGTR	11$
	CMPW	#TOKEN_EQUAL,R0	;MUST BE "=" SIGN
	BEQL	DO_LOWER_LIMIT
	JMP	RESET_ARITH
DO_LOWER_LIMIT:
11$:	CALLG	NOIO_ARG,SCANNER
	CMPW	#TOKEN_IDENTIFIER,R0
	BEQL	11$
	CMPW	#TOKEN_NUMBER,R0
	BEQL	11$
	CMPW	#TOKEN_END_OF_LINE,R0
	BNEQ	1$
	JMP	RESET_ARITH
1$:	CMPW	#TOKEN_LEFT_PARREN,R0
	BNEQ	2$
	INCL	PARREN_LEVEL
	BRB	11$
2$:	CMPW	#TOKEN_RIGHT_PARREN,R0
	BNEQ	3$
	DECL	PARREN_LEVEL
	BRB	11$
3$:	TSTL	PARREN_LEVEL
	BGTR	11$
	CMPW	#TOKEN_COMMA,R0	;MUST BE COMMA
	BNEQ	11$
DO_UPPER_LIMIT:
11$:	CALLG	NOIO_ARG,SCANNER
	CMPW	#TOKEN_IDENTIFIER,R0
	BEQL	11$
	CMPW	#TOKEN_NUMBER,R0
	BEQL	11$
	CMPW	#TOKEN_END_OF_LINE,R0
	BNEQ	1$
	JMP	DO_DONE
1$:	CMPW	#TOKEN_LEFT_PARREN,R0
	BNEQ	2$
	INCL	PARREN_LEVEL
	BRB	11$
2$:	CMPW	#TOKEN_RIGHT_PARREN,R0
	BNEQ	3$
	DECL	PARREN_LEVEL
	BRB	11$
3$:	TSTL	PARREN_LEVEL
	BGTR	11$
	CMPW	#TOKEN_COMMA,R0	;MUST BE COMMA
	BNEQ	11$
DO_STEP:
11$:	CALLG	NOIO_ARG,SCANNER
	CMPW	#TOKEN_IDENTIFIER,R0
	BEQL	11$
	CMPW	#TOKEN_NUMBER,R0
	BEQL	11$
	CMPW	#TOKEN_END_OF_LINE,R0
	BNEQ	1$
	JMP	DO_DONE
1$:	CMPW	#TOKEN_LEFT_PARREN,R0
	BNEQ	2$
	INCL	PARREN_LEVEL
	BRB	11$
2$:	CMPW	#TOKEN_RIGHT_PARREN,R0
	BNEQ	11$
	DECL	PARREN_LEVEL
	BRB	11$
DO_DONE:
	MOVL	#6,PROGRAM_LEVEL
	RET
	.PAGE
	.SUBTITLE	ASSIGN LABEL TO INTEGER
DC_ASSIGN:
	MOVAL	EVAL_ASSIGN,R6
	CVTWL	2(R6),EVALUATION_ROUTINE_TOKEN
	CVTWL	(R6),R7
	MOVC5	R7,@4(R6),#0,#31,LINE_MNEMONIC
;	NEXT ITEM SHOULD BE A NUMBER
	CALLG	NOIO_ARG,SCANNER
	CMPW	#TOKEN_NUMBER,R0
	BEQL	1$
	JMP	RESET_ARITH
1$:
;	SHOULD FIND NEXT TWO CHRS ARE "TO"
20$:	CALLG	NULL,GET_NON_BLANK_CHR
	CMPB	#^A/!/,R0
	BNEQ	21$
	MOVL	R10,R9
	BRB	20$
21$:	CMPB	#^A/T/,R0
	BEQL	2$
	JMP	RESET_ARITH
2$:	INCL	R9
22$:	CALLG	NULL,GET_NON_BLANK_CHR
	CMPB	#^A/!/,R0
	BNEQ	23$
	MOVL	R10,R9
	BRB	22$
23$:	CMPB	#^A/O/,R0
	BEQL	3$
	JMP	RESET_ARITH
3$:	INCL	R9
	MOVL	#TOKEN_TO,R0
	CALLG	NULL,INSERT_SIMPLE_TOKEN
	CALLG	NOIO_ARG,SCANNER	;GET THE ASSIGNED INTEGER
	CMPW	#TOKEN_IDENTIFIER,R0
	BEQL	4$
	JMP	RESET_ARITH	;OOPS-HAVE ERROR
4$:	CALLG	NOIO_ARG,SCANNER	;ONLY ACCEPTABLE RETURN IS E.O.L. OR "("
	CMPW	#TOKEN_END_OF_LINE,R0
	BNEQ	5$
	MOVL	#6,PROGRAM_LEVEL
	RET
5$:	CMPW	#TOKEN_LEFT_PARREN,R0
	BEQL	6$
	JMP	RESET_ARITH
6$:;	LOOP UNTILL ZERO LEVEL PARREN FOUND THEN NOTHING
	MOVL	#1,PARREN_LEVEL
7$:	CALLG	NOIO_ARG,SCANNER
	CMPW	#TOKEN_END_OF_LINE,R0
	BNEQ	8$
	JMP	RESET_ARITH
8$:	CMPW	#TOKEN_LEFT_PARREN,R0
	BNEQ	9$
	INCL	PARREN_LEVEL
	BRB	7$
9$:	CMPW	#TOKEN_RIGHT_PARREN,R0
	BNEQ	7$
	DECL	PARREN_LEVEL
	BGTR	7$
	CALLG	NOIO_ARG,SCANNER	;SHOULD BE E.O.L.
	CMPW	#TOKEN_END_OF_LINE,R0
	BEQL	10$
	JMP	RESET_ARITH
10$:	MOVL	#6,PROGRAM_LEVEL
	RET
	.PAGE
	.SUBTITLE	GOTO
DC_GOTO:
	MOVAL	EVAL_GOTO,R6
	CVTWL	2(R6),EVALUATION_ROUTINE_TOKEN
	CVTWL	(R6),R7
	MOVC5	R7,@4(R6),#0,#31.,LINE_MNEMONIC
;
;	TAKES FOLLOWING FORMS
;	GO TO E
;	GO TO E [[,](LIST)]
;	GO TO (LIST)[,] E
1$:	CALLG	NULL,GET_NON_BLANK_CHR	;WHAT CHARACTER FOLLOWS
	CMPB	#^A/!/,R0
	BNEQ	2$
	MOVL	R10,R9
	BRB	1$
2$:	CMPB	#^A/(/,R0
	BEQL	COMPUTED_GO_TO
	CMPB	#^A/0/,R0
	BLEQ	102$
	JMP	CHK_ASSIGNED
102$:	CMPB	#^A/9/,R0
	BGEQ	202$
	JMP	CHK_ASSIGNED
202$:
;	PLAIN VANILLA GO TO
	CALLG	NOIO_ARG,SCANNER	;GET LABEL
	CALLG	NOIO_ARG,SCANNER	;SHOULD BE NOTHING HERE
	CMPW	#TOKEN_END_OF_LINE,R0
	BEQL	3$
	JMP	RESET_ARITH
3$:	MOVL	#6,PROGRAM_LEVEL
	RET
COMPUTED_GO_TO:
	CALLG	NOIO_ARG,SCANNER	;RETURN IS NUMBER,COMMA OR ")"
	CMPW	#TOKEN_END_OF_LINE,R0
	BEQL	1$
	CMPW	#TOKEN_RIGHT_PARREN,R0
	BEQL	GET_GOTO_EXPRESSION
	CMPW	#TOKEN_NUMBER,R0
	BEQL	COMPUTED_GO_TO
	CMPW	#TOKEN_COMMA,R0
	BEQL	COMPUTED_GO_TO
	CMPW	#TOKEN_LEFT_PARREN,R0
	BEQL	COMPUTED_GO_TO
1$:	JMP	RESET_ARITH		;SOMETHING IS WRONG HERE
GET_GOTO_EXPRESSION:
	CLRL	PARREN_LEVEL		;SKIP TO E.O.L. WITH NO ZERO LEVEL "="
11$:	CALLG	NOIO_ARG,SCANNER
	CMPW	#TOKEN_END_OF_LINE,R0
	BEQL	GOTO_EXP_DONE
	CMPW	#TOKEN_LEFT_PARREN,R0
	BNEQ	1$
	INCL	PARREN_LEVEL
	BRB	11$
1$:	CMPW	#TOKEN_RIGHT_PARREN,R0
	BNEQ	2$
	DECL	PARREN_LEVEL
	BRB	11$
2$:	TSTL	PARREN_LEVEL
	BEQL	11$
	CMPL	#TOKEN_EQUAL,R0
	BNEQ	11$
	JMP	RESET_ARITH
GOTO_EXP_DONE:
	MOVL	#6,PROGRAM_LEVEL
	RET
CHK_ASSIGNED:
	CMPB	#^A/A/,R0
	BGTR	1$
	CMPB	#^A/Z/,R0
	BGEQ	2$
1$:	JMP	RESET_ARITH
2$:	CALLG	NOIO_ARG,SCANNER	;GET THE VARIABLE
	CALLG	NOIO_ARG,SCANNER	;SE IF ANYTHING FOLLOWS
	CMPW	#TOKEN_END_OF_LINE,R0
	BEQL	8$
	CMPW	#TOKEN_COMMA,R0		;COMMA OK
	BEQL	3$
	BRB	4$
3$:	CALLG	NOIO_ARG,SCANNER
4$:	CMPW	#TOKEN_LEFT_PARREN,R0	;LEFT PARREN OK
	BEQL	5$
	JMP	RESET_ARITH
5$:;	LOOP UNTILL ")" FOUND WITH NOTHING TO FOLLOW
	CALLG	NOIO_ARG,SCANNER	;RETURN IS NUMBER,COMMA OR ")"
	CMPW	#TOKEN_RIGHT_PARREN,R0
	BEQL	6$
	CMPW	#TOKEN_END_OF_LINE,R0
	BEQL	7$
	CMPW	#TOKEN_NUMBER,R0
	BEQL	5$
	CMPW	#TOKEN_COMMA,R0
	BEQL	5$
7$:	JMP	RESET_ARITH		;SOMETHING IS WRONG HERE
6$:	CALLG	NOIO_ARG,SCANNER
	CMPW	#TOKEN_END_OF_LINE,R0
	BEQL	8$
	JMP	RESET_ARITH
8$:	MOVL	#6,PROGRAM_LEVEL
	RET
	.PAGE
	.SUBTITLE	OPTION
DC_OPTION:
	TSTL	PROGRAM_LEVEL
	BEQL	1$
	JMP	RESET_ARITH
1$:	MOVAL	EVAL_OPTION,R6
	CVTWL	2(R6),EVALUATION_ROUTINE_TOKEN
	CVTWL	(R6),R7
	MOVC5	R7,@4(R6),#0,#31,LINE_MNEMONIC
;	THIS SHOULD CONSIST ONLY OF IDENIFIERS,SLASH,COMMA
2$:	CALLG	NOIO_ARG,SCANNER
	CMPW	#TOKEN_END_OF_LINE,R0
	BEQL	OPTION_DONE
	CMPW	#TOKEN_IDENTIFIER,R0
	BEQL	2$
	CMPW	#TOKEN_SLASH,R0
	BEQL	2$
	CMPW	#TOKEN_COMMA,R0
	BEQL	2$
	JMP	RESET_ARITH
OPTION_DONE:
	MOVL	#1,PROGRAM_LEVEL
	RET
	.PAGE
	.SUBTITLE	PARAMETER OLD AND NEW
DC_PARAMETER:
	MOVAL	EVAL_PARAMETER,R6
	CVTWL	2(R6),EVALUATION_ROUTINE_TOKEN
	CVTWL	(R6),R7
	MOVC5	R7,@4(R6),#0,#31,LINE_MNEMONIC
	MOVL	PROGRAM_LEVEL,R8
	CMPL	#4,R8		;IS THIS THE PLACE
	BLSS	NOT_PARAMETER
	BEQL	1$
	MOVL	#3,R8
1$:;	ASSUMED TO BE OK-JUST SCANN TO END OF LINE NO MATTER WHAT
;	THAT IS THE WAY THE FORTRAN COMPILER ACCEPTS IT
	CALLG	NOIO_ARG,SCANNER
	CMPW	#TOKEN_END_OF_LINE,R0
	BNEQ	1$
	MOVL	R8,PROGRAM_LEVEL
	RET
NOT_PARAMETER:
	JMP	RESET_ARITH
	.PAGE
	.SUBTITLE	FORMAT
DC_FORMAT:
	MOVL	PROGRAM_LEVEL,R8
	CMPL	#2,R8
	BLEQ	11$
	MOVL	#2,R8
11$:	MOVAL	EVAL_FORMAT,R6
	CVTWL	2(R6),EVALUATION_ROUTINE_TOKEN
	CVTWL	(R6),R7
	MOVC5	R7,@4(R6),#0,#31,LINE_MNEMONIC
;	LOOK FOR THELEADING "("
	CALLG	NOIO_ARG,SCANNER
	CMPW	#TOKEN_LEFT_PARREN,R0
	BEQL	1$
	JMP	RESET_ARITH
1$:	MOVL	#1,PARREN_LEVEL
FORMAT_LOOP:
	CALLG	NOIO_ARG,SCANNER
	CMPW	#TOKEN_END_OF_LINE,R0
	BNEQ	1$
	JMP	RESET_ARITH
1$:	CMPW	#TOKEN_LEFT_PARREN,R0
	BNEQ	2$
	INCL	PARREN_LEVEL
	BRB	FORMAT_LOOP
2$:	CMPW	#TOKEN_RIGHT_PARREN,R0
	BNEQ	FORMAT_LOOP
	DECL	PARREN_LEVEL
	BGTR	FORMAT_LOOP
;	HAVE COMPLETED FORMAT STATEMENT-NOTHNG SHOULD FOLLOW
	CALLG	NOIO_ARG,SCANNER
	CMPW	#TOKEN_END_OF_LINE,R0
	BEQL	END_FORMAT
	JMP	RESET_ARITH
END_FORMAT:
	MOVL	R8,PROGRAM_LEVEL
	RET
	.PAGE
	.SUBTITLE	CHARACTER AND CHARACTER FUNCTION
DC_CHARACTER:
	CMPL	#4,PROGRAM_LEVEL	;IS CHARACTER OR CHARACTER FUNCTION
					;PROPER IN THIS POSITION
	BGEQ	15$
	JMP	RESET_ARITH		;NO-TREAT AS ARITHMETIC
15$:	MOVAL	EVAL_CHARACTER,R6
	CVTWL	2(R6),EVALUATION_ROUTINE_TOKEN
	CVTWL	(R6),R7
	MOVC5	R7,@4(R6),#0,#31,LINE_MNEMONIC
;	CHECK ON LENGTH SPEC
;	BY  GETTING NEXT CHAR FOLLOWING THE KEY WORD
1$:	CALLG	NULL,GET_NON_BLANK_CHR
	CMPB	#^A/!/,R0
	BNEQ	2$
	MOVL	R10,R9
	BRB	1$
;	DOES A LENGTH SPEC FOLLOW ??
2$:	CMPB	#^A/*/,R0
	BEQL	102$
	JMP	NO_CHR_LEN_SPEC		;NO-SKIP TO POSSABLE CHECK FOR FUNCTION
102$:	CALLG	NOIO_ARG,SCANNER	;GET LENGTH SPEC IN PART OR ALL
	CMPW	#TOKEN_PASSED_LENGTH,R0	;IF GOT FORM *(*) GO IT ALL
	BNEQ	202$
	JMP	GET_CHR_COMMA		;GO GET POSABLE COMMA
202$:	CMPW	#TOKEN_ONE_BYTE,R0	;*1 SAME
	BEQL	GET_CHR_COMMA
	CMPW	#TOKEN_TWO_BYTES,R0	;*2 SAME
	BEQL	GET_CHR_COMMA
	CMPW	#TOKEN_FOUR_BYTES,R0	;*4 SAME
	BEQL	GET_CHR_COMMA
	CMPW	#TOKEN_OCTAL_BYTES,R0	;*8 SAME
	BEQL	GET_CHR_COMMA
	CMPW	#TOKEN_HEX_BYTES,R0	;*16 SAME
	BEQL	GET_CHR_COMMA
;	IF FALL THROUGH TO HERE-ONLY GOT "*"-GET REST OF LENGTH SPEC
	CALLG	NOIO_ARG,SCANNER	;GET NEXT PART OF LENGTH
	CMPW	#TOKEN_NUMBER,R0	;IF A NUMBER-HAVE ALL OF LENGTH SPEC
	BEQL	GET_CHR_COMMA
	CMPW	#TOKEN_IDENTIFIER,R0	;CAN BE AN IDENTIFIER
	BEQL	GET_CHR_COMMA
	CMPW	#TOKEN_LEFT_PARREN,R0	;OR "(" TO START COMPLEX LENGTH
	BEQL	3$
	JMP	UNKNOWN_LINE_TYPE	;UNKNOWN LINE TYPE-TRY AGAIN
3$:	MOVL	#1,PARREN_LEVEL		;LOOP UNTILL BACK TO ZERO PARREN LEVEL
4$:	CALLG	NOIO_ARG,SCANNER
	CMPW	#TOKEN_END_OF_LINE,R0
	BNEQ	5$
	JMP	UNKNOWN_LINE_TYPE
5$:	CMPW	#TOKEN_LEFT_PARREN,R0
	BNEQ	6$
	INCL	PARREN_LEVEL
	BRB	4$
6$:	CMPW	#TOKEN_RIGHT_PARREN,R0
	BNEQ	4$
	DECL	PARREN_LEVEL
	BGTR	4$
GET_CHR_COMMA:
	CALLG	NULL,GET_NON_BLANK_CHR	;GET THE NEXT CHR TO SEE IF IT IS A COMMA
	CMPB	#^A/!/,R0
	BNEQ	1$
	MOVL	R10,R9
	BRB	GET_CHR_COMMA
1$:	CMPB	#^A/,/,R0		;WELL IS IT
	BNEQ	NO_CHR_LEN_SPEC		;NOPE-CONTINUE
	INCL	R9			;BUMP POINTERS
	MOVL	#TOKEN_COMMA,R0		;AND INSERT TOKEN IN QUEUE
	CALLG	NULL,INSERT_SIMPLE_TOKEN
NO_CHR_LEN_SPEC:
	PUSHR	#^M<R9,R10,R11>		;SAVE REGESTERS FOR POSSABLE BACKUP
;	SEE WHERE WE ARE-SEE IF WORTH CHECKING FOR FUNCTION
	CMPL	#1,PROGRAM_LEVEL
	BGEQ	100$
	JMP	NO_CHR_FUNC_CHECK	;TO LATE-CAN'T BE FUNCTION
100$:
	.MACRO	CKF	LET,?AAA,?BBB,?CCC
CCC:	CALLG	NULL,GET_NON_BLANK_CHR
	CMPB	#^A/!/,R0
	BNEQ	BBB
	MOVL	R10,R9
	BRB	CCC
BBB:	CMPB	#^A/'LET'/,R0
	BEQL	AAA
	BRW	NO_CHR_FUNC_CHECK
AAA:
	INCL	R9
	.ENDM
	CKF	<F>			;SEE IF THE KEY WORD "FUNCTION" FOLLOW
	CKF	<U>
	CKF	<N>
	CKF	<C>
	CKF	<T>
	CKF	<I>
	CKF	<O>
	CKF	<N>
	MOVL	#TOKEN_FUNCTION,R0
	CALLG	NULL,INSERT_SIMPLE_TOKEN	;INSERT TOKEN FOR FUNCTION
	CALLG	NOIO_ARG,SCANNER		;MUST BE IDENTIFIER FOR FUNNCTION NAME
	CMPW	#TOKEN_IDENTIFIER,R0
	BEQL	200$
	JMP	RECOVER_NO_CHR_FUNCTION		;NOT AN IDENTIFIER-RETRACE
200$:	CALLG	NOIO_ARG,SCANNER		;COULD BE ANY OF FOLLOWES AND BE CORRECT
						;END OF LINE
						;LENGTH SPEC
						;LEFT PARREN
	CMPW	#TOKEN_END_OF_LINE,R0		;WAS IT A SIMPLE FUNCTION
	BNEQ	300$
	JMP	DONE_CHR_FUNCTION		;YES-NO ARGUMENTS
300$:	CMPW	#TOKEN_LEFT_PARREN,R0		;GO TO ARGUMENT LIST-NO LEN
	BNEQ	400$
	JMP	GET_CHR_ARG_LIST
400$:	CMPW	#TOKEN_ASTERISK,R0		;START OF LENGTH ?
	BEQL	GET_CHR_LEN
	CMPW	#TOKEN_PASSED_LENGTH,R0		;*(*)
	BNEQ	500$
	JMP	CHK_CHR_FUNC_ARG_LIST
500$:	CMPW	#TOKEN_ONE_BYTE,R0		;*1
	BNEQ	600$
	JMP	CHK_CHR_FUNC_ARG_LIST
600$:	CMPW	#TOKEN_TWO_BYTES,R0		;*2
	BEQL	CHK_CHR_FUNC_ARG_LIST
	CMPW	#TOKEN_FOUR_BYTES,R0		;*4
	BEQL	CHK_CHR_FUNC_ARG_LIST
	CMPW	#TOKEN_OCTAL_BYTES,R0		;*8
	BEQL	CHK_CHR_FUNC_ARG_LIST
	CMPW	#TOKEN_HEX_BYTES,R0		;*16
	BEQL	CHK_CHR_FUNC_ARG_LIST
	JMP	RECOVER_NO_CHR_FUNCTION
; POTENTIAL CHARACTER FUNCTION HAS ITS OWN LENGTH SPEC NOT FULLY IN-GET IT
GET_CHR_LEN:
	CALLG	NOIO_ARG,SCANNER		;GET NEXT TOKEN
	CMPW	#TOKEN_NUMBER,R0		;IF NUMBER
	BEQL	CHK_CHR_FUNC_ARG_LIST
	CMPW	#TOKEN_IDENTIFIER,R0		;OR PARAMETER
	BEQL	CHK_CHR_FUNC_ARG_LIST
	CMPW	#TOKEN_LEFT_PARREN,R0		;COMPLEX ARG
	BEQL	1$
	JMP	UNKNOWN_LINE_TYPE		;BAD ERROR
1$:	MOVL	#1,PARREN_LEVEL
;	SCAN ARGUEMNT LIST UNTILL ZERO PARREN LEVEL FOUND
4$:	CALLG	NOIO_ARG,SCANNER
	CMPW	#TOKEN_END_OF_LINE,R0
	BNEQ	5$
	JMP	UNKNOWN_LINE_TYPE
5$:	CMPW	#TOKEN_LEFT_PARREN,R0
	BNEQ	6$
	INCL	PARREN_LEVEL
	BRB	4$
6$:	CMPW	#TOKEN_RIGHT_PARREN,R0
	BNEQ	4$
	DECL	PARREN_LEVEL
	BGTR	4$
;	NOW TO CHECK TO SEE IF ARGUMENT LIST EXISTS
CHK_CHR_FUNC_ARG_LIST:
	CALLG	NOIO_ARG,SCANNER
	CMPW	#TOKEN_END_OF_LINE,R0	;IF END OF LINE-WE ARE DONE
	BEQL	DONE_CHR_FUNCTION	;DO CLOSE OUT FOR FUNCTION
	CMPW	#TOKEN_LEFT_PARREN,R0
	BEQL	GET_CHR_ARG_LIST	;YES-ARGUEMNT LIST EXISTS
	JMP	RECOVER_NO_CHR_FUNCTION	;NO-THIS NOT A FUNCTION-RETRY AS TYPE
GET_CHR_ARG_LIST:
	MOVL	#1,PARREN_LEVEL		;SCANN ARGUEMNT LIST UNTILL
4$:	CALLG	NOIO_ARG,SCANNER	;CLOSEING PARREN FOUND
	CMPW	#TOKEN_END_OF_LINE,R0
	BNEQ	5$
	JMP	UNKNOWN_LINE_TYPE
5$:	CMPW	#TOKEN_LEFT_PARREN,R0
	BNEQ	6$
	INCL	PARREN_LEVEL
	BRB	4$
6$:	CMPW	#TOKEN_RIGHT_PARREN,R0
	BNEQ	4$
	DECL	PARREN_LEVEL
	BGTR	4$
;	END  OF ARGUMENT LIST-NOTHING SHOULD FOLLOW
	CALLG	NOIO_ARG,SCANNER
	CMPW	#TOKEN_END_OF_LINE,R0
	BEQL	DONE_CHR_FUNCTION
	JMP	RECOVER_NO_CHR_FUNCTION		;LAST MINUTE ERROR-NOT A FUNCTION
DONE_CHR_FUNCTION:
	MOVL	#2,PROGRAM_LEVEL		;SET PROGRAM LEVEL
	MOVAL	EVAL_CHARACTER_FUNCTION,R6	;SET UP EVALUATION POINTERS
	CVTWL	2(R6),EVALUATION_ROUTINE_TOKEN
	CVTWL	(R6),R7
	MOVC5	R7,@4(R6),#0,#31,LINE_MNEMONIC
	RET
;
;	TREAT AS CHARACTER TYPE DECLARATION
;
RECOVER_NO_CHR_FUNCTION:
;	RECOVER FROM TRIAL AS A POSSABLE FUNCTION
1$:	REMQUE	@LINE_TOKEN_QUEUE+4,R6	;TAKE OFF LAST TOKEN
	BVC	2$			;BAD ERROR-SHOULD NOT GET HERE
	JMP	RESET_ARITH
2$:	CVTWL	12(R6),R7		;GET TOKENTYPE
	MOVL	R6,ARG2			;SET UP TO FREE
	CVTWL	14(R6),ARG1
	CALLG	ARG,FREE	;FREE TOKEN TO HEAP
3$:	CMPW	#TOKEN_FUNCTION,R7	;WAS IT LAST TO BE EXTRACTED
	BNEQ	1$			;NO
;
;	HAVE BACKED UP ALL CHANGES MADE UNDER ASSUMPTION OF FUNCTION
;	NOW TO TRY AS TYPE DECLARATOR
NO_CHR_FUNC_CHECK:
	POPR	#^M<R9,R10,R11>
;	LOOP FOR EACH IDENTIFIER
CHR_VAR:CALLG	NOIO_ARG,SCANNER
	CMPW	#TOKEN_END_OF_LINE,R0	;ARE WE DONE
	BNEQ	100$
	JMP	CHAR_STATEMENT_DONE
100$:	CMPW	#TOKEN_COMMA,R0		;COMMA
	BEQL	CHR_VAR
	CMPW	#TOKEN_IDENTIFIER,R0	;GOT NEXT VARIABLE TYPED
	BEQL	SCAN_CHAR_TYPE		;YES
	JMP	RESET_ARITH		;NO-BAD ERROR-RETRY AS ARITH
SCAN_CHAR_TYPE:
;	SEE IF ARRAY DECLARATION FOUND
	CALLG	NULL,GET_NON_BLANK_CHR
	CMPB	#^A/!/,R0
	BNEQ	1$
	MOVL	R10,R9
	BRB	SCAN_CHAR_TYPE
1$:	TSTB	R0		;CHECK FOR END OF LINE
	BNEQ	101$
	JMP	CHAR_STATEMENT_DONE
101$:	CMPB	#^A/,/,R0	;COMMA
	BEQL	CHR_VAR
	CMPB	#^A/(/,R0	;SEE IF ARRAY DECLARATOR
	BNEQ	CHK_CHR_ID_LEN	;NO-GO CHECK IF LENGTH
;
;	ARRAY DECLARATION INPUT LOOP
;
	INCL	R9
	MOVL	#TOKEN_LEFT_PARREN,R0
	CALLG	NULL,INSERT_SIMPLE_TOKEN
	MOVL	#1,PARREN_LEVEL		;SCANN ARGUEMNT LIST UNTILL
4$:	CALLG	NOIO_ARG,SCANNER	;CLOSEING PARREN FOUND
	CMPW	#TOKEN_END_OF_LINE,R0
	BNEQ	5$
	JMP	UNKNOWN_LINE_TYPE
5$:	CMPW	#TOKEN_LEFT_PARREN,R0
	BNEQ	6$
	INCL	PARREN_LEVEL
	BRB	4$
6$:	CMPW	#TOKEN_RIGHT_PARREN,R0
	BNEQ	4$
	DECL	PARREN_LEVEL
	BGTR	4$
;	CHECK FOR PRESENCE OF LENGTH SPEC
;
7$:	CALLG	NULL,GET_NON_BLANK_CHR
	CMPB	#^A/!/,R0
	BNEQ	8$
	MOVL	R10,R9
	BRB	7$
8$:	TSTB	R0	;END OF LINE
	BNEQ	108$
	JMP	CHAR_STATEMENT_DONE
108$:	CMPB	#^A/,/,R0
	BNEQ	CHK_CHR_ID_LEN
	JMP	CHR_VAR
CHK_CHR_ID_LEN:
	CMPB	#^A/*/,R0	;LENGTH SPEC ???
	BEQL	100$
	JMP	CHR_DATA_LOAD_CHK	;GO SEE IF DATA LOAD
100$:	CALLG	NOIO_ARG,SCANNER
	CMPW	#TOKEN_ASTERISK,R0		;START OF LENGTH ?
	BEQL	GET_CHR_ID_LEN
	CMPW	#TOKEN_PASSED_LENGTH,R0		;*(*)
	BNEQ	1000$
	JMP	CHK_CHR_ID_DATA
1000$:	CMPW	#TOKEN_ONE_BYTE,R0		;*1
	BNEQ	2000$
	JMP	CHK_CHR_ID_DATA
2000$:	CMPW	#TOKEN_TWO_BYTES,R0		;*2
	BEQL	CHK_CHR_ID_DATA
	CMPW	#TOKEN_FOUR_BYTES,R0		;*4
	BEQL	CHK_CHR_ID_DATA
	CMPW	#TOKEN_OCTAL_BYTES,R0		;*8
	BNEQ	200$
	JMP	CHK_CHR_ID_DATA
200$:	CMPW	#TOKEN_HEX_BYTES,R0		;*16
	BEQL	CHK_CHR_ID_DATA
	JMP	RECOVER_NO_CHR_FUNCTION
; POTENTIAL CHARACTER ID HAS ITS OWN LENGTH SPEC NOT FULLY IN-GET IT
GET_CHR_ID_LEN:
	CALLG	NOIO_ARG,SCANNER		;GET NEXT TOKEN
	CMPW	#TOKEN_NUMBER,R0		;IF NUMBER
	BEQL	CHK_CHR_ID_DATA
	CMPW	#TOKEN_IDENTIFIER,R0		;OR PARAMETER
	BEQL	CHK_CHR_ID_DATA
	CMPW	#TOKEN_LEFT_PARREN,R0		;COMPLEX ARG
	BEQL	1$
	JMP	UNKNOWN_LINE_TYPE		;BAD ERROR
1$:	MOVL	#1,PARREN_LEVEL
;	SCAN ARGUEMNT LIST UNTILL ZERO PARREN LEVEL FOUND
4$:	CALLG	NOIO_ARG,SCANNER
	CMPW	#TOKEN_END_OF_LINE,R0
	BNEQ	5$
	JMP	UNKNOWN_LINE_TYPE
5$:	CMPW	#TOKEN_LEFT_PARREN,R0
	BNEQ	6$
	INCL	PARREN_LEVEL
	BRB	4$
6$:	CMPW	#TOKEN_RIGHT_PARREN,R0
	BNEQ	4$
	DECL	PARREN_LEVEL
	BGTR	4$
;	CHECK TO SEE IF DATA ENTRY HERE
CHK_CHR_ID_DATA:
	CALLG	NULL,GET_NON_BLANK_CHR
	CMPB	#^A/!/,R0
	BNEQ	1$
	MOVL	R10,R9
	BRB	CHK_CHR_ID_DATA
1$:	TSTB	R0
	BEQL	CHAR_STATEMENT_DONE
	CMPB	#^A/,/,R0
	BNEQ	CHR_DATA_LOAD_CHK
	JMP	CHR_VAR
CHR_DATA_LOAD_CHK:
	CMPB	#^A?/?,R0
	BEQL	1$
	JMP	RESET_ARITH
1$:	INCL	R9
	MOVL	#TOKEN_SLASH,R0
	CALLG	NULL,INSERT_SIMPLE_TOKEN
;	LOOP-TAKEING IN DATA TOKENS UNTILL TERMINATEING "/"
2$:	CALLG	NOIO_ARG,SCANNER
	CMPW	#TOKEN_END_OF_LINE,R0
	BNEQ	3$
	JMP	RESET_ARITH
3$:	CMPW	#TOKEN_SLASH,R0
	BNEQ	2$
	JMP	CHR_VAR	;REPEAT FOR NEXT VAR
CHAR_STATEMENT_DONE:
	MOVL	#4,PROGRAM_LEVEL
	RET
	.PAGE
	.SUBTITLE	COMPLEX/COMPLEX FUNCTION (*8,*16)
;
;	HAVE KEY WORD COMPLEX COULD BE FUNCTION OR TYPE EITHER
;	COMPLEX OR DOUBLE COMPLEX
DC_COMPLEX:
	CMPL	#4,PROGRAM_LEVEL	;OK FOR THIS TYPE OF STATMENT??
	BGEQ	1$
	JMP	RESET_ARITH		;NO-RESET AS ARITHMETIC
1$:	CALLG	NULL,GET_NON_BLANK_CHR	;SEE IF LENGTH SPECIFIED
	CMPB	#^A/!/,R0
	BNEQ	2$
	MOVL	R10,R9
	BRB	1$
2$:	CMPB	#^A/*/,R0
	BNEQ	120$		;NO LENGTH SPEC
	CALLG	NOIO_ARG,SCANNER	;GET LENGTH SPEC
	CMPW	#TOKEN_OCTAL_BYTES,R0
	BEQL	120$
	MOVAL	EVAL_DOUBLE_COMPLEX,R6
	BRB	21$
120$:	MOVAL	EVAL_COMPLEX,R6
21$:	CVTWL	2(R6),EVALUATION_ROUTINE_TOKEN
	CVTWL	(R6),R7
	MOVC5	R7,@4(R6),#0,#31,LINE_MNEMONIC
;
;	SEE IF FUNCTION IS APPROPRIATE AT THIS LOCATION
;
	CMPL	#1,PROGRAM_LEVEL
	BGEQ	212$
	JMP	NOT_CMPLX_FUNCTION
212$:	PUSHR	#^M<R9,R10,R11>	;SAVE SCANNER POINTERS FOR BACKUP
	.MACRO	CKF	LET,?AAA,?BBB,?CCC
CCC:	CALLG	NULL,GET_NON_BLANK_CHR
	CMPB	#^A/!/,R0
	BNEQ	BBB
	MOVL	R10,R9
	BRB	CCC
BBB:	CMPB	#^A/'LET'/,R0
	BEQL	AAA
	BRW	SIMPLE_NOT_CMPLX_FUNCTION
AAA:
	INCL	R9
	.ENDM
	CKF	<F>
	CKF	<U>
	CKF	<N>
	CKF	<C>
	CKF	<T>
	CKF	<I>
	CKF	<O>
	CKF	<N>
;	POSSABLY A FUNCTION BUT NOT CONCLUSIVE
	MOVL	#TOKEN_FUNCTION,R0
	CALLG	NULL,INSERT_SIMPLE_TOKEN
	CALLG	NOIO_ARG,SCANNER	;GET THE NEXT IDENTIFIER
	CMPL	#TOKEN_IDENTIFIER,R0
	BEQL	3$
	JMP	RESTORE_SIMPLE_NOT_CMPLX_FN
3$:	CALLG	NOIO_ARG,SCANNER	;GET E.O.L.,LENGTH SPEC,OR LEFT PARREN
	CMPW	#TOKEN_COMMA,R0		;SEE IF FUNCTION IS PART OF NAME
	BNEQ	103$
	JMP	RESTORE_SIMPLE_NOT_CMPLX_FN
103$:	CMPW	#TOKEN_OCTAL_BYTES,R0
	BEQL	3$
	CMPW	#TOKEN_HEX_BYTES,R0
	BEQL	3$
	CMPW	#TOKEN_END_OF_LINE,R0
	BNEQ	4$
	;SIMPLE FUNCTION WITH NO ARGUMENTS
	BRW	9$
4$:	CMPW	#TOKEN_LEFT_PARREN,R0	;START OF ARGUMENT LIST
	BEQL	5$
;	ANYTHING ELSE IS AN ERROR-ASSUME SIMPLE TYPE
	JMP	RESTORE_SIMPLE_NOT_CMPLX_FN
5$:	MOVL	#1,PARREN_LEVEL
;	SKIP THROUGH ARGUMENT LIST UNTILL TO ZERO LEVEL PARREN
6$:	CALLG	NOIO_ARG,SCANNER
	CMPW	#TOKEN_END_OF_LINE,R0
	BNEQ	7$
	JMP	RESTORE_SIMPLE_NOT_CMPLX_FN
7$:	CMPW	#TOKEN_LEFT_PARREN,R0
	BNEQ	8$
	INCL	PARREN_LEVEL
	BRB	6$
8$:	CMPW	#TOKEN_RIGHT_PARREN,R0
	BNEQ	6$
	DECL	PARREN_LEVEL
	BGTR	6$
;	NOW BACK AT ZERO PARREN LEVEL-MUST BE NOTHING MORE ON LINE
	CALLG	NOIO_ARG,SCANNER
	CMPW	#TOKEN_END_OF_LINE,R0
	BEQL	9$
;	FOUND SOMETHING ELSE ON LINE-AN ERROR
	JMP	RESTORE_SIMPLE_NOT_CMPLX_FN
9$:	MOVL	#2,PROGRAM_LEVEL
;	RESET EVALUATION ROUTINE AND MENMONIC
	CMPW	#TOKEN_EVAL_COMPLEX,EVALUATION_ROUTINE_TOKEN
	BNEQ	11$
	MOVAL	EVAL_COMPLEX_FUNCTION,R6
	BRW	20$
11$:	MOVAL	EVAL_DOUBLE_CPLX_FUNCTION,R6
20$:	CVTWL	2(R6),EVALUATION_ROUTINE_TOKEN
	CVTWL	(R6),R7
	MOVC5	R7,@4(R6),#0,#31,LINE_MNEMONIC
	RET
RESTORE_SIMPLE_NOT_CMPLX_FN:
;	POP OFF END OF LINE TOKEN QUEUE UNTILL ONLY FIRST ELEMENT LEFT
	REMQUE	@LINE_TOKEN_QUEUE+4,R6
	BVC	1$
	JMP	RESET_ARITH
1$: 	CVTWL	12(R6),R7
    	CVTWL	14(R6),ARG1
	MOVL	R6,ARG2
	CALLG	ARG,FREE
2$:	CMPW	#TOKEN_FUNCTION,R0
	BNEQ	RESTORE_SIMPLE_NOT_CMPLX_FN
SIMPLE_NOT_CMPLX_FUNCTION:
	POPR	#^M<R9,R10,R11>
NOT_CMPLX_FUNCTION:
	CLRL	PARREN_LEVEL
;	LOOP THROUGH TOKENS-LOOK FOR NO ZERO LEVEL "="
11$:	CALLG	NOIO_ARG,SCANNER
	CMPW	#TOKEN_END_OF_LINE,R0
	BNEQ	1$
	MOVL	#4,PROGRAM_LEVEL
	RET
1$:	CMPW	#TOKEN_LEFT_PARREN,R0
	BNEQ	2$
	INCL	PARREN_LEVEL
	BRB	11$
2$:	CMPW	#TOKEN_RIGHT_PARREN,R0
	BNEQ	3$
	DECL	PARREN_LEVEL
	BRB	11$
3$:	TSTL	PARREN_LEVEL
	BGTR	11$
	CMPW	#TOKEN_EQUAL,R0
	BNEQ	11$
	JMP	RESET_ARITH
	.PAGE
	.SUBTITLE	REAL/REAL FUNCTION (*4,*8,*16)
;
;	HAVE KEY WORD COMPLEX COULD BE FUNCTION OR TYPE EITHER
;	REAL,DOUBLE PRECISION,QUAD
DC_REAL:
	CMPL	#4,PROGRAM_LEVEL	;OK FOR THIS TYPE OF STATMENT??
	BGEQ	1$
	JMP	RESET_ARITH		;NO-RESET AS ARITHMETIC
1$:	CALLG	NULL,GET_NON_BLANK_CHR	;SEE IF LENGTH SPECIFIED
	CMPB	#^A/!/,R0
	BNEQ	2$
	MOVL	R10,R9
	BRB	1$
2$:	CMPB	#^A/*/,R0
	BNEQ	120$		;NO LENGTH SPEC
	CALLG	NOIO_ARG,SCANNER	;GET LENGTH SPEC
	CMPW	#TOKEN_HEX_BYTES,R0
	BNEQ	22$
	MOVAL	EVAL_QUAD,R6
	BRB	21$
22$:	CMPW	#TOKEN_OCTAL_BYTES,R0
	BNEQ	120$
	MOVAL	EVAL_DOUBLE_PRECISION,R6
	BRB	21$
120$:	MOVAL	EVAL_REAL,R6
21$:	CVTWL	2(R6),EVALUATION_ROUTINE_TOKEN
	CVTWL	(R6),R7
	MOVC5	R7,@4(R6),#0,#31,LINE_MNEMONIC
;
;	SEE IF FUNCTION IS APPROPRIATE AT THIS LOCATION
;
	CMPL	#1,PROGRAM_LEVEL
	BGEQ	121$
	JMP	NOT_REAL_FUNCTION
121$:	PUSHR	#^M<R9,R10,R11>	;SAVE SCANNER POINTERS FOR BACKUP
	.MACRO	CKF	LET,?AAA,?BBB,?CCC
CCC:	CALLG	NULL,GET_NON_BLANK_CHR
	CMPB	#^A/!/,R0
	BNEQ	BBB
	MOVL	R10,R9
	BRB	CCC
BBB:	CMPB	#^A/'LET'/,R0
	BEQL	AAA
	BRW	SIMPLE_NOT_REAL_FUNCTION
AAA:
	INCL	R9
	.ENDM
	CKF	<F>
	CKF	<U>
	CKF	<N>
	CKF	<C>
	CKF	<T>
	CKF	<I>
	CKF	<O>
	CKF	<N>
;	POSSABLY A FUNCTION BUT NOT CONCLUSIVE
	MOVL	#TOKEN_FUNCTION,R0
	CALLG	NULL,INSERT_SIMPLE_TOKEN
	CALLG	NOIO_ARG,SCANNER	;GET THE NEXT IDENTIFIER
	CMPL	#TOKEN_IDENTIFIER,R0
	BEQL	3$
	JMP	RESTORE_SIMPLE_NOT_REAL_FN
3$:	CALLG	NOIO_ARG,SCANNER	;GET E.O.L.,LENGTH SPEC,OR LEFT PARREN
	CMPW	#TOKEN_COMMA,R0		;SEE IF FUNCTION IS PART OF NAME
	BNEQ	103$
	JMP	RESTORE_SIMPLE_NOT_REAL_FN
103$:	CMPW	#TOKEN_FOUR_BYTES,R0
	BEQL	3$
	CMPW	#TOKEN_OCTAL_BYTES,R0
	BEQL	3$
	CMPW	#TOKEN_HEX_BYTES,R0
	BEQL	3$
	CMPW	#TOKEN_END_OF_LINE,R0
	BNEQ	4$
	;SIMPLE FUNCTION WITH NO ARGUMENTS
	BRW	9$
4$:	CMPW	#TOKEN_LEFT_PARREN,R0	;START OF ARGUMENT LIST
	BEQL	5$
;	ANYTHING ELSE IS AN ERROR-ASSUME SIMPLE TYPE
	JMP	RESTORE_SIMPLE_NOT_REAL_FN
5$:	MOVL	#1,PARREN_LEVEL
;	SKIP THROUGH ARGUMENT LIST UNTILL TO ZERO LEVEL PARREN
6$:	CALLG	NOIO_ARG,SCANNER
	CMPW	#TOKEN_END_OF_LINE,R0
	BNEQ	7$
	JMP	RESTORE_SIMPLE_NOT_REAL_FN
7$:	CMPW	#TOKEN_LEFT_PARREN,R0
	BNEQ	8$
	INCL	PARREN_LEVEL
	BRB	6$
8$:	CMPW	#TOKEN_RIGHT_PARREN,R0
	BNEQ	6$
	DECL	PARREN_LEVEL
	BGTR	6$
;	NOW BACK AT ZERO PARREN LEVEL-MUST BE NOTHING MORE ON LINE
	CALLG	NOIO_ARG,SCANNER
	CMPW	#TOKEN_END_OF_LINE,R0
	BEQL	9$
;	FOUND SOMETHING ELSE ON LINE-AN ERROR
	JMP	RESTORE_SIMPLE_NOT_REAL_FN
9$:	MOVL	#2,PROGRAM_LEVEL
;	RESET EVALUATION ROUTINE AND MENMONIC
	CMPW	#TOKEN_EVAL_REAL,EVALUATION_ROUTINE_TOKEN
	BNEQ	11$
	MOVAL	EVAL_REAL_FUNCTION,R6
	BRW	20$
11$:	CMPW	#TOKEN_EVAL_DOUBLE_PRECISION,EVALUATION_ROUTINE_TOKEN
	BNEQ	12$
	MOVAL	EVAL_DOUBLE_PRECISION_FN,R6
	BRB	20$
12$:	MOVAL	EVAL_QUAD_FUNCTION,R6
20$:	CVTWL	2(R6),EVALUATION_ROUTINE_TOKEN
	CVTWL	(R6),R7
	MOVC5	R7,@4(R6),#0,#31,LINE_MNEMONIC
	RET
RESTORE_SIMPLE_NOT_REAL_FN:
;	POP OFF END OF LINE TOKEN QUEUE UNTILL ONLY FIRST ELEMENT LEFT
	REMQUE	@LINE_TOKEN_QUEUE+4,R6
	BVC	1$
	JMP	RESET_ARITH
1$: 	CVTWL	12(R6),R7
    	CVTWL	14(R6),ARG1
	MOVL	R6,ARG2
	CALLG	ARG,FREE
2$:	CMPW	#TOKEN_FUNCTION,R0
	BNEQ	RESTORE_SIMPLE_NOT_REAL_FN
SIMPLE_NOT_REAL_FUNCTION:
	POPR	#^M<R9,R10,R11>
NOT_REAL_FUNCTION:
	CLRL	PARREN_LEVEL
;	LOOP THROUGH TOKENS-LOOK FOR NO ZERO LEVEL "="
11$:	CALLG	NOIO_ARG,SCANNER
	CMPW	#TOKEN_END_OF_LINE,R0
	BNEQ	1$
	MOVL	#4,PROGRAM_LEVEL
	RET
1$:	CMPW	#TOKEN_LEFT_PARREN,R0
	BNEQ	2$
	INCL	PARREN_LEVEL
	BRB	11$
2$:	CMPW	#TOKEN_RIGHT_PARREN,R0
	BNEQ	3$
	DECL	PARREN_LEVEL
	BRB	11$
3$:	TSTL	PARREN_LEVEL
	BGTR	11$
	CMPW	#TOKEN_EQUAL,R0
	BNEQ	11$
	JMP	RESET_ARITH
	.PAGE
	.SUBTITLE	GET_CHARACTER ROUTINES
;
;	CALL	GET_NON_BLANK_CHR
;
;	RETURNS IN R0 THE FIRST NON_BLANK CHARACTER FOUND IN SOURCE LINE
;	OR NULL IF OUT OF CHARACTERS
;
	.ENTRY	GET_NON_BLANK_CHR,0
1$:	CALLG	NULL,GET_CHR	;ASK FOR NEXT CHAR
	CMPB	#9,R0		;TAB IS A BLANK
	BEQL	3$
	CMPB	#^A/ /,R0
	BNEQ	2$
3$:	INCL	R9	;BUMP POINTER TO CONTINUE SEARCH
	BRB	1$
2$:	RET
;
;	CALL	GET_CHR
;
;	RETURNS IN R0 THE NEXT CHR
	.ENTRY	GET_CHR,^M<>
	TSTB	(R9)		;END OF LINE-SHORT OF COL 72
	BEQL	5$		;YES-GO SEE IF CONTINUATION LINE
	CMPL	R9,R10		;DO WE ADVANCE TO NEXT LINE
	BLSSU	1$		;NO-JUST GET NEXT CHR
5$:	TSTL	136(R11)	;IS THERE A NEXT LINE ??
	BNEQ	2$		;YES IT GOES ON
	CLRL	R0		;NO-JUST RETURN A NULL
	RET
2$:	ADDL2	#136,R11	;UPDATE POINTER TO NEXT LINE
	ADDL3	#4,R11,R9	;POINTER TO START OF LINE
	ADDL3	#72,R9,R10	;POINT TO COL 73
	LOCC	#9,#6,(R9)	;SET UP POINTER TO START OF
				;STATEMENT FIELD-CHECK ON TAB CONVENTION
	BEQL	3$		;NO TAB
	CMPB	#^A/0/,1(R1)	;SEE IF TAB TO 6 OR 7
	BGTR	4$		;NO
	CMPB	#^A/9/,1(R1)	;BETWEEN 0-9??
	BLSS	4$		;NO
	INCL	R1		;YES-IS NUMBER-SKIP 1
4$:	ADDL3	#1,R1,R9	;SET START POINTER
	BRB	1$		;GO GET CHR
3$:	MOVL	R1,R9		;R1 POINTS TO COLL 7-PLACE TO START
1$:	MOVB	(R9),R0		;GET NEXT CHR
	RET
	.PAGE
	.SUBTITLE	GENERAL TOKEN SCANNER
;
;	CALL	SCANNER(IOFLAG)
;
;	SCANNER FOR THE NEXT TOKEN IN SOURCE LINE
;	FINDS THE NEXT TOKEN IN THE SOURCE LINE, APPENDS IT TO THE END
;	OF THE LINE TOKEN QUEUE AND RETURNS TO THE CALLING ROUTINE
;	IN R0 THE TYPE OF TOKEN FOUND.
;
;
;	INPUTS AND OUTPUTS INCLUDE
;	R11	POINTS TO START OF CURRENT SOURCE LINE
;	R10	POINTS TO COLUMN 73 OF CURRENT SOURCE LINE
;	R9	POINTS TO LOCATION IN CURRENT SOURCE LINE
;		TO START SCAN FOR NEXT TOKEN
;	IOFLAG	=0	DO NOT CHECK IDENTIFIER AS IO KEY WORD
;		<>0	CHECK IF IDENTIFYER IS IO KEY WORD
;
	.ENTRY	SCANNER,^M<R2,R3,R4,R5,R6,R7,R8>
RE_SCANNER:
12$:	CALLG	NULL,GET_NON_BLANK_CHR	;GET THE FIRST CHR OF NEXT TOKEN
	CMPB	#^A/!/,R0
	BNEQ	101$
	MOVL	R10,R9
	BRB	12$
101$:	TSTB	R0			;CHECK FOR OUT OF CURRENT LINE
	BNEQ	1$
	MOVL	#TOKEN_END_OF_LINE,R0	;TELL CALLER-FINI
	RET
1$:
;	INITIAL ACTION DEPENDS ON TYPE OF CHARACTER
;	A LETTER IS AN IDENTIFIER
;	NUMBER IS START OF LABEL, NUMBER OR HOLERTITH/RAD50 STRING
;	OTHER SYMBOL-QUOTED STRING,LOGICAL OPERATOR,SINGLE OR
;	MULTIPLE CHR STRING
	CMPB	#^A/A/,R0	;IS IT A CHARCTER
	BGTR	11$		;NO
	CMPB	#^A/Z/,R0	;OTHER END OF ALPHABET
	BLSS	11$
;	CHARACTER IS A LETTER-GO INPUT IDENTIFIER
	JMP	SCAN_ID
11$:	CMPB	#^A/0/,R0	;IS IT A NUMBER
	BGTR	2$		;NO
	CMPB	#^A/9/,R0
	BLSS	2$
;	CHARACTER IS A NUMBER
	JMP	SCAN_NUMBER
2$:	CMPB	#^A/'/,R0	;IS IT A QUOTED STRING
	BNEQ	3$
	JMP	SCAN_QUOTED_STRING
3$:	CMPB	#^A/*/,R0	;COULD BE A MULTIPLE CHR STARTING WITH *
	BNEQ	4$
	JMP	SCAN_STAR
4$:	CMPB	#^A?/?,R0	;COULD BE CONCATONCATION  SYMBOL
	BNEQ	5$
	JMP	SCAN_CONCATONATION
5$:	CMPB	#^A/./,R0	;COULD BE A FRACTIONAL NUMBER OR
				;LOGICAL OPERATOR
	BNEQ	6$
	JMP	SCAN_POINT
6$:	CMPB	#^A/!/,R0	;COMMENT INDICATOR
	BNEQ	7$
	MOVL	R10,R9		;FORCE NEXT LINE OF SOURCE
	JMP	RE_SCANNER		;AND CONTINUE FROM THE TOP
7$:	CMPB	#^A/"/,R0	;OLD FORM OF OCTAL
	BNEQ	8$
	JMP	SCAN_OLD_OCTAL
8$:	CMPB	#^A/%/,R0	;START OF BUILT IN FUNCTION
	BNEQ	SCAN_SINGLE_CHR
	JMP	SCAN_PERCENT
	.PAGE
	.SUBTITLE	SCAN SINGLE CHARACTER TERMINATOR
SCAN_SINGLE_CHR:
	MOVAL	SINGLE_CHARACTER_TABLE,R8
	MOVL	#NUMBER_OF_SINGLE_CHARACTERS,R7
7$:	CMPB	R0,@4(R8)	;IS IT THIS TOKEN
	BEQL	8$
	ADDL2	#8,R8		;ADVANCE TO NEXT CHR
	SOBGTR	R7,7$
;	SHOULD NOT GET HERE - UNKNOWN CHARACTER FOUND
	PUSHAL	UNKNOWN_CHR_ERR
	CALLS	#1,G^LIB$PUT_OUTPUT
	PUSHAL	UNKNOWN_CHR_ERR
	CALLS	#1,ERROR_LINE
	MOVL	#TOKEN_UNKNOWN_CHR,R0
	BRB	9$
8$:	CVTWL	2(R8),R0	;GET TOKEN OF CHR
9$:	INCL	R9
	JMP	ADD_SIMPLE_TOKEN
	.PAGE
	.SUBTITLE	SCAN %-BUILT IN FUNCTION
SCAN_PERCENT:
	INCL	R9	;BUMP SCANNER POINTERS
	PUSHR	#^M<R9,R10,R11>	;SAVE FOR BACK UP
1$:	CALLG	NULL,GET_NON_BLANK_CHR
	CMPB	#^A/!/,R0
	BNEQ	2$
	MOVL	R10,R9
	BRB	1$
2$:	CMPB	#^A/D/,R0	;DESCRIPTER ?
	BNEQ	3$
	JMP	100$		;GOOD START FOR IT
3$:	CMPB	#^A/L/,R0	;LOC?
	BNEQ	4$
	JMP	200$
4$:	CMPB	#^A/R/,R0	;REF?
	BNEQ	5$
	JMP	300$
5$:	CMPB	#^A/V/,R0	;VAL?
	BNEQ	6$
	JMP	400$
6$:	JMP	1000$		;NOPE JUST %
;	CONFERM OR DENY %DESCR(
100$:	INCL	R9
101$:	CALLG	NULL,GET_NON_BLANK_CHR
	CMPB	#^A/!/,R0
	BNEQ	102$
	MOVL	R10,R9
	BRB	101$
102$:	CMPB	#^A/E/,R0
	BEQL	112$
	JMP	1000$
112$:	INCL	R9
103$:	CALLG	NULL,GET_NON_BLANK_CHR
	CMPB	#^A/!/,R0
	BNEQ	104$
	MOVL	R10,R9
	BRB	103$
104$:	CMPB	#^A/S/,R0
	BEQL	114$
	JMP	1000$
114$:	INCL	R9
105$:	CALLG	NULL,GET_NON_BLANK_CHR
	CMPB	#^A/!/,R0
	BNEQ	106$
	MOVL	R10,R9
	BRB	105$
106$:	CMPB	#^A/C/,R0
	BEQL	116$
	JMP	1000$
116$:	INCL	R9
107$:	CALLG	NULL,GET_NON_BLANK_CHR
	CMPB	#^A/!/,R0
	BNEQ	108$
	MOVL	R10,R9
	BRB	107$
108$:	CMPB	#^A/R/,R0
	BEQL	118$
	JMP	1000$
118$:	INCL	R9
109$:	CALLG	NULL,GET_NON_BLANK_CHR
	CMPB	#^A/!/,R0
	BNEQ	110$
	MOVL	R10,R9
	BRB	109$
110$:	CMPB	#^A/(/,R0
	BEQL	120$
	JMP	1000$
120$:	MOVL	#TOKEN_PCT_DESCR,R0
	JMP	ADD_SIMPLE_TOKEN
;	CONFERM OR DENY %LOC(
200$:	INCL	R9
201$:	CALLG	NULL,GET_NON_BLANK_CHR
	CMPB	#^A/!/,R0
	BNEQ	202$
	MOVL	R10,R9
	BRB	201$
202$:	CMPB	#^A/O/,R0
	BEQL	212$
	JMP	1000$
212$:	INCL	R9
203$:	CALLG	NULL,GET_NON_BLANK_CHR
	CMPB	#^A/!/,R0
	BNEQ	204$
	MOVL	R10,R9
	BRB	203$
204$:	CMPB	#^A/C/,R0
	BEQL	214$
	JMP	1000$
214$:	INCL	R9
209$:	CALLG	NULL,GET_NON_BLANK_CHR
	CMPB	#^A/!/,R0
	BNEQ	210$
	MOVL	R10,R9
	BRB	209$
210$:	CMPB	#^A/(/,R0
	BEQL	220$
	JMP	1000$
220$:	MOVL	#TOKEN_PCT_LOC,R0
	JMP	ADD_SIMPLE_TOKEN
;	CONFERM OR DENY %DESCR(
300$:	INCL	R9
301$:	CALLG	NULL,GET_NON_BLANK_CHR
	CMPB	#^A/!/,R0
	BNEQ	302$
	MOVL	R10,R9
	BRB	301$
302$:	CMPB	#^A/E/,R0
	BEQL	312$
	JMP	1000$
312$:	INCL	R9
303$:	CALLG	NULL,GET_NON_BLANK_CHR
	CMPB	#^A/!/,R0
	BNEQ	304$
	MOVL	R10,R9
	BRB	303$
304$:	CMPB	#^A/F/,R0
	BEQL	314$
	JMP	1000$
314$:	INCL	R9
309$:	CALLG	NULL,GET_NON_BLANK_CHR
	CMPB	#^A/!/,R0
	BNEQ	310$
	MOVL	R10,R9
	BRB	309$
310$:	CMPB	#^A/(/,R0
	BEQL	320$
	JMP	1000$
320$:	MOVL	#TOKEN_PCT_REF,R0
	JMP	ADD_SIMPLE_TOKEN
;	CONFERM OR DENY %DESCR(
400$:	INCL	R9
401$:	CALLG	NULL,GET_NON_BLANK_CHR
	CMPB	#^A/!/,R0
	BNEQ	402$
	MOVL	R10,R9
	BRB	401$
402$:	CMPB	#^A/A/,R0
	BEQL	412$
	JMP	1000$
412$:	INCL	R9
403$:	CALLG	NULL,GET_NON_BLANK_CHR
	CMPB	#^A/!/,R0
	BNEQ	404$
	MOVL	R10,R9
	BRB	403$
404$:	CMPB	#^A/L/,R0
	BEQL	414$
	JMP	1000$
414$:	INCL	R9
409$:	CALLG	NULL,GET_NON_BLANK_CHR
	CMPB	#^A/!/,R0
	BNEQ	410$
	MOVL	R10,R9
	BRB	409$
410$:	CMPB	#^A/(/,R0
	BEQL	420$
	JMP	1000$
420$:	MOVL	#TOKEN_PCT_VAL,R0
	JMP	ADD_SIMPLE_TOKEN
1000$:	POPR	#^M<R9,R10,R11>
	MOVL	#TOKEN_PERCENT,R0
	JMP	ADD_SIMPLE_TOKEN
	.PAGE
	.SUBTITLE	SCAN OLD FORM OF OCTAL
SCAN_OLD_OCTAL:
	MOVL	SP,R8
	CLRL	R7
1$:	INCL	R9
	MOVB	R0,-(SP)
	INCL	R7
3$:	CALLG	NULL,GET_NON_BLANK_CHR
	CMPB	#^A/!/,R0
	BNEQ	2$
	MOVL	R10,R9
	BRB	3$
2$:	CMPB	#^A/0/,R0
	BGTR	10$
	CMPB	#^A/9/,R0
	BGEQ	1$
10$:	MOVL	#TOKEN_OCTAL_NUMBER,R0
	MOVL	R7,R1
	JMP	ADD_COMPLEX_TOKEN
	.PAGE
	.SUBTITLE	SCAN QUOTED STRING
SCAN_QUOTED_STRING:
;	SAVE STRING BUT NOT THE ENCLOSEING QUOTES
	MOVL	SP,R8	;SAVE POINTER TO START OF STRING STORAGE
	CLRL	R7	;CHARACTER COUNTER
	INCL	R9	;NEXT CHR
1$:	CALLG	NULL,GET_CHR	;GET NEXT CHR
	CMPB	#^A/'/,R0	;IS IT CLOSE QUOTE
	BEQL	2$
3$:	MOVB	R0,-(SP)
	INCL	R9
	INCL	R7
	TSTB	R0		;FOUND END OF SOURCE WITH NO CLOSE QUOTE
	BEQL	4$
	BRB	1$
2$:	INCL	R9	;IS IT A DOUBLE QUOTE
	CALLG	NULL,GET_CHR
	CMPB	#^A/'/,R0
	BEQL	3$
4$:;	HAVE ON STACK STARTING AT ADDR POINTED TO BY R8 FOR R7 CHRS
;	QUOTED STRING FOR STORAGE
12$:	CALLG	NULL,GET_NON_BLANK_CHR	;CHECK FOR OCTAL OR HEX NUMBER
	CMPB	#^A/!/,R0
	BNEQ	11$
	MOVL	R10,R9
	BRB	12$
11$:	CMPB	#^A/O/,R0
	BNEQ	10$
	INCL	R9
	INCL	R7
	MOVB	R0,-(SP)
	MOVL	#TOKEN_OCTAL_NUMBER,R0
	BRB	14$
10$:	CMPB	#^A/X/,R0
	BNEQ	13$
	INCL	R9
	INCL	R7
	MOVB	R0,-(SP)
	MOVL	#TOKEN_HEX_NUMBER,R0
	BRB	14$
13$:	MOVL	#TOKEN_QUOTED_STRING,R0
14$:	MOVL	R7,R1
	JMP	ADD_COMPLEX_TOKEN
	.PAGE
	.SUBTITLE	SCAN ASTERISK
SCAN_STAR:
;	POSSABLE COMBINATIONS ARE
;	**
;	*(*)
;	*1
;	*2
;	*4
;	*8
;	*16
	INCL	R9	;FOR NEXT CHR
	PUSHR	#^M<R9,R10,R11>;JUST IN CASE WE HAVE TO BACK UP SAVE SCAN POINTERS
37$:	CALLG	NULL,GET_NON_BLANK_CHR
	CMPB	#^A/!/,R0
	BNEQ	36$
	MOVL	R10,R9
	BRB	37$
36$:	CMPB	#^A/*/,R0	;IS IT **
	BNEQ	1$
	MOVL	#TOKEN_EXPONENTIATION,R0
	INCL	R9		;BUMP POINTER-FORGET SAVED POINTERS
	JMP	ADD_SIMPLE_TOKEN
1$:	CMPW	#4,PROGRAM_LEVEL	;ARE THESE FORMS ALLOWED HERE
	BGEQ	2$			;NO
	MOVL	#TOKEN_ASTERISK,R0
	JMP	ADD_SIMPLE_TOKEN
2$:	CMPB	#^A/(/,R0	;*(*) ??
	BNEQ	5$
	INCL	R9	;NEXT CHR SHOULD BE '*'
35$:	CALLG	NULL,GET_NON_BLANK_CHR
	CMPB	#^A/!/,R0
	BNEQ	34$
	MOVL	R10,R9
	BRB	35$
34$:	CMPB	#^A/*/,R0
	BEQL	11$
	JMP	20$		;NO
11$:	INCL	R9
	CALLG	NULL,GET_NON_BLANK_CHR	;GET ')'
	CMPB	#^A/!/,R0
	BNEQ	32$
	MOVL	R10,R9
	BRB	11$
32$:	CMPB	#^A/)/,R0
	BEQL	12$
	JMP	20$
12$:	INCL	R9
	MOVL	#TOKEN_PASSED_LENGTH,R0
	JMP	ADD_SIMPLE_TOKEN
5$:	;CHECK FOR LENGTH SPECIFIERS
	CMPB	#^A/2/,R0	;LOOK FOR 2,4, OR 8
	BNEQ	6$
	MOVL	#TOKEN_TWO_BYTES,R0
	BRB	15$
6$:	CMPB	#^A/4/,R0
	BNEQ	7$
	MOVL	#TOKEN_FOUR_BYTES,R0
	BRB	15$
7$:	CMPB	#^A/8/,R0
	BNEQ	8$
	MOVL	#TOKEN_OCTAL_BYTES,R0
	BRB	15$
8$:	CMPB	#^A/1/,R0
	BNEQ	20$
;	COULD BE EITHER 1 BYTE OR 16 BYTES
	PUSHR	#^M<R9,R10,R11>
	INCL	R9
18$:	CALLG	NULL,GET_NON_BLANK_CHR
	CMPB	#^A/!/,R0
	BNEQ	17$
	MOVL	R10,R9
	BRB	18$
17$:	CMPB	#^A/6/,R0
	BNEQ	9$	;NO
	POPR	#^M<R0,R1,R2>	;JUST DUMP STACK
	MOVL	#TOKEN_HEX_BYTES,R0
	BRB	15$
9$:	POPR	#^M<R9,R10,R11>	;RESTORE POINTERS
	MOVL	#TOKEN_ONE_BYTE,R0
15$:	PUSHR	#^M<R0>
	INCL	R9	;BUMP PASSED LAST DIGIT GOTTEN
115$:	CALLG	NULL,GET_NON_BLANK_CHR	;GET NEXT CHR
	CMPB	#^A/!/,R0
	BNEQ	16$
	MOVL	R10,R9
	BRB	115$
;	MUST NOT BE A DIGIT
16$:	CMPB	#^A/0/,R0
	BGTR	22$	;NO
	CMPB	#^A/9/,R0
	BGEQ	21$	;YES-JUST PASS ASTERISK
22$:	POPR	#^M<R0>
	JMP	ADD_SIMPLE_TOKEN
21$:	POPR	#^M<R0>
20$:	POPR	#^M<R9,R10,R11>	;ITS JUST AN ASTERISK
	MOVL	#TOKEN_ASTERISK,R0
	JMP	ADD_SIMPLE_TOKEN
	.PAGE
	.SUBTITLE	SCAN FOR CONCATONATION OPERATOR
SCAN_CONCATONATION:
;
;	JMP	SCAN_CONCATONATION
;
;	SEE IF SINGLE SLASH OR CONCATONATION OPERATOR
;
	INCL	R9
3$:	CALLG	NULL,GET_NON_BLANK_CHR
	CMPB	#^A/!/,R0
	BNEQ	2$
	MOVL	R10,R9
	BRB	3$
2$:	CMPB	#^A?/?,R0
	BNEQ	1$
	MOVL	#TOKEN_CONCATENATE,R0
	INCL	R9
	JMP	ADD_SIMPLE_TOKEN
1$:	MOVL	#TOKEN_SLASH,R0
	JMP	ADD_SIMPLE_TOKEN
	.PAGE
	.SUBTITLE	SCAN POINT FOR LOGICAL OPERATOR OR NUMBER
SCAN_POINT:
;
;	CHECK CHAR THAT FOLLOWES FOR LETTER OR NUMBER-SEE IF JUST POINT OR
;	NUMBER OR LOGICAL OPERATOR
;
	INCL	R9
	PUSHR	#^M<R9,R10,R11>	;SAVE POINTERS JUST IN CASE OF BACK UP
11$:	CALLG	NULL,GET_NON_BLANK_CHR
	CMPB	#^A/!/,R0
	BNEQ	10$
	MOVL	R10,R9
	BRB	11$
10$:	CMPB	#^A/0/,R0	;SEE IF IT IS A NUMBER
	BGTR	50$	;NO
	CMPB	#^A/9/,R0
	BLSS	50$
;	ITS A NUMBER-RESET SCANNER POINTERS AND GO TO NUMBER ROUTINE
	POPR	#^M<R9,R10,R11>
	MOVL	SP,R8
	CLRL	R7
	JMP	SCAN_NUMBER_POINT
;	YES IT IS BUT I HAPPEN TO LIKE PASTA
50$:
;	SAVE UP TO THE NEXT 7 NON BLANK CHRS THE LAST BEING ANOTHER '.'
;	AND CHECK FOR TYPE OF LOGICAL OPERATION
	SUBL2	#8,SP	;MAKE ROOM FOR POSSABLE LOGICAL OPERATOR STRING
	MOVL	SP,R8	;SAVE START OF STACK
	MOVL	#2,R7	;CHAR COUNTER
	MOVL	#5,R6
	MOVB	#^A/./,(R8)+
	MOVB	R0,(R8)+
51$:	INCL	R9
	CALLG	NULL,GET_NON_BLANK_CHR
	CMPB	#^A/!/,R0
	BNEQ	14$
	MOVL	R10,R9
	BRB	51$
14$:	MOVB	R0,(R8)+
	INCL	R7
	CMPB	#^A/./,R0	;IS IT TERMINATEING DOT
	BEQL	52$
	SOBGTR	R6,51$
;	IF GOT HERE-NO CLOSEING . SO JUST RESET AND PASS DOT ONLY TOKEN
	ADDL2	#8,SP
	POPR	#^M<R9,R10,R11>
	MOVL	#TOKEN_POINT,R0
	JMP	ADD_SIMPLE_TOKEN
52$:;	SEE IF IT IS A KNOWN LOGICAL TOKEN
	INCL	R9
	MOVAL	LOGICAL_TABLE,R4
	MOVL	#NUMBER_OF_LOGICAL,R5
53$:	CMPW	(R4),R7		;COMPARE ONLY IF SAME LENGTH
	BNEQ	55$
	CMPC3	R7,(SP),@4(R4)
	BEQL	54$
55$:	ADDL2	#8,R4
	SOBGTR	R5,53$
;	NOT A KNOWN LOGICAL IF GOT HERE
	ADDL2	#8,SP	;RESTORE STACK
	POPR	#^M<R9,R10,R11>	;BACK UP SCANNER
	MOVL	#TOKEN_POINT,R0
	JMP	ADD_SIMPLE_TOKEN
54$:	CVTWL	2(R4),R0	;GET TOKEN
	JMP	ADD_SIMPLE_TOKEN
	.PAGE
	.SUBTITLE	SCAN NUMBER/HOLARITH/LABEL
SCAN_NUMBER:
;
;	SCAN FOR INTEGER/FLOATING/LABEL NUMBERS
;	(MAKE SURE ON FINDING "." IS NOT START OF LOGICAL
;	OPERATOR )
;
;	FORM OF FLOATING NUMBERS AS FOLLOWS
;	N
;	N.
;	.N
;	N.N
;	IN ADDITION ANY OF THE ABOVE FORMS CAN
;	PRECEED AN EXPONENT DECLARATION
;	E,D, OR Q FOLLOWED BY N, +N OR -N
;
;	OTHER ITEMS CHECKED FOR ARE HOLERITH AND RAD50 STRINGS
;
	MOVL	SP,R8	;AM GOING TO SAVE NUMBER STRING ON STACK.
			;R8 POINTS TO START OF STRING
	CLRL	R7	;COUNTER
	MOVB	R0,-(SP)
	INCL	R7
SCAN_NUM_LOOP_1:
	INCL	R9	;GET NEXT CHR
	CALLG	NULL,GET_NON_BLANK_CHR
	CMPB	#^A/0/,R0	;SEE IF A NUMBER
	BGTR	NOT_NUM_1
	CMPB	#^A/9/,R0
	BLSS	NOT_NUM_1
	MOVB	R0,-(SP)
	INCL	R7
	BRB	SCAN_NUM_LOOP_1
NOT_NUM_1:
	CMPB	#^A/!/,R0
	BNEQ	1$
	MOVL	R10,R9
	BRB	SCAN_NUM_LOOP_1
1$:	CMPB	#^A/H/,R0	;HOLERITH
	BNEQ	101$
	JMP	SCAN_HOL
101$:	CMPB	#^A/R/,R0	;RAD50
	BNEQ	201$
	JMP	SCAN_RAD
201$:	CMPB	#^A/./,R0	;DECIMAL POINT OR START OF LOGICAL OPERATION
	BEQL	SCAN_DEC_POINT
	CMPB	#^A/E/,R0	;CHECK FOR EXPONENT
	BNEQ	301$
	JMP	CHK_EXP
301$:	CMPB	#^A/D/,R0
	BNEQ	401$
	JMP	CHK_EXP
401$:	CMPB	#^A/Q/,R0
	BNEQ	501$
	JMP	CHK_EXP
501$:	JMP	NUMBER_IN	;HAVE INTEGER-FULLY IN
SCAN_DEC_POINT:
	PUSHR	#^M<R9,R10,R11>	;SAVE SCANNER POINTERS FOR POSSABLE BACK UP
9$:	INCL	R9
	CALLG	NULL,GET_NON_BLANK_CHR
	CMPB	#^A/!/,R0
	BNEQ	10$
	MOVL	R10,R9
	BEQL	9$
10$:	CMPB	#^A/0/,R0	;SEE IF NUMBER FOLLOWS
	BGTR	1$
	CMPB	#^A/9/,R0
	BLSS	1$
	JMP	2$
1$:;	IF POINT IS FOLLED BY OTHER THAN LETTER- IT IS D.P. AND BELONGS TO NUMBER
	CMPB	#^A/A/,R0
	BLEQ	101$
	JMP	3$	;NOT A LETTER
101$:	CMPB	#^A/Z/,R0
	BGEQ	4$
	POPR	#^M<R0,R1,R2>	;NOT A LETTER-D.P. BELONGS TO NUMBER-CLEAR STACK
	MOVB	#^A/./,-(SP)	;PUT D.P. ON STACK
	INCL	R7		;AND STORE TOKEN
	INCL	R9
	JMP	NUMBER_IN
4$:;	CHECK TO SEE IF THE "." IS THE BEGINNING OF A LOGICAL OPERATOR
;	SAVE UP TO THE NEXT 7 NON BLANK CHRS THE LAST BEING ANOTHER '.'
;	AND CHECK FOR TYPE OF LOGICAL OPERATION
	PUSHR	#^M<R0,R1,R2,R3,R4,R5,R6,R7,R8,R9,R10,R11>
	SUBL2	#8,SP	;MAKE ROOM FOR POSSABLE LOGICAL OPERATOR STRING
	MOVL	SP,R8	;SAVE START OF STACK
	MOVL	#2,R7	;CHAR COUNTER
	MOVL	#5,R6
	MOVB	#^A/./,(R8)+
	MOVB	R0,(R8)+
51$:	INCL	R9
	CALLG	NULL,GET_NON_BLANK_CHR
	CMPB	#^A/!/,R0
	BNEQ	14$
	MOVL	R10,R9
	BRB	51$
14$:	MOVB	R0,(R8)+
	INCL	R7
	CMPB	#^A/./,R0	;IS IT TERMINATEING DOT
	BEQL	52$
	SOBGTR	R6,51$
;	IF GOT HERE-NO CLOSEING . SO JUST RESET AND PASS DOT ONLY TOKEN
	ADDL2	#8,SP
	POPR	#^M<R0,R1,R2,R3,R4,R5,R6,R7,R8,R9,R10,R11>
	JMP	60$
52$:;	SEE IF IT IS A KNOWN LOGICAL TOKEN
	INCL	R9
	MOVAL	LOGICAL_TABLE,R4
	MOVL	#NUMBER_OF_LOGICAL,R5
53$:	CMPW	(R4),R7		;COMPARE ONLY IF SAME LENGTH
	BNEQ	55$
	CMPC3	R7,(SP),@4(R4)
	BEQL	54$
55$:	ADDL2	#8,R4
	SOBGTR	R5,53$
;	NOT A KNOWN LOGICAL IF GOT HERE
	ADDL2	#8,SP	;RESTORE STACK
	POPR	#^M<R0,R1,R2,R3,R4,R5,R6,R7,R8,R9,R10,R11>	;BACK UP SCANNER
	JMP	60$
;	THE POINT IS PART OF A LOGICAL OPERATOR NOT PART OF NUMBER
54$:	ADDL2	#8,SP
	POPR	#^M<R0,R1,R2,R3,R4,R5,R6,R7,R8,R9,R10,R11>
	JMP	7$
60$:	CMPB	#^A/E/,R0	;IS IT A POSSABLE EXPONENT ??
	BEQL	3$
	CMPB	#^A/D/,R0
	BEQL	3$
	CMPB	#^A/Q/,R0
	BNEQ	7$
3$:	INCL	R9		;NEXT CHR MUST BE +,- OR NUMBER
	CALLG	NULL,GET_NON_BLANK_CHR
	CMPB	#^A/!/,R0
	BNEQ	12$
	MOVL	R10,R9
	BRB	3$
12$:	CMPB	#^A/+/,R0
	BEQL	6$
	CMPB	#^A/-/,R0
	BEQL	6$
	CMPB	#^A/0/,R0
	BGTR	7$
	CMPB	#^A/9/,R0
	BGEQ	8$
;	NOT EXPONENT-POINT IS NOT D.P.-GO PASS INTEGER
7$:	POPR	#^M<R9,R10,R11>
	BRW	NUMBER_IN
6$:
8$:	;FOUND EXPONENT
	POPR	#^M<R9,R10,R11>
	MOVB	#^A/./,-(SP)
	INCL	R7
	INCL	R9
	BRW	CHK_EXP
2$:	;FOUND A NUMBER-FRACTIONAL PART CONTINUES
	POPR	#^M<R9,R10,R11>	;RESTORE SCANNER POINTERS
	INCL	R9
SCAN_NUMBER_POINT:
	MOVB	#^A/./,-(SP)
	INCL	R7
1$:	CALLG	NULL,GET_NON_BLANK_CHR
	CMPB	#^A/!/,R0
	BNEQ	2$
	MOVL	R10,R9
	BRB	1$
2$:	CMPB	#^A/0/,R0
	BGTR	CHK_EXP
	CMPB	#^A/9/,R0
	BLSS	CHK_EXP
	INCL	R9
	MOVB	R0,-(SP)
	INCL	R7
	BRB	1$
CHK_EXP:
	CALLG	NULL,GET_NON_BLANK_CHR	;SEE IF EXPONENT FOLLOWS
	CMPB	#^A/!/,R0
	BNEQ	10$
	MOVL	R10,R9
	BRB	CHK_EXP
10$:	CMPB	#^A/E/,R0
	BEQL	1$
	CMPB	#^A/D/,R0
	BEQL	1$
	CMPB	#^A/Q/,R0
	BNEQ	NUMBER_IN
1$:	MOVB	R0,-(SP)
	INCL	R7
	INCL	R9
72$:	CALLG	NULL,GET_NON_BLANK_CHR
	CMPB	#^A/!/,R0
	BNEQ	71$
	MOVL	R10,R9
	BRB	72$
71$:	CMPB	#^A/+/,R0
	BEQL	2$
	CMPB	#^A/-/,R0
	BEQL	2$
3$:	CMPB	#^A/0/,R0
	BGTR	NUMBER_IN
	CMPB	#^A/9/,R0
	BLSS	NUMBER_IN
2$:	MOVB	R0,-(SP)
	INCL	R9
	INCL	R7
4$:	CALLG	NULL,GET_NON_BLANK_CHR
	CMPB	#^A/!/,R0
	BNEQ	3$
	MOVL	R10,R9
	BRB	4$
;	TERMINATE NUMBER INPUT
NUMBER_IN:
	MOVL	#TOKEN_NUMBER,R0
	MOVL	R7,R1
	JMP	ADD_COMPLEX_TOKEN
SCAN_HOL:
	MOVL	#TOKEN_HOLLERITH_STRING,R2
	BRB	GET_STR
SCAN_RAD:
	MOVL	#TOKEN_RADIX50_STRING,R2
GET_STR:
;	GET NUMBER OF CHRS OFF OF STACK AND CLEAN UP THE STACK
	CLRL	R3	;TO STROE BROKEN OUT COUNT
	MOVL	R8,R6
1$:	MULL	#10,R3
	MOVB	-(R6),R0
	SUBB2	#^A/0/,R0
	CVTBL	R0,R0
	ADDL2	R0,R3
	SOBGTR	R7,1$
	MOVL	R8,SP
	MOVL	R3,R7
2$:	INCL	R9
	CALLG	NULL,GET_CHR
	MOVB	R0,-(SP)
	SOBGTR	R3,2$
	INCL	R9
	MOVL	R7,R1
	MOVL	R2,R0
	JMP	ADD_COMPLEX_TOKEN
	.PAGE
	.SUBTITLE	SCAN ID
;
;	FOUND A LETTER-SCAN AN IDENTIFIER
;
SCAN_ID:
	MOVL	SP,R8		;SET UP TO SAVE IN STACK
	CLRL	R7
1$:	MOVB	R0,-(SP)
	INCL	R7
	INCL	R9
5$:	CALLG	NULL,GET_NON_BLANK_CHR
	CMPB	#^A/0/,R0	;SEE IF NUMBER
	BGTR	2$
	CMPB	#^A/9/,R0
	BGEQ	1$
2$:	CMPB	#^A/A/,R0
	BGTR	3$
	CMPB	#^A/Z/,R0
	BGEQ	1$
3$:	CMPB	#^A/$/,R0
	BEQL	1$
	CMPB	#^A/_/,R0
	BEQL	1$
	CMPB	#^A/!/,R0	;CONTINUATION
	BNEQ	4$
	MOVL	R10,R9		;CLOSE OUT LINE
	BRB	5$
4$:
;	SEE IF IO FLAG IS SET
	TSTL	@4(AP)
	BEQL	NO_IO_CHECK	;NO
	CMPB	#^A/=/,R0	;BEFORE DOING I/O CHECK-SEE IF EQUAL SIGN HERE
	BNEQ	9$
	MOVB	R0,-(SP)
	INCL	R7
9$:
;	KEY WORD ON STACK UPSIDE DOWN-MUST PUT UPRIGHT TO COMPARE
	MOVL	SP,R0
	MOVL	R7,R1
10$:	MOVB	(R0)+,-(SP)
	SOBGTR	R1,10$
	MOVAL	IO_TABLE,R6	;SET UP TO CHECK IO KEY WORD TABLE
	MOVL	#NUMBER_OF_IO,R5
6$:	CMPW	R7,(R6)		;IF STRINGS NOT SAME LENGTH-DONT BOTHER TO COMPARE
	BNEQ	7$
	CMPC3	R7,(SP),@4(R6)
	BNEQ	7$		;NOT THE SAME
;	FOUND A MATCH-RESET POINTERS AND INSET TOKEN
	ADDL2	R7,SP
	CMPB	#^A/=/,(SP)	;SEE IF WE PUSH '=' ON END
	BNEQ	8$
	INCL	R9
8$:	CVTWL	2(R6),R0	;GET TOKEN
	JMP	ADD_SIMPLE_TOKEN
7$:	ADDL2	#8,R6
	SOBGTR	R5,6$
	ADDL2	R7,SP
	CMPB	#^A/=/,(SP)
	BNEQ	107$
	DECL	R7
107$:
NO_IO_CHECK:
	MOVL	#TOKEN_IDENTIFIER,R0
	MOVL	R7,R1
	JMP	ADD_COMPLEX_TOKEN
	.PAGE
	.SUBTITLE	PUT IN COMPLEX TOKEN AT END OF QUEUE
ADD_COMPLEX_TOKEN:
;
;	JMP	ADD_COMPLEX_TOKEN
;
;	INPUT IS
;	R0	TOKEN
;	R1	LENGTH OF STRING
;	R8	STARTING ADDRESS ON STACK OF STRING-GOING BACKWARDS
;
	MOVQ	R0,R2	;SAVE ARGUEMNTS
	ADDL3	#16,R1,ARG1	;GET LENGTH OF TOKEN ELEMENT
	CALLG	ARG,ALLOCATE;ALLOCATE FROM HEAP
	INSQUE	(R0),@LINE_TOKEN_QUEUE+4;INSET AT END OF QUEUE
	MOVL	(R11),8(R0)	;INSERT LINE NUMBER
	MOVW	R2,12(R0)	;INSERT TOKEN
	ADDW3	#16,R3,14(R0)	;INSERT LENGTH
	MOVAL	16(R0),R6	;LOAD TOKEN STRING STORAGE STARTING ADDRESS
2$:	MOVB	-(R8),(R6)+	;LOAD CHR
	SOBGTR	R3,2$		;LOOP UNTILL LOADED
	MOVL	R2,R0		;RETURN TOKEN IN R0
	RET
	.PAGE
	.SUBTITLE	PUT SIMPLE TOKEN AT END OF QUEUE
	.ENTRY	INSERT_SIMPLE_TOKEN,^M<R2>
;
;	CALL	INSERT_SIMPLE_TOKEN
;	JMP	ADD_SIMPLE_TOKEN
;
;	INPUT IS R0 CONTIANING TOKEN FOR ELEMENT
;	PUT ELEMENT AT END OF QUEUE
;
ADD_SIMPLE_TOKEN:
	MOVL	R0,R2		;SAVE TOKEN
	MOVL	#64,ARG1	;LOAD MIN LENGTH FOR MEMORY BLOCK
	CALLG	ARG,ALLOCATE;ALLOCATE FROM HEAP
	INSQUE	(R0),@LINE_TOKEN_QUEUE+4;INSET AT END OF QUEUE
	MOVL	(R11),8(R0)	;INSERT LINE NUMBER
	MOVW	R2,12(R0)	;INSERT TOKEN
	MOVW	#16,14(R0)	;INSERT LENGTH
	MOVL	R2,R0		;RETURN TOKEN IN R0
	RET
	.PAGE
	.PSECT	PURE_DATA,RD,NOWRT,SHR,NOEXE,CON,GBL
UNKNOWN_CHR_ERR:
	.ASCID	/INDEX-W-Unknown character found in line/
NOIO_ARG:.LONG	1
	.ADDRESS	ZERO
IO_ARG:	.LONG	1
	.ADDRESS	ONE
ZERO:	.LONG	0
ONE:	.LONG	1
	.END