Google
 

Trailing-Edge - PDP-10 Archives - BB-4157E-BM - fortran-compiler/lexica.bli
There are 27 other files named lexica.bli in the archive. Click here to see a list.
!THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY ONLY BE USED
!  OR COPIED IN ACCORDANCE WITH THE TERMS OF SUCH LICENSE.

!COPYRIGHT (C) 1973,1981 BY DIGITAL EQUIPMENT CORPORATION
!AUTHOR: D. B. TOLMAN/DCE/SJW/AHM

MODULE LEXICAL(RESERVE(0,1,2,3),SREG=#17,FREG=#16,VREG=#15,DREGS=4)=
BEGIN


GLOBAL BIND LEXICV = 6^24 + 0^18 + 36;	! Version Date:	27-Oct-81

%(

***** Begin Revision History *****

2	-----	-----	KLUDGE UP THE CLASSIFIER SO IT WILL HANDLE 
			THE IBM ' RECORD MARKS
			ADD THE NECESSARY THING TO THE CLASSIFIER SO IT
			WILL RECOGNIZE THE PARAMETER STATEMENT

			HAVE THE IDENTIFIER LEXEME RETURN CHECK FOR
			PARAMETER REFERENCES

3	-----	-----	CHANGE ACMEOP SO THAT THE "+" COMPIL CONSTRUCT WILL WORK

4	-----	-----	PUT A CHECK IN THE CLASSIFIER SO THAT "["
			IN AN INCLUDE STATEMENT WILL NOT BLOW EVERYTHING
			UP

5	-----	-----	REMOVE THE INCLUDE CROCK BECAUSE THE FILE SPEC IS NOW IN 'S

			ACMRETNXT WAS CHANGED TO PASS OVER REMARKS BEFORE
			RETURNING

			ZEROCHK WAS CLEARED WHEN A BAD LABEL WAS ENCOUNTERED
			IN ORDER NOT TO GET THE ZERO LABEL MESSAGE

			INTERR WAS UPDATED TO THE E61<0,0> EXTERNAL FORM IN ASHELP

6	-----	-----	CHARPOS WAS NOT BEING ADJUSTED PROPERLY AFTER THE
			REL-OP LOOKAHEAD FOLLOWING <CONST>.<LETTER>
			ACMEXDBCHK  MACRO

7	-----	-----	UPLOW WAS SETTING CODE TO UPPER RATHER THAN
			DOING A SETCODE. THUS C AND D WERE NOT BEING
			RECOGNIZED IN COL 1

8	-----	-----	GOTINT - CHECK FOR INTEGER OVERFLOW

9	-----	-----	8 WAS NICE BUT THE CALL TO FATLEX DESTROYED
			THE CONTENTS OF NAME

			ALSO ADD CODE TO ACMBILDDBLINT SO THAT IT
			WILL INCREMENT DECEXP IF IT IS IGNORING
			INTEGRAL DIGITS OF A REAL NUMBER SO THAT
			THE EXPONENT WILL BE CORRECT

10	-----	-----	FIX STSSCAN AND STCSCAN SO THAT IF THEY
			ARE ENTERED WITH AN EOS THAT WHEN THEY FAIL 
			THEY WILL SET LEXLINE PROPERLY

11	-----	-----	HARD TO BELIEVE AT THIS LATE DATE BUT HOLLERITHS
			IN EVEN MULTIPLES OF 5 CHARACTERS ARE MESSING UP
			IN THE LAST WORD
			ACMCHECKLET  AND  ACMHOLEND

12	-----	-----	CHANGE CONTROL-Z CHECK TO USE FLAGS2  RATHER
			THAN DOING A DEVCHR

13	-----	-----	FIX ACMILABILL TO SET CHAR TO SMALCODE BECAUSE
			IN ONE INSTANCE IT IS ENTERED WITH CODE CONTAINING
			A BIGCODE
14	342	17876	FIX THINGS UP FOR LONG UNCLASSIFIABLE STMNTS, (DCE)
15	365	18857	FIX FORM FEEDS BETWEEN PROGRAMS (EAT ONE), (DCE)
16	366	18210	FIX MISC. BUGS IN SCANNING CONSTANTS SUCH AS
			X=.123EQ.A  AND   X=1.1HABC, (DCE)

***** Begin Version 5A *****

17	547	21820	(QAR863) FIX TAB7S AND TAB11S SO INITIAL TAB
			  IN COLUMN 6 GOES TO COL 7 IF AN INITIAL LINE
			  OR COL 6 IF A CONTINUATION LINE, (SJW)
18	561	10429	ALLOW CONTINUATION LINES AFTER FORM FEEDS
			USED SOLELY TO SEPARATE PAGES., (DCE)
19	573	-----	REQUIRE DBUGIT.REQ, (SJW)

***** Begin Version 5B *****

20	642	11409	FIX 561 SO THAT PAGE HEADING OUTPUT ONLY WHEN
			NOT ATTEMPTING TO CLASSIFY STATEMENT, (DCE)
21	667	25664	MAKE INCLAS A GLOBAL (FOR LINESEQNO), (DCE)
22	670	25571	CHANGE CONTINUATION LINE PROCESSING SO THAT
			THE LABEL FIELD CAN ONLY CONSIST OF BLANK CHARS., (DCE)
23	675	26049	RUBOUT CHAR (#177) IN SOURCE CAN GIVE INTERNAL
			ERRORS IN ROUTINE LEXICA, (DCE)
24	713	26658	COMMENT LINES TERMINATED WITH <CR><CR><LF> MAY
			GIVE PROBLEMS IF BUFFER SPLITS <CR> AND <LF>, (DCE)
25	717	26560	GIVE REASONABLE ERROR FOR DUPLICATE 
			PARAMETER STATEMENT., (DCE)
26	742	-----	ADD V6 STOP/PAUSE PROCESSING FOR DIGIT
			STRING INSTEAD OF OCTAL STRING, (DCE)

***** Begin Version 6 *****

30	1107	TFV	10-Jul-81	------
	Prohibit 0H hollerith constants and '' character constants.
	New errors are E158 (IVH) for invalid hollerith constant 0H and
	E159 (IVC) for invalid character constant ''.

34	1126	AHM	22-Sep-81	Q20-01654
	Remove last vestige of CALL DEFINE FILE support.

36	1141	EGM	27-Oct-81	10-31686
	Produce fatal diagnostic when octal constant contains more than
	24 significant digits.

***** End Revision History *****

)%

% LEXICAL.BLI MUST FIRST BE PROCESSED BY PRELEX.TEC, BEFORE COMPILATION
 IF ANY STATES OR ACTION MACROS HAVE BEEN ADDED OR DELETED.
 PRELEX.TEC USES LASTACT TO GENERATE THE LEXICAL CASE STATEMENT,
 LASTBIG AND LASTSMAL TO GENERATE THE STATE TABLE PRESET PLIT 
 SKELETONS.
%

	! Error pointers - in ERROUT.BLI

EXTERNAL E8,E10,E9,E7,E109,E110,E12,E19,E76,E0,E95,E72,E111,E158,E159;

REQUIRE  DBUGIT.REQ;
REQUIRE  IOFLG.BLI;

EXTERNAL  ENTRY,NAME;
EXTERNAL  LINEOUT,BACKTYPE,DECREMENT;
EXTERNAL  OVERFLOW;
EXTERNAL  LINESEQNO,  PRINT ,FATLERR,WARNERR,FATLEX,WARNLEX;
EXTERNAL STALABL;
EXTERNAL STMNDESC;	! STATEMENT DESCRIPTION BLOCK POINTER

OWN
	TEMP,		% TEMPORARY STORAGE WITHIN MACROS %
	CHARTMP,	% STORAGE FOR REGISTER CHAR UPON EXIT %
	CODETMP;	%STORAGE FOR REGISTER CODE UPON EXIT %

GLOBAL		% LINE PROCESSING VARIABLES %
	CLASLINE,	! LINE NUMBER OF BEGINNING OF CLASSIFICATION
	CLASPOS;	! CHARACTER POSITION OF BEGINNING OF CLASSIFICATION

OWN	FOUNDCR;	! INDICATES THAT A <CR> WAS ENCOUNTERED BEFORE THE
			! LINE TERMINATOR WHICH TERMINATED THE REMARK STATE
			! IF SET TO 1.

%[667]%	GLOBAL INCLAS; !MAKE INCLAS A GLOBAL, NOT AN OWN
OWN	VALUE,	! VALUE TO BE RETURNED AFTER SKIPPING TO NEXT SIGNIF CHAR
![667]	INCLAS,		! IF 1 INDICATES THAT CLASIFICATION LOOKAHEAD IS TAKING PLACE
	CLASERR,	! IF 1 INDICATES TO STSKIP THAT AN ILLEGAL CHARACTER
			! WAS DETECTED IN CLASSIFICATION AND THAT STSKIP
			! SHOULD ALSO DETECT IT AND REPORT IT
	ZEROCHK,	! SET TO 1 IF A DIGIT WAS ENCOUNTERED IN THE LABEL FIELD
			! USED TO CHECK FOR "0" LABEL
	INCOMNT;	! IF 1 INDICATES THAT A COMMENT LINE IS BEING PROCESSED

%[1107]% OWN CHARCOUNT;	! Used to hold length of character constant


!
! --------------------------------------------------
!
! FIRST WE NEED THE LEXEME AND CHARACTER CODE CLASS BINDS
!
! --------------------------------------------------
!
REQUIRE LEXNAM.BLI;

REQUIRE  LEXAID.BLI;


!
! --------------------------------------------------
!
! NOW WE NEED THE ACTION NAME BINDS AND ACTION MACRO NAME ASSOCATIONS
!
! --------------------------------------------------
!


%ACTDEF%

! ACTION NUMBER BINDS AND ACTION MACRO ASSOCIATIONS TO THE "LEXICAL" CASE STATEMENT
!
! THERE MUST BE AN EQUAL NUMBER OF ACTION REFERENCES IN THE "LEXICAL"
! CASE STATEMENT.  THIS CASE STATEMENT WILL BE GENERATED BY THE TECO
! MACRO PRELEX.TEC.  IT WILL GENERATE THE CASE STATEMENT WITH "LASTACT"
! ACTION REFERENCES.
!


!	ACTION	ACTION			LEXICAL		ACTION
!	NAME	NUMBER			REFERENCE	MACRO NAME

BIND	ACTEOB	= 0;		MACRO	ACT0	= ACMEOB   $ ;
BIND	ACTINIT	= 1;		MACRO	ACT1	= ACMINIT	$ ;
BIND	ACTANYS	= 2;		MACRO	ACT2	= ACMANYS	$ ;
BIND	ACTTABB = 3;		MACRO	ACT3	= ACMTABB	$ ;
BIND	ACTHOLCONDONE = 4 ;	MACRO	ACT4	= ACMHOLCONDONE	$ ;
BIND	ACTFMTHOLPKUP = 5 ;	MACRO	ACT5	= ACMFMTHOLPKUP	$ ;
BIND	ACTSTSKIP = 6;		MACRO	ACT6	= ACMSTSKIP	$ ;
BIND	ACTTABS	= 3;
BIND	ACTHOLCON = 7 ;		MACRO	ACT7	= ACMHOLCON	$ ;
BIND	ACTREMEND = 8;		MACRO	ACT8	= ACMREMEND	$ ;
BIND	ACTGOBAKNOW = 9;	MACRO	ACT9	= ACMGOBAKNOW	$ ;
BIND	ACTLT = 10 ;		MACRO	ACT10	= ACMLT		$ ;
BIND	ACTSTMNTFOS = 11;	MACRO	ACT11	= ACMSTMNTFOS	$ ;
BIND	ACTANYB = 2 ;
BIND	ACTFMTHOLCK = 12 ;	MACRO	ACT12	= ACMFMTHOLCK	$ ;
BIND	ACTGOBAKNXT = 13 ;	MACRO	ACT13	= ACMGOBAKNXT	$ ;
BIND	ACTEXPLT = 14 ;	MACRO	ACT14	= ACMEXPLT	$ ;
BIND	ACTLEXFOS = 15 ;	MACRO	ACT15	= ACMLEXFOS	$ ;
BIND	ACTRETNOW = 16 ;	MACRO	ACT16	= ACMRETNOW	$ ;
BIND	ACTIGNCRCALC = 17 ;	MACRO	ACT17	= ACMIGNCRCALC	$ ;
BIND	ACTCALCONT = 18 ;	MACRO	ACT18	= ACMCALCONT	$ ;
BIND	ACTCONTDIG = 19 ;		MACRO	ACT19	= ACMCONTDIG	$ ;
BIND	ACTCLABSKP = 20 ;	MACRO	ACT20	= ACMCLABSKP	$ ;
BIND	ACTNOEND = 21 ;		MACRO	ACT21	= ACMNOEND	$ ;
BIND	ACTSTEOP = 22 ;		MACRO	ACT22	= ACMSTEOP	$ ;
BIND	ACTENTREMARK = 23 ;	MACRO	ACT23	= ACMENTREMARK	$ ;
BIND	ACTMULTST = 24 ;	MACRO	ACT24	= ACMMULTST	$ ;
BIND	ACTCLASF1 = 25 ;	MACRO	ACT25 	= ACMCLASF1	$ ;
BIND	ACTMULTNULL = 26 ;	MACRO	ACT26	= ACMMULTNULL	$ ;
BIND	ACTILLCHAR = 27 ;	MACRO	ACT27	= ACMILLCHAR	$ ;
BIND	ACTCOMNT = 28 ;		MACRO	ACT28	= ACMCOMNT	$ ;
BIND	ACTDEBUG = 29 ;		MACRO	ACT29	= ACMDEBUG	$ ;
BIND	ACTCOMNTFOS = 30 ;	MACRO	ACT30	= ACMCOMNTFOS	$ ;
BIND	ACTINTERR = 31 ;	MACRO	ACT31	= ACMINTERR	$ ;
BIND	ACTNOCONT = 32 ;	MACRO	ACT32	= ACMNOCONT	$ ;
BIND	ACTNULLFOS = 33 ;	MACRO	ACT33	= ACMNULLFOS	$ ;
BIND	ACTCITCONT = 34 ;	MACRO	ACT34	= ACMCITCONT	$ ;
BIND	ACTCLABLT = 35 ;	MACRO	ACT35	= ACMCLABLT	$ ;
BIND	ACTENTCLABSKP = 36 ;	MACRO	ACT36	= ACMENTCLABSKP	$ ;
BIND	ACTCBUGCHK = 37 ;	MACRO	ACT37	= ACMCBUGCHK	$ ;
BIND	ACTENTLAB = 38 ;	MACRO	ACT38	= ACMENTLAB	$ ;
BIND	ACTILABILL = 39 ;	MACRO	ACT39	= ACMILABILL	$ ;
BIND	ACTILABEDCK = 40 ;	MACRO	ACT40	= ACMILABEDCK	$ ;
BIND	ACTILITCONT = 41 ;	MACRO	ACT41	= ACMILITCONT	$ ;
BIND	ACTILABDIG = 42 ;	MACRO	ACT42	= ACMILABDIG	$ ;
BIND	ACTILNTC = 43 ;	MACRO	ACT43	= ACMILNTC	$ ;
BIND	ACTILNTI = 44 ;	MACRO	ACT44	= ACMILNTI	$ ;
BIND	ACTILNTD = 45 ;	MACRO	ACT45	= ACMILNTD	$ ;
BIND	ACTILITNC = 46 ;	MACRO	ACT46	= ACMILITNC	$ ;
BIND	ACTILITC = 47 ;	MACRO	ACT47	= ACMILITC	$ ;
BIND	ACTILABLT = 48 ;	MACRO	ACT48	= ACMILABLT	$ ;
BIND	ACTUPLOW = 49 ;		MACRO	ACT49	= ACMUPLOW	$ ;
BIND	ACTCONSTSKP = 50 ;	MACRO	ACT50	= ACMCONSTSKP	$ ;
BIND	ACTSKNAME = 51 ;	MACRO	ACT51	= ACMSKNAME	$ ;
BIND	ACTSKLPAREN = 52 ;	MACRO	ACT52	= ACMSKLPAREN	$ ;
BIND	ACTSKRPAREN = 53 ;	MACRO	ACT53	= ACMSKRPAREN	$ ;
BIND	ACTSKCOMMA = 54 ;	MACRO	ACT54	= ACMSKCOMMA	$ ;
BIND	ACTGETLIT = 55 ;	MACRO	ACT55	= ACMGETLIT	$ ;
BIND	ACTENDLIT = 56 ;	MACRO	ACT56	= ACMENDLIT	$ ;
BIND	ACTBAKTOTERM = 57 ;	MACRO	ACT57	= ACMBAKTOTERM	$ ;
BIND	ACTSKCONBLD = 58 ;	MACRO	ACT58	= ACMSKCONBLD	$ ;
BIND	ACTSKPHOLX = 59 ;	MACRO	ACT59	= ACMSKPHOLX	$ ;
BIND	ACTSKPHOL = 60 ;	MACRO	ACT60	= ACMSKPHOL	$ ;
BIND	ACTHOLTAB = 61 ;	MACRO	ACT61	= ACMHOLTAB	$ ;
BIND	ACTENTERM = 62 ;	MACRO	ACT62	= ACMENTERM	$ ;
BIND	ACTUNMATEOS = 63 ;	MACRO	ACT63	= ACMUNMATEOS	$ ;
BIND	ACTFMTQT1 = 64 ;	MACRO	ACT64	= ACMFMTQT1	$ ;
BIND	ACTUNMATCHK = 65 ;
BIND	ACTSKILL = 65 ;	 	MACRO	ACT65	= ACMSKILL	$ ;
BIND	ACTCLASLT = 66 ;	MACRO	ACT66	= ACMCLASLT	$ ;
BIND	ACTCLASUNREC = 67 ;	MACRO	ACT67	= ACMCLASUNREC	$ ;
BIND	ACTCLILLCHAR = 68 ;	MACRO	ACT68	= ACMCLILLCHAR	$ ;
BIND	ACTCLASBACK = 69 ;	MACRO	ACT69	= ACMCLASBACK	$ ;
BIND	ACTCOMPAR = 70 ;	MACRO	ACT70	= ACMCOMPAR	$ ;
BIND	ACTCLASAL1 = 71 ;	MACRO	ACT71	= ACMCLASAL1	$ ;
BIND	ACTASGNMNT = 72 ;	MACRO	ACT72	= ACMASGNMNT	$ ;
BIND	ACTCLASF2 = 73 ;	MACRO	ACT73	= ACMCLASF2	$ ;
BIND	ACTIFCHK = 74 ;	MACRO	ACT74	= ACMIFCHK	$ ;
BIND	ACTDOCHK = 75 ;	MACRO	ACT75	= ACMDOCHK	$ ;
BIND	ACTARITHIF = 76 ;	MACRO	ACT76	= ACMARITHIF	$ ;
BIND	ACTLOGICIF = 77 ;	MACRO	ACT77	= ACMLOGICIF	$ ;
BIND	ACTUNMATUNREC = 78 ;	MACRO	ACT78	= ACMUNMATUNREC	$ ;
BIND	ACTSTFNARRY = 79 ;	MACRO	ACT79	= ACMSTFNARRY	$ ;
BIND	ACTDOCHK1 = 80 ;	MACRO	ACT80	= ACMDOCHK1	$ ;
BIND	ACTDOSTMNT = 81 ;	MACRO	ACT81	= ACMDOSTMNT	$ ;
BIND	ACTENDCHK = 82 ;	MACRO	ACT82	= ACMENDCHK	$ ;
BIND	ACTCLASF3 = 83 ;	MACRO	ACT83	= ACMCLASF3	$ ;
BIND	ACTCLASF4 = 84 ;	MACRO	ACT84	= ACMCLASF4	$ ;
BIND	ACTKEYTERM = 85 ;	MACRO	ACT85	= ACMKEYTERM	$ ;
BIND	ACTUNMATKEY = 86 ;	MACRO	ACT86	= ACMUNMATKEY	$ ;
BIND	ACTSPELLING = 87 ;	MACRO	ACT87	= ACMSPELLING	$ ;
BIND	ACTBADCHAR = 88 ;	MACRO	ACT88	= ACMBADCHAR	$ ;
BIND	ACTSINGLEX = 89 ;	MACRO	ACT89	= ACMSINGLEX	$ ;
BIND	ACTDOUBLEX = 90 ;	MACRO	ACT90	= ACMDOUBLEX	$ ;
BIND	ACTNOTDOUB = 91 ;	MACRO	ACT91	= ACMNOTDOUB	$ ;
BIND	ACTMAYBDOUB = 92 ;	MACRO	ACT92	= ACMMAYBDOUB	$ ;
BIND	ACTENTIDENT = 93 ;	MACRO	ACT93	= ACMENTIDENT	$ ;
BIND	ACTPKUPID = 94 ;	MACRO	ACT94	= ACMPKUPID	$ ;
BIND	ACTENDID = 95 ;	MACRO	ACT95	= ACMENDID	$ ;
BIND	ACTENTDOT = 96 ;	MACRO	ACT96	= ACMENTDOT	$ ;
BIND	ACTTRYREAL = 97 ;	MACRO	ACT97	= ACMTRYREAL	$ ;
BIND	ACTMISOPER = 98 ;	MACRO	ACT98	= ACMMISOPER	$ ;
BIND	ACTGETOPER = 99 ;	MACRO	ACT99	= ACMGETOPER	$ ;
BIND	ACTOPCHK = 100 ;	MACRO	ACT100	= ACMOPCHK	$ ;
BIND	ACTMISOP1 = 101 ;	MACRO	ACT101	= ACMMISOP1	$ ;
BIND	ACTENTGETCONST = 102 ;	MACRO	ACT102	= ACMENTGETCONST	$ ;
BIND	ACTGOTINT = 103 ;	MACRO	ACT103	= ACMGOTINT	$ ;
BIND	ACTCHECKLET = 104 ;	MACRO	ACT104	= ACMCHECKLET	$ ;
BIND	ACTBILDDBLINT = 105 ;	MACRO	ACT105	= ACMBILDDBLINT	$ ;
BIND	ACTREALCON = 106 ;	MACRO	ACT106	= ACMREALCON	$ ;
BIND	ACTENTRLBLDD = 107 ;	MACRO	ACT107	= ACMENTRLBLDD	$ ;
BIND	ACTGOTREAL = 108 ;	MACRO	ACT108	= ACMGOTREAL	$ ;
BIND	ACTEXDBCHK = 109 ;	MACRO	ACT109	= ACMEXDBCHK	$ ;
BIND	ACTGOTOP = 110 ;	MACRO	ACT110	= ACMGOTOP	$ ;
BIND	ACTCHKPLMI = 111 ;	MACRO	ACT111	= ACMCHKPLMI	$ ;
BIND	ACTNOEXP = 112 ;	MACRO	ACT112	= ACMNOEXP	$ ;
BIND	ACTINTEXP1 = 113 ;	MACRO	ACT113	= ACMINTEXP1	$ ;
BIND	ACTFMTQT = 114 ;	MACRO	ACT114	= ACMFMTQT	$ ;
BIND	ACTSUMIEXP = 58 ;
BIND	ACTGOTIEXP = 115 ;	MACRO	ACT115	= ACMGOTIEXP	$ ;
BIND	ACTHOLCHAR = 116 ;	MACRO	ACT116	= ACMHOLCHAR	$ ;
BIND	ACTHOLEND = 117 ;	MACRO	ACT117	= ACMHOLEND	$ ;
BIND	ACTENTLITLEX = 118 ;	MACRO	ACT118	= ACMENTLITLEX	$ ;
BIND	ACTLITEDCHK = 119 ;	MACRO	ACT119	= ACMLITEDCHK	$ ;
BIND	ACTTIC2CHK = 120 ;	MACRO	ACT120	= ACMTIC2CHK	$ ;
BIND	ACTENTOCTQ = 121 ;	MACRO	ACT121	= ACMENTOCTQ	$ ;
BIND	ACTNOOCT = 122 ;	MACRO	ACT122	= ACMNOOCT	$ ;
BIND	ACTCHKOCPM = 123 ;	MACRO	ACT123	= ACMCHKOCPM	$ ;
BIND	ACTOCTQ1 = 124 ;	MACRO	ACT124	= ACMOCTQ1	$ ;
BIND	ACTGOTOCT = 125 ;	MACRO	ACT125	= ACMGOTOCT	$ ;
BIND	ACTNOTIC = 126 ;	MACRO	ACT126	= ACMNOTIC	$ ;
BIND	ACTSCANCHAR = 127 ;	MACRO	ACT127	= ACMSCANCHAR	$ ;
BIND	ACTSTRCHK = 128 ;	MACRO	ACT128	= ACMSTRCHK	$;
BIND	ACTSTOPOCT = 129 ;	MACRO	ACT129	= ACMSTOPOCT	$ ;
BIND	ACTSTOPLIT = 130 ;	MACRO	ACT130	= ACMSTOPLIT	$ ;
BIND	ACTFLEX1 = 131 ;	MACRO	ACT131	= ACMFLEX1	$ ;
BIND	ACTFMTEOS = 132 ;	MACRO	ACT132	= ACMFMTEOS	$ ;
BIND	ACTFMTCHAR = 133 ;	MACRO	ACT133	= ACMFMTCHAR	$ ;
![675] ADD STATE FOR CHECKING RUBOUT CHARACTER IN SOURCE
BIND	ACTRIS	= 134 ;		MACRO	ACT134	= ACMRIS	$ ; ![675]
![742] ADD STATES FOR PROCESSING STOP/PAUSE CONSTANTS
BIND	ACTSTOPINT = 135 ;	MACRO	ACT135	= ACMSTOPINT	$ ; ![742]
BIND	ACTGOT6INT = 136 ;	MACRO 	ACT136	= ACMGOT6INT	$ ; ![742]
BIND	ACT6DIGIT  = 137 ;	MACRO	ACT137 = ACM6DIGIT	$ ; ![742]

BIND	%%LASTACT	= 138	; ![742]

%USFMAC%
%HERE ARE A FEW USEFUL MACROS %

MACRO  LINESEQBIT  =  @@CURPTR     $  ;


!
! --------------------------------------------------
!
! NOW ONE CAN DEFINE THE "LEXICAL" ACTIONS AND STATES
!
! THE INDIVIDUAL ACTIONS ARE DEFINED AS MACROS.  THEIR NAMES MUST APPEAR
! IN THE PRECEEDING TABLE, BOUND TO AN ACTION ( OR CASE ) NUMBER
! ALL REFERENCES TO ACTIONS ARE MADE THROUGH THE NAME "ACTXXXX",
! WHICH IS BOUND TO THE ACTION NUMBER.  THE ACTUAL ACTION MACRO DEFINITION
! NAME IS NEVER REFERENCED EXCEPT DURING THE DEFINITION OF THE 
! "LEXICAL" CASE STATEMENT.
!
! THE INDIVIDUAL STATES ARE DEFINED IN TERMS OF A NAME
! AND A SERIES OF BINDS OF INPUT CODE TO THE DESIRED ACTION (ACTXXX).
! THE STATE NAME IS NOT ACTUALLY DEFINED UNTIL LATER IN THIS 
! CODE AFTER THE ACTUAL STATE TABLE PLITS HAVE BEEN DEFINED,  HOWEVER
! THE STATE NAMES MAY STILL BE REFERENCED IN THE ACTION MACROS, SINCE
! THEIR REFERENCE IS NOT UNTIL EVEN LATER.
!
! IN ORDER TO DEFINE A STATE TABLES VALUES, ONE PRODUCES A SERIES
! OF BINDS, 11 FOR THE SMALL STATES AND 32 FOR THE BIG STATES.
! THE FORMAT IS CHARACTER CODE (SUCH AS "ILL"), SUFFEXED BY THE INDEX
! OF BIGSTATE OR SMALSTATE TO WHICH THIS NAME IS BOUND FOLLOWING THE
! STATE TABLE PLITS, FURTHER SUFFEXED BY A B ( FOR BIGSTATE )
! OR S (FOR SMALSTATE).  FOR EXAMPLE IF THE STATENAME "STXXXX"
! IS BOUND TO BIGSTATE[5], THEN THE DEFINITION OF THE RESULTING ACTION
! OF SOME CHARACTER CODE INPUT SUCH AS "ILL", WOULD BE OF THE FORM:
!    BIND  ILL5B  =   ACTXXX ;
!
! ALL PROCESSING DONE BY "LEXICAL" IS DEFINED IN THIS SECTION IN TERMS
! OF STATES AND ACTION MACROS.  
!
! --------------------------------------------------
!
! REQUIRED STRUCTURE FOR THE DEFINITION OF STATES AND ACTIONS:
!
!	1.	ALL STATES WHICH ARE LEXICAL ENTRY STATES, I.E.
!		SPECIFIED BY THE CALLER UPON CALLING, MUST BE BIGSTATES.
!		ALL RETURNS TO THE LEXICAL CALLER MUST CLASSIFY THE 
!		NEXT SIGNIFICANT CHARACTER INTERMS OF BIG CODES BEFORE
!		RETURNING.
!
!	2.
!
!
! --------------------------------------------------
!


!------------------------------ UTILITY MACROS ------------------------------

%UTILMAC%
% A FEW UTILITY MACROS %
EXTERNAL  CODETAB;
MACRO  SMALCODES (I) = .CODETAB [I] <LEFT>  $;
MACRO BIGCODES (I)  = . CODETAB [I]  <RIGHT >  $;
MACRO CODETYPE = @@STATE  $;	! CODETYPE REFERENCE TO STATE TABLES
BIND	B = 1,	!BIGCODES CODE
	S = 0;  !SMALCODES CODE

	% DETERMINE CODETYPE OF CURRENT STATE AND SET CODE ACCORDINGLY %
	MACRO	

SETCODE	=
		IF CODETYPE  EQL  S
		THEN  CODE _ SMALCODE 
		ELSE  CODE _ BIGCODE ;
$;

	% LEAVE TO BIG OR SMAL CHAR ACCORDING TO THE CURRENT STATE %
	MACRO 

LEAVENXT	=
	IF  CODETYPE  EQL  S
	THEN	LEAVE SMALCHAR
	ELSE	LEAVE BIGCHAR
$;

	%SAVE REGISTERS AND RETURN IMMEDIATELY %
	MACRO 

RETURNOW ( VAL ) =
		CHARTMP _ .CHAR;

			IF DBUGIT  THEN
			BEGIN
				EXTERNAL  TRACLEX;
				IF ( CHAR_.BUGOUT AND #10 ) NEQ 0
				THEN	TRACLEX(VAL)
			END;

		RETURN  VAL
$;
	% SKIP TO NEXT SIGNIFICANT CHARACTER AND THEN RETURN %
	MACRO 

RETURNXT ( VAL ) =
		VALUE _ VAL;
		STATE _ STRETNX ;
		LEAVE SMALCHAR
$;

	% CALL NXTSTATE AND RETURN TO RETURNTO WHEN FINISHED%
	MACRO
CALLR ( NXTSTATE, RETURNTO )   =
	STATESTACK [ .STSTKPTR ] _ RETURNTO;
	STSTKPTR _ .STSTKPTR + 1;
	STATE _ NXTSTATE
$;

	%PUSH RETURN STATE ON THE STACK  %
	MACRO 

CALL ( NXTSTATE )  =
		STATESTACK [ .STSTKPTR ] _ .STATE;
		STSTKPTR _ .STSTKPTR + 1;
		STATE _ NXTSTATE 
$;

	% RETURN TO THE CALLING STATE WITH CURRENT CHARACTER %
	MACRO
ACMGOBAKNOW  =
	GOBACK;
	SETCODE
	LEAVE NEWSTATE
$;

	% RETURN TO THE CALLING STATE WITH THE NEXT CHARACTER %
	MACRO
ACMGOBAKNXT  =
	GOBACK;
	LEAVENXT
$;

	% RETURN TO CALLING STATE  %
	MACRO  

GOBACK  =
		STATE _ .STATESTACK [ STSTKPTR _ .STSTKPTR -1 ]
$;





MACRO DVTTY = 21,1$;

	% THIS ACTION WILL SKIP OVER NULLS,  CHECK TO SEE IF ^Z IS AN END
	  OF FILE, AND CHECK FOR END OF STATEMENT BUFFER CONDITIONS 
	  (#177) AND THEN CONTINUE WITH CURRENT STATE.
	%
	MACRO 

ACMEOB  =
	EXTERNAL  GETBUF,OVRESTORE ,SHIFTPOOL;
	
	IF .CHAR EQL 0	! ITS A NULL
	THEN	(
		  DO CHAR _ SCANI (CURPTR )
		  UNTIL  .CHAR NEQ 0;
		  SETCODE
		  LEAVE %TO% NEWSTATE
		);
	IF .CHAR EQL  "?Z"
	THEN
	BEGIN
		EXTERNAL FLAGS2;
		IF .FLAGS2<TTYINPUT>	!IS INPUT DEVICE A TTY ?
		THEN	( %EOF%
			  % JUST DELETE THE ^Z SO WE NEVER SEE IT AGAIN
				MOVE TO THE END OF THE BUFFER, AND 
				DRIVE ON - EVERYTHING SHOULD WORK OUT %
			  .CURPTR _ 0;
			  CURPTR _ (@CURPOOLEND)<36,7>;
			  CHAR _ SCANI(CURPTR);
			  SETCODE;
			  LEAVE NEWACTION
			)
		ELSE
			( % JUST ^Z %
			  CODE _ ILL;
			  LEAVE NEWSTATE 
			)
	END
	ELSE
		%END OF BUFFER%
		( IF CURWORD  NEQ  .CURPOOLEND
		  THEN %NOT REALLY END OF BUFFER %
			( CODE _ ILL;
			  LEAVE NEWSTATE
			)
		  ELSE
			%END OF BUFFER %
			( IF (CHAR _ GETBUF())  NEQ  OVRFLO
			  THEN	( SETCODE
				  LEAVE NEWSTATE
				)
			  ELSE
				%TIME TO SHIFT POOL UP AND MAKE ROOM FOR MORE INPUT%
				( SHIFTPOOL();
				  % NOW BRING IN THE RING BUFFER %
				  IF ( CHAR _ OVRESTORE())  EQL  OVRFLO
				  THEN  % REAL OVERFLOW %
				  CHAR _ OVERFLOW (.INCLAS,CLASERR);
				  % OK PROCEED WITH THE CHARACTER NORMALLY%
				  SETCODE
				  LEAVE NEWSTATE
				)
			)
		)
	
$;

	MACRO
ACMINTERR = INTERR ('LEXICAL'); LEAVENXT   $;


	% IGNORE THE TAB AND ADJUST CHARPOS %
	MACRO  

ACMTABB =
	CHARPOS _ .CHARPOS AND NOT 7;
	LEAVENXT
	
$;

	% IGNORE THE TAB AND ADJUST CHARPOS %
%	MACRO  

ACMTABS =
	CHARPOS _ .CHARPOS AND NOT 7;
	LEAVE SMALCHAR
	
$;
%
	% JUST IGNORE IT  %
%	MACRO	

ACMANYB	=
	LEAVE BIGCHAR
$;
%
	% JUST IGNORE IT  %
	MACRO	

ACMANYS	=
	LEAVENXT
$;

	% TRANSLATE TO UPPER CASE %
	MACRO
ACMUPLOW  =
	CHAR _ .CHAR - #40;
	SETCODE;
	LEAVE NEWSTATE
$;


	% ILLEGAL CHARACTER DETECTED IN THE STATEMENT FIELD %
	MACRO
ACMILLCHAR =
	EXTERNAL  FATLERR;
	% ILLEGAL CHARACTER IN SOURCE %
	FATLERR ( .CHAR,.LINELINE, E8<0,0> );
	REPLACEN ( CURPTR, "??" );
	CALLR ( STSKIP, STSTMNT );
	LEAVE BIGCHAR
$;


	% ENTER THE REMARK STATE %
	MACRO

ACMENTREMARK   =

	ENTREMARK;
	LEAVE SMALCHAR
$;

	% END OF A STATEMENT ON MULTIPLE STATEMENT LINE %
	MACRO

ACMMULTST   =

BEGIN
	CHAR _ EOS;
	CODE _ FOS;
	LEAVE NEWSTATE
END $;





	MACRO
EXTRACRCHK  =
	ISCAN ( CHAR, CURPTR );
	IF ( CODE _ SMALCODE ) NEQ  LT
	THEN	IF CHKXCR()  NEQ  LT
%[713]%		THEN	( IF CODETYPE EQL B THEN CODE _ BIGCODE;
			  LEAVE NEWSTATE
			);
$;


	% HANDLE PRINTING LINE TERMINATORS %
	MACRO  

ACMLT =
	EXTERNAL PRINT;
	
	IF .CHAR EQL CR
	THEN    ( EXTRACRCHK )
	ELSE	IF .FOUNDCR	! CR WAS FOUND IN REMARK PROCESSING 
		THEN  FOUNDCR _ 0
		ELSE  NOCR _ 1;
	
	PRINT ();
	
	% CONTINUATION PROCESSING  %
	ENTCALCONT
	
$;

!------------------------------ CONTINUATION PROCESSING ------------------------------


% SMALL STATE DEFINITION	STCALCONT	NUMBER (#) 5S   %
% CALCULATE THE NEXT LINE (OR LIN SEQ NO.) AND BEGIN PROCESSING
  THE NEXT CONTINUATION FIELD.  RETURN TO THE CALLING STATE WITH
  THE FIRST CHARACTER OF THE STATEMENT FIELD IF ITS A CONTINUATION
  OR WITH EOS IF ITS NOT   %
 % SKIP ALL NULLS AND CR'S%

BIND
	ILL5S	=	ACTCALCONT	,
	TAB5S	=	ACTCALCONT	,
	LT5S	=	ACTIGNCRCALC	,
	BLANK5S	=	ACTCALCONT	,
	SPEC5S	=	ACTCALCONT	,
	DIGIT5S	=	ACTCALCONT	,
	UPPER5S	=	ACTCALCONT	,
	LOWER5S	=	ACTCALCONT	,
	FOS5S	=	ACTCALCONT	,
	EOB5S	=	ACTEOB		,
	REMARK5S	=	ACTCALCONT	;


	% ENTER THE CONTINUATION PROCESSING AFTER COMPUTING LINE NUMBERS  %
	MACRO  

ENTCALCONT  =
		CHARPOS _ 72;
		LINEPTR _ .CURPTR;	! RECORD THE BEGINNING OF THE LINE
		CALL ( STCALCONT );
		LEAVE SMALCHAR;			! WITH THE NEXT CHARACTER
	
$;


	% IGNORE CR'S FOLLOWING THE LINE TERMINATOR  %
	MACRO  

ACMIGNCRCALC  =
		IF .CHAR EQL  CR
		THEN	( CHARPOS _ .CHARPOS - 1 ; ! ADJUST LINE POSITION
			  LEAVE SMALCHAR
			)
		ELSE	( % BEGIN CONTINUATION PROCESSING WITH THIS CHARACTER %
			  ACTION _ ACTCALCONT;
			  LEAVE NEWACTION;
			)
	
$;

	%  CALCULATE LINE NUMBER ( OR LINE SEQUENCE NO) AND THEN BEGIN
	  CONTINUATION PROCESSING.  RETURN TO THE CALLER
	  WITH THE FIRST CHARACTER OF THE STATEMENT FIELD IF ITS A CONTINUATION
	  LINE OR EOS IF ITS NOT  %
	MACRO 

ACMCALCONT   =
	
		EXTERNAL  LINESEQNO;

		LASTLINE _ .LINELINE;	! SAVE LINE NUMBER
		% CHECK FOR LINE SEQ NO. AND SET LINELINE  %
		IF LINESEQBIT   % TEST LINE SEQ BIT  %
		THEN	( LINELINE _ LINESEQNO( CURPTR<ADRS> );	! DECODE NUMBER
			  LINEPTR _ .CURPTR; ! ADJUST BEGINNING PTR
			  ISCAN ( CHAR , CURPTR )
			)
		ELSE	% NO LINE SEQ NO %
			LINELINE _ .LINELINE + 1
		;
		
		% RETURN IF YOU ARE PROCESSING A COMMENT %
		IF  .INCOMNT  NEQ  0
		THEN	CODE _ FOS	! CAUSES STCONTINUE TO BELIEVE ITS HIT EOS
		ELSE	CODE _ BIGCODE;

			CONTPTR _ .LINEPTR;	! SET CONTINUATION BACKUP PTR
			STATE  _ STCONTINUE;	! ENTER CONTINUATION PROCESSING
			LEAVE NEWSTATE;		! WITH CURRENT CHARACTER

	
$;


!----------------------------------------------------------------------

! THE FOLLOWING STATES PROCESS THE CONTINUATION LINE CHECKING

% BIG STATE DEFINITION	STCONTINUE	NUMBER (#) 4B  %
% CONTINUATION LINE CHECK, FIRST CHARACTER OF THE LINE %

BIND
![670] CHANGE CONTINUATION LINE PROCESSING SO THAT THE
![670] LABEL FIELD MUST CONSIST OF ONLY BLANK CHARACTERS AS PER THE
![670] ANSI 1977 STANDARD.
%[670]%	ILL4B	=	ACTNOCONT	,
	TAB4B	=	ACTCITCONT	,
	LT4B	=	ACTCLABLT	,
	BLANK4B	=	ACTENTCLABSKP	,
%[670]%	SPEC4B	=	ACTNOCONT	,
%[670]%	DIGIT4B	=	ACTNOCONT	,
%[670]%	UPPER4B=	ACTNOCONT	,
	LOWER4B	=	ACTUPLOW	,
	FOS4B	=	ACTNOCONT	,
	EOB4B	=	ACTEOB	,
	REMARK4B	=	ACTNOCONT	,
%[670]%	EQUAL4B	=	ACTNOCONT	,
%[670]%	LPAREN4B	=	ACTNOCONT	,
%[670]%	RPAREN4B	=	ACTNOCONT	,
%[670]%	COLON4B	=	ACTNOCONT	,
%[670]%	COMMA4B	=	ACTNOCONT	,
	DOLLAR4B	=	ACTNOCONT	,
	ASTERISK4B	=	ACTNOCONT	,
	SLASH4B	=	ACTNOCONT	,
%[670]%	PLUS4B	=	ACTNOCONT	,
%[670]%	MINUS4B	=	ACTNOCONT	,
%[670]%	ANDSGN4B	=	ACTNOCONT	,
%[670]%	LITSGN4B	=	ACTNOCONT	,
%[670]%	OCTSGN4B	=	ACTNOCONT	,
%[670]%	NEQSGN4B	=	ACTNOCONT	,
%[670]%	DOT4B	=	ACTNOCONT	,
%[670]%	SEMICOL4B	=	ACTNOCONT	,
%[670]%	LTSGN4B	=	ACTNOCONT	,
%[670]%	GTSGN4B	=	ACTNOCONT	,
	COMNTSGN4B	=	ACTNOCONT	,
	DEBUGSGN4B	=	ACTCBUGCHK	,
%[670]%	UPAROW4B	=	ACTNOCONT	;


% SMALL STATE DEFINITION	STCLABSKP	NUMBER (#) 6S  %
% CONTINUATION LINE CHECK,  SKIP THE LABEL FIELD  %

BIND
%[670]%	ILL6S	=	ACTNOCONT	,
	TAB6S	=	ACTCITCONT	,
	LT6S	=	ACTCLABLT	,
	BLANK6S	=	ACTCLABSKP	,
%[670]%	SPEC6S	=	ACTNOCONT	,
%[670]%	DIGIT6S	=	ACTNOCONT	,
%[670]%	UPPER6S	=	ACTNOCONT	,
%[670]%	LOWER6S	=	ACTNOCONT	,
	FOS6S	=	ACTNOCONT	,
	EOB6S	=	ACTEOB	,
%[670]%	REMARK6S	=	ACTNOCONT	;


% SMALL STATE DEFINITION	STCNTCONT	NUMBER (#) 7S  %
% CONTINUAATION FIELD, CONTINUATION CHECK, NO INITIAL TAB %
BIND
	ILL7S	=	ACTNOCONT	,
	TAB7S	=	ACTCITCONT	,
	LT7S	=	ACTCLABLT	,
	BLANK7S	=	ACTNOCONT	,
	SPEC7S	=	ACTGOBAKNXT	,
	DIGIT7S	=	ACTCONTDIG	,
	UPPER7S	=	ACTGOBAKNXT	,
	LOWER7S	=	ACTGOBAKNXT	,
	FOS7S	=	ACTNOCONT	,
	EOB7S	=	ACTEOB	,
	REMARK7S	=	ACTGOBAKNXT	;


% SMALL STATE DEFINITION	STCITCONT	NUMBER (#) 8S  %
% CONTINUATION FIELD, CONTINUATION LINE CHECK, INITIAL TAB %

BIND
	ILL8S	=	ACTNOCONT	,
	TAB8S	=	ACTNOCONT	,
	LT8S	=	ACTCLABLT	,
	BLANK8S	=	ACTNOCONT	,
	SPEC8S	=	ACTNOCONT	,
	DIGIT8S	=	ACTCONTDIG	,
	UPPER8S	=	ACTNOCONT	,
	LOWER8S	=	ACTNOCONT	,
	FOS8S	=	ACTNOCONT	,
	EOB8S	=	ACTEOB	,
	REMARK8S	=	ACTNOCONT	;



!--------------------------------------------------

! CONTINUATION LINE LABEL FIELD PROCESSING MACROS

	% ENTER STATE WHICH SKIPS THE CONTINUATION LABEL FIELD %
	MACRO
ACMENTCLABSKP  =
	STATE _ STCLABSKP;
	LEAVE SMALCHAR
$;


	% DEBUG LINE IN CONTINUATION LOOKAHEAD %
	MACRO
ACMCBUGCHK  =
	% CHECK THE INCLUDE SWITCH  %
	IF .FLGREG<INCLUDE>  
	THEN
	BEGIN	%ITS NOT A COMMENT PROCESS IT%
		STATE _ STCLABSKP;
		LEAVE SMALCHAR
	END
	ELSE
	BEGIN	% ITS A COMMENT %
		ACTION _ ACTNOCONT ;
		LEAVE NEWACTION
	END
$;

	% SKIP THE LABEL FIELD %
	MACRO
ACMCLABSKP  =
	IF .CHARPOS NEQ  67  % POSITION 5%
	THEN LEAVE SMALCHAR
	ELSE
	BEGIN	% END OF THE LABEL FIELD %
		STATE _ STCNTCONT;	! NO INITIAL TAB CONTINUATION CHECK
		LEAVE SMALCHAR
	END
$;

	%ENTER THE CONTINUATION LINE INITIAL TAB, CONTINUATION FIELD CHECK%
	MACRO
ACMCITCONT  =
	STATE _ STCITCONT;
	LEAVE SMALCHAR
$;

	% LINE TERMINATORS FOR THE CONTINUATION LINE CHECK %
	MACRO
ACMCLABLT   =
	!WE WANT TO IGNORE FORM FEEDS HERE - OTHERWISE THEY WILL 
	! PREVENT CONTINUATION LINES AFTERWARDS
	IF NOT ( SPURCR() OR SPURFF())
	THEN
	BEGIN	% A LINE TERMINATOR ENCOUNTERED BEFORE THE STATEMENT
		  FIELD IMPLIES NO CONTINUATION %
		ACTION _ ACTNOCONT;
		LEAVE NEWACTION
	END
	ELSE
	BEGIN	% ITS AN EXTRANEOUS CR %
		% SET BIGCODE IF NECESSARY %
		IF CODETYPE EQL  B
		THEN CODE _ BIGCODE;
		LEAVE  NEWSTATE
	END
$;


	% DIGIT IN CONTINUATION FIELD OR FOLLOWING INITIAL TAB %
	MACRO
ACMCONTDIG   =
	IF .CHAR  NEQ  "0"
	THEN
	BEGIN	% 1 THRU 9 ARE CONTINUATION INDICATORS %
		CHARPOS _ 66;	! IN CASE OF INITIAL TAB
		GOBACK;
		LEAVENXT
	END
	ELSE
	BEGIN	% A 0 IMPLIES NO CONTINUATION%
		ACTION _ ACTNOCONT;
		LEAVE NEWACTION
	END
$;


	%  BACKUP  %
	MACRO  

ACMNOCONT  =
	CHARPOS _ 72;
	CURPTR _ .CONTPTR;
	IF .CHAR NEQ EOF  THEN  CHAR _ EOS;
	CODE _ FOS ;
	
	% RETURN TO CALLER  %
	GOBACK;
	LEAVE NEWSTATE  ;
	
$;



!------------------------------ REMARKS OR PAST POSITION 72 ------------------------------


%STMACS%
%BEGIN DEFINING THE SPECIFIC STATES AND THEIR ACTION MACROS %

% SMALL STATE DEFINITION	STREMARK	NUMBER (#) 0S  %
!
! PROCESSES REMARKS FOLLOWING A "!" IN THE STATEMENT FIELD OR PAST 
! CARACTER POSITION 72
!

BIND
	ILL0S	=	ACTANYS	,
	TAB0S	=	ACTANYS	,
	LT0S	=	ACTREMEND	,
	BLANK0S	=	ACTANYS	,
	SPEC0S	=	ACTANYS	,
	DIGIT0S	=	ACTANYS	,
	UPPER0S	=	ACTANYS	,
	LOWER0S	=	ACTANYS	,
	FOS0S	=	ACTREMEND	,
	EOB0S	=	ACTEOB	,
	REMARK0S	=	ACTANYS	;

	% ENTER THE REMARK STATE %
	MACRO  

ENTREMARK  =
		CALL  (STREMARK);
	
$;



	% LINE TERMINATION PROCESSING FOR REMARK STATE  %
	MACRO	

ACMREMEND	=
	IF .CHAR EQL CR
	THEN	( EXTRACRCHK;
		  FOUNDCR _ 1
		);
	% RETURN TO CALLING STATE %
	GOBACK;
	LEAVE NEWSTATE
	
$;




!------------------------------ FIRST PROGRAM UNIT INITIALIZATION ------------------------------


% SMALL STATE DEFINITION	STINIT	NUMBER (#) 1S  %
% INITILIZATION OF LEXICAL AT THE BEGINNING OF THE FIRST PROGRAM UNIT %

BIND
	ILL1S	=	ACTINIT	,
	TAB1S	=	ACTINIT	,
	LT1S	=	ACTINIT	,
	BLANK1S	=	ACTINIT	,
	SPEC1S	=	ACTINIT	,
	DIGIT1S	=	ACTINIT	,
	UPPER1S	=	ACTINIT	,
	LOWER1S	=	ACTINIT	,
	FOS1S	=	ACTINIT	,
	EOB1S	=	ACTEOB	,
	REMARK1S	=	ACTINIT	;

	% INITIALIZE LINELINE AND LEXICAL AFTER SKIPPING ALL NULLS AND CR'S%
	MACRO	

ACMINIT	=
	% HANDLE EOF %
	IF .CODE EQL FOS THEN  RETURN ENDOFILE<0,0>;
	% IGNORE INITIAL CR'S %
	IF .CHAR EQL CR
	THEN	( CHARPOS _ .CHARPOS -1 ;
		  LEAVE SMALCHAR
		);
	
	IF LINESEQBIT   %IS SET THEN ITS A LINE SEQUENCE NO %
	THEN	LINELINE _ LINESEQNO ( CURPTR<ADRS> )
	ELSE	( IF NOT .FLGREG<ININCLUD>  THEN  LINELINE _ 1;
		  DECREMENT ( CURPTR<ADRS> )
		);
	CHARTMP _ EOS;
	CHARPOS _ 72;
	LINEPTR _ .CURPTR;
	RETURN NOT ENDOFILE<0,0>
	
$;







!------------------------------ NEW STATEMENT ------------------------------


% BIG STATE DEFINITION	STSTMNT	NUMBER (#) 0B   %
% THIS IS THE STATEMENT CLASSIFICATION ENTRY POINT.  IT WILL FIRST
  SKIP ANY OF THE LAST STATEMENT WHICH WASN'T READ IN, SKIP ALL
  COMMENTS, NULL STATEMENTS, UNRECOGNIZED STATEMENTS, UNTIL FINALLY
  IT CAN CLASSIFY A STATEMENT OR END OF FILE IS REACHED.  IT WILL
  RETURN WITH THE CLASSIFICATION OR END OF FILE.
%

BIND
	ILL0B	=	ACTSTSKIP	,
	TAB0B	=	ACTSTSKIP	,
	LT0B	=	ACTSTSKIP	,
	BLANK0B	=	ACTSTSKIP	,
	SPEC0B	=	ACTSTSKIP	,
	DIGIT0B	=	ACTSTSKIP	,
	UPPER0B	=	ACTSTSKIP	,
	LOWER0B	=	ACTSTSKIP	,
	FOS0B	=	ACTSTMNTFOS	,
	EOB0B	=	ACTEOB	,
	REMARK0B	=	ACTSTSKIP	,
	EQUAL0B	=	ACTSTSKIP	,
	LPAREN0B	=	ACTSTSKIP	,
	RPAREN0B	=	ACTSTSKIP	,
	COLON0B	=	ACTSTSKIP	,
	COMMA0B	=	ACTSTSKIP	,
	DOLLAR0B	=	ACTSTSKIP	,
	ASTERISK0B	=	ACTSTSKIP	,
	SLASH0B	=	ACTSTSKIP	,
	PLUS0B	=	ACTSTSKIP	,
	MINUS0B	=	ACTSTSKIP	,
	ANDSGN0B	=	ACTSTSKIP	,
	LITSGN0B	=	ACTSTSKIP	,
	OCTSGN0B	=	ACTSTSKIP	,
	NEQSGN0B	=	ACTSTSKIP	,
	DOT0B	=	ACTSTSKIP	,
	SEMICOL0B	=	ACTSTSKIP	,
	LTSGN0B	=	ACTSTSKIP	,
	GTSGN0B	=	ACTSTSKIP	,
	COMNTSGN0B	=	ACTSTSKIP	,
	DEBUGSGN0B	=	ACTSTSKIP	,
	UPAROW0B	=	ACTSTSKIP	;

	% CHECK HERE TO SEE THAT THERE HAS BEEN AN ERROR MESSAGE %
	MACRO 

ACMSTSKIP =
	EXTERNAL  FATLERR,MSGNOTYPD;

	IF ( NOT .MSGNOTYPD AND NOT .ERRFLAG ) OR  .CLASERR NEQ  0
	THEN	% THE STATEMENT WAS NOT PROCESSID TO THE END AND
		  NO MESSAGE WAS TYPED, SO %
		IF .CLASERR NEQ 0
		THEN
		BEGIN	% CLASSIFIER WILL RETURN HERE IF IT CANNOT RECOGNIZE THE STATEMENT %
			FATLERR ( .ISN,  E10<0,0> );
			CLASERR _ 0
		END
		ELSE
		BEGIN	% ALL OTHER STATEMENTS SHOULD BE PROCESSED FULLY
			  OR HAVE AN ERROR MESSAGE OUTPUT  %
			INTERR ('STSKIP')
		END;

	%SKIP TO EOS %
	CALLR ( STSKIP ,STSTMNT);
	LEAVE NEWSTATE
	
$;


ROUTINE

INITLZSTMNT  =

BEGIN
	EXTERNAL  MSGNOTYPD,ERRLINK,ERRFLAG;

	% INITIALIZATION FOR THE BEGINNING OF A STATEMENT  %
	% OUTPUT MESSAGES FOR MULTIPLE STATEMENTS %
	IF NOT .FLGREG<TTYDEV> AND .CHARPOS NEQ 72
		AND  ( .ERRFLAG  OR  .MSGNOTYPD  )
	THEN
	BEGIN	% THERE ARE MESSAGES OR LINES TO BE OUTPUT TO TTY %
		LOCAL PTR;

		BACKTYPE ( ALLCHAR );	! TYPE OR FINISH TYPING THE STATEMENT
	
		% NOW OUTPUT THE MESSAGES IF ANY %
		MSGNOTYPD _ 0;	! CLEAR MESSAGES TO BE TYPED FLAG
		PTR _ .ERRLINK<RIGHT>;
		UNTIL  .PTR<RIGHT>  EQL  0
		DO
		BEGIN
			IF NOT .ERRTYPD( PTR )
			THEN
			BEGIN	% THE MESSAGE WAS NOT YET TYPED SO TYPE  IT %
				REGISTER  MSG;
				EXTERNAL  BLDMSG,ERRMSG;
				MACHOP OUTSTR = #051;
				MSG _ BLDMSG ( .ERRMSG[.EMSGNUM(PTR)],.PTR<RIGHT>);
				OUTSTR (3,0,MSG);
				ERRTYPD(PTR) _ 1
			END;
			PTR  _ @@PTR
		END  % MESSAGE LOOP %
	END; % MESSAGE OUTPUT CHECK %
	
	
		  LEXLINE _ .LINELINE;	! MUST BE SET IN CASE WE GOT HERE AFTER SKIPING THE LAST STATEMENT
		  ERRFLAG _ 0;
		  STPOS _ .CHARPOS;	! LINE POSITION OF CHARACTER
		  ISN _ .LINELINE;	! LINE NUMBER
		  STPTR _ .CURPTR;	! BEGINNING CHARACTER POSITION
		  STLPTR _ .LINEPTR;	! BEGINNING OF LINE
		  STALABL _ 0;
		  ZEROCHK _ 0;	! SET TO 1 IF DIGIT ENCOUNTERED IN THE
				! LABEL FIELD, USED TO CHECK FOR ZERO LABEL

END;  % INITIALIZE %

	% EOF AND EOS HANDLING FOR THE BEGINNING OF THE STATEMENT %
	MACRO  

ACMSTMNTFOS  =
	% THIS IS WHERE THE STATEMENT INITIALIZATION TAKES PLACE %
	
	IF .CHAR EQL  EOF
	THEN	(  RETURNOW ( ENDOFILE<0,0>)
		  % THIS IS THE ONLY PLACE EOF IS RETURNED FROM EXCEPT LEXINI %
		)
	ELSE
		( %EOS  SO BEGIN A NEW STATEMENT %
		  INITLZSTMNT();
		  % CHECK FOR MULTIPLE STATEMENTS %
		  IF .CHARPOS  NEQ  72
		  THEN
		  BEGIN	% IT IS MULTIPLE SO PROCEED TO NULL STATEMENT %
			STATE _ STNULLST;
			LEAVE SMALCHAR
		  END
		  ELSE
		  BEGIN
			  STATE _ STILINE;	! PROCEED TO INITIAL LINE PROCESSING
			  LEAVE BIGCHAR
		  END
		)
$;

!------------------------------ NORMAL END OF PROGRAM UNIT ------------------------------


% BIG STATE DEFINITION	STEOP	NUMBER (#) 6B  %
% IT IS THE END OF THE PROGRAM UNIT SO SKIP TO THE END OF THE CURRENT
  STATEMENT AND BRING THINGS UP TO DATE  %

BIND
	ILL6B	=	ACTINTERR	,
	TAB6B	=	ACTINTERR	,
	LT6B	=	ACTINTERR	,
	BLANK6B	=	ACTINTERR	,
	SPEC6B	=	ACTINTERR	,
	DIGIT6B	=	ACTINTERR	,
	UPPER6B	=	ACTINTERR	,
	LOWER6B	=	ACTINTERR	,
	FOS6B	=	ACTSTEOP	,
	EOB6B	=	ACTEOB	,
	REMARK6B	=	ACTINTERR	,
	EQUAL6B	=	ACTINTERR	,
	LPAREN6B	=	ACTINTERR	,
	RPAREN6B	=	ACTINTERR	,
	COLON6B	=	ACTINTERR	,
	COMMA6B	=	ACTINTERR	,
	DOLLAR6B	=	ACTINTERR	,
	ASTERISK6B	=	ACTINTERR	,
	SLASH6B	=	ACTINTERR	,
	PLUS6B	=	ACTINTERR	,
	MINUS6B	=	ACTINTERR	,
	ANDSGN6B	=	ACTINTERR	,
	LITSGN6B	=	ACTINTERR	,
	OCTSGN6B	=	ACTINTERR	,
	NEQSGN6B	=	ACTINTERR	,
	DOT6B	=	ACTINTERR	,
	SEMICOL6B	=	ACTINTERR	,
	LTSGN6B	=	ACTINTERR	,
	GTSGN6B	=	ACTINTERR	,
	COMNTSGN6B	=	ACTINTERR	,
	DEBUGSGN6B	=	ACTINTERR	,
	UPAROW6B	=	ACTINTERR	;

	% WE ARE AT THE END OF THE LAST STATEMENT IN THE PROGRAM UNIT %
	MACRO  

ACMSTEOP  =
	
	IF .CHAR EQL  EOF
	THEN
	BEGIN
		IF .CHARPOS LSS 71
		THEN % PARTIAL LINE LEFT TO BE PRINTED %
		BEGIN
			DECREMENT ( CURPTR<ADRS> );
			PRINT()
		END;
		RETURN  ENDOFILE<0,0>
	END;
	
	%ELSE EOS
	  PRINT PARTIAL LINE IF ANY AND THEN INITIALIZE FOR THE NEXT STATEMENT%
	
	IF .CHARPOS  NEQ  72
	THEN
	BEGIN  % THIS STATEMENT DOES NOT START AT THE BEGINNING OF A LINE %
		% PRINT BEGINNING OF LINE %
		PRINT ();
	END;
	INITLZSTMNT();	! NEW STATEMENT INITIALIZATION
	
	RETURN  NOT ENDOFILE<0,0>
	
$;


!------------------------------ MISSING "END".  END OF PROGRAM UNIT ------------------------------


% BIG STATE DEFINITION	STNOEND	NUMBER (#) 5B  %
% THIS PROGRAM UNIT HAS NO END STATEMENT SO BACK UP TO THE BEGINNING
  OF THE CURRENT STATEMENT BECAUSE IT BELONGS WITH THE NEXT PROGRAM
  UNIT AND THEN TRANSFER CONTROL TO THE NORMAL END OF PROGRAM PROCESSING %

BIND
	ILL5B	=	ACTNOEND	,
	TAB5B	=	ACTNOEND	,
	LT5B	=	ACTNOEND	,
	BLANK5B	=	ACTNOEND	,
	SPEC5B	=	ACTNOEND	,
	DIGIT5B	=	ACTNOEND	,
	UPPER5B	=	ACTNOEND	,
	LOWER5B	=	ACTNOEND	,
	FOS5B	=	ACTNOEND	,
	EOB5B	=	ACTNOEND	,
	REMARK5B	=	ACTNOEND	,
	EQUAL5B	=	ACTNOEND	,
	LPAREN5B	=	ACTNOEND	,
	RPAREN5B	=	ACTNOEND	,
	COLON5B	=	ACTNOEND	,
	COMMA5B	=	ACTNOEND	,
	DOLLAR5B	=	ACTNOEND	,
	ASTERISK5B	=	ACTNOEND	,
	SLASH5B	=	ACTNOEND	,
	PLUS5B	=	ACTNOEND	,
	MINUS5B	=	ACTNOEND	,
	ANDSGN5B	=	ACTNOEND	,
	LITSGN5B	=	ACTNOEND	,
	OCTSGN5B	=	ACTNOEND	,
	NEQSGN5B	=	ACTNOEND	,
	DOT5B	=	ACTNOEND	,
	SEMICOL5B	=	ACTNOEND	,
	LTSGN5B	=	ACTNOEND	,
	GTSGN5B	=	ACTNOEND	,
	COMNTSGN5B	=	ACTNOEND	,
	DEBUGSGN5B	=	ACTNOEND	,
	UPAROW5B	=	ACTNOEND	;


	MACRO  

ACMNOEND  =
	IF .CHAR  EQL  EOF
	THEN
	BEGIN
		ACTION _ ACTSTEOP;
		LEAVE NEWACTION
	END
	ELSE
	BEGIN	% BACK UP TO THE BEGINNING OF THE STATEMENT %
		CURPTR _ .STPTR;
		CHARPOS _ .STPOS;
		LINELINE _ .ISN;

		% CHECK TO SEE IF THERE MIGHT BE SOME PORTION UNPRINTED%
		IF .CHARPOS NEQ 72
		THEN	% ITS POSSIBLE %
			IF .LINEPTR  EQL  .STLPTR
			THEN	% IT HASN'T BEEN PRINTED %
				 PRINT();

		 ERRFLAG _ 0 ;	! CLEARED SO INITLZ DOSEN'T TRY TO PRINT
					! A STATEMENT WHOSE END IT DOSEN'T KNOW


		LINEPTR _ .STLPTR		;

		INITLZSTMNT();	! INITIALIZE THE STATEMENT
		RETURN  NOT  ENDOFILE<0,0>
	END;
$;




!------------------------------ STATEMENT SKIPPING ------------------------------

!----------------------------------------------------------------------


% BIG STATE DEFINITION	STSKIP	NUMBER (#) 3B  %

BIND
	ILL3B	=	ACTSKILL	,
	TAB3B	=	ACTTABB	,
	LT3B	=	ACTLT	,
	BLANK3B	=	ACTANYB	,
	SPEC3B	=	ACTANYB	,
	DIGIT3B	=	ACTENTERM	,
	UPPER3B	=	ACTENTERM	,
	LOWER3B	=	ACTENTERM	,
	FOS3B	=	ACTUNMATEOS	,
	EOB3B	=	ACTEOB	,
	REMARK3B	=	ACTENTREMARK	,
	EQUAL3B	=	ACTANYB	,
	LPAREN3B	=	ACTENTERM	,
	RPAREN3B	=	ACTUNMATCHK	,
	COLON3B	=	ACTANYB	,
	COMMA3B	=	ACTANYB	,
	DOLLAR3B	=	ACTANYB	,
	ASTERISK3B	=	ACTANYB	,
	SLASH3B	=	ACTANYB	,
	PLUS3B	=	ACTANYB	,
	MINUS3B	=	ACTANYB	,
	ANDSGN3B	=	ACTANYB	,
	LITSGN3B	=	ACTENTERM	,
	OCTSGN3B	=	ACTANYB	,
	NEQSGN3B	=	ACTANYB	,
	DOT3B	=	ACTANYB	,
	SEMICOL3B	=	ACTMULTST	,
	LTSGN3B	=	ACTANYB	,
	GTSGN3B	=	ACTANYB	,
	COMNTSGN3B	=	ACTENTERM	,
	DEBUGSGN3B	=	ACTENTERM	,
	UPAROW3B	=	ACTANYB	;



!----------------------------------------------------------------------

! THE FOLLOWING MACROS CONTROL THE SKIPPING OF STATEMENTS

	% PROBABLY AN UNMATCHED ).  REPORT ONLY IF .CLASERR %
!	MACRO
!ACMUNMATCHK  =
!	IF .CLASERR  NEQ  0
!	THEN
!	BEGIN	% UNMATCHED ) %
!		FATLERR (.ISN,E9<0,0>);
!		CLASERR _ 0
!	END;
!	LEAVE BIGCHAR
!$;
! THIS ROUTINE IS INCLUDED IN ACMSKILL

	% REPORT ILLEGAL CHARACTER IF .CLASERR %
	MACRO
ACMSKILL  =
	IF .CLASERR
	THEN
	BEGIN
		IF .CODE EQL  RPAREN 
		THEN	FATLERR(.ISN,E9<0,0>)	! UNMATCHED )
		ELSE	( FATLERR (.CHAR,.LINELINE,E8<0,0>);
			REPLACEN(CURPTR,"??"));
		CLASERR _ 0;
	END;
	LEAVE BIGCHAR
$;

	% CALL STTERM TO SKIP SOME LEXICAL CONSTRUCT  %
	MACRO
ACMENTERM   =
	CALL ( STTERM );
	PAREN _ 0;	! THIS MUST BE SET BECAUSE THE CLASSIFIER ENTERS AT THE 1 LEVEL
	LEAVE NEWSTATE
$;

	% CHECK FOR UNMATCHED PARENS %
	MACRO
ACMUNMATEOS  =
	 IF .CLASERR NEQ 0  AND  .PAREN NEQ 0
	THEN
	BEGIN	% UNMATCHED LEFT PAREN DETECTED IN THE CLASSIFIER %
		FATLERR(.ISN,E9<0,0>);
	END;
	CLASERR _ 0;
	GOBACK;		! WITH EOS OR EOF
	LEAVE NEWSTATE
$;





!------------------------------ SKIP LEXICAL CONSTRUCTS ------------------------------

!----------------------------------------------------------------------

! STATES WHICH SKIP OVER LEXEMES.  THEY ARE USED BY THE CLASSIFIER AND
! STSKIP TO PASS OVER THE STATEMENT

% BIG STATE DEFINITION	STTERM	NUMBER (#) 7B  %
% SKIPS OVER LEXICAL CONSTRUCTS - %

BIND
	ILL7B	=	ACTGOBAKNOW	,
	TAB7B	=	ACTTABB	,
	LT7B	=	ACTEXPLT	,
	BLANK7B	=	ACTANYB	,
	SPEC7B	=	ACTANYB	,
	DIGIT7B	=	ACTCONSTSKP	,
	UPPER7B	=	ACTSKNAME	,
	LOWER7B	=	ACTSKNAME	,
	FOS7B	=	ACTGOBAKNOW	,
	EOB7B	=	ACTEOB	,
	REMARK7B	=	ACTENTREMARK	,
	EQUAL7B	=	ACTANYB	,
	LPAREN7B	=	ACTSKLPAREN	,
	RPAREN7B	=	ACTSKRPAREN	,
	COLON7B	=	ACTANYB	,
	COMMA7B	=	ACTSKCOMMA	,
	DOLLAR7B	=	ACTANYB	,
	ASTERISK7B	=	ACTANYB	,
	SLASH7B	=	ACTANYB	,
	PLUS7B	=	ACTANYB	,
	MINUS7B	=	ACTANYB	,
	ANDSGN7B	=	ACTANYB	,
	LITSGN7B	=	ACTGETLIT	,
	OCTSGN7B	=	ACTANYB	,
	NEQSGN7B	=	ACTANYB	,
	DOT7B	=	ACTANYB	,
	SEMICOL7B	=	ACTMULTST	,
	LTSGN7B	=	ACTANYB	,
	GTSGN7B	=	ACTANYB	,
	COMNTSGN7B	=	ACTSKNAME	,
	DEBUGSGN7B	=	ACTSKNAME	,
	UPAROW7B	=	ACTANYB	;


% SMALL STATE DEFINITION	STGETLIT	NUMBER (#) 13S  %
% PICKS UP ' LITERALS  %

BIND
	ILL13S	=	ACTANYS	,
	TAB13S	=	ACTTABS	,
	LT13S	=	ACTEXPLT	,
	BLANK13S	=	ACTANYS	,
	SPEC13S	=	ACTENDLIT	,
	DIGIT13S	=	ACTANYS	,
	UPPER13S	=	ACTANYS	,
	LOWER13S	=	ACTANYS	,
	FOS13S	=	ACTGOBAKNOW	,
	EOB13S	=	ACTEOB	,
	REMARK13S	=	ACTANYS	;


% SMALL STATE DEFINITION	STSKNAME	NUMBER (#) 14S  %
% SKIPS IDENTIFIERS  %

BIND
	ILL14S	=	ACTGOBAKNOW	,
	TAB14S	=	ACTTABS	,
	LT14S	=	ACTEXPLT	,
	BLANK14S	=	ACTANYS	,
	SPEC14S	=	ACTBAKTOTERM	,
	DIGIT14S	=	ACTANYS	,
	UPPER14S	=	ACTANYS	,
	LOWER14S	=	ACTANYS	,
	FOS14S	=	ACTGOBAKNOW	,
	EOB14S	=	ACTEOB	,
	REMARK14S	=	ACTENTREMARK	;


% SMALL STATE DEFINITION	STCONSTSKP	NUMBER (#) 15S  %
%  SKIPS CONSTANTS FOLLOWED BY H ( HOLERITH ) OR X FOR FORMATS %

BIND
	ILL15S	=	ACTGOBAKNOW	,
	TAB15S	=	ACTTABS	,
	LT15S	=	ACTEXPLT	,
	BLANK15S	=	ACTANYS	,
	SPEC15S	=	ACTBAKTOTERM	,
	DIGIT15S	=	ACTSKCONBLD	,
	UPPER15S	=	ACTSKPHOLX	,
	LOWER15S	=	ACTUPLOW	,
	FOS15S	=	ACTGOBAKNOW	,
	EOB15S	=	ACTEOB	,
	REMARK15S	=	ACTENTREMARK	;


% SMALL STATE DEFINITION	STSKPHOL	NUMBER (#) 16S  %

BIND
	ILL16S	=	ACTSKPHOL	,
	TAB16S	=	ACTHOLTAB	,
	LT16S	=	ACTEXPLT	,
	BLANK16S	=	ACTSKPHOL	,
	SPEC16S	=	ACTSKPHOL	,
	DIGIT16S	=	ACTSKPHOL	,
	UPPER16S	=	ACTSKPHOL	,
	LOWER16S	=	ACTSKPHOL	,
	FOS16S	=	ACTGOBAKNOW	,
	EOB16S	=	ACTEOB	,
	REMARK16S	=	ACTSKPHOL	;




!----------------------------------------------------------------------

! THE FOLLOWING ACTIONS CONTROL THE SKIPPING OF LEXICAL CONSTRUCTS %

	% DETERMINE WHETHER CLASSIFICATION OR SKIPPING ANY HANDLE
	  LINE TERMINATORS ACCORDINGLY  %
	MACRO
ACMEXPLT  =

	IF .INCLAS  NEQ  0
	THEN	ACTION _ ACTCLASLT	! CLASSIFICATION SO NO PRINTING

	ELSE	ACTION _ ACTLT;		! SKIPPING SO PRINT LINE

	LEAVE NEWACTION
$;

	% ENTER THE CONSTANT PICKUP STATE %
	MACRO
ACMCONSTSKP  =
	STATE _ STCONSTSKP;
	HOLCONST _ .CHAR - "0";
	LEAVE SMALCHAR
$;

	% ENTER THE NAME SKIPPING STATE %
	MACRO
ACMSKNAME    =
	CODE _ SMALCODE;
	STATE _ STSKNAME;
	LEAVE NEWSTATE
$;


OWN PAREN;	! COUNT OF PARENS FOR CLASSIFICATION AND SKIPPING

	% LEFT PAREN ENCOUNTERED  %
	MACRO
ACMSKLPAREN  =
	PAREN _ .PAREN +1;
	LEAVE BIGCHAR
$;

	% RIGHT PAREN ENCOUNTERED %
	MACRO
ACMSKRPAREN  =
	IF ( PAREN _ .PAREN - 1 ) GTR 0
	THEN
	BEGIN	% SKIP OVER NESTED PARENS AND CONTINUE %
		LEAVE BIGCHAR
	END
	ELSE
	BEGIN	
		GOBACK;
		IF .PAREN  LSS 0
		THEN		! UNMATCHED ")", RETURN IT TO CALLER
		BEGIN
			IF CODETYPE EQL S  THEN  CODE _ SMALCODE;
			LEAVE NEWSTATE
		END
		ELSE	(LEAVENXT);	! END OF NEST, SKIP IT AND RETURN
	END
$;

	% SKIP COMMA IF IN NESTED PAREN  %
	MACRO
ACMSKCOMMA  =
	IF .PAREN  NEQ  0
	THEN	LEAVE BIGCHAR	! SKIP IT
	ELSE
	BEGIN	% RETURN IT TO CALLER %
		GOBACK;
		LEAVE NEWSTATE
	END
$;

GLOBAL  MSNGTIC;	! THIS FLAG IS SET IF THERE IS WHAT APPEARS TO BE AN
			! UNTERMINATED LIT STRING.  THE CLASSIFIER WILL THEN
			! LET UNMATCHED PARENS GO BY SO THAT IT CAN CLASSIFY
			! IO STATEMENTS WITH THE DAMN IBM ' RECORD MARK IN THEM

	% ENTER LITERAL PICKUP STATE %
	MACRO
ACMGETLIT  =
	MSNGTIC _ 1;	!SET MISSING TIC FLAG
	STATE _ STGETLIT;
	LEAVE SMALCHAR
$;

	% RETURN TO STTERM WITH THE NEXT CHARACTER %
	MACRO
ACMENDLIT   =
	% IF THIS CHARACTER IS ' %
	IF .CHAR  NEQ "'"
	THEN	LEAVE SMALCHAR;	! SKIP CHARACTER
	% ELSE SKIP THE ' AND RETURN TO STTERM %
	MSNGTIC _ 0;
	STATE _ STTERM;
	LEAVE BIGCHAR
$;

	% RETURN TO STTERM WITH CURRENT CHARACTER %
	MACRO
ACMBAKTOTERM  =
	CODE _ BIGCODE;
	STATE _ STTERM;
	LEAVE NEWSTATE
$;


OWN HOLCONST;	! HOLDS THE CONSTANT FOR SKIPPING HOLERITHS

	% BUILD THE CONSTANT  %
	MACRO
ACMSKCONBLD  =
	HOLCONST _ .HOLCONST*10  +  ( .CHAR - "0"  );
	LEAVE SMALCHAR
$;

	% CHECK FOR HOLERITH OR X FOLLOWING THE CONSTANT  %
	MACRO
ACMSKPHOLX  =
	STATE _ STTERM;
	IF .CHAR  EQL  "X"
	THEN
	BEGIN	% SKIP THE X %
		LEAVE BIGCHAR
	END;

	IF .CHAR EQL  "H" AND .HOLCONST  GTR  0
	THEN
	BEGIN	% HOLERITH %
		STATE _ STSKPHOL;
		LEAVE SMALCHAR
	END;

	% ELSE JUST SKIP THE CONSTANT %
	LEAVE NEWSTATE

$;


	% SKIP .HOLCONST CHARACTERS OF HOLERITH STRING %
	MACRO
ACMSKPHOL  =
	IF (HOLCONST _ .HOLCONST - 1 )  NEQ 0
	THEN	LEAVE SMALCHAR	! SKIP IT
	ELSE
	BEGIN
		% HOLERITH HAS BEEN PASSED OVER %
		STATE _ STTERM;
		LEAVE BIGCHAR
	END
$;


	% ADJUST FOR TABS IN HOLERITH %
	MACRO
ACMHOLTAB  =
	CHARPOS _ .CHARPOS AND NOT 7;
	CODE _ BLANK;	! SEMANTICLY EQUIVALENT TO BLANK
	LEAVE NEWSTATE
$;


!----------------------------------------------------------------------

! INITIAL LINE PROCESSING




% BIG STATE DEFINITION	STILINE	NUMBER (#) 1B  %
% BEGIN PROCESSING AN INITIAL LINE
	THIS IS CHARACTER POS 1 OF A STATEMENT WHICH BEGINS AT THE
	BEGINNING OF A LINE %


BIND
	ILL1B	=	ACTILABILL	,
	TAB1B	=	ACTILITCONT	,
	LT1B	=	ACTILABLT	,
	BLANK1B	=	ACTENTLAB	,
	SPEC1B	=	ACTILABILL	,
	DIGIT1B	=	ACTENTLAB	,
	UPPER1B	=	ACTILABILL	,
	LOWER1B	=	ACTUPLOW	,
	FOS1B	=	ACTSTMNTFOS	,
	EOB1B	=	ACTEOB	,
	REMARK1B	=	ACTCOMNT	,
	EQUAL1B	=	ACTILABILL	,
	LPAREN1B	=	ACTILABILL	,
	RPAREN1B	=	ACTILABILL	,
	COLON1B	=	ACTILABILL	,
	COMMA1B	=	ACTILABILL	,
	DOLLAR1B	=	ACTCOMNT	,
	ASTERISK1B	=	ACTCOMNT	,
	SLASH1B	=	ACTCOMNT	,
	PLUS1B	=	ACTILABILL	,
	MINUS1B	=	ACTILABILL	,
	ANDSGN1B	=	ACTILABILL	,
	LITSGN1B	=	ACTILABILL	,
	OCTSGN1B	=	ACTILABILL	,
	NEQSGN1B	=	ACTILABILL	,
	DOT1B	=	ACTILABILL	,
	SEMICOL1B	=	ACTILABILL	,
	LTSGN1B	=	ACTILABILL	,
	GTSGN1B	=	ACTILABILL	,
	COMNTSGN1B	=	ACTCOMNT	,
	DEBUGSGN1B	=	ACTDEBUG	,
	UPAROW1B	=	ACTILABILL	;


!----------------------------------------------------------------------

! 		 INITIAL LINE LABEL AND CONTINUATION FIELDS



% SMALL STATE DEFINITION	STILABEL	NUMBER (#) 9S  %
% PICKS UP CHARACTER POSITIONS OF THE LABEL FIELD AND ANY DIGITS %

BIND
	ILL9S	=	ACTILABILL	,
	TAB9S	=	ACTILITCONT	,
	LT9S	=	ACTILABLT	,
	BLANK9S	=	ACTILABEDCK	,
	SPEC9S	=	ACTILABILL	,
	DIGIT9S	=	ACTILABDIG	,
	UPPER9S	=	ACTILABILL	,
	LOWER9S	=	ACTILABILL	,
	FOS9S	=	ACTILABLT	,
	EOB9S	=	ACTEOB	,
	REMARK9S	=	ACTILABILL	;


% SMALL STATE DEFINITION	STLABSKP	NUMBER (#) 10S  %
% SKIPS THE LABEL FIELD OF INITIAL LINES FOUND TO HAVE ILLEGAL CHARACTERS %

BIND
	ILL10S	=	ACTILABEDCK	,
	TAB10S	=	ACTILITCONT	,
	LT10S	=	ACTILABLT	,
	BLANK10S	=	ACTILABEDCK	,
	SPEC10S	=	ACTILABEDCK	,
	DIGIT10S	=	ACTILABEDCK	,
	UPPER10S	=	ACTILABEDCK	,
	LOWER10S	=	ACTILABEDCK	,
	FOS10S	=	ACTILABLT	,
	EOB10S	=	ACTEOB	,
	REMARK10S	=	ACTILABEDCK	;


% SMALL STATE DEFINITION	STILNTCONT	NUMBER (#) 11S  %
% CHECK THE CONTINUATION FIELD OF AN INITIAL LINE , NO INITIAL TAB %

BIND
	ILL11S	=	ACTILNTC	,
	TAB11S	=	ACTILITCONT	,
	LT11S	=	ACTILABLT	,
	BLANK11S	=	ACTILNTI	,
	SPEC11S	=	ACTILNTC	,
	DIGIT11S	=	ACTILNTD	,
	UPPER11S	=	ACTILNTC	,
	LOWER11S	=	ACTILNTC	,
	FOS11S	=	ACTILABLT	,
	EOB11S	=	ACTEOB	,
	REMARK11S	=	ACTILNTC	;


% SMALL STATE DEFINITION	STILITCONT	NUMBER (#) 12S  %
% INITIAL LINE, FIRST CHARACTER AFTER INITIAL TAB  %

BIND
	ILL12S	=	ACTILITNC	,
	TAB12S	=	ACTILITNC	,
	LT12S	=	ACTILABLT	,
	BLANK12S	=	ACTILITNC	,
	SPEC12S	=	ACTILITNC	,
	DIGIT12S	=	ACTILITC	,
	UPPER12S	=	ACTILITNC	,
	LOWER12S	=	ACTILITNC	,
	FOS12S	=	ACTILITNC	,
	EOB12S	=	ACTEOB	,
	REMARK12S	=	ACTILITNC	;



!----------------------------------------------------------------------

! MACROS TO PROCESS THE LABEL FIELD OF THE INITIAL LINE 

	% ENTER THE LABEL PROCESSING STATE %
	MACRO
ACMENTLAB  =
	STATE _ STILABEL;
	LEAVE NEWSTATE
$;

	% ILLEGAL CHARACTER IN THE LABEL FIELD  %
	MACRO
ACMILABILL =
	EXTERNAL  FATLERR;
	STALABL _ 0;
	ZEROCHK _ 0;	!CLEAR ALL FLAGS ASSOCIATED WITH LABELS
	FATLERR (.CHAR,.LINELINE,E7<0,0>  );
	REPLACEN( CURPTR,"??" );
	STATE _ STLABSKP;
	CODE _ SMALCODE;
	LEAVE NEWSTATE
$;

	% CHECK FOR THE END OF THE LABEL FIELD  %
	MACRO
ACMILABEDCK  =
	IF .CHARPOS  NEQ   67  	! POSITION 5
	THEN  LEAVE SMALCHAR
	ELSE
	BEGIN	% END OF THE LABEL FIELD  %
		STATE _ STILNTCONT;	! GOTO NO INITIAL TAB CONT FLD CHECK
		LEAVE SMALCHAR
	END
$;

	% ENTER THE INITIAL LINE , INITIAL TAB CONTINUATION FIELD CHECK %
	MACRO
ACMILITCONT  =
	STATE _ STILITCONT;
	LEAVE SMALCHAR
$;


	% LINE TERMINATORS FOR THE LABEL FIELD OF INITIAL LINES %
	MACRO
ACMILABLT  =
	IF NOT SPURCR()
	THEN
	BEGIN	% A LINE TERMINATOR IMPLIES AN INITIAL LINE %
		STATE _ STNULLST ;
		LEAVE NEWSTATE
	END
	ELSE
	BEGIN	%SPURIOUS CR %
		IF CODETYPE EQL  B  % BIG %
		THEN CODE _ BIGCODE;
		LEAVE NEWSTATE
	END
$;

	% BUILD THE LABEL%
	MACRO
ACMILABDIG  =
	ZEROCHK _ 1;	! NOTE THAT A DIGIT WAS FOUND
	STALABL _ ( .STALABL * 10 ) + ( .CHAR - "0" );
	IF .CHARPOS NEQ  67
	THEN LEAVE SMALCHAR	
	ELSE
	BEGIN	% END OF THE LABEL FIELD  %
		STATE _ STILNTCONT;
		LEAVE SMALCHAR
	END
$;

	% CONTINUATION CHARACTER IN INITIAL LINE %
	MACRO
ACMILNTC =
	% TEMPORARY%
	EXTERNAL  WARNERR;
	WARNERR ( .LINELINE,E109<0,0>);
	STATE _ STNULLST;
	LEAVE SMALCHAR
$;

	% BLANK OR TAB IN THE CONTINUATION FIELD %
	MACRO
ACMILNTI  =
	STATE _ STNULLST;
	LEAVE NEWSTATE	! DON'T PICK UP THE NEXT CHAR SO AS TO ALLOW NULLST TO ADJUST FOR TABS
$;

	% DIGIT IN CONTINUATION FIELD %
	MACRO
ACMILNTD  =
	IF .CHAR  EQL  "0"
	THEN
	BEGIN	% INITIAL LINE %
		STATE _ STNULLST;
		LEAVE SMALCHAR
	END
	ELSE
	BEGIN	% CONTINUATION CHARACTER %
		ACTION _ ACTILNTC;
		LEAVE NEWACTION
	END
$;


	% NON CONTINUATION CHARACTER FOLLOWING TAB  %
	MACRO
ACMILITNC  =
	CHARPOS _ 65;	! 7TH CHARACTER POSITION
	STATE _ STNULLST;
	LEAVE NEWSTATE
$;

	% DIGIT FOLLOWING TAB ON INITIAL LINE %
	MACRO
ACMILITC  =
	STATE _ STNULLST;
	IF .CHAR NEQ "0"
	THEN
	BEGIN	% INITIAL LINE HAS CONTINUATION CHARACTER %
		EXTERNAL WARNERR;
		WARNERR ( .LINELINE, E109<0,0>);
		CHARPOS _ 66;	! 6TH CHARACTER POSITION  
		LEAVE SMALCHAR
	END
	ELSE
	BEGIN	% OK ITS A ZERO %
		CHARPOS _ 65;	! 7TH CARACTER POSITION 
		LEAVE SMALCHAR
	END
$;

	MACRO 
ACMCOMNT =
	INCOMNT _ 1;
	CALLR (STREMARK,STCOMNT);
	LEAVE SMALCHAR
$;

	MACRO
ACMDEBUG =
	IF NOT .FLGREG<INCLUDE>
	THEN
	BEGIN
		 INCOMNT _ 1;
		 CALLR ( STREMARK, STCOMNT  );	! TREAT AS COMMENT LINE
		LEAVE SMALCHAR
	END
	ELSE
	BEGIN
		STATE _ STILABEL;	! PROCESS THE LABEL FIELD
		LEAVE SMALCHAR
	END
$;


!------------------------------ COMMENT LINES ------------------------------


% SMALL STATE DEFINITION	STCOMNT	NUMBER (#) 4S  %

BIND
	ILL4S	=	ACTINTERR	,
	TAB4S	=	ACTINTERR	,
	LT4S	=	ACTLT	,
	BLANK4S	=	ACTINTERR	,
	SPEC4S	=	ACTINTERR	,
	DIGIT4S	=	ACTINTERR	,
	UPPER4S	=	ACTINTERR	,
	LOWER4S	=	ACTINTERR	,
	FOS4S	=	ACTCOMNTFOS	,
%[713]%	EOB4S	=	ACTEOB	,
	REMARK4S	=	ACTINTERR	;



	% END OF THE COMMENT LINE %
	MACRO
ACMCOMNTFOS  =
	INCOMNT _ 0;
	ACTION _ ACTSTMNTFOS;
	LEAVE NEWACTION
$;




!------------------------------ NULL STATEMENT CHECK ------------------------------


% SMALL STATE DEFINITION	STNULLST	NUMBER (#) 3S  %
% THIS STATE WILL SKIP ALL BLANKS AN TABS TO THE FIRST
  SIGNIFICANT CHARACTER OF THE STATEMENT FIELD.  IF IT THEN ENCOUNTERS
  EOS IT IS A NULL STATEMENT AND CONTROL WILL BE TRANSFERED BACK TO
  STSTMNT TO PROCESS THE NEXT STATEMENT.  OTHERWISE CONTROL IS TRANSFERED
  TO THE CLASSIFIER TO CLASSIFY THE STATEMENT.  %


BIND
	ILL3S	=	ACTILLCHAR	,
	TAB3S	=	ACTTABS	,
	LT3S	=	ACTLT	,
	BLANK3S	=	ACTANYS	,
	SPEC3S	=	ACTMULTNULL	,
	DIGIT3S	=	ACTMULTNULL	,
	UPPER3S	=	ACTCLASF1	,
	LOWER3S	=	ACTUPLOW	,
	FOS3S	=	ACTNULLFOS	,
	EOB3S	=	ACTEOB	,
	REMARK3S	=	ACTENTREMARK	;


	% CHECK FOR MULTIPLE STATEMENT TERMINATOR %
	MACRO

ACMMULTNULL  =
BEGIN

	IF .CHAR EQL  ";"
	THEN	% YOU GOT ONE %
	BEGIN	CHAR _ EOS;
		CODE _ FOS;
		LEAVE NEWSTATE
	END
	ELSE
	BEGIN  % UNRECOGNIZED STATEMENT %
		CLASERR _ 1;
		ACTION _ ACTSTSKIP;
		LEAVE NEWACTION
	END
END $;

	% CHECK TO SEE THAT THE NULL STATEMENT IS UNLABELED %
	MACRO
ACMNULLFOS  =
	IF .STALABL  NEQ  0  OR  .ZEROCHK  NEQ  0
	THEN
	BEGIN	% CAN'T HAVE LABELED NULL STATEMENTS %
		EXTERNAL FATLERR;
		FATLERR (PLIT'NULL?0', .ISN,E110<0,0>)
	END;
	ACTION _ ACTSTMNTFOS;
	LEAVE NEWACTION
$;



!------------------------------ CLASSIFICATION STATES ------------------------------


% BIG STATE DEFINITION	STCLASF2	NUMBER (#) 8B  %
% CHARACTER 2,  WE HAVE <ALPHA>  %

BIND
	ILL8B	=	ACTCLILLCHAR	,
	TAB8B	=	ACTTABB	,
	LT8B	=	ACTCLASLT	,
	BLANK8B	=	ACTANYB	,
	SPEC8B	=	ACTCLASUNREC	,
	DIGIT8B	=	ACTCLASAL1	,
	UPPER8B	=	ACTCLASF2	,
	LOWER8B	=	ACTUPLOW	,
	FOS8B	=	ACTCLASUNREC	,
	EOB8B	=	ACTEOB	,
	REMARK8B	=	ACTENTREMARK	,
	EQUAL8B	=	ACTASGNMNT	,
	LPAREN8B	=	ACTSTFNARRY	,
	RPAREN8B	=	ACTCLASUNREC	,
	COLON8B	=	ACTCLASUNREC	,
	COMMA8B	=	ACTCLASUNREC	,
	DOLLAR8B	=	ACTCLASUNREC	,
	ASTERISK8B	=	ACTCLASUNREC	,
	SLASH8B	=	ACTCLASUNREC	,
	PLUS8B	=	ACTCLASUNREC	,
	MINUS8B	=	ACTCLASUNREC	,
	ANDSGN8B	=	ACTCLASUNREC	,
	LITSGN8B	=	ACTCLASUNREC	,
	OCTSGN8B	=	ACTCLASUNREC	,
	NEQSGN8B	=	ACTCLASUNREC	,
	DOT8B	=	ACTCLASUNREC	,
	SEMICOL8B	=	ACTCLASUNREC	,
	LTSGN8B	=	ACTCLASUNREC	,
	GTSGN8B	=	ACTCLASUNREC	,
	COMNTSGN8B	=	ACTCLASF2	,
	DEBUGSGN8B	=	ACTCLASF2	,
	UPAROW8B	=	ACTCLASUNREC	;



% BIG STATE DEFINITION	STCLASAL1	NUMBER (#) 9B  %
%  WE HAVE *<ALPHANUM>    CLASSIFY AS TO ASSIGNMENT OR STFN/ARRY  %

BIND
	ILL9B	=	ACTCLILLCHAR	,
	TAB9B	=	ACTTABB	,
	LT9B	=	ACTCLASLT	,
	BLANK9B	=	ACTANYB	,
	SPEC9B	=	ACTCLASUNREC	,
	DIGIT9B	=	ACTANYB	,
	UPPER9B	=	ACTANYB	,
	LOWER9B	=	ACTANYB	,
	FOS9B	=	ACTCLASUNREC	,
	EOB9B	=	ACTEOB	,
	REMARK9B	=	ACTENTREMARK	,
	EQUAL9B	=	ACTASGNMNT	,
	LPAREN9B	=	ACTSTFNARRY	,
	RPAREN9B	=	ACTCLASUNREC	,
	COLON9B	=	ACTCLASUNREC	,
	COMMA9B	=	ACTCLASUNREC	,
	DOLLAR9B	=	ACTCLASUNREC	,
	ASTERISK9B	=	ACTCLASUNREC	,
	SLASH9B	=	ACTCLASUNREC	,
	PLUS9B	=	ACTCLASUNREC	,
	MINUS9B	=	ACTCLASUNREC	,
	ANDSGN9B	=	ACTCLASUNREC	,
	LITSGN9B	=	ACTCLASUNREC	,
	OCTSGN9B	=	ACTCLASUNREC	,
	NEQSGN9B	=	ACTCLASUNREC	,
	DOT9B	=	ACTCLASUNREC	,
	SEMICOL9B	=	ACTCLASUNREC	,
	LTSGN9B	=	ACTCLASUNREC	,
	GTSGN9B	=	ACTCLASUNREC	,
	COMNTSGN9B	=	ACTANYB	,
	DEBUGSGN9B	=	ACTANYB	,
	UPAROW9B	=	ACTCLASUNREC	;



% SMALL STATE DEFINITION	STCLASF3	NUMBER (#) 17S  %
% THIRD ALPHA CHARACTER  %
% LOOKING FOR POSSIBLE "DO" OR "IF"  %

BIND
	ILL17S	=	ACTCLILLCHAR	,
	TAB17S	=	ACTTABS	,
	LT17S	=	ACTCLASLT	,
	BLANK17S	=	ACTANYS	,
	SPEC17S	=	ACTIFCHK	,
	DIGIT17S	=	ACTDOCHK	,
	UPPER17S	=	ACTCLASF3	,
	LOWER17S	=	ACTUPLOW	,
	FOS17S	=	ACTCLASUNREC	,
	EOB17S	=	ACTEOB	,
	REMARK17S	=	ACTENTREMARK	;



% BIG STATE DEFINITION	STIFCHK	NUMBER (#) 10B  %
% WE HAVE "IF" "(" <EXP> ")"     %

BIND
	ILL10B	=	ACTCLILLCHAR	,
	TAB10B	=	ACTTABB	,
	LT10B	=	ACTCLASLT	,
	BLANK10B	=	ACTANYB	,
	SPEC10B	=	ACTCLASUNREC	,
	DIGIT10B	=	ACTARITHIF	,
	UPPER10B	=	ACTLOGICIF	,
	LOWER10B	=	ACTLOGICIF	,
	FOS10B	=	ACTUNMATUNREC	,
	EOB10B	=	ACTEOB	,
	REMARK10B	=	ACTENTREMARK	,
	EQUAL10B	=	ACTSTFNARRY	,
	LPAREN10B	=	ACTCLASUNREC	,
	RPAREN10B	=	ACTCLILLCHAR	,
	COLON10B	=	ACTCLASUNREC	,
	COMMA10B	=	ACTCLASUNREC	,
	DOLLAR10B	=	ACTCLASUNREC	,
	ASTERISK10B	=	ACTCLASUNREC	,
	SLASH10B	=	ACTCLASUNREC	,
	PLUS10B	=	ACTCLASUNREC	,
	MINUS10B	=	ACTCLASUNREC	,
	ANDSGN10B	=	ACTCLASUNREC	,
	LITSGN10B	=	ACTCLASUNREC	,
	OCTSGN10B	=	ACTCLASUNREC	,
	NEQSGN10B	=	ACTCLASUNREC	,
	DOT10B	=	ACTCLASUNREC	,
	SEMICOL10B	=	ACTCLASUNREC	,
	LTSGN10B	=	ACTCLASUNREC	,
	GTSGN10B	=	ACTCLASUNREC	,
	COMNTSGN10B	=	ACTLOGICIF	,
	DEBUGSGN10B	=	ACTLOGICIF	,
	UPAROW10B	=	ACTCLASUNREC	;



% BIG STATE DEFINITION	STDOCHK1	NUMBER (#) 11B  %
% WE HAVE "DO" <DIGIT>    %

BIND
	ILL11B	=	ACTCLILLCHAR	,
	TAB11B	=	ACTTABB	,
	LT11B	=	ACTCLASLT	,
	BLANK11B	=	ACTANYB	,
	SPEC11B	=	ACTCLASUNREC	,
	DIGIT11B	=	ACTANYB	,
	UPPER11B	=	ACTANYB	,
	LOWER11B	=	ACTANYB	,
	FOS11B	=	ACTCLASUNREC	,
	EOB11B	=	ACTEOB	,
	REMARK11B	=	ACTENTREMARK	,
	EQUAL11B	=	ACTDOCHK1	,
	LPAREN11B	=	ACTSTFNARRY	,
	RPAREN11B	=	ACTCLASUNREC	,
	COLON11B	=	ACTCLASUNREC	,
	COMMA11B	=	ACTCLASUNREC	,
	DOLLAR11B	=	ACTCLASUNREC	,
	ASTERISK11B	=	ACTCLASUNREC	,
	SLASH11B	=	ACTCLASUNREC	,
	PLUS11B	=	ACTCLASUNREC	,
	MINUS11B	=	ACTCLASUNREC	,
	ANDSGN11B	=	ACTCLASUNREC	,
	LITSGN11B	=	ACTCLASUNREC	,
	OCTSGN11B	=	ACTCLASUNREC	,
	NEQSGN11B	=	ACTCLASUNREC	,
	DOT11B	=	ACTCLASUNREC	,
	SEMICOL11B	=	ACTCLASUNREC	,
	LTSGN11B	=	ACTCLASUNREC	,
	GTSGN11B	=	ACTCLASUNREC	,
	COMNTSGN11B	=	ACTANYB	,
	DEBUGSGN11B	=	ACTANYB	,
	UPAROW11B	=	ACTCLASUNREC	;



% BIG STATE DEFINITION	STDOCHK2	NUMBER (#) 12B  %
% WE HAVE "DO" <ALPHANUM> "=" <TERM>   %

BIND
	ILL12B	=	ACTCLILLCHAR	,
	TAB12B	=	ACTTABB	,
	LT12B	=	ACTCLASLT	,
	BLANK12B	=	ACTANYB	,
	SPEC12B	=	ACTANYB	,
	DIGIT12B	=	ACTENTERM	,
	UPPER12B	=	ACTENTERM	,
	LOWER12B	=	ACTENTERM	,
	FOS12B	=	ACTUNMATKEY	,
	EOB12B	=	ACTEOB	,
	REMARK12B	=	ACTENTREMARK	,
	EQUAL12B	=	ACTANYB	,
	LPAREN12B	=	ACTENTERM	,
	RPAREN12B	=	ACTCLILLCHAR	,
	COLON12B	=	ACTANYB	,
	COMMA12B	=	ACTDOSTMNT	,
	DOLLAR12B	=	ACTANYB	,
	ASTERISK12B	=	ACTANYB	,
	SLASH12B	=	ACTANYB	,
	PLUS12B	=	ACTANYB	,
	MINUS12B	=	ACTANYB	,
	ANDSGN12B	=	ACTANYB	,
	LITSGN12B	=	ACTENTERM	,
	OCTSGN12B	=	ACTANYB	,
	NEQSGN12B	=	ACTANYB	,
	DOT12B	=	ACTANYB	,
	SEMICOL12B	=	ACTMULTST	,
	LTSGN12B	=	ACTANYB	,
	GTSGN12B	=	ACTANYB	,
	COMNTSGN12B	=	ACTENTERM	,
	DEBUGSGN12B	=	ACTENTERM	,
	UPAROW12B	=	ACTANYB	;





% BIG STATE DEFINITION	STCLASF4	NUMBER (#) 15B  %
% WE HAVE 3*<ALPHA>   %

BIND
	ILL15B	=	ACTCLILLCHAR	,
	TAB15B	=	ACTTABB	,
	LT15B	=	ACTCLASLT	,
	BLANK15B	=	ACTANYB	,
	SPEC15B	=	ACTCLASUNREC	,
	DIGIT15B	=	ACTCLASAL1	,
	UPPER15B	=	ACTCLASF4	,
	LOWER15B	=	ACTUPLOW	,
	FOS15B	=	ACTENDCHK	,
	EOB15B	=	ACTEOB	,
	REMARK15B	=	ACTENTREMARK	,
	EQUAL15B	=	ACTASGNMNT	,
	LPAREN15B	=	ACTSTFNARRY	,
	RPAREN15B	=	ACTCLASUNREC	,
	COLON15B	=	ACTCLASUNREC	,
	COMMA15B	=	ACTCLASUNREC	,
	DOLLAR15B	=	ACTCLASUNREC	,
	ASTERISK15B	=	ACTCLASUNREC	,
	SLASH15B	=	ACTCLASUNREC	,
	PLUS15B	=	ACTCLASUNREC	,
	MINUS15B	=	ACTCLASUNREC	,
	ANDSGN15B	=	ACTCLASUNREC	,
	LITSGN15B	=	ACTCLASUNREC	,
	OCTSGN15B	=	ACTCLASUNREC	,
	NEQSGN15B	=	ACTCLASUNREC	,
	DOT15B	=	ACTCLASUNREC	,
	SEMICOL15B	=	ACTMULTST	,
	LTSGN15B	=	ACTCLASUNREC	,
	GTSGN15B	=	ACTCLASUNREC	,
	COMNTSGN15B	=	ACTCLASF4	,
	DEBUGSGN15B	=	ACTCLASF4	,
	UPAROW15B	=	ACTCLASUNREC	;





% BIG STATE DEFINITION	STCLASAL2	NUMBER (#) 13B  %
%  WE HAVE < 4 LETTERS OF A KEY WORD >  %

BIND
	ILL13B	=	ACTCLILLCHAR	,
	TAB13B	=	ACTTABB	,
	LT13B	=	ACTCLASLT	,
	BLANK13B	=	ACTANYB	,
	SPEC13B	=	ACTSPELLING	,
	DIGIT13B	=	ACTANYB	,
	UPPER13B	=	ACTANYB	,
	LOWER13B	=	ACTANYB	,
	FOS13B	=	ACTSPELLING	,
	EOB13B	=	ACTEOB	,
	REMARK13B	=	ACTENTREMARK	,
	EQUAL13B	=	ACTASGNMNT	,
	LPAREN13B	=	ACTKEYTERM	,
	RPAREN13B	=	ACTCLILLCHAR	,
	COLON13B	=	ACTSPELLING	,
	COMMA13B	=	ACTSPELLING	,
	DOLLAR13B	=	ACTSPELLING	,
	ASTERISK13B	=	ACTSPELLING	,
	SLASH13B	=	ACTSPELLING	,
	PLUS13B	=	ACTSPELLING	,
	MINUS13B	=	ACTSPELLING	,
	ANDSGN13B	=	ACTSPELLING	,
	LITSGN13B	=	ACTSPELLING	,
	OCTSGN13B	=	ACTSPELLING	,
	NEQSGN13B	=	ACTSPELLING	,
	DOT13B	=	ACTSPELLING	,
	SEMICOL13B	=	ACTSPELLING	,
	LTSGN13B	=	ACTSPELLING	,
	GTSGN13B	=	ACTSPELLING	,
	COMNTSGN13B	=	ACTANYB	,
	DEBUGSGN13B	=	ACTANYB	,
	UPAROW13B	=	ACTSPELLING	;



% BIG STATE DEFINITION	STCLASAL2A	NUMBER (#) 14B  %
% WE HAVE < 4 LETTERS OF KEY WORD > < ALPHANUM> "(" <EXP> ")"   %

BIND
	ILL14B	=	ACTCLILLCHAR	,
	TAB14B	=	ACTTABB	,
	LT14B	=	ACTCLASLT	,
	BLANK14B	=	ACTANYB	,
	SPEC14B	=	ACTSPELLING	,
	DIGIT14B	=	ACTSPELLING	,
	UPPER14B	=	ACTSPELLING	,
	LOWER14B	=	ACTSPELLING	,
	FOS14B	=	ACTUNMATKEY	,
	EOB14B	=	ACTEOB	,
	REMARK14B	=	ACTENTREMARK	,
	EQUAL14B	=	ACTSTFNARRY	,
	LPAREN14B	=	ACTSPELLING	,
	RPAREN14B	=	ACTCLILLCHAR	,
	COLON14B	=	ACTSPELLING	,
	COMMA14B	=	ACTSPELLING	,
	DOLLAR14B	=	ACTSPELLING	,
	ASTERISK14B	=	ACTSPELLING	,
	SLASH14B	=	ACTSPELLING	,
	PLUS14B	=	ACTSPELLING	,
	MINUS14B	=	ACTSPELLING	,
	ANDSGN14B	=	ACTSPELLING	,
	LITSGN14B	=	ACTSPELLING	,
	OCTSGN14B	=	ACTSPELLING	,
	NEQSGN14B	=	ACTSPELLING	,
	DOT14B	=	ACTSPELLING	,
	SEMICOL14B	=	ACTSPELLING	,
	LTSGN14B	=	ACTSPELLING	,
	GTSGN14B	=	ACTSPELLING	,
	COMNTSGN14B	=	ACTSPELLING	,
	DEBUGSGN14B	=	ACTSPELLING	,
	UPAROW14B	=	ACTSPELLING	;



% SMALL STATE DEFINITION	STSPELLING	NUMBER (#) 18S  %
% CHECK THE SPELLING OF THE KEY WORD,  IGNORING BLANKS AND TABS  %

BIND
	ILL18S	=	ACTCOMPAR	,
	TAB18S	=	ACTTABS	,
	LT18S	=	ACTLT	,
	BLANK18S	=	ACTANYS	,
	SPEC18S	=	ACTCOMPAR	,
	DIGIT18S	=	ACTCOMPAR	,
	UPPER18S	=	ACTCOMPAR	,
	LOWER18S	=	ACTUPLOW	,
	FOS18S	=	ACTCOMPAR	,
	EOB18S	=	ACTEOB	,
	REMARK18S	=	ACTENTREMARK	;





!----------------------------------------------------------------------

! THE FOLLOWING MACROS CONTROL THE PROCESSING OF STATEMENT CLASSIFICATION

	% LINE TERMINATORS DURING CLASSIFICATION LOOKAHEAD SHOULD BE
	  DETECTED BUT NOT CAUSE PRINTING  %
	MACRO
ACMCLASLT  =
	IF .CHAR  EQL  CR
	THEN
	BEGIN	% IGNORE THE CR %
		ISCAN (CHAR, CURPTR );
		LEAVE NEWSTATE
	END
	ELSE
	BEGIN	% CHECK FOR CONTINUATION BUT NO PRINTING %
		EXTERNAL  SAVLINE;
		IF .INCLAS  EQL  0  THEN  SAVLINE();	! FOR NON-CLASSIFICATION BACKUP
		ENTCALCONT
	END
$;



	% UNRECOGNIZED STATEMENT %
	MACRO
ACMCLASUNREC  =
	CLASERR _ 1;	! CAUSES ACTSTSKP TO PRINT UNRECOGNIZED MESSAGE
	% CHECK FOR LOGICAL IF CLASSIFICATION %
	IF .LGIFCLAS NEQ  0
	THEN	( STATE _ STRETNX;  VALUE _ ENDOFILE<ADRS> )
	ELSE	STATE _ STSTMNT;
	ACTION _ ACTCLASBACK;
	LEAVE NEWACTION
$;
OWN  LGIFCLAS;	! IF 1 THEN CLASSIFYING THE OBJECT OF A LOGICAL IF

	% BACKUP AND GO TO SKIP STATEMENT WHICH WILL DETECT AND REPORT
  	  THE ERROR  %
	MACRO
ACMCLILLCHAR  =


	CLASERR _ 1;
	% CHECK FOR LOGICAL IF CLASSIFICATION %
	IF .LGIFCLAS NEQ  0
	THEN	( STATE _ STRETNX;  VALUE _ ENDOFILE<ADRS> )
	ELSE	( CALLR ( STSKIP,STSTMNT) );
	ACTION _ ACTCLASBACK;
	LEAVE NEWACTION
$;


	% RESTORE THE INPUT STREAM TO POSITION BEFORE CLASSIFICATION
		AND PROCEED TO THE STATE WHICH WAS SET BY THE ACTION
	 	WHICH EXECUTED THIS ACTION  %
	MACRO
ACMCLASBACK   =

	CURPTR _ .CLASPTR;
	LINELINE _ .CLASLINE;
	CHARPOS _ .CLASPOS;
	LINEPTR _ .CLASLPT;
	PAREN _ 0;
	INCLAS _ 0;
	LEAVENXT	! FIRST CHARACTER OF STATEMENT
$;

	% SET FLAG FOR LOGICAL IF CLASSIFICATION %
	MACRO
ACMCLASF1  =
	EXTERNAL STMNDESC;


	IF .STATE  EQL  STIFCLASIF
	THEN	LGIFCLAS _ 1
	ELSE	LGIFCLAS _ 0;

	% ENTER THE CLASSIFIER   WITH FIRST LETTER OF THE STATEMENT  %

	% CHECK FOR STATEMENTS LABELED WITH 0 %
	IF .STALABL EQL  0  AND  .ZEROCHK  NEQ  0
	THEN	FATLERR ( .ISN, E19<0,0> );	! LABEL WAS ZERO

	STMNDESC _ 0;	! CLEAR FOR PURPOSES OF RECOGNIZING THE PARAMETER STATEMENT
	INCLAS _ 1;
	CLASERR _ 0;
	NAME _ .CHAR;

	% SAVE POSITION FOR BACKUP  %
	CLASPTR _ .CURPTR;
	DECREMENT (CLASPTR<ADRS> );	! POINTS TO 1ST CHAR -1
	CLASLINE _ .LINELINE;
	CLASPOS _ .CHARPOS + 1;
	CLASLPT _ .LINEPTR ;

	% BEGIN CLASSIFICATION  %
	STATE _ STCLASF2;
	LEAVE BIGCHAR
$;


	% ENTER ALGORITHM 1 WHICH CHECKS FOR ASSIGNMENT OR 
 	  STATEMENT FN / ARRAY REF  %
	MACRO
ACMCLASAL1   =
	STATE _ STCLASAL1;
	LEAVE NEWSTATE	! WITH CURRENT CHARACTER
$;


	% WE HAVE AN ASSIGNMENT STATEMENT  %
	MACRO
ACMASGNMNT  =
	EXTERNAL  DSCASGNMT,DSCPARAMT;

	IF .STMNDESC  EQL  DSCPARAMT<0,0>
	THEN
	BEGIN	%MAY BE A PARAMETER STATEMENT%
		ACTION _ ACTSPELLING;
		LEAVE NEWACTION
	END;

	STMNDESC _ DSCASGNMT<ADRS>;
	STATE _ STRETNX;	! RETURN  - NOT END OF FILE
	VALUE _ NOT ENDOFILE<0,0>;
	ACTION _ ACTCLASBACK;
	LEAVE NEWACTION
$;


	% SECOND ALPHABETIC CHARACTER %
	MACRO
ACMCLASF2  =
	NAME _ .NAME^7  + .CHAR;
	STATE _ STCLASF3;	! WHAT IS THE 3RD
	LEAVE SMALCHAR
$;


	% THE THIRD CHARACTER OF THE STATEMENT WAS A SPECIAL CHARACTER
	  SO LETS SEE IF WE HAVE AN "IF"    %
	MACRO
ACMIFCHK  =

	IF .NAME  EQL  "IF"  AND  .CHAR  EQL  "("
	THEN
	BEGIN	% POSSIBLE IF  %
		CALLR ( STTERM, STIFCHK );	! SKIP WHATEVER IS IN ()
		PAREN _ 1;	! THE FIRST WAS JUST PICKED UP
		LEAVE BIGCHAR
	END
	ELSE
	BEGIN	% TRY ASSIGNMENT OR STFN/ARRAY  %
		STATE _ STCLASAL1;
		CODE _ BIGCODE;
		LEAVE NEWSTATE
	END
$;


	% THE FIRST 2 CHARACTERS WERE ALPHA AND THE 3RD A DIGIT
	  SO HOW ABOUT A "DO"  %
	MACRO
ACMDOCHK  =
	IF .NAME  EQL  "DO"
	THEN
	BEGIN	%POSSIBLY , LETS CHECK FOR  ZERO LEVEL COMMA %
		STATE _ STDOCHK1;
		LEAVE BIGCHAR
	END
	ELSE
	BEGIN	% TRY ASSIGNMENT OR STFN/ARRAY  %
		STATE _ STCLASAL1;
		LEAVE BIGCHAR
	END
$;


	% WE HAVE AN ARITHMETIC IF  %
	MACRO
ACMARITHIF   =
	EXTERNAL  DSCIFARITH;
	STMNDESC _ DSCIFARITH<ADRS>;
	ACTION _ ACTSPELLING;	! SKIPS OVER AND PRINTS THE IF
	LEAVE NEWACTION
$;


	% LOGICAL IF STATEMENT %
	MACRO
ACMLOGICIF  =
	EXTERNAL  DSCIFLOGIC;
	STMNDESC _ DSCIFLOGIC<ADRS>;
	ACTION _ ACTSPELLING;	! SKIPS OVER AND PRINTS THE IF
	LEAVE NEWACTION;
$;


	% THIS IS EITHER AN UNRECOGNIZED STATEMENT OR UNMATCHED "(" %
	MACRO
ACMUNMATUNREC   =
	IF .PAREN  NEQ 0
	THEN	ACTION _ ACTCLILLCHAR	! UNMATCHED
	ELSE	ACTION _ ACTCLASUNREC;	! UNRECOGNIZED STATEMENT
	LEAVE NEWACTION
$;


	% STATEMENT FUNCTION OR ARRAY REFERENCE %
	MACRO
ACMSTFNARRY  =
	% CANNOT TELL YET %
	EXTERNAL  DSCSFAY;
	STMNDESC _ DSCSFAY<ADRS>;
	VALUE _ NOT ENDOFILE<0,0>;
	STATE _ STRETNX;	! RETURN
	ACTION _ ACTCLASBACK;
	LEAVE NEWACTION
$;


	% WE HAVE DO <DIGIT> <ALPHANUM> =  %
	MACRO
ACMDOCHK1   =
	% CHECK FOR ZERO LEVEL COMMA  %
	PAREN _ 0;
	CALLR ( STTERM, STDOCHK2 );
	LEAVE BIGCHAR
$;


	% ITS A "DO"  %
	MACRO
ACMDOSTMNT  =
	EXTERNAL  DSCDO;
	STMNDESC _ DSCDO<ADRS>;
	ACTION _ ACTSPELLING;
	LEAVE NEWACTION
$;


	% WE HAVE <3 ALPHA > ( EOS / EOF )  %
	MACRO
ACMENDCHK   =
	EXTERNAL  DSCEND;

	IF .NAME EQL  "END"
	THEN
	BEGIN	% ITS AN END %
		STMNDESC _ DSCEND<ADRS>;
		ACTION _ ACTSPELLING;
		LEAVE NEWACTION
	END
	ELSE
	BEGIN	% UNRECOGNIZED STATEMENT %
		ACTION _ ACTCLASUNREC;
		LEAVE NEWACTION
	END
$;


	% THIRD LETTER %
	MACRO
ACMCLASF3  =
	NAME _ .NAME^7  + .CHAR;
	STATE _ STCLASF4;
	LEAVE BIGCHAR
$;


	% WE HAVE 4 ALPHA CHARACTERS  %
	MACRO
ACMCLASF4  =
	EXTERNAL  CLASHASH;

	NAME _ .NAME^7  + .CHAR;

	IF ( STMNDESC _ CLASHASH( .NAME ) )  NEQ  0
	THEN
	BEGIN	% POSSIBLE KEY WORD , GO CHECK FOR ZERO LEVEL "=" TO BE SURE %
		STATE _ STCLASAL2;
		LEAVE BIGCHAR
	END
	ELSE
	BEGIN	% TRY ASSIGNMENT OR STFN/ARRAY %
		STATE _ STCLASAL1;
		LEAVE BIGCHAR
	END
$;


	% WE HAVE <4 LETTERS OF KEY WORD> < ALPHANUM > "("   %
	MACRO
ACMKEYTERM   =
	% SKIP WHATS IN () AND LOOK FOR "="  %
	PAREN _ 1;	! ONE HAS BEEN PICKED UP
	CALLR  ( STTERM,  STCLASAL2A );
	LEAVE BIGCHAR
$;


	% WE HAVE EOS.  CHECK FOR UNMATCHED "(" BEFORE CLASSIFYING AS
		KEY WORD  %
	MACRO
ACMUNMATKEY   =
	IF .PAREN  NEQ  0  AND  NOT .MSNGTIC
	THEN	ACTION _ ACTCLILLCHAR		! UNMATCHED
	% THE MISSING TIC CHECK ALLOWS TIC RECORD MARKS TO GET THROUGH %
	ELSE
	BEGIN
		% IF WE GOT HERE FROM DO LOOP THEN ITS AN ASSIGNMENT %
		IF .STATE EQL  STDOCHK2
		THEN	ACTION _ ACTASGNMNT
		ELSE	ACTION _ ACTSPELLING		! KEY WORD STATEMENT
	END;
	LEAVE NEWACTION
$;


	% NOW CHECK THE SPELLNG OF THE KEY WORD.  THIS WILL ALSO CHECK
	  THE SPELLING OF THE FIRST 4 CHARACTERS AGAIN.   THIS IS JUST
	  TO ASSURE THAT THEY WILL BE PRINTED JUST IN CASE SOME DEVIATE 
	  HAS SPLIT THEM OVER A LINE  %
	MACRO
ACMSPELLING =

	KEYPTR _ ( KEYWRD ( @STMNDESC ) ) < 29,7 >;	! BYTE POINTER TO BEGINNING OF CORRECT SPELLING
	STATE _ STSPELLING;
	ACTION _ ACTCLASBACK;
	LEAVE NEWACTION
$;


OWN  KEYPTR;	! BYTE POINTER FOR KEYWORD SPELLING CHECK


	% CHECK THE INPUT STRING AGAINST THE CORRECT SPELLING %
	MACRO
ACMCOMPAR  =
	REGISTER KEYCHAR;
	ISCAN ( KEYCHAR, KEYPTR );	! NEXT CHARACTER OF KEY WORD
	IF .KEYCHAR  EQL  .CHAR
	THEN
	BEGIN	% MATCH %
		LEAVE SMALCHAR	! TRY THE NEXT ONE
	END
	ELSE
	BEGIN
		IF .KEYCHAR  EQL  0
		THEN
		BEGIN	% THE SPELLING IS CORRECT %
			RETURNOW ( NOT ENDOFILE<0,0> )
		END
		ELSE
		BEGIN	% NAME IS MISSPELLED %
			EXTERNAL  DSCPARAMT;
			%CHECK TO SEE IF WE WERE LOOKING FOR PARAMETER
			  BECAUSE THEN ITS REALLY AN ASSIGNMENT
			 CERTAINLY IS CONFUSING  %
			IF .STMNDESC  EQL  DSCPARAMT<0,0>
			THEN
			BEGIN	% INDEED IT IS ONE %
				STMNDESC _ 0;
				ACTION _ ACTASGNMNT;
				LEAVE NEWACTION;
			END;

			FATLERR ( .ISN, E12<0,0>   );
			IF .LGIFCLAS  NEQ  0
			THEN	( RETURNOW( ENDOFILE<ADRS> ) );
			CALLR ( STSKIP,STSTMNT);
			LEAVE NEWSTATE
		END
	END
$;




!------------------------------ RETURN    AFTER SKIP TO SIGNIFICANT CHAR ------------------------------


% SMALL STATE DEFINITION	STRETNX	NUMBER (#) 2S  %
% RETURN AFTER POSITIONING TO THE NEXT SIGNIFICANT CHARACTER %

BIND
	ILL2S	=	ACTRETNOW	,
	TAB2S	=	ACTTABS	,
	LT2S	=	ACTLT	,
	BLANK2S	=	ACTANYS	,
	SPEC2S	=	ACTRETNOW	,
	DIGIT2S	=	ACTRETNOW	,
	UPPER2S	=	ACTRETNOW	,
	LOWER2S	=	ACTRETNOW	,
	FOS2S	=	ACTRETNOW	,
	EOB2S	=	ACTEOB	,
	REMARK2S	=	ACTENTREMARK	;

	MACRO 

ACMRETNOW =
		RETURNOW (.VALUE)
$;



! ------------------------------ LOGICAL IF OBJECT CLASSIFICATION  ------------------------------

% SMALL STATE DEFINITION	STIFCLASF	NUMBER (#) 35S  %
% CLASSIFY THE STATEMENT FOLLOWING A LOGICAL IF - THE NEXT CHARACTER
	HAD BETTER BE A LETTER OR WE SHOULDN'T BE HERE  %

BIND
	ILL35S	=	ACTINTERR	,
	TAB35S	=	ACTINTERR	,
	LT35S	=	ACTINTERR	,
	BLANK35S	=	ACTINTERR	,
	SPEC35S	=	ACTINTERR	,
	DIGIT35S	=	ACTINTERR	,
	UPPER35S	=	ACTCLASF1	,
	LOWER35S	=	ACTUPLOW	,
	FOS35S	=	ACTINTERR	,
	EOB35S	=	ACTINTERR	,
	REMARK35S	=	ACTINTERR	;



!------------------------------ CHARACTER LOOKAHEAD ------------------------------

% SMALL STATE DEFINITION	STCSCAN	NUMBER (#) 36S  %
% LOOK AT THE NEXT CHARACTER AND SEE IF IT MATCHES THE CHARACTER
	 IN LOOK4CHAR  %

BIND
	ILL36S	=	ACTSCANCHAR	,
	TAB36S	=	ACTINTERR	,
	LT36S	=	ACTINTERR	,
	BLANK36S	=	ACTINTERR	,
	SPEC36S	=	ACTSCANCHAR	,
	DIGIT36S	=	ACTSCANCHAR	,
	UPPER36S	=	ACTSCANCHAR	,
	LOWER36S	=	ACTUPLOW	,
	FOS36S	=	ACTSCANCHAR	,
	EOB36S	=	ACTINTERR	,
	REMARK36S	=	ACTINTERR	;


	% SEE IF THE CHARACTER MATCHES %
	MACRO
ACMSCANCHAR  =
	EXTERNAL  LOOK4CHAR;

	IF .LOOK4CHAR  EQL  "?D"
	THEN
	BEGIN	% ANY DIGIT IS A MATCH %
		IF .CODE EQL  DIGIT
		THEN	( RETURNXT( .CHAR ) )
	END
	ELSE
		IF .LOOK4CHAR  EQL  "?L"
		THEN
		BEGIN	% ANY LETTER IS A MATCH %
			IF .CODE EQL UPPER
			THEN	( RETURNXT ( .CHAR ) )
		END
		ELSE
			IF .CHAR  EQL  .LOOK4CHAR
			THEN	( RETURNXT ( 1 ) );
	% NO MATCH %
	%FIX UP LEXLINE IF NECESSARY%
	IF .CHAR EQL EOS
	THEN	IF ..CURPTR NEQ ";"
		THEN	LEXLINE _ .LASTLINE;
	RETURNOW ( 0 )
$;


!------------------------------ STRING LOOKAHEAD ------------------------------

% SMALL STATE DEFINITION	STSSCAN	NUMBER (#) 37S  %
% TRY AND MATCH THE STRING POINTED TO BY LOOK4CHAR  %

BIND
	ILL37S	=	ACTSTRCHK	,
	TAB37S	=	ACTTABS	,
	LT37S	=	ACTCLASLT	,
	BLANK37S	=	ACTANYS	,
	SPEC37S	=	ACTSTRCHK	,
	DIGIT37S	=	ACTSTRCHK	,
	UPPER37S	=	ACTSTRCHK	,
	LOWER37S	=	ACTUPLOW	,
	FOS37S	=	ACTSTRCHK	,
	EOB37S	=	ACTEOB	,
	REMARK37S	=	ACTENTREMARK	;


	MACRO
ACMSTRCHK  =
	REGISTER R;
	EXTERNAL  BAKSAVE,BACKPRINT,BACKLINE,BACKUP,LOOK4CHAR;

	% SAVE POSITION IF FIRST ENTRY %
	IF .LOOK4CHAR  NEQ  0
	THEN
	BEGIN
		POINTER _ .LOOK4CHAR;
		LOOK4CHAR _ 0;
		ISCAN ( R,POINTER );
		IF .CHAR NEQ  .R
		THEN	(	%FIX UP LEXLINE IF NECESSARY%
				IF .CHAR EQL EOS
				THEN	IF ..CURPTR NEQ ";"
					THEN	LEXLINE _ .LASTLINE;
				 RETURNOW(0) 
			)
		ELSE	( BAKSAVE();  LEAVE SMALCHAR  )	! GOT ONE
	END;

	% CHECK THE STRING  %
	ISCAN ( R, POINTER );
	IF .CHAR  EQL  .R
	THEN	LEAVE SMALCHAR;	! GOT ONE

	IF .R  EQL  0
	THEN
	BEGIN	% ITS A MATCH %
		IF .BACKLINE  NEQ  0  THEN  BACKPRINT();

		RETURNOW ( 1 )
	END
	ELSE
	BEGIN	% BACKUP %
		BACKUP();
		ISCAN(CHAR,CURPTR);
		CHARPOS_.CHARPOS-1;
		RETURNOW( 0 )
	END
$;



!------------------------------ OBJECT OF STOP OR PAUSE STATEMENTS ------------------------------

% SMALL STATE DEFINITION	STOPOBJ	NUMBER (#) 38S  %
% LOOK FOR AN DECIMAL STRING OR A 'LITERAL-STRING' FOLLOWING A STOP OR PAUSE STATEMENT %

BIND
	ILL38S	=	ACTSTOPLIT	,
	TAB38S	=	ACTINTERR	,
	LT38S	=	ACTINTERR	,
	BLANK38S	=	ACTINTERR	,
	SPEC38S	=	ACTSTOPLIT	,
%[742]%	DIGIT38S	=	ACTSTOPINT	,
	UPPER38S	=	ACTSTOPLIT	,
	LOWER38S	=	ACTSTOPLIT	,
	FOS38S	=	ACTSTOPLIT	,
	EOB38S	=	ACTINTERR	,
	REMARK38S	=	ACTINTERR	;


	% GOT A DIGIT, TRY FOR OCTAL  %
	MACRO
ACMSTOPOCT  =
	HIAC_LOAC_SIIGN_0;
	ACTION _ ACTOCTQ1;
	LEAVE NEWACTION
$;

	% SEE IF ITS A LITERAL STRING %
	MACRO
ACMSTOPLIT  =
	IF .CHAR EQL  "'"
	THEN ( ACTION _ ACTENTLITLEX;  LEAVE NEWACTION )
	ELSE	RETURNOW ( 0 )
$;

	MACRO
ACMSTOPINT =

	% PICK UP A SIX DIGIT INTEGER FOR STOP/PAUSE STATEMENT
	THIS IS THE INITIALIZATION ROUTINE FOR THE NUMBER %

	BIND NDIGITS = 6;	! MAX OF SIX CHARACTERS (STANDARD SAYS 5)

	VALUE<RIGHT> _ LITDEF(NDIGITS); !WANT A STRING REPRESENTATION
	VALUE<LEFT> _ LITSTRING;
	POINTER _ (@VALUE + 3)<36,7>;
	SUM _ 0;
	ACTION _ ACT6DIGIT;
	LEAVE NEWACTION
$;


BIND
	ILL42S	=	ACTBADCHAR,
	TAB42S	=	ACTTABS,
	LT42S	=	ACTLT,
	BLANK42S=	ACTANYS,
	SPEC42S	=	ACTGOT6INT,
	DIGIT42S=	ACT6DIGIT,
	UPPER42S=	ACTGOT6INT,
	LOWER42S=	ACTGOT6INT,
	FOS42S	=	ACTGOT6INT,
	EOB42S	=	ACTEOB,
	REMARK42S=	ACTENTREMARK;

	MACRO
ACM6DIGIT =

	%COLLECT UP TO 6 DIGITS FOR STOP/PAUSE STATEMENT%

	STATE _ STSIXDIGIT;
	ACTION _ ACT6DIGIT;
	IF .SUM EQL 6 THEN FATLEX( PLIT'6-digit number?0', PLIT'larger number?0', E0<0,0> );


	REPLACEI(POINTER,.CHAR);
	SUM_.SUM+1;

	LEAVE SMALCHAR
$;

	MACRO
ACMGOT6INT =

	STATE _ STRETNX;
	LEAVE NEWSTATE
$;



!------------------------------ LEXICAL ANALYZER  ------------------------------

EXTERNAL  TBLSEARCH,CORMAN,NEWENTRY;

% BIG STATE DEFINITION	STLEXEME	NUMBER (#) 2B  %
% THIS IS THE ENTRANCE TO THE LEXICAL ANALYZER  %

BIND
	ILL2B	=	ACTBADCHAR	,
	TAB2B	=	ACTINTERR	,
	LT2B	=	ACTINTERR	,
	BLANK2B	=	ACTINTERR	,
	SPEC2B	=	ACTINTERR	,
	DIGIT2B	=	ACTENTGETCONST	,
	UPPER2B	=	ACTENTIDENT	,
	LOWER2B	=	ACTUPLOW	,
	FOS2B	=	ACTLEXFOS	,
![675] IN STLEXEME NUMBER 2B, CHANGE TO CATCH A RUBOUT IN SOURCE.
%[675]%	EOB2B	=	ACTRIS	,
	REMARK2B	=	ACTINTERR	,
	EQUAL2B	=	ACTDOUBLEX	,
	LPAREN2B	=	ACTSINGLEX	,
	RPAREN2B	=	ACTSINGLEX	,
	COLON2B	=	ACTSINGLEX	,
	COMMA2B	=	ACTSINGLEX	,
	DOLLAR2B	=	ACTSINGLEX	,
	ASTERISK2B	=	ACTDOUBLEX	,
	SLASH2B	=	ACTSINGLEX	,
	PLUS2B	=	ACTSINGLEX	,
	MINUS2B	=	ACTSINGLEX	,
	ANDSGN2B	=	ACTSINGLEX	,
	LITSGN2B	=	ACTENTLITLEX	,
	OCTSGN2B	=	ACTENTOCTQ	,
	NEQSGN2B	=	ACTSINGLEX	,
	DOT2B	=	ACTENTDOT	,
	SEMICOL2B	=	ACTMULTST	,
	LTSGN2B	=	ACTDOUBLEX	,
	GTSGN2B	=	ACTDOUBLEX	,
	COMNTSGN2B	=	ACTENTIDENT	,
	DEBUGSGN2B	=	ACTENTIDENT	,
	UPAROW2B	=	ACTSINGLEX	;


	MACRO  
ACMLEXFOS =
	IF ..CURPTR NEQ ";" AND .CHAR  EQL  EOS
	THEN  LEXLINE _ .LASTLINE;	! PROPERLY SET LEXEME LINE NUMBER
					! FOR STATEMENTS TERMINATED BY END OF LINE

	 RETURNOW (EOSLEX^18)  
$;
![675] ADD MACRO ROUTINE TO CHECK FOR A RUBOUT CHARACTER IN THE
![675] SOURCE PROGRAM - THIS IS NECESSARY SINCE THE RUBOUT
![675] CHARACTER (#177) IS ALSO USED INTERNALLY AS AN END OF
![675] BUFFER CHARACTER.
%[675]%	MACRO
ACMRIS	=
%[675]%	IF CURWORD NEQ .CURPOOLEND AND .CHAR EQL #177
%[675]%		THEN ACTION _ ACTBADCHAR
%[675]%		ELSE ACTION _ ACTINTERR;
%[675]%	LEAVE NEWACTION
$;%[675]%


	% ILLEGAL CHARACTER, SKIP STATEMENT AND RETURN EOSLEX %
	MACRO
ACMBADCHAR  =
	EXTERNAL  BACKLINE,BACKPRINT;
	IF .BACKLINE  NEQ  0
	THEN  BACKPRINT();	! THERE WAS A LOOKAHEAD THAT PASSED A LINE TERMINATOR

	FATLERR ( .CHAR, .LINELINE, E8<0,0> );
	REPLACEN ( CURPTR,  "??" );
	VALUE _ EOSLEX^18;
	CALLR(STSKIP,STRETNX);
	LEAVE BIGCHAR
$;

	% SINGLE CHARACTER LEXEME %
	MACRO
ACMSINGLEX  =
	% MOST CODES ARE IDENTICAL TO THE LEXEME CODE %

	RETURNXT (
		( IF ( VREG_.CODE )  LEQ  EQUAL
		  THEN	.VREG^18
			% INCLUDES LPAREN,RPAREN,COLON,COMMA,DOLLAR,SLASH,
				PLUS, MINUS, ANDSGN  %
		  ELSE	IF  .VREG  EQL  NEQSGN
			THEN	DOTNE	% # %
			ELSE	POWER^18	% ^ %
		)
		  )
$;


	% CHECK FOR TWO CHARACTER LEXEMES,  IE.  <=, > =  , **, ETC.  %
	MACRO
ACMDOUBLEX   =
	VALUE _ .CODE;
	STATE _ STDOUBLEX;
	LEAVE BIGCHAR
$;

% BIG STATE DEFINITION	STDOUBLEX	NUMBER (#) 16B  %
% WE HAVE *, =, <, OR >   -   SEE IF ITS A TWO CHARACTER LEXEME %

BIND
	ILL16B	=	ACTBADCHAR	,
	TAB16B	=	ACTTABB	,
	LT16B	=	ACTLT	,
	BLANK16B	=	ACTANYB	,
	SPEC16B	=	ACTNOTDOUB	,
	DIGIT16B	=	ACTNOTDOUB	,
	UPPER16B	=	ACTNOTDOUB	,
	LOWER16B	=	ACTNOTDOUB	,
	FOS16B	=	ACTNOTDOUB	,
	EOB16B	=	ACTEOB	,
	REMARK16B	=	ACTENTREMARK	,
	EQUAL16B	=	ACTMAYBDOUB	,
	LPAREN16B	=	ACTNOTDOUB	,
	RPAREN16B	=	ACTNOTDOUB	,
	COLON16B	=	ACTNOTDOUB	,
	COMMA16B	=	ACTNOTDOUB	,
	DOLLAR16B	=	ACTNOTDOUB	,
	ASTERISK16B	=	ACTMAYBDOUB	,
	SLASH16B	=	ACTNOTDOUB	,
	PLUS16B	=	ACTNOTDOUB	,
	MINUS16B	=	ACTNOTDOUB	,
	ANDSGN16B	=	ACTNOTDOUB	,
	LITSGN16B	=	ACTNOTDOUB	,
	OCTSGN16B	=	ACTNOTDOUB	,
	NEQSGN16B	=	ACTNOTDOUB	,
	DOT16B	=	ACTNOTDOUB	,
	SEMICOL16B	=	ACTNOTDOUB	,
	LTSGN16B	=	ACTMAYBDOUB	,
	GTSGN16B	=	ACTMAYBDOUB	,
	COMNTSGN16B	=	ACTNOTDOUB	,
	DEBUGSGN16B	=	ACTNOTDOUB	,
	UPAROW16B	=	ACTNOTDOUB	;

	% ITS NOT A DOUBLE CHARACTER LEXEME  %
	MACRO
ACMNOTDOUB =
	
	RETURNOW (
		( IF ( VREG _ .VALUE )  LEQ  EQUAL
		  THEN	.VREG^18
			% EQUAL AND ASTERISK %
		  ELSE	IF .VREG EQL  LTSGN
			THEN	VREG _ DOTLT	% < %
			ELSE	VREG _ DOTGT	% > %
		)
	)
$;


	% MIGHT HAVE A DOUBLE CHARACTER LEXEME  %
	MACRO
ACMMAYBDOUB  =

	ACTION _ ACTNOTDOUB;

	CASE  .VALUE-ASTERISK  OF
	SET

	% ASTERISK %
	BEGIN
		IF .CHAR  NEQ  "*"
		THEN	LEAVE NEWACTION;	! JUST *
		VREG _ POWER^18
	END;
	%=%
	BEGIN
		CASE .CODE-ASTERISK  OF
		SET
		%*% (LEAVE  NEWACTION);	! JUST =
		%=% (VREG _ DOTEQ);	! ==
		%<% (VREG _ DOTLE);	! =<
		%>% ( VREG _ DOTGE);	!  =>
		TES
	END;

	%<%
	BEGIN
		IF .CHAR  NEQ  "="
		THEN	LEAVE NEWACTION;
		VREG _ DOTLE
	END;

	%>%
	BEGIN
		IF .CHAR  NEQ  "="
		THEN	LEAVE NEWACTION;
		VREG _ DOTGE
	END;

	TES;

	RETURNXT (.VREG )
$;

!------------------------------ IDENTIFIERS ------------------------------


% SMALL STATE DEFINITION	STIDENT	NUMBER (#) 19S  %
% SCAN IDENTIFIERS AND PUT IN THE SYMBOL TABLE IN 6-BIT %

BIND
	ILL19S	=	ACTBADCHAR	,
	TAB19S	=	ACTTABS	,
	LT19S	=	ACTLT	,
	BLANK19S	=	ACTANYS	,
	SPEC19S	=	ACTENDID	,
	DIGIT19S	=	ACTPKUPID	,
	UPPER19S	=	ACTPKUPID	,
	LOWER19S	=	ACTUPLOW	,
	FOS19S	=	ACTENDID	,
	EOB19S	=	ACTEOB	,
	REMARK19S	=	ACTENTREMARK	;



OWN  IDENTF,CNT;

	% WE HAVE THE FIRST CHARACTER OF AN IDENTIFIER  %
	MACRO
ACMENTIDENT  =

	EXTERNAL SYMTYPE,TYPTAB;
	SYMTYPE _ .TYPTAB[.CHAR - "A" ]<RIGHT>;
	CNT _ 5;	! CHARACTER COUNT
	IDENTF _ .CHAR - " ";	! FIRST CHARACTER
	STATE _ STIDENT;
	LEAVE SMALCHAR
$;


	% PICKUP EACH CHARACTER OF THE IDENTIFIED AND CONVERT TO 6-BIT %
	MACRO
ACMPKUPID   =
	EXTERNAL  WARNERR,CALLST,STMNDESC;
	
	IF ( CNT _ .CNT - 1 )  GEQ  0
	THEN
	BEGIN	% SAVE THE CHARACTER %
		REGISTER R;  MACHOP  ADDI = #271, LSH = #242;

		R _ .IDENTF;
		LSH ( R,6 );
		ADDI ( R, -" ", CHAR );
		IDENTF _ .R;
		LEAVE SMALCHAR
	END;

	% ELSE WE HAVE MORE THAN 6 CHARACTER %
	IF .CNT  NEQ  -1
	THEN LEAVE SMALCHAR;	!IGNORE THE CHARACTER
	% OUTPUT THE MESSAGE IF ITS NOT CALL DEFINEFILE %
!%1126%	IF .STMNROUTINE ( @STMNDESC) EQL  CALLST<0,0>  AND  .IDENTF  EQL  SIXBIT'DEFINE'
!%1126%	THEN	LEAVE SMALCHAR;	! NO MESSAGE
	WARNLEX (.IDENTF,   E76<0,0>);
	LEAVE SMALCHAR
$;


	% END OF THE IDENTIFIER  -   ENTER IT INTO THE SYMBOL TABLE %
	MACRO
ACMENDID   =
%[717]%	EXTERNAL  SYMTYPE,TYPTAB,ENTRY,TBLSEARCH,GIDTAB,NAMREF,PARAST,LEXL;

	IF .CNT  GTR  0
	THEN	ENTRY _ .IDENTF^(.CNT*6)
	ELSE	ENTRY _ .IDENTF;
	NAME _ .GIDTAB ;
	TBLSEARCH();

	% CHECK HERE FOR PARAMETER VARIABLE REFERENCES%
	IF .(@VREG + 1 )<32,1>  	! [IDATTRIBUT(PARAMT)]
![717] DO NOT RETURN PARAMETER VALUE IF WE ARE PROCESSING A
![717] NEW PARAMETER STATEMENT VARIABLE
%[717]%	THEN (IF .STMNROUTINE(@STMNDESC) EQL PARAST<0,0>
%[717]%		AND .LEXL<LEFT> NEQ EQUAL
%[717]%			THEN VREG<LEFT> _ IDENTIFIER
%[717]%			ELSE NAMREF( 5%PARAREF%, .VREG<RIGHT> ))
		%NAMREF WILL RETURN THE CONSTLEX%
	ELSE	VREG<LEFT> _ IDENTIFIER;
	RETURNOW (.VREG)
$;

!------------------------------ DOTTED OPERATORS ------------------------------


% SMALL STATE DEFINITION	STDOT	NUMBER (#) 20S  %
% WE HAVE AN INITIAL "."  -  IS IT AN OPERATOR OR A CONSTANT  ?  %

BIND
	ILL20S	=	ACTBADCHAR	,
	TAB20S	=	ACTTABB	,
	LT20S	=	ACTLT	,
	BLANK20S	=	ACTANYB	,
	SPEC20S	=	ACTMISOPER	,
	DIGIT20S	=	ACTTRYREAL	,
	UPPER20S	=	ACTGETOPER	,
	LOWER20S	=	ACTUPLOW	,
	FOS20S	=	ACTMISOPER	,
	EOB20S	=	ACTEOB	,
	REMARK20S	=	ACTENTREMARK	;



	% FOUND AN INITIAL "."   %
	MACRO
ACMENTDOT  =
	STATE _ STDOT;
	LEAVE SMALCHAR
$;


	% "." FOLLOWED BY A DIGIT MUST BE A REAL CONSTANT %
	MACRO
ACMTRYREAL   =
	EXTERNAL GCONTAB,GREAL;

	DECEXP _ 0;
	INCREM _ -1;
	HIAC _ 0;
	LOAC _ 0;
	NAME _ .GCONTAB ;
	SYMTYPE _ GREAL<0,0>;
	CALLR ( STBLDDBLINT, STREALCON1 );
	LEAVE NEWSTATE
$;


	% UNRECOGNIZED DOTTED OPERATOR %
	MACRO
ACMMISOPER  =
	EXTERNAL  FATLERR;
	FATLEX ( PLIT'DOTTED OPERATOR?0', .CHAR,    E0<0,0> );
	VALUE _ EOSLEX^18;
	CALLR ( STSKIP, STRETNX );
	LEAVE BIGCHAR
$;

OWN  POINTER;

	% WE HAVE A "." FOLLOWED BY A LETTER - SEE IF IT COULD BE AN OPERATOR %
	MACRO
ACMGETOPER  =
	EXTERNAL  DOTOPTAB;


	STATE _ STSCANOP;
	IF ( POINTER _ @DOTOPTAB[.CHAR-"A" ] )  NEQ  0
	THEN   LEAVE SMALCHAR;	! WE HAVE A POSSIBLE OPERATOR
	% ELSE WHO KNOWS WHAT IT IS %
	ACTION _ ACTMISOPER;
	LEAVE NEWACTION
$;


% SMALL STATE DEFINITION	STSCANOP	NUMBER (#) 21S  %
% THIS STATE WILL DETERMINE WHETHER OR NOT WE HAVE FOUND A DOTTED OPERATOR

	SO FAR A "." AND THE FIRST LETTER OF A VALID OPERATOR HAVE
	BEEN FOUND.  POINTER CONTAINS A BYTE POINTER TO A CHARACTER
	STRING WHICH MAY LEGALLY COMPLETE THIS OPERATOR.  THIS IS
	IN TABLE LEGALOP.  THE ALGORITHM IS - IF ALL CHARACTERS IN
	THE STRING ARE MATCHED AND THE NEXT CHARACTER IS  ".", THEN
	THE WORD FOLLOWING THE CHARACTER STRING CONTAINS THE
	APPROPRIATE LEXEME CODE, WHICH IS RETURNED.  IF A CHARACTER
	DOES NOT MATCH THEN TRY THE PARALLEL CHARACTER IN THE NEXT
	POSSIBLE STRING, WHICH IS TWO WORDS FURTHER IN THE TABLE.
	EVENTUALLY , IF NO COMPLETE MATCHES ARE MADE A 0 WORD WILL
	BE REACHED SIGNALING NO MATCH.  THE WORD FOLLOWING THIS
	THEN BEGINS A LITERAL OF WHAT ONE WAS LOOKING FOR, WHICH
	CAN BE SHOVED OUT WITH ERROR 0.
%

BIND
	ILL21S	=	ACTBADCHAR	,
	TAB21S	=	ACTTABS	,
	LT21S	=	ACTLT	,
	BLANK21S	=	ACTANYS	,
	SPEC21S	=	ACTOPCHK	,
	DIGIT21S	=	ACTMISOP1	,
	UPPER21S	=	ACTOPCHK	,
	LOWER21S	=	ACTUPLOW	,
	FOS21S	=	ACTMISOP1	,
	EOB21S	=	ACTEOB	,
	REMARK21S	=	ACTENTREMARK	;



	% COMPARE THE INPUT STREAM AGAINST THE LEGAL OPERATOR STRINGS %
	MACRO
ACMOPCHK   =
	EXTERNAL  GLOGI,GCONTAB;
	REGISTER R;
	
	ISCAN ( R, POINTER );
	WHILE 1 DO
	BEGIN	% LOOP THROUGH POSSIBLE OPERATOR STRINGS %
		IF .R  EQL  .CHAR
		THEN	LEAVE SMALCHAR;	! FINE - GET THE NEXT CHARACTER
	
		IF .R  EQL  0  AND  .CHAR  EQL  "."
		THEN
		BEGIN	% A STRING HAS BEEN MATCHED %
			VREG _ @(@POINTER+1);
			IF .VREG  LSS  0
			THEN
			BEGIN	% LOGICAL CONSTANT %
				NAME _ .GCONTAB ;
				SYMTYPE _ GLOGI<0,0>;
				ENTRY[0] _ 0;
				ENTRY[1] _ .VREG+1;
				TBLSEARCH();
				VREG<LEFT> _ CONSTLEX
			END;
			RETURNXT ( .VREG )	! RETURN THE LEXEME CODE
		END;

		% LETS SEE IF THERE IS ANOTHER POSSIBILITY %
		IF ( @(POINTER_@POINTER+2) )  EQL  0 OR .R EQL 0
					% THE .R CHECK IS THERE SO .NET. WILL NOT BE ACCEPTED %
		THEN
		BEGIN	% NOTHING LEFT TO TRY %
			ACTION _ ACTMISOP1;
			LEAVE NEWACTION
		END;

		% THERE IS ANOTHER POSSIBILITY SO LETS TRY IT %
		R _ ..POINTER;

	END %LOOP%
$;


	% WE DIDN'T FIND THE OPERATOR , BUT HAD SOME IDEA OF WHAT WE WERE
	  LOOKING FOR %
	MACRO
ACMMISOP1  =
	% GET THE EXPECTED LITERAL  %
	UNTIL  @@POINTER  EQL  0
	DO  POINTER _ .POINTER + 1;

	FATLEX ( .POINTER<RIGHT>+1 , .CHAR,    E0<0,0> );
	CALLR ( STSKIP, STRETNX);
	VALUE _ EOSLEX^18;
	LEAVE BIGCHAR
$;



!------------------------------ CONSTANTS ------------------------------

EXTERNAL  DECEXP, INCREM, SYMTYPE;

% BIG STATE DEFINITION	STGETCONST	NUMBER (#) 17B  %
% RETURN HERE FROM
  BLDDBLINT, WHICH JUST PICKED UP AN INTEGER  %

BIND
	ILL17B	=	ACTBADCHAR	,
	TAB17B	=	ACTTABB	,
	LT17B	=	ACTLT	,
	BLANK17B	=	ACTANYB	,
	SPEC17B	=	ACTGOTINT	,
	DIGIT17B	=	ACTINTERR	,
	UPPER17B	=	ACTCHECKLET	,
	LOWER17B	=	ACTUPLOW	,
	FOS17B	=	ACTGOTINT	,
	EOB17B	=	ACTEOB	,
	REMARK17B	=	ACTENTREMARK	,
	EQUAL17B	=	ACTGOTINT	,
	LPAREN17B	=	ACTGOTINT	,
	RPAREN17B	=	ACTGOTINT	,
	COLON17B	=	ACTGOTINT	,
	COMMA17B	=	ACTGOTINT	,
	DOLLAR17B	=	ACTGOTINT	,
	ASTERISK17B	=	ACTGOTINT	,
	SLASH17B	=	ACTGOTINT	,
	PLUS17B	=	ACTGOTINT	,
	MINUS17B	=	ACTGOTINT	,
	ANDSGN17B	=	ACTGOTINT	,
	LITSGN17B	=	ACTGOTINT	,
	OCTSGN17B	=	ACTGOTINT	,
	NEQSGN17B	=	ACTGOTINT	,
	DOT17B	=	ACTREALCON	,
	SEMICOL17B	=	ACTMULTST	,
	LTSGN17B	=	ACTGOTINT	,
	GTSGN17B	=	ACTGOTINT	,
	COMNTSGN17B	=	ACTCHECKLET	,
	DEBUGSGN17B	=	ACTCHECKLET	,
	UPAROW17B	=	ACTGOTINT	;


GLOBAL HIAC,LOAC;
OWN SIIGN;
BIND SUM=HOLCONST;

	% WE HAVE A DIGIT FROM LEXEME AND THUS AN INTEGER TO PICK UP %
	MACRO
ACMENTGETCONST   =
	EXTERNAL GCONTAB;
	DECEXP _ 0;
	INCREM _ 0;
	HIAC _ 0;
	LOAC _ 0;
	NAME _ .GCONTAB ;

	CALLR ( STBLDDBLINT,  STGETCONST );
	LEAVE NEWSTATE	! GO  BUILD THE INTEGER
$;


	% WE HAVE AN INTEGER  %
	MACRO
ACMGOTINT  =
	EXTERNAL LOOK4LABEL;

	EXTERNAL FATLEX,E64,GCONTAB;

	%CHECK FOR OVERFLOW%
	IF .LOAC<35,1> OR .HIAC NEQ 0
	THEN	( FATLEX(E64<0,0>); NAME _ .GCONTAB );

	ENTRY[1] _ .LOAC;
	ENTRY[0] _ 0;
	% CHECK TO SEE IF WE ARE LOOKING FOR A LABEL %
	IF .LOOK4LABEL  NEQ  0
	THEN
	BEGIN	% THIS IS A LABEL %
		EXTERNAL LABREF;
		LABREF();	! LABEL IS IN ENTRY[1]
		VREG<LEFT> _ LABELEX
	END
	ELSE
	BEGIN	% INTEGER %
		EXTERNAL GINTEGER;
		SYMTYPE _ GINTEGER<0,0>;
		TBLSEARCH();
		VREG<LEFT> _ CONSTLEX
	END;
	RETURNOW ( .VREG )
$;


	% THERE IS A LETTER FOLLOWING AN INTEGER
	  IS IT A HOLERITH OR EXPONENT OR WHAT  %
	MACRO
ACMCHECKLET   =

	% FIRST CHECK FOR LABELS %
	EXTERNAL LOOK4LABEL;

	IF .STATE NEQ STREALCON1
	THEN BEGIN

	IF .LOOK4LABEL  NEQ  0
	THEN
	BEGIN	% WE REALLY WANT A LABEL %
		ACTION _ ACTGOTINT;
		LEAVE NEWACTION
	END;

	IF .CHAR  EQL  "H"
	THEN
	BEGIN	% HOLERITH %
		% THE NUMBER OF CHARACTERS IS IN LOAC %

%[1107]%	! Prohibit 0H - bad hollerith constant

%[1107]%	IF .LOAC EQL 0 THEN FATLEX(  E158<0,0> );

		% MAKE AN ENTRY IN THE LITERAL TABLE %
		VALUE<RIGHT> _ LITDEF(.LOAC);
		VALUE <LEFT> _ LITSTRING;
		POINTER _ (.VALUE<RIGHT>+3)<36,7> ;	! POINTER TO BEGINNING OF LITERAL STORAGE
		IF ( SUM _ 5-( .LOAC MOD 5)) EQL 5 THEN	SUM _ 0;	! FOR BLANK FILL AT END
	
		STATE _ STHOLEX;
		LEAVE SMALCHAR

	END
	END;

	% LOOK FOR EXPONENT %

	SIIGN _ 0;
!REMOVE	STATE _ STINTEXPONENT;

	IF .CHAR  EQL  "D"
	THEN
	BEGIN	% DOUBLEPRECISION %
		EXTERNAL GDOUBLPREC;
		SYMTYPE _ GDOUBLPREC<0,0>;
		STATE_STINTEXPONENT;
		LEAVE SMALCHAR
	END;
	IF .CHAR  EQL  "E"
	THEN
	BEGIN	% REAL EXPONENT %
		EXTERNAL  GREAL;
		SYMTYPE _ GREAL<0,0>;
		STATE_STINTEXPONENT;
		LEAVE SMALCHAR
	END;

	% JUST INTEGER %
	IF .STATE EQL STREALCON1 THEN ACTION_ACTGOTREAL ELSE
	ACTION _ ACTGOTINT;
	LEAVE NEWACTION
$;

% SMALL STATE DEFINITION	STBLDDBLINT	NUMBER (#)  22S  %
% BUILD A DOUBLE PRECISION CONSTANT IN HIAC AND LOAC %

BIND
	ILL22S	=	ACTGOBAKNOW	,
	TAB22S	=	ACTTABS	,
	LT22S	=	ACTLT	,
	BLANK22S	=	ACTANYS	,
	SPEC22S	=	ACTGOBAKNOW	,
	DIGIT22S	=	ACTBILDDBLINT	,
	UPPER22S	=	ACTGOBAKNOW	,
	LOWER22S	=	ACTGOBAKNOW	,
	FOS22S	=	ACTGOBAKNOW	,
	EOB22S	=	ACTEOB	,
	REMARK22S	=	ACTENTREMARK	;


MACRO LO = R[1]<0,36>$,
	HI = R[0]<0,36>$;
MACRO DPADD1(X) =	ADD(X+1,LOAC);
			TLZE(X+1,#400000);
			AOS(X,HIAC);
			MOVEM(X+1,LOAC)$;
MACRO DPADD(X) = ADDB(X,HIAC);
		   DPADD1(X);$;

	EXTERNAL DECEXP,INCREM;
	MACHOP ADD=#270, TLZE=#623, AOS=#350, MOVEM=#202, ADDB=#273, ASHC=#244;
	!
	!ALGORITHM IS SIMPLY
	!	(HIAC,LOAC)_ (HIAC,LOAC)*8 + (HIAC,LOAC)*2 + .CHAR -"0"
	!
	!
	MACRO
ACMBILDDBLINT=
BEGIN
	REGISTER  R[2];
		  HI _ .HIAC;
		  IF (.HI AND #760000000000 ) EQL 0
		  THEN BEGIN
			DECEXP _ .DECEXP+.INCREM;
			LO _ .LOAC;
			ASHC(HI,3);
			HIAC _ .HI; LOAC _ .LO;
			ASHC(HI,-2);
			DPADD(HI)	!MACRO ABOVE
			LO _ .CHAR;
			LO _ .LO - "0";
			DPADD1(HI)	!MACRO ABOVE
		      END
		      ELSE
		      BEGIN
			%ADJUST EXPONENT FOR IGNORED LEAST SIGNIFIGANT
			  DIGITS  %
			IF .INCREM  EQL   0
			THEN	DECEXP _ .DECEXP + 1
		      END;
	LEAVE SMALCHAR
END;
$;


% SMALL STATE DEFINITION	STREALCON	NUMBER (#) 23S  %
%  WE HAVE  <INTEGER> "."  
  WE ARE NOW LOOKING AT WHATEVER FOLLOWS THE "."
%

BIND
	ILL23S	=	ACTBADCHAR	,
	TAB23S	=	ACTTABS	,
	LT23S	=	ACTLT	,
	BLANK23S	=	ACTANYS	,
	SPEC23S	=	ACTGOTREAL	,
	DIGIT23S	=	ACTENTRLBLDD	,
	UPPER23S	=	ACTEXDBCHK	,
	LOWER23S	=	ACTUPLOW	,
	FOS23S	=	ACTGOTREAL	,
	EOB23S	=	ACTEOB	,
	REMARK23S	=	ACTENTREMARK	;



	MACRO
ACMREALCON   =
	EXTERNAL GREAL;
	 SYMTYPE _ GREAL<0,0>;
	STATE _ STREALCON;
	LEAVE SMALCHAR
$;


	% BUILD THE FRACTIONAL PORTION OF A CONSTANT  %
	MACRO
ACMENTRLBLDD  =
	INCREM _ -1;
	CALLR ( STBLDDBLINT,  STREALCON1 );
	LEAVE NEWSTATE
$;


	% WE HAVE A REAL OR DOUBLE PRECISION CONSTANT  %
	MACRO
ACMGOTREAL  =
	EXTERNAL FLTGEN;
	FLTGEN();
	ENTRY[0] _ .HIAC;
	ENTRY[1] _ .LOAC;
	RETURNOW (( CONSTLEX^18 + TBLSEARCH()  ))
$;


	% WE HAVE <INTEGER> "."  <LETTER>
	  AND UNFORTUNATELY MUST CHECK WHETHER IT IS AN EXPONENT OR
	  A RELATIONAL/LOGICAL OPERATOR  %
	MACRO
ACMEXDBCHK   =

	SIIGN _ 0;

	IF .CHAR  EQL  "D"
	THEN
	BEGIN	% DOUBLE PRECISION %
		EXTERNAL  GDOUBLPREC;
		SYMTYPE _ GDOUBLPREC<0,0>;
		STATE _ STINTEXPONENT;
		LEAVE SMALCHAR
	END;

	IF .CHAR  EQL  "E"
	THEN
	BEGIN	% POSSIBLE EXPONENT OR RELATIONAL OPERATOR %
		% IF THEREIS ANOTHER LETTER FOLLOWING IT WE
		  WILL ASSUME THAT IT IS AN OPERATOR  %
		EXTERNAL  BAKSAV;
		BAKSAV();	! SAVE CURRENT POSITION
		STATE _ STOPCHK;
		LEAVE SMALCHAR
	END;

	% ELSE EVERYTHING ELSE IS AN OPERATOR %
	DECREMENT ( CURPTR<ADRS> );
	CHARPOS _ .CHARPOS + 1;	!BACKUP THE CHARACTER POSITION COUNTER
	CHAR _ ".";
	CODE _ DOT;
	ACTION _ ACTGOTINT;
	LEAVE NEWACTION
$;


% SMALL STATE DEFINITION	STREALCON1	NUMBER (#) 24S  %
% WE HAVE [<INTEGER>] "."  < INTEGER >   -  SO LOOK FOR EXPONENT %

BIND
	ILL24S	=	ACTBADCHAR	,
	TAB24S	=	ACTTABS	,
	LT24S	=	ACTLT	,
	BLANK24S	=	ACTANYS	,
	SPEC24S	=	ACTGOTREAL	,
	DIGIT24S	=	ACTINTERR	,
	UPPER24S	=	ACTCHECKLET	,
	LOWER24S	=	ACTUPLOW	,
	FOS24S	=	ACTGOTREAL	,
	EOB24S	=	ACTEOB	,
	REMARK24S	=	ACTENTREMARK	;



% SMALL STATE DEFINITION	STOPCHK	NUMBER (#) 25S  %
% WE HAVE <INTEGER> "." "E"  -   ? IS IT AN EXPONENT OR OERATOR %

BIND
	ILL25S	=	ACTBADCHAR	,
	TAB25S	=	ACTTABS	,
	LT25S	=	ACTCLASLT	,
	BLANK25S	=	ACTANYS	,
	SPEC25S	=	ACTCHKPLMI	,
	DIGIT25S	=	ACTINTEXP1	,
	UPPER25S	=	ACTGOTOP	,
	LOWER25S	=	ACTGOTOP	,
	FOS25S	=	ACTNOEXP	,
	EOB25S	=	ACTEOB	,
	REMARK25S	=	ACTENTREMARK	;



	% ITS AN OPERATOR %
	MACRO
ACMGOTOP   =
	% SO BACK UP  %
	EXTERNAL  BACKUP;
	BACKUP();
	CHAR _ ".";
	CODE _ DOT;
	ACTION _ ACTGOTINT;
	LEAVE NEWACTION
$;


% SMALL STATE DEFINITION	STINTEXPONENT	NUMBER (#) 26S  %
% LOOK FOR SIGN OF EXPONENT FOLLOWING  D OR E  %

BIND
	ILL26S	=	ACTBADCHAR	,
	TAB26S	=	ACTTABS	,
	LT26S	=	ACTLT	,
	BLANK26S	=	ACTANYS	,
	SPEC26S	=	ACTCHKPLMI	,
	DIGIT26S	=	ACTINTEXP1	,
	UPPER26S	=	ACTNOEXP	,
	LOWER26S	=	ACTNOEXP	,
	FOS26S	=	ACTNOEXP	,
	EOB26S	=	ACTEOB	,
	REMARK26S	=	ACTENTREMARK	;



	% SET SIIGN IF ITS PLUS OF MINUS,  OTHERWISE ITS NO EXPONENT %
	MACRO
ACMCHKPLMI   =
	EXTERNAL  BACKLINE,BACKPRINT;
	% CHECK TO SEE IF SOME LINES WERE LOOKED AHEAD OVER  %
	IF  .BACKLINE  NEQ  0  THEN  BACKPRINT();
	
	STATE _ STINTEXP0;
	IF .CHAR  EQL  "-"
	THEN	( SIIGN _ -1;  LEAVE SMALCHAR);	! GO GET EXPONENT
	IF .CHAR  EQL  "+"  THEN  LEAVE SMALCHAR;

	% ELSE NO EXPONENT %
	ACTION _ ACTNOEXP;
	LEAVE NEWACTION
$;


	% NO EXPONENT AFTER E OR D  %
	MACRO
ACMNOEXP    =

	% CHECK FOR BACK PRINT  %
	EXTERNAL  BACKLINE,BACKPRINT,NAME,GCONTAB;
	IF .BACKLINE  NEQ  0  THEN  BACKPRINT();

	FATLEX(  E95<0,0>);
	NAME _ .GCONTAB;
	ACTION  _ ACTGOTREAL;
	LEAVE NEWACTION
$;


% SMALL STATE DEFINITION	STINTEXP0	NUMBER (#) 27S  %
% SIGN OF EXPONENT HAS BEEN FOUND - LETS NOT HAVE ANY MORE SIGNS %

BIND
	ILL27S	=	ACTBADCHAR	,
	TAB27S	=	ACTTABS	,
	LT27S	=	ACTLT	,
	BLANK27S	=	ACTANYS	,
	SPEC27S	=	ACTNOEXP	,
	DIGIT27S	=	ACTINTEXP1	,
	UPPER27S	=	ACTNOEXP	,
	LOWER27S	=	ACTNOEXP	,
	FOS27S	=	ACTNOEXP	,
	EOB27S	=	ACTEOB	,
	REMARK27S	=	ACTENTREMARK	;



% SMALL STATE DEFINITION	STINTEXP1	NUMBER (#) 28S  %
% LOOK FOR DIGITS OF THE EXPONENT AFTER THE FIRST  %

BIND
	ILL28S	=	ACTBADCHAR	,
	TAB28S	=	ACTTABS	,
	LT28S	=	ACTLT	,
	BLANK28S	=	ACTANYS	,
	SPEC28S	=	ACTGOTIEXP	,
	DIGIT28S	=	ACTSUMIEXP	,
	UPPER28S	=	ACTGOTIEXP	,
	LOWER28S	=	ACTGOTIEXP	,
	FOS28S	=	ACTGOTIEXP	,
	EOB28S	=	ACTEOB	,
	REMARK28S	=	ACTENTREMARK	;



	% WE HAVE  1ST DIGIT OF EXPONENT  %
	MACRO
ACMINTEXP1   =
	EXTERNAL  BACKLINE,BACKPRINT;
	IF  .BACKLINE  NEQ  0  THEN  BACKPRINT();

	SUM _ .CHAR - "0";
	STATE _ STINTEXP1;
	LEAVE SMALCHAR
$;


	% ADD UP THE EXPONENT  %
!	MACRO
!ACMSUMIEXP   =
!	SUM _ .SUM*10  + ( .CHAR  - "0"  );
!	LEAVE SMALCHAR
!$;
! THIS MACRO IS NOW ACMSKCONBLD


	% WE HAVE AN EXPONENT  %
	MACRO
ACMGOTIEXP   =
	IF .SIIGN  NEQ  0
	THEN  SUM _ -.SUM;
	DECEXP _ .DECEXP + .SUM;
	ACTION _ ACTGOTREAL;
	LEAVE NEWACTION
$;


!------------------------------ HOLERITH CONSTANTS ------------------------------
% SMALL STATE DEFINITION	STHOLEX	NUMBER (#) 29S  %
% PICK UP A HOLERITH STRING  - LOAC CONTAINS THE NUMBER OF CARACTERS %

BIND
	ILL29S	=	ACTHOLCHAR	,
	TAB29S	=	ACTHOLTAB	,
	LT29S	=	ACTLT	,
	BLANK29S	=	ACTHOLCHAR	,
	SPEC29S	=	ACTHOLCHAR	,
	DIGIT29S	=	ACTHOLCHAR	,
	UPPER29S	=	ACTHOLCHAR	,
	LOWER29S	=	ACTHOLCHAR	,
	FOS29S	=	ACTHOLEND	,
	EOB29S	=	ACTEOB	,
	REMARK29S	=	ACTHOLCHAR	;



	% FORM THE HOLERITH STRING  %
	MACRO
ACMHOLCHAR  =
	IF .LOAC   EQL  0
	THEN	( ACTION _ ACTHOLEND;  LEAVE NEWACTION  )

	ELSE
	BEGIN	% STORE THE CHARACTERS  %
		LOAC _ .LOAC -1;
		REPLACEI ( POINTER, .CHAR  );
		LEAVE SMALCHAR
	END
$;


	% END OF THE HOLERITH STRING  %
	MACRO
ACMHOLEND  =
	LOAC _ .LOAC + .SUM;	! SUM IS # CHARS TO BLANK FILL
	WHILE  .LOAC  NEQ  0
	DO
	BEGIN	% BLANK FILL IF EOS WAS REACHED AND TO WORD BONDRY %
		REPLACEI ( POINTER, " " );
		LOAC _ .LOAC-1
	END;
	(.POINTER<RIGHT>+1)<0,36> _ 0;	! NULL WORD ON THE END

	STATE _ STRETNX;
	LEAVE NEWSTATE
$;


!------------------------------ LITERAL STRINGS  ------------------------------

% SMALL STATE DEFINITION	STLITLEX	NUMBER (#) 30S  %
%  PICK UP A LITERAL STRING  %

BIND
	ILL30S	=	ACTLITEDCHK	,
	TAB30S	=	ACTHOLTAB	,
	LT30S	=	ACTLT	,
	BLANK30S	=	ACTLITEDCHK	,
	SPEC30S	=	ACTLITEDCHK	,
	DIGIT30S	=	ACTLITEDCHK	,
	UPPER30S	=	ACTLITEDCHK	,
	LOWER30S	=	ACTLITEDCHK	,
	FOS30S	=	ACTNOTIC	,
	EOB30S	=	ACTEOB	,
	REMARK30S	=	ACTLITEDCHK	;


BIND  LSTADDR = SUM;
EXTERNAL LITDEF;

	% THE SIZE OF TE LITERAL IS NOT KNOWN  SO WE WILL BUILD A LITERAL
	  TABLE ENTRY OF A REASONABLE SIZE AND SEE IF IT FITS.  IF SO
	  ANY SPACE LEFT OVER WILL BE RETURNED,  IF NOT A LARGER AREA WLL
	  BE REQUESTED.  THIS IS ACCOMPLISHED BY ADDING TO THE BLOCK
	  THROUGH ANOTHER CALL TO CORMAN.  SINCE ALL BLOCKS REQUESTED
 	  ARE LARGER THAN 10 WORDS THEY WILL BE TAKEN FROM FREE STORAGE
	  AND THUS SUCCESSIVE REQUESTS WILL ADD TO THE ORIGIONAL REQUEST.
	  THIS WILL HAVE TO BE REDONE IF CORMAN IS CHANGED  %
	MACRO
ACMENTLITLEX   =

	% MAKE FIRST ENTRY  %
	BIND  NUMCHARS  =  100;

%[1107]% CHARCOUNT _ 0;			! Length of character constant

	VALUE<RIGHT> _ LITDEF( NUMCHARS );	! TRY 100 CHARACTERS
	VALUE<LEFT> _ LITSTRING;
	POINTER _ (@VALUE + 3)<36,7>;	! FORM STARTING BYTE POINTER
	LSTADDR _ .VALUE<RIGHT> + 3 + (NUMCHARS/5) - 1;	! ADDRESS OF LAST WORD IN ENTRY
	STATE _ STLITLEX;
	LEAVE SMALCHAR
$;


	% LOOKING FOR CLOSING '  %
	MACRO
ACMLITEDCHK   =
	
	% MAKE SURE THAT THERE IS SPACE LEFT  %
	IF .LSTADDR<RIGHT>  EQL  .POINTER<RIGHT>
	THEN
	BEGIN	% NEED MORE SPACE %
		NAME<LEFT> _ 10;
		CORMAN();
		LSTADDR _ .LSTADDR+10;
	END;

	IF .CHAR  EQL  "'"
	THEN
	BEGIN	% THIS MAY BE THE END OF THE LITERAL  %
		STATE _ STLITEND
	END
	ELSE
	BEGIN	% STORE THE CHARACTER %
		REPLACEI ( POINTER, .CHAR  );

%[1107]%	CHARCOUNT _ .CHARCOUNT + 1;	! Increment length

	END;
	LEAVE SMALCHAR
$;

	% MISSING TERMINAL  "'"   %
	MACRO
ACMNOTIC  =
	FATLEX (   E72<0,0> );
	RETURNOW (EOSLEX^18)
$;



% SMALL STATE DEFINITION	STLITEND	NUMBER (#) 31S  %
% LOOKING FOR SECOND '  %

BIND
	ILL31S	=	ACTTIC2CHK	,
	TAB31S	=	ACTTIC2CHK	,
	LT31S	=	ACTLT	,
	BLANK31S	=	ACTTIC2CHK	,
	SPEC31S	=	ACTTIC2CHK	,
	DIGIT31S	=	ACTTIC2CHK	,
	UPPER31S	=	ACTTIC2CHK	,
	LOWER31S	=	ACTTIC2CHK	,
	FOS31S	=	ACTTIC2CHK	,
	EOB31S	=	ACTEOB	,
	REMARK31S	=	ACTTIC2CHK	;



	% CHECK FOR SUCCESSIVE 'S  %
	MACRO
ACMTIC2CHK  =
	IF .CHAR  EQL  "'"
	THEN
	BEGIN	% GOT ONE  %
		REPLACEI( POINTER, .CHAR );	! SPACE CHECK ALREADY MADE
%[1107]%	CHARCOUNT _ .CHARCOUNT + 1;	! Increment length
		STATE _ STLITLEX;
		LEAVE SMALCHAR
	END
	ELSE
	BEGIN	% END OF THE LINE FOR THE LITERAL %
		EXTERNAL  ENDOFLIT;

%[1107]%	IF .CHARCOUNT EQL 0 THEN FATLEX( E159<0,0> );	! Illegal character constant '' found - complain

		% BLANK FILL %
		UNTIL  .POINTER<30,6>  EQL  1
		DO	REPLACEI( POINTER, " " );

		ENDOFLIT( .POINTER<RIGHT>,.VALUE<RIGHT>,.LSTADDR<RIGHT> );
		% CLEAN UP AND SAVE SPACE  %

		STATE _ STRETNX;
		LEAVE  NEWSTATE
	END
$;


!------------------------------ OCTAL CONSTANTS ------------------------------

% SMALL STATE DEFINITION	STOCTQ	NUMBER (#) 32S  %
% LOOK FOR SIGN OF OCTAL  %

BIND
	ILL32S	=	ACTBADCHAR	,
	TAB32S	=	ACTTABS	,
	LT32S	=	ACTLT	,
	BLANK32S	=	ACTANYS	,
	SPEC32S	=	ACTCHKOCPM	,
	DIGIT32S	=	ACTOCTQ1	,
	UPPER32S	=	ACTNOOCT	,
	LOWER32S	=	ACTNOOCT	,
	FOS32S	=	ACTNOOCT	,
	EOB32S	=	ACTEOB	,
	REMARK32S	=	ACTENTREMARK	;


%[1141]%	BIND OCTOFLO=HOLCONST;

	% LOOKING FOR OCTAL  %
	MACRO
ACMENTOCTQ   =
	HIAC _ 0;
	LOAC _ 0;
	SIIGN _ 0;
%[1141]%	OCTOFLO _ 0;	!No octal overflow
	STATE _ STOCTQ;
	LEAVE SMALCHAR
$;


	% NO DIGITS IN OCTAL CONSTANT  %
	MACRO
ACMNOOCT  =
	FATLEX ( PLIT'OCTAL DIGIT?0', .CHAR,     E0<0,0> );
	CALLR  ( STSKIP, STRETNX );
	VALUE _ EOSLEX^18;
	LEAVE NEWSTATE
$;


	% SEE IF WE HAVE A SIGN  %
	MACRO
ACMCHKOCPM   =
	STATE _ STOCTQ0;
	IF .CHAR  EQL  "-"
	THEN	( SIIGN _ -1;  LEAVE  SMALCHAR  );
	IF .CHAR  EQL  "+"  THEN  LEAVE SMALCHAR;
	ACTION _ ACTNOOCT;
	LEAVE NEWACTION
$;


% SMALL STATE DEFINITION	STOCTQ0	NUMBER (#) 33S  %
% AFTER THE SIGN BUT BEFORE ANY DIGITS %

BIND
	ILL33S	=	ACTBADCHAR	,
	TAB33S	=	ACTTABS	,
	LT33S	=	ACTLT	,
	BLANK33S	=	ACTANYS	,
	SPEC33S	=	ACTNOOCT	,
	DIGIT33S	=	ACTOCTQ1	,
	UPPER33S	=	ACTNOOCT	,
	LOWER33S	=	ACTNOOCT	,
	FOS33S	=	ACTNOOCT	,
	EOB33S	=	ACTEOB	,
	REMARK33S	=	ACTENTREMARK	;



% SMALL STATE DEFINITION	STOCTQ1	NUMBER (#) 34S  %
%  LOOK FOR DIGITS AFTER THE FIRST  %

BIND
	ILL34S	=	ACTBADCHAR	,
	TAB34S	=	ACTTABS	,
	LT34S	=	ACTLT	,
	BLANK34S	=	ACTANYS	,
	SPEC34S	=	ACTGOTOCT	,
	DIGIT34S	=	ACTOCTQ1	,
	UPPER34S	=	ACTGOTOCT	,
	LOWER34S	=	ACTGOTOCT	,
	FOS34S	=	ACTGOTOCT	,
	EOB34S	=	ACTEOB	,
	REMARK34S	=	ACTENTREMARK	;



	% PICK UP THOSE OCTAL DIGITS  %
	MACRO
ACMOCTQ1  =
	MACHOP  LSHC = #246;
	REGISTER  T[2];
	STATE _ STOCTQ1;
	T[0] _ .HIAC;  T[1] _ .LOAC;
	IF .CHAR  GEQ "8"
	THEN
	BEGIN	% BAD DIGIT %
		FATLEX ( PLIT'OCTAL DIGIT?0', .CHAR,   E0<0,0> );
		CHAR _ "0"
	END;
![1141]		CHECK FOR OCTAL OVERFLOW - LOSS OF SIGNIFICANT DIGITS
![1141]		24 SIGNIFICANT DIGITS IS THE MAX FOR A DOUBLE OCTAL
%[1141]%	IF .OCTOFLO NEQ 0 THEN LEAVE SMALCHAR;	!Already overflowed
%[1141]%	LSHC(T[0],3);		!Check for loss of significance
%[1141]%	LSHC(T[0],-3);
%[1141]%	IF .T[0] NEQ .HIAC
%[1141]%	THEN			!Lost something - give error
%[1141]%	BEGIN
%[1141]%		FATLEX( PLIT'a maximum of 24?0',
%[1141]%			PLIT'too many digits?0', E0<0,0> );
%[1141]%		OCTOFLO _ -1;	!And mark overflow
%[1141]%		LEAVE SMALCHAR
%[1141]%	END;
	LSHC(T[0],3);
	T[1] _ .T[1] + ( .CHAR - "0" );
	HIAC _ .T[0];
	LOAC _ .T[1];

	LEAVE SMALCHAR
$;


	MACRO
ACMGOTOCT  =
	EXTERNAL  GCONTAB;
	EXTERNAL  GOCTAL,GDUBOCT;
	IF .SIIGN  NEQ  0
	THEN ( HIAC _ -.HIAC;  LOAC _ -.LOAC);
	% NEGATIVES ARE KEPT IN DOUBLE PRECISION %
	SYMTYPE _ ( IF .HIAC  NEQ  0
		    THEN	GDUBOCT<0,0>
		    ELSE	GOCTAL<0,0>  );
	ENTRY[0] _ .HIAC;
	ENTRY[1] _ .LOAC;
	NAME _ .GCONTAB ;
	RETURNOW ( CONSTLEX^18 +  TBLSEARCH() )
$;



!------------------------------ FORMAT STATEMENT LEXICAL ANALYZER ------------------------------

EXTERNAL FMTPTR,	! POINTER TO FORMAT STORAGE AREA
		FMTEND,	! ADDRESS OF END OF FORMAT AREA + 1
		FMTOVER;	! ROUTINE WHICH ADDS MORE SPACE TO THE FORMAT AREA



%
THE LEXICAL ANALYZER FOR FORMATS RETURNS CONSTANTS, LITERALS ( "'" AND 
HOLERITH ), AND SINGLE CHARACTER LEXEMES.  THE ACTUAL LEXEME NUMBER FOR
ANY GIVEN LEXEME IS OBTAINED FROM TWO TABLES IN MODULE FORMAT.
  FOR LETTERS THE CODE COMES FROM FMTLET[.CHAR], FOR THE OTHER SINGLE
LETTER LEXEMES THE CODE IS OBTAINED FROM THE TABLE FMTLEX[.CODE] 
( IE. THE LEXICAL CHARACTER CODE IS THE INDEX ).  THE CONSTANT LEXEME
NUMBER IS FMTLEX[DIGIT], THE LITERAL LEXEME CODE ( OR HOLERITH ) IS
FMTLEX[LITSGN].
%

% BIG STATE DEFINITION	STFMTLEX	NUMBER (#) 18B  %

BIND
	ILL18B	=	ACTFLEX1	,
	TAB18B	=	ACTINTERR	,
	LT18B	=	ACTINTERR	,
	BLANK18B	=	ACTINTERR	,
	SPEC18B	=	ACTFLEX1	,
	DIGIT18B	=	ACTFMTHOLCK	,
	UPPER18B	=	ACTFMTCHAR	,
	LOWER18B	=	ACTUPLOW	,
	FOS18B	=	ACTFMTEOS	,
	EOB18B	=	ACTEOB	,
	REMARK18B	=	ACTINTERR	,
	EQUAL18B	=	ACTFLEX1	,
	LPAREN18B	=	ACTFLEX1	,
	RPAREN18B	=	ACTFLEX1	,
	COLON18B	=	ACTFLEX1	,
	COMMA18B	=	ACTFLEX1	,
	DOLLAR18B	=	ACTFLEX1	,
	ASTERISK18B	=	ACTFLEX1	,
	SLASH18B	=	ACTFLEX1	,
	PLUS18B	=	ACTFLEX1	,
	MINUS18B	=	ACTFLEX1	,
	ANDSGN18B	=	ACTFLEX1	,
	LITSGN18B	=	ACTFMTQT	,
	OCTSGN18B	=	ACTFLEX1	,
	NEQSGN18B	=	ACTFLEX1	,
	DOT18B	=	ACTFLEX1	,
	SEMICOL18B	=	ACTMULTST	,
	LTSGN18B	=	ACTFLEX1	,
	GTSGN18B	=	ACTFLEX1	,
	COMNTSGN18B	=	ACTFMTCHAR	,
	DEBUGSGN18B	=	ACTFMTCHAR	,
	UPAROW18B	=	ACTFLEX1	;


	% STORE THE CHARACTER IN THE FORMAT NODE AND CHECK TO SEE
	  IF YOU HAVE RUN OUT OF SPACE  %
	MACRO
SVFMTCHAR  =
	REPLACEI ( FMTPTR, .CHAR );
	IF .FMTPTR<RIGHT>  EQL  .FMTEND  THEN  FMTOVER(.CHAR)
$;


	% SINGLE CHARACTER NON-LETTER LEXEMES %
	MACRO
ACMFLEX1  =


	% NOW STORE THE CHARACTER IN THE FORMAT NODE %
	SVFMTCHAR;
	RETURNXT( .FMTLEX[ .CODE ]<RIGHT> )
$;


	% EOS ENCOUNTERED %
	MACRO
ACMFMTEOS  =
	IF ..CURPTR  NEQ  ";" AND .CHAR  EQL  EOS
	THEN  LEXLINE _ .LASTLINE;	!ADJUST LEXEME ERROR LINE NUMBER
	RETURNOW ( .FMTLEX[ FOS ]<RIGHT> )
$;


	% ITS A LETTER %
	MACRO
ACMFMTCHAR  =
	SVFMTCHAR;
	RETURNXT ( .FMTLET [ .CHAR - "A" +1 ]<LEFT> )
$;


% SMALL STATE DEFINITION	STFMTQT	NUMBER (#) 39S  %
% PICK UP QUOTED LITERAL STRINGS IN FORMAT STATEMENTS %

BIND
	ILL39S	=	ACTFMTQT1	,
	TAB39S	=	ACTHOLTAB	,
	LT39S	=	ACTLT	,
	BLANK39S	=	ACTFMTQT1	,
	SPEC39S	=	ACTFMTQT1	,
	DIGIT39S	=	ACTFMTQT1	,
	UPPER39S	=	ACTFMTQT1	,
	LOWER39S	=	ACTFMTQT1	,
	FOS39S	=	ACTFMTQT1	,
	EOB39S	=	ACTEOB	,
	REMARK39S	=	ACTFMTQT1	;


	% WE HAVE THE FIRST ' - SEE IF YOU CAN FIND ANOTHER  %
	MACRO
ACMFMTQT  =
	SVFMTCHAR;
	STATE _ STFMTQT;
	LEAVE SMALCHAR
$;


	% LOOKING FOR THAT SECOND '  %
	MACRO
ACMFMTQT1  =
	 IF .CODE EQL  FOS  
	THEN
	BEGIN	% NEVER GOING TO FIND IT NOW  %
		FATLEX(E72<0,0>);
		RETURNOW(.FMTLEX[FOS]<RIGHT>)
	END
	ELSE
	BEGIN
		SVFMTCHAR;
		IF .CHAR  EQL "'"
		THEN (RETURNXT( .FMTLEX[ LITSGN ]<RIGHT> ))
		ELSE	LEAVE SMALCHAR
	END
$;


% SMALL STATE DEFINITION	STFHOLCON	NUMBER (#) 40S  %
% WE ARE HERE TO PICK UP A CONSTANT AND SAVE IT INCASE THERE IS A 
	HOLLERITH FOLLOWING  %

BIND
	ILL40S	=	ACTHOLCONDONE	,
	TAB40S	=	ACTTABS	,
	LT40S	=	ACTLT	,
	BLANK40S	=	ACTANYS	,
	SPEC40S	=	ACTHOLCONDONE	,
	DIGIT40S	=	ACTHOLCON	,
	UPPER40S	=	ACTHOLCONDONE	,
	LOWER40S	=	ACTUPLOW	,
	FOS40S	=	ACTHOLCONDONE	,
	EOB40S	=	ACTEOB	,
	REMARK40S	=	ACTENTREMARK	;



	% WE HAVE A DIGIT %
	MACRO
ACMFMTHOLCK  =
	% INITIALIZE THE CONSTANT PICKUP %
	STATE _ STFHOLCON;
	HOLCONST _ 0;
	ACTION _ ACTHOLCON;
	LEAVE NEWACTION
$;


	% ADD UP THOSE DIGITS  %
	MACRO
ACMHOLCON  =
	HOLCONST _ .HOLCONST*10 + .CHAR - "0";
	SVFMTCHAR;
	LEAVE SMALCHAR
$;

EXTERNAL  	FMTLEX,	! NON-LETTER LEXEME CODE TABLE BASED UPON
				! BIGSTATE CHARACTER CODES
			FMTLET;	! LETTER LEXEME CODES TABLE BASED UPON THE LETTER


	% NO MORE DIGITS TO BE FOUND %
	MACRO
ACMHOLCONDONE  =
	IF .CHAR   NEQ  "H"
	THEN	( RETURNOW( .FMTLEX[DIGIT]<RIGHT> ))	! YOU FOUND A CONSTANT
	ELSE
	BEGIN	% ITS A HOLERITH %
		STATE _ STFHOLPKUP;
		ACTION _ ACTFMTHOLPKUP;
		LEAVE NEWACTION
	END
$;


% SMALL STATE DEFINITION	STFHOLPKUP	NUMBER (#) 41S  %
% GET THE HOLERITH STRING  %

BIND
	ILL41S	=	ACTFMTHOLPKUP	,
	TAB41S	=	ACTHOLTAB	,
	LT41S	=	ACTLT	,
	BLANK41S	=	ACTFMTHOLPKUP	,
	SPEC41S	=	ACTFMTHOLPKUP	,
	DIGIT41S	=	ACTFMTHOLPKUP	,
	UPPER41S	=	ACTFMTHOLPKUP	,
	LOWER41S	=	ACTFMTHOLPKUP	,
	FOS41S	=	ACTFMTHOLPKUP	,
	EOB41S	=	ACTEOB	,
	REMARK41S	=	ACTFMTHOLPKUP	;



	% GET THOSE ELUSIVE CHARACTERS %
	MACRO
ACMFMTHOLPKUP  =
	% NOTE THAT THE INITIAL "H" PASSES THROUGH HERE TOOOOO %
	IF .CODE EQL  FOS  
	THEN	( RETURNOW ( .FMTLEX[LITSGN]<RIGHT> ));
	SVFMTCHAR;
	IF .HOLCONST EQL  0
	THEN
	BEGIN
		RETURNXT( .FMTLEX[ LITSGN ]<RIGHT> )
	END
	ELSE
	BEGIN	% GO ON TO THE NEXT ONE %
		HOLCONST _ .HOLCONST - 1;
		LEAVE SMALCHAR
	END
$;









!
! --------------------------------------------------
!
! STATE TABLE SKELETON PLITS PRODUCED BY PRELEX.TEC
!
! --------------------------------------------------
!
! TABLE SIZE AND PACKING DEFINITIONS

GLOBAL BIND
	%%STPACK = 4,  % 5 STATE TABLE ENTRIES PER WORD %
	STBITS  =  36/STPACK,	% NUMBER OF BITS PER ENTRY  %
	%%LASTBIG = 19, 	% TOTAL NO. OF BIG STATES, I.E. LAST NO. + 1 %
	%%LASTSMAL= 42;	% TOTAL NO. OF SMALL STATES, I.E. LAST NO. +1 %
!
! --------------------------------------------------
!



SWITCHES  NOLIST;

%%%BEGIN SMALL STATE PLIT%%%
BIND	DODO2	=	PLIT (	SMALSTATE GLOBALLY NAMES

	S ,
	 ILL0S^27 + ILL1S^18 + ILL2S^9 + ILL3S^0 ,
	 TAB0S^27 + TAB1S^18 + TAB2S^9 + TAB3S^0 ,
	 LT0S^27 + LT1S^18 + LT2S^9 + LT3S^0 ,
	 BLANK0S^27 + BLANK1S^18 + BLANK2S^9 + BLANK3S^0 ,
	 SPEC0S^27 + SPEC1S^18 + SPEC2S^9 + SPEC3S^0 ,
	 DIGIT0S^27 + DIGIT1S^18 + DIGIT2S^9 + DIGIT3S^0 ,
	 UPPER0S^27 + UPPER1S^18 + UPPER2S^9 + UPPER3S^0 ,
	 LOWER0S^27 + LOWER1S^18 + LOWER2S^9 + LOWER3S^0 ,
	 FOS0S^27 + FOS1S^18 + FOS2S^9 + FOS3S^0 ,
	 EOB0S^27 + EOB1S^18 + EOB2S^9 + EOB3S^0 ,
	 REMARK0S^27 + REMARK1S^18 + REMARK2S^9 + REMARK3S^0 ,
	S ,
	 ILL4S^27 + ILL5S^18 + ILL6S^9 + ILL7S^0 ,
	 TAB4S^27 + TAB5S^18 + TAB6S^9 + TAB7S^0 ,
	 LT4S^27 + LT5S^18 + LT6S^9 + LT7S^0 ,
	 BLANK4S^27 + BLANK5S^18 + BLANK6S^9 + BLANK7S^0 ,
	 SPEC4S^27 + SPEC5S^18 + SPEC6S^9 + SPEC7S^0 ,
	 DIGIT4S^27 + DIGIT5S^18 + DIGIT6S^9 + DIGIT7S^0 ,
	 UPPER4S^27 + UPPER5S^18 + UPPER6S^9 + UPPER7S^0 ,
	 LOWER4S^27 + LOWER5S^18 + LOWER6S^9 + LOWER7S^0 ,
	 FOS4S^27 + FOS5S^18 + FOS6S^9 + FOS7S^0 ,
	 EOB4S^27 + EOB5S^18 + EOB6S^9 + EOB7S^0 ,
	 REMARK4S^27 + REMARK5S^18 + REMARK6S^9 + REMARK7S^0 ,
	S ,
	 ILL8S^27 + ILL9S^18 + ILL10S^9 + ILL11S^0 ,
	 TAB8S^27 + TAB9S^18 + TAB10S^9 + TAB11S^0 ,
	 LT8S^27 + LT9S^18 + LT10S^9 + LT11S^0 ,
	 BLANK8S^27 + BLANK9S^18 + BLANK10S^9 + BLANK11S^0 ,
	 SPEC8S^27 + SPEC9S^18 + SPEC10S^9 + SPEC11S^0 ,
	 DIGIT8S^27 + DIGIT9S^18 + DIGIT10S^9 + DIGIT11S^0 ,
	 UPPER8S^27 + UPPER9S^18 + UPPER10S^9 + UPPER11S^0 ,
	 LOWER8S^27 + LOWER9S^18 + LOWER10S^9 + LOWER11S^0 ,
	 FOS8S^27 + FOS9S^18 + FOS10S^9 + FOS11S^0 ,
	 EOB8S^27 + EOB9S^18 + EOB10S^9 + EOB11S^0 ,
	 REMARK8S^27 + REMARK9S^18 + REMARK10S^9 + REMARK11S^0 ,
	S ,
	 ILL12S^27 + ILL13S^18 + ILL14S^9 + ILL15S^0 ,
	 TAB12S^27 + TAB13S^18 + TAB14S^9 + TAB15S^0 ,
	 LT12S^27 + LT13S^18 + LT14S^9 + LT15S^0 ,
	 BLANK12S^27 + BLANK13S^18 + BLANK14S^9 + BLANK15S^0 ,
	 SPEC12S^27 + SPEC13S^18 + SPEC14S^9 + SPEC15S^0 ,
	 DIGIT12S^27 + DIGIT13S^18 + DIGIT14S^9 + DIGIT15S^0 ,
	 UPPER12S^27 + UPPER13S^18 + UPPER14S^9 + UPPER15S^0 ,
	 LOWER12S^27 + LOWER13S^18 + LOWER14S^9 + LOWER15S^0 ,
	 FOS12S^27 + FOS13S^18 + FOS14S^9 + FOS15S^0 ,
	 EOB12S^27 + EOB13S^18 + EOB14S^9 + EOB15S^0 ,
	 REMARK12S^27 + REMARK13S^18 + REMARK14S^9 + REMARK15S^0 ,
	S ,
	 ILL16S^27 + ILL17S^18 + ILL18S^9 + ILL19S^0 ,
	 TAB16S^27 + TAB17S^18 + TAB18S^9 + TAB19S^0 ,
	 LT16S^27 + LT17S^18 + LT18S^9 + LT19S^0 ,
	 BLANK16S^27 + BLANK17S^18 + BLANK18S^9 + BLANK19S^0 ,
	 SPEC16S^27 + SPEC17S^18 + SPEC18S^9 + SPEC19S^0 ,
	 DIGIT16S^27 + DIGIT17S^18 + DIGIT18S^9 + DIGIT19S^0 ,
	 UPPER16S^27 + UPPER17S^18 + UPPER18S^9 + UPPER19S^0 ,
	 LOWER16S^27 + LOWER17S^18 + LOWER18S^9 + LOWER19S^0 ,
	 FOS16S^27 + FOS17S^18 + FOS18S^9 + FOS19S^0 ,
	 EOB16S^27 + EOB17S^18 + EOB18S^9 + EOB19S^0 ,
	 REMARK16S^27 + REMARK17S^18 + REMARK18S^9 + REMARK19S^0 ,
	S ,
	 ILL20S^27 + ILL21S^18 + ILL22S^9 + ILL23S^0 ,
	 TAB20S^27 + TAB21S^18 + TAB22S^9 + TAB23S^0 ,
	 LT20S^27 + LT21S^18 + LT22S^9 + LT23S^0 ,
	 BLANK20S^27 + BLANK21S^18 + BLANK22S^9 + BLANK23S^0 ,
	 SPEC20S^27 + SPEC21S^18 + SPEC22S^9 + SPEC23S^0 ,
	 DIGIT20S^27 + DIGIT21S^18 + DIGIT22S^9 + DIGIT23S^0 ,
	 UPPER20S^27 + UPPER21S^18 + UPPER22S^9 + UPPER23S^0 ,
	 LOWER20S^27 + LOWER21S^18 + LOWER22S^9 + LOWER23S^0 ,
	 FOS20S^27 + FOS21S^18 + FOS22S^9 + FOS23S^0 ,
	 EOB20S^27 + EOB21S^18 + EOB22S^9 + EOB23S^0 ,
	 REMARK20S^27 + REMARK21S^18 + REMARK22S^9 + REMARK23S^0 ,
	S ,
	 ILL24S^27 + ILL25S^18 + ILL26S^9 + ILL27S^0 ,
	 TAB24S^27 + TAB25S^18 + TAB26S^9 + TAB27S^0 ,
	 LT24S^27 + LT25S^18 + LT26S^9 + LT27S^0 ,
	 BLANK24S^27 + BLANK25S^18 + BLANK26S^9 + BLANK27S^0 ,
	 SPEC24S^27 + SPEC25S^18 + SPEC26S^9 + SPEC27S^0 ,
	 DIGIT24S^27 + DIGIT25S^18 + DIGIT26S^9 + DIGIT27S^0 ,
	 UPPER24S^27 + UPPER25S^18 + UPPER26S^9 + UPPER27S^0 ,
	 LOWER24S^27 + LOWER25S^18 + LOWER26S^9 + LOWER27S^0 ,
	 FOS24S^27 + FOS25S^18 + FOS26S^9 + FOS27S^0 ,
	 EOB24S^27 + EOB25S^18 + EOB26S^9 + EOB27S^0 ,
	 REMARK24S^27 + REMARK25S^18 + REMARK26S^9 + REMARK27S^0 ,
	S ,
	 ILL28S^27 + ILL29S^18 + ILL30S^9 + ILL31S^0 ,
	 TAB28S^27 + TAB29S^18 + TAB30S^9 + TAB31S^0 ,
	 LT28S^27 + LT29S^18 + LT30S^9 + LT31S^0 ,
	 BLANK28S^27 + BLANK29S^18 + BLANK30S^9 + BLANK31S^0 ,
	 SPEC28S^27 + SPEC29S^18 + SPEC30S^9 + SPEC31S^0 ,
	 DIGIT28S^27 + DIGIT29S^18 + DIGIT30S^9 + DIGIT31S^0 ,
	 UPPER28S^27 + UPPER29S^18 + UPPER30S^9 + UPPER31S^0 ,
	 LOWER28S^27 + LOWER29S^18 + LOWER30S^9 + LOWER31S^0 ,
	 FOS28S^27 + FOS29S^18 + FOS30S^9 + FOS31S^0 ,
	 EOB28S^27 + EOB29S^18 + EOB30S^9 + EOB31S^0 ,
	 REMARK28S^27 + REMARK29S^18 + REMARK30S^9 + REMARK31S^0 ,
	S ,
	 ILL32S^27 + ILL33S^18 + ILL34S^9 + ILL35S^0 ,
	 TAB32S^27 + TAB33S^18 + TAB34S^9 + TAB35S^0 ,
	 LT32S^27 + LT33S^18 + LT34S^9 + LT35S^0 ,
	 BLANK32S^27 + BLANK33S^18 + BLANK34S^9 + BLANK35S^0 ,
	 SPEC32S^27 + SPEC33S^18 + SPEC34S^9 + SPEC35S^0 ,
	 DIGIT32S^27 + DIGIT33S^18 + DIGIT34S^9 + DIGIT35S^0 ,
	 UPPER32S^27 + UPPER33S^18 + UPPER34S^9 + UPPER35S^0 ,
	 LOWER32S^27 + LOWER33S^18 + LOWER34S^9 + LOWER35S^0 ,
	 FOS32S^27 + FOS33S^18 + FOS34S^9 + FOS35S^0 ,
	 EOB32S^27 + EOB33S^18 + EOB34S^9 + EOB35S^0 ,
	 REMARK32S^27 + REMARK33S^18 + REMARK34S^9 + REMARK35S^0 ,
	S ,
	 ILL36S^27 + ILL37S^18 + ILL38S^9 + ILL39S^0 ,
	 TAB36S^27 + TAB37S^18 + TAB38S^9 + TAB39S^0 ,
	 LT36S^27 + LT37S^18 + LT38S^9 + LT39S^0 ,
	 BLANK36S^27 + BLANK37S^18 + BLANK38S^9 + BLANK39S^0 ,
	 SPEC36S^27 + SPEC37S^18 + SPEC38S^9 + SPEC39S^0 ,
	 DIGIT36S^27 + DIGIT37S^18 + DIGIT38S^9 + DIGIT39S^0 ,
	 UPPER36S^27 + UPPER37S^18 + UPPER38S^9 + UPPER39S^0 ,
	 LOWER36S^27 + LOWER37S^18 + LOWER38S^9 + LOWER39S^0 ,
	 FOS36S^27 + FOS37S^18 + FOS38S^9 + FOS39S^0 ,
	 EOB36S^27 + EOB37S^18 + EOB38S^9 + EOB39S^0 ,
	 REMARK36S^27 + REMARK37S^18 + REMARK38S^9 + REMARK39S^0 ,
![742] ADD STATES FOR STOP/PAUSE STATEMENTS
	S ,
%[742]%	 ILL40S^27 + ILL41S^18 + ILL42S^9 ,
%[742]%	 TAB40S^27 + TAB41S^18 + TAB42S^9 ,
%[742]%	 LT40S^27 + LT41S^18 + LT42S^9 ,
%[742]%	 BLANK40S^27 + BLANK41S^18 + BLANK42S^9 ,
%[742]%	 SPEC40S^27 + SPEC41S^18 + SPEC42S^9 ,
%[742]%	 DIGIT40S^27 + DIGIT41S^18 + DIGIT42S^9 ,
%[742]%	 UPPER40S^27 + UPPER41S^18 + UPPER42S^9 ,
%[742]%	 LOWER40S^27 + LOWER41S^18 + LOWER42S^9 ,
%[742]%	 FOS40S^27 + FOS41S^18 + FOS42S^9 ,
%[742]%	 EOB40S^27 + EOB41S^18 + EOB42S^9 ,
%[742]%	 REMARK40S^27 + REMARK41S^18 + REMARK42S^9
	);

%%%END SMALL STATE PLIT%%%

%%%BEGIN BIG STATE PLIT%%%
BIND	DODO1	=	PLIT (	BIGSTATE GLOBALLY NAMES

	B ,
	 ILL0B^27 + ILL1B^18 + ILL2B^9 + ILL3B^0 ,
	 TAB0B^27 + TAB1B^18 + TAB2B^9 + TAB3B^0 ,
	 LT0B^27 + LT1B^18 + LT2B^9 + LT3B^0 ,
	 BLANK0B^27 + BLANK1B^18 + BLANK2B^9 + BLANK3B^0 ,
	 SPEC0B^27 + SPEC1B^18 + SPEC2B^9 + SPEC3B^0 ,
	 DIGIT0B^27 + DIGIT1B^18 + DIGIT2B^9 + DIGIT3B^0 ,
	 UPPER0B^27 + UPPER1B^18 + UPPER2B^9 + UPPER3B^0 ,
	 LOWER0B^27 + LOWER1B^18 + LOWER2B^9 + LOWER3B^0 ,
	 FOS0B^27 + FOS1B^18 + FOS2B^9 + FOS3B^0 ,
	 EOB0B^27 + EOB1B^18 + EOB2B^9 + EOB3B^0 ,
	 REMARK0B^27 + REMARK1B^18 + REMARK2B^9 + REMARK3B^0 ,
	 ANDSGN0B^27 + ANDSGN1B^18 + ANDSGN2B^9 + ANDSGN3B^0 ,
	 LPAREN0B^27 + LPAREN1B^18 + LPAREN2B^9 + LPAREN3B^0 ,
	 RPAREN0B^27 + RPAREN1B^18 + RPAREN2B^9 + RPAREN3B^0 ,
	 COLON0B^27 + COLON1B^18 + COLON2B^9 + COLON3B^0 ,
	 COMMA0B^27 + COMMA1B^18 + COMMA2B^9 + COMMA3B^0 ,
	 DOLLAR0B^27 + DOLLAR1B^18 + DOLLAR2B^9 + DOLLAR3B^0 ,
	 MINUS0B^27 + MINUS1B^18 + MINUS2B^9 + MINUS3B^0 ,
	 SLASH0B^27 + SLASH1B^18 + SLASH2B^9 + SLASH3B^0 ,
	 PLUS0B^27 + PLUS1B^18 + PLUS2B^9 + PLUS3B^0 ,
	 ASTERISK0B^27 + ASTERISK1B^18 + ASTERISK2B^9 + ASTERISK3B^0 ,
	 EQUAL0B^27 + EQUAL1B^18 + EQUAL2B^9 + EQUAL3B^0 ,
	 LTSGN0B^27 + LTSGN1B^18 + LTSGN2B^9 + LTSGN3B^0 ,
	 GTSGN0B^27 + GTSGN1B^18 + GTSGN2B^9 + GTSGN3B^0 ,
	 NEQSGN0B^27 + NEQSGN1B^18 + NEQSGN2B^9 + NEQSGN3B^0 ,
	 DOT0B^27 + DOT1B^18 + DOT2B^9 + DOT3B^0 ,
	 SEMICOL0B^27 + SEMICOL1B^18 + SEMICOL2B^9 + SEMICOL3B^0 ,
	 LITSGN0B^27 + LITSGN1B^18 + LITSGN2B^9 + LITSGN3B^0 ,
	 OCTSGN0B^27 + OCTSGN1B^18 + OCTSGN2B^9 + OCTSGN3B^0 ,
	 COMNTSGN0B^27 + COMNTSGN1B^18 + COMNTSGN2B^9 + COMNTSGN3B^0 ,
	 DEBUGSGN0B^27 + DEBUGSGN1B^18 + DEBUGSGN2B^9 + DEBUGSGN3B^0 ,
	 UPAROW0B^27 + UPAROW1B^18 + UPAROW2B^9 + UPAROW3B^0 ,
	B ,
	 ILL4B^27 + ILL5B^18 + ILL6B^9 + ILL7B^0 ,
	 TAB4B^27 + TAB5B^18 + TAB6B^9 + TAB7B^0 ,
	 LT4B^27 + LT5B^18 + LT6B^9 + LT7B^0 ,
	 BLANK4B^27 + BLANK5B^18 + BLANK6B^9 + BLANK7B^0 ,
	 SPEC4B^27 + SPEC5B^18 + SPEC6B^9 + SPEC7B^0 ,
	 DIGIT4B^27 + DIGIT5B^18 + DIGIT6B^9 + DIGIT7B^0 ,
	 UPPER4B^27 + UPPER5B^18 + UPPER6B^9 + UPPER7B^0 ,
	 LOWER4B^27 + LOWER5B^18 + LOWER6B^9 + LOWER7B^0 ,
	 FOS4B^27 + FOS5B^18 + FOS6B^9 + FOS7B^0 ,
	 EOB4B^27 + EOB5B^18 + EOB6B^9 + EOB7B^0 ,
	 REMARK4B^27 + REMARK5B^18 + REMARK6B^9 + REMARK7B^0 ,
	 ANDSGN4B^27 + ANDSGN5B^18 + ANDSGN6B^9 + ANDSGN7B^0 ,
	 LPAREN4B^27 + LPAREN5B^18 + LPAREN6B^9 + LPAREN7B^0 ,
	 RPAREN4B^27 + RPAREN5B^18 + RPAREN6B^9 + RPAREN7B^0 ,
	 COLON4B^27 + COLON5B^18 + COLON6B^9 + COLON7B^0 ,
	 COMMA4B^27 + COMMA5B^18 + COMMA6B^9 + COMMA7B^0 ,
	 DOLLAR4B^27 + DOLLAR5B^18 + DOLLAR6B^9 + DOLLAR7B^0 ,
	 MINUS4B^27 + MINUS5B^18 + MINUS6B^9 + MINUS7B^0 ,
	 SLASH4B^27 + SLASH5B^18 + SLASH6B^9 + SLASH7B^0 ,
	 PLUS4B^27 + PLUS5B^18 + PLUS6B^9 + PLUS7B^0 ,
	 ASTERISK4B^27 + ASTERISK5B^18 + ASTERISK6B^9 + ASTERISK7B^0 ,
	 EQUAL4B^27 + EQUAL5B^18 + EQUAL6B^9 + EQUAL7B^0 ,
	 LTSGN4B^27 + LTSGN5B^18 + LTSGN6B^9 + LTSGN7B^0 ,
	 GTSGN4B^27 + GTSGN5B^18 + GTSGN6B^9 + GTSGN7B^0 ,
	 NEQSGN4B^27 + NEQSGN5B^18 + NEQSGN6B^9 + NEQSGN7B^0 ,
	 DOT4B^27 + DOT5B^18 + DOT6B^9 + DOT7B^0 ,
	 SEMICOL4B^27 + SEMICOL5B^18 + SEMICOL6B^9 + SEMICOL7B^0 ,
	 LITSGN4B^27 + LITSGN5B^18 + LITSGN6B^9 + LITSGN7B^0 ,
	 OCTSGN4B^27 + OCTSGN5B^18 + OCTSGN6B^9 + OCTSGN7B^0 ,
	 COMNTSGN4B^27 + COMNTSGN5B^18 + COMNTSGN6B^9 + COMNTSGN7B^0 ,
	 DEBUGSGN4B^27 + DEBUGSGN5B^18 + DEBUGSGN6B^9 + DEBUGSGN7B^0 ,
	 UPAROW4B^27 + UPAROW5B^18 + UPAROW6B^9 + UPAROW7B^0 ,
	B ,
	 ILL8B^27 + ILL9B^18 + ILL10B^9 + ILL11B^0 ,
	 TAB8B^27 + TAB9B^18 + TAB10B^9 + TAB11B^0 ,
	 LT8B^27 + LT9B^18 + LT10B^9 + LT11B^0 ,
	 BLANK8B^27 + BLANK9B^18 + BLANK10B^9 + BLANK11B^0 ,
	 SPEC8B^27 + SPEC9B^18 + SPEC10B^9 + SPEC11B^0 ,
	 DIGIT8B^27 + DIGIT9B^18 + DIGIT10B^9 + DIGIT11B^0 ,
	 UPPER8B^27 + UPPER9B^18 + UPPER10B^9 + UPPER11B^0 ,
	 LOWER8B^27 + LOWER9B^18 + LOWER10B^9 + LOWER11B^0 ,
	 FOS8B^27 + FOS9B^18 + FOS10B^9 + FOS11B^0 ,
	 EOB8B^27 + EOB9B^18 + EOB10B^9 + EOB11B^0 ,
	 REMARK8B^27 + REMARK9B^18 + REMARK10B^9 + REMARK11B^0 ,
	 ANDSGN8B^27 + ANDSGN9B^18 + ANDSGN10B^9 + ANDSGN11B^0 ,
	 LPAREN8B^27 + LPAREN9B^18 + LPAREN10B^9 + LPAREN11B^0 ,
	 RPAREN8B^27 + RPAREN9B^18 + RPAREN10B^9 + RPAREN11B^0 ,
	 COLON8B^27 + COLON9B^18 + COLON10B^9 + COLON11B^0 ,
	 COMMA8B^27 + COMMA9B^18 + COMMA10B^9 + COMMA11B^0 ,
	 DOLLAR8B^27 + DOLLAR9B^18 + DOLLAR10B^9 + DOLLAR11B^0 ,
	 MINUS8B^27 + MINUS9B^18 + MINUS10B^9 + MINUS11B^0 ,
	 SLASH8B^27 + SLASH9B^18 + SLASH10B^9 + SLASH11B^0 ,
	 PLUS8B^27 + PLUS9B^18 + PLUS10B^9 + PLUS11B^0 ,
	 ASTERISK8B^27 + ASTERISK9B^18 + ASTERISK10B^9 + ASTERISK11B^0 ,
	 EQUAL8B^27 + EQUAL9B^18 + EQUAL10B^9 + EQUAL11B^0 ,
	 LTSGN8B^27 + LTSGN9B^18 + LTSGN10B^9 + LTSGN11B^0 ,
	 GTSGN8B^27 + GTSGN9B^18 + GTSGN10B^9 + GTSGN11B^0 ,
	 NEQSGN8B^27 + NEQSGN9B^18 + NEQSGN10B^9 + NEQSGN11B^0 ,
	 DOT8B^27 + DOT9B^18 + DOT10B^9 + DOT11B^0 ,
	 SEMICOL8B^27 + SEMICOL9B^18 + SEMICOL10B^9 + SEMICOL11B^0 ,
	 LITSGN8B^27 + LITSGN9B^18 + LITSGN10B^9 + LITSGN11B^0 ,
	 OCTSGN8B^27 + OCTSGN9B^18 + OCTSGN10B^9 + OCTSGN11B^0 ,
	 COMNTSGN8B^27 + COMNTSGN9B^18 + COMNTSGN10B^9 + COMNTSGN11B^0 ,
	 DEBUGSGN8B^27 + DEBUGSGN9B^18 + DEBUGSGN10B^9 + DEBUGSGN11B^0 ,
	 UPAROW8B^27 + UPAROW9B^18 + UPAROW10B^9 + UPAROW11B^0 ,
	B ,
	 ILL12B^27 + ILL13B^18 + ILL14B^9 + ILL15B^0 ,
	 TAB12B^27 + TAB13B^18 + TAB14B^9 + TAB15B^0 ,
	 LT12B^27 + LT13B^18 + LT14B^9 + LT15B^0 ,
	 BLANK12B^27 + BLANK13B^18 + BLANK14B^9 + BLANK15B^0 ,
	 SPEC12B^27 + SPEC13B^18 + SPEC14B^9 + SPEC15B^0 ,
	 DIGIT12B^27 + DIGIT13B^18 + DIGIT14B^9 + DIGIT15B^0 ,
	 UPPER12B^27 + UPPER13B^18 + UPPER14B^9 + UPPER15B^0 ,
	 LOWER12B^27 + LOWER13B^18 + LOWER14B^9 + LOWER15B^0 ,
	 FOS12B^27 + FOS13B^18 + FOS14B^9 + FOS15B^0 ,
	 EOB12B^27 + EOB13B^18 + EOB14B^9 + EOB15B^0 ,
	 REMARK12B^27 + REMARK13B^18 + REMARK14B^9 + REMARK15B^0 ,
	 ANDSGN12B^27 + ANDSGN13B^18 + ANDSGN14B^9 + ANDSGN15B^0 ,
	 LPAREN12B^27 + LPAREN13B^18 + LPAREN14B^9 + LPAREN15B^0 ,
	 RPAREN12B^27 + RPAREN13B^18 + RPAREN14B^9 + RPAREN15B^0 ,
	 COLON12B^27 + COLON13B^18 + COLON14B^9 + COLON15B^0 ,
	 COMMA12B^27 + COMMA13B^18 + COMMA14B^9 + COMMA15B^0 ,
	 DOLLAR12B^27 + DOLLAR13B^18 + DOLLAR14B^9 + DOLLAR15B^0 ,
	 MINUS12B^27 + MINUS13B^18 + MINUS14B^9 + MINUS15B^0 ,
	 SLASH12B^27 + SLASH13B^18 + SLASH14B^9 + SLASH15B^0 ,
	 PLUS12B^27 + PLUS13B^18 + PLUS14B^9 + PLUS15B^0 ,
	 ASTERISK12B^27 + ASTERISK13B^18 + ASTERISK14B^9 + ASTERISK15B^0 ,
	 EQUAL12B^27 + EQUAL13B^18 + EQUAL14B^9 + EQUAL15B^0 ,
	 LTSGN12B^27 + LTSGN13B^18 + LTSGN14B^9 + LTSGN15B^0 ,
	 GTSGN12B^27 + GTSGN13B^18 + GTSGN14B^9 + GTSGN15B^0 ,
	 NEQSGN12B^27 + NEQSGN13B^18 + NEQSGN14B^9 + NEQSGN15B^0 ,
	 DOT12B^27 + DOT13B^18 + DOT14B^9 + DOT15B^0 ,
	 SEMICOL12B^27 + SEMICOL13B^18 + SEMICOL14B^9 + SEMICOL15B^0 ,
	 LITSGN12B^27 + LITSGN13B^18 + LITSGN14B^9 + LITSGN15B^0 ,
	 OCTSGN12B^27 + OCTSGN13B^18 + OCTSGN14B^9 + OCTSGN15B^0 ,
	 COMNTSGN12B^27 + COMNTSGN13B^18 + COMNTSGN14B^9 + COMNTSGN15B^0 ,
	 DEBUGSGN12B^27 + DEBUGSGN13B^18 + DEBUGSGN14B^9 + DEBUGSGN15B^0 ,
	 UPAROW12B^27 + UPAROW13B^18 + UPAROW14B^9 + UPAROW15B^0 ,
	B ,
	 ILL16B^27 + ILL17B^18 + ILL18B^9 ,
	 TAB16B^27 + TAB17B^18 + TAB18B^9 ,
	 LT16B^27 + LT17B^18 + LT18B^9 ,
	 BLANK16B^27 + BLANK17B^18 + BLANK18B^9 ,
	 SPEC16B^27 + SPEC17B^18 + SPEC18B^9 ,
	 DIGIT16B^27 + DIGIT17B^18 + DIGIT18B^9 ,
	 UPPER16B^27 + UPPER17B^18 + UPPER18B^9 ,
	 LOWER16B^27 + LOWER17B^18 + LOWER18B^9 ,
	 FOS16B^27 + FOS17B^18 + FOS18B^9 ,
	 EOB16B^27 + EOB17B^18 + EOB18B^9 ,
	 REMARK16B^27 + REMARK17B^18 + REMARK18B^9 ,
	 ANDSGN16B^27 + ANDSGN17B^18 + ANDSGN18B^9 ,
	 LPAREN16B^27 + LPAREN17B^18 + LPAREN18B^9 ,
	 RPAREN16B^27 + RPAREN17B^18 + RPAREN18B^9 ,
	 COLON16B^27 + COLON17B^18 + COLON18B^9 ,
	 COMMA16B^27 + COMMA17B^18 + COMMA18B^9 ,
	 DOLLAR16B^27 + DOLLAR17B^18 + DOLLAR18B^9 ,
	 MINUS16B^27 + MINUS17B^18 + MINUS18B^9 ,
	 SLASH16B^27 + SLASH17B^18 + SLASH18B^9 ,
	 PLUS16B^27 + PLUS17B^18 + PLUS18B^9 ,
	 ASTERISK16B^27 + ASTERISK17B^18 + ASTERISK18B^9 ,
	 EQUAL16B^27 + EQUAL17B^18 + EQUAL18B^9 ,
	 LTSGN16B^27 + LTSGN17B^18 + LTSGN18B^9 ,
	 GTSGN16B^27 + GTSGN17B^18 + GTSGN18B^9 ,
	 NEQSGN16B^27 + NEQSGN17B^18 + NEQSGN18B^9 ,
	 DOT16B^27 + DOT17B^18 + DOT18B^9 ,
	 SEMICOL16B^27 + SEMICOL17B^18 + SEMICOL18B^9 ,
	 LITSGN16B^27 + LITSGN17B^18 + LITSGN18B^9 ,
	 OCTSGN16B^27 + OCTSGN17B^18 + OCTSGN18B^9 ,
	 COMNTSGN16B^27 + COMNTSGN17B^18 + COMNTSGN18B^9 ,
	 DEBUGSGN16B^27 + DEBUGSGN17B^18 + DEBUGSGN18B^9 ,
	 UPAROW16B^27 + UPAROW17B^18 + UPAROW18B^9 
	);

%%%END BIG STATE PLIT%%%
SWITCHES  LIST ;




%ROUTLEX%
!---------------------------------------------------------------------------
GLOBAL ROUTINE LEXICAL (STATEE)  =
BEGIN % ROUTINE LEXICAL %
	
	EXTERNAL TRACE;
	REGISTER STATE;
	REGISTER  CODE=1,ACTION =2, CHAR =3;
	MACRO
SMALCODE = .CODETAB <LEFT,CHAR>  $,
BIGCODE = .CODETAB <RIGHT , CHAR > $;

!
! --------------------------------------------------
!
! STATE TABLE STRUCTURE DEFINITIONS AND MAPPINGS
!
! --------------------------------------------------
!


! DEFINITION OF THE STRUCTURE OF THE SMALL STATE TABLES
STRUCTURE SMAL [I] = [((I/STPACK)+1)*(LASTSMALCODE+1) ]
		( ( .SMAL + (.I/STPACK)*(LASTSMALCODE+1)  )
		  < (STPACK-(.I-((.I/STPACK)*STPACK)+1))*STBITS + ( 36 MOD STBITS ) , STBITS  , CODE >
		);

! DEFINITION OF THE STRUCTURE OF THE BIG STATE TABLES
STRUCTURE BIG [I] = [((I/STPACK)+1)*(LASTBIGCODE+1) ]
		( ( .BIG + (.I/STPACK)*(LASTBIGCODE+1)  )
		  < (STPACK-(.I-((.I/STPACK)*STPACK)+1))*STBITS + ( 36 MOD STBITS ) , STBITS  , CODE >
		);

% THE FIRST ENTRY IN EACH ACTION TABLE IS AN INDICATOR AS TO BIG OR SMALL
	CODES -   S(0) SMALL,  B(1)  BIG.  THIS ENTRY MUST BE REFERENCED
	AS  [-1].
%

MAP BIG BIGSTATE [ LASTBIG ];
MAP SMAL SMALSTATE [ LASTSMAL ];

!
! --------------------------------------------------
!

! ASSOCIATE STATE NAMES TO THE STARTING POSITION OF THEIR STATE TABLES.
!  THE TOTAL NUMBER OF BIGSTATES
! AND SMALL STATES MUST BE INPUT TO THE TECO MACROS BIGSTA.TEC AND
! SMALST.TEC RESPECTIVELY IN ORDER FOR THEM TO GENERATE THE PROPER SIZE PLIT
! WHICH PRESETS BIGSTATE AND SMALSTATE.

! THIS FILE MUST FOLLOW THE PLITS WHICH DEFINE THE BIG AND SMALL STATE TABLES
!
! --------------------------------------------------
!
! BINDS OF THE BIG STATES TO BIGSTATE[I]

%BIGDEF%
BIND
!	STATE NAME	=	BIGSTATE[I]

	STSTMNT = BIGSTATE [0],
	STILINE= BIGSTATE [1],
	STLEXEME = BIGSTATE [2],
	STSKIP = BIGSTATE [3],
	STCONTINUE = BIGSTATE [4],
	STNOEND = BIGSTATE [5],
	STEOP = BIGSTATE [6],
	STTERM = BIGSTATE [7],
	STCLASF2 = BIGSTATE [8],
	STCLASAL1 = BIGSTATE [9],
	STIFCHK = BIGSTATE [10],
	STDOCHK1 = BIGSTATE [11],
	STDOCHK2 = BIGSTATE [12],
	STCLASAL2 = BIGSTATE [13],
	STCLASAL2A = BIGSTATE [14],
	STCLASF4 = BIGSTATE [15],
	STDOUBLEX = BIGSTATE [16],
	STGETCONST = BIGSTATE [17],
	STFMTLEX = BIGSTATE [18],

%	LASTBIG	= ???       SET BIND APPEARING BEFORE PLIT DEFINITIONS%
	BIGEND	=  0 ;
!


!
! BINDS OF THE SMALL STATE NAMES TO SMALSTATE[I]
!

%SMALDEF%
BIND
!	STATE NAME	=	SMALSTATE[I]
!
	STREMARK= SMALSTATE [0],
	STINIT	= SMALSTATE [1],
	STRETNX = SMALSTATE [2],
	STNULLST = SMALSTATE [3],
	STCOMNT = SMALSTATE [4],
	STCALCONT = SMALSTATE [5],
	STCLABSKP = SMALSTATE [6],
	STCNTCONT = SMALSTATE [7],
	STCITCONT = SMALSTATE  [8],
	STILABEL = SMALSTATE [9],
	STLABSKP = SMALSTATE [10],
	STILNTCONT = SMALSTATE [11],
	STILITCONT = SMALSTATE [12],
	STGETLIT = SMALSTATE [13],
	STSKNAME = SMALSTATE [14],
	STCONSTSKP = SMALSTATE [15],
	STSKPHOL = SMALSTATE [16],
	STCLASF3 = SMALSTATE [17],
	STSPELLING = SMALSTATE [18],
	STIDENT = SMALSTATE [19],
	STDOT = SMALSTATE [20],
	STSCANOP = SMALSTATE [21],
	STBLDDBLINT = SMALSTATE [22],
	STREALCON = SMALSTATE [23],
	STREALCON1 = SMALSTATE [24],
	STOPCHK = SMALSTATE [25],
	STINTEXPONENT = SMALSTATE [26],
	STINTEXP0 = SMALSTATE [27],
	STINTEXP1 = SMALSTATE [28],
	STHOLEX = SMALSTATE [29],
	STLITLEX = SMALSTATE [30],
	STLITEND = SMALSTATE [31],
	STOCTQ = SMALSTATE [32],
	STOCTQ0 = SMALSTATE [33],
	STOCTQ1 = SMALSTATE [34],
	STIFCLASIF = SMALSTATE [35],
	STCSCAN = SMALSTATE [36],
	STSSCAN = SMALSTATE [37],
	STOPOBJ = SMALSTATE [38],
	STFMTQT = SMALSTATE [39],
	STFHOLCON = SMALSTATE [40],
	STFHOLPKUP = SMALSTATE [41],
%[742]%	STSIXDIGIT = SMALSTATE[42],

%	LASTSMAL	= ???	SET BIND APPEARING BEFORE PLIT DEFINITIONS%
	SMALEND	= 0  ;


! ALL GLOBAL STATE NAMES ARE DEFINED HERE IN THE FOLLOWING FORMAT:
!  BIND  DUM# = PLIT( EXTNAME  GLOBALLY NAMES INTERNAL-NAME )
!
! AN EXTERNAL STATE REFERENCE IS MADE WITH THE CONTENTS

BIND  DUM0 = PLIT(

	GSTSTMNT GLOBALLY NAMES STSTMNT ,
	GSTLEXEME GLOBALLY NAMES STLEXEME ,
	GSTNOEND GLOBALLY NAMES STNOEND ,
	GSTEOP GLOBALLY NAMES STEOP  ,
	GSTCSCAN GLOBALLY NAMES STCSCAN ,
	GSTSSCAN GLOBALLY NAMES STSSCAN ,
	GSTOPOBJ GLOBALLY NAMES STOPOBJ ,
	GSTFMTLEX GLOBALLY NAMES STFMTLEX,
	GSTIFCLASIF GLOBALLY NAMES STIFCLASIF 
);





	 ROUTINE
CHKXCR  =
BEGIN	% CHANGES ALL EXTRANEOUS CRS TO NULL AND OUTPUTS MESSAGE %
	LOCAL  TMP;
	REGISTER  CODE = 1,ACTION = 2, CHAR = 3;
	TMP _ .CURPTR;
	DECREMENT (TMP);	! THE CR WAS THE LAST CHARACTER

	% SKIP ALL NULLS OR CR'S %
	WHILE .CHAR  EQL  CR  OR .CHAR  EQL  0
	DO  ISCAN ( CHAR, CURPTR );

	IF ( CODE _ SMALCODE ) NEQ  LT
	THEN
	BEGIN
		% HANDLE EXTRANEOUS CR'S  %
		% SET ALL CR'S TO NULL %
		   DO (REPLACEN(TMP,0);INCP(TMP))
		   UNTIL  .TMP  EQL  .CURPTR  ;
		  IF .CODE  NEQ  EOB
		  THEN  % OUTPUT EXTRANEOUS CR MESSAGE  %
			% TEMPORARY MESSAGE %
		  BEGIN
			EXTERNAL  WARNERR;
			LOCAL SAVNAME;
			EXTERNAL  NAME;
			SAVNAME _ .NAME;	!NAME MAY BE DESTROYED
			WARNERR ( .LINELINE, E111<0,0>);
			NAME _ .SAVNAME
		  END;
		  % ELSE WE DON'T KNOW WHETHER ITS EXTRANEOUS OR NOT SO ITS CLEARED
		    IN CASE IT IS BUT NO MESSAGE IS OUTPUT IN CASE ITS NOT.  THIS
		    IS AN UNLIKELY CASE SO WE CAN LIVE THROUGH NOT REPORTING THE 
		    EXTRANEOUS  CR
		  %
		  % CONTINUE PROCESSING WITH GIVEN CHAR %
		% THE CODE RETURNED IS SMALL SO IF BIG IS REQUIRED THEN THE CALLER MUST SET IT %
	END;
	
	RETURN .CODE

END;	% CHKXCR %

	EXTERNAL FNDFF,CHAROUT,HEADING;
	ROUTINE SPURFF =
	BEGIN !DETECTS FORM FEED WHEN ATTEMPTING TO DETECT CONTINUATION LINE.
		!THIS CONDITION WILL CAUSE PAGE HEADER TO BE PRINTED, BUT
		!WILL NOT PROHIBIT A CONTINUATION LINE AFTER THIS!

		REGISTER CHAR=3;
		IF .CHAR EQL FF
		THEN
			BEGIN
				LINEPTR_CONTPTR_.CURPTR;
				ISCAN(CHAR,CURPTR);
				FNDFF_1;
![642] ONLY OUTPUT THE PAGE HEADING IF NOT STILL CLASSIFYING THE 
![642] STATEMENT WHICH PRECEDED THE FORM FEED.
%[642]%				IF .FLGREG<LISTING> THEN
%[642]%					IF .INCLAS EQL 0 THEN (CHAROUT(FF); HEADING());
				RETURN 1;
			END
		ELSE RETURN 0;
	END; !OF ROUTINE SPURFF

	ROUTINE SPURCR =
BEGIN	% DETECTS SPURIOUS CR.  RETURNS 1 IF SPUR CR ,OUTPUTS MESSAGE AND 0 IF NO SPURIOUSCR%
	REGISTER  CODE = 1, ACTION = 2, CHAR = 3;
	IF .CHAR  EQL  CR
	THEN
	BEGIN
		ISCAN  ( CHAR,CURPTR);
		IF ( CODE _ SMALCODE ) NEQ LT
		THEN	IF CHKXCR()  NEQ  LT
			THEN  RETURN  1;
		FOUNDCR _ 1
	END;
	RETURN 0
END;	% SPURCR%


! THIS IS THE ROUTINE WHICH WILL INITIAIZE LEXICAL


GLOBAL ROUTINE LEXINI  =
BEGIN

	EXTERNAL  LEXICAL,NUMWARN,NUMFATL,WARNOPT,MSGNOTYPD,PAGE;

 INCOMNT _ 0;

 IF CURWORD EQL  0
 THEN	( % INITIALIZATION FOR FIRST PROGRAM UNIT. PICK UP LINESEQNO IF ANY %
	CHARPOS _ 72;
	

	CURPTR _ POOLBEGIN<FIRSTCHAR>;
	CHARTMP _ ..CURPTR  ;
	RETURN  LEXICAL ( STINIT ) 
	)
 ELSE
	( % INITIALIZATION FOR >=2ND PROGRAM UNIT %
	  IF NOT .SEQLAST  THEN  LINELINE _ 1;
	  % ELSE LEAVE IT BECAUSE ITS A LINE SEQUENCE NO. %
	  CHARTMP _ EOS ;
	  %BLANK OUT THE BEGINNING 0F MULTIPLE STATEMENT LINES %

	  TEMP _ .LINEPTR;
	  UNTIL .TEMP EQL  .CURPTR  DO REPLACEI(TEMP," ");
	  !EAT ONE FORM FEED BETWEEN SUBPROGRAMS FOR READABILITY
	  SCANI(TEMP);
	  IF ..TEMP EQL FF THEN (SCANI(LINEPTR);SCANI(CURPTR));

	  RETURN 1
	)
END;

!
! --------------------------------------------------
!
! BEGIN ROUTINE LEXICAL
!
! --------------------------------------------------
!
LABEL  NEWSTATE,NEWACTION;


! STRUCTURE DEFINITION FOR STATE TABLE REFERENCES
STRUCTURE STATEREF [I] = [1]  ( . ( ( ..STATEREF ) + .I )  );
%REGISTER   ACTION = 2  ;
REGISTER	CHAR=3,	CODE=1;
%
%	THE NEXT CHARACTER IS FETCHED FROM THE INTERNAL STATEMENT
	BUFFER AND PLACED IN "CHAR".  THE CHARACTER CODE IS THEN
	FETCHED FROM THE APPROPRIATE CODE TABLE AND PLACED IN "CODE".
%

MAP STATEREF STATE;

% AREA FOR STATE CALL STACK %
OWN  STATESTACK[10],  
	STSTKPTR;	! CURRENT STACK POINTER

% INITIALIZE STACK POINTER %
STSTKPTR _ 0;

% RESTORE THE LAST CHARACTER TO THE REGISTERS %
CHAR _ .CHARTMP;
STATE _ .STATEE;	! PUT STATE IN A REGITER
SETCODE;
% SET LEXLINE TO THE LINENUMBER WHICH BEGINS THE LEXEME %
LEXLINE _ .LINELINE;

WHILE 1 DO
NEWSTATE:BEGIN
	LABEL  SMALCHAR;
	SMALCHAR:
	BEGIN
		WHILE 1 DO
		BEGIN %LOOP%
			LABEL BIGCHAR;
			BIGCHAR:
			BEGIN

				%ACTION _ STATE [ .CODE ] ;%
				NSCAN ( ACTION, STATE );

				WHILE 1 DO
				NEWACTION:
				BEGIN

					IF DBUGIT
					THEN
					BEGIN	% TRACE %
						REGISTER T1;
						IF ( T1_.BUGOUT AND 2 ) NEQ 0
						THEN TRACE(.STATE,.CHAR,.CODE,.ACTION)
					END;

				%%%BEGIN LEXICAL CASE%%%
				CASE .ACTION OF
				SET
					BEGIN ACT0 END;
					BEGIN ACT1 END;
					BEGIN ACT2 END;
					BEGIN ACT3 END;
					BEGIN ACT4 END;
					BEGIN ACT5 END;
					BEGIN ACT6 END;
					BEGIN ACT7 END;
					BEGIN ACT8 END;
					BEGIN ACT9 END;
					BEGIN ACT10 END;
					BEGIN ACT11 END;
					BEGIN ACT12 END;
					BEGIN ACT13 END;
					BEGIN ACT14 END;
					BEGIN ACT15 END;
					BEGIN ACT16 END;
					BEGIN ACT17 END;
					BEGIN ACT18 END;
					BEGIN ACT19 END;
					BEGIN ACT20 END;
					BEGIN ACT21 END;
					BEGIN ACT22 END;
					BEGIN ACT23 END;
					BEGIN ACT24 END;
					BEGIN ACT25 END;
					BEGIN ACT26 END;
					BEGIN ACT27 END;
					BEGIN ACT28 END;
					BEGIN ACT29 END;
					BEGIN ACT30 END;
					BEGIN ACT31 END;
					BEGIN ACT32 END;
					BEGIN ACT33 END;
					BEGIN ACT34 END;
					BEGIN ACT35 END;
					BEGIN ACT36 END;
					BEGIN ACT37 END;
					BEGIN ACT38 END;
					BEGIN ACT39 END;
					BEGIN ACT40 END;
					BEGIN ACT41 END;
					BEGIN ACT42 END;
					BEGIN ACT43 END;
					BEGIN ACT44 END;
					BEGIN ACT45 END;
					BEGIN ACT46 END;
					BEGIN ACT47 END;
					BEGIN ACT48 END;
					BEGIN ACT49 END;
					BEGIN ACT50 END;
					BEGIN ACT51 END;
					BEGIN ACT52 END;
					BEGIN ACT53 END;
					BEGIN ACT54 END;
					BEGIN ACT55 END;
					BEGIN ACT56 END;
					BEGIN ACT57 END;
					BEGIN ACT58 END;
					BEGIN ACT59 END;
					BEGIN ACT60 END;
					BEGIN ACT61 END;
					BEGIN ACT62 END;
					BEGIN ACT63 END;
					BEGIN ACT64 END;
					BEGIN ACT65 END;
					BEGIN ACT66 END;
					BEGIN ACT67 END;
					BEGIN ACT68 END;
					BEGIN ACT69 END;
					BEGIN ACT70 END;
					BEGIN ACT71 END;
					BEGIN ACT72 END;
					BEGIN ACT73 END;
					BEGIN ACT74 END;
					BEGIN ACT75 END;
					BEGIN ACT76 END;
					BEGIN ACT77 END;
					BEGIN ACT78 END;
					BEGIN ACT79 END;
					BEGIN ACT80 END;
					BEGIN ACT81 END;
					BEGIN ACT82 END;
					BEGIN ACT83 END;
					BEGIN ACT84 END;
					BEGIN ACT85 END;
					BEGIN ACT86 END;
					BEGIN ACT87 END;
					BEGIN ACT88 END;
					BEGIN ACT89 END;
					BEGIN ACT90 END;
					BEGIN ACT91 END;
					BEGIN ACT92 END;
					BEGIN ACT93 END;
					BEGIN ACT94 END;
					BEGIN ACT95 END;
					BEGIN ACT96 END;
					BEGIN ACT97 END;
					BEGIN ACT98 END;
					BEGIN ACT99 END;
					BEGIN ACT100 END;
					BEGIN ACT101 END;
					BEGIN ACT102 END;
					BEGIN ACT103 END;
					BEGIN ACT104 END;
					BEGIN ACT105 END;
					BEGIN ACT106 END;
					BEGIN ACT107 END;
					BEGIN ACT108 END;
					BEGIN ACT109 END;
					BEGIN ACT110 END;
					BEGIN ACT111 END;
					BEGIN ACT112 END;
					BEGIN ACT113 END;
					BEGIN ACT114 END;
					BEGIN ACT115 END;
					BEGIN ACT116 END;
					BEGIN ACT117 END;
					BEGIN ACT118 END;
					BEGIN ACT119 END;
					BEGIN ACT120 END;
					BEGIN ACT121 END;
					BEGIN ACT122 END;
					BEGIN ACT123 END;
					BEGIN ACT124 END;
					BEGIN ACT125 END;
					BEGIN ACT126 END;
					BEGIN ACT127 END;
					BEGIN ACT128 END;
					BEGIN ACT129 END;
					BEGIN ACT130 END;
					BEGIN ACT131 END;
					BEGIN ACT132 END;
					BEGIN ACT133 END;
![675] ADD A NEW ACTION IN THE BODY OF LEXICA ITSELF - IT
![675] DISTINGUISHES BETWEEN AN INTERNAL ERROR AND A SIMPLE RUBOUT
![675] IN THE SOURCE PROGRAM
%[675]%					BEGIN ACT134 END;
![742] ADD ACTIONS TO SCAN STOP/PAUSE CONSTANTS
%[742]%					BEGIN ACT135 END;
%[742]%					BEGIN ACT136 END;
%[742]%					BEGIN ACT137 END;
				TES;
				%%%END LEXICAL CASE%%%

				END %NEWACTION%
			END; %BIGCHAR%

			% GET NEXT CHARACTER AND CLASIFY FOR BIG STATE%
			IF .CHARPOS EQL 0	% CHARACTER POSITION 72 %
			THEN (  LEAVE SMALCHAR );   % ENTER REMARK PROCESSING STATE %
			CHARPOS _ .CHARPOS - 1;
			ISCAN ( CHAR, CURPTR );
			CODE _ BIGCODE;

		END %LOOP%
	END; %SMALCHAR%

	% GET NEXT CHARACTER AND CLASIFY FOR SMALL STATE %
	IF .CHARPOS EQL 0	% CHARACTER POSITION 72 %
	THEN IF .STATE  NEQ  STREMARK
		THEN ( ENTREMARK );   % ENTER REMARK PROCESSING STATE %
	CHARPOS _ .CHARPOS - 1   ;
	ISCAN ( CHAR, CURPTR );
	CODE _ SMALCODE;

END %NEWSTATE%

END;   % ROUTINE LEXICAL %

END   %LEXICAL%
ELUDOM