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

1 files changed, 0 insertions, 4845 deletions

diff --git a/compiler_and_linker/unsorted/CDecl.c b/compiler_and_linker/unsorted/CDecl.c
deleted file mode 100644
index 43ca92e..0000000
--- a/compiler_and_linker/unsorted/CDecl.c
+++ /dev/null
@@ -1,4845 +0,0 @@
-#include "compiler/CDecl.h"
-#include "compiler/CABI.h"
-#include "compiler/CBrowse.h"
-#include "compiler/CClass.h"
-#include "compiler/CError.h"
-#include "compiler/CException.h"
-#include "compiler/CExpr.h"
-#include "compiler/CFunc.h"
-#include "compiler/CInit.h"
-#include "compiler/CInline.h"
-#include "compiler/CInt64.h"
-#include "compiler/CMachine.h"
-#include "compiler/CMangler.h"
-#include "compiler/CObjC.h"
-#include "compiler/CParser.h"
-#include "compiler/CPrep.h"
-#include "compiler/CPrepTokenizer.h"
-#include "compiler/CSOM.h"
-#include "compiler/CTemplateClass.h"
-#include "compiler/CTemplateFunc.h"
-#include "compiler/CTemplateNew.h"
-#include "compiler/CTemplateTools.h"
-#include "compiler/CompilerTools.h"
-#include "compiler/objects.h"
-#include "compiler/scopes.h"
-#include "compiler/templates.h"
-#include "compiler/tokens.h"
-
-AccessType global_access;
-FileOffsetInfo member_fileoffset;
-
-// forward declarations
-static void scandirectdecl1(DeclInfo *declinfo);
-
-Type *CDecl_NewStructType(SInt32 size, SInt16 align) {
-    TypeStruct *tstruct = galloc(sizeof(TypeStruct));
-    memclrw(tstruct, sizeof(TypeStruct));
-
-    tstruct->type = TYPESTRUCT;
-    tstruct->size = size;
-    tstruct->align = align;
-    tstruct->stype = STRUCT_TYPE_STRUCT;
-
-    return (Type *) tstruct;
-}
-
-Type *CDecl_NewArrayType(Type *type, SInt32 size) {
-    TypePointer *tarray = galloc(sizeof(TypePointer));
-    memclrw(tarray, sizeof(TypePointer));
-
-    tarray->type = TYPEARRAY;
-    tarray->size = size;
-    tarray->target = type;
-    tarray->qual = 0;
-
-    return (Type *) tarray;
-}
-
-Type *CDecl_NewPointerType(Type *type) {
-    TypePointer *tptr = galloc(sizeof(TypePointer));
-    memclrw(tptr, sizeof(TypePointer));
-
-    tptr->type = TYPEPOINTER;
-    tptr->size = 4;
-    tptr->target = type;
-
-    return (Type *) tptr;
-}
-
-Type *CDecl_NewRefPointerType(Type *type) {
-    TypePointer *tptr = galloc(sizeof(TypePointer));
-    memclrw(tptr, sizeof(TypePointer));
-
-    tptr->type = TYPEPOINTER;
-    tptr->size = 4;
-    tptr->target = type;
-    tptr->qual = Q_REFERENCE;
-
-    return (Type *) tptr;
-}
-
-Type *CDecl_NewTemplDepType(TypeTemplDepType tdt) {
-    TypeTemplDep *t = galloc(sizeof(TypeTemplDep));
-    memclrw(t, sizeof(TypeTemplDep));
-
-    t->type = TYPETEMPLATE;
-    t->size = 1;
-    t->dtype = tdt;
-
-    return (Type *) t;
-}
-
-void CDecl_SetResultReg(TypeFunc *tfunc) {
-}
-
-static void CDecl_SetFuncResultReg(TypeFunc *tfunc) {
-}
-
-void CDecl_SetFuncFlags(TypeFunc *tfunc, UInt32 flags) {
-    CDecl_SetResultReg(tfunc);
-}
-
-static void CDecl_ParseCPPFuncDecl(TypeFunc *tfunc) {
-    for (;;) {
-        if (tk == TK_CONST) {
-            if (tfunc->flags & FUNC_CONST)
-                CError_Warning(CErrorStr313, "const");
-            tfunc->flags |= FUNC_CONST;
-            tk = lex();
-        } else if (tk == TK_VOLATILE) {
-            if (tfunc->flags & FUNC_VOLATILE)
-                CError_Warning(CErrorStr313, "volatile");
-            tfunc->flags |= FUNC_VOLATILE;
-            tk = lex();
-        } else {
-            break;
-        }
-    }
-
-    if (tk == TK_THROW)
-        CExcept_ScanExceptionSpecification(tfunc);
-}
-
-void CDecl_NewConvFuncType(DeclInfo *declinfo) {
-    TypeFunc *tfunc;
-
-    if (tk != '(')
-        CError_Error(CErrorStr114);
-    else
-        tk = lex();
-
-    if (tk == TK_VOID)
-        tk = lex();
-
-    if (tk != ')')
-        CError_Error(CErrorStr115);
-    else
-        tk = lex();
-
-    tfunc = galloc(sizeof(TypeFunc));
-    memclrw(tfunc, sizeof(TypeFunc));
-    declinfo->name = CMangler_ConversionFuncName(declinfo->thetype, declinfo->qual);
-    tfunc->type = TYPEFUNC;
-    tfunc->functype = declinfo->thetype;
-    tfunc->qual = declinfo->qual & (Q_CONST | Q_VOLATILE);
-    tfunc->flags = FUNC_CONVERSION;
-    declinfo->x49 = 0;
-    CDecl_SetFuncFlags(tfunc, 1);
-    CDecl_ParseCPPFuncDecl(tfunc);
-
-    declinfo->thetype = (Type *) tfunc;
-    declinfo->qual &= ~(Q_CONST | Q_VOLATILE);
-    declinfo->storageclass = 0;
-}
-
-void CDecl_CompleteType(Type *type) {
-    switch (type->type) {
-        case TYPEPOINTER:
-            if ((TYPE_POINTER(type)->qual & Q_REFERENCE) && IS_TYPE_CLASS(TYPE_POINTER(type)->target)) {
-                type = TYPE_POINTER(type)->target;
-                break;
-            }
-            return;
-        case TYPEARRAY:
-            do {
-                type = TYPE_POINTER(type)->target;
-            } while (IS_TYPE_ARRAY(type));
-            if (IS_TYPE_CLASS(type))
-                break;
-            return;
-        case TYPECLASS:
-            break;
-        default:
-            return;
-    }
-
-    if ((TYPE_CLASS(type)->flags & (CLASS_COMPLETED | CLASS_IS_TEMPL_INST)) == CLASS_IS_TEMPL_INST)
-        CTempl_InstantiateTemplateClass(TYPE_CLASS(type));
-}
-
-Boolean IsCompleteType(Type *type) {
-    switch (type->type) {
-        case TYPEVOID:
-            CError_Error(CErrorStr126);
-            return 0;
-        case TYPEFUNC:
-            CError_Error(CErrorStr146);
-            return 0;
-        case TYPESTRUCT:
-            if (!type->size) {
-                CError_Error(CErrorStr136, type, 0);
-                return 0;
-            }
-            return 1;
-        case TYPECLASS:
-            if (
-                !(TYPE_CLASS(type)->flags & CLASS_COMPLETED) &&
-                (
-                    !(TYPE_CLASS(type)->flags & CLASS_IS_TEMPL_INST) ||
-                    !CTempl_InstantiateTemplateClass(TYPE_CLASS(type))
-                    )
-                    )
-            {
-                CError_Error(CErrorStr136, type, 0);
-                return 0;
-            }
-            return 1;
-        default:
-            if (!type->size) {
-                CError_Error(CErrorStr145);
-                return 0;
-            }
-            return 1;
-    }
-}
-
-Boolean CanAllocObject(Type *type) {
-    switch (type->type) {
-        case TYPEVOID:
-            CError_Error(CErrorStr126);
-            return 0;
-        case TYPEFUNC:
-            CError_Error(CErrorStr146);
-            return 0;
-        case TYPECLASS:
-            if (TYPE_CLASS(type)->flags & CLASS_ABSTRACT) {
-                CError_AbstractClassError(TYPE_CLASS(type));
-                return 0;
-            }
-        default:
-            return 1;
-    }
-}
-
-Boolean CanCreateObject(Type *type) {
-    if (!CanAllocObject(type))
-        return 0;
-
-    if (IS_TYPE_CLASS(type)) {
-        if (TYPE_CLASS(type)->flags & CLASS_HANDLEOBJECT) {
-            CError_Error(CErrorStr191);
-            return 0;
-        }
-        if (TYPE_CLASS(type)->objcinfo) {
-            CError_Error(CErrorStr307);
-            return 0;
-        }
-    }
-
-    return 1;
-}
-
-static Boolean CanCreateHandleMemberObject(Type *type) {
-    while (IS_TYPE_ARRAY(type))
-        type = TYPE_POINTER(type)->target;
-
-    if (!CanCreateObject(type))
-        return 0;
-
-    if (IS_TYPE_CLASS(type)) {
-        if (CClass_Destructor(TYPE_CLASS(type)) || CClass_Constructor(TYPE_CLASS(type))) {
-            CError_Error(CErrorStr191);
-            return 0;
-        }
-    }
-
-    return 1;
-}
-
-void makethetypepointer(DeclInfo *declinfo, UInt32 qual) {
-    declinfo->thetype = CDecl_NewPointerType(declinfo->thetype);
-    TYPE_POINTER(declinfo->thetype)->qual = qual;
-}
-
-void CDecl_AddThisPointerArgument(TypeFunc *tfunc, TypeClass *tclass) {
-    Type *ptype;
-    FuncArg *arg;
-
-    ptype = CDecl_NewPointerType(!tclass->sominfo ? (Type *) tclass : &stvoid);
-    TYPE_POINTER(ptype)->qual = Q_CONST;
-
-    arg = CParser_NewFuncArg();
-    arg->name = this_name_node;
-    arg->type = ptype;
-    if (tfunc->flags & FUNC_CONST)
-        arg->qual |= Q_CONST;
-    if (tfunc->flags & FUNC_VOLATILE)
-        arg->qual |= Q_VOLATILE;
-    arg->next = tfunc->args;
-    tfunc->args = arg;
-}
-
-void CDecl_MakePTMFuncType(TypeFunc *tfunc) {
-    Type *cvoidp;
-    FuncArg *arg1;
-    FuncArg *arg2;
-
-    cvoidp = CDecl_NewPointerType(&stvoid);
-    TYPE_POINTER(cvoidp)->qual = Q_CONST;
-
-    arg1 = CParser_NewFuncArg();
-    arg1->name = this_name_node;
-    arg1->type = cvoidp;
-    if (tfunc->flags & FUNC_CONST)
-        arg1->qual |= Q_CONST;
-    if (tfunc->flags & FUNC_VOLATILE)
-        arg1->qual |= Q_VOLATILE;
-
-    arg2 = CParser_NewFuncArg();
-    arg2->name = this_name_node;
-    arg2->type = cvoidp;
-    arg2->qual = Q_CONST;
-
-    arg1->next = tfunc->args;
-    arg2->next = arg1;
-    tfunc->args = arg2;
-    tfunc->flags |= FUNC_FLAGS_80;
-}
-
-void CDecl_AddArgument(TypeFunc *tfunc, Type *argtype) {
-    FuncArg *arg = CParser_NewFuncArg();
-    arg->type = argtype;
-
-    arg->next = tfunc->args;
-    tfunc->args = arg;
-
-    if (arg->next && arg->next->type == &stvoid)
-        arg->next = NULL;
-}
-
-Boolean CDecl_CheckArrayIntegr(Type *type) {
-    if (!IsCompleteType(type))
-        return 0;
-
-    if (IS_TYPE_CLASS(type) && TYPE_CLASS(type)->sominfo) {
-        CError_Error(CErrorStr289);
-        return 0;
-    }
-
-    if (IS_TYPE_REFERENCE(type)) {
-        CError_Error(CErrorStr196);
-        return 0;
-    }
-
-    return CanCreateObject(type);
-}
-
-static Boolean checkfuncintegr(Type *type) {
-    if (IS_TYPE_VOID(type))
-        return 1;
-
-    if (IS_TYPE_CLASS(type) && TYPE_CLASS(type)->sominfo) {
-        CError_Error(CErrorStr283);
-        return 0;
-    }
-
-    return CanCreateObject(type);
-}
-
-void CDecl_ParseDirectFuncDecl(DeclInfo *declinfo) {
-    FuncArg *list;
-    TypeFunc *tfunc;
-
-    if (tk == ')') {
-        if (copts.cplusplus)
-            list = NULL;
-        else
-            list = &oldstyle;
-        tk = lex();
-    } else {
-        list = parameter_type_list(declinfo);
-        if (tk != ')')
-            CError_ErrorSkip(CErrorStr115);
-        else
-            tk = lex();
-    }
-
-    tfunc = galloc(sizeof(TypeFunc));
-    memclrw(tfunc, sizeof(TypeFunc));
-    tfunc->type = TYPEFUNC;
-    tfunc->args = list;
-    if (declinfo->qual & Q_PASCAL) {
-        declinfo->qual &= ~Q_PASCAL;
-        tfunc->flags = FUNC_PASCAL;
-    }
-
-    if (copts.cplusplus) {
-        CDecl_ParseCPPFuncDecl(tfunc);
-        if (declinfo->storageclass == TK_TYPEDEF && tfunc->exspecs)
-            CError_Error(CErrorStr264);
-    }
-
-    scandirectdecl1(declinfo);
-    if (!checkfuncintegr(declinfo->thetype))
-        declinfo->thetype = &stvoid;
-
-    tfunc->functype = declinfo->thetype;
-    tfunc->qual = declinfo->qual & (Q_CONST | Q_VOLATILE);
-    declinfo->thetype = (Type *) tfunc;
-    declinfo->qual &= ~(Q_CONST | Q_VOLATILE);
-    declinfo->x49 = 0;
-}
-
-static void scandirectdecl1(DeclInfo *declinfo) {
-    Boolean flag;
-    CInt64 len;
-    ENode *expr;
-    TypeTemplDep *ttempl;
-
-    flag = 0;
-    if (tk == '[') {
-        if ((tk = lex()) == ']') {
-            len = cint64_zero;
-            tk = lex();
-            flag = 1;
-        } else {
-            if (!declinfo->x46 || declinfo->x47) {
-                expr = CExpr_IntegralConstOrDepExpr();
-                if (!ENODE_IS(expr, EINTCONST)) {
-                    if (tk != ']')
-                        CError_ErrorSkip(CErrorStr125);
-                    else
-                        tk = lex();
-                    declinfo->x47 = 1;
-                    scandirectdecl1(declinfo);
-                    if (!CDecl_CheckArrayIntegr(declinfo->thetype))
-                        declinfo->thetype = (Type *) &stsignedchar;
-                    ttempl = (TypeTemplDep *) CDecl_NewTemplDepType(TEMPLDEP_ARRAY);
-                    ttempl->u.array.type = declinfo->thetype;
-                    ttempl->u.array.index = CInline_CopyExpression(expr, CopyMode1);
-                    declinfo->thetype = (Type *) ttempl;
-                    return;
-                }
-                len = expr->data.intval;
-                if (CInt64_IsNegative(&len)) {
-                    CError_Error(CErrorStr124);
-                    len = cint64_one;
-                } else if (CInt64_IsZero(&len)) {
-                    if (!copts.ANSIstrict && declinfo->x50) {
-                        flag = 1;
-                    } else {
-                        CError_Error(CErrorStr124);
-                        len = cint64_one;
-                    }
-                }
-            } else {
-                len = cint64_one;
-                expr = expression();
-                if (IS_TYPE_INT(expr->rtype)) {
-                    if (!ENODE_IS(expr, EINTCONST))
-                        declinfo->x24 = expr;
-                    else
-                        len = expr->data.intval;
-                } else {
-                    CError_Error(CErrorStr124);
-                }
-            }
-
-            if (tk != ']')
-                CError_ErrorSkip(CErrorStr125);
-            else
-                tk = lex();
-        }
-
-        declinfo->x47 = 1;
-        scandirectdecl1(declinfo);
-
-        if (!flag && !CDecl_CheckArrayIntegr(declinfo->thetype))
-            declinfo->thetype = (Type *) &stsignedchar;
-
-        if (!declinfo->thetype->size && CTemplTool_IsTemplateArgumentDependentType(declinfo->thetype)) {
-            ttempl = (TypeTemplDep *) CDecl_NewTemplDepType(TEMPLDEP_ARRAY);
-            ttempl->u.array.type = declinfo->thetype;
-            ttempl->u.array.index = CInline_CopyExpression(intconstnode((Type *) &stsignedint, CInt64_GetULong(&len)), CopyMode1);
-            declinfo->thetype = (Type *) ttempl;
-        } else {
-            declinfo->thetype = CDecl_NewArrayType(declinfo->thetype, declinfo->thetype->size * CInt64_GetULong(&len));
-        }
-    } else if (tk == '(') {
-        if (!copts.cplusplus || !declinfo->name || IS_TYPE_VOID(declinfo->thetype) || CParser_TryParamList(!IS_TYPE_CLASS(declinfo->thetype))) {
-            tk = lex();
-            CDecl_ParseDirectFuncDecl(declinfo);
-        }
-    }
-}
-
-static void substitute_type(Type *type1, Type *type2) {
-    SInt32 oldsize;
-
-    while (1) {
-        switch (type1->type) {
-            case TYPEPOINTER:
-                if (TYPE_POINTER(type1)->target == &stillegal) {
-                    TYPE_POINTER(type1)->target = type2;
-                    type1->size = 4;
-                    return;
-                }
-                type1 = TYPE_POINTER(type1)->target;
-                break;
-            case TYPEMEMBERPOINTER:
-                if (TYPE_MEMBER_POINTER(type1)->ty1 == &stillegal) {
-                    TYPE_MEMBER_POINTER(type1)->ty1 = type2;
-                    if (IS_TYPE_FUNC(type2)) {
-                        CDecl_MakePTMFuncType(TYPE_FUNC(type2));
-                        type1->size = 12;
-                    } else {
-                        type1->size = 4;
-                    }
-                    return;
-                }
-                type1 = TYPE_MEMBER_POINTER(type1)->ty1;
-                break;
-            case TYPEARRAY:
-                if (TYPE_POINTER(type1)->target == &stillegal) {
-                    if (!CDecl_CheckArrayIntegr(type2))
-                        type2 = (Type *) &stsignedchar;
-                    type1->size *= type2->size;
-                    TYPE_POINTER(type1)->target = type2;
-                    return;
-                }
-                oldsize = TYPE_POINTER(type1)->target->size;
-                substitute_type(TYPE_POINTER(type1)->target, type2);
-                if (oldsize != TYPE_POINTER(type1)->target->size && oldsize != 0)
-                    type1->size = TYPE_POINTER(type1)->target->size * (type1->size / oldsize);
-                return;
-            case TYPEFUNC:
-                if (TYPE_FUNC(type1)->functype == &stillegal) {
-                    if (!checkfuncintegr(type2))
-                        type2 = &stvoid;
-                    TYPE_FUNC(type1)->functype = type2;
-                    CDecl_SetFuncResultReg((TypeFunc *) type1);
-                    return;
-                }
-                type1 = TYPE_FUNC(type1)->functype;
-                break;
-            case TYPETEMPLATE:
-                if (TYPE_TEMPLATE(type1)->dtype == TEMPLDEP_ARRAY) {
-                    if (TYPE_TEMPLATE(type1)->u.array.type == &stillegal) {
-                        if (!CDecl_CheckArrayIntegr(type2))
-                            type2 = (Type *) &stsignedchar;
-                        TYPE_TEMPLATE(type1)->u.array.type = type2;
-                        return;
-                    }
-                    type1 = TYPE_TEMPLATE(type1)->u.array.type;
-                } else {
-                    CError_Error(CErrorStr146);
-                    return;
-                }
-                break;
-            default:
-                CError_Error(CErrorStr121);
-                return;
-        }
-    }
-}
-
-static void scandecl(DeclInfo *declinfo) {
-    Type *oldtype;
-    Type *newtype;
-
-    oldtype = declinfo->thetype;
-    declinfo->thetype = &stillegal;
-    scandeclarator(declinfo);
-
-    if (tk != ')')
-        CError_ErrorSkip(CErrorStr115);
-    else
-        tk = lex();
-
-    newtype = declinfo->thetype;
-    if (newtype == &stillegal) {
-        declinfo->thetype = oldtype;
-        scandirectdecl1(declinfo);
-    } else {
-        declinfo->thetype = oldtype;
-        scandirectdecl1(declinfo);
-        substitute_type(newtype, declinfo->thetype);
-        declinfo->thetype = newtype;
-    }
-}
-
-static Boolean CDecl_ParseOperatorDecl(DeclInfo *declinfo) {
-    if (declinfo->operator_token) {
-        CError_Error(CErrorStr121);
-        return 0;
-    }
-
-    declinfo->operator_token = 0;
-    if (!CParser_ParseOperatorName(&declinfo->operator_token, declinfo->x4A && cscope_current->theclass, 0))
-        return 0;
-
-    if (!declinfo->operator_token) {
-        conversion_type_name(declinfo);
-        tkidentifier = CMangler_ConversionFuncName(declinfo->thetype, declinfo->qual);
-        declinfo->x54 = 1;
-    }
-    return 1;
-}
-
-static Boolean CDecl_IsEnumClassTypeOrRef(Type *type) {
-    if (IS_TYPE_CLASS(type) || IS_TYPE_ENUM(type))
-        return 1;
-    if (!IS_TYPE_REFERENCE(type))
-        return 0;
-    type = TYPE_POINTER(type)->target;
-    return IS_TYPE_CLASS(type) || IS_TYPE_ENUM(type);
-}
-
-static Boolean CDecl_CheckOperatorType(DeclInfo *declinfo, Boolean flag) {
-    FuncArg *args;
-    FuncArg *secondarg;
-    Type *functype;
-    short argCount;
-    Boolean isMethod;
-
-    if (!IS_TYPE_FUNC(declinfo->thetype)) {
-        CError_Error(CErrorStr193);
-        return 0;
-    }
-
-    functype = TYPE_FUNC(declinfo->thetype)->functype;
-    args = TYPE_FUNC(declinfo->thetype)->args;
-    if (args) {
-        if (args != &elipsis && args != &oldstyle) {
-            argCount = 1;
-            if (args->dexpr) {
-                switch (declinfo->operator_token) {
-                    case TK_NEW:
-                    case TK_DELETE:
-                    case TK_NEW_ARRAY:
-                    case TK_DELETE_ARRAY:
-                        break;
-                    default:
-                        CError_Error(CErrorStr205);
-                }
-            }
-
-            secondarg = args->next;
-            if (secondarg) {
-                argCount = ((secondarg != &elipsis && !secondarg->next) != 0) ? 2 : 3;
-                if (secondarg->dexpr) {
-                    switch (declinfo->operator_token) {
-                        case '(':
-                        case TK_NEW:
-                        case TK_DELETE:
-                        case TK_NEW_ARRAY:
-                        case TK_DELETE_ARRAY:
-                            break;
-                        default:
-                            CError_Error(CErrorStr205);
-                    }
-                }
-            }
-        } else {
-            argCount = 3;
-        }
-    } else {
-        CError_Error(CErrorStr193);
-        return 0;
-    }
-
-    isMethod = flag &&
-               IS_TYPEFUNC_METHOD(TYPE_FUNC(declinfo->thetype)) &&
-               !TYPE_METHOD(declinfo->thetype)->is_static;
-
-    switch (declinfo->operator_token) {
-        case TK_NEW:
-        case TK_NEW_ARRAY:
-            if (isMethod || !is_typesame(functype, TYPE(&void_ptr)) || argCount < 1 || args->type != CABI_GetSizeTType()) {
-                CError_Error(CErrorStr193);
-                return 0;
-            }
-            return 1;
-        case TK_DELETE:
-        case TK_DELETE_ARRAY:
-            if (isMethod || !IS_TYPE_VOID(functype) || argCount < 1 || !is_typesame(args->type, TYPE(&void_ptr))) {
-                CError_Error(CErrorStr193);
-                return 0;
-            }
-            return 1;
-        case '=':
-            if (!isMethod) {
-                CError_Error(CErrorStr193);
-                return 0;
-            }
-            break;
-        case '(':
-            if (!isMethod) {
-                CError_Error(CErrorStr193);
-                return 0;
-            }
-            return 1;
-        case '[':
-            if (!isMethod) {
-                CError_Error(CErrorStr193);
-                return 0;
-            }
-            break;
-        case TK_ARROW:
-            if (argCount != 1 || isMethod == 0) {
-                CError_Error(CErrorStr193);
-                return 0;
-            }
-            return 1;
-        case TK_INCREMENT:
-        case TK_DECREMENT:
-            if (argCount == 2 && secondarg->type != TYPE(&stsignedint)) {
-                CError_Error(CErrorStr193);
-                return 0;
-            }
-            break;
-    }
-
-    if (flag && !isMethod) {
-        CError_Error(CErrorStr193);
-        return 0;
-    }
-
-    switch (declinfo->operator_token) {
-        case '&':
-        case '*':
-        case '+':
-        case '-':
-        case TK_INCREMENT:
-        case TK_DECREMENT:
-            if (argCount != 1)
-                goto whatever;
-        case '!':
-        case '~':
-            if (argCount == 1) {
-                if (flag || CDecl_IsEnumClassTypeOrRef(args->type))
-                    return 1;
-            }
-            break;
-        case '%':
-        case ',':
-        case '/':
-        case '<':
-        case '=':
-        case '>':
-        case '[':
-        case '^':
-        case '|':
-        case TK_MULT_ASSIGN:
-        case TK_DIV_ASSIGN:
-        case TK_MOD_ASSIGN:
-        case TK_ADD_ASSIGN:
-        case TK_SUB_ASSIGN:
-        case TK_SHL_ASSIGN:
-        case TK_SHR_ASSIGN:
-        case TK_AND_ASSIGN:
-        case TK_XOR_ASSIGN:
-        case TK_OR_ASSIGN:
-        case TK_LOGICAL_OR:
-        case TK_LOGICAL_AND:
-        case TK_LOGICAL_EQ:
-        case TK_LOGICAL_NE:
-        case TK_LESS_EQUAL:
-        case TK_GREATER_EQUAL:
-        case TK_SHL:
-        case TK_SHR:
-        case TK_ARROW:
-        case TK_DOT_STAR:
-        case TK_ARROW_STAR:
-        whatever:
-            if (argCount == 2) {
-                if (flag || CDecl_IsEnumClassTypeOrRef(args->type) || CDecl_IsEnumClassTypeOrRef(secondarg->type))
-                    return 1;
-            }
-            break;
-    }
-
-    CError_Error(CErrorStr193);
-    return 0;
-}
-
-static void scandirectdeclarator(DeclInfo *declinfo, NameSpace *nspace) {
-    HashNameNode *saveident;
-    CScopeSave scopesave;
-    Boolean flag;
-
-    if (nspace)
-        CScope_SetNameSpaceScope(nspace, &scopesave);
-
-    if (tk == '(') {
-        if ((tk = lex()) == ')') {
-            if (declinfo->x55) {
-                CDecl_ParseDirectFuncDecl(declinfo);
-                if (nspace)
-                    CScope_RestoreScope(&scopesave);
-                return;
-            } else {
-                CError_Error(CErrorStr121);
-                if (nspace)
-                    CScope_RestoreScope(&scopesave);
-                return;
-            }
-        }
-
-        if (!(tk >= TK_AUTO && tk <= TK_BYREF)) {
-            if (!(tk == TK_IDENTIFIER && CScope_PossibleTypeName(tkidentifier))) {
-                scandecl(declinfo);
-                if (nspace)
-                    CScope_RestoreScope(&scopesave);
-                return;
-            } else {
-                saveident = tkidentifier;
-                switch (lookahead()) {
-                    case ')':
-                    case ',':
-                        break;
-                    default:
-                        tkidentifier = saveident;
-                        scandecl(declinfo);
-                        if (nspace)
-                            CScope_RestoreScope(&scopesave);
-                        return;
-                }
-            }
-        }
-
-        if (declinfo->name)
-            CError_Error(CErrorStr121);
-
-        CDecl_ParseDirectFuncDecl(declinfo);
-        if (nspace)
-            CScope_RestoreScope(&scopesave);
-        return;
-    }
-
-    if (nspace) {
-        if (tk == TK_OPERATOR) {
-            if (!CDecl_ParseOperatorDecl(declinfo)) {
-                CScope_RestoreScope(&scopesave);
-                return;
-            }
-
-            if (declinfo->x54) {
-                declinfo->nspace = nspace;
-                declinfo->name = tkidentifier;
-                if (nspace)
-                    CScope_RestoreScope(&scopesave);
-
-                if (tk == '(') {
-                    tk = lex();
-                    CDecl_ParseDirectFuncDecl(declinfo);
-                    if (IS_TYPE_FUNC(declinfo->thetype))
-                        TYPE_FUNC(declinfo->thetype)->flags |= FUNC_CONVERSION;
-                    else
-                        CError_Error(CErrorStr121);
-                } else {
-                    CError_Error(CErrorStr114);
-                }
-                return;
-            }
-
-            flag = 1;
-        } else if (tk != TK_IDENTIFIER) {
-            CError_Error(CErrorStr107);
-            CScope_RestoreScope(&scopesave);
-            return;
-        } else {
-            flag = 0;
-        }
-
-        if (declinfo->name) {
-            CError_Error(CErrorStr121);
-            CScope_RestoreScope(&scopesave);
-            return;
-        }
-
-        declinfo->nspace = nspace;
-        declinfo->name = tkidentifier;
-        if (!flag)
-            tk = lex();
-    } else if (tk == TK_IDENTIFIER) {
-        if (declinfo->name)
-            CError_Error(CErrorStr121);
-        declinfo->name = tkidentifier;
-        tk = lex();
-    } else if (tk == TK_OPERATOR) {
-        if (!CDecl_ParseOperatorDecl(declinfo))
-            return;
-        declinfo->name = tkidentifier;
-    }
-
-    if (tk == '<' && declinfo->x51) {
-        declinfo->expltargs = CTempl_ParseUncheckTemplArgs(NULL, 0);
-        declinfo->has_expltargs = 1;
-        declinfo->x51 = 0;
-        tk = lex();
-    }
-
-    scandirectdecl1(declinfo);
-
-    if (nspace)
-        CScope_RestoreScope(&scopesave);
-}
-
-void makememberpointertype(DeclInfo *declinfo, TypeClass *tclass, UInt32 qual) {
-    TypeMemberPointer *tmemp;
-    TypeFunc *tfunc;
-
-    if (tclass->flags & CLASS_HANDLEOBJECT) {
-        CError_Error(CErrorStr191);
-        declinfo->thetype = (Type *) &stsignedint;
-        return;
-    }
-    if (tclass->sominfo) {
-        CError_Error(CErrorStr290);
-        declinfo->thetype = (Type *) &stsignedint;
-        return;
-    }
-
-    tmemp = galloc(sizeof(TypeMemberPointer));
-    memclrw(tmemp, sizeof(TypeMemberPointer));
-    tmemp->type = TYPEMEMBERPOINTER;
-    tmemp->ty2 = (Type *) tclass;
-    tmemp->qual = qual;
-
-    if (IS_TYPE_FUNC(declinfo->thetype)) {
-        tfunc = galloc(sizeof(TypeFunc));
-        *tfunc = *TYPE_FUNC(declinfo->thetype);
-        tmemp->ty1 = (Type *) tfunc;
-        tmemp->size = 12;
-        CDecl_MakePTMFuncType(tfunc);
-    } else {
-        tmemp->size = 4;
-        tmemp->ty1 = declinfo->thetype;
-    }
-    declinfo->thetype = (Type *) tmemp;
-}
-
-void CDecl_ScanPointer(DeclInfo *declinfo, NameSpace *nspace, Boolean flag) {
-    NameResult pr;
-    UInt32 qual;
-
-    while (1) {
-        qual = (tk == '&') ? Q_REFERENCE : 0;
-
-        for (tk = lex(); ; tk = lex()) {
-            switch (tk) {
-                case TK_CONST:
-                    if (qual & Q_CONST)
-                        CError_Error(CErrorStr121);
-                    qual |= Q_CONST;
-                    continue;
-                case TK_VOLATILE:
-                    if (qual & Q_VOLATILE)
-                        CError_Error(CErrorStr121);
-                    qual |= Q_VOLATILE;
-                    continue;
-                case TK_RESTRICT:
-                    if (qual & Q_RESTRICT)
-                        CError_Error(CErrorStr121);
-                    qual |= Q_RESTRICT;
-                    continue;
-                default:
-                    break;
-            }
-            break;
-        }
-
-        if (IS_TYPE_REFERENCE(declinfo->thetype) || ((qual & Q_REFERENCE) && IS_TYPE_VOID(declinfo->thetype))) {
-            CError_Error(CErrorStr196);
-            return;
-        }
-
-        if (nspace) {
-            makememberpointertype(declinfo, nspace->theclass, qual);
-            nspace = NULL;
-        } else {
-            makethetypepointer(declinfo, qual);
-        }
-
-        switch (tk) {
-            case '*':
-                continue;
-            case '&':
-                if (!copts.cplusplus) {
-                    if (flag)
-                        scandirectdeclarator(declinfo, NULL);
-                    return;
-                }
-                continue;
-            case TK_IDENTIFIER:
-                if (!copts.cplusplus)
-                    break;
-                if (copts.cpp_extensions && cscope_current->theclass && cscope_current->theclass->classname == tkidentifier && lookahead() == TK_COLON_COLON) {
-                    tk = lex();
-                    tk = lex();
-                    break;
-                }
-            case TK_COLON_COLON:
-                if (CScope_ParseQualifiedNameSpace(&pr, 1, 0)) {
-                    if ((nspace = pr.nspace_0)) {
-                        if (nspace->theclass && tk == '*')
-                            continue;
-                    } else {
-                        if (pr.type && IS_TYPE_TEMPLATE(pr.type) && declinfo->x30) {
-                            if (CTempl_IsQualifiedMember(declinfo, pr.type, &nspace))
-                                scandirectdeclarator(declinfo, nspace);
-                            else
-                                declinfo->x20 = pr.type;
-                            return;
-                        }
-                        CError_Error(CErrorStr121);
-                    }
-                }
-                break;
-        }
-        break;
-    }
-
-    if (flag)
-        scandirectdeclarator(declinfo, nspace);
-}
-
-static void CDecl_TemplatePTM(DeclInfo *declinfo, Type *type) {
-    TypeMemberPointer *tmemp = galloc(sizeof(TypeMemberPointer));
-    tmemp->type = TYPEMEMBERPOINTER;
-    if (IS_TYPE_FUNC(declinfo->thetype)) {
-        CDecl_MakePTMFuncType((TypeFunc *) declinfo->thetype);
-        tmemp->size = 12;
-    } else {
-        tmemp->size = 4;
-    }
-
-    tmemp->ty1 = declinfo->thetype;
-    tmemp->ty2 = type;
-    tmemp->qual = 0;
-    declinfo->thetype = (Type *) tmemp;
-}
-
-void scandeclarator(DeclInfo *declinfo) {
-    NameResult pr;
-    NameSpace *nspace;
-
-    switch (tk) {
-        case '&':
-            if (!copts.cplusplus)
-                break;
-        case '*':
-            CDecl_ScanPointer(declinfo, NULL, 1);
-            if (tk == TK_UU_ATTRIBUTE_UU)
-                CParser_ParseAttribute(NULL, declinfo);
-            return;
-        case TK_IDENTIFIER:
-            if (!copts.cplusplus)
-                break;
-        case TK_COLON_COLON:
-            if (CScope_ParseQualifiedNameSpace(&pr, 1, 0)) {
-                nspace = pr.nspace_0;
-                if (nspace) {
-                    if (nspace->theclass && tk == '*')
-                        CDecl_ScanPointer(declinfo, nspace, 1);
-                    else
-                        scandirectdeclarator(declinfo, nspace);
-                    return;
-                }
-                if (pr.type && IS_TYPE_TEMPLATE(pr.type)) {
-                    if (declinfo->x30 && CTempl_IsQualifiedMember(declinfo, pr.type, &nspace)) {
-                        scandirectdeclarator(declinfo, nspace);
-                        return;
-                    } else if (declinfo->x30 && tk == TK_OPERATOR) {
-                        declinfo->x20 = pr.type;
-                        return;
-                    } else if ((tk = lex()) == TK_COLON_COLON && (tk = lex()) == '*') {
-                        CDecl_TemplatePTM(declinfo, pr.type);
-                        tk = lex();
-                        break;
-                    } else if (declinfo->x30) {
-                        declinfo->x20 = pr.type;
-                        return;
-                    }
-                }
-                CError_Error(CErrorStr121);
-            }
-            break;
-    }
-
-    scandirectdeclarator(declinfo, NULL);
-    if (tk == TK_UU_ATTRIBUTE_UU)
-        CParser_ParseAttribute(NULL, declinfo);
-}
-
-void conversion_type_name(DeclInfo *declinfo) {
-    NameResult pr;
-    DeclInfo subdeclinfo;
-
-    memclrw(&subdeclinfo, sizeof(DeclInfo));
-    CParser_GetDeclSpecs(&subdeclinfo, 0);
-
-    switch (tk) {
-        case '&':
-        case '*':
-            CDecl_ScanPointer(&subdeclinfo, NULL, 0);
-            break;
-        case TK_IDENTIFIER:
-        case TK_COLON_COLON:
-            if (CScope_ParseQualifiedNameSpace(&pr, 0, 0)) {
-                if (pr.nspace_0 && pr.nspace_0->theclass && tk == '*')
-                    CDecl_ScanPointer(&subdeclinfo, pr.nspace_0, 0);
-                else
-                    CError_Error(CErrorStr121);
-            }
-            break;
-    }
-
-    declinfo->name = subdeclinfo.name;
-    declinfo->thetype = subdeclinfo.thetype;
-    declinfo->qual |= subdeclinfo.qual;
-}
-
-static void scaninlinefunc(Object *obj) {
-    short array[256];
-    short r29;
-    CInt64 val;
-
-    if (tk == '{') {
-        tk = lex();
-        r29 = 0;
-        while (1) {
-            if (r29 >= 256) {
-                CError_Error(CErrorStr127);
-                r29 = 255;
-            }
-            val = CExpr_IntegralConstExpr();
-            array[r29++] = CInt64_GetULong(&val);
-            if (tk != '}') {
-                if (tk != ',')
-                    CError_Error(CErrorStr116);
-                tk = lex();
-            } else {
-                tk = lex();
-                break;
-            }
-        }
-    } else {
-        val = CExpr_IntegralConstExpr();
-        array[0] = CInt64_GetULong(&val);
-        r29 = 1;
-    }
-
-    obj->datatype = DINLINEFUNC;
-    obj->u.ifunc.size = r29 * 2;
-    obj->u.ifunc.data = galloc(obj->u.ifunc.size);
-    obj->u.ifunc.xrefs = NULL;
-    memcpy(obj->u.ifunc.data, array, obj->u.ifunc.size);
-
-    if (tk != ';')
-        CError_Error(CErrorStr123);
-}
-
-typedef enum {
-    OverloadMode0,
-    OverloadMode1,
-    OverloadMode2,
-    OverloadMode3
-} OverloadMode;
-
-static Object *CDecl_OverloadFunctionObject(NameSpaceObjectList *list, DeclInfo *declinfo, Boolean *outflag, OverloadMode mode, Boolean flag2) {
-    TypeFunc *scanfunc;
-    NameSpaceObjectList *scan;
-    TypeFunc *tfunc;
-    FuncArg *args;
-    FuncArg *scanargs;
-    Object *obj;
-    Boolean r24;
-    short compareresult;
-
-    if (outflag)
-        *outflag = 0;
-
-    tfunc = (TypeFunc *) declinfo->thetype;
-    args = tfunc->args;
-    r24 = 0;
-    for (scan = list; scan; scan = scan->next) {
-        obj = OBJECT(scan->object);
-        if (obj->otype != OT_OBJECT)
-            continue;
-
-        scanfunc = TYPE_FUNC(obj->type);
-        if (!IS_TYPE_FUNC(scanfunc))
-            continue;
-
-        scanargs = scanfunc->args;
-        if (scanfunc->flags & FUNC_IS_TEMPL)
-            r24 = 1;
-
-        if (IS_TYPEFUNC_METHOD(scanfunc)) {
-            switch (mode) {
-                case OverloadMode0:
-                    CError_Error(CErrorStr197);
-                    break;
-                case OverloadMode1:
-                    if (!TYPE_METHOD(scanfunc)->is_static)
-                        continue;
-                    break;
-                case OverloadMode2:
-                    if (TYPE_METHOD(scanfunc)->is_static)
-                        continue;
-                    break;
-                case OverloadMode3:
-                    if (!TYPE_METHOD(scanfunc)->is_static) {
-                        if (scanargs->qual & Q_CV)
-                            continue;
-                        scanargs = scanargs->next;
-                    }
-                    break;
-            }
-        } else {
-            if (mode)
-                CError_Error(CErrorStr197);
-        }
-
-        compareresult = CParser_CompareArgLists(args, scanargs);
-        if (compareresult == 1) {
-            if (scanfunc->flags & FUNC_CONVERSION) {
-                if (!(tfunc->flags & FUNC_CONVERSION)) {
-                    CError_Error(CErrorStr197);
-                    break;
-                }
-                if (!is_typesame(tfunc->functype, scanfunc->functype))
-                    continue;
-                if ((tfunc->qual & Q_CV) != (scanfunc->qual & Q_CV))
-                    continue;
-                if ((tfunc->flags & FUNC_CALL_CONV_MASK) != (scanfunc->flags & FUNC_CALL_CONV_MASK)) {
-                    CError_Error(CErrorStr197);
-                    break;
-                }
-                if (tfunc->exspecs || scanfunc->exspecs)
-                    CExcept_CompareSpecifications(tfunc->exspecs, scanfunc->exspecs);
-                return obj;
-            }
-
-            if (tfunc->flags & FUNC_CONVERSION) {
-                CError_Error(CErrorStr197);
-                break;
-            }
-
-            if (
-                !is_typesame(tfunc->functype, scanfunc->functype) ||
-                ((tfunc->qual & (Q_CONST | Q_PASCAL)) != (scanfunc->qual & (Q_CONST | Q_PASCAL))) ||
-                ((tfunc->flags & FUNC_CALL_CONV_MASK) != (scanfunc->flags & FUNC_CALL_CONV_MASK))
-                )
-            {
-                CError_Error(CErrorStr197);
-                break;
-            }
-
-            if (tfunc->exspecs || scanfunc->exspecs) {
-                if (obj->name != newp_fobj->name && obj->name != newa_fobj->name && obj->name != delp_fobj->name && obj->name != dela_fobj->name)
-                    CExcept_CompareSpecifications(tfunc->exspecs, scanfunc->exspecs);
-            }
-
-            return obj;
-        } else if (compareresult == 2) {
-            CError_Error(CErrorStr197);
-            break;
-        }
-    }
-
-    if (r24 && (flag2 || declinfo->x3C)) {
-        if ((obj = CTempl_TemplateFunctionCheck(declinfo, list)))
-            return obj;
-    }
-
-    if (!outflag) {
-        CError_Error(CErrorStr197);
-        return NULL;
-    }
-
-    if (declinfo->nspace)
-        CError_Error(CErrorStr336);
-
-    *outflag = 1;
-    obj = CParser_NewFunctionObject(declinfo);
-    CheckDefaultArgs(TYPE_FUNC(obj->type)->args);
-
-    if (tfunc->flags & FUNC_PASCAL) {
-        for (scan = list; scan; scan = scan->next) {
-            if (scan->object->otype == OT_OBJECT && IS_TYPE_FUNC(OBJECT(scan->object)->type)) {
-                if (TYPE_FUNC(OBJECT(scan->object)->type)->flags & FUNC_PASCAL)
-                    CError_Error(CErrorStr226);
-            }
-        }
-    }
-
-    if (copts.cplusplus && declinfo->is_extern_c) {
-        for (scan = list; scan; scan = scan->next) {
-            if (scan->object->otype == OT_OBJECT && !(OBJECT(scan->object)->qual & Q_MANGLE_NAME))
-                CError_Error(CErrorStr197);
-        }
-    }
-
-    CScope_AddObject(cscope_current, declinfo->name, OBJ_BASE(obj));
-    if (cscope_current->theclass && (cscope_current->theclass->flags & CLASS_IS_TEMPL) &&
-        CTemplTool_IsTemplateArgumentDependentType(declinfo->thetype))
-        CTemplClass_RegisterObjectDef(TEMPL_CLASS(cscope_current->theclass), OBJ_BASE(obj));
-
-    return obj;
-}
-
-void MergeDefaultArgs(FuncArg *a, FuncArg *b) {
-    FuncArg *scan_a;
-    FuncArg *scan_b;
-
-    if (a == &oldstyle || b == &oldstyle)
-        return;
-
-    scan_a = a;
-    scan_b = b;
-    while (scan_a && scan_b) {
-        if (scan_a->dexpr) {
-            while (scan_b) {
-                if (scan_b->dexpr) {
-                    while (a) {
-                        a->dexpr = NULL;
-                        a = a->next;
-                    }
-                    while (b) {
-                        b->dexpr = NULL;
-                        b = b->next;
-                    }
-                    CError_Error(CErrorStr205);
-                    return;
-                }
-                scan_b = scan_b->next;
-            }
-            break;
-        } else if (scan_b->dexpr) {
-            do {
-                scan_a = scan_a->next;
-                scan_b = scan_b->next;
-                if (!scan_a) goto secondpart;
-                if (scan_a == &elipsis) goto secondpart;
-                if (scan_a->dexpr && scan_b->dexpr) break;
-            } while (scan_a->dexpr || scan_b->dexpr);
-
-            while (a) {
-                a->dexpr = NULL;
-                a = a->next;
-            }
-            while (b) {
-                b->dexpr = NULL;
-                b = b->next;
-            }
-            CError_Error(CErrorStr205);
-            return;
-        } else {
-            scan_a = scan_a->next;
-            scan_b = scan_b->next;
-        }
-    }
-
-secondpart:
-    while (a && b) {
-        if (b->dexpr)
-            a->dexpr = b->dexpr;
-        else
-            b->dexpr = a->dexpr;
-        a = a->next;
-        b = b->next;
-    }
-}
-
-void CheckDefaultArgs(FuncArg *args) {
-    FuncArg *scan;
-
-    scan = args;
-    while (scan && !scan->dexpr)
-        scan = scan->next;
-
-    while (scan && scan != &elipsis && scan != &oldstyle) {
-        if (!scan->dexpr) {
-            while (args) {
-                args->dexpr = NULL;
-                args = args->next;
-            }
-            CError_Error(CErrorStr205);
-            return;
-        }
-        scan = scan->next;
-    }
-}
-
-static void CDecl_FuncRedeclCheck(Object *obj, DeclInfo *declinfo, Boolean flag) {
-    if (declinfo->storageclass == TK_STATIC && obj->sclass != TK_STATIC) {
-        if (copts.cplusplus)
-            CError_Error(CErrorStr260);
-        else
-            obj->sclass = TK_STATIC;
-    }
-
-    obj->qual |= declinfo->qual;
-    if (flag)
-        CheckDefaultArgs(TYPE_FUNC(obj->type)->args);
-    else
-        MergeDefaultArgs(TYPE_FUNC(obj->type)->args, TYPE_FUNC(declinfo->thetype)->args);
-
-    if (!declinfo->x45)
-        TYPE_FUNC(obj->type)->args = TYPE_FUNC(declinfo->thetype)->args;
-}
-
-Object *CDecl_GetFunctionObject(DeclInfo *declinfo, NameSpace *nspace, Boolean *pflag, Boolean someotherflag) {
-    NameSpace *nspace2;
-    Type *type;
-    Object *obj;
-    NameSpaceObjectList *list;
-    TypeMemberFunc tmp;
-    Boolean r27;
-    Boolean outflag;
-
-    r27 = 0;
-    if (pflag)
-        *pflag = 0;
-
-    nspace2 = declinfo->nspace;
-    if (!nspace2)
-        nspace2 = cscope_current;
-
-    CError_QualifierCheck(declinfo->qual & ~(Q_ALIGNED_MASK | Q_WEAK | Q_20000 | Q_INLINE | Q_PASCAL | Q_ASM | Q_VOLATILE | Q_CONST));
-    switch (TYPE_FUNC(declinfo->thetype)->functype->type) {
-        case TYPEFUNC:
-        case TYPEARRAY:
-            CError_Error(CErrorStr128);
-            TYPE_FUNC(declinfo->thetype)->functype = TYPE(&stsignedint);
-            break;
-    }
-
-    if (nspace2->theclass) {
-        CError_ASSERT(1969, declinfo->name);
-        if (!nspace2->theclass->size)
-            CDecl_CompleteType(TYPE(nspace2->theclass));
-        if (!(list = CScope_GetLocalObject(nspace2, declinfo->name))) {
-            CError_Error(CErrorStr140, declinfo->name->name);
-            return NULL;
-        }
-
-        obj = OBJECT(list->object);
-        type = obj->type;
-        if (!IS_TYPE_FUNC(type)) {
-            CError_Error(CErrorStr249, CError_GetObjectName(obj), type, obj->qual, declinfo->thetype, declinfo->qual);
-            return NULL;
-        }
-
-        if (declinfo->has_expltargs)
-            return CTempl_TemplateFunctionCheck(declinfo, list);
-
-        if (declinfo->x3C || (list->next && list->next->object->otype == OT_OBJECT)) {
-            if (TYPE_FUNC(declinfo->thetype)->flags & (FUNC_CONST | FUNC_VOLATILE)) {
-                CDecl_AddThisPointerArgument(TYPE_FUNC(declinfo->thetype), nspace2->theclass);
-                obj = CDecl_OverloadFunctionObject(list, declinfo, NULL, OverloadMode2, someotherflag);
-                if (!obj)
-                    return NULL;
-            } else {
-                obj = CDecl_OverloadFunctionObject(list, declinfo, NULL, OverloadMode3, someotherflag);
-                if (!obj)
-                    return NULL;
-                if (!TYPE_METHOD(obj->type)->is_static)
-                    CDecl_AddThisPointerArgument(TYPE_FUNC(declinfo->thetype), nspace2->theclass);
-            }
-        } else {
-            if (TYPE_METHOD(type)->is_static) {
-                if (nspace2->theclass->sominfo)
-                    CSOM_FixNewDeleteFunctype(TYPE_FUNC(declinfo->thetype));
-            } else {
-                CDecl_AddThisPointerArgument(TYPE_FUNC(declinfo->thetype), nspace2->theclass);
-            }
-
-            if (copts.cpp_extensions) {
-                declinfo->qual |= obj->qual & (Q_PASCAL | Q_CONST);
-                TYPE_FUNC(declinfo->thetype)->qual |= TYPE_FUNC(obj->type)->qual & (Q_PASCAL | Q_CONST);
-                TYPE_FUNC(declinfo->thetype)->flags |= TYPE_FUNC(obj->type)->flags & (FUNC_FLAGS_4000000 | FUNC_FLAGS_10000000);
-            }
-
-            if (!is_typesame(declinfo->thetype, obj->type) || (declinfo->qual & (Q_PASCAL | Q_CONST)) != (obj->qual & (Q_PASCAL | Q_CONST))) {
-                tmp = *TYPE_METHOD(obj->type);
-                *(TYPE_FUNC(&tmp)) = *TYPE_FUNC(declinfo->thetype);
-                tmp.flags |= FUNC_METHOD;
-                CError_Error(CErrorStr249, CError_GetObjectName(obj), obj->type, obj->qual, &tmp, declinfo->qual);
-            }
-
-            if (TYPE_FUNC(declinfo->thetype)->exspecs || TYPE_FUNC(obj->type)->exspecs)
-                CExcept_CompareSpecifications(TYPE_FUNC(declinfo->thetype)->exspecs, TYPE_FUNC(obj->type)->exspecs);
-        }
-
-        CDecl_FuncRedeclCheck(obj, declinfo, 0);
-        if (declinfo->x3C) {
-            if (obj->nspace->theclass && !(obj->nspace->theclass->flags & CLASS_IS_TEMPL_INST))
-                CError_Error(CErrorStr335);
-            declinfo->x3C = 0;
-        }
-    } else {
-        if (TYPE_FUNC(declinfo->thetype)->flags & (FUNC_VOLATILE | FUNC_CONST))
-            CError_Error(CErrorStr384);
-
-        if (declinfo->operator_token && !CDecl_CheckOperatorType(declinfo, 0))
-            return NULL;
-
-        list = CScope_GetLocalObject(nspace2, declinfo->name);
-        if (declinfo->has_expltargs)
-            return CTempl_TemplateFunctionCheck(declinfo, list);
-
-        if (list) {
-            if (copts.cplusplus) {
-                obj = CDecl_OverloadFunctionObject(list, declinfo, &outflag, OverloadMode0, someotherflag);
-                if (!obj)
-                    return NULL;
-                if (pflag)
-                    *pflag = outflag;
-                if (nspace)
-                    obj->nspace = nspace;
-            } else {
-                obj = OBJECT(list->object);
-                if (!is_typesame(declinfo->thetype, obj->type) || (declinfo->qual & (Q_CONST | Q_PASCAL)) != (obj->qual & (Q_CONST | Q_PASCAL))) {
-                    CError_Error(CErrorStr249, CError_GetObjectName(obj), obj->type, obj->qual, declinfo->thetype, declinfo->qual);
-                    r27 = 1;
-                    if (!IS_TYPE_FUNC(obj->type))
-                        return NULL;
-                }
-            }
-
-            if (!r27 && pflag)
-                CDecl_FuncRedeclCheck(obj, declinfo, *pflag);
-        } else {
-            if (declinfo->nspace)
-                CError_Error(CErrorStr336);
-
-            if (declinfo->has_expltargs) {
-                if (declinfo->name)
-                    CError_Error(CErrorStr140, declinfo->name->name);
-                else
-                    CError_Error(CErrorStr127);
-            }
-
-            obj = CParser_NewFunctionObject(declinfo);
-            if (nspace)
-                obj->nspace = nspace;
-            if (pflag)
-                *pflag = 1;
-            else
-                CError_Error(CErrorStr127);
-
-            CheckDefaultArgs(TYPE_FUNC(obj->type)->args);
-            CScope_AddObject(nspace2, declinfo->name, OBJ_BASE(obj));
-        }
-    }
-
-    return obj;
-}
-
-void CDecl_TypedefDeclarator(DeclInfo *declinfo) {
-    NameSpace *nspace;
-    NameSpaceObjectList *list;
-    ObjType *objt;
-
-    nspace = declinfo->nspace;
-    if (!nspace)
-        nspace = cscope_current;
-
-    CError_QualifierCheck(declinfo->qual & ~(Q_ALIGNED_MASK | Q_REFERENCE | Q_PASCAL | Q_VOLATILE | Q_CONST));
-    if (declinfo->x48 || declinfo->x44)
-        CError_Error(CErrorStr121);
-    if (declinfo->operator_token)
-        CError_Error(CErrorStr193);
-
-    objt = NULL;
-    list = CScope_FindName(nspace, declinfo->name);
-    if (list) {
-        switch (list->object->otype) {
-            case OT_TYPE:
-                objt = OBJ_TYPE(list->object);
-                break;
-            case OT_TYPETAG:
-                break;
-            case OT_NAMESPACE:
-                CError_Error(CErrorStr321);
-                return;
-            case OT_ENUMCONST:
-            case OT_OBJECT:
-                CError_Error(CErrorStr322);
-                return;
-            default:
-                CError_FATAL(2156);
-        }
-    }
-
-    if (objt) {
-        const UInt32 mask = Q_ALIGNED_MASK | Q_REFERENCE | Q_PASCAL | Q_VOLATILE | Q_CONST;
-        if (!is_typesame(objt->type, declinfo->thetype) || (objt->qual & mask) != (declinfo->qual & mask)) {
-            CError_Error(CErrorStr249, declinfo->name->name, objt->type, objt->qual, declinfo->thetype, declinfo->qual);
-        } else if (!copts.cplusplus && (copts.pedantic || copts.ANSIstrict)) {
-            if (copts.pedantic)
-                CError_Warning(CErrorStr122, declinfo->name->name);
-            else
-                CError_Error(CErrorStr122, declinfo->name->name);
-        }
-        return;
-    }
-
-    objt = galloc(sizeof(ObjType));
-    memclrw(objt, sizeof(ObjType));
-    objt->otype = OT_TYPE;
-    objt->access = ACCESSPUBLIC;
-    objt->type = declinfo->thetype;
-    objt->qual = declinfo->qual;
-    CScope_AddObject(nspace, declinfo->name, OBJ_BASE(objt));
-
-    if (nspace->theclass && (nspace->theclass->flags & CLASS_IS_TEMPL) &&
-        CTemplTool_IsTemplateArgumentDependentType(declinfo->thetype))
-        CTemplClass_RegisterObjectDef(TEMPL_CLASS(nspace->theclass), OBJ_BASE(objt));
-
-    if (copts.cplusplus) {
-        if (IS_TYPE_CLASS(declinfo->thetype) && IsTempName(TYPE_CLASS(declinfo->thetype)->classname)) {
-            TYPE_CLASS(declinfo->thetype)->classname = declinfo->name;
-            TYPE_CLASS(declinfo->thetype)->nspace->name = declinfo->name;
-        }
-        if (IS_TYPE_ENUM(declinfo->thetype) && IsTempName(TYPE_ENUM(declinfo->thetype)->enumname)) {
-            TYPE_ENUM(declinfo->thetype)->enumname = declinfo->name;
-        }
-    }
-
-    if (cparamblkptr->browseoptions.recordTypedefs && declinfo->file->recordbrowseinfo)
-        CBrowse_NewTypedef(nspace, declinfo->name, declinfo->file, declinfo->file2, declinfo->sourceoffset, CPrep_BrowserFileOffset());
-}
-
-static void CDecl_DataDeclarator(DeclInfo *declinfo, AccessType access, Boolean flag) {
-    NameSpaceObjectList *list;
-    Object *obj;
-    NameSpace *nspace;
-    Boolean tmpflag;
-    ENode *expr;
-
-    nspace = declinfo->nspace;
-    if (!nspace)
-        nspace = cscope_current;
-
-    CError_QualifierCheck(declinfo->qual & ~(Q_ALIGNED_MASK | Q_WEAK | Q_20000 | Q_PASCAL | Q_VOLATILE | Q_CONST));
-    if (declinfo->x48 || declinfo->x44)
-        CError_Error(CErrorStr121);
-    if (declinfo->operator_token)
-        CError_Error(CErrorStr193);
-
-    obj = NULL;
-    list = CScope_FindName(nspace, declinfo->name);
-    if (list) {
-        switch (list->object->otype) {
-            case OT_OBJECT:
-                obj = OBJECT(list->object);
-                if (flag)
-                    CError_Error(CErrorStr122, declinfo->name->name);
-                break;
-            case OT_TYPETAG:
-                break;
-            case OT_NAMESPACE:
-                CError_Error(CErrorStr321);
-                return;
-            case OT_ENUMCONST:
-            case OT_TYPE:
-                CError_Error(CErrorStr322);
-                break;
-            case OT_MEMBERVAR:
-                CError_Error(CErrorStr221);
-                break;
-            default:
-                CError_FATAL(2281);
-        }
-    }
-
-    if (copts.cplusplus) {
-        if (!flag)
-            CDecl_CompleteType(declinfo->thetype);
-        switch (declinfo->storageclass) {
-            case TK_EXTERN:
-                if (tk == '=' || tk == '(')
-                    declinfo->storageclass = 0;
-                break;
-            case 0:
-                if (CParser_IsConst(declinfo->thetype, declinfo->qual)) {
-                    if ((!obj && !nspace->theclass) || (obj && obj->sclass != TK_EXTERN && !obj->nspace->theclass))
-                        declinfo->storageclass = TK_STATIC;
-                }
-                break;
-        }
-    } else {
-        if (declinfo->storageclass == TK_EXTERN && tk == '=')
-            declinfo->storageclass = 0;
-    }
-
-    if (IS_TYPE_ARRAY(declinfo->thetype) && !declinfo->thetype->size && !declinfo->storageclass && tk != '=')
-        declinfo->storageclass = TK_EXTERN;
-
-    if (obj) {
-        if ((!obj->type->size || !declinfo->thetype->size) && IS_TYPE_ARRAY(declinfo->thetype) && IS_TYPE_ARRAY(obj->type))
-            tmpflag = is_typesame(TYPE_POINTER(declinfo->thetype)->target, TYPE_POINTER(obj->type)->target);
-        else
-            tmpflag = is_typesame(declinfo->thetype, obj->type);
-
-        if (!tmpflag || (obj->qual & (Q_PASCAL | Q_VOLATILE | Q_CONST)) != (declinfo->qual & (Q_PASCAL | Q_VOLATILE | Q_CONST)))
-            CError_Error(CErrorStr249, CError_GetObjectName(obj), obj->type, obj->qual, declinfo->thetype, declinfo->qual);
-
-        if (obj->qual & Q_INLINE_DATA) {
-            if (tk == ',' || tk == ';')
-                return;
-            CError_Error(CErrorStr333, obj);
-        }
-
-        if (declinfo->storageclass != TK_EXTERN) {
-            if (obj->sclass != TK_EXTERN && declinfo->storageclass && obj->sclass != declinfo->storageclass)
-                CError_Error(CErrorStr333, obj);
-
-            if (tmpflag) {
-                obj->sclass = declinfo->storageclass;
-                obj->qual |= declinfo->qual;
-                if (declinfo->thetype->size)
-                    obj->type = declinfo->thetype;
-            }
-
-            CParser_UpdateObject(obj, declinfo);
-        } else {
-            flag = 1;
-        }
-    } else {
-        if (declinfo->nspace)
-            CError_Error(CErrorStr336);
-        if (IS_TYPE_CLASS(declinfo->thetype) && TYPE_CLASS(declinfo->thetype)->sominfo)
-            CError_Error(CErrorStr288);
-        if (!CanCreateObject(declinfo->thetype))
-            declinfo->thetype = TYPE(&stsignedint);
-
-        obj = CParser_NewGlobalDataObject(declinfo);
-        obj->access = access;
-        CScope_AddObject(nspace, declinfo->name, OBJ_BASE(obj));
-
-        if (nspace->theclass && (nspace->theclass->flags & CLASS_IS_TEMPL) &&
-            CTemplTool_IsTemplateArgumentDependentType(declinfo->thetype))
-            CTemplClass_RegisterObjectDef(TEMPL_CLASS(nspace->theclass), OBJ_BASE(obj));
-
-        if (flag && nspace->theclass && cparamblkptr->browseoptions.recordClasses)
-            CBrowse_AddClassMemberData(obj, CPrep_BrowserTokenOffset(&member_fileoffset) + 1, CPrep_BrowserFileOffset());
-    }
-
-    if (!flag) {
-        if (declinfo->nspace) {
-            CScopeSave save;
-            CScope_SetNameSpaceScope(declinfo->nspace, &save);
-            CInit_InitializeData(obj);
-            CScope_RestoreScope(&save);
-
-            if (declinfo->x3C && obj->nspace->theclass && (TYPE_CLASS(obj->nspace->theclass)->flags & CLASS_IS_TEMPL_INST))
-                declinfo->x3C = 0;
-        } else {
-            CInit_InitializeData(obj);
-        }
-
-        if (declinfo->file->recordbrowseinfo && obj->sclass != TK_EXTERN)
-            CBrowse_NewData(obj, declinfo->file, declinfo->file2, declinfo->sourceoffset, CPrep_BrowserFileOffset());
-    } else if (tk == '=') {
-        tk = lex();
-        expr = CExpr_IntegralConstOrDepExpr();
-        if (IS_TYPE_TEMPLATE(obj->type) || !ENODE_IS(expr, EINTCONST)) {
-            CError_ASSERT(2426, nspace->theclass && (nspace->theclass->flags & CLASS_IS_TEMPL));
-            CTemplClass_RegisterObjectInit(TEMPL_CLASS(nspace->theclass), obj, expr);
-        } else if ((obj->qual & Q_CONST) && IS_TYPE_INT_OR_ENUM(obj->type)) {
-            obj->u.data.u.intconst = expr->data.intval;
-            obj->qual |= Q_INLINE_DATA | Q_20000;
-        } else {
-            CError_Error(CErrorStr354, obj->name->name);
-        }
-    }
-}
-
-Boolean CDecl_FunctionDeclarator(DeclInfo *declinfo, NameSpace *nspace, Boolean flag, Boolean flag2) {
-    Object *obj;
-    Boolean pflag;
-
-    obj = CDecl_GetFunctionObject(declinfo, nspace, &pflag, 0);
-    if (obj) {
-        if (declinfo->x44 || tk == '{' || tk == TK_TRY || (declinfo->x4B && tk == ':') || (!copts.cplusplus && isdeclaration(0, 0, 0, 0))) {
-            if (!flag || cscope_currentfunc) {
-                CError_Error(CErrorStr127);
-                if (cscope_currentfunc)
-                    return 0;
-            }
-
-            if (obj->nspace == cscope_root && !strcmp(obj->name->name, "main")) {
-                if (obj->sclass == TK_STATIC || (copts.ANSIstrict && TYPE_FUNC(obj->type)->functype != (Type *) &stsignedint))
-                    CError_Error(CErrorStr334);
-            } else if (copts.checkprotos && (pflag || declinfo->x64)) {
-                if (obj->sclass != TK_STATIC && !(obj->qual & Q_INLINE) && !obj->nspace->is_unnamed)
-                    CError_Warning(CErrorStr178);
-            }
-
-            CFunc_ParseFuncDef(obj, declinfo, NULL, 0, 0, NULL);
-            if (declinfo->file->recordbrowseinfo)
-                CBrowse_NewFunction(
-                        obj,
-                        declinfo->file,
-                        declinfo->file2,
-                        declinfo->sourceoffset,
-                        CPrep_BrowserFileOffset());
-
-            if (copts.cplusplus && lookahead() == ';')
-                tk = lex();
-            return 0;
-        }
-    }
-
-    return 1;
-}
-
-static void CDecl_ParseSpecialMember(DeclInfo *declinfo, Boolean flag) {
-    Object *r28;
-    NameSpace *r25;
-
-    if (!(r28 = declinfo->x10)) {
-        CError_ASSERT(2544, declinfo->x14);
-        r28 = OBJECT(declinfo->x14->object);
-        CError_ASSERT(2546, r28->otype == OT_OBJECT);
-    }
-
-    if (!r28->nspace->theclass) {
-        CError_Error(CErrorStr121);
-        return;
-    }
-
-    if (IS_TYPE_FUNC(r28->type)) {
-        if (TYPE_FUNC(r28->type)->flags & (FUNC_IS_CTOR | FUNC_IS_DTOR)) {
-            if (r28->nspace->theclass->sominfo)
-                declinfo->thetype = TYPE(&stvoid);
-            else
-                declinfo->thetype = TYPE(&void_ptr);
-            declinfo->nspace = r28->nspace;
-            declinfo->name = r28->name;
-            if (TYPE_FUNC(r28->type)->flags & FUNC_IS_CTOR)
-                declinfo->x4B = 1;
-
-            if ((tk = lex()) == '(') {
-                tk = lex();
-
-                r25 = cscope_current;
-                cscope_current = r28->nspace;
-                CDecl_ParseDirectFuncDecl(declinfo);
-                cscope_current = r25;
-
-                if (IS_TYPE_FUNC(declinfo->thetype)) {
-                    if (TYPE_FUNC(r28->type)->flags & FUNC_IS_CTOR) {
-                        if ((r28->nspace->theclass->flags & CLASS_HAS_VBASES) && !r28->nspace->theclass->sominfo)
-                            CDecl_AddArgument(TYPE_FUNC(declinfo->thetype), TYPE(&stsignedshort));
-                    } else {
-                        if (!r28->nspace->theclass->sominfo)
-                            CDecl_AddArgument(TYPE_FUNC(declinfo->thetype), TYPE(&stsignedshort));
-                    }
-                    if (flag)
-                        CDecl_FunctionDeclarator(declinfo, NULL, 1, 1);
-                } else {
-                    CError_Error(CErrorStr121);
-                }
-            } else {
-                CError_Error(CErrorStr114);
-            }
-            return;
-        } else if (TYPE_FUNC(r28->type)->flags & FUNC_CONVERSION) {
-            CError_FATAL(2603);
-
-            declinfo->thetype = TYPE_FUNC(r28->type)->functype;
-            declinfo->qual |= TYPE_FUNC(r28->type)->qual;
-            declinfo->nspace = r28->nspace;
-            declinfo->name = r28->name;
-
-            if ((tk = lex()) == '(') {
-                tk = lex();
-                CDecl_ParseDirectFuncDecl(declinfo);
-                if (IS_TYPE_FUNC(declinfo->thetype)) {
-                    TYPE_FUNC(declinfo->thetype)->flags |= FUNC_CONVERSION;
-                    if (flag)
-                        CDecl_FunctionDeclarator(declinfo, NULL, 1, 1);
-                } else {
-                    CError_Error(CErrorStr121);
-                }
-            } else {
-                CError_Error(CErrorStr114);
-            }
-            return;
-        } else {
-            declinfo->thetype = TYPE(&stsignedint);
-            declinfo->nspace = r28->nspace;
-            declinfo->name = r28->name;
-
-            if ((tk = lex()) == '(') {
-                tk = lex();
-
-                r25 = cscope_current;
-                cscope_current = r28->nspace;
-                CDecl_ParseDirectFuncDecl(declinfo);
-                cscope_current = r25;
-
-                if (IS_TYPE_FUNC(declinfo->thetype)) {
-                    if (flag)
-                        CDecl_FunctionDeclarator(declinfo, NULL, 1, 1);
-                    return;
-                }
-            } else {
-                CError_Error(CErrorStr114);
-            }
-        }
-    }
-
-    CError_Error(CErrorStr121);
-}
-
-void CDecl_ScanDeclarator(DeclInfo *declinfo) {
-    if (declinfo->x14 || declinfo->x10) {
-        CDecl_ParseSpecialMember(declinfo, 0);
-        CDecl_GetFunctionObject(declinfo, NULL, NULL, 1);
-        return;
-    }
-
-    if (IS_TYPE_FUNC(declinfo->thetype)) {
-        TypeFunc *copy = galloc(sizeof(TypeFunc));
-        *copy = *TYPE_FUNC(declinfo->thetype);
-        declinfo->thetype = TYPE(copy);
-    }
-    scandeclarator(declinfo);
-    if (!declinfo->name) {
-        CError_Error(CErrorStr121);
-        return;
-    }
-
-    if (declinfo->storageclass && declinfo->storageclass != TK_EXTERN)
-        CError_Error(CErrorStr177);
-
-    if (IS_TYPE_FUNC(declinfo->thetype)) {
-        CDecl_GetFunctionObject(declinfo, NULL, NULL, 1);
-        return;
-    }
-
-    if (declinfo->x48 || declinfo->x44)
-        CError_Error(CErrorStr121);
-
-    if (declinfo->operator_token)
-        CError_Error(CErrorStr193);
-
-    if (
-        (declinfo->qual & ~(Q_ALIGNED_MASK | Q_WEAK | Q_20000 | Q_PASCAL | Q_VOLATILE | Q_CONST)) ||
-        (declinfo->storageclass == TK_TYPEDEF && (declinfo->qual & ~(Q_ALIGNED_MASK | Q_REFERENCE | Q_PASCAL | Q_VOLATILE | Q_CONST)))
-            )
-        CError_Error(CErrorStr176);
-}
-
-void scandeclaratorlist(DeclInfo *declinfo) {
-    CScopeSave savescope;
-    Type *r30;
-    UInt32 r29;
-    Boolean r28;
-
-    if (declinfo->x14 || declinfo->x10) {
-        CDecl_ParseSpecialMember(declinfo, 1);
-        return;
-    }
-
-    CScope_GetScope(&savescope);
-    CError_ASSERT(2707, declinfo->thetype);
-
-    r28 = 1;
-    while (1) {
-        r30 = declinfo->thetype;
-        r29 = declinfo->qual;
-        declinfo->nspace = NULL;
-        declinfo->operator_token = 0;
-        if (IS_TYPE_FUNC(r30)) {
-            declinfo->thetype = galloc(sizeof(TypeFunc));
-            *TYPE_FUNC(declinfo->thetype) = *TYPE_FUNC(r30);
-        }
-        declinfo->name = NULL;
-        scandeclarator(declinfo);
-        if (!declinfo->name) {
-            CError_Error(CErrorStr121);
-            break;
-        }
-
-        if (declinfo->storageclass != TK_TYPEDEF) {
-            if (IS_TYPE_FUNC(declinfo->thetype)) {
-                if (!CDecl_FunctionDeclarator(declinfo, NULL, r28, 1))
-                    return;
-            } else {
-                CDecl_DataDeclarator(declinfo, ACCESSPUBLIC, 0);
-            }
-        } else {
-            CDecl_TypedefDeclarator(declinfo);
-        }
-
-        CScope_RestoreScope(&savescope);
-        declinfo->thetype = r30;
-        declinfo->qual = r29;
-
-        if (tk != ',')
-            break;
-        tk = lex();
-        r28 = 0;
-    }
-
-    if (tk != ';')
-        CError_Error(CErrorStr123);
-}
-
-static TypeIntegral *CDecl_FindSignedType(short size) {
-    if (stsignedchar.size == size)
-        return &stsignedchar;
-    if (stsignedshort.size == size)
-        return &stsignedshort;
-    if (stsignedint.size == size)
-        return &stsignedint;
-    if (stsignedlong.size == size)
-        return &stsignedlong;
-    if (copts.longlong && copts.longlong_enums && stsignedlonglong.size == size)
-        return &stsignedlonglong;
-    return &stsignedlong;
-}
-
-static TypeIntegral *CDecl_FindUnsignedType(short size) {
-    if (stunsignedchar.size == size)
-        return &stunsignedchar;
-    if (stunsignedshort.size == size)
-        return &stunsignedshort;
-    if (stunsignedint.size == size)
-        return &stunsignedint;
-    if (stunsignedlong.size == size)
-        return &stunsignedlong;
-    if (copts.longlong && copts.longlong_enums && stunsignedlonglong.size == size)
-        return &stunsignedlonglong;
-    return &stunsignedlong;
-}
-
-static TypeIntegral *CDecl_IterateIntegralEnumType(int *t) {
-    switch (*t) {
-        case 0:
-            *t = 1;
-            return &stsignedchar;
-        case 1:
-            if (stsignedshort.size > stsignedchar.size) {
-                *t = 2;
-                return &stsignedshort;
-            }
-        case 2:
-            if (stsignedint.size > stsignedshort.size) {
-                *t = 3;
-                return &stsignedint;
-            }
-        case 3:
-            if (stsignedlong.size > stsignedint.size) {
-                *t = 4;
-                return &stsignedlong;
-            }
-        case 4:
-            *t = 5;
-            if (stsignedlonglong.size > stsignedlong.size && copts.longlong && copts.longlong_enums)
-                return &stsignedlonglong;
-        default:
-            return NULL;
-    }
-}
-
-static TypeIntegral *CDecl_IterateUIntegralEnumType(int *t) {
-    switch (*t) {
-        case 0:
-            *t = 1;
-            return &stunsignedchar;
-        case 1:
-            if (stunsignedshort.size > stunsignedchar.size) {
-                *t = 2;
-                return &stunsignedshort;
-            }
-        case 2:
-            if (stunsignedint.size > stunsignedshort.size) {
-                *t = 3;
-                return &stunsignedint;
-            }
-        case 3:
-            if (stunsignedlong.size > stunsignedint.size) {
-                *t = 4;
-                return &stunsignedlong;
-            }
-        case 4:
-            *t = 5;
-            if (stunsignedlonglong.size > stunsignedlong.size && copts.longlong && copts.longlong_enums)
-                return &stunsignedlonglong;
-        default:
-            return NULL;
-    }
-}
-
-static TypeEnum *CDecl_OldParseEnumList(TypeEnum *tenum, HashNameNode *name) {
-    AccessType access;
-    Boolean has_template_value;
-    Boolean r24;
-    Boolean r23;
-    ObjEnumConst *oec;
-    ObjEnumConst *last;
-    Boolean overflowed;
-    CInt64 val;
-    CInt64 minimum;
-    CInt64 maximum;
-    CInt64 var_74;
-    CInt64 unused;
-    Type *basetype;
-    Type *basetype2;
-    CPrepFileInfo *fileinfo;
-    SInt32 offset;
-    ENode *expr;
-    Type *tmp;
-
-    if (!tenum) {
-        tenum = galloc(sizeof(TypeEnum));
-        memclrw(tenum, sizeof(TypeEnum));
-        tenum->type = TYPEENUM;
-        tenum->nspace = cscope_current;
-
-        if (name) {
-            tenum->enumname = name;
-            CScope_DefineTypeTag(cscope_current, name, TYPE(tenum));
-        }
-
-        if (!cscope_current->is_global) {
-            do {
-                tenum->nspace = tenum->nspace->parent;
-            } while (!tenum->nspace->is_global);
-            if (tenum->enumname)
-                tenum->enumname = CParser_AppendUniqueNameFile(tenum->enumname->name);
-        }
-    }
-
-    if (cscope_current->theclass && (cscope_current->theclass->flags & CLASS_IS_TEMPL)) {
-        CTemplClass_RegisterEnumType(TEMPL_CLASS(cscope_current->theclass), tenum);
-    }
-
-    access = cscope_current->theclass ? global_access : ACCESSPUBLIC;
-    last = NULL;
-    unused = cint64_zero;
-    val = cint64_zero;
-    minimum = cint64_zero;
-    maximum = cint64_zero;
-    r23 = 0;
-    if (copts.enumsalwaysint) {
-        basetype = TYPE(&stsignedint);
-        r24 = 1;
-    } else {
-        basetype = TYPE(&stunsignedchar);
-        r24 = 0;
-    }
-
-    tk = lex();
-    if (!copts.cplusplus || tk != '}') {
-        do {
-            if (tk != TK_IDENTIFIER) {
-                if (tk == '}') {
-                    if (copts.cpp_extensions)
-                        break;
-                    if (!copts.warn_extracomma)
-                        break;
-                }
-                CError_Warning(CErrorStr107);
-                break;
-            }
-
-            oec = galloc(sizeof(ObjEnumConst));
-            memclrw(oec, sizeof(ObjEnumConst));
-            oec->otype = OT_ENUMCONST;
-            oec->access = access;
-            oec->type = TYPE(tenum);
-            oec->name = tkidentifier;
-            CPrep_BrowserFilePosition(&fileinfo, &offset);
-            overflowed = 0;
-            if ((tk = lex()) == '=') {
-                tk = lex();
-                val = CExpr_IntegralConstExprType(&basetype2);
-                if (!CInt64_IsNegative(&val) || is_unsigned(basetype2)) {
-                    if (CInt64_GreaterU(val, minimum)) {
-                        minimum = val;
-                        overflowed = 1;
-                    }
-                } else {
-                    if (CInt64_Less(val, maximum)) {
-                        maximum = val;
-                        overflowed = 1;
-                    }
-                    if (!r24) {
-                        basetype = TYPE(&stsignedchar);
-                        r24 = 1;
-                    }
-                }
-                r23 = 0;
-            } else {
-                if (r23)
-                    CError_Error(CErrorStr154);
-
-                if (!r24 || !CInt64_IsNegative(&val)) {
-                    if (CInt64_GreaterU(val, minimum)) {
-                        minimum = val;
-                        overflowed = 1;
-                    }
-                } else {
-                    if (CInt64_Less(val, maximum)) {
-                        maximum = val;
-                        overflowed = 1;
-                    }
-                }
-            }
-
-            if (copts.enumsalwaysint) {
-                if (copts.ANSIstrict) {
-                    if (!CInt64_IsInRange(val, stsignedint.size))
-                        CError_Error(CErrorStr154);
-                } else {
-                    if (!CInt64_IsInRange(val, stsignedint.size) && !CInt64_IsInURange(val, stunsignedint.size))
-                        CError_Error(CErrorStr154);
-                }
-            } else if (r24) {
-                switch (basetype->size) {
-                    case 1:
-                        if (CInt64_IsInRange(minimum, 1) && CInt64_IsInRange(maximum, 1))
-                            break;
-                        basetype = TYPE(CDecl_FindSignedType(2));
-                    case 2:
-                        if (CInt64_IsInRange(minimum, 2) && CInt64_IsInRange(maximum, 2))
-                            break;
-                        basetype = TYPE(CDecl_FindSignedType(4));
-                    case 4:
-                        if (CInt64_IsInRange(minimum, 4) && CInt64_IsInRange(maximum, 4))
-                            break;
-                        basetype = TYPE(CDecl_FindSignedType(8));
-                        if (basetype->size != 8) {
-                            if (!copts.ANSIstrict && CInt64_IsInRange(maximum, 4) && CInt64_IsInURange(minimum, 4))
-                                break;
-                            if (overflowed)
-                                CError_Error(CErrorStr154);
-                            break;
-                        }
-                    case 8:
-                        if (CInt64_Equal(val, minimum) && CInt64_IsNegative(&val))
-                            CError_Error(CErrorStr154);
-                        break;
-                    default:
-                        CError_FATAL(3071);
-                }
-            } else {
-                switch (basetype->size) {
-                    case 1:
-                        if (CInt64_IsInURange(minimum, 1))
-                            break;
-                        basetype = TYPE(CDecl_FindUnsignedType(2));
-                    case 2:
-                        if (CInt64_IsInURange(minimum, 2))
-                            break;
-                        basetype = TYPE(CDecl_FindUnsignedType(4));
-                    case 4:
-                        if (CInt64_IsInURange(minimum, 4))
-                            break;
-                        basetype = TYPE(CDecl_FindUnsignedType(8));
-                        if (basetype->size != 8) {
-                            if (overflowed)
-                                CError_Error(CErrorStr154);
-                            break;
-                        }
-                    case 8:
-                        break;
-                    default:
-                        CError_FATAL(3099);
-                }
-            }
-
-            tenum->size = basetype->size;
-            tenum->enumtype = basetype;
-            oec->val = val;
-            CScope_AddObject(cscope_current, oec->name, OBJ_BASE(oec));
-
-            if (last) {
-                last->next = oec;
-                last = oec;
-            } else {
-                last = oec;
-                tenum->enumlist = oec;
-            }
-
-            if (cparamblkptr->browseoptions.recordEnums) {
-                CPrepFileInfo *f = CPrep_BrowserCurrentFile();
-                if (f->recordbrowseinfo) {
-                    CBrowse_NewEnumConstant(cscope_current, oec->name, f, fileinfo, offset, CPrep_BrowserFileOffset());
-                }
-            }
-
-            var_74 = CInt64_Add(val, cint64_one);
-            if (r24) {
-                if (CInt64_IsNegative(&var_74) && !CInt64_IsNegative(&val))
-                    r23 = 1;
-            } else {
-                if (CInt64_IsZero(&var_74))
-                    r23 = 1;
-            }
-            val = var_74;
-
-            if (tk != ',')
-                break;
-            tk = lex();
-        } while (1);
-    }
-
-    tenum->size = basetype->size;
-    tenum->enumtype = basetype;
-
-    for (oec = tenum->enumlist; oec; oec = oec->next)
-        oec->type = TYPE(tenum);
-
-    if (tk != '}')
-        CError_ErrorSkip(CErrorStr130);
-    else
-        tk = lex();
-
-    return tenum;
-}
-
-static Type *CDecl_MaxType(Type *a, Type *b) {
-    if (a->size > b->size)
-        return a;
-    if (b->size > a->size)
-        return b;
-    if (is_unsigned(b))
-        return b;
-    else
-        return a;
-}
-
-void CDecl_ComputeUnderlyingEnumType(TypeEnum *tenum) {
-    ObjEnumConst *oec;
-    ObjEnumConst *oec2;
-    Type *r26;
-    int t;
-
-    if (!copts.enumsalwaysint) {
-        for (oec2 = tenum->enumlist; oec2; oec2 = oec2->next) {
-            if (CInt64_IsNegative(&oec2->val) && !is_unsigned(oec2->type))
-                break;
-        }
-
-        if (oec2) {
-            CInt64 unused = cint64_zero;
-            CInt64 minimum = cint64_zero;
-            CInt64 maximum = cint64_zero;
-            for (oec = tenum->enumlist; oec; oec = oec->next) {
-                if (CInt64_IsNegative(&oec->val) && !is_unsigned(oec->type)) {
-                    if (CInt64_Less(oec->val, minimum))
-                        minimum = oec->val;
-                } else {
-                    if (CInt64_GreaterU(oec->val, maximum))
-                        maximum = oec->val;
-                }
-            }
-
-            if (CInt64_IsNegative(&maximum))
-                CError_Error(CErrorStr154);
-
-            t = 0;
-            do {
-                r26 = TYPE(CDecl_IterateIntegralEnumType(&t));
-                if (!r26) {
-                    r26 = TYPE(&stsignedlong);
-                    CError_Error(CErrorStr154);
-                    break;
-                }
-
-                if (CInt64_IsInRange(maximum, r26->size) && CInt64_IsInRange(minimum, r26->size))
-                    break;
-                if (r26->size == stsignedlong.size && !copts.ANSIstrict && CInt64_IsInRange(minimum, r26->size) && CInt64_IsInURange(maximum, r26->size))
-                    break;
-            } while (1);
-        } else {
-            CInt64 val = cint64_zero;
-
-            for (oec = tenum->enumlist; oec; oec = oec->next) {
-                if (CInt64_GreaterU(oec->val, val))
-                    val = oec->val;
-            }
-
-            t = 0;
-            do {
-                r26 = TYPE(CDecl_IterateUIntegralEnumType(&t));
-                if (!r26) {
-                    r26 = TYPE(&stunsignedlong);
-                    CError_Error(CErrorStr154);
-                    break;
-                }
-                if (CInt64_IsInURange(val, r26->size))
-                    break;
-            } while (1);
-        }
-    } else {
-        r26 = TYPE(&stsignedint);
-    }
-
-    tenum->size = r26->size;
-    tenum->enumtype = r26;
-    for (oec = tenum->enumlist; oec; oec = oec->next)
-        oec->type = TYPE(tenum);
-}
-
-static Type *CDecl_FindUnderlyingType(short size, CInt64 *a, CInt64 *b) {
-    if (CInt64_IsZero(a)) {
-        if (size <= stsignedchar.size && CInt64_IsInURange(*b, stunsignedchar.size))
-            return TYPE(&stunsignedchar);
-        if (size <= stsignedshort.size && CInt64_IsInURange(*b, stunsignedshort.size))
-            return TYPE(&stunsignedshort);
-        if (size <= stsignedint.size && CInt64_IsInURange(*b, stunsignedint.size))
-            return TYPE(&stunsignedint);
-        if (size <= stsignedlong.size && CInt64_IsInURange(*b, stunsignedlong.size))
-            return TYPE(&stunsignedlong);
-        if (size <= stsignedlonglong.size && copts.longlong && copts.longlong_enums && CInt64_IsInURange(*b, stunsignedlonglong.size))
-            return TYPE(&stunsignedlonglong);
-    } else {
-        if (size <= stsignedchar.size && CInt64_IsInRange(*a, stsignedchar.size) && CInt64_IsInRange(*b, stsignedchar.size))
-            return TYPE(&stsignedchar);
-        if (size <= stsignedshort.size && CInt64_IsInRange(*a, stsignedshort.size) && CInt64_IsInRange(*b, stsignedshort.size))
-            return TYPE(&stsignedshort);
-        if (size <= stsignedint.size && CInt64_IsInRange(*a, stsignedint.size) && CInt64_IsInRange(*b, stsignedint.size))
-            return TYPE(&stsignedint);
-        if (size <= stsignedlong.size && CInt64_IsInRange(*a, stsignedlong.size) && CInt64_IsInRange(*b, stsignedlong.size))
-            return TYPE(&stsignedlong);
-        if (size <= stsignedlonglong.size && copts.longlong && copts.longlong_enums && CInt64_IsInRange(*a, stsignedlonglong.size) && CInt64_IsInRange(*b, stsignedlonglong.size))
-            return TYPE(&stsignedlonglong);
-        if (!copts.ANSIstrict && size <= stsignedlong.size && CInt64_IsInRange(*a, stsignedlong.size) && CInt64_IsInURange(*b, stunsignedlong.size))
-            return TYPE(&stsignedlong);
-    }
-
-    return NULL;
-}
-
-static TypeEnum *CDecl_ParseEnumList(TypeEnum *tenum, HashNameNode *name) {
-    AccessType access;
-    TemplClass *tmclass;
-    ObjEnumConst *oec;
-    Boolean has_template_value;
-    Boolean overflowed;
-    Boolean is_first;
-    CInt64 val;
-    CInt64 minimum;
-    CInt64 maximum;
-    CInt64 unused;
-    Type *basetype;
-    CPrepFileInfo *fileinfo;
-    SInt32 offset;
-    ENode *expr;
-    Type *tmp;
-    ObjEnumConst *last;
-
-    if (!tenum) {
-        tenum = galloc(sizeof(TypeEnum));
-        memclrw(tenum, sizeof(TypeEnum));
-        tenum->type = TYPEENUM;
-        tenum->nspace = cscope_current;
-
-        if (name) {
-            tenum->enumname = name;
-            CScope_DefineTypeTag(cscope_current, name, TYPE(tenum));
-        }
-
-        if (!cscope_current->is_global) {
-            do {
-                tenum->nspace = tenum->nspace->parent;
-            } while (!tenum->nspace->is_global);
-            if (tenum->enumname)
-                tenum->enumname = CParser_AppendUniqueNameFile(tenum->enumname->name);
-        }
-    }
-
-    if (cscope_current->theclass && (cscope_current->theclass->flags & CLASS_IS_TEMPL)) {
-        tmclass = TEMPL_CLASS(cscope_current->theclass);
-        CTemplClass_RegisterEnumType(tmclass, tenum);
-    } else {
-        tmclass = NULL;
-    }
-
-    access = cscope_current->theclass ? global_access : ACCESSPUBLIC;
-    last = NULL;
-    is_first = 1;
-    has_template_value = 0;
-    unused = cint64_zero;
-    val = cint64_zero;
-    minimum = cint64_zero;
-    maximum = cint64_zero;
-    basetype = copts.enumsalwaysint ? TYPE(&stsignedint) : TYPE(&stsignedchar);
-    tenum->size = basetype->size;
-    tenum->enumtype = basetype;
-
-    do {
-        if ((tk = lex()) != TK_IDENTIFIER) {
-            if (tk == '}') {
-                if (is_first) {
-                    if (copts.cplusplus)
-                        break;
-                } else {
-                    if (!copts.warn_extracomma)
-                        break;
-                    if (copts.c9x)
-                        break;
-                    if (copts.cpp_extensions)
-                        break;
-                }
-                CError_Warning(CErrorStr107);
-            } else {
-                CError_Error(CErrorStr107);
-            }
-            break;
-        }
-
-        oec = galloc(sizeof(ObjEnumConst));
-        memclrw(oec, sizeof(ObjEnumConst));
-        oec->otype = OT_ENUMCONST;
-        oec->access = access;
-        oec->name = tkidentifier;
-        CPrep_BrowserFilePosition(&fileinfo, &offset);
-        overflowed = 0;
-        if ((tk = lex()) == '=') {
-            tk = lex();
-            if (tmclass) {
-                expr = CExpr_IntegralConstOrDepExpr();
-                if (ENODE_IS(expr, EINTCONST)) {
-                    val = expr->data.intval;
-                    basetype = expr->rtype;
-                    has_template_value = 0;
-                } else {
-                    val = cint64_zero;
-                    basetype = TYPE(tenum);
-                    CTemplClass_RegisterEnumerator(tmclass, oec, expr);
-                    has_template_value = 1;
-                }
-            } else {
-                val = CExpr_IntegralConstExprType(&basetype);
-                has_template_value = 0;
-            }
-        } else if (has_template_value) {
-            CTemplClass_RegisterEnumerator(tmclass, oec, NULL);
-        } else if (!is_first) {
-            if (is_unsigned(basetype)) {
-                val = CInt64_Add(val, cint64_one);
-                if (CInt64_IsZero(&val))
-                    overflowed = 1;
-            } else if (!CInt64_IsNegative(&val)) {
-                val = CInt64_Add(val, cint64_one);
-                if (CInt64_IsNegative(&val))
-                    overflowed = 1;
-            } else {
-                val = CInt64_Add(val, cint64_one);
-            }
-        }
-
-        if (!has_template_value) {
-            if (copts.enumsalwaysint) {
-                if (!CInt64_IsInRange(val, stsignedint.size) && (copts.ANSIstrict || !CInt64_IsInURange(val, stunsignedint.size)))
-                    overflowed = 1;
-                basetype = TYPE(&stsignedint);
-            } else if (CInt64_IsNegative(&val) && !is_unsigned(basetype)) {
-                if (CInt64_Less(val, minimum)) {
-                    minimum = val;
-                    if ((tmp = CDecl_FindUnderlyingType(tenum->size, &minimum, &maximum))) {
-                        tenum->size = tmp->size;
-                        tenum->enumtype = tmp;
-                    } else {
-                        overflowed = 1;
-                    }
-                }
-            } else {
-                if (CInt64_GreaterU(val, maximum)) {
-                    maximum = val;
-                    if ((tmp = CDecl_FindUnderlyingType(tenum->size, &minimum, &maximum))) {
-                        tenum->size = tmp->size;
-                        tenum->enumtype = tmp;
-                    } else {
-                        overflowed = 1;
-                    }
-                }
-            }
-        }
-
-        if (overflowed)
-            CError_Error(CErrorStr154);
-
-        oec->val = val;
-        oec->type = basetype;
-        CScope_AddObject(cscope_current, oec->name, OBJ_BASE(oec));
-
-        if (last) {
-            last->next = oec;
-            last = oec;
-        } else {
-            last = oec;
-            tenum->enumlist = oec;
-        }
-
-        if (cparamblkptr->browseoptions.recordEnums) {
-            CPrepFileInfo *f = CPrep_BrowserCurrentFile();
-            if (f->recordbrowseinfo) {
-                CBrowse_NewEnumConstant(cscope_current, oec->name, f, fileinfo, offset, CPrep_BrowserFileOffset());
-            }
-        }
-
-        is_first = 0;
-    } while (tk == ',');
-
-    for (oec = tenum->enumlist; oec; oec = oec->next)
-        oec->type = TYPE(tenum);
-
-    if (tk != '}')
-        CError_ErrorSkip(CErrorStr130);
-    else
-        tk = lex();
-
-    return tenum;
-}
-
-void scanenum(DeclInfo *declinfo) {
-    HashNameNode *name;
-    Type *type;
-    NameResult pr;
-
-    if (tk == '{') {
-        declinfo->thetype = TYPE(CDecl_ParseEnumList(NULL, NULL));
-        TYPE_ENUM(declinfo->thetype)->enumname = CParser_AppendUniqueNameFile("@enum");
-        return;
-    }
-
-    if (tk == TK_IDENTIFIER) {
-        name = tkidentifier;
-        if (lookahead() == '{') {
-            type = CScope_GetLocalTagType(cscope_current, name);
-            if (type) {
-                lex();
-            do_shit:
-                if (type->size || !IS_TYPE_ENUM(type)) {
-                    CError_Error(CErrorStr122, name->name);
-                    declinfo->thetype = TYPE(CDecl_ParseEnumList(NULL, NULL));
-                    return;
-                }
-                declinfo->thetype = TYPE(CDecl_ParseEnumList(TYPE_ENUM(type), NULL));
-            } else {
-                lex();
-                declinfo->thetype = TYPE(CDecl_ParseEnumList(NULL, name));
-            }
-
-            if (cparamblkptr->browseoptions.recordEnums && declinfo->file->recordbrowseinfo)
-                CBrowse_NewEnum(
-                        cscope_current,
-                        TYPE_ENUM(declinfo->thetype)->enumname,
-                        declinfo->file,
-                        declinfo->file2,
-                        declinfo->sourceoffset,
-                        CPrep_BrowserFileOffset());
-            return;
-        } else {
-            CError_ASSERT(3851, !copts.cplusplus || tk != ';');
-            tkidentifier = name;
-        }
-    }
-
-    if (CScope_ParseElaborateName(&pr)) {
-        if ((type = pr.type)) {
-            if (!IS_TYPE_ENUM(type))
-                CError_Error(CErrorStr121);
-            if ((tk = lex()) == '{')
-                goto do_shit;
-            declinfo->thetype = type;
-            return;
-        } else {
-            CError_ASSERT(3865, pr.name_4);
-            if ((tk = lex()) == '{') {
-                declinfo->thetype = TYPE(CDecl_ParseEnumList(NULL, pr.name_4));
-                return;
-            } else {
-                CError_Error(CErrorStr140, pr.name_4->name);
-            }
-        }
-    } else {
-        CError_Error(CErrorStr121);
-    }
-
-    declinfo->thetype = TYPE(&stsignedint);
-}
-
-void CDecl_ScanStructDeclarator(BigDeclInfo *bde) {
-    ENode *expr;
-    short val;
-    short bits;
-    Boolean is_bitfield;
-    TypeTemplDep *ttempl;
-    TypeBitfield *tbitfield;
-    Type *type;
-
-    bde->declinfo2 = bde->declinfo;
-    bde->declinfo2.name = NULL;
-    bde->declinfo2.operator_token = 0;
-    bde->xCD = 0;
-    is_bitfield = 0;
-
-    if (tk == ':') {
-        bde->declinfo2.name = no_name_node;
-        is_bitfield = 1;
-    } else {
-        bde->declinfo2.x50 = 1;
-        scandeclarator(&bde->declinfo2);
-        if (!bde->declinfo2.name) {
-            CError_Error(CErrorStr131);
-            return;
-        }
-
-        if ((!copts.ANSIstrict || copts.c9x) && !bde->declinfo2.thetype->size && IS_TYPE_ARRAY(bde->declinfo2.thetype)) {
-            if (bde->declinfo2.storageclass != TK_STATIC && bde->declinfo2.storageclass != TK_TYPEDEF) {
-                type = TYPE_POINTER(bde->declinfo2.thetype)->target;
-                while (IS_TYPE_ARRAY(type))
-                    type = TYPE_POINTER(type)->target;
-                if (!IsCompleteType(type))
-                    return;
-                if (tk != ';' || lookahead() != '}') {
-                    CError_Error(CErrorStr145);
-                    return;
-                }
-            }
-        } else {
-            if (bde->declinfo2.storageclass != TK_STATIC && bde->declinfo2.storageclass != TK_TYPEDEF) {
-                if (!IS_TYPE_FUNC(bde->declinfo2.thetype) && !IsCompleteType(bde->declinfo2.thetype))
-                    return;
-            }
-        }
-
-        if (IS_TYPE_CLASS(bde->declinfo2.thetype) && TYPE_CLASS(bde->declinfo2.thetype)->sominfo) {
-            CError_Error(CErrorStr287);
-            return;
-        }
-
-        if (tk != ':')
-            goto not_a_bitfield;
-    }
-
-    if (!IS_TYPE_INT_OR_ENUM(bde->declinfo2.thetype)) {
-        if (CTemplTool_IsTemplateArgumentDependentType(bde->declinfo2.thetype))
-            goto fuckup;
-        CError_Error(CErrorStr138);
-        bde->declinfo2.thetype = TYPE(&stunsignedint);
-    } else if (copts.ANSIstrict && !copts.cplusplus) {
-        if (bde->declinfo2.thetype != TYPE(&stsignedint) && bde->declinfo2.thetype != TYPE(&stunsignedint)) {
-            CError_Error(CErrorStr138);
-            bde->declinfo2.thetype = TYPE(&stunsignedint);
-        }
-    }
-
-    switch (bde->declinfo2.thetype->size) {
-        case 1:
-            bits = 8;
-            break;
-        case 2:
-            bits = 16;
-            break;
-        case 4:
-            bits = 32;
-            break;
-        default:
-            CError_Error(CErrorStr138);
-            return;
-    }
-fuckup:
-    tk = lex();
-    expr = CExpr_IntegralConstOrDepExpr();
-    if (!ENODE_IS(expr, EINTCONST)) {
-        ttempl = TYPE_TEMPLATE(CDecl_NewTemplDepType(TEMPLDEP_BITFIELD));
-        ttempl->u.bitfield.type = bde->declinfo2.thetype;
-        ttempl->u.bitfield.size = CInline_CopyExpression(expr, CopyMode1);
-        bde->declinfo2.thetype = TYPE(ttempl);
-        bde->xCD = 1;
-        return;
-    }
-    val = CInt64_GetULong(&expr->data.intval);
-    if (is_bitfield) {
-        if (val < 0 || val > bits) {
-            CError_Error(CErrorStr138);
-            return;
-        }
-    } else {
-        if (val <= 0 || val > bits) {
-            CError_Error(CErrorStr138);
-            return;
-        }
-    }
-
-    tbitfield = galloc(sizeof(TypeBitfield));
-    memclrw(tbitfield, sizeof(TypeBitfield));
-    tbitfield->type = TYPEBITFIELD;
-    tbitfield->size = bde->declinfo2.thetype->size;
-    tbitfield->bitfieldtype = bde->declinfo2.thetype;
-    tbitfield->bitlength = val;
-    bde->declinfo2.thetype = TYPE(tbitfield);
-
-    if (tk == TK_UU_ATTRIBUTE_UU)
-        CParser_ParseAttribute(NULL, &bde->declinfo2);
-
-not_a_bitfield:
-    bde->xCD = 1;
-}
-
-static void CDecl_LayoutStruct(TypeStruct *tstruct) {
-    StructMember *member;
-    SInt32 r28;
-    StructMember *innermember;
-    SInt32 innerbase;
-    StructMember *newmember;
-    StructMember **memberp;
-    TypeBitfield *bf;
-    SInt32 r24;
-    Boolean r23;
-    SInt32 tmp;
-
-    r28 = 0;
-    r23 = 0;
-    CMach_StructLayoutInitOffset(0);
-    for (member = tstruct->members; member; member = member->next) {
-        if (tstruct->stype == STRUCT_TYPE_UNION)
-            CMach_StructLayoutInitOffset(0);
-
-        if (IS_TYPE_BITFIELD(member->type))
-            member->offset = CMach_StructLayoutBitfield(TYPE_BITFIELD(member->type), member->qual);
-        else
-            member->offset = CMach_StructLayoutGetOffset(member->type, member->qual);
-
-        if (tstruct->stype == STRUCT_TYPE_UNION) {
-            tmp = CMach_StructLayoutGetCurSize();
-            if (tmp > r28)
-                r28 = tmp;
-        }
-
-        if (member->name == no_name_node)
-            r23 = 1;
-
-        if (!member->name) {
-            CError_ASSERT(4064, IS_TYPE_STRUCT(member->type));
-            innerbase = member->offset;
-            innermember = TYPE_STRUCT(member->type)->members;
-            r23 = 1;
-            while (innermember) {
-                if (ismember(tstruct, innermember->name))
-                    CError_Error(CErrorStr133, innermember->name->name);
-                if (r23) {
-                    member->type = innermember->type;
-                    member->name = innermember->name;
-                    member->qual = innermember->qual;
-                    member->offset = innerbase + innermember->offset;
-                } else {
-                    newmember = galloc(sizeof(StructMember));
-                    memclrw(newmember, sizeof(StructMember));
-                    newmember->next = member->next;
-                    newmember->type = innermember->type;
-                    newmember->name = innermember->name;
-                    newmember->qual = innermember->qual | Q_WEAK;
-                    newmember->offset = innerbase + innermember->offset;
-                    member->next = newmember;
-                    member = newmember;
-                }
-                if (copts.reverse_bitfields && IS_TYPE_BITFIELD(member->type)) {
-                    bf = galloc(sizeof(TypeBitfield));
-                    *bf = *TYPE_BITFIELD(member->type);
-                    CABI_ReverseBitField(bf);
-                    member->type = TYPE(bf);
-                }
-                r23 = 0;
-                innermember = innermember->next;
-            }
-            r23 = 1;
-        }
-    }
-
-    if (r23) {
-        memberp = &tstruct->members;
-        while (*memberp) {
-            if ((*memberp)->name == no_name_node || !(*memberp)->name)
-                *memberp = (*memberp)->next;
-            else
-                memberp = &(*memberp)->next;
-        }
-    }
-
-    if (tstruct->stype == STRUCT_TYPE_UNION)
-        r24 = r28;
-    else
-        r24 = CMach_StructLayoutGetCurSize();
-    tstruct->size = r24;
-    tstruct->align = CMach_GetStructAlign(tstruct);
-    tstruct->size = r24 + CABI_StructSizeAlignValue(TYPE(tstruct), r24);
-
-    if (copts.reverse_bitfields) {
-        for (member = tstruct->members; member; member = member->next) {
-            if (IS_TYPE_BITFIELD(member->type))
-                CABI_ReverseBitField(TYPE_BITFIELD(member->type));
-        }
-    }
-
-    if (copts.warn_padding && tstruct->stype != STRUCT_TYPE_UNION) {
-        StructMember *prev;
-
-        member = tstruct->members;
-        prev = NULL;
-        while (member) {
-            if (prev && (prev->offset + prev->type->size) < member->offset) {
-                CError_Warning(CErrorStr350, member->offset - (prev->offset + prev->type->size), prev->name->name);
-            }
-            prev = member;
-            member = member->next;
-        }
-
-        if (prev && (prev->offset + prev->type->size) < tstruct->size) {
-            CError_Warning(CErrorStr350, tstruct->size - (prev->offset + prev->type->size), prev->name->name);
-        }
-    }
-}
-
-static SInt32 scanstructdeclarationlist(TypeStruct *tstruct, Boolean flag) {
-    SInt32 offset;
-    StructMember *member;
-    BigDeclInfo bde;
-
-    offset = -1;
-    memclrw(&bde, sizeof(BigDeclInfo));
-
-    if (tk == TK_AT_DEFS) {
-        CPrep_NewFileOffsetInfo(&member_fileoffset, NULL);
-        CObjC_ParseDefs(tstruct);
-        if ((tk = lex()) != '}')
-            CError_Error(CErrorStr130);
-    } else {
-        do {
-            CPrep_NewFileOffsetInfo(&member_fileoffset, NULL);
-            memclrw(&bde.declinfo, sizeof(DeclInfo));
-            CParser_GetDeclSpecs(&bde.declinfo, 0);
-            if (bde.declinfo.storageclass || bde.declinfo.x44) {
-                CError_Error(CErrorStr131);
-                tstruct->members = NULL;
-                return -1;
-            }
-
-            if (tk != ';') {
-                while (1) {
-                    CDecl_ScanStructDeclarator(&bde);
-                    if (!CanCreateObject(bde.declinfo2.thetype)) {
-                        CError_Error(CErrorStr131);
-                        bde.xCD = 0;
-                    }
-
-                    if (bde.declinfo2.operator_token) {
-                        CError_Error(CErrorStr131);
-                        bde.xCD = 0;
-                    }
-
-                    if (bde.xCD) {
-                        if (bde.declinfo2.name == no_name_node || !ismember(tstruct, bde.declinfo2.name)) {
-                            member = galloc(sizeof(StructMember));
-                            memclrw(member, sizeof(StructMember));
-                            member->type = bde.declinfo2.thetype;
-                            member->name = bde.declinfo2.name;
-                            member->qual = bde.declinfo2.qual;
-                            appendmember(tstruct, member);
-
-                            if (flag) {
-                                CBrowse_AddStructMember(member, CPrep_BrowserTokenOffset(&member_fileoffset) + 1, CPrep_BrowserFileOffset());
-                            }
-                        } else {
-                            CError_Error(CErrorStr133, bde.declinfo2.name->name);
-                        }
-                    }
-
-                    if (tk != ',')
-                        break;
-                    tk = lex();
-                }
-            } else if (!copts.ANSIstrict && IS_TYPE_STRUCT(bde.declinfo.thetype)) {
-                member = galloc(sizeof(StructMember));
-                memclrw(member, sizeof(StructMember));
-                member->type = bde.declinfo.thetype;
-                appendmember(tstruct, member);
-            } else {
-                CError_Error(CErrorStr131);
-            }
-
-            if (tk != ';') {
-                tstruct->members = NULL;
-                CError_Error(CErrorStr123);
-                return -1;
-            }
-
-            CPrep_TokenStreamFlush();
-        } while ((tk = lex()) != '}');
-        CDecl_LayoutStruct(tstruct);
-    }
-
-    if (flag) {
-        offset = CPrep_BrowserFileOffset();
-        if (tk == ';')
-            offset++;
-    }
-
-    tk = lex();
-    return offset;
-}
-
-static TypeStruct *CDecl_DefineStruct(HashNameNode *name, short stype) {
-    TypeStruct *tstruct;
-
-    tstruct = galloc(sizeof(TypeStruct));
-    memclrw(tstruct, sizeof(TypeStruct));
-
-    tstruct->type = TYPESTRUCT;
-    tstruct->align = 1;
-    tstruct->stype = stype;
-    if (name) {
-        tstruct->name = name;
-        CScope_DefineTypeTag((in_func_arglist && !copts.cplusplus) ? cscope_root : cscope_current, name, (Type *) tstruct);
-    }
-
-    return tstruct;
-}
-
-void scanstruct(DeclInfo *declinfo, short structtype) {
-    Type *type;
-    HashNameNode *name;
-    TypeStruct typecopy;
-    Boolean add_to_browse;
-    GList gl;
-    SInt32 offset;
-
-    if (copts.cplusplus) {
-        CDecl_ParseClass(declinfo, structtype, 1, 0);
-        return;
-    }
-
-    if (tk == TK_IDENTIFIER) {
-        name = tkidentifier;
-        type = CScope_GetTagType(cscope_current, name);
-        if (type) {
-            if (IS_TYPE_CLASS(type)) {
-                CDecl_ParseClass(declinfo, structtype, 1, 0);
-                return;
-            }
-
-            tk = lex();
-            if (!CScope_GetLocalTagType(cscope_current, name) && (tk == ';' || tk == '{'))
-                type = (Type *) CDecl_DefineStruct(name, structtype);
-
-            if (!IS_TYPE_STRUCT(type) || TYPE_STRUCT(type)->stype != structtype) {
-                CError_Error(CErrorStr132, name->name);
-                declinfo->thetype = type;
-                return;
-            }
-
-            if (tk != '{') {
-                declinfo->thetype = type;
-                return;
-            }
-
-            if (type->size) {
-                CError_Error(CErrorStr132, name->name);
-                type = (Type *) CDecl_DefineStruct(NULL, structtype);
-            }
-        } else {
-            type = (Type *) CDecl_DefineStruct(name, structtype);
-            if ((tk = lex()) != '{') {
-                declinfo->thetype = type;
-                return;
-            }
-        }
-    } else if (tk != '{') {
-        CError_Error(CErrorStr131);
-        declinfo->thetype = (Type *) &stsignedint;
-        return;
-    } else {
-        type = (Type *) CDecl_DefineStruct(NULL, structtype);
-    }
-
-    if ((add_to_browse = cparamblkptr->browseoptions.recordClasses && declinfo->file->recordbrowseinfo))
-        CBrowse_BeginStruct(declinfo, TYPE_STRUCT(type), &gl);
-
-    typecopy = *TYPE_STRUCT(type);
-    tk = lex();
-    offset = scanstructdeclarationlist(&typecopy, add_to_browse);
-    *TYPE_STRUCT(type) = typecopy;
-    declinfo->thetype = type;
-
-    if (add_to_browse)
-        CBrowse_EndStruct(offset, &gl);
-}
-
-static void InlineFunctionObject(Object *obj, TypeClass *tclass) {
-    TokenStream stream;
-    CPrepFileInfo *file;
-
-    obj->qual |= Q_INLINE;
-    TYPE_FUNC(obj->type)->flags |= FUNC_DEFINED;
-
-    CPrep_StreamGetBlock(&stream, NULL, 1);
-    if (stream.tokens) {
-        if (IS_TYPEFUNC_METHOD(TYPE_FUNC(obj->type)) && (TYPE_METHOD(obj->type)->theclass->flags & CLASS_IS_TEMPL)) {
-            TYPE_FUNC(obj->type)->flags |= FUNC_IS_TEMPL_INSTANCE;
-            CTemplClass_DefineMember(TEMPL_CLASS(TYPE_METHOD(obj->type)->theclass), obj, &member_fileoffset, &stream);
-        } else {
-            CInline_AddInlineFunctionAction(obj, tclass, &member_fileoffset, &stream, 0);
-        }
-    }
-
-    file = CPrep_BrowserCurrentFile();
-    if (file->recordbrowseinfo) {
-        CBrowse_NewFunction(
-                obj, file,
-                member_fileoffset.file,
-                CPrep_BrowserTokenOffset(&member_fileoffset) + 1,
-                CPrep_BrowserFileOffset());
-    }
-
-    if (lookahead() == ';')
-        tk = lex();
-    else
-        tk = ';';
-}
-
-void CDecl_ExtractClassExportFlags(DeclInfo *declinfo, UInt8 flags) {
-    if (flags & CLASS_EFLAGS_INTERNAL)
-        declinfo->exportflags = declinfo->exportflags | EXPORT_FLAGS_INTERNAL;
-    if (flags & CLASS_EFLAGS_IMPORT)
-        declinfo->exportflags = declinfo->exportflags | EXPORT_FLAGS_IMPORT;
-    if (flags & CLASS_EFLAGS_EXPORT)
-        declinfo->exportflags = declinfo->exportflags | EXPORT_FLAGS_EXPORT;
-}
-
-TypeMemberFunc *CDecl_MakeTypeMemberFunc(TypeFunc *tfunc, TypeClass *tclass, Boolean flag) {
-    TypeMemberFunc *method;
-
-    method = galloc(sizeof(TypeMemberFunc));
-    memclrw(method, sizeof(TypeMemberFunc));
-    *TYPE_FUNC(method) = *tfunc;
-    method->theclass = tclass;
-    method->is_static = flag;
-    method->flags |= FUNC_METHOD;
-    if (!flag)
-        CDecl_AddThisPointerArgument(TYPE_FUNC(method), tclass);
-
-    if ((flag || (tfunc->flags & (FUNC_IS_CTOR | FUNC_IS_DTOR))) && (tfunc->flags & (FUNC_CONST | FUNC_VOLATILE)))
-        CError_Error(CErrorStr384);
-
-    return method;
-}
-
-static void CDecl_MakeFunctionVirtual(TypeClass *tclass, Object *func) {
-    if (is_pascal_object(func))
-        CError_Error(CErrorStr219);
-    if (tclass->mode == CLASS_MODE_UNION)
-        CError_Error(CErrorStr352, func);
-    func->datatype = DVFUNC;
-}
-
-static void CDecl_AddFunctionMember(ClassLayout *decle, TypeClass *tclass, DeclInfo *declinfo, AccessType access, Boolean flag1, Boolean flag2, Boolean flag3, Boolean flag4) {
-    NameSpaceObjectList *list; // r20
-    Object *obj; // also r20
-    TypeMemberFunc *tfunc; // r19
-    Boolean r31;
-    Boolean outflag;
-
-    if (IS_TYPE_ARRAY(TYPE_FUNC(declinfo->thetype)->functype) || IS_TYPE_FUNC(TYPE_FUNC(declinfo->thetype)->functype)) {
-        CError_Error(CErrorStr128);
-        TYPE_FUNC(declinfo->thetype)->functype = (Type *) &stsignedint;
-    }
-
-    if (tclass->sominfo)
-        CSOM_CheckFuncType(TYPE_FUNC(declinfo->thetype));
-
-    r31 = 0;
-    if (declinfo->qual & Q_VIRTUAL) {
-        declinfo->qual &= ~Q_VIRTUAL;
-        r31 = 1;
-        flag1 = 1;
-    }
-
-    if ((list = CScope_FindName(tclass->nspace, declinfo->name))) {
-        if (list->object->otype != OT_TYPETAG) {
-            if (list->object->otype != OT_OBJECT || !IS_TYPE_FUNC(OBJECT(list->object)->type))
-                CError_Error(CErrorStr133, declinfo->name->name);
-        } else {
-            list = NULL;
-        }
-    }
-
-    if (!IS_TYPEFUNC_METHOD(TYPE_FUNC(declinfo->thetype))) {
-        tfunc = CDecl_MakeTypeMemberFunc(TYPE_FUNC(declinfo->thetype), tclass, flag4);
-        declinfo->thetype = (Type *) tfunc;
-    } else {
-        tfunc = TYPE_METHOD(declinfo->thetype);
-        CError_ASSERT(4579, !tclass->sominfo);
-    }
-
-    CDecl_ExtractClassExportFlags(declinfo, tclass->eflags);
-
-    CError_ASSERT(4597, cscope_current == tclass->nspace);
-
-    if (list) {
-        obj = CDecl_OverloadFunctionObject(list, declinfo, &outflag, flag4 ? OverloadMode1 : OverloadMode2, 0);
-        if (!obj)
-            return;
-        if (outflag)
-            tfunc->vtbl_index = ++decle->lex_order_count;
-        else
-            CError_Error(CErrorStr133, CError_GetObjectName(obj));
-    } else {
-        tfunc->vtbl_index = ++decle->lex_order_count;
-        obj = CParser_NewFunctionObject(declinfo);
-        if ((tclass->flags & CLASS_IS_TEMPL) && CTemplTool_IsTemplateArgumentDependentType(declinfo->thetype))
-            CTemplClass_RegisterObjectDef(TEMPL_CLASS(tclass), OBJ_BASE(obj));
-        CScope_AddObject(tclass->nspace, declinfo->name, OBJ_BASE(obj));
-    }
-
-    obj->access = access;
-    CheckDefaultArgs(TYPE_FUNC(obj->type)->args);
-
-    if (flag2) {
-        tfunc->flags |= FUNC_CONVERSION;
-        tclass->flags = tclass->flags | CLASS_IS_CONVERTIBLE;
-    }
-
-    if (r31) {
-        CDecl_MakeFunctionVirtual(tclass, obj);
-        decle->has_vtable = 1;
-    }
-
-    if ((flag1 || r31) && flag3 && (tk == '=')) {
-        if ((tk = lex()) == TK_INTCONST) {
-            if (!CInt64_IsZero(&tkintconst))
-                CError_Error(CErrorStr121);
-            tfunc->flags |= FUNC_PURE;
-            tclass->flags = tclass->flags | CLASS_ABSTRACT;
-            tk = lex();
-        } else {
-            CError_Error(CErrorStr121);
-        }
-    }
-
-    if (flag3 && ((tk == '{') || (tk == TK_TRY) || ((tk == ':') && CClass_IsConstructor(obj)))) {
-        if (declinfo->x49)
-            CError_Error(CErrorStr127);
-        InlineFunctionObject(obj, NULL);
-    }
-
-    if (cparamblkptr->browseoptions.recordClasses)
-        CBrowse_AddClassMemberFunction(obj, CPrep_BrowserTokenOffset(&member_fileoffset) + 1, CPrep_BrowserFileOffset());
-}
-
-static Boolean CDecl_IsAccessDeclaration(TypeClass *tclass, AccessType access) {
-    SInt32 state;
-    Boolean flag;
-
-    CPrep_TokenStreamGetState(&state);
-    flag = 0;
-
-restart:
-    switch (tk) {
-        case TK_IDENTIFIER:
-            if ((tk = lex()) != ';')
-                break;
-        case TK_OPERATOR:
-            CPrep_TokenStreamSetCurState(&state);
-            if (flag) {
-                CScope_ParseUsingDeclaration(tclass->nspace, access, 1);
-                return 1;
-            }
-            return 0;
-        default:
-            CPrep_TokenStreamSetCurState(&state);
-            return 0;
-    }
-
-    switch (tk) {
-        case TK_COLON_COLON:
-            flag = 1;
-            tk = lex();
-            goto restart;
-        case '<':
-            tk = lex();
-            while (1) {
-                switch (tk) {
-                    case 0:
-                    case ';':
-                    case '{':
-                    case '}':
-                        CPrep_TokenStreamSetCurState(&state);
-                        return 0;
-                    case '>':
-                        if ((tk = lex()) == TK_COLON_COLON) {
-                            flag = 1;
-                            tk = lex();
-                            goto restart;
-                        }
-                    default:
-                        tk = lex();
-                }
-            }
-    }
-
-    CPrep_TokenStreamSetCurState(&state);
-    return 0;
-}
-
-void CDecl_PackDeclInfo(PackedDeclInfo *packed, DeclInfo *declinfo) {
-    packed->thetype = declinfo->thetype;
-    packed->qual = declinfo->qual;
-    packed->nspace = declinfo->nspace;
-    packed->name = declinfo->name;
-    packed->expltargs = CTemplTool_MakeGlobalTemplArgCopy(declinfo->expltargs);
-    packed->storageclass = declinfo->storageclass;
-    packed->section = declinfo->section;
-    packed->exportflags = declinfo->exportflags;
-    packed->has_expltargs = declinfo->has_expltargs;
-}
-
-void CDecl_UnpackDeclInfo(DeclInfo *declinfo, PackedDeclInfo *packed) {
-    memclrw(declinfo, sizeof(DeclInfo));
-    declinfo->thetype = packed->thetype;
-    declinfo->qual = packed->qual;
-    declinfo->nspace = packed->nspace;
-    declinfo->name = packed->name;
-    declinfo->expltargs = packed->expltargs;
-    declinfo->storageclass = packed->storageclass;
-    declinfo->section = packed->section;
-    declinfo->exportflags = packed->exportflags;
-    declinfo->has_expltargs = packed->has_expltargs;
-}
-
-void CDecl_AddFriend(TypeClass *tclass, Object *friendfunc, TypeClass *friendclass) {
-    ClassFriend *scan;
-    ClassFriend *newfriend;
-
-    if (friendfunc) {
-        for (scan = tclass->friends; scan; scan = scan->next) {
-            if (!scan->isclass && scan->u.obj == friendfunc)
-                break;
-        }
-        if (!scan) {
-            newfriend = galloc(sizeof(ClassFriend));
-            memclrw(newfriend, sizeof(ClassFriend));
-            newfriend->next = tclass->friends;
-            tclass->friends = newfriend;
-            newfriend->u.obj = friendfunc;
-            newfriend->isclass = 0;
-        }
-    }
-
-    if (friendclass) {
-        for (scan = tclass->friends; scan; scan = scan->next) {
-            if (scan->isclass && scan->u.theclass == friendclass)
-                break;
-        }
-        if (!scan) {
-            newfriend = galloc(sizeof(ClassFriend));
-            memclrw(newfriend, sizeof(ClassFriend));
-            newfriend->next = tclass->friends;
-            tclass->friends = newfriend;
-            newfriend->u.theclass = friendclass;
-            newfriend->isclass = 1;
-        }
-    }
-}
-
-static void CDecl_ParseFriendDecl(TypeClass *tclass) {
-    DeclInfo declinfo;
-    DeclInfo declinfo_copy;
-    Boolean is_templ;
-    Boolean r27;
-    Boolean pflag;
-    CScopeSave save;
-    Object *obj;
-    NameSpace *nspace;
-
-    is_templ = (tclass->flags & CLASS_IS_TEMPL) != 0;
-    r27 = (tk == TK_CLASS || tk == TK_STRUCT || tk == TK_UNION);
-    memclrw(&declinfo, sizeof(DeclInfo));
-
-    declinfo.in_friend_decl = 1;
-    CParser_GetDeclSpecs(&declinfo, 1);
-    if (declinfo.storageclass) {
-        CError_Error(CErrorStr177);
-        declinfo.storageclass = 0;
-    }
-    declinfo.in_friend_decl = 0;
-
-    if (tk == ';') {
-        if (!r27)
-            CError_Error(CErrorStr201);
-
-        if (IS_TYPE_CLASS(declinfo.thetype)) {
-            if (!(TYPE_CLASS(declinfo.thetype)->flags & CLASS_IS_TEMPL) || CParser_CheckTemplateClassUsage(TEMPL_CLASS(declinfo.thetype), 1)) {
-                if (!is_templ)
-                    CDecl_AddFriend(tclass, NULL, TYPE_CLASS(declinfo.thetype));
-                else
-                    CTemplClass_RegisterFriend(TEMPL_CLASS(tclass), &declinfo);
-            }
-        } else {
-            if (IS_TYPE_TEMPLATE(declinfo.thetype) && is_templ)
-                CTemplClass_RegisterFriend(TEMPL_CLASS(tclass), &declinfo);
-            else
-                CError_Error(CErrorStr201);
-        }
-    } else {
-        if (declinfo.x14 || declinfo.x10) {
-            CDecl_ParseSpecialMember(&declinfo, 0);
-            if (declinfo.name) {
-                obj = CDecl_GetFunctionObject(&declinfo, NULL, &pflag, 0);
-                if (obj)
-                    CDecl_AddFriend(tclass, obj, NULL);
-                if (tk != ';')
-                    CError_Error(CErrorStr123);
-                else
-                    tk = lex();
-            }
-            return;
-        } else {
-            nspace = CScope_FindGlobalNS(cscope_current);
-            declinfo_copy = declinfo;
-            while (1) {
-                declinfo = declinfo_copy;
-                declinfo.x4D = 1;
-                declinfo.x51 = 1;
-                scandeclarator(&declinfo);
-
-                if (IS_TYPE_FUNC(declinfo.thetype)) {
-                    if (!is_templ) {
-                        CScope_SetNameSpaceScope(nspace, &save);
-                        obj = CDecl_GetFunctionObject(&declinfo, NULL, &pflag, 0);
-                        CScope_RestoreScope(&save);
-
-                        if (obj) {
-                            CDecl_AddFriend(tclass, obj, NULL);
-                            if (!declinfo.nspace && tk == '{') {
-                                InlineFunctionObject(obj, tclass);
-                            } else {
-                                if (!obj->sclass)
-                                    obj->sclass = TK_EXTERN;
-                            }
-                        }
-                    } else {
-                        CTemplClass_RegisterFriend(TEMPL_CLASS(tclass), &declinfo);
-                    }
-                } else {
-                    CError_Error(CErrorStr201);
-                }
-
-                if (tk != ',')
-                    break;
-                tk = lex();
-            }
-        }
-    }
-
-    if (tk == ';')
-        tk = lex();
-    else
-        CError_Error(CErrorStr123);
-}
-
-static ObjMemberVar *CDecl_InstanceDataDeclarator(ClassLayout *decle, TypeClass *tclass, Type *type, UInt32 qual, HashNameNode *name, AccessType access) {
-    NameSpaceObjectList *list;
-    ObjMemberVar *ivar;
-    ObjMemberVar *scan;
-
-    if (name && (list = CScope_FindName(tclass->nspace, name))) {
-        switch (list->object->otype) {
-            case OT_NAMESPACE:
-                CError_Error(CErrorStr321);
-                return NULL;
-            case OT_ENUMCONST:
-            case OT_TYPE:
-            case OT_OBJECT:
-                CError_Error(CErrorStr322);
-                return NULL;
-            case OT_MEMBERVAR:
-                CError_Error(CErrorStr122, name->name);
-                return NULL;
-            case OT_TYPETAG:
-                break;
-            default:
-                CError_FATAL(4989);
-        }
-    }
-
-    ivar = galloc(sizeof(ObjMemberVar));
-    memclrw(ivar, sizeof(ObjMemberVar));
-    ivar->otype = OT_MEMBERVAR;
-    ivar->access = access;
-    ivar->name = name;
-    ivar->type = type;
-    ivar->qual = qual;
-    if (!tclass->sominfo)
-        decle->lex_order_count++;
-
-    if ((scan = tclass->ivars)) {
-        while (scan->next)
-            scan = scan->next;
-        scan->next = ivar;
-    } else {
-        tclass->ivars = ivar;
-    }
-
-    if (name && name != no_name_node) {
-        CScope_AddObject(tclass->nspace, name, OBJ_BASE(ivar));
-        if ((tclass->flags & CLASS_IS_TEMPL) && CTemplTool_IsTemplateArgumentDependentType(type))
-            CTemplClass_RegisterObjectDef(TEMPL_CLASS(tclass), OBJ_BASE(ivar));
-        if (cparamblkptr->browseoptions.recordClasses)
-            CBrowse_AddClassMemberVar(ivar, CPrep_BrowserTokenOffset(&member_fileoffset) + 1, CPrep_BrowserFileOffset());
-    }
-
-    return ivar;
-}
-
-void CDecl_CheckCtorIntegrity(FuncArg *args, TypeClass *tclass) {
-    if (args && args->type == TYPE(tclass)) {
-        if (!args->next || args->next->dexpr) {
-            CError_Error(CErrorStr239);
-            args->type = &stvoid;
-        }
-    }
-}
-
-static void CDecl_ParseClassMembers(ClassLayout *decle, TypeClass *tclass, short mode) {
-    AccessType access;
-    Boolean r17;
-    BigDeclInfo bde;
-    DeclInfo declinfo;
-    //Type *newtype
-    ObjMemberVar *ivar;
-    ObjMemberVar *scanivar;
-    Type *tmptype;
-    UInt32 r22;
-    UInt32 r21;
-    UInt8 r20;
-    UInt8 r18;
-    Boolean r19;
-    short t;
-
-    r17 = (tclass->flags & CLASS_IS_TEMPL) && TEMPL_CLASS(tclass)->pspec_owner;
-    memclrw(&bde, sizeof(BigDeclInfo));
-
-    access = (mode == CLASS_MODE_CLASS) ? ACCESSPRIVATE : ACCESSPUBLIC;
-    global_access = access;
-
-    restart:
-    while (tk != '}') {
-        CPrep_NewFileOffsetInfo(&member_fileoffset, NULL);
-        r21 = 0;
-        r22 = 0;
-        r20 = 0;
-        r18 = 0;
-
-        if (tk == TK_TEMPLATE) {
-            NameSpace *nspace = cscope_current;
-            TemplClass *tmclass;
-
-            if (nspace->theclass && (nspace->theclass->flags & CLASS_IS_TEMPL)) {
-                tmclass = TEMPL_CLASS(nspace->theclass);
-            } else {
-                for (; nspace; nspace = nspace->parent) {
-                    if (!nspace->name && !nspace->theclass && nspace->parent && !nspace->is_templ) {
-                        CError_Error(CErrorStr347);
-                        break;
-                    }
-                }
-            }
-
-            CTempl_Parse(TEMPL_CLASS(tclass), access);
-            tk = lex();
-            continue;
-        }
-
-    restart2:
-        r19 = 0;
-        switch (tk) {
-            case TK_UU_DECLSPEC:
-                if ((tk = lex()) != '(')
-                    CError_Error(CErrorStr114);
-                memclrw(&declinfo, sizeof(DeclInfo));
-                CParser_ParseDeclSpec(&declinfo, 1);
-                r21 |= declinfo.qual;
-                r20 |= declinfo.exportflags;
-                r18 = declinfo.section;
-                if ((tk = lex()) != ')')
-                    CError_Error(CErrorStr115);
-                tk = lex();
-                goto restart2;
-            case TK_PRIVATE:
-                global_access = access = ACCESSPRIVATE;
-                goto check_access;
-            case TK_PROTECTED:
-                global_access = access = ACCESSPROTECTED;
-                goto check_access;
-            case TK_PUBLIC:
-                global_access = access = ACCESSPUBLIC;
-            check_access:
-                if (r22 || r20)
-                    CError_Error(CErrorStr121);
-                if ((tk = lex()) != ':')
-                    CError_Error(CErrorStr170);
-                else
-                    tk = lex();
-                goto restart;
-            case TK_EXPLICIT:
-                CError_QualifierCheck(r22 & Q_EXPLICIT);
-                r22 |= Q_EXPLICIT;
-                tk = lex();
-                goto restart2;
-            case TK_INLINE:
-                CError_QualifierCheck(r22 & Q_INLINE);
-                r22 |= Q_INLINE;
-                tk = lex();
-                goto restart2;
-            case TK_ASM:
-                CError_QualifierCheck(r22 & Q_ASM);
-                r22 |= Q_ASM;
-                tk = lex();
-                goto restart2;
-            case TK_VIRTUAL:
-                CError_QualifierCheck(r22 & Q_VIRTUAL);
-                r22 |= Q_VIRTUAL;
-                tk = lex();
-                goto restart2;
-            case TK_IDENTIFIER:
-                while (1) {
-                    if (tkidentifier == tclass->classname) {
-                        t = lookahead();
-                        tkidentifier = tclass->classname;
-                        r19 = 1;
-                        if (copts.cpp_extensions && t == TK_COLON_COLON) {
-                            lex();
-                            tk = lex();
-                            if (tk == TK_IDENTIFIER)
-                                continue;
-                            if (tk == '~')
-                                goto restart2;
-                            CError_Error(CErrorStr107);
-                        }
-
-                        if (t == '(') {
-                        redo_thing:
-                            CError_QualifierCheck(r22 & ~(Q_EXPLICIT | Q_INLINE | Q_ASM));
-                            memclrw(&bde.declinfo2, sizeof(DeclInfo));
-                            if (tclass->sominfo)
-                                bde.declinfo2.thetype = &stvoid;
-                            else
-                                bde.declinfo2.thetype = TYPE(&void_ptr);
-
-                            bde.declinfo2.qual = r22;
-                            bde.declinfo2.exportflags = r20;
-                            bde.declinfo2.section = r18;
-                            bde.declinfo2.x4B = 1;
-                            scandeclarator(&bde.declinfo2);
-                            if (IS_TYPE_FUNC(bde.declinfo2.thetype)) {
-                                if (r17)
-                                    bde.declinfo2.thetype = CTemplTool_ResolveMemberSelfRefs(TEMPL_CLASS(tclass), bde.declinfo2.thetype, &bde.declinfo2.qual);
-                                if (tclass->sominfo) {
-                                    if (TYPE_FUNC(bde.declinfo2.thetype)->args)
-                                        CError_Error(CErrorStr272);
-                                    bde.declinfo2.qual |= Q_VIRTUAL;
-                                } else {
-                                    CDecl_CheckCtorIntegrity(TYPE_FUNC(bde.declinfo2.thetype)->args, tclass);
-                                    if (tclass->flags & CLASS_HAS_VBASES)
-                                        CDecl_AddArgument(TYPE_FUNC(bde.declinfo2.thetype), TYPE(&stsignedshort));
-                                    bde.declinfo2.qual &= ~Q_VIRTUAL;
-                                }
-                                TYPE_FUNC(bde.declinfo2.thetype)->flags |= FUNC_IS_CTOR;
-                                bde.declinfo2.name = constructor_name_node;
-                                bde.declinfo2.qual |= r21;
-                                CDecl_AddFunctionMember(decle, tclass, &bde.declinfo2, access, 0, 0, 1, 0);
-                            } else {
-                                CError_Error(CErrorStr241);
-                            }
-                            if (tk == ';')
-                                tk = lex();
-                            else
-                                CError_Error(CErrorStr123);
-                            goto restart;
-                        }
-                    }
-                    // 6F8D8
-                    if (!r22 && CDecl_IsAccessDeclaration(tclass, access)) {
-                        tk = lex();
-                        goto restart;
-                    }
-                    break;
-                }
-                break;
-            case TK_USING:
-                CError_QualifierCheck(r22);
-                tk = lex();
-                CScope_ParseUsingDeclaration(tclass->nspace, access, 0);
-                tk = lex();
-                goto restart;
-            case '~':
-                if ((tk = lex()) != TK_IDENTIFIER || tkidentifier != tclass->classname) {
-                    CError_Error(CErrorStr241);
-                    goto restart;
-                }
-                CError_QualifierCheck(r22 & ~(Q_VIRTUAL | Q_INLINE | Q_ASM));
-                if (tclass->flags & CLASS_IS_TEMPL_ANY) {
-                    t = lookahead();
-                    tkidentifier = tclass->classname;
-                    if (t == '<') {
-                        memclrw(&bde.declinfo, sizeof(DeclInfo));
-                        CParser_GetDeclSpecs(&bde.declinfo, 0);
-                        if (tk != '(' || bde.declinfo.thetype != TYPE(tclass) || bde.declinfo.nspace) {
-                            CError_Error(CErrorStr241);
-                            goto restart;
-                        }
-                        CPrep_UnLex();
-                        tk = TK_IDENTIFIER;
-                        tkidentifier = tclass->classname;
-                    }
-                }
-                memclrw(&bde.declinfo2, sizeof(DeclInfo));
-                bde.declinfo2.qual = r22;
-                bde.declinfo2.exportflags = r20;
-                bde.declinfo2.section = r18;
-                if (tclass->sominfo)
-                    bde.declinfo2.thetype = &stvoid;
-                else
-                    bde.declinfo2.thetype = TYPE(&void_ptr);
-                scandeclarator(&bde.declinfo2);
-                if (IS_TYPE_FUNC(bde.declinfo2.thetype) && !TYPE_FUNC(bde.declinfo2.thetype)->args) {
-                    if (!CScope_FindName(tclass->nspace, destructor_name_node)) {
-                        if (tclass->sominfo)
-                            bde.declinfo2.qual |= Q_VIRTUAL;
-                        else
-                            CDecl_AddArgument(TYPE_FUNC(bde.declinfo2.thetype), TYPE(&stsignedshort));
-                        bde.declinfo2.name = destructor_name_node;
-                        TYPE_FUNC(bde.declinfo2.thetype)->flags |= FUNC_IS_DTOR;
-                        bde.declinfo2.qual |= r21;
-                        CDecl_AddFunctionMember(decle, tclass, &bde.declinfo2, access, 1, 0, 1, 0);
-                    } else {
-                        CError_Error(CErrorStr133, CError_GetFunctionName(tclass->nspace, destructor_name_node, NULL));
-                    }
-                } else {
-                    CError_Error(CErrorStr146);
-                }
-                if (tk == ';')
-                    tk = lex();
-                else
-                    CError_Error(CErrorStr123);
-                goto restart;
-            case TK_OPERATOR:
-                if (CMangler_OperatorName(lookahead())) {
-                    memclrw(&bde.declinfo, sizeof(DeclInfo));
-                    bde.declinfo.thetype = TYPE(&stsignedint);
-                    goto after_various_things;
-                } else {
-                    tk = lex();
-                    CError_QualifierCheck(r22 & ~(Q_VIRTUAL | Q_INLINE | Q_ASM));
-                    memclrw(&bde.declinfo2, sizeof(DeclInfo));
-                    bde.declinfo2.qual = r22;
-                    bde.declinfo2.exportflags = r20;
-                    bde.declinfo2.section = r18;
-                    conversion_type_name(&bde.declinfo2);
-                    bde.declinfo2.qual |= r21;
-                    tmptype = bde.declinfo2.thetype;
-                    CDecl_NewConvFuncType(&bde.declinfo2);
-                    if ((tclass->flags & CLASS_IS_TEMPL) && CTemplTool_IsTemplateArgumentDependentType(tmptype))
-                        bde.declinfo2.name = CParser_GetUniqueName();
-                    CDecl_AddFunctionMember(decle, tclass, &bde.declinfo2, access, 1, 1, 1, 0);
-                    if (tk == ';')
-                        tk = lex();
-                    else
-                        CError_Error(CErrorStr123);
-                    goto restart;
-                }
-            case TK_FRIEND:
-                tk = lex();
-                CDecl_ParseFriendDecl(tclass);
-                goto restart;
-        }
-
-        CError_QualifierCheck(r22 & Q_EXPLICIT);
-        global_access = access;
-        memclrw(&bde.declinfo, sizeof(DeclInfo));
-        bde.declinfo.qual = r22;
-        bde.declinfo.exportflags = r20;
-        bde.declinfo.section = r18;
-        CParser_GetDeclSpecs(&bde.declinfo, 0);
-
-        if (r19 && tk == '(' && (tclass->flags & CLASS_IS_TEMPL_ANY) && bde.declinfo.thetype == TYPE(tclass) && !bde.declinfo.nspace) {
-            CPrep_UnLex();
-            tk = TK_IDENTIFIER;
-            tkidentifier = tclass->classname;
-            r22 = bde.declinfo.qual;
-            goto redo_thing;
-        }
-
-        after_various_things:
-        switch (bde.declinfo.storageclass) {
-            case 0:
-            case TK_STATIC:
-            case TK_TYPEDEF:
-            case TK_MUTABLE:
-                break;
-            default:
-                CError_Error(CErrorStr177);
-                bde.declinfo.storageclass = 0;
-        }
-
-        if (tk != ';') {
-            while (1) {
-                CDecl_ScanStructDeclarator(&bde);
-                if (r17)
-                    bde.declinfo2.thetype = CTemplTool_ResolveMemberSelfRefs(TEMPL_CLASS(tclass), bde.declinfo2.thetype, &bde.declinfo2.qual);
-                if (bde.declinfo2.nspace)
-                    CError_Error(CErrorStr200);
-                if (bde.declinfo2.operator_token) {
-                    if (bde.declinfo.storageclass == TK_MUTABLE)
-                        CError_QualifierCheck(Q_MUTABLE);
-                    r19 = 0;
-                    switch (bde.declinfo2.operator_token) {
-                        case TK_NEW:
-                        case TK_NEW_ARRAY:
-                            CError_QualifierCheck(bde.declinfo2.qual & Q_VIRTUAL);
-                            r19 = 1;
-                            break;
-                        case TK_DELETE:
-                        case TK_DELETE_ARRAY:
-                            CError_QualifierCheck(bde.declinfo2.qual & Q_VIRTUAL);
-                            r19 = 1;
-                            break;
-                        default:
-                            if (bde.declinfo2.storageclass == TK_STATIC)
-                                CError_Error(CErrorStr193);
-                            if (tclass->sominfo)
-                                CError_Error(CErrorStr193);
-                    }
-
-                    bde.declinfo2.storageclass = 0;
-                    if (IS_TYPE_FUNC(bde.declinfo2.thetype)) {
-                        bde.declinfo2.qual |= r21;
-                        CDecl_AddFunctionMember(decle, tclass, &bde.declinfo2, access, r19 == 0, 0, 1, r19);
-                        CDecl_CheckOperatorType(&bde.declinfo2, 1);
-                        if (tclass->sominfo)
-                            CSOM_FixNewDeleteFunctype(TYPE_FUNC(bde.declinfo2.thetype));
-                    } else {
-                        CError_Error(CErrorStr121);
-                    }
-                } else if (bde.xCD) {
-                    if (bde.declinfo2.name == constructor_name_node || bde.declinfo2.name == destructor_name_node)
-                        CError_Error(CErrorStr241);
-                    switch (bde.declinfo2.storageclass) {
-                        case TK_TYPEDEF:
-                            CError_QualifierCheck(bde.declinfo2.qual & Q_VIRTUAL);
-                            CDecl_TypedefDeclarator(&bde.declinfo2);
-                            break;
-                        case TK_STATIC:
-                            CError_QualifierCheck(bde.declinfo2.qual & Q_VIRTUAL);
-                            if (tclass->sominfo)
-                                CError_Error(CErrorStr271);
-                            if (IS_TYPE_FUNC(bde.declinfo2.thetype)) {
-                                bde.declinfo2.qual |= r21;
-                                bde.declinfo2.storageclass = 0;
-                                if (bde.declinfo2.name == tclass->classname)
-                                    CError_Error(CErrorStr241);
-                                CDecl_AddFunctionMember(decle, tclass, &bde.declinfo2, access, 0, 0, 1, 1);
-                            } else {
-                                CDecl_ExtractClassExportFlags(&bde.declinfo2, tclass->eflags);
-                                bde.declinfo2.storageclass = 0;
-                                CDecl_DataDeclarator(&bde.declinfo2, access, 1);
-                            }
-                            break;
-                        case 0:
-                        case TK_MUTABLE:
-                            if (IS_TYPE_FUNC(bde.declinfo2.thetype)) {
-                                if (bde.declinfo2.name == tclass->classname)
-                                    CError_Error(CErrorStr241);
-                                if (bde.declinfo.storageclass == TK_MUTABLE)
-                                    CError_QualifierCheck(Q_MUTABLE);
-                                bde.declinfo2.qual |= r21;
-                                CDecl_AddFunctionMember(decle, tclass, &bde.declinfo2, access, 1, 0, 1, 0);
-                            } else {
-                                CDecl_CompleteType(bde.declinfo2.thetype);
-                                CanCreateObject(bde.declinfo2.thetype);
-                                CError_QualifierCheck(bde.declinfo2.qual & (Q_VIRTUAL | Q_INLINE));
-                                if (bde.declinfo2.storageclass == TK_MUTABLE)
-                                    bde.declinfo2.qual |= Q_MUTABLE;
-                                CDecl_InstanceDataDeclarator(decle, tclass, bde.declinfo2.thetype, bde.declinfo2.qual, bde.declinfo2.name, access);
-                            }
-                            break;
-                        default:
-                            CError_Error(CErrorStr177);
-                    }
-                }
-
-                // this should be 70058
-                if (tk != ',')
-                    break; // goes to 70148
-                tk = lex();
-            }
-        } else if (CParser_IsAnonymousUnion(&bde.declinfo, 1)) {
-            if ((ivar = CDecl_InstanceDataDeclarator(decle, tclass, bde.declinfo.thetype, 0, NULL, access)))
-                ivar->anonunion = 1;
-            for (scanivar = TYPE_CLASS(bde.declinfo.thetype)->ivars; scanivar; scanivar = scanivar->next) {
-                tmptype = scanivar->type;
-                if (IS_TYPE_BITFIELD(tmptype) && copts.reverse_bitfields) {
-                    TypeBitfield *newtype = galloc(sizeof(TypeBitfield));
-                    *newtype = *TYPE_BITFIELD(tmptype);
-                    CABI_ReverseBitField(newtype);
-                    tmptype = TYPE(newtype);
-                }
-                if ((ivar = CDecl_InstanceDataDeclarator(decle, tclass, tmptype, scanivar->qual, scanivar->name, access)))
-                    ivar->offset = scanivar->offset | 0x80000000;
-            }
-        }
-
-        // this should be 70148 i think
-        if (tk != ';') {
-            CError_Error(CErrorStr123);
-            return;
-        }
-        CPrep_TokenStreamFlush();
-        tk = lex();
-    }
-}
-
-static VClassList *AddVBaseToList(TypeClass *tclass, TypeClass *baseclass) {
-    VClassList *scan;
-    VClassList *vbase;
-
-    for (scan = tclass->vbases; scan; scan = scan->next) {
-        if (scan->base == baseclass)
-            return NULL;
-    }
-
-    vbase = galloc(sizeof(VClassList));
-    memclrw(vbase, sizeof(VClassList));
-    vbase->base = baseclass;
-
-    if ((scan = tclass->vbases)) {
-        while (scan->next)
-            scan = scan->next;
-        scan->next = vbase;
-    } else {
-        tclass->vbases = vbase;
-    }
-
-    return vbase;
-}
-
-void CDecl_MakeVBaseList(TypeClass *tclass) {
-    ClassList *base;
-    VClassList *vbase;
-    VClassList *new_vbase;
-    SInt32 offset;
-
-    if (copts.vbase_ctor_offset)
-        tclass->flags = tclass->flags | CLASS_FLAGS_8000;
-
-    for (base = tclass->bases, offset = tclass->size; base; base = base->next) {
-        for (vbase = base->base->vbases; vbase; vbase = vbase->next) {
-            if ((new_vbase = AddVBaseToList(tclass, vbase->base))) {
-                new_vbase->offset = offset + CMach_MemberAlignValue(TYPE(vbase->base), offset);
-                offset = new_vbase->offset + vbase->base->size;
-            }
-        }
-
-        if (base->is_virtual && (new_vbase = AddVBaseToList(tclass, base->base))) {
-            new_vbase->offset = offset + CMach_MemberAlignValue(TYPE(base->base), offset);
-            offset = new_vbase->offset + base->base->size;
-        }
-    }
-}
-
-Boolean CDecl_CheckNewBase(TypeClass *tclass, TypeClass *baseclass, Boolean is_virtual) {
-    ClassList *scan;
-
-    if (tclass == baseclass) {
-        CError_Error(CErrorStr131);
-        return 0;
-    }
-
-    if (!(baseclass->flags & CLASS_COMPLETED)) {
-        CError_Error(CErrorStr136, baseclass, 0);
-        return 0;
-    }
-
-    if (baseclass->flags & CLASS_SINGLE_OBJECT) {
-        if (is_virtual || tclass->bases) {
-            CError_Error(CErrorStr191);
-            return 0;
-        }
-        tclass->flags = tclass->flags | CLASS_SINGLE_OBJECT;
-    }
-
-    if (baseclass->flags & CLASS_HANDLEOBJECT) {
-        if (is_virtual || tclass->bases) {
-            CError_Error(CErrorStr191);
-            return 0;
-        }
-        tclass->flags = tclass->flags | CLASS_HANDLEOBJECT;
-    }
-
-    if (baseclass->sominfo) {
-        if (!is_virtual)
-            CError_Error(CErrorStr268);
-        CSOM_MakeSOMClass(tclass);
-    } else if (tclass->sominfo) {
-        CError_Error(CErrorStr267);
-    }
-
-    if (tclass->bases && (tclass->flags & CLASS_SINGLE_OBJECT) && (tclass->flags & CLASS_SINGLE_OBJECT)) {
-        CError_Error(CErrorStr131);
-        return 0;
-    }
-
-    if (copts.ecplusplus && (is_virtual || tclass->bases)) {
-        CError_Error(CErrorStr339);
-        return 0;
-    }
-
-    for (scan = tclass->bases; scan; scan = scan->next) {
-        if (scan->base == baseclass) {
-            CError_Error(CErrorStr131);
-            return 0;
-        }
-    }
-
-    if (baseclass->flags & CLASS_COM_OBJECT)
-        tclass->flags = tclass->flags | CLASS_COM_OBJECT;
-    if (baseclass->flags & CLASS_IS_CONVERTIBLE)
-        tclass->flags = tclass->flags | CLASS_IS_CONVERTIBLE;
-    if (baseclass->flags & CLASS_HAS_VBASES)
-        tclass->flags = tclass->flags | CLASS_HAS_VBASES;
-
-    if (is_virtual)
-        tclass->flags = tclass->flags | CLASS_HAS_VBASES;
-
-    return 1;
-}
-
-static void CDecl_ParseBaseClassList(TypeClass *tclass, short mode, Boolean is_templ) {
-    Boolean is_virtual;
-    AccessType access;
-    NameResult pr;
-    ObjType *inherited_type;
-    ClassList *base;
-    ClassList *scan;
-    TypeClass *baseclass;
-
-    do {
-        if (mode == CLASS_MODE_CLASS)
-            access = ACCESSPRIVATE;
-        else
-            access = ACCESSPUBLIC;
-
-        is_virtual = 0;
-        if ((tk = lex()) == TK_VIRTUAL) {
-            tk = lex();
-            is_virtual = 1;
-        }
-
-        switch (tk) {
-            case TK_PRIVATE:
-                access = ACCESSPRIVATE;
-                tk = lex();
-                break;
-            case TK_PUBLIC:
-                access = ACCESSPUBLIC;
-                tk = lex();
-                break;
-            case TK_PROTECTED:
-                if (!copts.ARMconform) {
-                    access = ACCESSPROTECTED;
-                    tk = lex();
-                }
-                break;
-        }
-
-        if (tk == TK_VIRTUAL) {
-            if (is_virtual)
-                CError_Error(CErrorStr121);
-            is_virtual = 1;
-            tk = lex();
-        }
-
-        if (CScope_ParseDeclName(&pr)) {
-            if (!pr.type) {
-                if (!pr.name_4) {
-                    CError_Error(CErrorStr121);
-                } else if (tk == TK_IDENTIFIER && pr.name_4 == tkidentifier) {
-                    goto special_parsing;
-                }
-                CError_Error(CErrorStr140, tkidentifier->name);
-                continue;
-            }
-
-            CDecl_CompleteType(pr.type);
-            if (is_templ && CTemplTool_IsTemplateArgumentDependentType(pr.type)) {
-                if (!IS_TYPE_CLASS(pr.type) || !(TYPE_CLASS(pr.type)->flags & CLASS_IS_TEMPL) ||
-                    CParser_CheckTemplateClassUsage(TEMPL_CLASS(pr.type), 1)) {
-                    CTemplClass_RegisterBaseClass(TEMPL_CLASS(tclass), pr.type, access, is_virtual);
-                    if (is_virtual)
-                        tclass->flags = tclass->flags | CLASS_HAS_VBASES;
-                }
-                continue;
-            }
-
-            if (!IS_TYPE_CLASS(pr.type) || (TYPE_CLASS(pr.type)->flags & CLASS_IS_TEMPL)) {
-                CError_Error(CErrorStr131);
-                continue;
-            }
-            baseclass = TYPE_CLASS(pr.type);
-        } else {
-        special_parsing:
-            if (!strcmp(tkidentifier->name, "HandleObject")) {
-                if (tclass->bases)
-                    CError_Error(CErrorStr191);
-                tclass->flags |= CLASS_SINGLE_OBJECT | CLASS_HANDLEOBJECT;
-                tk = lex();
-                break;
-            }
-            if (!strcmp(tkidentifier->name, "SingleObject") || !strcmp(tkidentifier->name, "SingleInheritance")) {
-                if (tclass->bases)
-                    CError_Error(CErrorStr191);
-                tclass->flags = tclass->flags | CLASS_SINGLE_OBJECT;
-                tk = lex();
-                break;
-            }
-            if (!strcmp(tkidentifier->name, "__comobject")) {
-                tclass->flags = tclass->flags | CLASS_COM_OBJECT;
-                tk = lex();
-                break;
-            }
-            if (!strcmp(tkidentifier->name, "__somobject")) {
-                if (!is_virtual)
-                    CError_Error(CErrorStr268);
-                CSOM_MakeSOMClass(tclass);
-                tk = lex();
-                break;
-            }
-            if (!strcmp(tkidentifier->name, "__javaobject")) {
-                tk = lex();
-                tclass->action = CLASS_ACTION_3;
-                break;
-            }
-
-            CError_Error(CErrorStr140, tkidentifier->name);
-            continue;
-        }
-
-        if (CDecl_CheckNewBase(tclass, baseclass, is_virtual)) {
-            base = galloc(sizeof(ClassList));
-            memclrw(base, sizeof(ClassList));
-            base->base = baseclass;
-            base->access = access;
-            base->is_virtual = is_virtual;
-            if ((scan = tclass->bases)) {
-                while (scan->next)
-                    scan = scan->next;
-                scan->next = base;
-            } else {
-                tclass->bases = base;
-            }
-        }
-    } while ((tk = lex()) == ',');
-
-    if (tclass->flags & CLASS_HAS_VBASES)
-        CDecl_MakeVBaseList(tclass);
-
-    if (copts.def_inherited && tclass->bases && !tclass->bases->next) {
-        inherited_type = galloc(sizeof(ObjType));
-        memclrw(inherited_type, sizeof(ObjType));
-        inherited_type->otype = OT_TYPE;
-        inherited_type->access = ACCESSPUBLIC;
-        inherited_type->type = TYPE(tclass->bases->base);
-        CScope_AddObject(tclass->nspace, GetHashNameNodeExport("inherited"), OBJ_BASE(inherited_type));
-    }
-}
-
-static AccessType getaccesstype(AccessType a, AccessType b, AccessType c) {
-    if (a == ACCESSNONE || b == ACCESSNONE || b == ACCESSPRIVATE)
-        return ACCESSNONE;
-
-    if (c == ACCESSPUBLIC && b != ACCESSPUBLIC)
-        return ACCESSNONE;
-
-    return ACCESSPUBLIC;
-}
-
-static TypeMemberFunc *CDecl_MakeDefaultCtorType(TypeClass *tclass) {
-    TypeMemberFunc *tmeth = galloc(sizeof(TypeMemberFunc));
-    memclrw(tmeth, sizeof(TypeMemberFunc));
-    tmeth->type = TYPEFUNC;
-    tmeth->functype = TYPE(&void_ptr);
-    tmeth->flags = FUNC_IS_CTOR | FUNC_AUTO_GENERATED | FUNC_METHOD;
-    tmeth->theclass = tclass;
-    CDecl_SetFuncFlags(TYPE_FUNC(tmeth), 1);
-
-    if (tclass->flags & CLASS_HAS_VBASES)
-        CDecl_AddArgument(TYPE_FUNC(tmeth), TYPE(&stsignedshort));
-
-    CDecl_AddThisPointerArgument(TYPE_FUNC(tmeth), tclass);
-    return tmeth;
-}
-
-static void CDecl_AddDefArgConstructor(TypeClass *tclass) {
-    // empty
-}
-
-static void CDecl_AddMemberFunctionObject(TypeClass *tclass, HashNameNode *name, TypeMemberFunc *tmeth, AccessType access) {
-    Object *obj = CParser_NewCompilerDefFunctionObject();
-    obj->name = name;
-    obj->type = TYPE(tmeth);
-    obj->qual = Q_MANGLE_NAME;
-    obj->access = access;
-    obj->nspace = tclass->nspace;
-    obj->qual = obj->qual | Q_INLINE;
-    CScope_AddObject(tclass->nspace, obj->name, OBJ_BASE(obj));
-}
-
-static void CDecl_AddDefaultConstructor(ClassLayout *decle, TypeClass *tclass) {
-    ClassList *base;
-    ObjMemberVar *ivar;
-    Object *obj;
-    Boolean has_ctor;
-
-    if (CClass_Constructor(tclass)) {
-        CDecl_AddDefArgConstructor(tclass);
-        return;
-    }
-
-    has_ctor = 0;
-
-    if (tclass->flags & CLASS_HAS_VBASES)
-        has_ctor = 1;
-    if (decle->has_vtable)
-        has_ctor = 1;
-
-    for (base = tclass->bases; base; base = base->next) {
-        if (CClass_Constructor(base->base))
-            has_ctor = 1;
-    }
-
-    for (ivar = tclass->ivars; ivar; ivar = ivar->next) {
-        Type *type = ivar->type;
-        while (IS_TYPE_ARRAY(type))
-            type = TYPE_POINTER(type)->target;
-        if (IS_TYPE_CLASS(type) && CClass_Constructor(TYPE_CLASS(type)))
-            has_ctor = 1;
-    }
-
-    if (has_ctor) {
-        CDecl_AddMemberFunctionObject(
-                tclass,
-                constructor_name_node,
-                CDecl_MakeDefaultCtorType(tclass),
-                ACCESSPUBLIC
-        );
-    }
-}
-
-static TypeMemberFunc *CDecl_MakeCopyCtorType(TypeClass *tclass, Boolean is_const) {
-    FuncArg *arg;
-    TypeMemberFunc *tmeth = galloc(sizeof(TypeMemberFunc));
-    memclrw(tmeth, sizeof(TypeMemberFunc));
-    tmeth->type = TYPEFUNC;
-    tmeth->functype = TYPE(&void_ptr);
-    tmeth->flags = FUNC_IS_CTOR | FUNC_AUTO_GENERATED | FUNC_METHOD;
-    tmeth->theclass = tclass;
-    CDecl_SetFuncFlags(TYPE_FUNC(tmeth), 1);
-
-    arg = CParser_NewFuncArg();
-    if (is_const)
-        arg->qual = Q_CONST;
-    arg->type = CDecl_NewRefPointerType(TYPE(tclass));
-    tmeth->args = arg;
-
-    if (tclass->flags & CLASS_HAS_VBASES)
-        CDecl_AddArgument(TYPE_FUNC(tmeth), TYPE(&stsignedshort));
-
-    CDecl_AddThisPointerArgument(TYPE_FUNC(tmeth), tclass);
-    return tmeth;
-}
-
-static void CDecl_AddDefaultCopyConstructor(ClassLayout *decle, TypeClass *tclass) {
-    ClassList *base;
-    ObjMemberVar *ivar;
-    Object *obj;
-    AccessType access;
-    Boolean has_copyctor;
-    Boolean is_const;
-    FuncArg *arg;
-
-    if (CClass_CopyConstructor(tclass))
-        return;
-
-    access = ACCESSPUBLIC;
-    is_const = 1;
-    has_copyctor = 0;
-
-    if (CClass_Constructor(tclass))
-        has_copyctor = 1;
-    if ((tclass->flags & CLASS_HAS_VBASES) || decle->has_vtable)
-        has_copyctor = 1;
-
-    for (base = tclass->bases; base; base = base->next) {
-        if ((obj = CClass_CopyConstructor(base->base))) {
-            has_copyctor = 1;
-            access = getaccesstype(access, obj->access, ACCESSPRIVATE);
-            arg = TYPE_FUNC(obj->type)->args->next;
-            if (base->base->flags & CLASS_HAS_VBASES)
-                arg = arg->next;
-            if (!(arg->qual & Q_CONST))
-                is_const = 0;
-        }
-    }
-
-    for (ivar = tclass->ivars; ivar; ivar = ivar->next) {
-        Type *type = ivar->type;
-        while (IS_TYPE_ARRAY(type))
-            type = TYPE_POINTER(type)->target;
-        if (IS_TYPE_CLASS(type) && (obj = CClass_CopyConstructor(TYPE_CLASS(type)))) {
-            has_copyctor = 1;
-            access = getaccesstype(access, obj->access, ACCESSPUBLIC);
-            arg = TYPE_FUNC(obj->type)->args->next;
-            if (TYPE_CLASS(type)->flags & CLASS_HAS_VBASES)
-                arg = arg->next;
-            if (!(arg->qual & Q_CONST))
-                is_const = 0;
-        }
-    }
-
-    if (has_copyctor) {
-        CDecl_AddMemberFunctionObject(
-                tclass,
-                constructor_name_node,
-                CDecl_MakeCopyCtorType(tclass, is_const),
-                access
-        );
-    }
-}
-
-static TypeMemberFunc *CDecl_MakeAssignmentOperatorType(TypeClass *tclass, Boolean is_const) {
-    FuncArg *arg;
-    TypeMemberFunc *tmeth = galloc(sizeof(TypeMemberFunc));
-    memclrw(tmeth, sizeof(TypeMemberFunc));
-    tmeth->type = TYPEFUNC;
-    tmeth->functype = CDecl_NewRefPointerType(TYPE(tclass));
-    tmeth->flags = FUNC_AUTO_GENERATED | FUNC_METHOD;
-    tmeth->theclass = tclass;
-    CDecl_SetFuncFlags(TYPE_FUNC(tmeth), 1);
-
-    arg = CParser_NewFuncArg();
-    if (is_const)
-        arg->qual = Q_CONST;
-    arg->type = CDecl_NewRefPointerType(TYPE(tclass));
-    tmeth->args = arg;
-
-    CDecl_AddThisPointerArgument(TYPE_FUNC(tmeth), tclass);
-    return tmeth;
-}
-
-static void CDecl_AddDefaultAssignmentOperator(ClassLayout *decle, TypeClass *tclass) {
-    ClassList *base;
-    ObjMemberVar *ivar;
-    Object *obj;
-    AccessType access;
-    Boolean is_const;
-    Boolean has_ass;
-    DeclInfo declinfo;
-
-    is_const = 1;
-    has_ass = 0;
-    access = ACCESSPUBLIC;
-
-    if (!CClass_AssignmentOperator(tclass)) {
-        if (!copts.old_argmatch)
-            has_ass = 1;
-
-        if ((tclass->flags & CLASS_HAS_VBASES) || decle->has_vtable || CClass_MemberObject(tclass, asop_name_node))
-            has_ass = 1;
-
-        for (base = tclass->bases; base; base = base->next) {
-            if ((obj = CClass_AssignmentOperator(base->base))) {
-                has_ass = 1;
-                access = getaccesstype(access, obj->access, ACCESSPRIVATE);
-                if (!(TYPE_FUNC(obj->type)->args->next->qual & Q_CONST))
-                    is_const = 0;
-            }
-        }
-
-        for (ivar = tclass->ivars; ivar; ivar = ivar->next) {
-            Type *type = ivar->type;
-            while (IS_TYPE_ARRAY(type))
-                type = TYPE_POINTER(type)->target;
-            if (IS_TYPE_CLASS(type) && (obj = CClass_AssignmentOperator(TYPE_CLASS(type)))) {
-                has_ass = 1;
-                access = getaccesstype(access, obj->access, ACCESSPUBLIC);
-                if (!(TYPE_FUNC(obj->type)->args->next->qual & Q_CONST))
-                    is_const = 0;
-            }
-        }
-    }
-
-    if (has_ass) {
-        memclrw(&declinfo, sizeof(DeclInfo));
-        declinfo.qual |= Q_INLINE;
-        declinfo.thetype = (Type *) CDecl_MakeAssignmentOperatorType(tclass, is_const);
-        declinfo.name = asop_name_node;
-        CDecl_AddFunctionMember(decle, tclass, &declinfo, access, 1, 0, 0, 0);
-    }
-}
-
-TypeMemberFunc *CDecl_MakeDefaultDtorType(TypeClass *tclass, Boolean is_virtual) {
-    TypeMemberFunc *tmeth = galloc(sizeof(TypeMemberFunc));
-    memclrw(tmeth, sizeof(TypeMemberFunc));
-    tmeth->type = TYPEFUNC;
-    tmeth->functype = (Type *) &void_ptr;
-    tmeth->flags = FUNC_IS_DTOR | FUNC_AUTO_GENERATED | FUNC_METHOD;
-    tmeth->theclass = tclass;
-    CDecl_SetFuncFlags(TYPE_FUNC(tmeth), 1);
-    if (is_virtual)
-        CDecl_AddArgument(TYPE_FUNC(tmeth), TYPE(&stsignedshort));
-    CDecl_AddThisPointerArgument(TYPE_FUNC(tmeth), tclass);
-    return tmeth;
-}
-
-static void CDecl_AddDefaultDestructor(ClassLayout *decle, TypeClass *tclass) {
-    ClassList *base;
-    ObjMemberVar *ivar;
-    Object *obj;
-    AccessType access;
-    Boolean has_dtor;
-    Boolean is_virtual;
-    DeclInfo declinfo;
-
-    if (CClass_Destructor(tclass))
-        return;
-
-    has_dtor = 0;
-    is_virtual = 0;
-    access = ACCESSPUBLIC;
-
-    for (base = tclass->bases; base; base = base->next) {
-        if ((obj = CClass_Destructor(base->base))) {
-            has_dtor = 1;
-            if (obj->datatype == DVFUNC)
-                is_virtual = 1;
-            access = getaccesstype(access, obj->access, ACCESSPRIVATE);
-        }
-    }
-
-    for (ivar = tclass->ivars; ivar; ivar = ivar->next) {
-        Type *type = ivar->type;
-        while (IS_TYPE_ARRAY(type))
-            type = TYPE_POINTER(type)->target;
-        if (IS_TYPE_CLASS(type) && (obj = CClass_Destructor(TYPE_CLASS(type)))) {
-            has_dtor = 1;
-            access = getaccesstype(access, obj->access, ACCESSPUBLIC);
-        }
-    }
-
-    if (has_dtor) {
-        memclrw(&declinfo, sizeof(DeclInfo));
-        declinfo.qual |= Q_INLINE;
-        if (is_virtual)
-            declinfo.qual |= Q_VIRTUAL;
-
-        declinfo.thetype = (Type *) CDecl_MakeDefaultDtorType(tclass, 1);
-        declinfo.name = destructor_name_node;
-        CDecl_AddFunctionMember(decle, tclass, &declinfo, access, 1, 0, 0, 0);
-    }
-}
-
-static void CDecl_SetupClassLayout(ClassLayout *decle, TypeClass *tclass, ObjBase **objbuf) {
-    SInt32 index;
-    SInt32 i;
-    Object *obj;
-    CScopeObjectIterator iter;
-    ObjMemberVar *ivar;
-    SInt32 bufsize;
-
-    if (decle->lex_order_count > 32) {
-        bufsize = decle->lex_order_count * sizeof(ObjBase *);
-        objbuf = lalloc(bufsize);
-    } else {
-        bufsize = 32 * sizeof(ObjBase *);
-    }
-    memclrw(objbuf, bufsize);
-    decle->objlist = objbuf;
-
-    CScope_InitObjectIterator(&iter, tclass->nspace);
-    index = 0;
-    while (1) {
-        obj = OBJECT(CScope_NextObjectIteratorObject(&iter));
-        if (!obj) break;
-
-        if (!IS_TYPE_FUNC(obj->type))
-            continue;
-        if (!IS_TYPEFUNC_METHOD(TYPE_FUNC(obj->type)))
-            continue;
-        if (obj->datatype == DALIAS)
-            continue;
-
-        i = TYPE_METHOD(obj->type)->vtbl_index;
-        if (i > 0) {
-            CError_ASSERT(6363, (i - 1) < decle->lex_order_count && !objbuf[(int) (i - 1)]);
-            objbuf[(int) (i - 1)] = OBJ_BASE(obj);
-            index++;
-            if (obj->datatype != DVFUNC && !TYPE_METHOD(obj->type)->is_static && CClass_OverridesBaseMember(tclass, obj->name, obj))
-                CDecl_MakeFunctionVirtual(tclass, obj);
-
-            if (obj->datatype == DVFUNC) {
-                decle->has_vtable = 1;
-                if (!tclass->vtable) {
-                    CABI_AddVTable(tclass);
-                    decle->xA = i - 1;
-                } else {
-                    if ((i - 1) < decle->xA)
-                        decle->xA = i - 1;
-                }
-            } else if (TYPE_FUNC(obj->type)->flags & FUNC_PURE) {
-                CError_Error(CErrorStr351, obj);
-                TYPE_FUNC(obj->type)->flags &= ~FUNC_PURE;
-            }
-        } else {
-            CError_ASSERT(6412, i == 0);
-        }
-
-        if (!tclass->sominfo)
-            TYPE_METHOD(obj->type)->vtbl_index = 0;
-    }
-
-    if (!tclass->action) {
-        for (i = 0; i < decle->lex_order_count; i++) {
-            Object *obj2 = OBJECT(objbuf[i]);
-            if (obj2 && obj2->datatype == DVFUNC && !(obj2->qual & Q_INLINE) && !(TYPE_FUNC(obj2->type)->flags & FUNC_PURE)) {
-                tclass->action = CLASS_ACTION_1;
-                TYPE_FUNC(obj2->type)->flags |= FUNC_FLAGS_4;
-                break;
-            }
-        }
-    }
-
-    if (!tclass->sominfo) {
-        for (i = 0, ivar = tclass->ivars; i < decle->lex_order_count; i++) {
-            if (!objbuf[i]) {
-                CError_ASSERT(6449, ivar);
-                objbuf[i] = OBJ_BASE(ivar);
-                ivar = ivar->next;
-                index++;
-            }
-        }
-        CError_ASSERT(6455, ivar == NULL);
-    }
-
-    CError_ASSERT(6458, index == decle->lex_order_count);
-}
-
-void CDecl_CompleteClass(ClassLayout *decle, TypeClass *tclass) {
-    ClassList *base;
-    ObjBase *buf[32];
-
-    for (base = tclass->bases; base; base = base->next) {
-        if (base->base->vtable)
-            decle->has_vtable = 1;
-    }
-
-    if (!tclass->sominfo) {
-        CDecl_AddDefaultDestructor(decle, tclass);
-        CDecl_AddDefaultAssignmentOperator(decle, tclass);
-        CDecl_AddDefaultConstructor(decle, tclass);
-        CDecl_AddDefaultCopyConstructor(decle, tclass);
-    }
-
-    CDecl_SetupClassLayout(decle, tclass, buf);
-    if (decle->has_vtable)
-        CClass_CheckOverrides(tclass);
-    CABI_LayoutClass(decle, tclass);
-    if (tclass->sominfo)
-        CSOM_ClassComplete(tclass);
-
-    if ((tclass->flags & CLASS_IS_TEMPL_INST) && !TEMPL_CLASS_INST(tclass)->is_specialized)
-        tclass->action = CLASS_ACTION_0;
-
-    if (!tclass->action)
-        CClass_MakeStaticActionClass(tclass);
-    CClass_ClassDefaultFuncAction(tclass);
-}
-
-TypeClass *CDecl_DefineClass(NameSpace *nspace, HashNameNode *name, TypeClass *tclass, short mode, Boolean flag2, Boolean flag3) {
-    NameSpace *mynspace;
-    ObjType *objtype;
-
-    if (!tclass && nspace->theclass && (nspace->theclass->flags & CLASS_IS_TEMPL)) {
-        CError_ASSERT(6556, !flag2);
-        return TYPE_CLASS(CTemplClass_DefineNestedClass(TEMPL_CLASS(nspace->theclass), name, mode));
-    }
-
-    mynspace = CScope_NewListNameSpace(name, 1);
-    if (!tclass) {
-        tclass = galloc(sizeof(TypeClass));
-        memclrw(tclass, sizeof(TypeClass));
-    }
-
-    tclass->type = TYPECLASS;
-    tclass->align = 1;
-    tclass->mode = mode;
-    tclass->action = CLASS_ACTION_0;
-    if (name) {
-        tclass->classname = name;
-        if (flag3) {
-            if (flag2) {
-                objtype = galloc(sizeof(ObjType));
-                memclrw(objtype, sizeof(ObjType));
-                objtype->otype = OT_TYPE;
-                objtype->access = ACCESSPUBLIC;
-                objtype->type = (Type *) tclass;
-                CScope_AddObject(nspace, name, OBJ_BASE(objtype));
-            } else {
-                CScope_DefineTypeTag(nspace, name, (Type *) tclass);
-            }
-        }
-        CScope_DefineTypeTag(mynspace, name, (Type *) tclass);
-
-        if (cscope_currentfunc)
-            mynspace->name = CParser_AppendUniqueNameFile(name->name);
-
-        if (copts.direct_to_som && nspace == cscope_root && !strcmp(name->name, "SOMObject"))
-            CSOM_MakeSOMClass(tclass);
-    } else {
-        tclass->classname = CParser_AppendUniqueNameFile("@class");
-        mynspace->name = tclass->classname;
-    }
-
-    tclass->nspace = mynspace;
-    mynspace->theclass = tclass;
-    mynspace->parent = nspace;
-    if (!nspace->is_global)
-        CParser_RegisterNonGlobalClass(tclass);
-
-    return tclass;
-}
-
-void CDecl_ParseClassDeclSpec(UInt8 *declspec) {
-    DeclInfo declinfo;
-
-    if ((tk = lex()) == '(') {
-        memclrw(&declinfo, sizeof(DeclInfo));
-        CParser_ParseDeclSpec(&declinfo, 1);
-        if (declinfo.exportflags & EXPORT_FLAGS_INTERNAL)
-            *declspec = *declspec | CLASS_EFLAGS_INTERNAL;
-        if (declinfo.exportflags & EXPORT_FLAGS_IMPORT)
-            *declspec = *declspec | CLASS_EFLAGS_IMPORT;
-        if (declinfo.exportflags & EXPORT_FLAGS_EXPORT)
-            *declspec = *declspec | CLASS_EFLAGS_EXPORT;
-        if ((tk = lex()) != ')')
-            CError_Error(CErrorStr115);
-        else
-            tk = lex();
-    } else {
-        CError_Error(CErrorStr114);
-    }
-}
-
-static TemplClass *CDecl_SpecializeTemplateClass(TemplClass *tmclass) {
-    tmclass->theclass.nspace->names = 0;
-    tmclass->theclass.nspace->data.list = NULL;
-    tmclass->theclass.ivars = NULL;
-    tmclass->theclass.bases = NULL;
-    tmclass->theclass.vbases = NULL;
-    tmclass->theclass.friends = NULL;
-    tmclass->theclass.vtable = NULL;
-    tmclass->members = NULL;
-    tmclass->instances = NULL;
-    tmclass->pspec_owner = NULL;
-    tmclass->pspecs = NULL;
-    tmclass->actions = NULL;
-    tmclass->lex_order_count = 0;
-    tmclass->align = 0;
-    tmclass->flags = TEMPLCLASS_FLAGS_2;
-    return tmclass;
-}
-
-void CDecl_ParseClass(DeclInfo *declinfo, short mode, Boolean flag1, UInt8 class_declspec) {
-    ClassLayout decle;
-    TypeClass *tclass;
-    HashNameNode *classname;
-    Type *search;
-    short t;
-    NameSpace *nspace;
-    NameResult pr;
-    CScopeSave scopesave;
-    GList gl;
-    FileOffsetInfo offsetsave;
-    SInt32 offset;
-    Boolean is_templ;
-    Boolean add_to_browse;
-
-    memclrw(&decle, sizeof(ClassLayout));
-    if (declinfo->x28) {
-        tclass = TYPE_CLASS(declinfo->x28);
-    } else {
-        if (tk == TK_UU_DECLSPEC)
-            CDecl_ParseClassDeclSpec(&class_declspec);
-
-        switch (tk) {
-            case ':':
-            case '{':
-                tclass = CDecl_DefineClass(cscope_current, NULL, NULL, mode, 0, 1);
-                tclass->eflags |= class_declspec;
-                break;
-            case TK_IDENTIFIER:
-                classname = tkidentifier;
-                if (!declinfo->in_friend_decl && !declinfo->x4F && ((t = lookahead()) == ':' || t == ';' || t == '{')) {
-                    tk = lex();
-                    search = CScope_GetLocalTagType(cscope_current, classname);
-                    if (search) {
-                        tagtype_search:
-                        if (!IS_TYPE_CLASS(search)) {
-                            if ((IS_TYPE_TEMPLATE(search) || IS_TYPE_STRUCT(search)) && tk != '{' && tk != ':') {
-                                declinfo->thetype = search;
-                                return;
-                            }
-                            if (!IS_TYPE_TEMPLATE(search) || !(tclass = TYPE_CLASS(CTemplTool_GetSelfRefTemplate(search)))) {
-                                CError_Error(CErrorStr132, classname->name);
-                                tclass = CDecl_DefineClass(cscope_current, NULL, NULL, mode, 0, 1);
-                                break;
-                            }
-                        } else {
-                            tclass = TYPE_CLASS(search);
-                        }
-                        if (tclass->mode != mode) {
-                            if (
-                                (mode == CLASS_MODE_CLASS && tclass->mode == CLASS_MODE_STRUCT) ||
-                                (mode == CLASS_MODE_STRUCT && tclass->mode == CLASS_MODE_CLASS)
-                                )
-                            {
-                                if (copts.warn_structclass)
-                                    CError_Warning(CErrorStr343);
-                            } else {
-                                CError_Error(CErrorStr132, classname);
-                            }
-                        }
-                        tclass->eflags |= class_declspec;
-                        break;
-                    } else {
-                        tclass = CDecl_DefineClass(cscope_current, classname, NULL, mode, 0, 1);
-                        tclass->eflags |= class_declspec;
-                        break;
-                    }
-                } else {
-                    tkidentifier = classname;
-                }
-            default:
-                if (!CScope_ParseElaborateName(&pr)) {
-                    CError_Error(CErrorStr121);
-                    declinfo->thetype = TYPE(&stsignedint);
-                    return;
-                }
-
-                tk = lex();
-                if ((search = pr.type)) {
-                    goto tagtype_search;
-                }
-
-                CError_ASSERT(6786, pr.name_4);
-
-                tclass = CDecl_DefineClass(CScope_FindNonClassNonFunctionNS(cscope_current), pr.name_4, NULL, mode, 0, 1);
-                tclass->eflags |= class_declspec;
-        }
-    }
-
-    declinfo->thetype = TYPE(tclass);
-    if (tk == ':' || tk == '{') {
-        if (declinfo->in_friend_decl)
-            CError_Error(CErrorStr201);
-
-        if (tclass->flags & CLASS_COMPLETED) {
-            if (
-                (tclass->flags & CLASS_IS_TEMPL) &&
-                !TEMPL_CLASS(tclass)->instances &&
-                !(TEMPL_CLASS(tclass)->flags & TEMPLCLASS_FLAGS_2)
-                )
-            {
-                tclass = TYPE_CLASS(CDecl_SpecializeTemplateClass(TEMPL_CLASS(tclass)));
-            } else {
-                CError_Error(CErrorStr132, tclass->classname->name);
-                tclass = CDecl_DefineClass(cscope_current, NULL, NULL, mode, 0, 1);
-            }
-        }
-
-        for (nspace = cscope_current; nspace; nspace = nspace->parent) {
-            if (nspace == tclass->nspace) {
-                CError_Error(CErrorStr132, tclass->classname->name);
-                tclass = CDecl_DefineClass(cscope_current, NULL, NULL, mode, 0, 1);
-                break;
-            }
-        }
-
-        is_templ = (tclass->flags & CLASS_IS_TEMPL) != 0;
-        if (tclass->flags & CLASS_IS_TEMPL_INST) {
-            TEMPL_CLASS_INST(tclass)->is_instantiated = 1;
-            if (!declinfo->x28)
-                TEMPL_CLASS_INST(tclass)->is_specialized = 1;
-        }
-
-        CError_ASSERT(6853, copts.structalignment >= 0 && copts.structalignment <= 14);
-
-        tclass->eflags = tclass->eflags | (((copts.structalignment + 1) << 4) & 0xF0);
-        if (tk == ':')
-            CDecl_ParseBaseClassList(tclass, mode, is_templ);
-
-        CScope_SetClassDefScope(tclass, &scopesave);
-        if (tk == '{') {
-            tk = lex();
-            if ((add_to_browse = cparamblkptr->browseoptions.recordClasses && declinfo->file->recordbrowseinfo)) {
-                offsetsave = member_fileoffset;
-                CBrowse_BeginClass(declinfo, &gl);
-            }
-            CDecl_ParseClassMembers(&decle, tclass, mode);
-            offset = CPrep_BrowserFileOffset();
-            if (flag1)
-                tk = lex();
-            if (add_to_browse) {
-                member_fileoffset = offsetsave;
-                if (flag1 && tk == ';')
-                    CPrep_BrowserFileOffset();
-                CBrowse_EndClass(offset, &gl);
-            }
-        } else {
-            CError_Error(CErrorStr135);
-        }
-
-        if (is_templ)
-            CTemplClass_CompleteClass(TEMPL_CLASS(tclass), &decle);
-        else
-            CDecl_CompleteClass(&decle, tclass);
-        CScope_RestoreScope(&scopesave);
-    }
-}