Copyright © 1985 by Xerox Corporation. All rights reserved.

Satterthwaite, April 11, 1986 10:11:47 am PST

Maxwell, August 1, 1983 12:46 pm

Paul Rovner, September 7, 1983 5:57 pm

Russ Atkinson (RRA) March 6, 1985 10:16:28 pm PST

Alloc: TYPE USING [Notifier],

BcdDefs: TYPE USING [Link, ModuleIndex],

Literals: TYPE USING [LitDescriptor],

PrincOpsUtils: TYPE USING [BITAND],

Symbols: TYPE,

Tree: TYPE USING [Index, Link, Map, NodeName, Scan];

OPEN Symbols;

mark: BOOL = FALSE;

ownGfi: BcdDefs.ModuleIndex = 1;

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 = REF WordSeq;

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

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

AssignImports: Tree.Scan;

InitBCD: PROC[Tree.Link];

FinishBCD: Tree.Scan;

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

MatchBCD: PROC RETURNS[BOOL];

ProcessDirectory: Tree.Scan;

ProcessExports: Tree.Map;

ProcessImports: Tree.Scan;

ProcessSymLiterals: PROC;

BiasForType: PROC[Type] RETURNS[INTEGER];

CanonicalType: PROC[Type] RETURNS[Type];

ComparableType: PROC[Type] RETURNS[BOOL];

DeclItem: Tree.Scan;

DeclUpdate: Tree.Map;

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

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

RepForType: PROC[Type] RETURNS[Repr];

SparseRep: PROC[Type] RETURNS[BOOL];

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

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

WordsForType: PROC[Type] RETURNS[WordCount];

VarInit: SIGNAL RETURNS[BOOL];

AssignEntries: PROC[BTIndex];

BitsForType: PROC[Type] 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, Type] RETURNS[Tree.Link];

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

Cover: PROC[lType: Type, lRep: Repr, rType: Type, rRep: Repr] RETURNS[Covering];

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];

ListCons: PUBLIC 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];

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

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

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

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

Rhs: PROC[exp: Tree.Link, lhsType: Type, 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;

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, Type] RETURNS[Tree.Link];

LiteralAttr: PROC[Repr] RETURNS[Attr];

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

NeutralExp: Tree.Map;

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

RegsForType: PROC[Type] 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;

}.