<<>>
<<Pass3D.mesa>>
    <<Copyright Ó 1985, 1986, 1987, 1989, 1991 by Xerox Corporation.  All rights reserved.>>
    <<Russ Atkinson (RRA) May 15, 1989 5:30:55 pm PDT>>
    <<Satterthwaite, June 18, 1986 12:21:40 pm PDT>>
    <<JKF August 15, 1988 2:45:28 pm PDT>>
    DIRECTORY
        Alloc USING [Notifier],
        MimData USING [idANY, idCARD, idDREAL, idINT, interface, mainCtx, moduleCtx, seAnon, textIndex, typeStringBody, wordAlignment],
        MimosaLog USING [Error, ErrorHti, ErrorRope, ErrorSei, ErrorTree],
        MimP3 USING [Attr, NPUse, SequenceNP, fullAttr, voidAttr, mark, pathNP, phraseNP, CheckDisjoint, ClearRefStack, CopyTree, 
        EnterComposite, EnterType, Exp, FindSe, InterfaceCtx, MakeFrameRecord, PopCtx, PushCtx, RAttrPop, RecordLhs, RecordMention, 
        Rhs, RPop, RPush, RType, SafetyAttr, SealRefStack, SearchCtxList, SelectVariantType, TopCtx, UnsealRefStack, 
        VariantUnionType, VoidExp],
        Pass3Attributes USING [AssignableType, Default, DefaultInit, IndexType, OrderedType, TargetType, TypeForTree, Voidable, VoidItem],
        OSMiscOps USING [WordOr],
        SourceMap USING [Loc],
        SymbolOps USING [ArgCtx, CopyXferType, CtxLevel, DecodeCard, DecodeTreeIndex, DecodeType, EncodeCard, EncodeType, EnterExtension, 
        EqTypes, FromType, LinkMode, MakeNonCtxSe, NormalType, own, RCType, ReferentType, ToBti, ToType, TypeForm, TypeLink, 
        UnderType, XferMode],
        Symbols USING [Base, bodyType, CBTIndex, CSEIndex, CSENull, CTXIndex, CTXNull, ctxType, ISEIndex, ISENull, lG, lZ, mdType, Name, 
        nullType, RecordSEIndex, RefSEIndex, SERecord, seType, Type, typeANY, typeTYPE],
        Target: TYPE MachineParms USING [bitsPerLongWord, bitsPerReal, bitsPerRef, bitsPerWord],
        Tree USING [Base, Index, Link, lsbitOption, Map, msbitOption, nativeOption, Null, nullIndex, packedOption, Scan, SubInfo, treeType, 
        word16Option, word32Option, word64Option, word8Option],
        TreeOps USING [FreeTree, GetHash, GetNode, GetSe, GetTag, IdentityMap, ListHead, ListLength, NthSon, OpName, ScanList, ToLoc, 
        UpdateList];
Pass3D: PROGRAM
    IMPORTS MimData, MimosaLog, MimP3, Pass3Attributes, OSMiscOps, SymbolOps, TreeOps
    EXPORTS MimP3 = {
    OPEN MimP3, TreeOps, Symbols;

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

    DeclNotify: 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];
        };
<<signals for type loop detection>>
    CheckTypeLoop: SIGNAL [loopNode: Tree.Index] RETURNS [BOOL] = CODE;
    LogTypeLoop: SIGNAL [loopNode: Tree.Index] = CODE;
<<declaration processing>>
    ItemId: PROC [t: Tree.Link] RETURNS [ISEIndex] = {
        DO
            WITH t SELECT GetTag[t] FROM
                symbol => RETURN [index];
                subtree => t Ź tb[index].son[1];
                ENDCASE => ERROR;
            ENDLOOP;
        };

    FirstId: PUBLIC PROC [node: Tree.Index] RETURNS [ISEIndex] = {
        RETURN [ItemId[ListHead[tb[node].son[1]]]];
        };

    DeclList: PUBLIC Tree.Scan = {
        ScanList[t, DeclA];
        ScanList[t, DeclBInit];
        };

    DeclA: Tree.Scan = {
        node: Tree.Index = GetNode[t];
        IF tb[node].attr3 # MimP3.mark THEN {
            type: Type;
            saveIndex: SourceMap.Loc = MimData.textIndex;
            son1: Tree.Link Ź tb[node].son[1];
            son2: Tree.Link Ź tb[node].son[2];
            tb[node].attr3 Ź MimP3.mark;
            MimData.textIndex Ź ToLoc[tb[node].info];
            son2 Ź tb[node].son[2] Ź TypeLink[son2
                ! CheckTypeLoop => {IF loopNode = node THEN RESUME [TRUE]};
                    LogTypeLoop => {IF loopNode = node THEN RESUME}];
            type Ź Pass3Attributes.TypeForTree[son2];
            SELECT tb[node].name FROM
                typedecl => DefineTypeSe[son1, type];
                decl => DefineSeType[son1, type, tb[node].attr1];
                ENDCASE => ERROR;
            ClearRefStack[];
            MimData.textIndex Ź saveIndex;
            };
        };

    DeclBField: Tree.Scan = {DeclBDefault[t, FALSE]};

    DeclBVarField: Tree.Scan = {DeclBDefault[t, TRUE]};

    DeclBDefault: PROC [t: Tree.Link, varOK: BOOLŹFALSE] = {
        node: Tree.Index = GetNode[t];
        IF tb[node].attr2 # MimP3.mark THEN {
            saveIndex: SourceMap.Loc = MimData.textIndex;
            tb[node].attr2 Ź MimP3.mark;
            MimData.textIndex Ź ToLoc[tb[node].info];
            TypeAttr[typeExp: tb[node].son[2], varOK: varOK];
            SELECT tb[node].name FROM
                typedecl => {};
                decl => {
                    type: Type = Pass3Attributes.TypeForTree[tb[node].son[2]];
                    son1: Tree.Link Ź tb[node].son[1];
                    son3: Tree.Link Ź tb[node].son[3];
                    IF ~ComponentType[type] THEN MimosaLog.ErrorTree[typeLength, tb[node].son[2]];
                    IF son3 # Tree.Null THEN {
                        ScanList[son1, RecordDeclInit];
                        son3 Ź tb[node].son[3] Ź DefaultExp[t: son3, type: type, ids: son1];
                        };
                    DefineSeValue[son1, FALSE];
                    };
                ENDCASE => ERROR;
            ClearRefStack[];
            MimData.textIndex Ź saveIndex;
            };
        };

    DeclBInit: Tree.Scan = {
        node: Tree.Index = GetNode[t];
        IF tb[node].attr2 # MimP3.mark THEN {
            saveIndex: SourceMap.Loc = MimData.textIndex;
            son1: Tree.Link Ź tb[node].son[1];
            son2: Tree.Link Ź tb[node].son[2];
            son3: Tree.Link Ź tb[node].son[3];
            ctx: CTXIndex = TopCtx[];
            type: Type;
            tb[node].attr2 Ź MimP3.mark;
            MimData.textIndex Ź ToLoc[tb[node].info];
            [] Ź CheckPositions[son1, FieldAttrs[]];
            SELECT tb[node].name FROM
                typedecl => {
                    TypeAttr[son2];
                    type Ź Pass3Attributes.TypeForTree[son2];
                    IF son3 # Tree.Null THEN {
                        tb[node].son[3] Ź DefaultExp[t: son3, type: type, ids: son1];
                        [] Ź ProcessDefault[node];  -- note: alters tb[node].son[3]
                        };
                    IF GlobalContext[ctx] THEN {
                        <<RRA: this could be an exported type, so enter it to be sure that we eventually have a type code for it.>>
                        CheckPublic: Tree.Scan = {
                            WITH t SELECT GetTag[t] FROM
                                symbol => {
                                    sei: ISEIndex = index;
                                    IF notYet AND seb[sei].public THEN {
                                        MimP3.EnterType[type];
                                        notYet Ź FALSE;
                                        };
                                    };
                                ENDCASE;
                            };
                        notYet: BOOL Ź TRUE;
                        ScanList[son1, CheckPublic];
                        };
                    };
                decl => {
                    constFlag, extFlag: BOOL;
                    TypeAttr[typeExp: son2, varOK: InterfaceContext[ctx]];
                    type Ź Pass3Attributes.TypeForTree[son2];
                    IF NOT ComponentType[type] THEN MimosaLog.ErrorTree[typeLength, son2];
                    IF son3 = Tree.Null
                        THEN {
                            IF NOT InterfaceContext[ctx] AND NOT tb[node].attr1 THEN {
                                IF Pass3Attributes.Default[type] = nonVoid THEN
                                    <<A type with defaults forces the appearance of initialization>>
                                        <<(RRA, May 15, 1989 5:15:05 pm PDT)>>
                                    ScanList[son1, RecordDeclInit];
                                son3 Ź tb[node].son[3] Ź Pass3Attributes.DefaultInit[type];
                                pathNP Ź SequenceNP[pathNP][phraseNP];
                                RPop[];
                                };
                            constFlag Ź FALSE;
                            }
                        ELSE {
                            [son3, extFlag] Ź InitialExp[son3, type];
                            tb[node].son[3] Ź son3;
                            IF extFlag AND ~tb[node].attr1 THEN MimosaLog.ErrorTree[misusedInline, son3];
                            pathNP Ź SequenceNP[pathNP][phraseNP];
                            constFlag Ź RAttrPop[].const AND tb[node].attr1;
                            IF son3 # Tree.Null THEN ScanList[son1, RecordDeclInit];
                            };
                    SELECT TRUE FROM
                        (son3 = Tree.Null) => {
                            IF ~InterfaceContext[ctx] AND NOT Pass3Attributes.Voidable[type] THEN
                                MimosaLog.ErrorSei[missingInit, FirstId[node]];
                            };
                        GlobalContext[ctx] =>
                            SELECT SymbolOps.RCType[SymbolOps.own, type] FROM
                                composite =>
                                    EnterComposite[SymbolOps.UnderType[SymbolOps.own, type], son3, TRUE];
                                ENDCASE;
                        ENDCASE => NULL;
                    DefineSeValue[son1, constFlag];
                    };
                ENDCASE => ERROR;
            ClearRefStack[];
            MimData.textIndex Ź saveIndex;
            };
        };

    RecordDeclInit: Tree.Scan = {
        sei: ISEIndex = ItemId[t];
        RecordMention[sei];
        RecordLhs[sei];
        };

    DefaultExp: PROC [t: Tree.Link, type: Type, ids: Tree.Link] RETURNS [v: Tree.Link] = {
        subType: Type = Pass3Attributes.TargetType[type];
        ExpInit: PROC [t: Tree.Link] RETURNS [val: Tree.Link] = {
            val Ź Rhs[t, subType];
            RPop[];
            };
        v Ź UpdateList[t, ExpInit];
        IF Pass3Attributes.VoidItem[v]
        AND NOT Pass3Attributes.Voidable[type] THEN MimosaLog.ErrorSei[defaultForm, ItemId[ids]];
        };

    InitialExp: PUBLIC PROC [t: Tree.Link, type: Type]
    RETURNS [v: Tree.Link, extended: BOOL] = {
        v Ź t;
        extended Ź FALSE;
        phraseNP Ź none;
        SELECT OpName[t] FROM
            body => {
                <<defer processing of bodies (see Body)>>
                subType: CSEIndex = SymbolOps.UnderType[SymbolOps.own, type];
                expNode: Tree.Index = GetNode[t];
                bti: CBTIndex = LOOPHOLE[SymbolOps.ToBti[tb[expNode].info]];
                attr: Attr Ź voidAttr;
                SELECT SymbolOps.XferMode[SymbolOps.own, type] FROM
                    proc, program => NULL;
                    ENDCASE =>
                        IF SymbolOps.TypeForm[SymbolOps.own, type] = $definition
                        THEN attr Ź fullAttr
                        ELSE MimosaLog.Error[bodyType];
                bb[bti].ioType Ź SELECT seb[type].seTag FROM
                    cons => subType,
                    ENDCASE => SymbolOps.CopyXferType[subType, IdentityMap];
                RPush[type, attr];
                extended Ź tb[expNode].attr3;  -- inline
                CheckBodyType[subType, expNode];
                };
            inline => {
                expNode: Tree.Index = GetNode[t];
                CodeBody: Tree.Map = {
                    WITH e: t SELECT GetTag[t] FROM
                        string => v Ź t;
                            <<No processing needed>>
                        ENDCASE => v Ź UpdateList[t, NumericConst];
                    };
                IF SymbolOps.XferMode[SymbolOps.own, type] # proc THEN
                    MimosaLog.Error[inlineType];
                IF tb[expNode].attr1 THEN MimosaLog.Error[inlineChecked];
                tb[expNode].son[1] Ź UpdateList[tb[expNode].son[1], CodeBody];
                RPush[type, fullAttr];
                extended Ź TRUE;
                CheckBodyType[SymbolOps.UnderType[SymbolOps.own, type], expNode];
                };
            apply => {
                expNode: Tree.Index = GetNode[t];
                IF tb[expNode].son[1] = Tree.Null
                    AND SymbolOps.EqTypes[SymbolOps.own,
                    SymbolOps.ReferentType[SymbolOps.own, type], MimData.typeStringBody]
                    AND ListLength[tb[expNode].son[2]] = 1 THEN
                        tb[expNode].name Ź stringinit;
                v Ź Rhs[t, Pass3Attributes.TargetType[type]];
                };
            signalinit => RPush[type, voidAttr];
            void => {v Ź FreeTree[t];  RPush[type, voidAttr]};
            ENDCASE => v Ź Rhs[t, Pass3Attributes.TargetType[type]];
        };

    RecordField: PROC [ctx: CTXIndex] RETURNS [BOOL] = INLINE {
        RETURN [ctx = CTXNull
        OR (SymbolOps.CtxLevel[SymbolOps.own, ctx] = lZ AND ctx # MimData.moduleCtx)];
        };

    GlobalContext: PROC [ctx: CTXIndex] RETURNS [BOOL] = INLINE {
        RETURN [~MimData.interface AND SymbolOps.CtxLevel[SymbolOps.own, ctx] = lG];
        };

    InterfaceContext: PROC [ctx: CTXIndex] RETURNS [BOOL] = INLINE {
        RETURN [MimData.interface AND ctx = MimData.mainCtx];
        };

    InterfaceSe: PROC [sei: ISEIndex] RETURNS [BOOL] = INLINE {
        RETURN [InterfaceContext[seb[sei].idCtx]];
        };

    CheckBodyType: PROC [type: CSEIndex, node: Tree.Index] = {
        WITH t: seb[type] SELECT FROM
            transfer => {
                IF SymbolOps.TypeForm[SymbolOps.own, t.typeIn] = $any
                OR SymbolOps.TypeForm[SymbolOps.own, t.typeOut] = $any THEN
                    MimosaLog.Error[bodyType];
                IF t.safe AND SafetyAttr[node] = none THEN MimosaLog.Error[unsafeBlock];
                };
            ENDCASE;
        };

    DefineTypeSe: PROC [t: Tree.Link, info: Type] = {
        first: BOOL Ź TRUE;
        UpdateSe: Tree.Scan = {
            sei: ISEIndex = ItemId[t];
            seb[sei].idType Ź typeTYPE;  seb[sei].idInfo Ź SymbolOps.EncodeType[info];
            seb[sei].immutable Ź seb[sei].constant Ź TRUE;
            IF first THEN {info Ź sei; first Ź FALSE};
            seb[sei].mark3 Ź TRUE;
            };
        ScanList[t, UpdateSe];
        };

    DefineSeType: PROC [t: Tree.Link, type: Type, fixed: BOOL] = {
        UpdateSe: Tree.Scan = {
            sei: ISEIndex = ItemId[t];
            seb[sei].idType Ź type;  seb[sei].constant Ź FALSE;
            IF InterfaceSe[sei]
                THEN seb[sei].immutable Ź seb[sei].immutable OR fixed
                ELSE seb[sei].immutable Ź fixed;
            seb[sei].mark3 Ź TRUE;
            };
        ScanList[t, UpdateSe];
        };

    DefineSeValue: PROC [t: Tree.Link, const: BOOL] = {
        UpdateSe: Tree.Scan = {
            sei: ISEIndex = ItemId[t];
            seb[sei].constant Ź const;
            IF InterfaceSe[sei] AND SymbolOps.LinkMode[SymbolOps.own, sei] = val THEN seb[sei].immutable Ź TRUE;
            };
        ScanList[t, UpdateSe];
        };

    ProcessDefault: PROC [node: Tree.Index] RETURNS [nonVoid: BOOL] = {
        copy: BOOL Ź FALSE;
        v: Tree.Link = tb[node].son[3];
        DefineDefault: Tree.Scan = {
            SymbolOps.EnterExtension[ItemId[t], default, IF copy THEN CopyTree[v] ELSE v];
            copy Ź TRUE;
            };
        SELECT OpName[v] FROM
            stringinit => MimosaLog.ErrorSei[defaultForm, FirstId[node]];
            lengthen =>
                IF OpName[NthSon[v, 1]] = stringinit THEN
                    MimosaLog.ErrorSei[defaultForm, FirstId[node]];
            void => nonVoid Ź FALSE;
            ENDCASE => nonVoid Ź TRUE;
        ScanList[tb[node].son[1], DefineDefault];
        tb[node].son[3] Ź Tree.Null;
        };
<<forward reference resolution>>
    ResolveType: PUBLIC PROC [sei: ISEIndex] = {
        currentCtx: CTXIndex = TopCtx[];
        IF seb[sei].idCtx # currentCtx
            THEN {
                PopCtx[];
                ResolveType[sei];
                PushCtx[currentCtx];
                }
            ELSE {
                SealRefStack[];
                DeclA[[subtree[index: SymbolOps.DecodeTreeIndex[seb[sei].idValue]]]];
                UnsealRefStack[];
                };
        };

    ResolveValue: PUBLIC PROC [sei: ISEIndex] = {
        currentCtx: CTXIndex = TopCtx[];
        IF seb[sei].idCtx # currentCtx
            THEN {
                PopCtx[];
                ResolveValue[sei];
                PushCtx[currentCtx];
                }
            ELSE {
                index: Tree.Index;
                SealRefStack[];
                index Ź SymbolOps.DecodeTreeIndex[seb[sei].idValue];
                IF RecordField[currentCtx]
                    THEN DeclBDefault[[subtree[index: index]]]
                    ELSE  DeclBInit[[subtree[index: index]]];
                UnsealRefStack[];
                }
        };
<<type expressions>>
    CheckTypeId: PROC [sei: ISEIndex] RETURNS [BOOL] = {
        SELECT TRUE FROM
            (sei = ISENull) => RETURN [FALSE];
            seb[sei].mark3 => RETURN [seb[sei].idType = typeTYPE];
            ENDCASE => {
                node: Tree.Index = SymbolOps.DecodeTreeIndex[seb[sei].idValue];
                RETURN [node = Tree.nullIndex OR tb[node].name = typedecl];
                };
        };

    TypeSymbol: PROC [sei: ISEIndex] RETURNS [val: Tree.Link] = {
        entryIndex: SourceMap.Loc = MimData.textIndex;
        circular: BOOL Ź FALSE;
        IF ~seb[sei].mark3 THEN {
            ENABLE
                LogTypeLoop => {
                    saveIndex: SourceMap.Loc = MimData.textIndex;
                    MimData.textIndex Ź entryIndex;
                    MimosaLog.ErrorSei[circularType, sei];
                    circular Ź TRUE;
                    MimData.textIndex Ź saveIndex;
                    };
            declNode: Tree.Index = SymbolOps.DecodeTreeIndex[seb[sei].idValue];
            IF tb[declNode].attr3 # MimP3.mark
                THEN ResolveType[sei]
                ELSE IF SIGNAL CheckTypeLoop[declNode] THEN SIGNAL LogTypeLoop[declNode];
            };
        IF CheckTypeId[sei] AND ~circular
            THEN val Ź [symbol[index: sei]]
            ELSE {
                IF ~circular AND sei # MimData.seAnon THEN MimosaLog.ErrorSei[nonTypeId, sei];
                val Ź [symbol[index: MimData.idANY]];
                };
        };

    PushArgCtx: PROC [sei: CSEIndex] = {
        ctx: CTXIndex = SymbolOps.ArgCtx[SymbolOps.own, sei];
        IF ctx # CTXNull THEN PushCtx[ctx];
        };

    PopArgCtx: PROC [sei: CSEIndex] = {
        IF SymbolOps.ArgCtx[SymbolOps.own, sei] # CTXNull THEN PopCtx[];
        };

    TypeExp: PUBLIC PROC [typeExp: Tree.Link] RETURNS [val: Tree.Link] = {
        val Ź TypeLink[typeExp];
        TypeAttr[val];
        };

    TypeAppl: PUBLIC PROC [typeExp: Tree.Link] RETURNS [val: Tree.Link] = {
        attr: Attr Ź fullAttr;
        IF OpName[typeExp] = apply
            THEN {
                node: Tree.Index = GetNode[typeExp];
                son1: Tree.Link Ź tb[node].son[1] Ź TypeExp[tb[node].son[1]];
                rType: Type Ź Pass3Attributes.TypeForTree[son1];
                uType: Type Ź SymbolOps.UnderType[SymbolOps.own, rType];
                vuType: Type Ź VariantUnionType[rType];
                tb[node].info Ź SymbolOps.FromType[rType];
                SELECT TRUE FROM
                    (SymbolOps.UnderType[SymbolOps.own, rType] = MimData.typeStringBody),
                    (SymbolOps.TypeForm[SymbolOps.own, vuType] = $sequence) => {
                        tb[node].son[2] Ź Rhs[tb[node].son[2], MimData.idINT];
                        attr Ź RAttrPop[];
                        };
                    (SymbolOps.TypeForm[SymbolOps.own, vuType] = $union) => {
                        TypeDiscrim[rType, node];
                        phraseNP Ź none;
                        };
                    ENDCASE => {
                        MimosaLog.ErrorTree[noApplication, son1];
                        tb[node].son[2] Ź Exp[tb[node].son[2], typeANY];
                        attr Ź RAttrPop[];
                        };
                val Ź typeExp;
                }
            ELSE {
                val Ź TypeExp[typeExp];
                phraseNP Ź none;
                };
        RPush[typeTYPE, attr];
        };

    ClusterExp: PROC [t: Tree.Link] RETURNS [val: Tree.Link] = {
        WITH t SELECT GetTag[t] FROM
            hash => {
                sei: ISEIndex = FindSe[index].symbol;
                IF ~CheckTypeId[sei] THEN
                    <<prevent duplicate error messages>>
                    RETURN [Exp[IF sei = MimData.seAnon THEN [symbol[sei]] ELSE t, typeANY]];
                val Ź TypeSymbol[sei];
                };
            symbol => {
                sei: ISEIndex = index;
                IF ~CheckTypeId[sei] THEN RETURN [Exp[t, typeANY]];
                val Ź TypeSymbol[sei];
                };
            ENDCASE => val Ź TypeLink[t];
        RPush[typeTYPE, fullAttr];
        };

    TypeDot: PROC [rType: Type, node: Tree.Index] = TypeDiscrim;
        <<for now, should do other possible cluster items>>

    TypeDiscrim: PROC [rType: Type, node: Tree.Index] = {
        t2: Tree.Link = tb[node].son[2];
        WITH h: t2 SELECT GetTag[t2] FROM
            hash => {
                iSei: ISEIndex = SelectVariantType[rType, h.index];
                IF iSei # ISENull
                    THEN {
                        tb[node].info Ź SymbolOps.FromType[iSei];
                        tb[node].son[2] Ź [symbol[index: iSei]];
                        tb[node].name Ź discrimTC;
                        }
                    ELSE {
                        IF rType # typeANY THEN MimosaLog.ErrorTree[unknownVariant, t2];
                        tb[node].info Ź SymbolOps.FromType[MimData.idANY];
                        };
                };
            ENDCASE => {
                MimosaLog.ErrorTree[unknownVariant, t2];
                tb[node].son[2] Ź VoidExp[t2];
                };
        };

    linkType: Type Ź nullType;    -- to find list link type

    TypeLink: PROC [typeExp: Tree.Link] RETURNS [val: Tree.Link] = {
        WITH typeExp SELECT GetTag[typeExp] FROM
            hash => {
                sei: ISEIndex = FindSe[index].symbol;
                IF sei # ISENull
                    THEN val Ź TypeSymbol[sei]
                    ELSE {MimosaLog.ErrorHti[nonTypeId, index]; val Ź [symbol[MimData.idANY]]};
                };
            symbol => val Ź TypeSymbol[index];
            subtree => {
                node: Tree.Index = index;
                SELECT tb[node].name FROM
                    longTC => {
                        son1: Tree.Link = tb[node].son[1] Ź TypeLink[tb[node].son[1]];
                        tb[node].info Ź SymbolOps.FromType[MakeLongType[Pass3Attributes.TypeForTree[son1]]];
                        };
                    optionTC => {
                        son1: Tree.Link = tb[node].son[1] Ź TypeLink[tb[node].son[1]];
                        sonType: Type Ź Pass3Attributes.TypeForTree[son1];
                        ut: CSEIndex = SymbolOps.UnderType[SymbolOps.own, sonType];
                        subInfo: Tree.SubInfo Ź tb[node].subInfo;
                        ok: BOOL Ź FALSE;
                        SELECT subInfo FROM
                            Tree.packedOption => {
                                WITH t: seb[ut] SELECT FROM
                                    array => ok Ź t.packed;
                                    sequence => ok Ź t.packed;
                                    record => ok Ź t.packed;
                                    ENDCASE => ok Ź FALSE;
                                WITH st: son1 SELECT GetTag[son1] FROM
                                    subtree => IF tb[st.index].name = optionTC THEN ok Ź FALSE;
                                    ENDCASE;
                                };
                            Tree.msbitOption, Tree.lsbitOption, Tree.nativeOption => {
                                link: Tree.Link Ź son1;
                                isRecord: BOOL Ź FALSE;
                                WITH t: seb[ut] SELECT FROM
                                    record => ok Ź isRecord Ź t.machineDep;
                                    array => ok Ź t.packed;
                                    arraydesc => ok Ź TRUE;
                                    ENDCASE => ok Ź FALSE;
                                DO
                                    WITH st: link SELECT GetTag[link] FROM
                                        subtree => IF tb[st.index].name = optionTC THEN
                                            SELECT tb[st.index].subInfo FROM
                                                Tree.word8Option, Tree.word16Option,
                                                Tree.word32Option, Tree.word64Option => {
                                                    link Ź tb[st.index].son[1];
                                                    IF isRecord THEN LOOP;
                                                    ok Ź FALSE;
                                                    };
                                                Tree.packedOption => {
                                                    link Ź tb[st.index].son[1];
                                                    IF NOT isRecord THEN LOOP;
                                                    ok Ź FALSE;
                                                    };
                                                ENDCASE => ok Ź FALSE;
                                        ENDCASE;
                                    EXIT;
                                    ENDLOOP;
                                };
                            Tree.word8Option, Tree.word16Option,
                            Tree.word32Option, Tree.word64Option => {
                                link: Tree.Link Ź son1;
                                WITH t: seb[ut] SELECT FROM
                                    record => ok Ź t.machineDep;
                                    ENDCASE => ok Ź FALSE;
                                DO
                                    WITH st: link SELECT GetTag[link] FROM
                                        subtree => IF tb[st.index].name = optionTC THEN
                                            SELECT tb[st.index].subInfo FROM
                                                Tree.msbitOption, Tree.lsbitOption, Tree.nativeOption => {
                                                    link Ź tb[st.index].son[1];
                                                    LOOP;
                                                    };
                                                ENDCASE => ok Ź FALSE;
                                        ENDCASE;
                                    EXIT;
                                    ENDLOOP;
                                };
                            ENDCASE;
                        IF NOT ok THEN MimosaLog.ErrorRope[other, "invalid type attribute combination"];
                        tb[node].info Ź SymbolOps.FromType[sonType];
                        };
                    discrimTC => {
                        son1: Tree.Link Ź tb[node].son[1] Ź TypeLink[tb[node].son[1]];
                        TypeDiscrim[Pass3Attributes.TypeForTree[son1], node];
                        };
                    apply => {
                        son1: Tree.Link Ź tb[node].son[1] Ź TypeLink[tb[node].son[1]];
                        rType: Type Ź Pass3Attributes.TypeForTree[tb[node].son[1]];
                        tb[node].info Ź SymbolOps.FromType[rType];
                        SELECT SymbolOps.TypeForm[SymbolOps.own, VariantUnionType[rType]] FROM
                            $union => TypeDiscrim[rType, node];
                            $sequence => MimosaLog.ErrorTree[unimplemented, typeExp];
                            ENDCASE => MimosaLog.ErrorTree[noApplication, son1];
                        };
                    dot => {
                        id: Name = GetHash[tb[node].son[2]];
                        nDerefs: CARDINAL Ź 0;
                        next: Type;
                        ctx: CTXIndex Ź CTXNull;
                        son1: Tree.Link Ź tb[node].son[1] Ź ClusterExp[tb[node].son[1]];
                        FOR type: Type Ź RType[], next DO
                            sei: CSEIndex = SymbolOps.UnderType[SymbolOps.own, type];
                            WITH t: seb[sei] SELECT FROM
                                mode => GO TO type;
                                definition, transfer => {
                                    ctx Ź InterfaceCtx[sei, son1];
                                    GO TO cluster;
                                    };
                                record => {
                                    ctx Ź t.fieldCtx;
                                    GO TO cluster;
                                    };
                                ref => {IF (nDerefs Ź nDerefs+1) > 63 THEN GO TO cluster; next Ź t.refType};
                                subrange => next Ź t.rangeType;
                                ENDCASE => GO TO cluster;
                            REPEAT
                                type => TypeDot[Pass3Attributes.TypeForTree[son1], node];
                                cluster => {
                                    iSei: ISEIndex;
                                    found: BOOL;
                                    [found, iSei] Ź SearchCtxList[id, ctx];
                                    IF ~found THEN {
                                        iSei Ź MimData.idANY;
                                        MimosaLog.ErrorHti[unknownField, id];
                                        };
                                    tb[node].name Ź cdot;
                                    tb[node].info Ź SymbolOps.FromType[iSei];
                                    tb[node].son[2] Ź TypeSymbol[iSei];
                                    };
                            ENDLOOP;
                        RPop[];
                        };
                    paintTC => {
                        son1: Tree.Link Ź tb[node].son[1] Ź TypeLink[tb[node].son[1]];
                        son2: Tree.Link Ź tb[node].son[2] Ź TypeLink[tb[node].son[2]];
                        tb[node].info Ź SymbolOps.FromType[Pass3Attributes.TypeForTree[son2]];
                        };
                    linkTC => tb[node].info Ź SymbolOps.FromType[linkType];
                    implicitTC => {};
                    frameTC => {
                        son1: Tree.Link Ź tb[node].son[1] Ź Exp[tb[node].son[1], typeANY];
                        RPop[];
                        tb[node].info Ź SymbolOps.FromType[MakeFrameRecord[son1]];
                        };
                    ENDCASE => {
                        type: CSEIndex = SymbolOps.UnderType[
                        SymbolOps.own, SymbolOps.ToType[tb[node].info]];
                        WITH t: seb[type] SELECT FROM
                            record => {
                                PushCtx[t.fieldCtx];
                                ScanList[tb[node].son[1], DeclA];
                                PopCtx[];
                                };
                            ref => {
                                oldLink: Type Ź linkType;
                                newLink: Type Ź linkType Ź type;
                                son1: Tree.Link Ź tb[node].son[1] Ź TypeLink[tb[node].son[1]
                                    ! CheckTypeLoop => {RESUME [FALSE]}];
                                subType: Type Ź t.refType Ź Pass3Attributes.TypeForTree[son1];
                                IF t.list THEN {
                                    ut: CSEIndex = SymbolOps.UnderType[SymbolOps.own, subType];
                                    WITH se: seb[ut] SELECT FROM
                                        record => {
                                            <<The record type is for a LIST>>
                                            se.list Ź TRUE;
                                            se.machineDep Ź se.painted Ź FALSE;
                                            };
                                        ENDCASE;
                                    };
                                linkType Ź oldLink;
                                };
                            array => {
                                son1: Tree.Link Ź tb[node].son[1];
                                son2: Tree.Link Ź tb[node].son[2];
                                IF son1 = Tree.Null
                                    THEN t.indexType Ź MimData.idCARD
                                    ELSE {
                                        son1 Ź tb[node].son[1] Ź TypeLink[son1];
                                        t.indexType Ź Pass3Attributes.TypeForTree[son1];
                                        };
                                son2 Ź tb[node].son[2] Ź TypeLink[son2];
                                t.componentType Ź Pass3Attributes.TypeForTree[son2];
                                };
                            arraydesc => {
                                son1: Tree.Link Ź tb[node].son[1] Ź TypeLink[tb[node].son[1]
                                    ! CheckTypeLoop => {RESUME [FALSE]}];
                                t.describedType Ź Pass3Attributes.TypeForTree[son1];
                                };
                            transfer => {
                                ENABLE CheckTypeLoop => {RESUME [FALSE]};
                                CheckDisjoint[SymbolOps.ArgCtx[SymbolOps.own, t.typeIn], SymbolOps.ArgCtx[SymbolOps.own, t.typeOut]];
                                PushArgCtx[t.typeIn];
                                IF OpName[tb[node].son[1]] # anyTC THEN
                                    ScanList[tb[node].son[1], DeclA];
                                PushArgCtx[t.typeOut];
                                IF OpName[tb[node].son[2]] # anyTC THEN
                                    ScanList[tb[node].son[2], DeclA];
                                PopArgCtx[t.typeOut];
                                PopArgCtx[t.typeIn];
                                };
                            definition => t.defCtx Ź MimData.mainCtx;
                            union => {
                                DeclA[tb[node].son[1]];
                                ScanList[tb[node].son[2], DeclA];
                                };
                            sequence => {
                                DeclA[tb[node].son[1]];
                                t.componentType Ź Pass3Attributes.TypeForTree[
                                tb[node].son[2] Ź TypeLink[tb[node].son[2]]];
                                };
                            relative => {
                                son1: Tree.Link Ź tb[node].son[1] Ź TypeLink[tb[node].son[1]
                                    ! CheckTypeLoop => {RESUME [FALSE]}];
                                t.baseType Ź Pass3Attributes.TypeForTree[son1];
                                t.resultType Ź t.offsetType Ź Pass3Attributes.TypeForTree[
                                tb[node].son[2] Ź TypeLink[tb[node].son[2]]];
                                };
                            opaque =>
                                IF t.id = ISENull OR ~InterfaceSe[t.id] THEN MimosaLog.Error[misplacedType];
                            subrange => {
                                t.range Ź LOOPHOLE[node];    -- to allow symbolic evaluation
                                t.rangeType Ź Pass3Attributes.TypeForTree[tb[node].son[1] Ź TypeLink[tb[node].son[1]]];
                                };
                            ENDCASE;
                        seb[type].mark3 Ź TRUE;
                        };
                val Ź typeExp;
                };
            ENDCASE => ERROR;
        };

    TypeAttr: PROC [typeExp: Tree.Link, indirect, varOK: BOOL Ź FALSE] = {
        WITH typeExp SELECT GetTag[typeExp] FROM
            symbol =>
                IF ~indirect THEN {
                    sei: ISEIndex = index;
                    IF seb[sei].mark3 AND ~seb[sei].mark4 THEN {
                        declNode: Tree.Index = SymbolOps.DecodeTreeIndex[seb[sei].idValue];
                        IF tb[declNode].attr2 # MimP3.mark THEN ResolveValue[sei];
                        }
                    };
            subtree => {
                node: Tree.Index = index;
                SELECT tb[node].name FROM
                    discrimTC, longTC, optionTC => TypeAttr[tb[node].son[1], indirect];
                    cdot => TypeAttr[tb[node].son[2], indirect];
                    paintTC => {
                        TypeAttr[tb[node].son[1]];
                        TypeAttr[tb[node].son[2], indirect];
                        MimosaLog.Error[unimplemented];
                        };
                    implicitTC, linkTC, frameTC, dot => NULL;
                    apply => tb[node].son[2] Ź VoidExp[tb[node].son[2]];
                    ENDCASE => {
                        type: CSEIndex = SymbolOps.UnderType[
                        SymbolOps.own, SymbolOps.ToType[tb[node].info]];
                        WITH t: seb[type] SELECT FROM
                            enumerated =>
                                IF AssignedEnumeration[tb[node].son[1]] AND ~t.machineDep THEN
                                    MimosaLog.Error[machDep];
                            record => {
                                saveNP: NPUse = pathNP;
                                son1: Tree.Link Ź tb[node].son[1];
                                PushCtx[t.fieldCtx];
                                pathNP Ź none;
                                ScanList[son1, DeclBField];
                                WITH s: t SELECT FROM
                                    linked => CheckDisjointPrefix[t.fieldCtx, s.linkType];
                                    notLinked => {
                                        attrs: FieldAttrs = CollectAttrs[
                                        son1, FieldAttrs[positionValid: t.machineDep]];
                                        UpdateHints[LOOPHOLE[type], attrs];
                                        tb[node].attr1 Ź AssignedPositions[attrs];
                                        };
                                    ENDCASE => ERROR;
                                PopCtx[];
                                pathNP Ź saveNP;
                                };
                            ref => {
                                IF t.var AND ~varOK THEN MimosaLog.Error[var];
                                TypeAttr[tb[node].son[1], TRUE];
                                };
                            array => {
                                IF tb[node].son[1] # Tree.Null THEN TypeAttr[tb[node].son[1]];
                                IF NOT Pass3Attributes.IndexType[t.indexType] THEN {
                                    t.indexType Ź typeANY;
                                    MimosaLog.Error[nonOrderedType];
                                    };
                                TypeAttr[tb[node].son[2], indirect];
                                IF NOT ComponentType[t.componentType] THEN
                                    MimosaLog.ErrorTree[typeLength, tb[node].son[2]]
                                };
                            arraydesc => {
                                TypeAttr[tb[node].son[1], TRUE];
                                IF SymbolOps.TypeForm[SymbolOps.own, t.describedType] # $array THEN
                                    MimosaLog.Error[descriptor];
                                };
                            transfer => {
                                saveNP: NPUse = pathNP;
                                IF t.mode = error THEN t.safe Ź FALSE;
                                PushArgCtx[t.typeIn];
                                ArgAttr[t.typeIn, tb[node].son[1], t.mode = proc OR t.mode = signal];
                                PushArgCtx[t.typeOut];
                                ArgAttr[t.typeOut, tb[node].son[2], FALSE];
                                PopArgCtx[t.typeOut];
                                PopArgCtx[t.typeIn];
                                pathNP Ź saveNP;
                                };
                            definition, zone, any => {};
                            union => {
                                tagType: CSEIndex;
                                DeclBDefault[tb[node].son[1]];
                                seb[t.tagSei].immutable Ź TRUE;
                                tagType Ź SymbolOps.UnderType[
                                SymbolOps.own, Pass3Attributes.TargetType[seb[t.tagSei].idType]];
                                IF seb[tagType].typeTag # enumerated THEN {
                                    MimosaLog.ErrorSei[nonTagType, t.tagSei];
                                    tagType Ź typeANY;
                                    };
                                VariantList[tb[node].son[2], tagType];
                                };
                            sequence => {
                                DeclBDefault[tb[node].son[1]];
                                seb[t.tagSei].immutable Ź TRUE;
                                IF NOT Pass3Attributes.IndexType[seb[t.tagSei].idType] THEN
                                    MimosaLog.ErrorSei[nonTagType, t.tagSei];
                                TypeAttr[tb[node].son[2], indirect];
                                IF NOT ComponentType[t.componentType] THEN
                                    MimosaLog.ErrorTree[typeLength, tb[node].son[2]]
                                };
                            relative => {
                                subType, vType: CSEIndex;
                                nt: CSEIndex Ź SymbolOps.NormalType[SymbolOps.own, t.baseType];
                                TypeAttr[tb[node].son[1], TRUE];
                                IF nt = nullType OR seb[nt].typeTag # ref THEN MimosaLog.Error[relative];
                                TypeAttr[tb[node].son[2]];
                                vType Ź SymbolOps.UnderType[SymbolOps.own, t.offsetType];
                                subType Ź SymbolOps.NormalType[SymbolOps.own, vType];
                                SELECT SymbolOps.TypeForm[SymbolOps.own, subType] FROM
                                    $ref, $arraydesc => {};
                                    ENDCASE => {MimosaLog.Error[relative]; subType Ź typeANY};
                                t.resultType Ź subType;
                                };
                            opaque => {
                                son1: Tree.Link Ź tb[node].son[1];
                                IF son1 # Tree.Null THEN {
                                    son1 Ź tb[node].son[1] Ź Rhs[son1, MimData.idINT];
                                    IF ~RAttrPop[].const THEN MimosaLog.ErrorTree[nonConstant, son1];
                                    };
                                };
                            subrange => {
                                target: Type;
                                subNode: Tree.Index = GetNode[tb[node].son[2]];
                                TypeAttr[tb[node].son[1], indirect];
                                target Ź t.rangeType;
                                SELECT TRUE FROM
                                    (SymbolOps.TypeForm[SymbolOps.own, target] = $ref) =>
                                        target Ź MimData.idINT;
                                    Pass3Attributes.OrderedType[target] => {
                                        subType: CSEIndex = SymbolOps.UnderType[SymbolOps.own, target];
                                        WITH s: seb[subType] SELECT FROM
                                            real => MimosaLog.Error[subrangeNesting];
                                            ENDCASE;
                                        target Ź Pass3Attributes.TargetType[target];
                                        };
                                    ENDCASE => {MimosaLog.Error[nonOrderedType]; target Ź typeANY};
                                tb[subNode].son[1] Ź EndPoint[tb[subNode].son[1], target];
                                tb[subNode].son[2] Ź EndPoint[tb[subNode].son[2], target];
                                };
                            ENDCASE => ERROR;
                        };
                };
            ENDCASE => ERROR;
        };

    EndPoint: PROC [t: Tree.Link, target: Type] RETURNS [v: Tree.Link] = {
        v Ź Rhs[t, target];
        IF ~RAttrPop[].const THEN MimosaLog.ErrorTree[nonConstant, v];
        };

    ComponentType: PROC [type: Type] RETURNS [BOOL] = {
        sei: CSEIndex = SymbolOps.UnderType[SymbolOps.own, type];
        WITH t: seb[sei] SELECT FROM
            mode, any, nil => RETURN [FALSE];
            record => 
                IF t.hints.variant THEN
                    SELECT seb[MimP3.VariantUnionType[sei]].typeTag FROM
                        sequence => RETURN [FALSE];
                        ENDCASE;
            opaque => RETURN [t.lengthKnown];
            ENDCASE;
        RETURN [TRUE];
        };

<<record attribute collection>>
    FieldAttrs: TYPE = MACHINE DEPENDENT RECORD [
        positionValid: BOOL Ź FALSE,
        noAssign: BOOL Ź FALSE,
        refField, unVoidable, default: BOOL Ź FALSE,
        positions: PACKED ARRAY {implicit, explicit} OF BOOL Ź [FALSE, FALSE]];

    MergeAttrs: PROC [a1, a2: FieldAttrs] RETURNS [FieldAttrs] = INLINE {
        RETURN [LOOPHOLE [OSMiscOps.WordOr[LOOPHOLE[a1, WORD], LOOPHOLE[a2, WORD]]]];
        };

    UpdateHints: PROC [rSei: RecordSEIndex, attrs: FieldAttrs] = {
        seb[rSei].hints.assignable Ź ~attrs.noAssign;
        seb[rSei].hints.refField Ź attrs.refField;
        seb[rSei].hints.voidable Ź ~attrs.unVoidable;
        seb[rSei].hints.default Ź attrs.default;
        };

    AssignedPositions: PROC [attrs: FieldAttrs] RETURNS [assigned: BOOL Ź FALSE] = {
        IF attrs.positionValid THEN {
            IF attrs.positions = [TRUE, TRUE] THEN MimosaLog.Error[mixedPositions];
            assigned Ź attrs.positions[explicit];
            };
        };

    CollectAttrs: PROC [t: Tree.Link, attrs: FieldAttrs] RETURNS [FieldAttrs] = {
        ProcessField: Tree.Scan = {
            node: Tree.Index = GetNodeNoOptions[t];
            type: Type = Pass3Attributes.TypeForTree[tb[node].son[2]];
            subType: CSEIndex = SymbolOps.UnderType[SymbolOps.own, type];
            attrs Ź CheckPositions[tb[node].son[1], attrs];
            IF (IF tb[node].son[3] = Tree.Null
                THEN Pass3Attributes.Default[type] = nonVoid
                ELSE ProcessDefault[node]) THEN attrs.default Ź TRUE;
            WITH t: seb[subType] SELECT FROM
                union => {
                    subNode: Tree.Index = GetNodeNoOptions[tb[node].son[2]];
                    IF t.controlled THEN ProcessField[tb[subNode].son[1]];
                    attrs Ź MergeVariantAttrs[tb[subNode].son[2], attrs];
                    t.hints.refField Ź attrs.refField; t.hints.voidable Ź ~attrs.unVoidable;
                    t.hints.default Ź attrs.default;
                    tb[subNode].attr1 Ź attrs.positions[explicit];
                    };
                sequence => {
                    subNode: Tree.Index = GetNodeNoOptions[tb[node].son[2]];
                    IF t.controlled THEN ProcessField[tb[subNode].son[1]];
                    IF SymbolOps.RCType[SymbolOps.own, t.componentType] # none THEN {
                        IF ~t.controlled THEN MimosaLog.Error[attrClash];
                        attrs.refField Ź --attrs.unVoidable Ź-- TRUE};
                    attrs.noAssign Ź TRUE;
                    tb[subNode].attr1 Ź attrs.positions[explicit];
                    };
                ENDCASE => {
                    IF ~attrs.refField AND SymbolOps.RCType[SymbolOps.own, subType] # none THEN
                        attrs.refField Ź attrs.unVoidable Ź TRUE;
                    IF NOT attrs.unVoidable AND NOT Pass3Attributes.Voidable[type] THEN
                        attrs.unVoidable Ź TRUE;
                    IF NOT Pass3Attributes.AssignableType[subType, FALSE] THEN
                        attrs.noAssign Ź TRUE;
                    };
            };
        ScanList[t, ProcessField];
        RETURN [attrs];
        };

    GetNodeNoOptions: PROC [t: Tree.Link] RETURNS [Tree.Index] = {
        DO
            WITH e: t SELECT GetTag[t] FROM
                subtree => {
                    IF tb[e.index].name = optionTC THEN {t Ź tb[e.index].son[1]; LOOP};
                    RETURN [e.index];
                    };
                ENDCASE => ERROR;
            ENDLOOP;
        };

    ArgAttr: PROC [rSei: CSEIndex, t: Tree.Link, varOK: BOOL] = {
        IF rSei # CSENull THEN
            WITH seb[rSei] SELECT FROM
                record => {
                    ScanList[t, IF varOK THEN DeclBVarField ELSE DeclBField];
                    UpdateHints[LOOPHOLE[rSei], CollectAttrs[t, FieldAttrs[]]];
                    };
                ENDCASE
        };
<<machine dependent layout>>
    NumericConst: Tree.Map = {v Ź Rhs[t, MimData.idINT]; RPop[]};

    AssignedEnumeration: PROC [t: Tree.Link] RETURNS [assigned: BOOL] = {
        AssignElement: Tree.Scan = {
            WITH t SELECT GetTag[t] FROM
                subtree => {
                    node: Tree.Index = index;
                    tb[node].son[2] Ź NumericConst[tb[node].son[2]];  assigned Ź TRUE};
                ENDCASE => NULL;
            };
        assigned Ź FALSE;
        ScanList[t, AssignElement];
        };

    CheckPositions: PROC [t: Tree.Link, attrs: FieldAttrs] RETURNS [FieldAttrs] = {
        CheckPosition: Tree.Scan = {
            WITH t SELECT GetTag[t] FROM
                subtree => {
                    node: Tree.Index = GetNode[tb[index].son[2]];
                    IF ~attrs.positionValid THEN MimosaLog.ErrorSei[position, ItemId[tb[index].son[1]]];
                    tb[node].son[1] Ź NumericConst[tb[node].son[1]];
                    IF tb[node].son[2] # Tree.Null THEN {
                        subNode: Tree.Index = GetNode[tb[node].son[2]];
                        tb[subNode].son[1] Ź NumericConst[tb[subNode].son[1]];
                        tb[subNode].son[2] Ź NumericConst[tb[subNode].son[2]];
                        };
                    attrs.positions[explicit] Ź TRUE;
                    };
                ENDCASE => attrs.positions[implicit] Ź TRUE
            };
        ScanList[t, CheckPosition];
        RETURN [attrs];
        };
<<variants>>
    CheckDisjointPrefix: PROC [ctx: CTXIndex, link: Type] = {
        FOR sei: Type Ź link, SymbolOps.TypeLink[SymbolOps.own, sei] UNTIL sei = nullType DO
            type: CSEIndex = SymbolOps.UnderType[SymbolOps.own, sei];
            WITH t: seb[type] SELECT FROM
                record => CheckDisjoint[ctx, t.fieldCtx];
                ENDCASE;
            ENDLOOP;
        };

    VariantList: PROC [t: Tree.Link, tagType: CSEIndex] = {
        DefineTag: Tree.Scan = {
            sei: ISEIndex = GetSe[t];
            seb[sei].idValue Ź SymbolOps.EncodeCard[TagValue[seb[sei].hash, tagType]];
            };
        VariantItem: Tree.Scan = {
            node: Tree.Index = GetNode[t];
            saveIndex: SourceMap.Loc = MimData.textIndex;
            MimData.textIndex Ź ToLoc[tb[node].info];
            ScanList[tb[node].son[1], DefineTag];
            DeclBDefault[t];
            MimData.textIndex Ź saveIndex;
            };
        ScanList[t, VariantItem];
        };

    TagValue: PROC [tag: Name, tagType: CSEIndex] RETURNS [CARD] = {
        WITH t: seb[tagType] SELECT FROM
            enumerated => {
                matched: BOOL;
                sei: ISEIndex;
                [matched, sei] Ź SearchCtxList[tag, t.valueCtx];
                IF matched THEN RETURN [SymbolOps.DecodeCard[seb[sei].idValue]];
                };
            ENDCASE;
        MimosaLog.ErrorHti[unknownTag, tag];
        RETURN [0];
        };

    MergeVariantAttrs: PROC
    [list: Tree.Link, prefixAttrs: FieldAttrs] RETURNS [mergedAttrs: FieldAttrs] = {
        ProcessVariant: Tree.Scan = {
            node: Tree.Index = GetNode[t];
            ProcessLabel: Tree.Scan = {
                sei: ISEIndex = GetSe[t];
                type: Type = SymbolOps.DecodeType[seb[sei].idInfo];
                WITH v: seb[type] SELECT FROM
                    cons =>
                        WITH r: v SELECT FROM
                            record => {
                                subNode: Tree.Index = GetNode[tb[node].son[2]];
                                attrs: FieldAttrs = CollectAttrs[tb[subNode].son[1], prefixAttrs];
                                UpdateHints[LOOPHOLE[type], attrs];
                                r.hints.default Ź TRUE;
                                tb[subNode].attr1 Ź attrs.positions[explicit];
                                mergedAttrs Ź MergeAttrs[mergedAttrs, attrs];
                                };
                            ENDCASE;
                    ENDCASE;
                };
            ScanList[tb[node].son[1], ProcessLabel];
            };
        mergedAttrs Ź prefixAttrs;
        ScanList[list, ProcessVariant];
        mergedAttrs.default Ź prefixAttrs.default;
        };
<<type construction>>
    MakeLongType: PUBLIC PROC [rType, hint: Type Ź nullType] RETURNS [type: Type] = {
        subType: CSEIndex = SymbolOps.UnderType[SymbolOps.own, rType];
        protoType: CSEIndex = SymbolOps.UnderType[SymbolOps.own, hint];
        WITH t: seb[subType] SELECT FROM
            basic =>
                IF t.length = Target.bitsPerLongWord THEN RETURN [rType];
            ref =>
                IF t.length = Target.bitsPerLongWord THEN RETURN [rType];
            signed =>
                IF t.length = Target.bitsPerLongWord THEN RETURN [rType];
            unsigned =>
                IF t.length = Target.bitsPerLongWord THEN RETURN [rType];
            real =>
                SELECT t.length FROM
                    Target.bitsPerReal => RETURN [MimData.idDREAL];
                    Target.bitsPerReal*2 => RETURN [MimData.idDREAL];
                    ENDCASE => ERROR;
            relative => {
                oType: Type = MakeLongType[t.offsetType, t.resultType];
                type Ź SymbolOps.MakeNonCtxSe[SERecord.cons.relative.SIZE];
                seb[type] Ź [mark3: TRUE, mark4: TRUE, body: cons[
                    align: unknown,
                    typeInfo: relative[baseType: t.baseType, offsetType: oType, resultType: oType]]];
                RETURN;
                };
            arraydesc => {
                longLength: NAT = Target.bitsPerLongWord+Target.bitsPerWord;
                shortLength: NAT = Target.bitsPerWord+Target.bitsPerWord;
                SELECT t.length FROM
                    longLength => RETURN [rType];
                    shortLength => {
                        type Ź SymbolOps.MakeNonCtxSe[SERecord.cons.relative.SIZE];
                        seb[type] Ź [mark3: TRUE, mark4: TRUE, body: cons[
                            align: MimData.wordAlignment,
                            typeInfo: arraydesc[
                            describedType: t.describedType,
                            var: t.var,
                            readOnly: t.readOnly,
                            bitOrder: t.bitOrder,
                            length: longLength]]];
                        RETURN [type];
                        };
                    ENDCASE => ERROR;
                };
            ENDCASE;
        MimosaLog.Error[long];
        RETURN [rType];
        };

    MakeRefType: PUBLIC PROC
    [cType, hint: Type, bits: NAT, readOnly, counted, var: BOOL]
    RETURNS [type: RefSEIndex] = {
        protoType: CSEIndex = SymbolOps.UnderType[SymbolOps.own, hint];
        WITH p: seb[protoType] SELECT FROM
            ref =>
                IF ~p.ordered AND p.readOnly = readOnly AND p.counted = counted AND p.var = var AND SymbolOps.EqTypes[SymbolOps.own, p.refType, 
                cType] THEN
                    RETURN [LOOPHOLE[protoType]];
            ENDCASE;
        IF bits < Target.bitsPerWord THEN bits Ź Target.bitsPerWord;
        type Ź LOOPHOLE[SymbolOps.MakeNonCtxSe[SERecord.cons.ref.SIZE]];
        seb[type] Ź [mark3: TRUE, mark4: TRUE, body: cons[
            align: MimData.wordAlignment,
            typeInfo: ref[
                counted: counted,
                var: var,
                readOnly: readOnly, ordered: FALSE, list: FALSE, basing: FALSE,
                refType: cType,
                length: IF counted THEN Target.bitsPerRef ELSE bits]]];
        };
}.
    <<Russ Atkinson (RRA) July 31, 1987 7:07:07 pm PDT>>
        <<Added handling of optionTC (replaces use of packedTC)>>
    <<>>