move lots of source files around to match their actual placement in the original treemain

1 files changed, 2068 insertions, 0 deletions

diff --git a/compiler_and_linker/FrontEnd/C/CSOM.c b/compiler_and_linker/FrontEnd/C/CSOM.c
new file mode 100644
index 0000000..7e80e32
--- /dev/null
+++ b/compiler_and_linker/FrontEnd/C/CSOM.c
@@ -0,0 +1,2068 @@
+#include "compiler/CSOM.h"
+#include "compiler/CClass.h"
+#include "compiler/CDecl.h"
+#include "compiler/CError.h"
+#include "compiler/CException.h"
+#include "compiler/CExpr.h"
+#include "compiler/CFunc.h"
+#include "compiler/CInit.h"
+#include "compiler/CInt64.h"
+#include "compiler/CMachine.h"
+#include "compiler/CMangler.h"
+#include "compiler/CParser.h"
+#include "compiler/CPrep.h"
+#include "compiler/CPrepTokenizer.h"
+#include "compiler/CScope.h"
+#include "compiler/CodeGen.h"
+#include "compiler/CompilerTools.h"
+#include "compiler/objects.h"
+#include "compiler/scopes.h"
+#include "compiler/types.h"
+#include "cos.h"
+
+// all pointers have been converted to UInt32 for the sake of maintaining 32-bit compat
+
+typedef struct {
+    SInt32 zero;
+    /* struct somStaticClassInfo * */ UInt32 sci;
+    /* void * */ UInt32 instanceDataToken;
+    SInt32 reserved[3];
+    /* void * */ UInt32 tokens[1];
+} somClassDataStructure;
+
+enum {
+    mtVirtualMethod = 0,
+    mtProcedure = 1,
+    mtNonStatic = 2,
+    mtEmpty = 3,
+    mtDToken = 4
+};
+
+enum {
+    pdUByte = 0,
+    pdSByte = 1,
+    pdUHalf = 2,
+    pdSHalf = 3,
+    pdULong = 4,
+    pdSLong = 5,
+    pdVLong = 6,
+    pdVoid = 7,
+    pdSFlt = 8,
+    pdDFlt = 9,
+    pdLFlt = 10,
+    pdVSAgg = 11,
+    pdNPtr = 12,
+    pdLPtr = 13,
+    pdSAgg = 14,
+    pdLAgg = 15
+};
+
+enum {
+    fgShortOrChars = 1,
+    fgShortFloats = 2,
+    fgAnyFloats = 4,
+    fgAnyNon4Bytes = 8
+};
+
+enum {
+    cfSharedStrings = 1,
+    cfTempClass = 2,
+    cfProxyClass = 4,
+    cfClassAllocate = 0x100,
+    cfClassDeallocate = 0x200,
+    cfClassInit = 0x400,
+    cfClassUninit = 0x800
+};
+
+typedef struct {
+    UInt32 majorVersion;
+    UInt32 minorVersion;
+    UInt32 flags;
+    UInt16 dataAlignment;
+    UInt16 classTokenCount;
+    UInt16 numDirectParents;
+    UInt16 numMetaClasses;
+    UInt16 numOverriddenAncestors;
+    UInt16 numMigratedMethods;
+    UInt16 numSelectInherited;
+    UInt16 numUnused;
+    UInt16 dummy2a[4];
+} somStaticClassCounts;
+
+typedef UInt8 somSlotUsage;
+typedef UInt8 somSignatureInfo;
+typedef UInt16 somOverrideData;
+typedef UInt16 somMigratedMethods;
+typedef UInt16 somSelectedInherited;
+typedef UInt32 somParentVersions;
+
+typedef struct {
+    /* const char * */ UInt32 className;
+    UInt32 instanceDataSize;
+    /* const somParentVersions * */ UInt32 parentVersions;
+    /* const somSlotUsage * */ UInt32 ttSlotUsage;
+    /* const somSignatureInfo * */ UInt32 signatureInfo;
+    /* const char * */ UInt32 methodNames;
+    /* const somOverrideData * */ UInt32 overrideData;
+    /* const somMigratedMethods * */ UInt32 migratedMethods;
+    /* const somSelectedInherited * */ UInt32 selectedInherited;
+    /* const void * */ UInt32 unused;
+    /* const void * */ UInt32 dummy4b[4];
+} somStaticClassDescription;
+
+typedef struct somStaticClassInfo {
+    UInt32 layoutVersion;
+    /* somClassDataStructure * */ UInt32 tokenTable;
+    /* somMethodPtr * */ UInt32 overrideMethods;
+    /* somClassDataStructure ** */ UInt32 specifiedAncestry;
+    /* somOpaque */ UInt32 DLLDesignator;
+    /* somMethodPtr * */ UInt32 specialProcs;
+    /* somRuntimeClassInfo * */ UInt32 runtimeClassInfo;
+    SInt32 interesting;
+    /* somClassDataStructure ** */ UInt32 actualAncestry;
+    /* void * */ UInt32 extra[4];
+    /* const somStaticClassCounts * */ UInt32 classCounts;
+    somStaticClassDescription classDescription;
+} somStaticClassInfo;
+
+CSOMStub *csom_stubs;
+static HashNameNode *csom_initname;
+static HashNameNode *csom_uninitname;
+static HashNameNode *csom_envname;
+static HashNameNode *csom_selfname;
+
+static FuncArg SOMIDT_arg1 = {
+    NULL,
+    NULL,
+    NULL,
+    TYPE(&void_ptr),
+    0,
+    0,
+    0
+};
+
+static TypeFunc SOMIDT_type = {
+    TYPEFUNC,
+    0,
+    &SOMIDT_arg1,
+    NULL,
+    TYPE(&void_ptr),
+    0,
+    0
+};
+
+void CSOM_Setup(Boolean flag) {
+    if (!flag)
+        csom_stubs = NULL;
+
+    csom_initname = GetHashNameNodeExport("somInit");
+    csom_uninitname = GetHashNameNodeExport("somUninit");
+    csom_envname = GetHashNameNodeExport("Environment");
+    csom_selfname = GetHashNameNodeExport("__somself");
+}
+
+void CSOM_Cleanup(void) {
+    CSOMStub *stub;
+
+    if (cparamblkptr->precompile != 1) {
+        for (stub = csom_stubs; stub; stub = stub->next) {
+            switch (stub->x10) {
+                case 0:
+                    CodeGen_SOMStub(stub->object, rt_som_glue1, stub->tclass->sominfo->classdataobject, stub->offset);
+                    break;
+                case 1:
+                    CodeGen_SOMStub(stub->object, rt_som_glue2, stub->tclass->sominfo->classdataobject, stub->offset);
+                    break;
+                case 2:
+                    CodeGen_SOMStub(stub->object, rt_som_glue3, stub->tclass->sominfo->classdataobject, stub->offset);
+                    break;
+                default:
+                    CError_FATAL(132);
+            }
+        }
+    }
+}
+
+static HashNameNode *CSOM_NameTranslate(HashNameNode *name) {
+    if (name == constructor_name_node)
+        name = csom_initname;
+    else if (name == destructor_name_node)
+        name = csom_uninitname;
+    return name;
+}
+
+static Type *CSOM_FindClassType(HashNameNode *name) {
+    Type *type;
+
+    type = CScope_GetTagType(cscope_current, name);
+    if (!type) {
+        CPrep_ErrorName(CErrorStr281, name->name);
+        type = &stvoid;
+    }
+
+    return type;
+}
+
+CW_INLINE UInt16 CSOM_GetTokenTableIndex(const Object *object) {
+    CError_ASSERT(173, IS_TYPE_METHOD(object->type));
+    return TYPE_METHOD(object->type)->vtbl_index;
+}
+
+static SInt32 CSOM_GetTokenOffset(Object *object) {
+    return 24 + 4 * CSOM_GetTokenTableIndex(object);
+}
+
+typedef struct TypeSig {
+    UInt8 x0;
+    UInt8 x1;
+    UInt8 x2;
+} TypeSig;
+
+static int CSOM_GetTypeSig(TypeSig *sig, Type *type, Boolean flag) {
+    if (type->size > 4)
+        sig->x1 |= fgAnyNon4Bytes;
+
+    switch (type->type) {
+        case TYPEVOID:
+            if (flag)
+                return pdVoid;
+            break;
+        case TYPEINT:
+        case TYPEENUM:
+            if (is_unsigned(type)) {
+                switch (type->size) {
+                    case 1:
+                        sig->x1 |= fgShortOrChars;
+                        return pdUByte;
+                    case 2:
+                        sig->x1 |= fgShortOrChars;
+                        return pdUHalf;
+                    case 4:
+                        return pdULong;
+                    case 8:
+                        return pdVLong;
+                }
+            } else {
+                switch (type->size) {
+                    case 1:
+                        sig->x1 |= fgShortOrChars;
+                        return pdSByte;
+                    case 2:
+                        sig->x1 |= fgShortOrChars;
+                        return pdSHalf;
+                    case 4:
+                        return pdSLong;
+                    case 8:
+                        return pdVLong;
+                }
+            }
+            break;
+        case TYPEFLOAT:
+            sig->x1 |= fgAnyFloats;
+            switch (type->size) {
+                case 4:
+                    sig->x1 |= fgShortFloats;
+                    return pdSFlt;
+                case 8:
+                    return pdDFlt;
+                case 12:
+                case 16:
+                    return pdLFlt;
+            }
+            break;
+        case TYPEPOINTER:
+            return pdNPtr;
+        case TYPESTRUCT:
+        case TYPECLASS:
+            if (flag) {
+                if (type->size <= 2) {
+                    sig->x1 |= fgShortOrChars;
+                    return pdVSAgg;
+                } else if (type->size <= 4) {
+                    return pdSAgg;
+                } else {
+                    return pdLAgg;
+                }
+            }
+            break;
+    }
+
+    CError_Error(CErrorStr273);
+    return 5;
+}
+
+static void CSOM_GetFuncSig(TypeFunc *tfunc, Boolean flag) {
+    FuncArg *arg;
+    Boolean pendingData;
+    UInt8 work;
+    TypeSig sig;
+
+    sig.x2 = CSOM_GetTypeSig(&sig, tfunc->functype, 1);
+    sig.x1 = 0;
+    sig.x0 = 0;
+
+    for (arg = tfunc->args; arg; arg = arg->next) {
+        if (arg == &elipsis || arg == &oldstyle || (++sig.x0 == 0)) {
+            CError_Error(CErrorStr273);
+            break;
+        }
+
+        CSOM_GetTypeSig(&sig, arg->type, 0);
+    }
+
+    if (flag) {
+        if ((arg = tfunc->args)) {
+            if (TYPE_METHOD(tfunc)->is_static == 0)
+                arg = arg->next;
+            if (arg && CMach_GetFunctionResultClass(tfunc) != 0)
+                arg = arg->next;
+        }
+
+        AppendGListByte(&name_mangle_list, sig.x0);
+        AppendGListByte(&name_mangle_list, (sig.x1 << 4) | sig.x2);
+        if (sig.x1) {
+            pendingData = 0;
+            work = 0;
+            while (arg) {
+                work = (work << 4) | CSOM_GetTypeSig(&sig, arg->type, 0);
+                if (pendingData) {
+                    AppendGListByte(&name_mangle_list, work);
+                    pendingData = 0;
+                    work = 0;
+                } else {
+                    pendingData = 1;
+                }
+                arg = arg->next;
+            }
+
+            if (pendingData)
+                AppendGListByte(&name_mangle_list, work << 4);
+        }
+    }
+}
+
+void CSOM_CheckFuncType(TypeFunc *tfunc) {
+    CSOM_GetFuncSig(tfunc, 0);
+}
+
+static Object *CSOM_MakeObject(char *name1, char *name2, SInt32 size) {
+    Object *object = CParser_NewCompilerDefDataObject();
+    object->name = CParser_NameConcat(name1, name2);
+    object->type = CDecl_NewStructType(size, 4);
+    CScope_AddObject(object->nspace, object->name, OBJ_BASE(object));
+    return object;
+}
+
+void CSOM_MakeSOMClass(TypeClass *tclass) {
+    ClassList *base;
+
+    for (base = tclass->bases; base; base = base->next) {
+        if (!base->base->sominfo) {
+            CError_Error(CErrorStr267);
+            break;
+        }
+    }
+
+    if (!tclass->sominfo) {
+        SOMInfo *info = galloc(sizeof(SOMInfo));
+        memclrw(info, sizeof(SOMInfo));
+        tclass->sominfo = info;
+
+        info->classdataobject = CSOM_MakeObject(tclass->classname->name, "ClassData", 28);
+        info->classdataobject->flags = info->classdataobject->flags | OBJECT_EXPORT;
+    }
+}
+
+static Boolean CSOM_IsTokenListFunc(Object *object) {
+    Type *type = object->type;
+    if (
+        IS_TYPE_FUNC(type) &&
+        !(TYPE_FUNC(type)->flags & FUNC_FLAGS_20) &&
+        !TYPE_METHOD(type)->is_static &&
+        (!(object->qual & Q_INLINE) || object->datatype == DVFUNC)
+        )
+        return 1;
+
+    return 0;
+}
+
+static Object **CSOM_GetLexicalOrderMethodArray(TypeClass *tclass, int *resultCount) {
+    Object *object;
+    int count;
+    Object **array;
+    CScopeObjectIterator iter;
+
+    count = 0;
+    CScope_InitObjectIterator(&iter, tclass->nspace);
+    while (1) {
+        if (!(object = OBJECT(CScope_NextObjectIteratorObject(&iter))))
+            break;
+
+        if (IS_TYPE_METHOD(object->type)) {
+            if (CSOM_IsTokenListFunc(object)) {
+                if (TYPE_METHOD(object->type)->vtbl_index > count)
+                    count = TYPE_METHOD(object->type)->vtbl_index;
+            } else {
+                TYPE_METHOD(object->type)->vtbl_index = 0;
+            }
+        }
+    }
+
+    *resultCount = ++count;
+
+    array = lalloc(sizeof(Object *) * count);
+    memclrw(array, sizeof(Object *) * count);
+
+    CScope_InitObjectIterator(&iter, tclass->nspace);
+    while (1) {
+        if (!(object = OBJECT(CScope_NextObjectIteratorObject(&iter))))
+            break;
+
+        if (CSOM_IsTokenListFunc(object))
+            array[TYPE_METHOD(object->type)->vtbl_index] = object;
+    }
+
+    return array;
+}
+
+void CSOM_ClassComplete(TypeClass *tclass) {
+    Object *object;
+    CScopeObjectIterator iter;
+    SInt32 counter;
+    SOMReleaseOrder *order;
+
+    if (tclass->sominfo->order) {
+        CScope_InitObjectIterator(&iter, tclass->nspace);
+        while (1) {
+            if (!(object = OBJECT(CScope_NextObjectIteratorObject(&iter))))
+                break;
+
+            if (CSOM_IsTokenListFunc(object)) {
+                HashNameNode *name;
+
+                name = CSOM_NameTranslate(object->name);
+                for (order = tclass->sominfo->order, counter = 0; order; order = order->next, counter++) {
+                    if (order->name == name) {
+                        order->state = SOMMS_Method;
+                        TYPE_METHOD(object->type)->vtbl_index = counter;
+                        break;
+                    }
+                }
+
+                if (!order)
+                    CError_Error(CErrorStr278, object);
+            }
+        }
+
+        for (order = tclass->sominfo->order; order; order = order->next) {
+            if (order->state == SOMMS_Deleted) {
+                SOMReleaseOrder *order2;
+                VClassList *vbase;
+                for (vbase = tclass->vbases; vbase; vbase = vbase->next) {
+                    for (order2 = vbase->base->sominfo->order; order2; order2 = order2->next) {
+                        if (order->name == order2->name && order2->state == SOMMS_Method) {
+                            order->state = SOMMS_Migrated;
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+    } else {
+        Object **array;
+        int arrayCount;
+        SInt32 i;
+
+        array = CSOM_GetLexicalOrderMethodArray(tclass, &arrayCount);
+        for (i = counter = 0; i < arrayCount; i++) {
+            object = array[i];
+            if (object) {
+                if (counter == 0 && copts.pedantic)
+                    CError_Warning(CErrorStr291);
+                TYPE_METHOD(object->type)->vtbl_index = counter++;
+            }
+        }
+    }
+
+    CScope_InitObjectIterator(&iter, tclass->nspace);
+    while (1) {
+        NameSpaceObjectList *nsol;
+        if (!(nsol = CScope_NextObjectIteratorObjectList(&iter)))
+            break;
+
+        if (nsol->object->otype == OT_OBJECT && nsol->next && nsol->next->object->otype == OT_OBJECT) {
+            while (nsol) {
+                if (
+                    nsol->object->otype == OT_OBJECT &&
+                    (!(OBJECT(nsol->object)->qual & Q_INLINE) || OBJECT(nsol->object)->datatype == DVFUNC)
+                    )
+                    CError_Error(CErrorStr270, nsol->object);
+                nsol = nsol->next;
+            }
+        }
+    }
+
+    CScope_InitObjectIterator(&iter, tclass->nspace);
+    while (1) {
+        if (!(object = OBJECT(CScope_NextObjectIteratorObject(&iter))))
+            break;
+
+        if (!(object->qual & Q_INLINE)) {
+            CError_ASSERT(529, IS_TYPE_FUNC(object->type));
+
+            TYPE_FUNC(object->type)->flags |= FUNC_FLAGS_4;
+            tclass->action = CLASS_ACTION_1;
+            while (1) {
+                if (!(object = OBJECT(CScope_NextObjectIteratorObject(&iter))))
+                    break;
+
+                if (IS_TYPE_FUNC(object->type))
+                    TYPE_FUNC(object->type)->flags &= ~FUNC_FLAGS_4;
+            }
+            break;
+        }
+    }
+
+    if (tclass->sominfo->oidl_callstyle == 0) {
+        Type *envType;
+        envType = CSOM_FindClassType(csom_envname);
+
+        CScope_InitObjectIterator(&iter, tclass->nspace);
+        while (1) {
+            if (!(object = OBJECT(CScope_NextObjectIteratorObject(&iter))))
+                break;
+
+            if (
+                IS_TYPE_FUNC(object->type) &&
+                TYPE_METHOD(object->type)->is_static == 0 &&
+                !(TYPE_FUNC(object->type)->flags & FUNC_FLAGS_20) &&
+                !(
+                    TYPE_FUNC(object->type)->args &&
+                    TYPE_FUNC(object->type)->args->next &&
+                    IS_TYPE_POINTER_ONLY(TYPE_FUNC(object->type)->args->next->type) &&
+                    TPTR_TARGET(TYPE_FUNC(object->type)->args->next->type) == envType
+                    )
+                )
+            {
+                CError_Error(CErrorStr282, object);
+            }
+        }
+    }
+
+    if (tclass->action == CLASS_ACTION_0)
+        CError_Error(CErrorStr280);
+}
+
+#ifdef __MWERKS__
+#pragma options align=mac68k
+#endif
+typedef struct SOMOverride {
+    struct SOMOverride *next;
+    Object *a;
+    Object *b;
+} SOMOverride;
+
+typedef struct SOMAncestor {
+    struct SOMAncestor *next;
+    TypeClass *tclass;
+    SOMOverride *overrides;
+    Boolean xC;
+    Boolean xD;
+} SOMAncestor;
+
+typedef struct SOMMethod {
+    struct SOMMethod *next;
+    HashNameNode *name;
+    union {
+        Object *object;
+        struct {
+            UInt16 a;
+            UInt16 b;
+        } pair;
+    } u;
+    SOMMethodState state;
+} SOMMethod;
+
+typedef struct SOMGenerator {
+    SOMMethod *methods;
+    SOMAncestor *ancestors;
+    Object *sciObj;
+    Object *classAncestorsObj;
+    Object *overrideProcsObj;
+    Object *dlldFunc;
+    Object *specialProcsObj;
+    somStaticClassCounts counts;
+    int overrideProcsCount;
+    Boolean hasNew;
+    Boolean hasDelete;
+} SOMGenerator;
+#ifdef __MWERKS__
+#pragma options align=reset
+#endif
+
+static SOMAncestor *CSOM_FindAddAncestor(SOMGenerator *gen, TypeClass *tclass, TypeClass *ancestorClass, UInt16 *resultIndex) {
+    SOMAncestor *ancestor;
+    SOMAncestor *scan;
+    UInt16 index;
+
+    ancestor = gen->ancestors;
+    for (scan = ancestor, index = 0; scan; scan = scan->next, index++) {
+        if (scan->tclass == ancestorClass) {
+            if (resultIndex)
+                *resultIndex = index;
+            return scan;
+        }
+    }
+
+    if (ancestor) {
+        index = 1;
+        while (ancestor->next) {
+            index++;
+            ancestor = ancestor->next;
+        }
+
+        ancestor->next = lalloc(sizeof(SOMAncestor));
+        memclrw(ancestor->next, sizeof(SOMAncestor));
+        ancestor = ancestor->next;
+    } else {
+        index = 0;
+        ancestor = lalloc(sizeof(SOMAncestor));
+        memclrw(ancestor, sizeof(SOMAncestor));
+        gen->ancestors = ancestor;
+    }
+
+    ancestor->tclass = ancestorClass;
+    if (resultIndex)
+        *resultIndex = index;
+    return ancestor;
+}
+
+static void CSOM_GenerateOverrideIntroLists(SOMGenerator *gen, TypeClass *tclass) {
+    Object *object;
+    VClassList *vbase;
+    ClassList *base;
+    SOMMethod *method;
+    SOMMethod **ptr;
+    CScopeObjectIterator iter;
+
+    for (base = tclass->bases; base; base = base->next) {
+        SOMAncestor *ancestor = CSOM_FindAddAncestor(gen, tclass, base->base, NULL);
+        ancestor->xD = 1;
+        gen->counts.numDirectParents++;
+    }
+
+    if (tclass->sominfo->metaclass && tclass->sominfo->metaclass->sominfo) {
+        SOMAncestor *ancestor = CSOM_FindAddAncestor(gen, tclass, tclass->sominfo->metaclass, NULL);
+        ancestor->xC = 1;
+        gen->counts.numMetaClasses++;
+    }
+
+    CScope_InitObjectIterator(&iter, tclass->nspace);
+    while (1) {
+        if (!(object = OBJECT(CScope_NextObjectIteratorObject(&iter))))
+            break;
+
+        if (IS_TYPE_FUNC(object->type) && (TYPE_FUNC(object->type)->flags & FUNC_FLAGS_20)) {
+            for (vbase = tclass->vbases; vbase; vbase = vbase->next) {
+                Object *object2;
+                CScopeObjectIterator iter2;
+                CScope_InitObjectIterator(&iter2, vbase->base->nspace);
+                while (1) {
+                    if (!(object2 = OBJECT(CScope_NextObjectIteratorObject(&iter2))))
+                        break;
+
+                    if (
+                        IS_TYPE_FUNC(object2->type) &&
+                        object->name == object2->name &&
+                        object2->datatype == DVFUNC &&
+                        !(TYPE_FUNC(object2->type)->flags & FUNC_FLAGS_20) &&
+                        CClass_GetOverrideKind(TYPE_FUNC(object->type), TYPE_FUNC(object2->type), 0) != 0
+                        )
+                    {
+                        SOMAncestor *ancestor;
+                        SOMOverride *override;
+                        ancestor = CSOM_FindAddAncestor(gen, tclass, vbase->base, NULL);
+                        if (ancestor->overrides) {
+                            override = lalloc(sizeof(SOMOverride));
+                            memclrw(override, sizeof(SOMOverride));
+                            override->next = ancestor->overrides;
+                            ancestor->overrides = override;
+                        } else {
+                            override = lalloc(sizeof(SOMOverride));
+                            memclrw(override, sizeof(SOMOverride));
+                            ancestor->overrides = override;
+                            gen->counts.numOverriddenAncestors++;
+                        }
+                        override->a = object;
+                        override->b = object2;
+                        break;
+                    }
+                }
+            }
+            gen->overrideProcsCount++;
+        }
+    }
+
+    ptr = &gen->methods;
+    if (tclass->sominfo->order) {
+        SOMReleaseOrder *order;
+        SOMReleaseOrder *order2;
+        SInt32 index;
+        UInt16 index2;
+
+        for (order = tclass->sominfo->order, index = 0; order; order = order->next, index++) {
+            method = lalloc(sizeof(SOMMethod));
+            memclrw(method, sizeof(SOMMethod));
+            *ptr = method;
+            ptr = &method->next;
+
+            method->name = order->name;
+            method->state = order->state;
+            switch (order->state) {
+                case SOMMS_Migrated:
+                    for (vbase = tclass->vbases; vbase; vbase = vbase->next) {
+                        for (order2 = vbase->base->sominfo->order, index2 = 0; order2; order2 = order2->next, index2++) {
+                            if (order->name == order2->name && order2->state == SOMMS_Method) {
+                                CSOM_FindAddAncestor(gen, tclass, vbase->base, &method->u.pair.a);
+                                method->u.pair.b = index2;
+                                break;
+                            }
+                        }
+
+                        if (order2)
+                            break;
+                    }
+                    gen->counts.numMigratedMethods++;
+                    break;
+
+                case SOMMS_Method:
+                    CScope_InitObjectIterator(&iter, tclass->nspace);
+                    while (1) {
+                        if (!(object = OBJECT(CScope_NextObjectIteratorObject(&iter))))
+                            break;
+
+                        if (
+                            IS_TYPE_FUNC(object->type) &&
+                            CSOM_NameTranslate(object->name) == order->name
+                            )
+                        {
+                            CError_ASSERT(733, TYPE_METHOD(object->type)->vtbl_index == index);
+                            method->u.object = object;
+                            break;
+                        }
+                    }
+
+                    CError_ASSERT(737, object != NULL);
+                    break;
+            }
+
+            gen->counts.classTokenCount++;
+        }
+    } else {
+        Object **array;
+        int arrayCount;
+        SInt32 i;
+
+        array = CSOM_GetLexicalOrderMethodArray(tclass, &arrayCount);
+        for (i = 0; i < arrayCount; i++) {
+            object = array[i];
+            if (object) {
+                method = lalloc(sizeof(SOMMethod));
+                memclrw(method, sizeof(SOMMethod));
+                *ptr = method;
+                ptr = &method->next;
+
+                method->u.object = object;
+                method->name = object->name;
+                method->state = SOMMS_Method;
+                gen->counts.classTokenCount++;
+            }
+        }
+    }
+}
+
+static void CSOM_GenerateClassAncestors(SOMGenerator *gen, TypeClass *tclass) {
+    SOMAncestor *ancestor;
+    Object *object;
+    OLinkList *relocs;
+    SInt32 size;
+    char *buf;
+
+    if (gen->ancestors) {
+        object = CSOM_MakeObject(tclass->classname->name, "ClassAncestors", 4);
+        object->sclass = TK_STATIC;
+
+        relocs = NULL;
+        size = 0;
+        for (ancestor = gen->ancestors; ancestor; ancestor = ancestor->next) {
+            OLinkList *reloc = lalloc(sizeof(OLinkList));
+            reloc->next = relocs;
+            relocs = reloc;
+            reloc->obj = ancestor->tclass->sominfo->classdataobject;
+            reloc->offset = size;
+            reloc->somevalue = 0;
+            size += 4;
+        }
+
+        buf = lalloc(size);
+        memclrw(buf, size);
+        object->type->size = size;
+        CInit_DeclareData(object, buf, relocs, object->type->size);
+        gen->classAncestorsObj = object;
+    }
+}
+
+static void CSOM_GenerateOverrideProcs(SOMGenerator *gen, TypeClass *tclass) {
+    SOMOverride *override;
+    SOMAncestor *ancestor;
+    Object *object;
+    OLinkList *relocs;
+    SInt32 size;
+    SInt32 offset;
+    char *buf;
+
+    if (gen->overrideProcsCount) {
+        size = gen->overrideProcsCount * 4;
+        object = CSOM_MakeObject(tclass->classname->name, "OverrideProcs", size);
+        object->sclass = TK_STATIC;
+
+        relocs = NULL;
+        offset = 0;
+        for (ancestor = gen->ancestors; ancestor; ancestor = ancestor->next) {
+            if (ancestor->overrides) {
+                for (override = ancestor->overrides; override; override = override->next) {
+                    OLinkList *reloc = lalloc(sizeof(OLinkList));
+                    reloc->next = relocs;
+                    relocs = reloc;
+                    reloc->obj = override->a;
+                    reloc->offset = offset;
+                    reloc->somevalue = 0;
+                    offset += 4;
+                }
+            }
+        }
+
+        buf = lalloc(size);
+        memclrw(buf, size);
+        CInit_DeclareData(object, buf, relocs, object->type->size);
+        gen->overrideProcsObj = object;
+    }
+}
+
+static Object *CSOM_GenerateOverrideData(SOMGenerator *gen) {
+    SOMAncestor *ancestor;
+    Object *object;
+    short ancestorIndex;
+
+    name_mangle_list.size = 0;
+    for (ancestor = gen->ancestors, ancestorIndex = 0; ancestor; ancestor = ancestor->next, ancestorIndex++) {
+        if (ancestor->overrides) {
+            SOMOverride *override;
+            short overrideCount;
+
+            AppendGListWord(&name_mangle_list, CTool_EndianConvertWord16(ancestorIndex));
+
+            override = ancestor->overrides;
+            overrideCount = 0;
+            while (override) {
+                overrideCount++;
+                override = override->next;
+            }
+            AppendGListWord(&name_mangle_list, CTool_EndianConvertWord16(overrideCount));
+
+            for (override = ancestor->overrides; override; override = override->next) {
+                AppendGListWord(&name_mangle_list, CTool_EndianConvertWord16(CSOM_GetTokenTableIndex(override->b)));
+            }
+        }
+    }
+
+    COS_LockHandle(name_mangle_list.data);
+    object = CInit_DeclareString(*name_mangle_list.data, name_mangle_list.size, 0, 0);
+    COS_UnlockHandle(name_mangle_list.data);
+    return object;
+}
+
+static Object *CSOM_GenerateMigrateData(SOMGenerator *gen) {
+    SOMMethod *method;
+    Object *object;
+    int index;
+
+    name_mangle_list.size = 0;
+    for (method = gen->methods, index = 0; method; method = method->next, index++) {
+        if (method->state == SOMMS_Migrated) {
+            AppendGListWord(&name_mangle_list, CTool_EndianConvertWord16(method->u.pair.a));
+            AppendGListWord(&name_mangle_list, CTool_EndianConvertWord16(method->u.pair.b));
+            AppendGListWord(&name_mangle_list, CTool_EndianConvertWord16(index));
+        }
+    }
+
+    COS_LockHandle(name_mangle_list.data);
+    object = CInit_DeclareString(*name_mangle_list.data, name_mangle_list.size, 0, 0);
+    COS_UnlockHandle(name_mangle_list.data);
+    return object;
+}
+
+static void CSOM_GenerateDLLDFunc(SOMGenerator *gen, TypeClass *tclass) {
+    TypeFunc *tfunc;
+    Object *object;
+
+    tfunc = galloc(sizeof(TypeFunc));
+    memclrw(tfunc, sizeof(TypeFunc));
+    tfunc->type = TYPEFUNC;
+    tfunc->functype = &stvoid;
+
+    object = CParser_NewCompilerDefFunctionObject();
+    object->type = TYPE(tfunc);
+    object->sclass = TK_STATIC;
+    object->name = CParser_NameConcat(tclass->classname->name, "DLLD");
+
+    if (CScope_GetLocalObject(cscope_root, object->name))
+        CError_Error(CErrorStr333, object);
+
+    gen->dlldFunc = object;
+    CFunc_GenerateDummyFunction(object);
+}
+
+static void CSOM_GenerateSpecialProcs(SOMGenerator *gen, TypeClass *tclass) {
+    Object *newFunc;
+    Object *deleteFunc;
+    Object *object;
+    OLinkList *relocs;
+    SInt32 size;
+    CScopeObjectIterator iter;
+    char buf[16];
+
+    newFunc = deleteFunc = NULL;
+    CScope_InitObjectIterator(&iter, tclass->nspace);
+    while (1) {
+        if (!(object = OBJECT(CScope_NextObjectIteratorObject(&iter))))
+            break;
+
+        if (IS_TYPE_FUNC(object->type)) {
+            if (object->name == CMangler_OperatorName(TK_NEW)) {
+                newFunc = object;
+                gen->hasNew = 1;
+            } else if (object->name == CMangler_OperatorName(TK_DELETE)) {
+                deleteFunc = object;
+                gen->hasDelete = 1;
+            }
+        }
+    }
+
+    if (newFunc || deleteFunc) {
+        object = CSOM_MakeObject(tclass->classname->name, "SpecialProcs", 4);
+        object->sclass = TK_STATIC;
+
+        relocs = NULL;
+        size = 0;
+
+        if (newFunc) {
+            OLinkList *reloc = lalloc(sizeof(OLinkList));
+            reloc->next = relocs;
+            relocs = reloc;
+            reloc->obj = newFunc;
+            reloc->offset = size;
+            reloc->somevalue = 0;
+            size += 4;
+        }
+
+        if (deleteFunc) {
+            OLinkList *reloc = lalloc(sizeof(OLinkList));
+            reloc->next = relocs;
+            relocs = reloc;
+            reloc->obj = deleteFunc;
+            reloc->offset = size;
+            reloc->somevalue = 0;
+            size += 4;
+        }
+
+        memclrw(buf, sizeof(buf));
+        object->type->size = size;
+        CInit_DeclareData(object, buf, relocs, object->type->size);
+        gen->specialProcsObj = object;
+    }
+}
+
+static Object *CSOM_GenerateParentVersion(SOMGenerator *gen) {
+    SInt32 size;
+    UInt32 *buf;
+    SOMAncestor *ancestor;
+    SInt32 offset;
+
+    size = 8 * (gen->counts.numDirectParents + gen->counts.numMetaClasses);
+    buf = lalloc(size);
+
+    for (ancestor = gen->ancestors, offset = 0; ancestor; ancestor = ancestor->next) {
+        if (ancestor->xC || ancestor->xD) {
+            buf[offset++] = CTool_EndianConvertWord32(ancestor->tclass->sominfo->majorversion);
+            buf[offset++] = CTool_EndianConvertWord32(ancestor->tclass->sominfo->minorversion);
+        }
+    }
+
+    return CInit_DeclareString((char *) buf, size, 0, 0);
+}
+
+static void CSOM_SetNibble(char *buf, int offset, UInt8 value) {
+    int i = offset >> 1;
+    if (offset & 1) {
+        int left = buf[i] & 0xF0;
+        int right = value & 0xF;
+        buf[i] = left | right;
+    } else {
+        int left = value << 4;
+        int right = buf[i] & 0xF;
+        buf[i] = left | right;
+    }
+}
+
+static Object *CSOM_GenerateSlotUsage(SOMGenerator *gen) {
+    SInt32 size;
+    SOMMethod *method;
+    char *buf;
+    int offset;
+
+    size = (gen->counts.classTokenCount + 1) / 2;
+    buf = lalloc(size);
+    memclrw(buf, size);
+
+    for (method = gen->methods, offset = 0; method; method = method->next, offset++) {
+        switch (method->state) {
+            case SOMMS_Deleted:
+            case SOMMS_Migrated:
+                CSOM_SetNibble(buf, offset, mtEmpty);
+                break;
+            case SOMMS_Method:
+                CSOM_SetNibble(buf, offset, mtVirtualMethod);
+                break;
+            default:
+                CError_FATAL(1048);
+        }
+    }
+
+    return CInit_DeclareString(buf, size, 0, 0);
+}
+
+static Object *CSOM_GenerateSignature(SOMGenerator *gen) {
+    Object *object;
+    SOMMethod *method;
+
+    name_mangle_list.size = 0;
+
+    for (method = gen->methods; method; method = method->next) {
+        if (method->state == SOMMS_Method)
+            CSOM_GetFuncSig(TYPE_FUNC(method->u.object->type), 1);
+    }
+
+    COS_LockHandle(name_mangle_list.data);
+    object = CInit_DeclareString(*name_mangle_list.data, name_mangle_list.size, 0, 0);
+    COS_UnlockHandle(name_mangle_list.data);
+    return object;
+}
+
+static Object *CSOM_GenerateMethodNames(SOMGenerator *gen) {
+    Object *object;
+    SOMMethod *method;
+    HashNameNode *name;
+
+    name_mangle_list.size = 0;
+
+    for (method = gen->methods; method; method = method->next) {
+        if (method->name) {
+            name = CSOM_NameTranslate(method->name);
+            AppendGListID(&name_mangle_list, name->name);
+        }
+    }
+
+    COS_LockHandle(name_mangle_list.data);
+    object = CInit_DeclareString(*name_mangle_list.data, name_mangle_list.size, 0, 0);
+    COS_UnlockHandle(name_mangle_list.data);
+    return object;
+}
+
+static void CSOM_SetupClassCounts(SOMGenerator *gen, TypeClass *tclass, somStaticClassCounts *counts) {
+    gen->counts.majorVersion = tclass->sominfo->majorversion;
+    gen->counts.minorVersion = tclass->sominfo->minorversion;
+    gen->counts.flags = cfSharedStrings;
+    if (gen->hasNew)
+        gen->counts.flags |= cfClassAllocate;
+    if (gen->hasDelete)
+        gen->counts.flags |= cfClassDeallocate;
+
+    switch (tclass->align) {
+        case 1:
+            gen->counts.dataAlignment = 0;
+            break;
+        case 2:
+            gen->counts.dataAlignment = 1;
+            break;
+        case 4:
+            gen->counts.dataAlignment = 2;
+            break;
+        case 8:
+            gen->counts.dataAlignment = 3;
+            break;
+        default:
+            gen->counts.dataAlignment = 4;
+            break;
+    }
+
+    gen->counts.numSelectInherited = 0;
+
+    memclrw(counts, sizeof(somStaticClassCounts));
+    counts->majorVersion = CTool_EndianConvertWord32(gen->counts.majorVersion);
+    counts->minorVersion = CTool_EndianConvertWord32(gen->counts.minorVersion);
+    counts->flags = CTool_EndianConvertWord32(gen->counts.flags);
+    counts->dataAlignment = CTool_EndianConvertWord16(gen->counts.dataAlignment);
+    counts->classTokenCount = CTool_EndianConvertWord16(gen->counts.classTokenCount);
+    counts->numDirectParents = CTool_EndianConvertWord16(gen->counts.numDirectParents);
+    counts->numMetaClasses = CTool_EndianConvertWord16(gen->counts.numMetaClasses);
+    counts->numOverriddenAncestors = CTool_EndianConvertWord16(gen->counts.numOverriddenAncestors);
+    counts->numMigratedMethods = CTool_EndianConvertWord16(gen->counts.numMigratedMethods);
+    counts->numSelectInherited = CTool_EndianConvertWord16(gen->counts.numSelectInherited);
+}
+
+static void CSOM_GenerateSCIObject(SOMGenerator *gen, TypeClass *tclass) {
+    Object *object;
+    OLinkList *relocs;
+    OLinkList *reloc;
+    somStaticClassInfo sci;
+    somStaticClassCounts classCounts;
+
+    object = CSOM_MakeObject(tclass->classname->name, "SCI", sizeof(sci));
+    object->sclass = TK_STATIC;
+
+    memclrw(&sci, sizeof(sci));
+    sci.layoutVersion = CTool_EndianConvertWord32(70);
+
+    reloc = lalloc(sizeof(OLinkList));
+    reloc->next = NULL;
+    relocs = reloc;
+    reloc->obj = tclass->sominfo->classdataobject;
+    reloc->offset = 4;
+    reloc->somevalue = 0;
+
+    if (gen->overrideProcsObj) {
+        reloc = lalloc(sizeof(OLinkList));
+        reloc->next = relocs;
+        relocs = reloc;
+        reloc->obj = gen->overrideProcsObj;
+        reloc->offset = 8;
+        reloc->somevalue = 0;
+    }
+
+    if (gen->classAncestorsObj) {
+        reloc = lalloc(sizeof(OLinkList));
+        reloc->next = relocs;
+        relocs = reloc;
+        reloc->obj = gen->classAncestorsObj;
+        reloc->offset = 12;
+        reloc->somevalue = 0;
+    }
+
+    if (gen->dlldFunc) {
+        reloc = lalloc(sizeof(OLinkList));
+        reloc->next = relocs;
+        relocs = reloc;
+        reloc->obj = gen->dlldFunc;
+        reloc->offset = 16;
+        reloc->somevalue = 0;
+    }
+
+    if (gen->specialProcsObj) {
+        reloc = lalloc(sizeof(OLinkList));
+        reloc->next = relocs;
+        relocs = reloc;
+        reloc->obj = gen->specialProcsObj;
+        reloc->offset = 20;
+        reloc->somevalue = 0;
+    }
+
+    CSOM_SetupClassCounts(gen, tclass, &classCounts);
+
+    reloc = lalloc(sizeof(OLinkList));
+    reloc->next = relocs;
+    relocs = reloc;
+    reloc->obj = CInit_DeclareString((char *) &classCounts, sizeof(classCounts), 0, 0);
+    reloc->offset = 52;
+    reloc->somevalue = 0;
+
+    reloc = lalloc(sizeof(OLinkList));
+    reloc->next = relocs;
+    relocs = reloc;
+    reloc->obj = CInit_DeclareString(tclass->classname->name, strlen(tclass->classname->name) + 1, 0, 0);
+    reloc->offset = 56;
+    reloc->somevalue = 0;
+
+    sci.classDescription.instanceDataSize = CTool_EndianConvertWord32(tclass->size);
+
+    reloc = lalloc(sizeof(OLinkList));
+    reloc->next = relocs;
+    relocs = reloc;
+    reloc->obj = CSOM_GenerateParentVersion(gen);
+    reloc->offset = 64;
+    reloc->somevalue = 0;
+
+    if (gen->methods) {
+        reloc = lalloc(sizeof(OLinkList));
+        reloc->next = relocs;
+        relocs = reloc;
+        reloc->obj = CSOM_GenerateSlotUsage(gen);
+        reloc->offset = 68;
+        reloc->somevalue = 0;
+
+        reloc = lalloc(sizeof(OLinkList));
+        reloc->next = relocs;
+        relocs = reloc;
+        reloc->obj = CSOM_GenerateSignature(gen);
+        reloc->offset = 72;
+        reloc->somevalue = 0;
+
+        reloc = lalloc(sizeof(OLinkList));
+        reloc->next = relocs;
+        relocs = reloc;
+        reloc->obj = CSOM_GenerateMethodNames(gen);
+        reloc->offset = 76;
+        reloc->somevalue = 0;
+    }
+
+    if (gen->overrideProcsObj) {
+        reloc = lalloc(sizeof(OLinkList));
+        reloc->next = relocs;
+        relocs = reloc;
+        reloc->obj = CSOM_GenerateOverrideData(gen);
+        reloc->offset = 80;
+        reloc->somevalue = 0;
+    }
+
+    if (gen->counts.numMigratedMethods) {
+        reloc = lalloc(sizeof(OLinkList));
+        reloc->next = relocs;
+        relocs = reloc;
+        reloc->obj = CSOM_GenerateMigrateData(gen);
+        reloc->offset = 84;
+        reloc->somevalue = 0;
+    }
+
+    sci.classDescription.selectedInherited = 0;
+
+    CInit_DeclareData(object, &sci, relocs, object->type->size);
+    gen->sciObj = object;
+}
+
+static void CSOM_GenerateClassDataObject(SOMGenerator *gen, TypeClass *tclass) {
+    void *buf;
+    OLinkList *relocs;
+    OLinkList *reloc;
+    SInt32 size;
+    SOMMethod *method;
+
+    relocs = NULL;
+    for (size = 24, method = gen->methods; method; method = method->next) {
+        if (method->state == SOMMS_Method) {
+            reloc = lalloc(sizeof(OLinkList));
+            reloc->next = relocs;
+            relocs = reloc;
+            reloc->obj = method->u.object;
+            reloc->offset = size;
+            reloc->somevalue = 0;
+        }
+        size += 4;
+    }
+
+    buf = lalloc(size);
+    memclrw(buf, size);
+
+    reloc = lalloc(sizeof(OLinkList));
+    reloc->next = relocs;
+    relocs = reloc;
+    reloc->obj = gen->sciObj;
+    reloc->offset = 4;
+    reloc->somevalue = 0;
+
+    tclass->sominfo->classdataobject->type->size = size;
+    CInit_DeclareData(tclass->sominfo->classdataobject, buf, relocs, tclass->sominfo->classdataobject->type->size);
+}
+
+void CSOM_GenerateClassStructures(TypeClass *tclass) {
+    SOMGenerator gen;
+
+    memclrw(&gen, sizeof(gen));
+    CSOM_GenerateOverrideIntroLists(&gen, tclass);
+    CSOM_GenerateClassAncestors(&gen, tclass);
+    CSOM_GenerateOverrideProcs(&gen, tclass);
+    CSOM_GenerateDLLDFunc(&gen, tclass);
+    CSOM_GenerateSpecialProcs(&gen, tclass);
+    CSOM_GenerateSCIObject(&gen, tclass);
+    CSOM_GenerateClassDataObject(&gen, tclass);
+}
+
+static TypeClass *CSOM_GetCurrentSOMClass(void) {
+    if (cscope_current->theclass && cscope_current->theclass->sominfo)
+        return cscope_current->theclass;
+
+    CError_Error(CErrorStr277);
+    return NULL;
+}
+
+void CSOM_PragmaReleaseOrder(void) {
+    TypeClass *tclass;
+    SOMReleaseOrder *firstOrder;
+    SOMReleaseOrder *order;
+    SOMReleaseOrder **ptr;
+    Boolean flag;
+    short token;
+
+    if (!(tclass = CSOM_GetCurrentSOMClass()))
+        return;
+
+    token = CPrep_PragmaLex(0);
+    if (token != '(') {
+        if (token != TK_IDENTIFIER) {
+            CPrep_Error(CErrorStr114);
+            return;
+        }
+
+        if (!strcmp(tkidentifier->name, "list")) {
+            token = CPrep_PragmaLex(0);
+            if (token != TK_IDENTIFIER) {
+                CPrep_Error(CErrorStr107);
+                return;
+            }
+        }
+
+        flag = 1;
+    } else {
+        flag = 0;
+        token = CPrep_PragmaLex(0);
+    }
+
+    firstOrder = NULL;
+    if (flag || token != ')') {
+        ptr = &firstOrder;
+        while (1) {
+            if (token != TK_IDENTIFIER) {
+                CPrep_Error(CErrorStr107);
+                return;
+            }
+
+            for (order = firstOrder; order; order = order->next) {
+                if (order->name == tkidentifier) {
+                    CError_Error(CErrorStr122, tkidentifier->name);
+                    return;
+                }
+            }
+
+            order = galloc(sizeof(SOMReleaseOrder));
+            *ptr = order;
+            ptr = &order->next;
+
+            order->next = NULL;
+            order->name = tkidentifier;
+            order->state = SOMMS_Deleted;
+
+            if (flag) {
+                token = CPrep_PragmaLex(1);
+                if (!token)
+                    break;
+            } else {
+                token = CPrep_PragmaLex(0);
+                if (token == ')')
+                    break;
+            }
+
+            if (token != ',') {
+                CPrep_Error(CErrorStr116);
+                return;
+            }
+
+            token = CPrep_PragmaLex(flag);
+        }
+    }
+
+    tclass->sominfo->order = firstOrder;
+}
+
+void CSOM_PragmaClassVersion(void) {
+    Type *type;
+
+    if (CPrep_PragmaLex(0) != '(') {
+        CPrep_Error(CErrorStr114);
+        return;
+    }
+
+    if (CPrep_PragmaLex(0) != TK_IDENTIFIER) {
+        CPrep_Error(CErrorStr107);
+        return;
+    }
+
+    type = CScope_GetTagType(cscope_current, tkidentifier);
+    if (!(type && IS_TYPE_CLASS(type) && TYPE_CLASS(type)->sominfo)) {
+        CPrep_ErrorName(CErrorStr276, tkidentifier->name);
+        return;
+    }
+
+    if (CPrep_PragmaLex(0) != ',') {
+        CPrep_Error(CErrorStr116);
+        return;
+    }
+
+    if (CPrep_PragmaLex(0) != TK_INTCONST) {
+        CPrep_Error(CErrorStr186);
+        return;
+    }
+
+    TYPE_CLASS(type)->sominfo->majorversion = CInt64_GetULong(&tkintconst);
+
+    if (CPrep_PragmaLex(0) != ',') {
+        CPrep_Error(CErrorStr116);
+        return;
+    }
+
+    if (CPrep_PragmaLex(0) != TK_INTCONST) {
+        CPrep_Error(CErrorStr186);
+        return;
+    }
+
+    TYPE_CLASS(type)->sominfo->minorversion = CInt64_GetULong(&tkintconst);
+
+    if (CPrep_PragmaLex(0) != ')') {
+        CPrep_Error(CErrorStr115);
+        return;
+    }
+}
+
+void CSOM_PragmaMetaClass(void) {
+    Type *type;
+    Type *type2;
+
+    if (CPrep_PragmaLex(0) != '(') {
+        CPrep_Error(CErrorStr114);
+        return;
+    }
+
+    if (CPrep_PragmaLex(0) != TK_IDENTIFIER) {
+        CPrep_Error(CErrorStr107);
+        return;
+    }
+
+    type = CScope_GetTagType(cscope_current, tkidentifier);
+    if (!(type && IS_TYPE_CLASS(type) && TYPE_CLASS(type)->sominfo)) {
+        CPrep_ErrorName(CErrorStr276, tkidentifier->name);
+        return;
+    }
+
+    if (CPrep_PragmaLex(0) != ',') {
+        CPrep_Error(CErrorStr116);
+        return;
+    }
+
+    if (CPrep_PragmaLex(0) != TK_IDENTIFIER) {
+        CPrep_Error(CErrorStr107);
+        return;
+    }
+
+    type2 = CScope_GetTagType(cscope_current, tkidentifier);
+    if (!(type2 && IS_TYPE_CLASS(type2) && TYPE_CLASS(type2)->sominfo)) {
+        CPrep_ErrorName(CErrorStr276, tkidentifier->name);
+        return;
+    }
+
+    TYPE_CLASS(type)->sominfo->metaclass = TYPE_CLASS(type2);
+
+    if (CPrep_PragmaLex(0) != ')') {
+        CPrep_Error(CErrorStr115);
+        return;
+    }
+}
+
+void CSOM_PragmaCallStyle(void) {
+    TypeClass *tclass;
+
+    if (!(tclass = CSOM_GetCurrentSOMClass()))
+        return;
+
+    if (CPrep_PragmaLex(0) != TK_IDENTIFIER) {
+        CPrep_Error(CErrorStr107);
+        return;
+    }
+
+    if (!strcmp(tkidentifier->name, "IDL")) {
+        tclass->sominfo->oidl_callstyle = 0;
+        return;
+    }
+
+    if (!strcmp(tkidentifier->name, "OIDL")) {
+        tclass->sominfo->oidl_callstyle = 1;
+        return;
+    }
+
+    CPrep_Error(CErrorStr186);
+}
+
+void CSOM_FixNewDeleteFunctype(TypeFunc *tfunc) {
+    FuncArg *arg = CParser_NewFuncArg();
+    arg->name = GetHashNameNodeExport("__theclass");
+    arg->type = CDecl_NewPointerType(CSOM_FindClassType(GetHashNameNodeExport("SOMClass")));
+    arg->next = tfunc->args;
+    tfunc->args = arg;
+}
+
+static Object *CSOM_FindRTFunc(char *namestr, char *sig) {
+    NameSpaceObjectList *nsol;
+    Object *object;
+    FuncArg *arg;
+
+    if (
+        (nsol = CScope_GetLocalObject(cscope_root, GetHashNameNodeExport(namestr))) &&
+        nsol->object->otype == OT_OBJECT
+        )
+    {
+        object = OBJECT(nsol->object);
+        if (
+            IS_TYPE_FUNC(object->type) &&
+            *(sig++) == 'p' &&
+            IS_TYPE_POINTER_ONLY(TYPE_FUNC(object->type)->functype)
+            )
+        {
+            for (arg = TYPE_FUNC(object->type)->args; arg; arg = arg->next) {
+                switch (*(sig++)) {
+                    case 'p':
+                        if (IS_TYPE_POINTER_ONLY(arg->type))
+                            continue;
+                        break;
+                    case 'i':
+                        if (arg->type == TYPE(&stsignedint))
+                            continue;
+                        break;
+                    case 'I':
+                        if (arg->type == TYPE(&stunsignedint))
+                            continue;
+                        break;
+                    case 'l':
+                        if (arg->type == TYPE(&stsignedlong))
+                            continue;
+                        break;
+                    case 'L':
+                        if (arg->type == TYPE(&stunsignedlong))
+                            continue;
+                        break;
+                }
+                break;
+            }
+
+            if (arg == NULL && *sig == 0)
+                return object;
+        }
+
+        CError_Error(CErrorStr275, namestr);
+    } else {
+        CError_Error(CErrorStr274, namestr);
+    }
+
+    return NULL;
+}
+
+static ENode *CSOM_MakeTempCondition(ENode *left, ENode *cond, ENode *expr1, ENode *right) {
+    ENode *expr;
+
+    expr = lalloc(sizeof(ENode));
+    expr->type = ECOND;
+    expr->cost = 0;
+    expr->flags = 0;
+    expr->rtype = &stvoid;
+    expr->data.cond.cond = cond;
+    expr->data.cond.expr1 = expr1;
+    expr->data.cond.expr2 = nullnode();
+    expr->data.cond.expr2->rtype = &stvoid;
+
+    if (left)
+        expr = makediadicnode(left, expr, ECOMMA);
+
+    if (right) {
+        expr = makediadicnode(expr, right, ECOMMA);
+        expr->rtype = right->rtype;
+    }
+
+    return expr;
+}
+
+ENode *CSOM_New(TypeClass *tclass) {
+    Object *newFunc;
+    ENode *expr;
+
+    if (tk == '(') {
+        if ((tk = lex()) == ')') {
+            tk = lex();
+        } else {
+            CError_Error(CErrorStr272);
+        }
+    }
+
+    if (!copts.som_env_check || !copts.som_call_optimize) {
+        newFunc = CSOM_FindRTFunc("somNewObjectInstance", "ppll");
+        if (!newFunc)
+            return nullnode();
+    } else {
+        newFunc = rt_som_new;
+    }
+
+    expr = funccallexpr(
+        newFunc,
+        create_objectrefnode(tclass->sominfo->classdataobject),
+        intconstnode(TYPE(&stunsignedlong), tclass->sominfo->majorversion),
+        intconstnode(TYPE(&stunsignedlong), tclass->sominfo->minorversion),
+        NULL
+        );
+    expr->rtype = CDecl_NewPointerType(TYPE(tclass));
+
+    if (copts.som_env_check && !copts.som_call_optimize) {
+        ENode *tempExpr;
+        ENode *checkExpr;
+        ENode *notExpr;
+        tempExpr = CExpr_GetETEMPCopy(expr);
+        checkExpr = funccallexpr(rt_som_newcheck, nullnode(), NULL, NULL, NULL);
+        notExpr = makemonadicnode(tempExpr, ELOGNOT);
+        notExpr->rtype = CParser_GetBoolType();
+        expr = CSOM_MakeTempCondition(NULL, notExpr, checkExpr, tempExpr);
+    }
+
+    return expr;
+}
+
+ENode *CSOM_Delete(TypeClass *tclass, ENode *objExpr) {
+    Object *func;
+
+    if ((func = CSOM_FindRTFunc("somReleaseObjectReference", "pp")))
+        return funccallexpr(func, objExpr, NULL, NULL, NULL);
+
+    return nullnode();
+}
+
+void CSOM_InitAutoClass(Object *object) {
+    Type *type;
+    Statement *stmt;
+    Object *func;
+
+    if ((func = CSOM_FindRTFunc("somReleaseObjectReference", "pp"))) {
+        type = object->type;
+        object->type = CDecl_NewPointerType(type);
+        TPTR_QUAL(object->type) = Q_REFERENCE;
+
+        stmt = CFunc_AppendStatement(ST_EXPRESSION);
+        stmt->expr = makediadicnode(create_objectnode2(object), CSOM_New(TYPE_CLASS(type)), EASS);
+        CExcept_RegisterDeleteObject(stmt, object, func);
+    }
+}
+
+static void CSOM_FindIntroClassOffset(TypeClass *tclass, Object *func, TypeClass **resultClass, SInt32 *resultOffset) {
+    Object *scan;
+    VClassList *vbase;
+    CScopeObjectIterator iter;
+
+    if (!(TYPE_FUNC(func->type)->flags & FUNC_FLAGS_20)) {
+        CScope_InitObjectIterator(&iter, tclass->nspace);
+        while (1) {
+            if (!(scan = OBJECT(CScope_NextObjectIteratorObject(&iter))))
+                break;
+
+            if (scan == func) {
+                *resultClass = tclass;
+                *resultOffset = CSOM_GetTokenOffset(scan);
+                return;
+            }
+        }
+
+        for (vbase = tclass->vbases; vbase; vbase = vbase->next) {
+            CScope_InitObjectIterator(&iter, vbase->base->nspace);
+            while (1) {
+                if (!(scan = OBJECT(CScope_NextObjectIteratorObject(&iter))))
+                    break;
+
+                if (scan == func) {
+                    *resultClass = vbase->base;
+                    *resultOffset = CSOM_GetTokenOffset(scan);
+                    return;
+                }
+            }
+        }
+    } else {
+        for (vbase = tclass->vbases; vbase; vbase = vbase->next) {
+            CScope_InitObjectIterator(&iter, vbase->base->nspace);
+            while (1) {
+                if (!(scan = OBJECT(CScope_NextObjectIteratorObject(&iter))))
+                    break;
+
+                if (scan->name == func->name) {
+                    if (
+                        IS_TYPE_FUNC(scan->type) &&
+                        scan->datatype == DVFUNC &&
+                        !(TYPE_FUNC(scan->type)->flags & FUNC_FLAGS_20) &&
+                        CClass_GetOverrideKind(TYPE_FUNC(func->type), TYPE_FUNC(scan->type), 0)
+                        )
+                    {
+                        *resultClass = vbase->base;
+                        *resultOffset = CSOM_GetTokenOffset(scan);
+                        return;
+                    }
+                    break;
+                }
+            }
+        }
+    }
+
+    CError_FATAL(1731);
+}
+
+static ENode *CSOM_ComputeSOMSelf(TypeClass *tclass, ENode *selfExpr) {
+    ENode *expr;
+    Object obj;
+
+    expr = create_objectrefnode(tclass->sominfo->classdataobject);
+    expr = makediadicnode(expr, intconstnode(TYPE(&stsignedlong), 8), EADD);
+    expr->rtype = CDecl_NewPointerType(TYPE(&SOMIDT_type));
+    expr = makemonadicnode(expr, EINDIRECT);
+
+    memclrw(&obj, sizeof(Object));
+    obj.otype = OT_OBJECT;
+    obj.type = TYPE(&SOMIDT_type);
+    obj.name = no_name_node;
+    obj.datatype = DFUNC;
+    selfExpr = funccallexpr(&obj, selfExpr, NULL, NULL, NULL);
+
+    CError_ASSERT(1761, ENODE_IS(selfExpr, EFUNCCALL));
+
+    selfExpr->data.funccall.funcref = expr;
+
+    return selfExpr;
+}
+
+ENode *CSOM_SOMSelfObjectExpr(TypeClass *tclass) {
+    ObjectList *list;
+    Object *obj;
+
+    for (list = locals; list; list = list->next) {
+        if (list->object->name == csom_selfname)
+            return create_objectnode(list->object);
+    }
+
+    obj = CParser_NewLocalDataObject(NULL, 1);
+    obj->name = csom_selfname;
+    obj->type = CDecl_NewPointerType(TYPE(tclass));
+    CFunc_SetupLocalVarInfo(obj);
+    return create_objectnode(obj);
+}
+
+void CSOM_InitSOMSelf(TypeClass *tclass, Statement *stmt) {
+    ObjectList *list;
+    HashNameNode *name;
+    ENode *selfExpr;
+
+    name = GetHashNameNodeExport("__somself");
+    for (list = locals; list; list = list->next) {
+        if (list->object->name == name) {
+            selfExpr = CClass_CreateThisSelfExpr();
+            CError_ASSERT(1811, selfExpr);
+
+            selfExpr = CSOM_ComputeSOMSelf(tclass, selfExpr);
+
+            stmt = CFunc_InsertStatement(ST_EXPRESSION, stmt);
+            stmt->expr = makediadicnode(create_objectnode(list->object), selfExpr, EASS);
+            break;
+        }
+    }
+}
+
+ENode *CSOM_EnvCheck(ENode *funccall, ENodeList *checkArg) {
+    ENodeList *arg; // r26
+    ENodeList *arg2; // r28
+    ENode *expr26; // r26
+    ENode *expr27; // r27
+    ENode *expr28; // r28
+    Type *returnType; // r31
+
+    returnType = funccall->rtype;
+    CError_ASSERT(1842, arg = funccall->data.funccall.args);
+
+    if (arg == checkArg)
+        CError_ASSERT(1845, arg = arg->next);
+
+    CError_ASSERT(1847, arg2 = arg->next);
+
+    if (arg2 == checkArg)
+        CError_ASSERT(1850, arg2 = arg2->next);
+
+    CError_ASSERT(1852, IS_TYPE_POINTER_ONLY(arg2->node->rtype));
+
+    if (!IS_TYPE_VOID(funccall->data.funccall.functype->functype)) {
+        if (checkArg) {
+            if (ENODE_IS(checkArg->node, ETEMP)) {
+                if (checkArg->node->data.temp.uniqueid == 0)
+                    checkArg->node->data.temp.uniqueid = CParser_GetUniqueID();
+
+                expr26 = lalloc(sizeof(ENode));
+                *expr26 = *checkArg->node;
+                expr26->data.temp.needs_dtor = 0;
+            } else {
+                expr26 = CExpr_GetETEMPCopy(checkArg->node);
+            }
+        } else {
+            expr26 = CExpr_GetETEMPCopy(funccall);
+        }
+    } else {
+        expr26 = NULL;
+    }
+
+    if (!ENODE_IS(arg2->node, EOBJREF)) {
+        if (ENODE_IS_INDIRECT_TO(arg2->node, EOBJREF) && arg2->node->data.monadic->data.objref->datatype == DLOCAL) {
+            expr27 = lalloc(sizeof(ENode));
+            *expr27 = *arg2->node;
+        } else {
+            expr27 = CExpr_GetETEMPCopy(arg2->node);
+        }
+    } else {
+        expr27 = lalloc(sizeof(ENode));
+        *expr27 = *arg2->node;
+    }
+
+    if (copts.som_call_optimize) {
+        funccall = makediadicnode(funccall, funccallexpr(rt_som_check, expr27, NULL, NULL, NULL), ECOMMA);
+        if (expr26)
+            funccall = makediadicnode(funccall, expr26, ECOMMA);
+    } else {
+        expr28 = lalloc(sizeof(ENode));
+        *expr28 = *expr27;
+        expr28 = makemonadicnode(expr28, EINDIRECT);
+        expr28->rtype = TYPE(&stsignedlong);
+
+        funccall = CSOM_MakeTempCondition(
+            funccall,
+            expr28,
+            funccallexpr(rt_som_check, expr27, NULL, NULL, NULL),
+            expr26);
+    }
+
+    funccall->rtype = returnType;
+    return funccall;
+}
+
+static Boolean CSOM_CanUseGlueCall(TypeFunc *tfunc) {
+    int gprCounter;
+    int fprCounter;
+    FuncArg *arg;
+
+    gprCounter = 8;
+    fprCounter = 13;
+    if (CMach_GetFunctionResultClass(tfunc) != 0)
+        gprCounter = 7;
+
+    for (arg = tfunc->args; arg; arg = arg->next) {
+        if (arg == &elipsis || arg == &oldstyle)
+            return 0;
+
+        switch (arg->type->type) {
+            case TYPEINT:
+            case TYPEENUM:
+            case TYPEPOINTER:
+                if (--gprCounter < 0)
+                    return 0;
+                break;
+            case TYPEFLOAT:
+                if (--fprCounter < 0)
+                    return 0;
+                break;
+            default:
+                return 0;
+        }
+    }
+
+    return 1;
+}
+
+static char *CSOM_AppendString(char *dst, char *src) {
+    int ch;
+    while ((ch = *(src++)))
+        *(dst++) = ch;
+    return dst;
+}
+
+static ENode *CSOM_SOMGlueCall(TypeClass *tclass, SInt32 offset, Object *object) {
+    UInt8 funcResultClass;
+    UInt32 bufsize;
+    char *buf;
+    char *ptr;
+    Object *stubObj;
+    CSOMStub *stub;
+    ENode *expr;
+    char mybuf[256];
+    char numberbuf[16];
+
+    for (stub = csom_stubs; stub; stub = stub->next) {
+        if (stub->tclass == tclass && stub->offset == offset)
+            break;
+    }
+
+    if (!stub) {
+        funcResultClass = CMach_GetFunctionResultClass(TYPE_FUNC(object->type));
+
+        bufsize = strlen(tclass->sominfo->classdataobject->name->name) + 32;
+        buf = (bufsize > sizeof(mybuf)) ? lalloc(bufsize) : mybuf;
+
+        ptr = CSOM_AppendString(buf, "___glue_");
+        if (tclass->sominfo->oidl_callstyle == 0) {
+            if (funcResultClass == 0) {
+                *(ptr++) = '4';
+            } else {
+                *(ptr++) = '5';
+            }
+        } else {
+            *(ptr++) = '_';
+        }
+        *(ptr++) = '_';
+
+        sprintf(numberbuf, "%ld", strlen(tclass->sominfo->classdataobject->name->name));
+        ptr = CSOM_AppendString(ptr, numberbuf);
+        ptr = CSOM_AppendString(ptr, tclass->sominfo->classdataobject->name->name);
+        *(ptr++) = '_';
+        sprintf(numberbuf, "%" PRId32, offset);
+        ptr = CSOM_AppendString(ptr, numberbuf);
+        *ptr = 0;
+
+        stubObj = CParser_NewCompilerDefFunctionObject();
+        stubObj->nspace = cscope_root;
+        stubObj->name = GetHashNameNodeExport(buf);
+        stubObj->u.func.linkname = stubObj->name;
+        stubObj->type = object->type;
+        stubObj->qual = object->qual | Q_20000;
+        stubObj->flags = OBJECT_INTERNAL;
+        CScope_AddObject(stubObj->nspace, stubObj->name, OBJ_BASE(stubObj));
+
+        stub = galloc(sizeof(CSOMStub));
+        stub->next = csom_stubs;
+        stub->object = stubObj;
+        stub->tclass = tclass;
+        stub->offset = offset;
+        csom_stubs = stub;
+
+        if (tclass->sominfo->oidl_callstyle == 0) {
+            if (funcResultClass == 0)
+                stub->x10 = 0;
+            else
+                stub->x10 = 1;
+        } else {
+            stub->x10 = 2;
+        }
+    }
+
+    expr = create_objectrefnode(stub->object);
+    expr->rtype = CDecl_NewPointerType(object->type);
+    return expr;
+}
+
+ENode *CSOM_MemberVarAccess(BClassList *path, ObjMemberVar *ivar, ENode *thisExpr) {
+    if (!thisExpr) {
+        if (
+            !cscope_currentfunc ||
+            !cscope_currentclass ||
+            !cscope_is_member_func ||
+            !(thisExpr = CClass_CreateThisSelfExpr())
+            )
+        {
+            CError_Error(CErrorStr221);
+            return NULL;
+        }
+    }
+
+    CError_ASSERT(2069, ENODE_IS(thisExpr, EINDIRECT));
+
+    thisExpr = thisExpr->data.monadic;
+
+    if (
+        path->next == NULL &&
+        cscope_currentclass == TYPE_CLASS(path->type) &&
+        ENODE_IS(thisExpr, EOBJREF) &&
+        thisExpr->data.objref->name == this_name_node
+        )
+    {
+        thisExpr = CSOM_SOMSelfObjectExpr(cscope_currentclass);
+    }
+    else
+    {
+        CClass_CheckPathAccess(path, NULL, ivar->access);
+        if (ivar->has_path)
+            path = OBJ_MEMBER_VAR_PATH(ivar)->path;
+        while (path->next)
+            path = path->next;
+        thisExpr = CSOM_ComputeSOMSelf(TYPE_CLASS(path->type), thisExpr);
+    }
+
+    thisExpr = makemonadicnode(thisExpr, EINDIRECT);
+    thisExpr->rtype = path->type;
+    return CClass_AccessMember(thisExpr, ivar->type, ivar->qual, ivar->offset);
+}
+
+ENode *CSOM_MethodAccess(BClassList *path, Object *func, Boolean flag) {
+    TypeClass *tclass;
+    TypeClass *tclass2;
+    TypeClass *tclass3;
+    ENode *expr;
+    SInt32 offset;
+    ClassList *base;
+
+    CError_ASSERT(2107, path != NULL);
+
+    tclass = TYPE_CLASS(path->type);
+    if (path->next)
+        path = path->next;
+    tclass2 = TYPE_CLASS(path->type);
+
+    if (flag) {
+        SInt32 counter;
+        ENode *indirectExpr;
+        Object *resolveFunc;
+
+        counter = 0;
+        if (tclass != tclass2) {
+            for (base = tclass->bases; base; base = base->next) {
+                counter++;
+                if (base->base == tclass2)
+                    break;
+            }
+
+            if (!base)
+                CError_Error(CErrorStr279);
+        }
+
+        CSOM_FindIntroClassOffset(tclass2, func, &tclass3, &offset);
+        expr = create_objectrefnode(tclass3->sominfo->classdataobject);
+        expr = makediadicnode(expr, intconstnode(TYPE(&stsignedlong), offset), EADD);
+        indirectExpr = makemonadicnode(expr, EINDIRECT);
+        indirectExpr->rtype = CDecl_NewPointerType(func->type);
+
+        resolveFunc = CSOM_FindRTFunc("somParentNumResolve", "ppip");
+        if (!resolveFunc)
+            return nullnode();
+
+        expr = funccallexpr(
+            resolveFunc,
+            create_objectrefnode(tclass->sominfo->classdataobject),
+            intconstnode(TYPE(&stsignedint), counter),
+            indirectExpr,
+            NULL);
+        expr->rtype = indirectExpr->rtype;
+        if (copts.som_env_check && tclass3->sominfo->oidl_callstyle == 0)
+            expr->flags = expr->flags | ENODE_FLAG_10;
+    } else {
+        CSOM_FindIntroClassOffset(tclass2, func, &tclass3, &offset);
+        if (copts.som_call_optimize && CSOM_CanUseGlueCall(TYPE_FUNC(func->type)))
+            return CSOM_SOMGlueCall(tclass3, offset, func);
+
+        expr = create_objectrefnode(tclass3->sominfo->classdataobject);
+        expr = makediadicnode(expr, intconstnode(TYPE(&stsignedlong), offset), EADD);
+        expr = makemonadicnode(expr, EINDIRECT);
+        expr->rtype = CDecl_NewPointerType(func->type);
+        if (copts.som_env_check && tclass3->sominfo->oidl_callstyle == 0)
+            expr->flags = expr->flags | ENODE_FLAG_10;
+    }
+
+    return expr;
+}