
    <<P5U.mesa>>
        <<Copyright © 1985 by Xerox Corporation.  All rights reserved.>>
        <<Sweet, May 31, 1986 9:57:19 pm PDT>>
        <<Satterthwaite, November 14, 1985 11:43:28 am PST>>
        <<Russ Atkinson (RRA) March 6, 1985 11:07:25 pm PST>>

    DIRECTORY
        Alloc USING [Handle, Notifier],
        CodeDefs USING [ApplyNode, ArithTypeIndex, BlockNode, ChunkIndex, CodeList, OpWordCount, VLoc, WordSize],
        IntCodeDefs USING [ArithSelector, CaseList, CedarSelector, Comparator, Count, Label, Location, LogicalId, MesaSelector, Node, 
        NodeList, NullVariableId, Var, VarList],
        SourceMap USING [Loc],
        Symbols USING [BitAddress, BitCount, CSEIndex, CTXIndex, ISEIndex, RecordSEIndex, SEIndex, typeANY],
        Tree USING [Index, Link];

    P5U: DEFINITIONS = { OPEN Symbols, IntCodeDefs, CodeDefs;

        CgenUtilNotify: Alloc.Notifier;

        AdjustLoc: PROC [vl: VLoc, rSei: Symbols.RecordSEIndex, fSei: Symbols.ISEIndex, tBits: BitCount] RETURNS [VLoc];
        AllocLabel: PUBLIC PROC [id: LogicalId _ 0] RETURNS [Label];
        ApplyOp: PROC [oper: Node, args: NodeList, bits: Count _ 0] RETURNS [l: ApplyNode];
        ArithTypeForTree: PROC [node: Tree.Index] RETURNS [ati: ArithTypeIndex];
        ArithOp: PROC [op: ArithSelector, ati: ArithTypeIndex] RETURNS [l: Node];
        ArithOpForTree: PROC [node: Tree.Index, op: ArithSelector] RETURNS [l: Node];
        Bits: PROC [ba: BitAddress] RETURNS [INT];
        BitsForOperand: PROC [t: Tree.Link] RETURNS [CARDINAL];
        BitsForType: PROC [sei: SEIndex] RETURNS [CARDINAL];
        BoundsCheck: PROC [exp, bound: Node] RETURNS [Node];
        CedarOpNode: PROC [op: CedarSelector] RETURNS [l: Node];
        CgenUtilInit: PROC [ownTable: Alloc.Handle];
        CJump: PROC [cl: CodeList, test: Comparator, op1, op2: Node, ati: ArithTypeIndex, target: Label];
        CompareOp: PROC [sense: Comparator, ati: ArithTypeIndex] RETURNS [l: Node];
        CompareOpForTree: PROC [node: Tree.Index, sense: Comparator] RETURNS [l: Node];
        ConvertOpNode: PROC [from, to: ArithTypeIndex] RETURNS [l: Node];
        CreateTemp: PROC [bits: BitCount, type: SEIndex _ typeANY] RETURNS [var: Var,  sei: ISEIndex];
        Declare: PROC [cl: CodeList, var: Var, init: Node _ NIL];
        Deref: PROC [n: Node, bits: Count] RETURNS [v: Var];
        DoAssign: PROC [cl: CodeList, lhs: Var, rhs: Node];
        EnumerateCaseArms: PROC [node: Tree.Index, action: PROC [t: Tree.Link]];
        ExtractList: PROC [cl: CodeList] RETURNS [nl: NodeList];
        FormalVar: PROC [bits: BitCount] RETURNS [v: Var];
        FreeChunk: PROC [i: CodeDefs.ChunkIndex, size: CARDINAL];
        FullWordBits: PROC [bits: BitCount] RETURNS [BitCount];
        GetChunk: PROC [size: CARDINAL] RETURNS [c: CodeDefs.ChunkIndex];
        InsertLabel: PROC [cl: CodeList, lbl: Label];
        Jump: PROC [cl: CodeList, target: Label];
        MakeBlock: PROC [cl: CodeList, bits: BitCount _ 0] RETURNS [n: BlockNode];
        MakeCaseList: PROC [tests: NodeList, body: Node, rest: CaseList _ NIL] RETURNS [CaseList];
        MakeLongTreeLiteral: PROC [d: DESCRIPTOR FOR ARRAY OF WORD, type: CSEIndex] RETURNS [Tree.Link];
        MakeNodeList: PROC [first: Node, last: NodeList _ NIL] RETURNS [NodeList];
        MakeNodeList2: PROC [first, second: Node] RETURNS [NodeList];
        MakeNodeLiteral: PROC [val: INT] RETURNS [Node];
        MakeTemp: PROC [cl: CodeList, bits: BitCount, init: Node _ NIL, type: SEIndex _ typeANY] RETURNS [var: Var,  sei: ISEIndex];
        MakeTreeLiteral: PROC [val: WORD] RETURNS [Tree.Link];
        MakeVar: PROC [bits: Count, id: LogicalId _ NullVariableId, loc: Location] RETURNS [var: Var];
        MakeVarList: PROC [first: Var, last: VarList _ NIL] RETURNS [VarList];
        MakeVarList2: PROC [first, second: Var] RETURNS [VarList];
        MarkedType: PROC [SEIndex] RETURNS [CSEIndex];
        MaybeBlock: PROC [cl: CodeList, l: Node] RETURNS [b: Node];
        MesaOpNode: PROC [op: MesaSelector] RETURNS [l: Node];
        MoreCode: PROC [cl: CodeList, n: Node];
        NewCodeList: PROC RETURNS [CodeList];
        NextVar: PROC [sei: ISEIndex] RETURNS [ISEIndex];
        NilTree: PROC [type: CSEIndex] RETURNS [Tree.Link];
        OperandType: PROC [t: Tree.Link] RETURNS [sei: CSEIndex];
        OutSource: PROC [cl: CodeList, index: SourceMap.Loc];
        PrevVar: PROC [ssei, sei : ISEIndex] RETURNS [ISEIndex];
        ProcessSafens: PROC [cl: CodeList, t: Tree.Link, ignore: BOOL _ FALSE] RETURNS [nt: Tree.Link];
        PushLitVal: PROC [v: UNSPECIFIED];
        ReferentType: PROC [type: SEIndex] RETURNS [SEIndex];
        SignExtend: PROC [n: Node, to: BitCount _ WordSize] RETURNS [Node];
        TakeField: PUBLIC PROC [n: Node, vl: VLoc] RETURNS [nv: Var];
        TakeVField: PROC [vl: VLoc, disp: INT, size: BitCount] RETURNS [VLoc];
        TreeLiteral: PROC [t: Tree.Link] RETURNS [BOOL];
        TreeLiteralValue: PROC [t: Tree.Link] RETURNS [WORD];
        TypeForTree: PROC [t: Tree.Link] RETURNS [SEIndex];
        VariantTag: PROC [type: SEIndex, ctx: CTXIndex] RETURNS [WORD];
        WordAligned: PROC [tsei: RecordSEIndex] RETURNS [BOOL];
        WordsForBits: PROC [b: INT] RETURNS [INT];
        WordsForOperand: PROC [t: Tree.Link] RETURNS [OpWordCount];
        WordsForSei: PROC [sei: SEIndex] RETURNS [OpWordCount];
        WordsForString: PROC [nChars: CARDINAL] RETURNS [CARDINAL];
        ZeroExtend: PROC [n: Node, to: BitCount _ WordSize] RETURNS [cvt: Node]
        }.