Repr: TYPE = [none..all];

CommonRep: PROC [Repr, Repr] RETURNS [Repr] = LOOPHOLE[PrincOpsUtils.BITAND];

Prop: TYPE = RECORD [

fullProp: Prop = [

emptyProp: Prop = [

voidProp: Prop = fullProp;

CommonProp: PROC [Prop, Prop] RETURNS [Prop] = LOOPHOLE[PrincOpsUtils.BITAND];

Attr: TYPE = RECORD [prop: Prop, rep: Repr];

voidAttr: Attr = [prop: voidProp, rep: none];

CommonAttr: PROC [Attr, Attr] RETURNS [Attr] = LOOPHOLE[PrincOpsUtils.BITAND];

OpWordCount: TYPE = CARDINAL; -- size of operands for builtins

RegCount: TYPE = [0..32);

maxRegs: RegCount = RegCount.LAST;

WordSeq: TYPE = RECORD[SEQUENCE length: CARDINAL OF WORD];

ValueDescriptor: TYPE = LONG POINTER TO WordSeq;

BCDNotify, DeclNotify, LayoutNotify, StmtNotify: Alloc.Notifier;

OpsNotify, ExpANotify, ExpBNotify, ExpCNotify: Alloc.Notifier;

AssignImports: Tree.Scan;

InitBCD: PROC [Tree.Link, UNCOUNTED ZONE];

FinishBCD: Tree.Scan;

MakeEPLink: PROC [ep: CARDINAL, gfi: PrincOps.GFTIndex] RETURNS [BcdDefs.Link];

MatchBCD: PROC RETURNS [BOOL];

ProcessDirectory: Tree.Scan;

ProcessExports: Tree.Map;

ProcessImports: Tree.Scan;

ProcessSymLiterals: PROC;

BiasForType: PROC [CSEIndex] RETURNS [INTEGER];

CanonicalType: PROC [CSEIndex] RETURNS [CSEIndex];

ComparableType: PROC [CSEIndex] RETURNS [BOOL];

DeclItem: Tree.Scan;

DeclUpdate: Tree.Map;

DefaultBasicOps: PROC [SEIndex, BitCount] RETURNS [BOOL];

MaxCardinality: PROC [SEIndex, BOOL, WordCount] RETURNS [LONG CARDINAL];

RepForType: PROC [CSEIndex] RETURNS [Repr];

SparseRep: PROC [CSEIndex] RETURNS [BOOL];

TypeExp: PROC [typeExp: Tree.Link, body, indirect: BOOL←FALSE];

TypeForTree: PROC [Tree.Link] RETURNS [SEIndex];

WordsForType: PROC [CSEIndex] RETURNS [WordCount];

VarInit: SIGNAL RETURNS [BOOL];

AssignEntries: PROC [BTIndex];

BitsForType: PROC [SEIndex] RETURNS [BitCount];

CheckBlock: PROC [BTIndex];

CheckFields: PROC [RecordSEIndex, CARDINAL];

LayoutArgs: PROC [RecordSEIndex, CARDINAL, BOOL] RETURNS [CARDINAL];

LayoutBlock: PROC [BTIndex, CARDINAL] RETURNS [CARDINAL];

LayoutFields: PROC [RecordSEIndex, CARDINAL];

LayoutGlobals: PROC [bti: CBTIndex, stopping, fragments: BOOL] RETURNS [CARDINAL];

LayoutInterface: PROC [CBTIndex] RETURNS [CARDINAL];

LayoutLocals: PROC [CBTIndex] RETURNS [CARDINAL];

currentLevel: VAR ContextLevel;

checked: VAR BOOL;

BindCase: PROC [

BindType: PROC [Tree.Index, Tree.Map] RETURNS [Tree.Link];

Body: PROC [CBTIndex];

CaseDriver: PROC [Tree.Index, Tree.Map, INTEGER] RETURNS [Tree.Link];

CatchNest: PROC [Tree.Link];

MarkString: PROC [local: BOOL←TRUE];

Subst: PROC [Tree.Index] RETURNS [Tree.Link];

RelOp: TYPE = Tree.NodeName [relE .. relLE];

BoolTest: PROC [Tree.Link] RETURNS [BOOL];

FoldExpr: PROC [Tree.Index, Repr] RETURNS [Tree.Link];

IntervalTest: PROC [l,r: Tree.Link, rep: Repr] RETURNS [BOOL];

IntToReal: PROC [Tree.Index] RETURNS [Tree.Link];

LiteralRep: PROC [Tree.Link, Repr] RETURNS [Repr];

LongToShort: PROC [Tree.Index, Repr] RETURNS [Tree.Link];

MakeTreeLiteral: PROC [WORD] RETURNS [Tree.Link];

RelTest: PROC [l,r: Tree.Link, op: RelOp, rep: Repr] RETURNS [BOOL];

ShortToLong: PROC [Tree.Index, Repr] RETURNS [Tree.Link];

StructuredLiteral: PROC [Tree.Link] RETURNS [BOOL];

TreeLiteral: PROC [Tree.Link] RETURNS [BOOL];

TreeLiteralDesc: PROC [Tree.Link] RETURNS [Literals.LitDescriptor];

TreeLiteralValue: PROC [Tree.Link] RETURNS [WORD];

ZeroP: PROC [Tree.Link] RETURNS [BOOL];

ConsState: TYPE = {init, first, rest};

Covering: TYPE = {none, partial, full};

All: PROC [node: Tree.Index, cs: ConsState←$init] RETURNS [Tree.Link];

Assignment: PROC [Tree.Index] RETURNS [Tree.Link];

Call: PROC [Tree.Index] RETURNS [Tree.Link];

CheckRange: PROC [Tree.Link, CARDINAL, CSEIndex] RETURNS [Tree.Link];

Construct: PROC [node: Tree.Index, cs: ConsState←$init] RETURNS [Tree.Link];

Cover: PROC [lType: CSEIndex, lRep: Repr, rType: CSEIndex, rRep: Repr]

Dollar: PROC [Tree.Index] RETURNS [Tree.Link];

Dot: PROC [Tree.Index, Repr] RETURNS [Tree.Link];

Extract: PROC [Tree.Index] RETURNS [Tree.Link];

Index: PROC [Tree.Index] RETURNS [Tree.Link];

MakeArgRecord: PROC [RecordSEIndex, Tree.Link] RETURNS [Tree.Link];

Narrow: PROC [Tree.Index] RETURNS [Tree.Link];

New: PROC [Tree.Index] RETURNS [Tree.Link];

PadRecord: PROC [t: Tree.Link, lType: CSEIndex] RETURNS [Tree.Link];

RewriteAssign: PROC [Tree.Index, CSEIndex] RETURNS [Tree.Link];

Reloc: PROC [Tree.Index] RETURNS [Tree.Link];

Rhs: PROC [exp: Tree.Link, lType: CSEIndex, cs: ConsState←$init, voidOK: BOOL←FALSE]

RowConstruct: PROC [node: Tree.Index, cs: ConsState←$init] RETURNS [Tree.Link];

SeqIndex: PROC [Tree.Index] RETURNS [Tree.Link];

Substx: PROC [Tree.Index] RETURNS [Tree.Link];

Union: PROC [node: Tree.Index, cs: ConsState←$init] RETURNS [Tree.Link];

ExpInit: PROC [UNCOUNTED ZONE];

ExpReset: PROC;

AdjustBias: PROC [Tree.Link, INTEGER] RETURNS [Tree.Link];

BoolValue: PROC [t: Tree.Link] RETURNS [Tree.Link] = INLINE {

ComputeIndexRegs: PROC [Tree.Index] RETURNS [RegCount];

Exp: PROC [Tree.Link, Repr] RETURNS [Tree.Link];

FillMultiWord: PROC [words: ValueDescriptor, origin: CARDINAL, t: Tree.Link];

ForceType: PROC [Tree.Link, CSEIndex] RETURNS [Tree.Link];

LiteralAttr: PROC [Repr] RETURNS [Attr];

MakeStructuredLiteral: PROC [val: WORD, type: CSEIndex] RETURNS [Tree.Link];

NeutralExp: Tree.Map;

OperandType: PROC [Tree.Link] RETURNS [CSEIndex];

RegsForType: PROC [CSEIndex] RETURNS [RegCount];

RValue: PROC [exp: Tree.Link, bias: INTEGER, target: Repr] RETURNS [Tree.Link];

VAttr: PROC RETURNS [Attr];

VBias: PROC RETURNS [INTEGER];

VPop: PROC;

VProp: PROC RETURNS [Prop];

VPush: PROC [bias: INTEGER, attr: Attr, nRegs: RegCount];

VRegs: PROC RETURNS [RegCount];

VRep: PROC RETURNS [Repr];

AddrOp: PROC [Tree.Index] RETURNS [Tree.Link];

ConstantInterval: PROC [Tree.Index] RETURNS [origin, range: INTEGER];

Interval: PROC [Tree.Index, INTEGER, Repr] RETURNS [const: BOOL];

Nil: PROC [Tree.Index] RETURNS [Tree.Link];

NormalizeRange: PROC [Tree.Link] RETURNS [Tree.Link];

MiscXfer: PROC [Tree.Index] RETURNS [Tree.Link];

TypeOp: PROC [Tree.Index] RETURNS [Tree.Link];

EmptyInterval: SIGNAL;

}.