<<>>
<<Pass3S.mesa>>
    <<Copyright Ó 1985, 1986, 1987, 1990, 1991 by Xerox Corporation.  All rights reserved.>>
    <<Satterthwaite, June 18, 1986 12:29:52 pm PDT>>
    <<Russ Atkinson (RRA) February 5, 1990 7:21:57 pm PST>>
    <<>>
    DIRECTORY
        Alloc USING [Notifier],
        MimData USING [bodyIndex, idANY, idBOOL, monitored, ownSymbols, textIndex],
        MimosaLog USING [Error, ErrorSei, ErrorTree, ErrorTreeOp, ErrorType, Warning, WarningTree],
        MimP3 USING [And, Apply, Assignment, Attr, BoundNP, BumpCount, CheckDisjoint, checkedANY, ClearRefStack, ClearType, CloseBase, 
        CopyLock, DeclList, Discrimination, EnterComposite, EnterType, Exp, Extract, FieldDefault, FindLockParams, FirstId, 
        InsertCatchLabel, lockNode, LockVar, MatchFields, MiscStmt, NPUse, OpenBase, phraseNP, PopCtx, PushCtx, Range, RAttr, 
        RAttrPop, RecordMention, Rhs, RPop, RPush, RType, Safety, SealRefStack, SequenceNP, UnsealRefStack, UpdateTreeAttr, UType, 
        voidAttr],
        MimP3S USING [BodyData, ImplicitInfo, implicit],
        Pass3Attributes USING [CanonicalType, DefaultInit, IdentifiedType, LhsMode, OperandLhs, TargetType, Voidable],
        SourceMap USING [Loc, nullLoc, Up],
        SymbolOps USING [CopyBasicType, CtxLevel, EncodeCard, EncodeTreeIndex, EncodeType, FirstCtxSe, FromType, NextSe, own, RCType, 
        SetCtxLevel, ToBti, ToCtx, TransferTypes, TypeForm, UnderType],
        Symbols USING [Base, bodyType, BTIndex, BTNull, CBTIndex, ContextLevel, CSEIndex, CSENull, CTXIndex, CTXNull, ctxType, HTNull, 
        ISEIndex, ISENull, lG, mdType, RecordSEIndex, RecordSENull, RootBti, seType, Type, typeANY],
        SymLiteralOps USING [DescribeRefLits],
        Tree USING [Base, Index, Link, Map, NodeName, Null, Scan, nullId, nullIndex, treeType],
        TreeOps USING [FreeNode, FromLoc, GetHash, GetNode, GetTag, MakeList, NthSon, OpName, PopTree, PushNode, PushTree, ReverseScanList, 
        ScanList, SetAttr, SetInfo, ToLoc, UpdateList],
        Types USING [Assignable];
Pass3S: PROGRAM
    IMPORTS MimData, MimosaLog, MimP3, MimP3S, Pass3Attributes, SourceMap, SymbolOps, SymLiteralOps, TreeOps, Types
    EXPORTS MimP3, MimP3S = {
    OPEN MimP3, Pass3Attributes, Symbols, TreeOps;

    tb: Tree.Base;    -- tree base address (local copy)
    seb: Symbols.Base;    -- se table base address (local copy)
    ctxb: Symbols.Base;    -- context table base (local copy)
    mdb: Symbols.Base;    -- module table base (local copy)
    bb: Symbols.Base;    -- body table base (local copy)

    StmtNotify: PUBLIC Alloc.Notifier = {
        <<called by allocator whenever table area is repacked>>
        tb Ź base[Tree.treeType];
        seb Ź base[seType];
        ctxb Ź base[ctxType];
        mdb Ź base[mdType];
        bb Ź base[bodyType];
        };
<<parameter usage>>
    pathNP: PUBLIC NPUse Ź none;
<<bodies and blocks>>
    currentBody: PUBLIC MimP3S.BodyData;
    current: POINTER TO MimP3S.BodyData = @currentBody;

    currentScope: PUBLIC BTIndex Ź BTNull;
    safety: PUBLIC Safety Ź none;
    exits: BOOL;

    BodyList: PUBLIC PROC [firstBti: BTIndex] = {
        bti: BTIndex Ź firstBti;
        IF bti # BTNull THEN
            DO
                WITH b: bb[bti] SELECT FROM
                    Callable => IF b.kind # Catch THEN Body[LOOPHOLE[bti, CBTIndex]];
                    ENDCASE;
                IF bb[bti].link.which = parent THEN EXIT;
                bti Ź bb[bti].link.index;
                ENDLOOP;
        };

    Body: PROC [bti: CBTIndex] = {
        saved: MimP3S.BodyData = current­;
        saveIndex: SourceMap.Loc = MimData.textIndex;
        saveBodyIndex: CBTIndex = MimData.bodyIndex;
        saveScope: BTIndex = currentScope;
        saveSafety: Safety = safety;
        node: Tree.Index;
        lockVar: ISEIndex;
        lockBit: BOOL;
        inRecord, outRecord, bType: RecordSEIndex;
        argLevel: ContextLevel;
        MimData.bodyIndex Ź currentScope Ź bti;
        MimData.textIndex Ź SourceMap.Up[bb[bti].sourceIndex];
        current.bodyNode Ź node Ź WITH bb[bti].info SELECT FROM
            Internal => bodyTree,
            ENDCASE => ERROR;
        current.level Ź bb[bti].level;
        current.entry Ź bb[bti].entry;
        SetSafety[SafetyAttr[node]];
        bb[bti].resident Ź FALSE;
        current.lockHeld Ź bb[bti].entry OR bb[bti].internal;
        argLevel Ź IF bti = RootBti THEN lG ELSE current.level;
        IF bb[bti].ioType # typeANY THEN seb[bb[bti].ioType].mark4 Ź FALSE;
        [inRecord, outRecord] Ź SymbolOps.TransferTypes[SymbolOps.own, bb[bti].ioType];
        IF inRecord = RecordSENull
            THEN current.argCtx Ź CTXNull
            ELSE {
                current.argCtx Ź seb[inRecord].fieldCtx;
                SymbolOps.SetCtxLevel[current.argCtx, argLevel];
                IF argLevel = lG THEN EnterTypes[current.argCtx];
                };
        IF outRecord # RecordSENull THEN {
            SymbolOps.SetCtxLevel[seb[outRecord].fieldCtx, argLevel];
            IF argLevel = lG THEN EnterTypes[seb[outRecord].fieldCtx];
            };
        PushArgCtx[current.inputRecord Ź inRecord];  SetArgRefs[inRecord, 1];
        PushArgCtx[current.returnRecord Ź outRecord];  SetArgRefs[outRecord, 0];
        ClearRefStack[];
        <<initialize computed attributes>>
            current.labelList Ź Tree.Null;
            current.loopDepth Ź 0;
            current.catchDepth Ź 0;
            current.unwindEnabled Ź FALSE;
            current.resumeRecord Ź RecordSENull;
            current.resumeFlag Ź FALSE;
        IF ~current.entry
            THEN pathNP Ź none
            ELSE {
                IF (lockVar Ź FindLockParams[].actual) # ISENull THEN {
                    lockBit Ź seb[lockVar].immutable;
                    seb[lockVar].immutable Ź TRUE;
                    };
                tb[node].son[4] Ź CopyLock[];
                pathNP Ź phraseNP;
                };
        {
            ENABLE InsertCatchLabel => {MimosaLog.Error[catchLabel]; RESUME};
            outInit: Tree.Link Ź Tree.Null;
            ScanList[tb[node].son[1], OpenItem];
            current.noXfers Ź TRUE;
            IF inRecord # RecordSENull THEN
                CheckDisjoint[current.argCtx, bb[bti].localCtx];
            IF outRecord # RecordSENull THEN {
                CheckDisjoint[seb[outRecord].fieldCtx, bb[bti].localCtx];
                outInit Ź AssignDefaults[seb[outRecord].fieldCtx, bb[bti].inline];
                };
            PushCtx[bb[bti].localCtx];
            IF bti = RootBti AND MimData.monitored THEN {
                PushCtx[SymbolOps.ToCtx[tb[MimP3.lockNode].info]];
                DeclList[tb[MimP3.lockNode].son[1]];
                IF (lockVar Ź SymbolOps.FirstCtxSe[SymbolOps.own, SymbolOps.ToCtx[tb[MimP3.lockNode].info]]) # ISENull THEN 
                    BumpCount[lockVar];
                tb[MimP3.lockNode].son[2] Ź LockVar[tb[MimP3.lockNode].son[2]];
                PopCtx[];
                ClearRefStack[FALSE];
                };
            DeclList[tb[node].son[2]];
            IF outInit # Tree.Null THEN {
                PushTree[outInit];  PushTree[tb[node].son[2]];
                PushNode[initlist, 2];  SetInfo[FromLoc[MimData.textIndex]];
                tb[node].son[2] Ź PopTree[];
                };
            };
        bType Ź bb[bti].type;
        IF bType # RecordSENull THEN {
            IF bti = RootBti THEN {
                EnterTypes[seb[bType].fieldCtx];
                FOR sei: ISEIndex Ź SymbolOps.FirstCtxSe[SymbolOps.own, seb[bType].fieldCtx], SymbolOps.NextSe[SymbolOps.own, sei]
                UNTIL sei = ISENull DO
                    IF ~seb[sei].constant
                    AND SymbolOps.RCType[SymbolOps.own, SymbolOps.UnderType[SymbolOps.own, seb[sei].idType]] # none THEN {
                        seb[bType].hints.refField Ź TRUE;
                        EnterType[bType];
                        EXIT;
                        }
                    ENDLOOP;
                };
            seb[bType].mark3 Ź TRUE;
            };
        current.reachable Ź TRUE;
        tb[node].son[3] Ź UpdateList[tb[node].son[3], Stmt
            ! InsertCatchLabel => {IF ~catchSeen THEN MimosaLog.Error[catchLabel]; RESUME}];
        IF current.reachable THEN tb[node].son[3] Ź ImpliedReturn[tb[node].son[3]];
        BodyList[bb[bti].firstSon];
        PopCtx[];
        ReverseScanList[tb[node].son[1], CloseItem];
        bb[bti].noXfers Ź current.noXfers;
        bb[bti].hints Ź [
            safe: pathNP <= ref,
            argUpdated: inRecord # RecordSENull AND ctxb[seb[inRecord].fieldCtx].varUpdated,
            nameSafe: pathNP # unsafe,
            noStrings: ];
        PopArgCtx[outRecord];  PopArgCtx[inRecord];
        IF bti = RootBti AND SymLiteralOps.DescribeRefLits[].length # 0 THEN {
            rSei: RecordSEIndex = bb[bti].type;
            seb[rSei].hints.refField Ź TRUE;
            EnterType[rSei];
            };
        IF current.entry AND lockVar # ISENull THEN seb[lockVar].immutable Ź lockBit;
        current­ Ź saved;
        currentScope Ź saveScope;
        SetSafety[saveSafety];
        MimData.bodyIndex Ź saveBodyIndex;
        MimData.textIndex Ź saveIndex;
        };

    Scope: PUBLIC PROC [node: Tree.Index, body: Tree.Map] = {
        bti: BTIndex = SymbolOps.ToBti[tb[node].info];
        saveIndex: SourceMap.Loc = MimData.textIndex;
        saveScope: BTIndex = currentScope;
        MimData.textIndex Ź SourceMap.Up[bb[bti].sourceIndex];
        currentScope Ź bti;
        PushCtx[bb[bti].localCtx];
        DeclList[tb[node].son[1] ! InsertCatchLabel => {MimosaLog.Error[catchLabel]; RESUME}];
        IF bb[bti].type # RecordSENull THEN seb[bb[bti].type].mark3 Ź TRUE;
        tb[node].son[2] Ź body[tb[node].son[2]];
        BodyList[bb[bti].firstSon];
        PopCtx[];
        currentScope Ź saveScope;
        MimData.textIndex Ź saveIndex;
        };

    PushArgCtx: PROC [rSei: RecordSEIndex] = INLINE {
        IF rSei # RecordSENull THEN PushCtx[seb[rSei].fieldCtx];
        };

    PopArgCtx: PROC [rSei: RecordSEIndex] = INLINE {
        IF rSei # RecordSENull THEN PopCtx[];
        };

    SetArgRefs: PROC [rSei: RecordSEIndex, nRefs: NAT] = {
        IF rSei # RecordSENull THEN {
            seb[rSei].mark4 Ź FALSE;
            FOR sei: ISEIndex Ź SymbolOps.FirstCtxSe[SymbolOps.own, seb[rSei].fieldCtx], SymbolOps.NextSe[SymbolOps.own, sei]
            UNTIL sei = ISENull DO
                IF seb[sei].mark4 THEN {
                    seb[sei].idValue Ź SymbolOps.EncodeTreeIndex[Tree.nullIndex];
                    seb[sei].mark4 Ź FALSE;
                    };
                seb[sei].idInfo Ź SymbolOps.EncodeCard[nRefs];
                ENDLOOP;
            };
        };

    EnterTypes: PROC [ctx: CTXIndex] = {
        FOR sei: ISEIndex Ź SymbolOps.FirstCtxSe[SymbolOps.own, ctx], SymbolOps.NextSe[SymbolOps.own, sei] UNTIL sei = ISENull DO
            ut: Type = SymbolOps.UnderType[SymbolOps.own, seb[sei].idType];
            IF SymbolOps.RCType[SymbolOps.own, ut] = composite THEN EnterType[ut];
            ENDLOOP;
        };

    AssignDefaults: PUBLIC PROC [ctx: CTXIndex, copyable: BOOL] RETURNS [Tree.Link] = {
        n: INTEGER Ź 0;
        FOR sei: ISEIndex Ź SymbolOps.FirstCtxSe[SymbolOps.own, ctx], SymbolOps.NextSe[SymbolOps.own, sei] UNTIL sei = ISENull DO
            IF seb[sei].hash # Symbols.HTNull OR seb[sei].extended THEN {
                t: Tree.Link =
                    IF seb[sei].extended THEN FieldDefault[sei] ELSE DefaultInit[seb[sei].idType];
                        <<note: pushes onto the R-stack>>
                IF t = Tree.Null
                    THEN {
                        IF ~Voidable[seb[sei].idType] THEN MimosaLog.ErrorSei[missingInit, sei];
                        }
                    ELSE {
                        lhs: Tree.Link = [symbol[sei]];
                        mode: LhsMode;
                        RecordMention[sei];
                        mode Ź OperandLhs[lhs];
                        PushTree[lhs];  PushTree[t];  PushNode[assign, 2];
                        SetInfo[FromLoc[MimData.textIndex]];  SetAttr[1, TRUE];
                        IF mode # counted
                            THEN SetAttr[2, FALSE]
                            ELSE {
                                type: Type = seb[sei].idType;
                                SELECT SymbolOps.RCType[SymbolOps.own, type] FROM
                                    simple => {SetAttr[2, OpName[t] # nil]; SetAttr[3, FALSE]};
                                    composite => {
                                        SetAttr[2, TRUE];
                                        SetAttr[3, TRUE];
                                        EnterComposite[type, t, TRUE];
                                        };
                                    ENDCASE => SetAttr[2, FALSE];
                                };
                        <<<<RRA: Why is this test here?  It does not seem to be doing any good, and leads to error messages in places that do not appear to 
                        be wrong!>>>>
                        <<IF seb[sei].hash = HTNull AND copyable THEN>>
                            <<MimosaLog.ErrorSei[defaultForm, sei];>>
                        n Ź n+1;
                        pathNP Ź SequenceNP[pathNP][phraseNP];
                        ClearRefStack[];
                        };
                RPop[];
                };
            ENDLOOP;
        RETURN [MakeList[n]];
        };

    SafetyAttr: PUBLIC PROC [node: Tree.Index] RETURNS [Safety] = {
        RETURN [SELECT TRUE FROM
            tb[node].attr1 => checked,
            tb[node].attr2 => asserted,
            ENDCASE => none]
        };

    SetSafety: PUBLIC PROC [new: Safety] = {
        IF safety # new THEN {
            SELECT new FROM
                checked => {
                    IF MimP3.checkedANY = CSENull THEN
                        MimP3.checkedANY Ź SymbolOps.CopyBasicType[typeANY];
                    seb[MimData.idANY].idInfo Ź SymbolOps.EncodeType[MimP3.checkedANY];
                    };
                ENDCASE =>
                    seb[MimData.idANY].idInfo Ź SymbolOps.EncodeType[typeANY];
            safety Ź new;
            }
        };
<<statements>>
    continued: PUBLIC BOOL Ź FALSE;
    markCatch: PUBLIC BOOL Ź FALSE;

    SourceSeen: SIGNAL [index: SourceMap.Loc] = CODE;
    sourceBreak: SourceMap.Loc Ź SourceMap.nullLoc;

    Stmt: PUBLIC PROC [stmt: Tree.Link] RETURNS [val: Tree.Link] = {
        saveIndex: SourceMap.Loc = MimData.textIndex;
        saveMark: BOOL = markCatch;
        saveContinued: BOOL = continued;
        IF stmt = Tree.Null THEN RETURN [Tree.Null];
        WITH stmt SELECT GetTag[stmt] FROM
            subtree => {
                node: Tree.Index Ź index;
                name: Tree.NodeName Ź tb[node].name;
                fIndex: SourceMap.Loc Ź MimData.textIndex Ź ToLoc[tb[node].info];
                IF tb[node].free THEN ERROR;
                IF fIndex = sourceBreak AND fIndex # SourceMap.nullLoc THEN
                    <<For debugging down to the statement level>>
                    SIGNAL SourceSeen[fIndex];
                IF ~current.reachable AND tb[node].name # list THEN {
                    MimosaLog.Warning[unreachable];
                    current.reachable Ź TRUE;
                    };
                val Ź stmt;        -- the default
                markCatch Ź continued Ź FALSE;
                SELECT name FROM

                    assign => {
                        Assignment[node];
                        RPop[];
                        pathNP Ź SequenceNP[pathNP][phraseNP];
                        };

                    extract => {
                        Extract[node];
                        RPop[];
                        pathNP Ź SequenceNP[pathNP][phraseNP];
                        };

                    apply => {
                        node Ź Apply[node, typeANY, TRUE];
                        val Ź [subtree[node]];
                        SELECT tb[node].name FROM
                            wait => MimosaLog.ErrorTree[typeClash, tb[node].son[1]];
                            error => current.reachable Ź FALSE;
                            ENDCASE;
                        SELECT RType[] FROM
                            CSENull, typeANY => NULL;
                            ENDCASE => MimosaLog.Error[nonVoidStmt];
                        RPop[];
                        pathNP Ź SequenceNP[pathNP][phraseNP];
                        };

                    block => {
                        saveSafety: Safety = safety;
                        SetSafety[SafetyAttr[node]];
                        IF saveSafety = checked AND safety = none THEN MimosaLog.Error[unsafeBlock];
                        Scope[node, Stmt];
                        SetSafety[saveSafety];
                        };

                    if => {
                        saveReachable: BOOL;
                        entryNP, saveNP: NPUse;
                        tb[node].son[1] Ź Rhs[tb[node].son[1], MimData.idBOOL];  RPop[]; 
                        pathNP Ź entryNP Ź SequenceNP[pathNP][phraseNP];  ClearRefStack[];
                        tb[node].son[2] Ź UpdateList[tb[node].son[2], Stmt];
                        saveReachable Ź current.reachable;  saveNP Ź pathNP;
                        current.reachable Ź TRUE;  pathNP Ź entryNP;
                        tb[node].son[3] Ź UpdateList[tb[node].son[3], Stmt];
                        IF saveReachable THEN current.reachable Ź TRUE;
                        pathNP Ź BoundNP[saveNP][pathNP];
                        };

                    case, bind => {
                        saveNP: NPUse = pathNP;
                        Selection: Tree.Map = {
                            current.reachable Ź TRUE;
                            pathNP Ź SequenceNP[saveNP][phraseNP];
                            v Ź Stmt[t];
                            IF current.reachable THEN newReachable Ź TRUE;
                            newNP Ź BoundNP[newNP][pathNP];
                            };
                        newReachable: BOOL Ź FALSE;
                        newNP: NPUse Ź none;
                        IF name = case THEN Case[node, Selection] ELSE Discrimination[node, Selection];
                        RPop[];
                        current.reachable Ź newReachable;
                        pathNP Ź newNP;
                        };

                    do => DoStmt[node];

                    label => {
                        son2: Tree.Link Ź tb[node].son[2];
                        InsertLabels[son2];
                        tb[node].son[1] Ź UpdateList[tb[node].son[1], Stmt];
                        DeleteLabels[son2];
                        LabelList[son2];
                        };

                    goto => {
                        ValidateLabel[tb[node].son[1]];
                        current.reachable Ź FALSE;
                        };

                    return => Return[node];

                    exit, loop => {
                        IF tb[node].name = exit THEN exits Ź TRUE;
                        IF current.loopDepth = 0 THEN MimosaLog.Error[exit];
                        current.reachable Ź FALSE;
                        };

                    null => NULL;
                    syserror => current.reachable Ź FALSE;

                    open => {
                        ScanList[tb[node].son[1], OpenItem];
                        tb[node].son[2] Ź UpdateList[tb[node].son[2], Stmt];
                        ReverseScanList[tb[node].son[1], CloseItem];
                        };

                    checked => { 
                        saveSafety: Safety = safety;
                        SetSafety[SafetyAttr[node]];
                        IF saveSafety = checked AND safety = none THEN MimosaLog.Error[unsafeBlock];
                        tb[node].son[1] Ź Stmt[tb[node].son[1]];
                        SetSafety[saveSafety];
                        };

                    list => val Ź UpdateList[val, Stmt];
                    ENDCASE => val Ź MiscStmt[node];
                };

            ENDCASE => ERROR;
        IF markCatch THEN {
            PushTree[val];
            PushNode[catchmark, 1];
            SetInfo[FromLoc[MimData.textIndex]];
            val Ź PopTree[];
            IF continued THEN current.reachable Ź TRUE;
            pathNP Ź unsafe;
            };
        markCatch Ź saveMark;
        continued Ź saveContinued;
        ClearRefStack[];
        MimData.textIndex Ź saveIndex;
        };
<<case driver>>
    Case: PUBLIC PROC [node: Tree.Index, selection: Tree.Map] = {
        saveImplicit: MimP3S.ImplicitInfo = MimP3S.implicit;
        entryNP: NPUse;
        attr: Attr;
        eqTests: BOOL;
        CaseItem: Tree.Scan = {
            switchable: BOOL Ź FALSE;
            saveIndex: SourceMap.Loc = MimData.textIndex;
            CaseTest: Tree.Map = {
                IF t # Tree.Null THEN WITH e: t SELECT GetTag[t] FROM
                    subtree => {
                        node: Tree.Index = e.index;
                        SELECT tb[node].name FROM
                            relE => {
                                son2: Tree.Link Ź tb[node].son[2]
                                Ź Rhs[tb[node].son[2], TargetType[MimP3S.implicit.type]];
                                type: Type Ź RType[];
                                tb[node].info Ź SymbolOps.FromType[MimData.idBOOL];
                                SELECT SymbolOps.TypeForm[SymbolOps.own, type] FROM
                                    $real => {tb[node].attr1 Ź TRUE; tb[node].attr2 Ź FALSE};
                                    ENDCASE => {
                                        IF OpName[son2] = shorten THEN
                                            MimosaLog.ErrorTree[typeClash, NthSon[son2, 1]];
                                        tb[node].attr1 Ź tb[node].attr2 Ź FALSE;
                                        };
                                switchable Ź switchable AND RAttr[].const;
                                v Ź t;
                                };
                            ENDCASE => {
                                v Ź Rhs[t, MimData.idBOOL];
                                eqTests Ź switchable Ź FALSE;
                                };
                        attr Ź And[RAttrPop[], attr];
                        entryNP Ź SequenceNP[entryNP][phraseNP];
                        };
                    ENDCASE;
                };
            IF t # Tree.Null THEN WITH e: t SELECT GetTag[t] FROM
                subtree => {
                    node: Tree.Index = e.index;
                    IF OpName[tb[node].son[1]] = decl
                        THEN {
                            bti: BTIndex = SymbolOps.ToBti[tb[node].info];
                            Item: Tree.Map = {phraseNP Ź entryNP; v Ź selection[t]};
                            MimData.textIndex Ź SourceMap.Up[bb[bti].sourceIndex];
                            MimosaLog.Error[discrimForm];
                            switchable Ź FALSE;
                            Scope[node, Item];
                            }
                        ELSE {
                            MimData.textIndex Ź ToLoc[tb[node].info];
                            switchable Ź TRUE;
                            tb[node].son[1] Ź UpdateList[tb[node].son[1], CaseTest];
                            tb[node].attr1 Ź switchable;
                            phraseNP Ź entryNP;
                            tb[node].son[2] Ź selection[tb[node].son[2]];
                            };
                    MimData.textIndex Ź saveIndex;
                    };
                ENDCASE;
            };
        SealRefStack[];
        tb[node].son[1] Ź Exp[tb[node].son[1], typeANY];
        MimP3S.implicit.type Ź CanonicalType[RType[]]; 
        MimP3S.implicit.attr Ź attr Ź RAttrPop[];
        entryNP Ź phraseNP;
        IF ~IdentifiedType[MimP3S.implicit.type] THEN
            MimosaLog.ErrorTreeOp[missingOp, tb[node].son[1], relE];
        MimP3S.implicit.tree Ź tb[node].son[1];
        eqTests Ź TRUE;
        UnsealRefStack[];
        ScanList[tb[node].son[2], CaseItem];
        tb[node].attr1 Ź eqTests;
        tb[node].attr2 Ź attr.const;
        phraseNP Ź entryNP;
        tb[node].son[3] Ź selection[tb[node].son[3]];
        RPush[CSENull, attr];
        MimP3S.implicit Ź saveImplicit;
        };
<<iteration>>
    DoStmt: PROC [node: Tree.Index] = {
        forNode: Tree.Index;
        cvType: Type;
        controlled, block, cvUpdate, newReachable, saveExits: BOOL;
        saveNP, exitNP: NPUse;
        saveScope: BTIndex = currentScope;
        newReachable Ź controlled Ź block Ź cvUpdate Ź FALSE;
        IF tb[node].son[1] # Tree.Null THEN {
            sei: ISEIndex;
            mode: LhsMode;
            forNode Ź GetNode[tb[node].son[1]];
            IF tb[forNode].son[1] = Tree.Null
                THEN {
                    sei Ź ISENull;
                    mode Ź uncounted;
                    cvType Ź typeANY;
                    }
                ELSE {
                    IF OpName[tb[forNode].son[1]] # decl
                        THEN {
                            tb[forNode].son[1] Ź Exp[tb[forNode].son[1], typeANY];
                            IF (mode Ź OperandLhs[tb[forNode].son[1]]) = none THEN
                                MimosaLog.ErrorTree[nonLHS, tb[forNode].son[1]];
                            sei Ź WITH tb[forNode].son[1] SELECT GetTag[tb[forNode].son[1]] FROM 
                                symbol => index,
                                ENDCASE => ISENull;
                            }
                        ELSE {
                            bti: BTIndex = SymbolOps.ToBti[tb[forNode].info];
                            declNode: Tree.Index = GetNode[tb[forNode].son[1]];
                            block Ź TRUE;  currentScope Ź bti;
                            PushCtx[bb[bti].localCtx];
                            DeclList[tb[forNode].son[1]];
                            sei Ź FirstId[declNode];  seb[sei].immutable Ź TRUE;
                            RPush[seb[sei].idType, voidAttr];
                            mode Ź IF SymbolOps.CtxLevel[SymbolOps.own, seb[sei].idCtx] = lG THEN counted ELSE uncounted;
                            };
                    IF sei # ISENull
                        THEN {
                            <<account for implicit refs>>
                            BumpCount[sei];
                            BumpCount[sei];
                            }
                        ELSE MimosaLog.ErrorTree[controlId, tb[forNode].son[1]];
                    cvType Ź TargetType[RType[]];
                    RPop[];
                    };
            SELECT mode FROM
                counted =>
                    SELECT SymbolOps.RCType[SymbolOps.own, cvType] FROM
                        simple => {tb[forNode].attr2 Ź TRUE; tb[forNode].attr3 Ź FALSE};
                        composite => tb[forNode].attr2 Ź tb[forNode].attr3 Ź TRUE;
                        ENDCASE => tb[forNode].attr2 Ź FALSE;
                ENDCASE => tb[forNode].attr2 Ź FALSE;
            SELECT tb[forNode].name FROM
                forseq => {
                    son2: Tree.Link Ź tb[forNode].son[2] Ź Rhs[tb[forNode].son[2], cvType];  RPop[];
                    IF tb[forNode].attr2 AND tb[forNode].attr3 THEN
                        EnterComposite[cvType, tb[forNode].son[2], OpName[tb[forNode].son[1]] = decl];
                    cvUpdate Ź TRUE;
                    };
                upthru, downthru => {
                    son2: Tree.Link Ź tb[forNode].son[2] Ź Range[tb[forNode].son[2], cvType];
                    lType: CSEIndex = SymbolOps.UnderType[SymbolOps.own, cvType];
                    rType: CSEIndex = UType[];
                    controlled Ź TRUE;
                    IF NOT Types.Assignable[
                    [MimData.ownSymbols, lType], [MimData.ownSymbols, rType]] THEN {
                        SELECT SymbolOps.TypeForm[SymbolOps.own, ClearType[lType]] FROM
                            signed, unsigned =>
                                SELECT SymbolOps.TypeForm[SymbolOps.own, ClearType[rType]] FROM
                                    signed, unsigned =>
                                        GO TO matched;
                                    ENDCASE;
                            ENDCASE;
                        MimosaLog.ErrorType[typeClash, son2, [MimData.ownSymbols, cvType]];
                        EXITS matched => {};
                        };
                    RPop[];
                    };
                ENDCASE => ERROR;
            pathNP Ź SequenceNP[pathNP][phraseNP];
            ClearRefStack[];
            };
        saveNP Ź pathNP;  pathNP Ź none;
        IF tb[node].son[2] # Tree.Null THEN {
            controlled Ź TRUE;
            tb[node].son[2] Ź Rhs[tb[node].son[2], MimData.idBOOL];
            RPop[];
            pathNP Ź SequenceNP[pathNP][phraseNP];
            ClearRefStack[];
            };
        ScanList[tb[node].son[3], OpenItem];
        InsertLabels[tb[node].son[5]];
        current.loopDepth Ź current.loopDepth + 1;
        saveExits Ź exits;
        exits Ź FALSE;  
        tb[node].son[4] Ź UpdateList[tb[node].son[4], Stmt];
        IF exits THEN newReachable Ź TRUE;
        exits Ź saveExits;
        DeleteLabels[tb[node].son[5]];
        current.loopDepth Ź current.loopDepth - 1;
        IF cvUpdate THEN {
            tb[forNode].son[3] Ź Rhs[tb[forNode].son[3], cvType];
            RPop[];
            IF tb[forNode].attr2 AND tb[forNode].attr3 THEN
                EnterComposite[cvType, tb[forNode].son[3], FALSE];
            pathNP Ź SequenceNP[pathNP][phraseNP];
            ClearRefStack[];
            };
        IF pathNP = refset THEN pathNP Ź unsafe;
        saveNP Ź pathNP Ź SequenceNP[saveNP][pathNP];
        IF tb[node].son[5] # Tree.Null THEN {
            current.reachable Ź FALSE;
            LabelList[tb[node].son[5]];
            IF current.reachable THEN newReachable Ź TRUE;
            };
        exitNP Ź pathNP;
        IF tb[node].son[6] # Tree.Null
            THEN {
                current.reachable Ź controlled;  pathNP Ź saveNP;
                tb[node].son[6] Ź UpdateList[tb[node].son[6], Stmt];
                IF current.reachable THEN newReachable Ź TRUE;
                exitNP Ź BoundNP[exitNP][pathNP];
                }
            ELSE IF controlled THEN newReachable Ź TRUE;
        ReverseScanList[tb[node].son[3], CloseItem];
        current.reachable Ź newReachable;
        pathNP Ź exitNP;
        IF block THEN PopCtx[];
        currentScope Ź saveScope;
        };
<<labels>>
    LabelList: PROC [t: Tree.Link] = {
        LabelItem: PROC [item: Tree.Link] = {
            node: Tree.Index = GetNode[item];
            current.reachable Ź tb[node].attr1;
            pathNP Ź saveNP;
            tb[node].son[2] Ź UpdateList[tb[node].son[2], Stmt];
            IF current.reachable THEN newReachable Ź TRUE;
            newNP Ź BoundNP[newNP][pathNP];
            };
        newReachable: BOOL Ź current.reachable;
        saveNP: NPUse Ź pathNP;
        newNP: NPUse Ź none;
        ScanList[t, LabelItem];
        current.reachable Ź newReachable;
        pathNP Ź newNP;
        };

    InsertLabels: PROC [t: Tree.Link] = {
        labelMark: Tree.Link = current.labelList;
        InsertLabel: PROC [labeled: Tree.Link] = {
            node: Tree.Index = GetNode[labeled];
            saveIndex: SourceMap.Loc = MimData.textIndex;
            MimData.textIndex Ź ToLoc[tb[node].info];
            ScanList[tb[node].son[1], StackLabel];
            MimData.textIndex Ź saveIndex;
            };
        StackLabel: PROC [id: Tree.Link] = {
            node: Tree.Index;
            FOR t: Tree.Link Ź current.labelList, tb[node].son[2] UNTIL t = labelMark DO
                node Ź GetNode[t];
                IF tb[node].son[1] = id AND id # Tree.nullId THEN
                    MimosaLog.ErrorTree[duplicateLabel, id];
                ENDLOOP;
            PushTree[id];
            PushTree[current.labelList];
            PushNode[item, 2];
            SetAttr[1, FALSE];
            current.labelList Ź PopTree[];
            };
        ScanList[t, InsertLabel];
        };

    ValidateLabel: PROC [id: Tree.Link] = INLINE {
        node: Tree.Index;
        FOR t: Tree.Link Ź current.labelList, tb[node].son[2] UNTIL t = Tree.Null DO
            node Ź GetNode[t];
            IF tb[node].son[1] = id THEN {tb[node].attr1 Ź TRUE; RETURN};
            ENDLOOP;
        MimosaLog.ErrorTree[unknownLabel, id];
        };

    DeleteLabels: PROC [t: Tree.Link] = {
        anyReachable: BOOL;
        DeleteLabel: PROC [labeled: Tree.Link] = {
            node: Tree.Index = GetNode[labeled];
            saveIndex: SourceMap.Loc = MimData.textIndex;
            MimData.textIndex Ź ToLoc[tb[node].info];
            anyReachable Ź FALSE;
            ReverseScanList[tb[node].son[1], UnstackLabel];
            tb[node].attr1 Ź anyReachable;
            MimData.textIndex Ź saveIndex;
            };
        UnstackLabel: PROC [id: Tree.Link] = {
            node: Tree.Index Ź GetNode[current.labelList];
            IF tb[node].attr1
                THEN anyReachable Ź TRUE
                ELSE MimosaLog.WarningTree[unusedId, tb[node].son[1]];
            current.labelList Ź tb[node].son[2];
            tb[node].son[2] Ź Tree.Null;
            FreeNode[node];
            };
        ReverseScanList[t, DeleteLabel];
        };
<<control transfers>>
    BumpArgRefs: PUBLIC PROC [record: RecordSEIndex, write: BOOL] = {
        IF record # RecordSENull THEN
            FOR sei: ISEIndex Ź SymbolOps.FirstCtxSe[SymbolOps.own, seb[record].fieldCtx],
            SymbolOps.NextSe[SymbolOps.own, sei]
            UNTIL sei = ISENull DO
                IF write THEN BumpCount[sei] ELSE RecordMention[sei];
                ENDLOOP;
        };

    CheckLocals: PUBLIC PROC [t: Tree.Link] RETURNS [localsOnly: BOOL Ź TRUE] = {
        level: ContextLevel = bb[MimData.bodyIndex].level;
        CheckElement: Tree.Scan = {
            WITH t SELECT GetTag[t] FROM
                literal => NULL;
                symbol => {
                    sei: ISEIndex = index;
                    IF ~seb[sei].constant
                    AND SymbolOps.CtxLevel[SymbolOps.own, seb[sei].idCtx] # level THEN
                        localsOnly Ź FALSE
                    };
                ENDCASE => localsOnly Ź FALSE;
            };
        ScanList[t, CheckElement];
        };

    Return: PROC [node: Tree.Index] = {
        rSei: RecordSEIndex = current.returnRecord;
        son1: Tree.Link Ź tb[node].son[1];
        IF current.catchDepth # 0
        OR (MimData.bodyIndex = RootBti AND rSei = RecordSENull) THEN
            MimosaLog.Error[misplacedReturn];
        IF rSei # RecordSENull AND son1 = Tree.Null
            THEN {
                BumpArgRefs[rSei, FALSE];
                FOR sei: ISEIndex Ź SymbolOps.FirstCtxSe[SymbolOps.own, seb[rSei].fieldCtx], SymbolOps.NextSe[SymbolOps.own, sei] UNTIL sei = 
                ISENull DO
                    IF seb[sei].hash = HTNull AND ~seb[sei].extended THEN {
                        MimosaLog.Error[illDefinedReturn];
                        EXIT};
                    ENDLOOP;
                tb[node].attr2 Ź TRUE;
                }
            ELSE {
                son1 Ź tb[node].son[1] Ź IF tb[node].attr3 AND rSei # RecordSENull
                    THEN Rhs[son1, rSei]
                    ELSE MatchFields[rSei, son1];
                RPop[];
                pathNP Ź SequenceNP[pathNP][phraseNP];
                IF current.entry THEN tb[node].attr2 Ź CheckLocals[son1];
                };
        IF (tb[node].attr1 Ź current.entry) THEN {
            [] Ź UpdateTreeAttr[tb[current.bodyNode].son[4]];
            pathNP Ź SequenceNP[pathNP][phraseNP];
            };
        current.reachable Ź FALSE;
        };

    ImpliedReturn: Tree.Map = {
        v Ź t;
        IF current.returnRecord # RecordSENull OR current.entry THEN {
            PushTree[Tree.Null];
            PushNode[return, 1];
            SetInfo[FromLoc[MimData.textIndex]];
            SetAttr[3, FALSE];
            PushTree[Stmt[PopTree[]]];
            PushTree[t];
            v Ź MakeList[-2];
            };
        };
<<basing>>
    OpenItem: Tree.Scan = {
        node: Tree.Index = GetNode[t];
        saveIndex: SourceMap.Loc = MimData.textIndex;
        MimData.textIndex Ź ToLoc[tb[node].info];
        tb[node].son[2] Ź OpenBase[tb[node].son[2], GetHash[tb[node].son[1]]
            ! InsertCatchLabel => {MimosaLog.Error[catchLabel]; RESUME}];
        ClearRefStack[];
        MimData.textIndex Ź saveIndex;
        };

    CloseItem: Tree.Scan = {
        node: Tree.Index = GetNode[t];
        CloseBase[tb[node].son[2], GetHash[tb[node].son[1]]];
        };
}.