
    <<EDIFSemantics.Mesa>>
        <<Spreitzer, February 24, 1986 11:31:11 pm PST>>

    DIRECTORY EDIFfing, EDIFGrammar, HashTable, Rope;

    EDIFSemantics: CEDAR DEFINITIONS
        IMPORTS Rope
        = {OPEN EDIFGrammar, EDIFfing;

        SyntaxError: SIGNAL [
            pt: ParseTree,
            msg: ROPE,
            severity: Severity _ error
            ];

        Severity: TYPE = {warning, error};

        LORA: TYPE = LIST OF REF ANY;
        REFINT: TYPE = REF INT;

        MacroDef: TYPE = REF MacroDefPrivate;
        MacroDefPrivate: TYPE = RECORD [
            requiredFormals, optionalFormals, extraFormals: IdPtList _ NIL,
            okToSkipTail: BOOL _ FALSE,
            generators: ParseTreeGeneratorList _ NIL,
            comments: LIST OF LIST OF ROPE _ NIL
            ];

        IdPtList: TYPE = LIST OF IdPt;
        IdPt: TYPE = REF identifier ParseTreePrivate;

        ParseTreeGeneratorList: TYPE = LIST OF ParseTreeGenerator;
        ParseTreeGenerator: TYPE = REF ParseTreeGeneratorPrivate;
        ParseTreeGeneratorPrivate: TYPE = RECORD [
            quaPT: ParseTree,
            variant: SELECT type: ParseTreeGeneratorType FROM
                literal => [pt: ParseTree],
                name => [id: ATOM],
                buildList => [elts: ParseTreeGeneratorList],
                buildName => [id: ATOM],
                forEach => [domain: ATOMList, range: ParseTreeGeneratorList],
                index => [var: ATOM],
                ENDCASE
            ];

        ParseTreeGeneratorType: TYPE = {literal, name, buildList, buildName, forEach, index};

        Semantics: TYPE = REF SemanticsPrivate;
        SemanticsPrivate: TYPE = RECORD [
            Before: Beforer _ NIL,
            After: Afterer _ NIL,
            PerSubResult: SubResultConsumer _ NIL,
            HandleSpecially: SpecialHandler _ NIL,
            FilterResult: ResultFilter _ NIL
            ];

        Beforer: TYPE = PROC [parentContext: REF ANY, selfTree: ParseTree] RETURNS [context: REF ANY _ NIL];
        Afterer: TYPE =
            PROC [
                parentContext, context: REF ANY,
                selfTree: ParseTree,
                SetLevel: PROC [
                    <<ups=1 sets level in construct containing this, and no more.>>
                DefineMacro: PROC [name: ATOM, def: MacroDef]
                ]
            RETURNS [result: REF ANY _ NIL];

        SubResultConsumer: TYPE = PROC [parentContext, context, result: REF ANY, index: INT, subTree: ParseTree];
            <<index=1 for first thing seen = first thing after keyword.>>

        ResultFilter: TYPE = PROC [subResult: REF ANY, subRule: Rule, nc: NamingContext] RETURNS [result: REF ANY];

        ResultOffTail: PROC = INLINE {};

        SpecialHandler: TYPE = PROC [ptl: ParseTreeList, parentTree: ParseTree, r, repeatSub: Rule, level: Level, onces: Onces, 
        description: ROPE, sem: Semantics, context: REF ANY, SetLevel: PROC [        ConsumeResult: PROC [res: REF ANY, pt: ParseTree], nc: NamingContext, keyword: ATOM] RETURNS [match: BOOL, ptail: 
        ParseTreeList, result: REF ANY, lastWasStar: BOOL];

        TreeWork: PROC [ptl: ParseTreeList, parentTree: ParseTree, r, repeatSub: Rule, level: Level, onces: Onces, okToFail: BOOL, 
        description: ROPE, sem: Semantics, context: REF ANY, SetLevel: PROC [        ConsumeResult: PROC [res: REF ANY, pt: ParseTree], nc: NamingContext] RETURNS [match: BOOL, ptail: ParseTreeList, result: 
        REF ANY];

        Onces: TYPE = HashTable.Table;

        NamingContext: TYPE = REF NamingContextPrivate;
        NamingContextPrivate: TYPE = RECORD [
            parent: NamingContext _ NIL,
            class: NamingContextClass,
            data: REF ANY _ NIL];

        NamingContextClass: TYPE = REF NamingContextClassPrivate;
        NamingContextClassPrivate: TYPE = RECORD [
            Lookup: PROC [nc: NamingContext, name: ATOM] RETURNS [found: BOOL, value: REF ANY],
            Define: PROC [nc: NamingContext, name: ATOM, value: REF ANY, re: BOOL _ FALSE]
            ];

        Lookup: PROC [nc: NamingContext, name: ATOM] RETURNS [found: BOOL, value: REF ANY];
        Define: PROC [nc: NamingContext, name: ATOM, value: REF ANY, re: BOOL _ FALSE];

        CreateHashTableNamingContext: PROC [parent: NamingContext _ NIL] RETURNS [nc: NamingContext];

        DiscardResult: PROC [res: REF ANY, pt: ParseTree];

        SS: PROC [category: ATOM, semp: SemanticsPrivate];

        Traverse: PROC [pt: ParseTree, r: Rule, level: Level, description: ROPE, context: REF ANY _ NIL, macros: HashTable.Table _ NIL, nc: 
        NamingContext _ NIL] RETURNS [match: BOOL, result: REF ANY _ NIL];

        AtomNameEq: PROC [n1, n2: ATOM] RETURNS [BOOL];
        RopeNameEq: PROC [n1, n2: ROPE] RETURNS [eq: BOOL]
            = INLINE {eq _ Rope.Equal[n1, n2, FALSE]};

        MakeAtomDict: PROC RETURNS [dict: HashTable.Table];
        MakeRopeDict: PROC RETURNS [dict: HashTable.Table];

        }.