! bliss.req - common definitions for all source files.

! fundamental constants

Literal
	WRDSZ		= 16,		! BITS/WORD FOR COMPILED CODE
	BYTSZ		= 8;		! BITS/BYTE FOR COMPILED CODE

! tunable constants

Literal
	DEFAULTSSTK	= %o'400',	! DEFAULT NO. OF WORDS IN RUNTIME STACK
	HTSIZE		= 125,		! LENGTH OF HASH TABLE
	MAXSTRING	= 135,		! MAXIMUM STRING SIZE
	DTSIZE		= 128;		! SIZE OF DELIMITER TABLE

! miscellaneous constants

Literal
	TRUE		= 1,
	FALSE		= 0;

! names for common types

Macro
	Boolean		= Quad %,
	Integer		= Quad %;

! common macros

Macro
	_POS(P,E,S)		= (P) %,
	_LEN(P,S,E)		= (S) %,
	AZ[s]			= Uplit Byte ( %Asciz s ) %,
	MOVECORE(SRC,DST,LENTH)	= ch$move((LENTH)*8,SRC,DST) %,
	CLEARCORE(BASE,LENTH)	= ch$fill(0,(LENTH)*8,BASE) %,
	SWAP(A,B)		= (Local n; n = .a; a = .b; b = .n) %,
	ONEOF(NUM)[] 		= (((0 Or BITMASK(%REMAINING))^(-(NUM)) And 1) Neq 0) %,
	BITMASK[N]		= 1^(N) %,
	FIELDK(PS,N,O)=
				  Literal
					N=O,
					%Name(FLD_Q_,N) = PS;
				  Macro
					%Name(FLD_K_,N)=N^PS %Quote % %;

! i/o constants
!
! notes:
!	these device codes are really bit masks.

Literal
	TTYDEV		= 1,			! TTY
	LSTDEV		= 2,			! LISTING DEVICE
	ERRDEV		= LSTDEV+TTYDEV;	! ERROR DEVICE

! lexeme type codes
!
! notes:
!	these codes are kept in the <lex_type> field of lexemes.

Literal
	T_LITERAL	= 1,		! LITERAL LEXEME
	T_SYMBOL	= 2,		! BOUND VARIABLE (POINTS TO A SYMBOL TABLE ENTRY).
	T_NODE		= 3,		! GRAPH TABLE LEXEME.
	T_ERROR		= 4,		! ERROR LEXEME.
	T_STRING_L	= 5,		! LONG STRING LEXEME
	T_STRING_S	= 6,		! SHORT STRING LEXEME
	T_STRUCT_ARG	= 7,		! STRUCTURE ACTUAL (IN STREAMS ONLY)
	T_NAME		= 8,		! UNBOUND VARIABLE (POINTS TO A NAME TABLE ENTRY).
	T_LEX_CONV	= 9,		! SPECIAL FUNCTIONS (CONVERSION)
	T_MACRO		= 10,		! MACRO NAME (POINTS TO A SYMBOL TABLE ENTRY).
	T_LEX_EXPAND	= 11,		! SPECIAL FUNCTIONS (EXPANSION)
	T_MACRO_ARG	= 12,		! MACRO ACTUAL (IN STREAMS ONLY)
	T_SELECT	= 13,		! OTHERWISE OR ALWAYS IN SELECT
	T_TEMP		= 14,		! TEMP NAME LEXEME
	T_WANT_SYM	= 15,		! SYMBOL DECLARED DURING STRUCTURE EXPANSION
	T_ALPHA		= 31,
	T_RHO		= 30,
	T_CHI		= 29,
	T_OMEGA		= 28,
	LOWFLOLSTTYPE	= 28;		! IF A FLOLSTTYPE IS ADDED, CHANGE!!!

! special lexemes
!
! notes:
!	these are macros because they produce values with more
!	than 32 bits in them

Macro
	LEXALWAYS	= T_SELECT ^ _POS(lex_type)+1 %,
	LEXOTHERWISE	= T_SELECT ^ _POS(lex_type)   %;

! quote levels for RUND

Literal
	QL_LEXEME	= T_SYMBOL,
	QL_STRING_L	= T_STRING_L,
	QL_STRING_S	= T_STRING_S,
	QL_NAME		= T_NAME,
	QL_LEX_CONVERT	= T_LEX_CONV,
	QL_MACRO	= T_MACRO;

! bits in the macro subtype.

Macro
	MAC_V_RECURSIVE	= 0,1 %,	! [] specified
	MAC_V_ITERATIVE	= 1,1 %,	! [X,...] specified
	MAC_V_FIXED	= 2,1 %,	! (X,...) specified
	MAC_V_STRUCTURE	= 3,1 %,	! structure type - allows comon "POPORIT"
	MAC_V_ARGUMENTS	= 0,3 %;	! composite of first three above

! special bit combinations in the macro subtype

Literal
	MAC_SIMPLE	= 0,
	MAC_PASSED	= 1,
	MAC_ITERATIVE	= 2,
	MAC_FIXED	= 4,
	MAC_RECURSIVE	= 4+1,
	MAC_STRUCTURE	= 8;

! panic stop codes
!
! notes:
!	maybe a mask of terminator delimiters should be used
!	which would be OR'ed in with the current mask of
!	delimiters.  this might avoid skipping over delimiters
!	wanted at higher levels.

Literal
	PSPARSEM	= 1,
	PSENDSEM	= 2,
	PSOF		= 3,
	PSTES		= 4,
	PSTESSEM	= 5,
	PSTESN		= 6,
	PSTESNCOLSEM	= 7,
	PSELBCOLSEM	= 8,
	PSCOMSEM	= 9,
	PSCOMSQBC	= 10,
	PSPARCOM	= 11,
	PSPAR		= 12,
	PSDO		= 13,
	PSWU		= 14,
	PSTHEN		= 15,
	PSAT		= 16,
	PSLENGTH	= 17,
	PSSEM		= 18,
	PSPOI		= 19,
	PSEND		= 20;

! delimiter class codes and delimiter flag bits
!
! notes:
!	delimiters have a class field which indicates
!	whether the delimiter is an operator, open bracket,
!	close bracket, or a declarator.
!
!	the delimiter class is used in determining operator precedence.
!
!	SE	operator/keyword is valid after an operator.
!
!	AE	operator/keyword is valid at the start of an expression
!		(but invalid after a CASE or SELECT statement).
!
!	MT	binary operator (e.g. wants a LHS operand)
!
!	R2L	operator precedence is right to left

Literal
	SE		= 8,	! HSE
	MT		= 4,	! HMT
	AE		= 2,	! HAE
	R2L		= 1,	! HFORCER2L
	OBR		= 0,
	OPENBRAC	= 0,
	OP		= 1,
	CBR		= 2,
	CLOBRAC		= 2,
	DCL		= 3,
	DCLRTR		= 3,
	LO_CLASS_TYPE	= 0,
	HI_CLASS_TYPE	= 3;

! declaration routine indices.
!
! notes:
!	these codes are embedded in their associated
!	lexemes and are used as an index into a jump
!	table.

Literal
	DCLBYTE		= 1,
	DCLOWN		= 2,
	DCLGLO		= 3,
	DCLEXT		= 4,
	DCLROU		= 5,
	DCLSTR		= 6,
	DCLMAP		= 7,
	DCLFOR		= 8,
	DCLBIN		= 9,
	DCLMAC		= 10,
	DCLUND		= 11,
	DCLLAB		= 12,
	DCLWORD		= 13,
	DCLSWI		= 14,
	DCLLOC		= 15,
	DCLREG		= 16,
	DCLENABLE	= 17,
	DCLREQU		= 18,
	DCLCSECT	= 19,
	DCLSLOCAL	= 20,
	DCLLNKG		= 21,
	DCLPSECT	= 22;

! symbol type codes
!
! notes:
!	the symbol type is stored in the [gt_type] field.
!
!	nodes and tempnames are used in common situations because
!	they share some common fields (e.g. [gt_reg], [gt_mode], etc)
!	and have their own symbol type codes but are really not symbols.
!
!	reserved words are placed in the symbol table with a type
!	code of S_DELIMITER.

Literal
	S_DELIMITER	= 0,
	S_NODE		= 2,
	S_TEMPNAME	= 3,
	S_UNDECLARE	= 5,

LOWVARTYPE		= 6,		! variable types

	S_LOCAL	  	= 6,
	S_OWN	  	= 7,
	S_REGISTER  	= 8,
	S_FORMAL  	= 9,
	S_EXTERNAL 	= 10,
	S_GLOBAL  	= 11,

HIGHVARTYPE		= 11,

	S_ROUTINE  	= 15,
	S_GBL_ROUTINE 	= 16,
	S_FORWARD  	= 17,

HIGHADDTYPE		= 17,		! symbols which have an address

	S_BIND	  	= 18,

HIGHEXPTYPE		= 18,		! symbols usable in an expressions

	S_LABEL	  	= 19,
	S_LINKAGE  	= 20,
	S_MACRO	  	= 21,
	S_SPECIAL  	= 22,
	S_MACRO_ARG	= 23,
	S_LEX_CONV	= 24,
	S_LEX_EXPAND  	= 25,
	S_STRUCT_ARG	= 26,
	S_STRUCTURE	= 27;

! operator codes
!
! notes:
!	these codes are embedded within their associated delimiter
!	lexemes.
!
!	in nodes, these codes are stored in the [gt_code] field.
!
!	the order of this table is assumed by many jump tables.
!	also, the order of the relational operators is assumed
!	in many places.

Literal
	RELOPBASE	= 11,
	MAXDELIMITER	= 64,
	MAXOPERATOR	= 32;

Literal
	OP_ADD		= 0,
	OP_SWAB		= 1,
	OP_DIV		= 2,
	OP_DOT		= 3,
	OP_SUB		= 4,
	OP_MOD		= 5,
	OP_MUL		= 6,
	OP_NEG		= 7,
	OP_PLUS		= 8,
	OP_LOAD_NODE	= 8,	! same as OP_PLUS
	OP_SHIFT	= 9,
	OP_BIT		= 10,
	OP_GTR		= 11,
	OP_LEQ		= 12,
	OP_LSS		= 13,
	OP_GEQ		= 14,
	OP_EQL		= 15,
	OP_NEQ		= 16,
	OP_NOT		= 17,
	OP_EQV		= 18,
	OP_AND		= 19,
	OP_OR		= 20,
	OP_XOR		= 21,
	OP_GTRU		= 22,
	OP_LEQU		= 23,
	OP_LSSU		= 24,
	OP_GEQU		= 25,
	OP_EQLU		= 26,
	OP_NEQU		= 27,
	OP_ROT		= 28,
	OP_MAX		= 29,
	OP_MIN		= 30,
	OP_CARRY	= 31,
	OP_OVERFLOW	= 32,
	OP_STORE	= MAXOPERATOR+1,
	OP_ERROR	= MAXOPERATOR+2,
	OP_CASE		= MAXOPERATOR+3,
	OP_FPARM	= MAXOPERATOR+4,
	OP_FSTORE	= MAXOPERATOR+5,
	OP_WHILE	= MAXOPERATOR+6,
	OP_UNTIL	= MAXOPERATOR+7,
	OP_ROUTINE	= MAXOPERATOR+8,
	OP_COMPOUND	= MAXOPERATOR+9,
	OP_INCR		= MAXOPERATOR+10,
	OP_DECR		= MAXOPERATOR+11,
	OP_IF		= MAXOPERATOR+12,
	OP_DO_WHILE	= MAXOPERATOR+13,
	OP_DO_UNTIL	= MAXOPERATOR+14,
	OP_CREATE	= MAXOPERATOR+15,
	OP_EXCHANGE	= MAXOPERATOR+16,
	OP_SELECT	= MAXOPERATOR+17,
	OP_EXITLOOP	= MAXOPERATOR+18,
	OP_LABEL	= MAXOPERATOR+19,
	OP_MODULE	= MAXOPERATOR+20,
	OP_PLIT		= MAXOPERATOR+21,
	OP_CALL		= MAXOPERATOR+22,
	OP_POINTER	= MAXOPERATOR+23,
	OP_BRACKET	= MAXOPERATOR+24,
	OP_EXIT		= MAXOPERATOR+25,
	OP_RETURN	= MAXOPERATOR+26,
	OP_NULL		= MAXOPERATOR+27,
	OP_FAKE_CSE	= MAXOPERATOR+27,	! same as OP_NULL
	OP_INLINE	= MAXOPERATOR+28,
	OP_ENABLE	= MAXOPERATOR+29,
	OP_SIGNAL	= MAXOPERATOR+30,
	OP_MOVP		= MAXOPERATOR+31;

! PDP-11 addressing modes.
!
! notes:
!	these modes just happen to match the actual
!	hardware modes on the PDP-11.

Literal
	DEFERRED	= 1,

	GENREG		= 0,
	AUTOINCR	= 2,
	AUTODECR	= 4,
	INDEXED		= 6,

	IMMEDIATE	= 2,
	ABSOLUTE	= 3,
	RELATIVE	= 6;

! special PDP-11 registers.

Literal
	VR		= 0,
	SP		= 6,
	PC		= 7;

! instruction opcodes
!
! notes:
!	the order of these codes is assumed
!	in several tables.
!
!	the order relationship of the codes PROR to PASLB
!	is assumed.
!
!	the order of the branch codes is assumed in places.
!	the order relationship of branches and their
!	reverse branch is assumed.

Literal
	PINLINE	= 0,
	PMOV	= 1, PMOVB	= 2,
	PCMP	= 3, PCMPB	= 4,
	PBIT	= 5, PBITB	= 6,
	PBIC	= 7, PBICB	= 8,
	PBIS	= 9, PBISB	= 10,
	PADD	= 11,
	PSUB	= 12,
	PCLR	= 13, PCLRB	= 14,
	PCOM	= 15, PCOMB	= 16,
	PINC	= 17, PINCB	= 18,
	PDEC	= 19, PDECB	= 20,
	PNEG	= 21, PNEGB	= 22,
	PADC	= 23, PADCB	= 24,
	PSBC	= 25, PSBCB	= 26,
	PTST	= 27, PTSTB	= 28,
	PROR	= 29, PRORB	= 30,
	PROL	= 31, PROLB	= 32,
	PASR	= 33, PASRB	= 34,
	PASL	= 35, PASLB	= 36,
	PJMP	= 37,
	PSWAB	= 38,
	PJSR	= 39,
	PRTS	= 40,
	PHALT	= 41,
	PWAIT	= 42,
	PRTI	= 43,
	PIOT	= 44,
	PRESETX	= 45,		! reserved word w/o the 'X'!
	PEMT	= 46,
	PTRAP	= 47,

	PBR	= 48, PNBR	= PBR   Or 1,
	PBNE	= 50, PBEQ	= PBNE  Or 1,
	PBGE	= 52, PBLT	= PBGE  Or 1,
	PBLE	= 54, PBGT	= PBLE  Or 1,
	PBPL	= 56, PBMI	= PBPL  Or 1,
	PBHI	= 58, PBLOS	= PBHI  Or 1,
	PBVC	= 60, PBVS	= PBVC  Or 1,
	PBHIS	= 62, PBLO	= PBHIS Or 1,

	PNOP		= 64,
	PCLC		= 65,
	PCLVC		= 66,
	PWORD		= 67,
	PCASE		= 68,
	PMFPI		= 69,
	PMFPD		= 70,
	PMTPI		= 71,
	PMTPD		= 72,
	INFLOOPOP	= 73,
	SETEQLOP	= 74;

! cell field codes.

Literal
	UNUSED			= 0,

! cell types

	CELL_CODE		= 1,	! contains an instruction
	CELL_LABEL		= 2,	! contains a label
	CELL_REF		= 3,	! contains a reference to a label
	LO_CELL_TYPE		= 1,
	HI_CELL_TYPE		= 3,

! label cell types

	LAB_ROUTINE		= 0,	! routine entry point
	LAB_USER		= 1,	! user defined label
	LAB_COMP		= 2,	! compiler generated label
	LO_LAB_TYPE		= 0,
	HI_LAB_TYPE		= 2,

! code cell types

	INST_NORMAL		= 0,
	INST_CASE_PARAM		= 1,
	INST_INLINE		= 2,	! INLINE code
	INST_UNCOND_JUMP	= 3,	! unconditional branch
	INST_ADD_IMMED		= 4,	! ADD(SUB) #k,Rn
	INST_COND_JUMP		= 5,	! conditional branch
	LO_INST_TYPE		= 0,
	HI_INST_TYPE		= 5,

! operand name type

	NAME_NORMAL		= 0,
	NAME_LABEL		= 1,
	NAME_ERROR		= 2,
	NAME_FORMAL		= 3,

! address reference types
!
! notes:
!	a value of zero (UNUSED) indicates the operand
!	is not used (e.g. the second operand field for the INC
!	instruction).
!
!	the ordering of these types is important because
!	of assumption in MAY_REFER in FINAL.

	ADDR_IMMED		= 1,
	ADDR_REG		= 2,
	ADDR_INDIRECT		= 3,
	ADDR_MEMORY		= 4,
	LO_ADDR_TYPE		= 1,
	HI_ADDR_TYPE		= 4,

! operand types

	OPND_NORMAL		= 1,
	OPND_NAME		= 2,
	OPND_ERROR		= 3,
	OPND_INLINE		= 4,
	OPND_TRAP		= 6,
	OPND_LABEL		= 7,
	LO_OPND_TYPE		= 1,
	HI_OPND_TYPE		= 7,

!CONTENTS OF CELLSIZEF

	SZ_CELL_CODE		= 9,
	SZ_CELL_LABEL		= 5,
	SZ_CELL_REF		= 5,

! operand types

	OPTYPE_NOP		= 0,
	OPTYPE_ONE		= 1,
	OPTYPE_TWO		= 2,
	OPTYPE_BR		= 3,
	OPTYPE_JSR		= 4,
	OPTYPE_RTS		= 5,
	OPTYPE_TRAP		= 6,
	OPTYPE_WORD		= 7,
	OPTYPE_CASE		= 8,
	LO_OPTYPE		= 0,
	HI_OPTYPE		= 8;

! linkage type codes

Literal
	LNK_SPECIAL	= 0,		! ANY SPECIAL FUNCTIONS (HALT,WAIT, ETC.)
	LNK_BLISS	= 1,		! BLISS
	LNK_EMT		= 2,		! EMT
	LNK_FORTRAN	= 3,		! FORTRAN
	LNK_INTERRUPT	= 4,		! INTERRUPT
	LNK_TRAP	= 5,		! TRAP
	LNK_IOT		= 6,		! IOT LINKAGE
	LNK_HYDRA	= 7,
	LNK_IHYDRA	= 8,
	LO_LNK_TYPE	= 0,
	HI_LNK_TYPE	= 8;

! linkage parameter types

Literal
	PARM_STACK	= 0,		! STACK TYPE PARM
	PARM_REGISTER	= 1,		! REGISTER PARM
	PARM_LITERAL	= 2,		! LITERAL MEMORY PARM
	PARM_MEMORY	= 3,		! NAMED MEMORY PAR,
	LO_PARM_TYPE	= 0,
	HI_PARM_TYPE	= 3;

! PLIT structure codes
!
! note:
!	there really is no difference between
!	PL_LEXEME and PL_STRING.  strings are stored as
!	a sequence of literal lexemes.

Literal
	PL_LEXEME	= 0,		! CELL CONTAINS A LEXEME
	PL_DUPLICATOR	= 1,		! CELL IS A DUPLICATION HEADER
	PL_STRING	= 0;		! CELL IS A LONG STRING HEADER

! structure definitions.
!
! notes:
!	all structures used are actually either BLOCK or VECTOR.
!	because ST, NT, and GT all use the high 32 bits of their
!	pointers to hold information, an equivalent to the
!	BLOCK structure is used which masks out those high bits.
!	the compiler does not allow for 32 bit literals (they
!	would be sign extended anyway) so a 31 bit mask is used.

Structure
	ST[I,P,S,E]		= ((ST And %x'7fffffff')+I*8)<P,S,E>,
	NT[I,P,S,E]		= ((NT And %x'7fffffff')+I*8)<P,S,E>,
	GT[I,P,S,E]		= ((GT And %x'7fffffff')+I*8)<P,S,E>;

Macro
	ITEM			= Block[2,Quad] %,
	ADRVARSTR		= Block[2,Quad] %,
	CELL			= Block[0,Quad] %,
	PLSTSTK			= Block[1,Quad] %,
	LSTHDR			= Block[1,Quad] %,
	TNREPR			= Block[4,Quad] %,
	TNLSTHDR		= Block[1,Quad] %,
	LVL			= Block[1,Quad] %,
	FLOLSTPTR		= Block[2,Quad] %;

! sizes of the various structures.
!
! note:	the item sizes depend on the arguments to MAKITEM

Literal
	SZ_TEMPNAME		= 6,
	SZ_NAME			= 4,
	SZ_STELIST		= 2,
	SZ_ITEM			= 2,
	SZ_TNREP		= 3,
	SZ_FLOLIST		= 2,
	SZ_LSTHDR		= 2,
	SZ_PLSTSTK		= 2,
	SZ_PLIT			= 4,
	SZ_LVL			= 1,
	SZ_STREAM		= 2,
	SZ_RHO_ITEM		= 3,
	SZ_CHI_ITEM		= 2,
	SZ_PSI_ITEM		= 2,
	SZ_FLSTK_ITEM		= 3,
	SZ_NODE			= 8;


! delimiter lexeme fields
!
! notes:
!	SOPERATOR uses a combination of class and priority to determine
!	whether one operator has a higher precedence than another.
!	this is why HCLASS and HPRIORITY overlap.
!
!	lex_delim holds the delimiter index in a window structure.
!
!	the fields HSE, HMT, HAE, and HFORCER2L correspond to the
!	literal masks SE, MT, AE, and R2L respectively.

Macro
	lex_class	= 28, 4,0 %,
	lex_priority	= 24, 8,0 %,	! overlap - AARGH!
	HSE		= 19, 1,0 %,
	HMT		= 18, 1,0 %,
	HAE		= 17, 1,0 %,
	HFORCER2L	= 16, 1,0 %,
	lex_attr	= 16, 4,0 %,	! HSE+HMT+HAE+HFORCER2L
	lex_delim	= 40, 8,0 %,	! DELIM TABLE INDEX WITH WINDOW STRUCT
	lex_reswd	= 48, 1,0 %,	! TRUE IF DELIMITER WAS A RESERVED WORD
	lex_unique	=  8, 8,0 %,
	lex_index	=  0, 8,0 %;	! ACTUAL INDEX

! symbol lexeme fields
!
! notes:
!	lex_part = lex_addr + lex_type
!
!	the 'ss_' fields are the substate flags produced by DELAY.
!
!	DELAY uses bits 40-63 for delay request information.
!	these bits are defined locally in DELAY.
!
!	lex_abc is only used for queue-type symbols

Macro
	lex_addr	=  0,32,1 %,	! ADDRESS PORTION OF LEXEME
	lex_type	= 32, 8,0 %,	! LEXEME TYPE FIELD
	lex_part	=  0,40,0 %,	! ADDRF + LTYPF
	lex_abc		= 40,16,0 %,	! atomic block count
	lex_value	=  0,16,1 %,	! literal value

!	these fields are stored in the high bits of symbol lexemes.
!	they are duplicated in the gt_state word for nodes and
!	correspond to the 'rw_' fields.

	ss_real_flow	= 51, 2,0 %,		! REAL/FLOW SUBSTATES
	  ss_real	= 51, 1,0 %,		! REAL RESULT BIT
	  ss_flow	= 52, 1,0 %,		! FLOW RESULT BIT
	ss_literal	= 50, 1,0 %,		! NON-LITERAL(=0)/LITERAL(=1)
	ss_ptr_state	= 44, 3,0 %,		! POINTER SUBSTATE CASES
	ss_negated	= 43, 1,0 %,		! RESULT NEGATIVE
	ss_complemented	= 42, 1,0 %,		! RESULT COMPLEMENTED
	ss_destroyable	= 41, 1,0 %,		! INVOLVES DESTROYABLE TEMPORARY
	ss_immediate	= 40, 1,0 %,		! IMMEDIATE ADDRESS (ON SYMBOL OR LIT)
	RWORDF		= 40,13,0 %;		! THE WHOLE RESULT WORD BITS FIELD

Literal
	RESULTPOS	= 40;

! macro for building a symbol/delimiter pair to be stored in a stream.

Macro
	FORMWINDOW(S,D)		= ((S) Or D^_POS(lex_delim)) %;

! macros for building lexemes

Macro
	LEXTYPE(TYPE)		= ((TYPE)^_POS(lex_type)) %,
	LEXOUT(TYPE,ADDRESS)	= (((ADDRESS) And %x'7fffffff')+LEXTYPE(TYPE)) %,
	FASTLEXOUT(T,A)		= (A Or LEXTYPE(T)) %,
	LITLEXEME(X)		= (((X) And %x'ffff')+LEXTYPE(T_LITERAL)) %;

! delimiter lexeme codes

Macro
	DEFLEX(CLASS,PRIO,FLGS,UN,IND)=
			(CLASS)	^ _POS(lex_class)	Or
			(PRIO)	^ _POS(lex_priority)	Or
			(FLGS)	^ _POS(lex_attr)	Or
			(UN)	^ _POS(lex_unique)	Or
			(IND)	^ _POS(lex_index) %;

!
! notes:
!	MT is a flag which indicates whether SYM is allowed
!	to be empty at a given point.  it also indicates
!	unary or binary in the case of operators.
!
!	AE indicates whether AEFOLLOWS() in SYNTAX should be TRUE.
!	similarly for SE and SEFOLLOWS().

Literal

! SPECIAL LEXEMES

	TK_EMPTY	= 0,
	TK_WHILE2	= DEFLEX(CBR,0,0,          1,OP_DO_WHILE),
	TK_UNTIL2	= DEFLEX(CBR,0,0,          0,OP_DO_UNTIL),
	TK_COMPOUND	= DEFLEX(OBR,1,0,          0,OP_COMPOUND),
	TK_COMPOUND2	= DEFLEX(OBR,1,0,          1,OP_COMPOUND),
	TK_NULL		= DEFLEX(0,  0,0,          0,OP_NULL),
	TK_FPARM	= DEFLEX(OBR,0,0,          0,OP_FPARM),
	TK_FSTORE	= DEFLEX(OBR,0,0,          0,OP_FSTORE),
	TK_SWAB		= DEFLEX(OP, 0,0,          0,OP_SWAB),
	TK_CARRY	= DEFLEX(OP, 0,0,          0,OP_CARRY),
	TK_OVERFLOW	= DEFLEX(OP, 0,0,          0,OP_OVERFLOW),
	TK_MOVP		= DEFLEX(OP, 0,0,          0,OP_MOVP),

! OPEN BRACKETS

	TK_BEGIN	= DEFLEX(OBR,0,SE+AE,      0,OP_COMPOUND),
	TK_LPAREN	= DEFLEX(OBR,0,SE+AE,      1,OP_COMPOUND),
	TK_CASE		= DEFLEX(OBR,0,   AE,      0,OP_CASE),
	TK_CREATE	= DEFLEX(OBR,0,   AE,      0,OP_CREATE),
	TK_DECR		= DEFLEX(OBR,0,   AE,      0,OP_DECR),
	TK_DO		= DEFLEX(OBR,0,   AE,      2,OP_DO_WHILE),
	TK_EXCHANGE	= DEFLEX(OBR,0,SE+AE,      0,OP_EXCHANGE),
	TK_EXITLOOP	= DEFLEX(OBR,0,   AE,      1,OP_EXITLOOP),
	TK_INLINE	= DEFLEX(OBR,0,SE+AE,      0,OP_INLINE),
	TK_INLINECOM	= DEFLEX(OBR,0,SE+AE,      1,OP_INLINE),
	TK_LABUSE	= DEFLEX(OBR,0,0,          0,OP_LABEL),
	TK_LEAVE	= DEFLEX(OBR,0,   AE,      0,OP_EXIT),
	TK_IF		= DEFLEX(OBR,0,   AE,      0,OP_IF),
	TK_INCR		= DEFLEX(OBR,0,   AE,      0,OP_INCR),
	TK_MODULE	= DEFLEX(OBR,0,SE+AE,      0,OP_MODULE),
	TK_CALL		= DEFLEX(OBR,0,SE+MT+AE,   0,OP_CALL),
	TK_PLIT		= DEFLEX(OBR,0,SE+AE,      0,OP_PLIT),
	TK_LANGLE	= DEFLEX(OBR,0,SE+MT+AE,   0,OP_POINTER),
	TK_RETURN	= DEFLEX(OBR,0,   AE,      0,OP_RETURN),
	TK_SELECT	= DEFLEX(OBR,0,SE+AE,      0,OP_SELECT),	! why SE?
	TK_SIGNAL	= DEFLEX(OBR,0,   AE,      0,OP_SIGNAL),
	TK_LBRACKET	= DEFLEX(OBR,0,SE+MT+AE,   0,OP_BRACKET),
	TK_UNTIL	= DEFLEX(OBR,0,   AE,      0,OP_UNTIL),
	TK_UPLIT	= DEFLEX(OBR,0,SE+AE,      1,OP_PLIT),
	TK_WHILE	= DEFLEX(OBR,0,   AE,      1,OP_WHILE),

! STANDARD ARITH OPERATORS

	TK_ADD		= DEFLEX(OP, 6,SE+MT+AE,    0,OP_ADD),
	TK_AT		= DEFLEX(OP, 0,SE+AE+R2L,   1,OP_DOT),
	TK_DIV		= DEFLEX(OP, 4,SE+MT+AE,    1,OP_DIV),
	TK_DOT		= DEFLEX(OP, 0,SE+AE+R2L,   0,OP_DOT),
	TK_MINUS	= DEFLEX(OP, 6,SE+MT+AE,    1,OP_SUB),
	TK_MOD		= DEFLEX(OP, 4,SE+MT+AE,    0,OP_MOD),
	TK_MUL		= DEFLEX(OP, 4,SE+MT+AE,    0,OP_MUL),
	TK_NEG		= DEFLEX(OP, 2,SE+AE+R2L,   0,OP_NEG),
	TK_PLUS		= DEFLEX(OP, 2,SE+AE+R2L,   0,OP_PLUS),
	TK_ROT		= DEFLEX(OP, 3,SE+MT+AE,    0,OP_ROT),
	TK_SHIFT	= DEFLEX(OP, 3,SE+MT+AE,    0,OP_SHIFT),
	TK_MAX		= DEFLEX(OP, 7,SE+MT+AE,    0,OP_MAX),
	TK_MIN		= DEFLEX(OP, 7,SE+MT+AE,    0,OP_MIN),
	TK_STORE	= DEFLEX(OP,15,SE+MT+AE+R2L,0,OP_STORE),

! BOOLEAN OPERATORS

	TK_AND		= DEFLEX(OP,10,SE+MT+AE,    0,OP_AND),
	TK_EQL		= DEFLEX(OP, 8,SE+MT+AE,    0,OP_EQL),
	TK_EQLU		= DEFLEX(OP, 8,SE+MT+AE,    0,OP_EQLU),
	TK_EQV		= DEFLEX(OP,14,SE+MT+AE,    0,OP_EQV),
	TK_GEQ		= DEFLEX(OP, 8,SE+MT+AE,    0,OP_GEQ),
	TK_GEQU		= DEFLEX(OP, 8,SE+MT+AE,    0,OP_GEQU),
	TK_GTR		= DEFLEX(OP, 8,SE+MT+AE,    0,OP_GTR),
	TK_GTRU		= DEFLEX(OP, 8,SE+MT+AE,    0,OP_GTRU),
	TK_LEQ		= DEFLEX(OP, 8,SE+MT+AE,    0,OP_LEQ),
	TK_LEQU		= DEFLEX(OP, 8,SE+MT+AE,    0,OP_LEQU),
	TK_LSS		= DEFLEX(OP, 8,SE+MT+AE,    0,OP_LSS),
	TK_LSSU		= DEFLEX(OP, 8,SE+MT+AE,    0,OP_LSSU),
	TK_NEQ		= DEFLEX(OP, 8,SE+MT+AE,    0,OP_NEQ),
	TK_NEQU		= DEFLEX(OP, 8,SE+MT+AE,    0,OP_NEQU),
	TK_NOT		= DEFLEX(OP, 9,SE+AE+R2L,   0,OP_NOT),
	TK_OR		= DEFLEX(OP,12,SE+MT+AE,    0,OP_OR),
	TK_XOR		= DEFLEX(OP,14,SE+MT+AE,    0,OP_XOR),

! CLOSE BRACKETS

! note:  TK_END through TK_RBRACKET must be in order!
!	HRUND assumes this

	TK_END		= DEFLEX(CBR,0,0,0, 0),
	TK_RPAREN	= DEFLEX(CBR,0,0,0, 1),
	TK_RANGLE	= DEFLEX(CBR,0,0,0, 2),
	TK_RBRACKET	= DEFLEX(CBR,0,0,0, 3),
	TK_ALWAYS	= DEFLEX(CBR,0,0,0, 4),
	TK_BY		= DEFLEX(CBR,0,0,0, 5),
	TK_COLON	= DEFLEX(CBR,0,0,0, 6),
	TK_COMMA	= DEFLEX(CBR,0,0,0, 7),
	TK_CRAT		= DEFLEX(CBR,0,0,0, 8),
	TK_DO2		= DEFLEX(CBR,0,0,0, 9),
	TK_ELBANE	= DEFLEX(CBR,0,0,0,10),
	TK_ELSE		= DEFLEX(CBR,0,0,0,11),
	TK_ELUDOM	= DEFLEX(CBR,0,0,0,12),
	TK_EQUAL	= TK_STORE,
	TK_FROM		= DEFLEX(CBR,0,0,0,13),
	TK_LENGTH	= DEFLEX(CBR,0,0,0,14),
	TK_NSET		= DEFLEX(CBR,0,0,0,15),
	TK_OF		= DEFLEX(CBR,0,0,0,16),
	TK_OTHERWISE	= DEFLEX(CBR,0,0,0,17),
	TK_SEMICOLON	= DEFLEX(CBR,0,0,0,18),
	TK_SET		= DEFLEX(CBR,0,0,0,19),
	TK_TES		= DEFLEX(CBR,0,0,0,20),
	TK_TESN		= DEFLEX(CBR,0,0,0,21),
	TK_THEN		= DEFLEX(CBR,0,0,0,22),
	TK_TO		= DEFLEX(CBR,0,0,0,23),
	TK_WITH		= DEFLEX(CBR,0,0,0,24),

! DECLARATORS

	TK_BIND		= DEFLEX(DCL,0,0,0,DCLBIN),
	TK_ENABLE	= DEFLEX(DCL,0,0,0,DCLENABLE),
	TK_EXTERNAL	= DEFLEX(DCL,0,0,0,DCLEXT),
	TK_FORWARD	= DEFLEX(DCL,0,0,0,DCLFOR),
	TK_GLOBAL	= DEFLEX(DCL,0,0,0,DCLGLO),
	TK_LABEL	= DEFLEX(DCL,0,0,0,DCLLAB),
	TK_LOCAL	= DEFLEX(DCL,0,0,0,DCLLOC),
	TK_MACRO	= DEFLEX(DCL,0,0,0,DCLMAC),
	TK_MAP		= DEFLEX(DCL,0,0,0,DCLMAP),
	TK_OWN		= DEFLEX(DCL,0,0,0,DCLOWN),
	TK_REGISTER	= DEFLEX(DCL,0,0,0,DCLREG),
	TK_ROUTINE	= DEFLEX(DCL,0,0,0,DCLROU),
	TK_STRUCTURE	= DEFLEX(DCL,0,0,0,DCLSTR),
	TK_SWITCHES	= DEFLEX(DCL,0,0,0,DCLSWI),
	TK_UNDECLARE	= DEFLEX(DCL,0,0,0,DCLUND),
	TK_WORD		= DEFLEX(DCL,0,0,0,DCLWORD),
	TK_BYTE		= DEFLEX(DCL,0,0,0,DCLBYTE),
	TK_REQUIRE	= DEFLEX(DCL,0,0,0,DCLREQU),
	TK_CSECT	= DEFLEX(DCL,0,0,0,DCLCSECT),
	TK_STACKLOCAL	= DEFLEX(DCL,0,0,0,DCLSLOCAL),
	TK_LINKAGE	= DEFLEX(DCL,0,0,0,DCLLNKG),
	TK_PSECT	= DEFLEX(DCL,0,0,0,DCLPSECT),

!SPECIAL ERROR OPERATOR

	TK_ERROR	= DEFLEX(OP,14,SE+MT+AE,0,OP_ERROR),
	TK_BACKSLASH	= DEFLEX(OP,14,SE+MT+AE,1,OP_ERROR);

! name table entry fields

Macro
	nt_data		= 0, 0, 8,0 %,		! text of name (15 characters max)
	nt_next		= 2, 0,32,1 %,		! POINTER TO NEXT NAME ENTRY
	nt_symb		= 2,32,32,1 %,		! POINTER TO MOST RECENT IN ST
	nt_hash		= 3, 0,32,1 %,		! POINTER BACK TO HASH TABLE
	nt_debug	= 3,32,32,1 %;		! CHAIN OF DEBUG ST ENTRIES

! GT node fields
!
! notes:
!	many of the fields overlap.  this is because FLOWAN's
!	structures are completely different from that of DELAY,
!	TNBIND, and CODE and are not shared.
!
!	the fields [gt_type], [gt_mode], [gt_reg], [gt_disp],
!	[gt_disp_16], [gt_pos], and [gt_len] are common to
!	symbols and tempnames also.

Macro

! fields common to FLOWAN, DELAY, TNBIND, and CODE

	gt_depth	= 0,56, 8,0 %,	! loop depth
	gt_occ		= 0,40, 8,0 %,	! occurence count
	gt_type		= 0,32, 8,0 %,

	gt_csparent	= 1,32,32,1 %,	! -> CSE parent
	gt_csthread	= 1, 0,32,1 %,	! -> next CSE thread

! FLOWAN only fields

	gt_gthread	= 0, 0,32,1 %,	! -> next GTHASH thread

	gt_xdepth	= 2,56, 8,0 %,	! cs parent loop depth
	gt_abc		= 2,32,12,0 %,	! atomic block count
	gt_pcsthread	= 2, 0,32,1 %,	! Psi CSE thread

	gt_flow		= 3, 0,32,1 %,	! -> flow list structure

	gt_crlevel	= 4, 0,32,1 %,	! creation level
	gt_inner_omega	= 4,32,32,1 %,	! -> inner omega list entry

	gt_fparent	= 5,32,32,1 %,	! -> formal parent
	gt_fsthread	= 5, 0,32,1 %,	! -> next formal thread

	gt_mklevel	= 6,32,32,1 %,	! make level
	gt_end_of_pcs	= 6, 0,32,1 %,	! -> end of Psi/potential CSE list

! DELAY, TNBIND, CODE only fields

	gt_label	= 0, 0,32,1 %,	! node label

	gt_lon		= 2,32,32,0 %,	! linear order number
	gt_fon		= 2, 0,32,0 %,	! flow order number

	gt_mode		= 3,56, 8,0 %,
	gt_pos		= 3,40, 8,0 %,
	gt_len		= 3,32, 8,0 %,

	gt_reg		= 4,32,32,1 %,
	gt_disp_16	= 4, 0,16,1 %,
	gt_disp		= 4, 0,32,1 %,

	gt_state	= 5, 0,64,0 %,	! state word

	gt_lab_t	= 6,32,32,1 %,	! true label
	gt_lab_f	= 6, 0,32,1 %,	! false label

! DELAY only fields

	gt_ru_compl	= 3, 0,16,0 %,	! register use complexity
	gt_cs_compl	= 3,16,16,0 %,	! code size complexity

! TNBIND, CODE only fields

	gt_dtdelete	= 3, 0,16,0 %,	! dynamic temps level

! note: many of these bit fields previously overlapped and so
! one phase would erase its own bits on first use of a node (e.g.
! DELAYBITS and CXBITS).  I have given each flag its own bit
! and have assumed that they no longer need to be reset.

! usage:
!	mustgencode	code must be generated for this node
!	enable		this is a compound statement with an ENABLE statement
!	inlinecom	this is an INLINECOM statement
!	omega		this is the child of an omega list entry
!	rho		this is the child of a rho list entry
!	csp		this is a CSE parent
!	bogus		this node is bogus.  it marks the head of a P-CSE list
!	fp		this is a formal parent
!	purge		pernamently disabled for CSE recognition
!	jm		note to turn on RM at next join
!	mm		note to turn on RM at next sync point
!	rm		disabled for CSE recognition
!	alpha		this is the child of an alpha list entry
!	chi		this is the child of a chi list entry
!	flow		gt_flow contains a valid pointer
!	prolog		this is a member of the prolog
!	postlog		this is a member of the postlog
!	dont_unlink
!	delayed
!	old_rcmt
!	add_copied
!	copied
!	coded
!	ctl_or_cse
!	tpath		0 if LHS argument is target, 1 if RHS argument is
!	chpdfr
!	bound

	gt_v_mustgencode= 7,63, 1,0 %,
	gt_v_enable	= 7,62, 1,0 %,	! syntax, code
	gt_v_inlinecom	= 7,62, 1,0 %,	! syntax, code
	gt_v_omega	= 7,61, 1,0 %,	! flowan
	gt_v_rho	= 7,60, 1,0 %,	! flowan
	gt_v_csp	= 7,59, 1,0 %,	! syntax, flowan
	gt_v_bogus	= 7,58, 1,0 %,	! syntax, flowan, delay
	gt_v_fp		= 7,57, 1,0 %,	! syntax, flowan
	gt_v_purge	= 7,56, 1,0 %,	! syntax, flowan
	gt_v_jm		= 7,55, 1,0 %,	! flowan
	gt_v_mm		= 7,54, 1,0 %,	! flowan
	gt_v_rm		= 7,53, 1,0 %,	! syntax, flowan
	gt_v_alpha	= 7,52, 1,0 %,	! flowan
	gt_v_chi	= 7,51, 1,0 %,	! flowan
	gt_v_flow	= 7,50, 1,0 %,	! flowan, delay, tables
	gt_v_prolog	= 7,49, 1,0 %,	! flowan
	gt_v_postlog	= 7,48, 1,0 %,	! flowan

! delay bits.  these bits are clear by delay.

	gt_v_dont_unlink= 7,47, 1,0 %,	! delay, flowan, syntax
	gt_v_delayed	= 7,46, 1,0 %,	! delay, tnbind, code
	gt_v_old_rcmt	= 7,45, 1,0 %,	! delay, tnbind
	gt_v_add_copied	= 7,44, 1,0 %,	! delay
	gt_v_copied	= 7,43, 1,0 %,	! delay, tnbind
	gt_v_coded	= 7,42, 1,0 %,	! tnbind, code
	gt_v_ctl_or_cse	= 7,41, 1,0 %,	! delay

! start of CXBITS

	gt_v_tpath	= 7,40, 1,0 %,	! delay, tnbind, code
	gt_v_chpdfr	= 7,39, 1,0 %,	! delay
	gt_v_bound	= 7,38, 1,0 %,	! tnbind

! start of RCBITS (real code)

	rc_mov_offset	= 7,37, 1,0 %,	! "MOV OFFSET, TEMP"
	rc_mov_target	= 7,36, 1,0 %,	! "MOV TARGET, TEMP"
	rc_negate	= 7,34, 1,0 %,	! "NEG TEMP"
	rc_operate	= 7,33, 1,0 %,	! "OPERATOR NON-TARGET, TEMP"
	rc_add_offset	= 7,32, 1,0 %,	! "ADD OFFSET,TEMP"
	rc_sub_offset	= 7,31, 1,0 %,	! "SUB OFFSET, TEMP"
	rc_complement	= 7,30, 1,0 %,	! "COMPLEMENT TEMP"
	rc_otherwise	= 7,32, 1,0 %,	!  SELECT CONTAINS AN OTHERWISE OR ALWAYS

	RCBITS		= 7,30, 6,0 %,
	CXBITS		= 7,30,10,0 %,

! OTHER CONTROL BITS IN THE GT ENTRY
  
	gt_v_lab_req	= 7,29, 1,0 %,	! LABEL MUST BE ASSIGNED FOR NODE
	gt_v_symoff	= 7,28, 1,0 %,	! OFFSETF IS A SYMBOL RATHER THAN LIT
	gt_v_symresult	= 7,27, 1,0 %,	! RESULT IS SYMBOL (OFF. AND RES. STATE)

	DELAYBITS	= 7,27,21,0 %,

	gt_code		= 7,16, 8,0 %,
	gt_argc		= 7, 0,16,0 %,

	gt_argv(N)	= 8+(N),0,64,0 %,
	gt_arg1		= gt_argv(0) %,
	gt_arg2		= gt_argv(1) %,
	gt_arg3		= gt_argv(2) %,
	gt_arg4		= gt_argv(3) %,
	gt_arg5		= gt_argv(4) %,
	gt_arg6		= gt_argv(5) %,
	gt_arg7		= gt_argv(6) %;

! symbol table fields
!
! notes:
!	VUSELSTF is used with the base of a symbol.  NAMEXPTR
!	is used with symbols linked off the base symbol.

Macro

! common fields

	st_scope		= 0,40, 8,0 %,
	st_next			= 0, 0,32,1 %,
	st_prev			= 1,32,32,1 %,
	st_name			= 1, 0,32,1 %,
	st_which		= 2, 0,32,1 %,

! linkage symbol fields

	st_lnk_type		= 2,32,32,1 %,
	st_lnk_desc		= 2, 0,32,1 %,

! macro symbol fields

	st_mac_type		= 2,32,32,1 %,
	st_mac_body		= 2, 0,32,1 %,
	st_mac_num_fixed	= 3,32,32,1 %,
	st_mac_num_ited		= 3, 0,32,1 %,
	st_mac_depth		= 4,32,32,1 %,

! structure symbol fields

	st_str_alloc		= 2,32,32,1 %,
	st_str_body		= 2, 0,32,1 %,
	st_str_argc		= 3,32,32,1 %,

! label symbol fields

	st_lab_stop_ncse	= 0,63, 1,0 %,
	st_lab_used		= 0,62, 1,0 %,
	st_lab_left		= 0,61, 1,0 %,
	st_lab_dead		= 0,60, 1,0 %,
	st_lab_alive		= 0,59, 1,0 %,
	st_lab_cell		= 2,32,32,1 %,
	st_lab_node		= 2, 0,32,1 %,
	st_lab_inc		= 3,32,32,1 %,
	st_lab_level		= 3, 0,32,1 %,

! bind symbol

	st_bind_data		= 4, 0,64,0 %,

! variable symbol fields

	st_rout_argc		= 0,56, 8,0 %,
	st_var_reg_index	= 0,56, 8,0 %,
	st_var_linkage		= 2,32,32,1 %,

	st_enable_loc		= st_lab_cell %,
	st_var_actuals		= 2, 0,32,1 %,
	st_var_size		= 3, 0,32,1 %,
	st_retlab		= 3, 0,32,1 %,
	st_unique		= 5,32,32,1 %,
	st_v_unique		= 5,13, 1,0 %,
	st_v_gbl_bind		= 5,12, 1,0 %,
	st_v_nouplevel		= 5,11, 1,0 %,
	st_v_unlim_acts		= 5,10, 1,0 %,
	st_v_counted		= 5, 9, 1,0 %,
	st_v_listed_external	= 5, 8, 1,0 %,
	st_v_printed		= 5, 7, 1,0 %,
	st_v_debug		= 5, 6, 1,0 %,
	st_v_namexp		= 5, 5, 1,0 %,
	st_v_init		= 5, 4, 1,0 %,
	st_v_release_init	= 5, 3, 1,0 %,
	st_v_release_acts	= 5, 2, 1,0 %,
	st_v_plit		= 5, 1, 1,0 %,
	st_v_no_acts		= 5, 0, 1,0 %,
	st_var_reg_save		= 6,32,32,0 %,
	st_var_reg_list		= 6, 0,32,1 %,
	st_var_chg_list		= 6,32,32,1 %,
	st_var_use_list		= 6, 0,32,1 %,
	st_var_base		= 6, 0,32,1 %,
	st_var_init		= 7, 0,32,1 %,
	st_var_next		= 7,32,32,1 %;

! list of symbols record.  used in DECLAR to hold a list of
! symbols which are being declared as a group.

Macro
	ste_next	= 0, 0,32,1 %,
	ste_symb	= 0,32,32,1 %,
	ste_pos		= 1, 0,64,1 %;

! formal parameter list descriptor

Macro
	parm_size	= 0, 0,64,0 %,
	parm_data(N)	= N, 0,64,0 %,
	parm_type(N)	= N,32,32,0 %,
	parm_loc(N)	= N, 0,32,0 %;

! tempname fields
!
! notes:
!	some fields are in common with ST and GT nodes

Macro
	tn_type		= 0,56, 8,0 %,	! TYPE TO WHICH THIS TN HAS BEEN BOUND
	tn_request	= 0,48, 8,0 %,	! TYPE OF TEMP REQUIRED
	tn_depth	= 0,40, 8,0 %,	! LOOPDEPTH FIELD
	tn_pref		= 0, 0,32,1 %,	! POINTER TO PREFERENCE LIST
	tn_lon_fu	= 1,32,32,0 %,	! LON OF FIRST USE
	tn_lon_lu	= 1, 0,32,0 %,	! LON OF LAST USE
	tn_fon_fu	= 2,32,32,0 %,	! FON OF FIRST USE
	tn_fon_lu	= 2, 0,32,0 %,	! FON OF LAST USE
	tn_v_lit	= 3,48, 1,0 %,	! THIS TN POINTS TO A LITERAL
	tn_marked	= 3,49, 1,0 %,	! marked for debugging
	tn_bind_list	= 3, 0,32,1 %,	! POINTER TO LIST OF ALL THINGS BOUND
					! TO THE SAME PLACE AS THIS ONE
	tn_permit	= 4, 0,32,1 %,	! IF NONZERO, POINTS TO A TN WHICH THIS ONE
					! MAY LIVE WITH REGARDLESS OF LIFETIME
					! OVERLAP.
	tn_literal	= 4, 0,64,0 %,	! CONTAINS LITLEXEME IF TNLITBIT IS ON
	tn_max_complexity=5,32,32,0 %,	! MAX USE COMPLEXITY
	tn_min_complexity=5, 0,32,0 %;	! (MIN) USE COMPLEXITY

! tn_request codes

Literal
	NOREQDB		= 0,	! ANY BINDING IS POSSIBLE
	MEMREQDB	= 1,	! BINDING REQUIRED TO SPECIFIC MEMORY
	SLREQDB		= 2,	!    "        "    "  STATIC LOCAL
	ARREQDB		= 3,	!    "        "    "  ANY REGISTER
	SRREQDB		= 4,	!    "        "    "  A SPECIFIC REGISTER
	IGREQDB		= 5,	! IGNORE THIS TN (DUMMY ENTRY)
	DECREQDB	= 6,	! DECLARED TN (LOCAL OR REGISTER)
	RFREQDB		= 7,	! BIND TO REGISTER OR FORGET IT (FORGET IT BINDING IS IN OFFSETF)
	LO_REQD_TYPE	= 0,
	HI_REQD_TYPE	= 7;

! tn_type codes
!
! notes:
!	BNDREG		tempname is bound to a register
!			set by MARKANDCOPY in CODE, TRYSPREG
!			in TRY, LOADR0 in TNBIND, TPACK in TNBIND,
!			TMARK in TNBIND, INITPDTNS in TNBIND.
!
!	BNDLOCAL	tempname is bound to a static local
!			set by TRYCLVTEMPS in CODE, TMARK
!			in TNBIND.
!
!	BNDPUSH		tempname is bound to a dynamic local
!			set by MAKEPUSHVT in CODE, OPENDYTEMP
!			in TRY, TMARK in TNBIND
!
!	BNDPREF		tempname is bound to whatever its
!			preference is bound to.  set by
!			TRYPREF in TNBIND
!
!	BNDNCSE		tempname is bound to a named CSE.
!			set by GETLOAD in DELAY

Literal
	BNDREG		= 1,
	BNDLOCAL	= 2,
	BNDPUSH		= 3,
	BNDPREF		= 4,
	BNDNCSE		= 5;

! TNREP fields
!
! notes:
!	this structure shares the [itm_llink] and [itm_rlink] fields.

Macro
	tnr_req		= 1,32,32,1 %,
	tnr_ptr		= 1, 0,32,1 %,	! POINTER TO THE TN THIS TNREP REPS
	tnr_pref	= 2, 0,32,1 %;	! backlink to preference

! stack of levels, atomic block counts, etc.

Macro
	stk_data	= 0, 0,32,1 %,
	stk_next	= 0,32,32,1 %;

! stack of lists

Macro
	stk_idx		= 0, 0,32,1 %,
	stk_max		= 0,32,32,1 %,
	stk_item(Z)	= (Z)+1,0,0,0 %;

! fields of the DTDSTK, FONSTK, and LOOPLFSTK stacks (see TNBIND).
!
! notes:
!	these are variable length stack implemented using item
!	lists and so word zero is the itm_rlink/itm_llink field.
!	the top of the stack is referenced using STACK[itm_rlink].
!	the stack is expanded with the macro PUSHLS and contracted
!	using the macro POPLS.
!
!	these stacks all use the same macros for pushing and
!	popping and so their sizes must match.

Macro
	stk_fon_lo	= 1, 0,32,1 %,
	stk_fon_hi	= 1,32,32,1 %,
	stk_dtd_lo	= 1, 0,32,1 %,
	stk_dtd_hi	= 1,32,32,1 %,
	stk_exit_fon	= 1, 0,32,1 %,
	stk_exit_lon	= 1,32,32,1 %;

! stream fields.
!
! notes:
!	a stream is a linked list of vectors which forms a stack of
!	words.  the first two words in each vector are reserved for
!	[strm_size] and [strm_next].
!
!	there are four major streams:
!
!		INP		structure stream input
!
!		WST		output stream
!
!		APL		actual parameter list
!
!		APM		actual parameter mechanism

Macro 
	strm_size	= 0 %,		! LENGTH IN WORDS, INCLUDING THE 0TH
  	strm_next	= 1 %,		! LINK WORD, SET BY PUSH
	strm_data(I)	= (I)+2 %;

!  F. DEFAULT VECTOR STACK MECHANISM

Macro
	STRUCF		= strm_next %;

Macro
	plit_lexeme	= 3, 0,64,0 %,	! cell hanging from plit list
	plit_lbyte	= 3, 8, 8,0 %,
	plit_rbyte	= 3, 0, 8,0 %,
	plit_length	= 3, 0,32,0 %,	! string length in words
	plit_replicator	= 3, 0,32,0 %;	! # of duplicated sublists

! item lists fields
!
! notes:
!	other types of item lists include TNREP's and
!	the FON/DTD/loop LON/FON stacks in TNBIND.
!
!	items are normally created using MAKITEM and the arguments
!	to MAKITEM must match the order of the itm_xxx fields
!	after itm_llink.

Macro
	itm_rlink	= 0, 0,32,1 %,
	itm_llink	= 0,32,32,1 %,
	itm_kill_abc	= 1,48,16,0 %,
	itm_kill_type	= 1,32,16,0 %,
	itm_kill_cause	= 1, 0,32,1 %,
	itm_size	= itm_rdata(1) %,
	itm_abc		= itm_ldata(1) %,
	itm_fparent	= itm_ldata(1) %,
	itm_int_data(I) = I+1, 0,64,0 %,
	itm_int_rdata(I)= I+1, 0,32,1 %,
	itm_int_ldata(I)= I+1,32,32,1 %,
	itm_data(I)     = I,   0,64,0 %,
	itm_ldata(I)	= I,  32,32,1 %,
	itm_rdata(I)	= I,   0,32,1 %,

	hdr_enter	= 1, 0,32,1 %,
	hdr_remove	= 1,32,32,1 %,

! NCSE list entry

	itm_ncse_data	= 1, 0,32,1 %,
	itm_ncse_csp	= 1,32, 1,0 %,
	itm_ncse_lst1	= 2,32,32,1 %,
	itm_ncse_lst2	= 2, 0,32,1 %;

! flow list fields
!
! notes:
!	if ever FLOW is separated from LEXSYN then there should be
!	no need for this structure.

Macro
	flow_prolog	= 0, 0,32,1 %,
	flow_mu		= 0,32,32,1 %,
	flow_postlog	= 1, 0,32,1 %,
	flow_epilog	= 1,32,32,1 %;

! item destroy methods:
!
!	0 - simple item
!	1 - simple item + bogus node
!	2 - intersection list
!	3 - Rho list item
!	4 - FLSTK item

Literal
	CHIREMOVE	= 0,
	PRLGREMOVE	= 0,
	MUREMOVE	= 0,
	PSLGREMOVE	= 0,
	EPLGREMOVE	= 0,
	VCHGREMOVE	= 0,
	VUSEREMOVE	= 0,
	KILREMOVE	= 0,
	FREETEMPREMOVE	= 0,
	TEMPREMOVE	= 0,
	PARAMREMOVE	= 0,
	BOGREMOVE	= 1,
	ALPHAREMOVE	= 2,
	OMEGAREMOVE	= 2,
	RHOREMOVE	= 3,
	FLSREMOVE	= 4;

! item enter rules.  0 = LIFO, 1 = SORT, 2 = XSORT

Literal
	BOGENTER	= 0,
	FREETEMPENTER	= 0,
	TEMPENTER	= 0,
	PARAMENTER	= 0,
	ALPHAENTER	= 1,
	RHOENTER	= 1,
	CHIENTER	= 1,
	OMEGAENTER	= 1,
	PRLGENTER	= 1,
	MUENTER		= 1,
	PSLGENTER	= 1,
	EPLGENTER	= 1,
	VCHGENTER	= 1,
	VUSEENTER	= 1,
	KILENTER	= 1,
	FLSENTER	= 2;

!
!  THE FOLLOWING FIELD DEFINITIONS HAVE TO DO WITH SETTING AND TESTING
!    THE FIELDS OF THE NODES THEMSELVES.  THE FIRST PART HAS TO DO
!    WITH THE RESULT WORD FORMAT (AND IS PERHAPS NOT NEEDED OUTSIDE
!    OF DELAY).  THE SECOND PART CONCERNS CODE PRODUCTION AND MUST BE
!    SHARED.

!
! SAME FIELD DEFINITIONS EXCEPT FOR USE WITH GTVEC MAPPING IN ACCESSING
!  THE STATE WORD OF THE GT NODE

Macro
	rw_real_flow	= 5,51, 2,0 %,	! REAL/FLOW SUBSTATES
	  rw_real	= 5,51, 1,0 %,	! REAL RESULT BIT
	  rw_flow	= 5,52, 1,0 %,	! FLOW RESULT BIT
	rw_literal	= 5,50, 1,0 %,	! NON-LITERAL(=0)/LITERAL(=1)
	rw_ptr_state	= 5,44, 3,0 %,	! POINTER SUBSTATE CASES
	rw_negated	= 5,43, 1,0 %,	! RESULT NEGATIVE
	rw_complemented	= 5,42, 1,0 %,	! RESULT COMPLEMENTED
	rw_destroyable	= 5,41, 1,0 %,	! INVOLVES DESTROYABLE TEMPORARY
	rw_immediate	= 5,40, 1,0 %,	! IMMEDIATE ADDRESS (ON SYMBOL OR LIT)
	NRWORDF		= 5,40,13,0 %;	! THE "WHOLE THING"

!(SAME FIELD DEFINITIONS FOR THE STATE WORD OF THE GT NODE.)

  ! SRFF VALUES

	FIELDK(51,RFNONE,0);
	FIELDK(51,RFREAL,1);
	FIELDK(51,RFFLOW,2);
	FIELDK(51,RFBOTH,3);

  ! SLF VALUES

	FIELDK(50,LIT,1);

  ! SSPF VALUES

	FIELDK(44,PFNONE,0);	! NO POINTER SPECIFIED
	FIELDK(44,PF016,1);	! <0,16>
	FIELDK(44,PF08,2);	! <0,8>
	FIELDK(44,PFE1,3);	! <E,1>
	FIELDK(44,PFOTHER,4);	! <E1,E2>
	FIELDK(44,PF88,5);	! <8,8>

  ! KNEGF VALUES

	FIELDK(43,KPOS,0);
	FIELDK(43,KNEG,1);

  ! IMMF VALUES

	FIELDK(40,IMM,1);

Macro
	adr_name	= 0, 0,32,1 %,
	adr_reg		= 0,32, 3,0 %,
	adr_mode	= 0,36, 3,0 %,
	adr_type	= 0,40, 3,0 %,
	adr_delta	= 0,44, 3,1 %,
	adr_name_type	= 0,48, 3,0 %,
	adr_disp	= 1, 0,16,1 %,

	cel_dst		= 7,0,0,0 %,
	cel_dst_delta	= 7+adr_delta %,
	cel_dst_mode	= 7+adr_mode %,
	cel_dst_name	= 7+adr_name %,
	cel_dst_name_type=7+adr_name_type %,
	cel_dst_disp	= 7+adr_disp %,
	cel_dst_reg	= 7+adr_reg %,
	cel_dst_type	= 7+adr_type %,

	cel_src		= 5,0,0,0 %,
	cel_src_delta	= 5+adr_delta %,
	cel_src_mode	= 5+adr_mode %,
	cel_src_name	= 5+adr_name %,
	cel_src_name_type=5+adr_name_type %,
	cel_src_disp	= 5+adr_disp %,
	cel_src_reg	= 5+adr_reg %,
	cel_src_type	= 5+adr_type %;

!
! FIELD NAMES FOR THE GMA RESULT WORD
!
Macro
	gma_disp	= 0,32,0 %,
	gma_reg		= 32,3,0 %,
	gma_mode	= 36,3,0 %,
	gma_type	= 40,3,0 %,
	gma_name_type	= 48,3,0 %;
!
! notes:
!	PLIT's are stored using cells.

Macro
	cel_prev	= 0,32,32,1 %,
	cel_next	= 0, 0,32,1 %,

	cel_bot		= 1,32,32,1 %,
	cel_top		= 1, 0,32,1 %,

	cel_type	= 2,32,32,1 %,
	cel_size	= 2, 0,32,1 %,

	cel_min_loc	= 3,32,32,1 %,
	cel_min_len	= 3, 0,32,1 %,

	cel_ref_ef	= 3,32,32,1 %,
	cel_ref_rf	= 3, 0,32,1 %,

	cel_sym_name	= 4,32,32,1 %,
	cel_sym_disp	= 4, 0,32,1 %,

	cel_class	= 4,32,32,1 %,
	cel_code	= 4, 0,32,1 %,

	cel_lab_info	= 4, 0,64,0 %,
	cel_lab_name	= 4, 0,32,1 %,
	cel_lab_type	= 4,32,31,0 %,
	cel_lab_seen	= 4,63, 1,0 %,

	cel_inl_comment	=  5,40,1,0 %,
	cel_inl_arg	=  5,lex_part %,
	cel_hydra_word	=  7,59,1,0 %;

Macro		! VARIOUS PREDICATES
	HASSOURCE(OP)	= ONEOF(.OPERTYPE[OP],OPTYPE_ONE,OPTYPE_TWO,OPTYPE_BR,OPTYPE_WORD,OPTYPE_CASE) %,
	HASDEST(OP)	= ONEOF(.OPERTYPE[OP],OPTYPE_TWO,OPTYPE_JSR,OPTYPE_CASE) %;

! note:
!	bliss-64 does not allow for constants of more than 32 bits.
!	thus the need for this kludge.

Macro
	ADRPLIT(FORM,REG,TYPE,NAMETYPE,NAME) =
		UPlit Long (
			NAME,
			 FORM    ^(_POS(gma_mode)-32)
			+TYPE    ^(_POS(gma_type)-32)
			+REG     ^(_POS(gma_reg)-32)
			+NAMETYPE^(_POS(gma_name_type)-32),
			0,0) %,
	ADR1PLIT(FORM,REG,TYPE,NAMETYPE,NAME) =
		UPlit Long (
			NAME,
			 FORM    ^(_POS(gma_mode)-32)
			+TYPE    ^(_POS(gma_type)-32)
			+REG     ^(_POS(gma_reg)-32)
			+NAMETYPE^(_POS(gma_name_type)-32),
			1,0) %,
	BUILDOPD(TYP,MD,REG,OPRND)=
		((TYP)^_POS(gma_type) Or
		  (MD)^_POS(gma_mode) Or
		 (REG)^_POS(gma_reg) Or
		 (OPRND And %x'7fffffff')) %,
	COPYADR(X,Y)	= ch$move(16,Y,X) %;

!-----------------------------------------
!9. LOOPING CONSTRUCT DEFAULT DEFINITIONS:

Macro
	DFROM		= ZERO %,
	DTOI		= LITLEXEME((1^15)-1) %,
	DTOD		= LITLEXEME(((-1)^15)) %,
	DBY		= LITLEXEME(1) %;

!-----------------------------------------
!10.  PRIMITIVES TO SET AND RESTORE NOTREE

Macro
	NOCODE		= (NOTREE = (.NOTREE^1) Or 1) %,
	RESNOTREE	= (NOTREE = .NOTREE^(-1)) %;
! MACRO FOR USING "CREATED" SYMBOLS

Macro	BASESYM(S)=
			(If .GT[S,st_v_namexp]
			    Then .GT[S,st_var_base]
			    Else S)  %;

! SIZE OF ALLOCATED STACKS
! --------------------------

Literal
	STKSIZE		= 64,
	DTDONTCARE	= %x'ffff';	! DEPENDS ON SIZE OF DTDELETE FIELD

Macro
	SUCCESS		= Return TRUE %,
	FAIL		= Return FALSE %;

Bind
	 GENESIS	= 0,		! FIRST LON/FON
	 ETERNITY	= -1;		! LAST LON/FON

Macro
	NULLLST(A)	=
			Begin
			Bind Q = A : ITEM;
			Q[itm_llink] = A;
			Q[itm_rlink] = A
			End %,
	ISOPEN(LST)	= Not(EMPTY(LST))  %,
	OPENREG(Z)	= OPENLIST(REGS[(Z)])  %;

!
Macro
	PUSHSTK(STK)=
		Begin
		STK[stk_idx] = .STK[stk_idx] + 1;
		If .STK[stk_idx] Gtr .STK[stk_max] Then
		    STK[stk_max] = .STK[stk_idx];
		NULLLST(STK[stk_item(.STK[stk_idx])])
		End %;

Macro
	POPSTK(STK)=
		Begin
		RELTNREPLST(STK[stk_item(.STK[stk_idx])]);
		STK[stk_idx] = .STK[stk_idx]-1
		End %;

! VARIOUS USEFUL PREDICATES

Macro
	ISSTVAR(QN)=
		(.QN[gt_type] Geq LOWVARTYPE And .QN[gt_type] Leq HIGHVARTYPE ) %,
	ISEXP(QN)=
		(.QN[gt_type] Geq LOWVARTYPE And .QN[gt_type] Leq HIGHEXPTYPE ) %,
	ISADDR(QN)=
		(.QN[gt_type] Geq LOWVARTYPE And .QN[gt_type] Leq HIGHADDTYPE ) %,
	LOADCONST(QN)=
		ONEOF(.QN[gt_type],S_OWN,S_EXTERNAL,S_GLOBAL,S_ROUTINE,S_GBL_ROUTINE,S_FORWARD) %;


!	2. NOW VARIOUS OTHER USEFUL LEXEMES.

Macro
	MINONE		= LITLEXEME(-1) %,
	ZERO		= LITLEXEME(0) %,
	FULLWORD	= LITLEXEME(WRDSZ) %,
	ONE		= LITLEXEME(1) %;

!
! FUNCTION:
!	PREDICATES TO DETERMINE CSE INFORMATION ABOUT
!	A NODE. THE PREDICATES GIVE 'TRUE' ON THE FOLLOWING DESCRIBED
!	CONDITIONS:
!	  ISCSE -- IF NODE IS ANY KIND OF CSE (PARENT OR USE)
!	  ISCSEUSE -- IF NODE IS A CSE USE BUT NOT A CSPARENT
!	  ISCSECREATION -- IF NODE IS A CSPARENT
!	  ISLARGECSE -- IF NODE IS A LARGE CSE (3 OR MORE USES)
!
Macro
	ISCSE(NODE)		= (.GT[.NODE[gt_csparent],gt_occ] Gtr 1) %,
	ISCSEUSE(NODE)		= (Bind ND=NODE : Ref GT; ISCSE(ND) And Not .ND[gt_v_mustgencode]) %,
	ISCSECREATION(NODE)	= (Bind ND=NODE : Ref GT; ISCSE(ND) And .ND[gt_v_mustgencode]) %,
	ISLARGECSE(NODE)	= (.GT[.NODE[gt_csparent],gt_occ] Gtr 2) %,
	UNBOGUS(NODE)		=
		Begin
		Do
		    NODE<lex_addr> = .NODE[gt_csthread]
		Until .NODE[gt_v_mustgencode]
		End %;

! clever macro to count the number of bits in a word.  works
! for up to 7 bits.

Literal
	ONES		= %b'1001001001001001001001',
	REPLICA3	= %x'10101';

Macro
	SUMBITS(RCC)=
		(Local QQ;
		QQ = ((RCC)*REPLICA3 And ONES)*ONES;
		.QQ<21,3>) %;
!
!-----------------------------------------------------------------------
!14. COMMON SUBEXPRESSION ELIMINATION AND FLOW-ANALYSIS

Macro

! PUSHLV and POPLV implement variable length stacks
! for LVLCOPY, FLOOR, CEILING, ABCBASE, hdr_prolog, etc.

	PUSHLV(L,N)=
		Begin
		Bind Q = L : LVL;
		Local ZQ14 : Ref LVL;
		ZQ14 = GETSPACE(N);
		ZQ14[stk_next] = .Q[stk_next];
		ZQ14[stk_data] = .Q[stk_data];
		Q[stk_next] = .ZQ14
		End %,
	POPLV(L,N)=
		Begin
		Bind Q = L : LVL;
		Local ZQ13 : Ref LVL;
		ZQ13 = .Q[stk_next];
		Q[stk_next] = .ZQ13[stk_next];
		Q[stk_data] = .ZQ13[stk_data];
		RELEASESPACE(.ZQ13,N)
		End %,
	FORALLRATORS(I)=
		Decr I From MAXOPERATOR To 0 Do  %,
	NUMRANDS(N)=
		N[gt_argc]-1 %,
	FORALLRANDS(I,J)=
		Decr I From J[gt_argc]-1 To 0 Do  %;

!---------------------------------------------------------------------
!17. THE FOLLOWING ARE: A FLAG TO INFORM "RUNC" OF THE PROPER REACTION
!   TO CERTAIN OPEN BRACKETS, AND MACROS (CALLED IN "DCLARE" AND
!   "EXPRESSION") TO SET AND RESTORE THAT FLAG.

Macro	INDCL		= INDECL = .INDECL^1 + 1  %,
	INEXP		= INDECL = .INDECL^1 + 0  %,
	RESINDECL	= INDECL = .INDECL^(-1)  %;

Macro
	NEWLASTEND(N)	= SAVEL = .LASTEND; LASTEND = N  %,
	RESLASTEND	= LASTEND = .SAVEL  %;
!-------------------------------------------------------------------------
!8. FLAGS:
!
!   A. THE FOLLOWING ARE MACRO DEFINITIONS OF FLAGS FOR COMPILATION.
!
! notes:
!	can't use BIND on these.
!
Macro
	swit_expand	= FLAGS<32,1> %, ! LIST MACRO EXPANSIONS
	swit_optimize	= FLAGS<33,1> %, ! NO OPTIMIZATION ACROSS ;'S
	swit_statistics	= FLAGS<34,1> %, ! PRINT COMPILER STATISTICS
	swit_list	= FLAGS<35,1> %, ! PRODUCE LISTING
	swit_pic	= FLAGS<36,1> %, ! PRODUCE POSITION INDEPENDENT CODE
	swit_errors	= FLAGS<37,1> %, ! REPORT ERRORS TO USER'S TERMINAL
	swit_hydra	= FLAGS<38,1> %, ! DO SPECIAL THINGS FOR HYDRA
	swit_final	= FLAGS<39,1> %, ! ON FOR 'SUPER' OPTIMIZE IN FINAL
	swit_unames	= FLAGS<40,1> %, ! PRINT UNIQUE NAMES
	swit_mark	= FLAGS<41,1> %, ! MARK DOT NODES FOR .X =
	swit_debug	= FLAGS<42,1> %, ! PRODUCE TABLES, ETC., FOR SIX12
	swit_zip	= FLAGS<43,1> %, ! OPTIMIZE FOR SPEED INSTEAD OF SIZE
	swit_i_d	= FLAGS<44,1> %, ! SEPARATION OF INSTRUCTIONS AND DATA
	swit_quick	= FLAGS<45,1> %, ! SPEED UP COMPILATION
	swit_peep	= FLAGS<46,1> %,
	swit_dump_flowan= FLAGS<47,1> %,
	swit_dump_delay	= FLAGS<48,1> %,
	swit_dump_tnbind= FLAGS<49,1> %,
	swit_dump	= FLAGS<47,3> %,
	swit_page	= FLAGS<50,1> %,

	flg_eof		= FLAGS< 1,1> %, ! END OF FILE FLAG
	flg_tty		= FLAGS< 0,1> %; ! TELETYPE LISTING FLAG.

Macro
	CSFLG	= SECTFLAGS< 0,8> %,
	CSCFLG	= SECTFLAGS< 8,8> %,	! CODE
	CSGFLG	= SECTFLAGS<16,8> %,	! GLOBALS
	CSOFLG	= SECTFLAGS<24,8> %,	! OWNS
	CSPFLG	= SECTFLAGS<32,8> %,	! PLITS
	CSDFLG	= SECTFLAGS<40,8> %;	! DEBUG STUFF

Require 'routines.req';
Require 'externals.req';
Require 'room.req';
Require 'errcodes.req';