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

1 files changed, 0 insertions, 4206 deletions

diff --git a/compiler_and_linker/unsorted/CInline.c b/compiler_and_linker/unsorted/CInline.c
deleted file mode 100644
index de51ab7..0000000
--- a/compiler_and_linker/unsorted/CInline.c
+++ /dev/null
@@ -1,4206 +0,0 @@
-#include "compiler/CInline.h"
-#include "compiler/CABI.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/CInt64.h"
-#include "compiler/CMachine.h"
-#include "compiler/CMangler.h"
-#include "compiler/COptimizer.h"
-#include "compiler/CParser.h"
-#include "compiler/CPrepTokenizer.h"
-#include "compiler/CTemplateNew.h"
-#include "compiler/CodeGen.h"
-#include "compiler/CompilerTools.h"
-#include "compiler/Exceptions.h"
-#include "compiler/InlineAsm.h"
-#include "compiler/ObjGenMachO.h"
-#include "compiler/Switch.h"
-#include "compiler/enode.h"
-#include "compiler/objects.h"
-#include "compiler/scopes.h"
-#include "compiler/templates.h"
-
-#ifdef __MWERKS__
-#pragma options align=mac68k
-#endif
-typedef struct IDTrans {
-    struct IDTrans *next;
-    SInt32 from;
-    SInt32 to;
-} IDTrans;
-
-typedef struct LabelTrans {
-    struct LabelTrans *next;
-    CLabel **labelptr;
-    short id;
-} LabelTrans;
-
-typedef struct UIDTemp {
-    struct UIDTemp *next;
-    Object *object;
-    SInt32 uid;
-} UIDTemp;
-
-typedef struct CI_Export {
-    struct CI_Export *next;
-    Object *object;
-    CI_FuncData *funcdata;
-    Boolean xC;
-} CI_Export;
-
-typedef struct AObject {
-    Object *object;
-    ENode *expr1;
-    ENode *expr2;
-} AObject;
-
-typedef struct CI_StmtLink {
-    struct CI_StmtLink *next;
-    Statement *stmt;
-    CI_Statement *ciStmt;
-} CI_StmtLink;
-#ifdef __MWERKS__
-#pragma options align=reset
-#endif
-
-static CInlineCopyMode enode_copymode;
-static Boolean enode_globalcopy;
-static IDTrans *enode_idtrans;
-static Object **local_dobjects;
-static AObject *local_aobjects;
-static CI_Var *loc_args;
-static CI_Var *loc_vars;
-static Boolean inline_expanded;
-static Boolean any_inline_expanded;
-static short cinline_level;
-static LabelTrans *cinline_label_trans;
-static Statement *cinline_first_stmt;
-static ENode *cinline_stmtlevelexpr[16];
-static short cinline_stmtlevelexprs;
-static Boolean cinline_unconditionalpart;
-static Boolean cinline_serialize_stmt;
-static CI_Export *cinline_exportlist; // type?
-static CI_Action *cinline_actionlist;
-CI_Action *cinline_tactionlist;
-static ObjectList *cinline_freflist;
-static Boolean cinline_gendeps;
-static Statement *cinline_serial_stmt;
-static Statement *cinline_cur_serial_stmt;
-static UIDTemp *cinline_uid_temps;
-static Boolean cinline_has_sideeffect;
-static SInt32 inline_max_size;
-static Boolean recursive_inline;
-static Object *expanding_function;
-static Boolean cinline_funccallfound;
-
-// forward decls
-static ENode *CInline_FoldConst(ENode *expr);
-static ENode *CInline_CopyNodes(ENode *node);
-static SInt32 CInline_EstimateSizeOfFunc(CI_FuncData *funcdata, SInt32 size, SInt32 level);
-static ENode *CInline_SerializeExpr(ENode *expr);
-static void CInline_AddFRefList_InlineFunc(CI_FuncData *data);
-
-void CInline_Init(void) {
-    cinline_exportlist = NULL;
-    cinline_actionlist = NULL;
-    cinline_tactionlist = NULL;
-    cinline_gendeps = 0;
-}
-
-static ENode *CInline_MakeNotNot(ENode *expr) {
-    expr = CInline_FoldConst(expr);
-
-    if (!ENODE_IS(expr, EINTCONST)) {
-        expr = makemonadicnode(expr, ELOGNOT);
-        expr->rtype = CParser_GetBoolType();
-        expr = makemonadicnode(expr, ELOGNOT);
-    } else {
-        expr->data.intval = CInt64_Not(CInt64_Not(expr->data.intval));
-    }
-
-    return expr;
-}
-
-static ENode *CInline_FoldConst(ENode *expr) {
-    ENode *inner;
-    ENode *right;
-    ENode *left;
-    ENodeList *list;
-
-    switch (expr->type) {
-        case EINTCONST:
-        case EFLOATCONST:
-        case ESTRINGCONST:
-        case EOBJREF:
-        case EPRECOMP:
-        case ETEMP:
-        case ELABEL:
-        case EOBJLIST:
-        case EINSTRUCTION:
-        case EVECTOR128CONST:
-            return expr;
-
-        case EMONMIN:
-        case EBINNOT:
-        case ELOGNOT:
-            expr->data.monadic = CInline_FoldConst(expr->data.monadic);
-            inner = expr->data.monadic;
-            switch (inner->type) {
-                case EINTCONST:
-                    if (!ENODE_IS(expr, ELOGNOT)) {
-                        inner->data.intval = CMach_CalcIntMonadic(
-                            expr->rtype, CParser_GetOperator(expr->type), inner->data.intval);
-                    } else {
-                        inner->data.intval = CInt64_Not(inner->data.intval);
-                    }
-                    inner->rtype = expr->rtype;
-                    return inner;
-
-                case EFLOATCONST:
-                    if (ENODE_IS(expr, ELOGNOT)) {
-                        inner->type = EINTCONST;
-                        CInt64_SetLong(&inner->data.intval, CMach_FloatIsZero(inner->data.floatval));
-                    } else {
-                        inner->data.floatval = CMach_CalcFloatMonadic(
-                            expr->rtype, CParser_GetOperator(expr->type), inner->data.floatval);
-                    }
-                    inner->rtype = expr->rtype;
-                    return inner;
-            }
-
-            return expr;
-
-        case ETYPCON:
-            expr->data.monadic = CInline_FoldConst(expr->data.monadic);
-            switch (expr->data.monadic->type) {
-                case EINTCONST:
-                    switch (expr->rtype->type) {
-                        case TYPEFLOAT:
-                            expr->type = EFLOATCONST;
-                            expr->data.floatval = CMach_CalcFloatConvertFromInt(
-                                expr->data.monadic->rtype, expr->data.monadic->data.intval);
-                            return expr;
-
-                        case TYPEINT:
-                            expr->type = EINTCONST;
-                            expr->data.intval = CExpr_IntConstConvert(
-                                expr->rtype, expr->data.monadic->rtype, expr->data.monadic->data.intval);
-                            break;
-                    }
-                    break;
-
-                case EFLOATCONST:
-                    switch (expr->rtype->type) {
-                        case TYPEFLOAT:
-                            expr->type = EFLOATCONST;
-                            expr->data.floatval = CMach_CalcFloatConvert(
-                                expr->rtype, expr->data.monadic->data.floatval);
-                            return expr;
-
-                        case TYPEINT:
-                            expr->type = EINTCONST;
-                            expr->data.intval = CMach_CalcIntConvertFromFloat(
-                                expr->rtype, expr->data.monadic->data.floatval);
-                            return expr;
-                    }
-                    break;
-            }
-
-            return expr;
-
-        case EPOSTINC:
-        case EPOSTDEC:
-            expr->data.monadic = CInline_FoldConst(expr->data.monadic);
-            switch (expr->data.monadic->type) {
-                case EINTCONST:
-                case EFLOATCONST:
-                    expr->data.monadic->rtype = expr->rtype;
-                    return expr->data.monadic;
-            }
-
-            return expr;
-
-        case EPREINC:
-        case EPREDEC:
-        case EINDIRECT:
-        case EFORCELOAD:
-        case EBITFIELD:
-            expr->data.monadic = CInline_FoldConst(expr->data.monadic);
-            return expr;
-
-        case EMUL:
-        case EDIV:
-        case EMODULO:
-        case EADD:
-        case ESUB:
-        case ESHL:
-        case ESHR:
-        case EAND:
-        case EXOR:
-        case EOR:
-            expr->data.diadic.left = CInline_FoldConst(expr->data.diadic.left);
-            expr->data.diadic.right = CInline_FoldConst(expr->data.diadic.right);
-            if ((left = expr->data.diadic.left)->type == (right = expr->data.diadic.right)->type) {
-                switch (left->type) {
-                    case EINTCONST:
-                        left->data.intval = CMach_CalcIntDiadic(
-                            expr->rtype,
-                            expr->data.diadic.left->data.intval,
-                            CParser_GetOperator(expr->type),
-                            right->data.intval);
-                        left->rtype = expr->rtype;
-                        return left;
-
-                    case EFLOATCONST:
-                        left->data.floatval = CMach_CalcFloatDiadic(
-                            expr->rtype,
-                            expr->data.diadic.left->data.floatval,
-                            CParser_GetOperator(expr->type),
-                            right->data.floatval);
-                        left->rtype = expr->rtype;
-                        return left;
-                }
-            }
-
-            return expr;
-
-        case ELESS:
-        case EGREATER:
-        case ELESSEQU:
-        case EGREATEREQU:
-        case EEQU:
-        case ENOTEQU:
-            expr->data.diadic.left = CInline_FoldConst(expr->data.diadic.left);
-            expr->data.diadic.right = CInline_FoldConst(expr->data.diadic.right);
-            if ((left = expr->data.diadic.left)->type == (right = expr->data.diadic.right)->type) {
-                switch (left->type) {
-                    case EINTCONST:
-                        left->data.intval = CMach_CalcIntDiadic(
-                            left->rtype,
-                            expr->data.diadic.left->data.intval,
-                            CParser_GetOperator(expr->type),
-                            right->data.intval);
-                        left->rtype = expr->rtype;
-                        return left;
-
-                    case EFLOATCONST:
-                        CInt64_SetLong(&left->data.intval, CMach_CalcFloatDiadicBool(
-                            left->rtype,
-                            expr->data.diadic.left->data.floatval,
-                            CParser_GetOperator(expr->type),
-                            right->data.floatval
-                            ));
-                        left->type = EINTCONST;
-                        left->rtype = expr->rtype;
-                        return left;
-                }
-            }
-
-            return expr;
-
-        case ELAND:
-            expr->data.diadic.left = CInline_FoldConst(expr->data.diadic.left);
-            if (iszero(expr->data.diadic.left))
-                return expr->data.diadic.left;
-            if (isnotzero(expr->data.diadic.left))
-                return CInline_MakeNotNot(expr->data.diadic.right);
-
-            expr->data.diadic.right = CInline_FoldConst(expr->data.diadic.right);
-            if (isnotzero(expr->data.diadic.right))
-                return CInline_MakeNotNot(expr->data.diadic.left);
-
-            return expr;
-
-        case ELOR:
-            expr->data.diadic.left = CInline_FoldConst(expr->data.diadic.left);
-            if (iszero(expr->data.diadic.left))
-                return CInline_MakeNotNot(expr->data.diadic.right);
-            if (isnotzero(expr->data.diadic.left))
-                return CInline_MakeNotNot(expr->data.diadic.left);
-
-            expr->data.diadic.right = CInline_FoldConst(expr->data.diadic.right);
-            if (iszero(expr->data.diadic.right))
-                return CInline_MakeNotNot(expr->data.diadic.left);
-
-            return expr;
-
-        case EASS:
-        case EMULASS:
-        case EDIVASS:
-        case EMODASS:
-        case EADDASS:
-        case ESUBASS:
-        case ESHLASS:
-        case ESHRASS:
-        case EANDASS:
-        case EXORASS:
-        case EORASS:
-        case ECOMMA:
-        case EROTL:
-        case EROTR:
-            expr->data.diadic.left = CInline_FoldConst(expr->data.diadic.left);
-            expr->data.diadic.right = CInline_FoldConst(expr->data.diadic.right);
-            return expr;
-
-        case ECOND:
-            expr->data.cond.cond = CInline_FoldConst(expr->data.cond.cond);
-            if (isnotzero(expr->data.cond.cond))
-                return CInline_FoldConst(expr->data.cond.expr1);
-            if (iszero(expr->data.cond.cond))
-                return CInline_FoldConst(expr->data.cond.expr2);
-
-            expr->data.cond.expr1 = CInline_FoldConst(expr->data.cond.expr1);
-            expr->data.cond.expr2 = CInline_FoldConst(expr->data.cond.expr2);
-            return expr;
-
-        case EMFPOINTER:
-            expr->data.mfpointer.accessnode = CInline_FoldConst(expr->data.mfpointer.accessnode);
-            expr->data.mfpointer.mfpointer = CInline_FoldConst(expr->data.mfpointer.mfpointer);
-            return expr;
-
-        case EFUNCCALL:
-        case EFUNCCALLP:
-            expr->data.funccall.funcref = CInline_FoldConst(expr->data.funccall.funcref);
-            for (list = expr->data.funccall.args; list; list = list->next)
-                list->node = CInline_FoldConst(list->node);
-            return expr;
-
-        case ENULLCHECK:
-            expr->data.nullcheck.nullcheckexpr = CInline_FoldConst(expr->data.nullcheck.nullcheckexpr);
-            expr->data.nullcheck.condexpr = CInline_FoldConst(expr->data.nullcheck.condexpr);
-            return expr;
-
-        case EMEMBER:
-            if (expr->data.emember->expr)
-                expr->data.emember->expr = CInline_FoldConst(expr->data.emember->expr);
-            return expr;
-
-        default:
-            CError_FATAL(421);
-            return expr;
-    }
-}
-
-// unknown name
-CW_INLINE SInt32 CInline_GetLocalID2(Object *object) {
-    ObjectList *list;
-    SInt32 counter;
-
-    for (list = locals, counter = 0; list; list = list->next) {
-        if (list->object->datatype == DLOCAL) {
-            if (list->object == object)
-                return counter;
-            counter++;
-        }
-    }
-
-    return -1;
-}
-
-SInt32 CInline_GetLocalID(Object *object) {
-    ObjectList *list;
-    SInt32 counter;
-
-    if (object) {
-        for (list = arguments, counter = 0; list; list = list->next, counter++) {
-            if (list->object == object) {
-                loc_args[counter].xD = 1;
-                loc_args[counter].xE = 0;
-                return counter - 0x7FFFFFFF;
-            }
-        }
-
-        counter = CInline_GetLocalID2(object);
-        CError_ASSERT(465, counter >= 0);
-        loc_vars[counter].xD = 1;
-        return counter + 1;
-    }
-
-    return 0;
-}
-
-static Boolean CInline_IsTrivialExpression(ENode *expr) {
-    while (1) {
-        switch (expr->type) {
-            case EINTCONST:
-            case EFLOATCONST:
-            case EOBJREF:
-            case EARGOBJ:
-            case ELOCOBJ:
-            case EOBJLIST:
-            case EVECTOR128CONST:
-                return 0;
-
-            case ESTRINGCONST:
-                return copts.dont_reuse_strings;
-
-            case EMEMBER:
-                if (expr->data.emember->expr)
-                    return CInline_IsTrivialExpression(expr->data.emember->expr);
-                return 0;
-
-            case EINDIRECT:
-                if (ENODE_IS(expr->data.monadic, EOBJREF)) {
-                    if (expr->data.monadic->data.objref->datatype == DLOCAL &&
-                        !(expr->data.monadic->data.objref->flags & OBJECT_FLAGS_2))
-                        return 0;
-
-                    if (is_const_object(expr->data.monadic->data.objref))
-                        return 0;
-
-                    return 1;
-                }
-
-                return 1;
-
-            case EPOSTINC:
-            case EPOSTDEC:
-            case EPREINC:
-            case EPREDEC:
-            case EFORCELOAD:
-            case EASS:
-            case EMULASS:
-            case EDIVASS:
-            case EMODASS:
-            case EADDASS:
-            case ESUBASS:
-            case ESHLASS:
-            case ESHRASS:
-            case EANDASS:
-            case EXORASS:
-            case EORASS:
-            case EFUNCCALL:
-            case EFUNCCALLP:
-            case EMFPOINTER:
-            case ENULLCHECK:
-            case EPRECOMP:
-            case ETEMP:
-            case ELABEL:
-            case EINSTRUCTION:
-                return 1;
-
-            case EMONMIN:
-            case EBINNOT:
-            case ELOGNOT:
-            case ETYPCON:
-            case EBITFIELD:
-                expr = expr->data.monadic;
-                continue;
-
-            case EMUL:
-            case EDIV:
-            case EMODULO:
-            case EADD:
-            case ESUB:
-            case ESHL:
-            case ESHR:
-            case ELESS:
-            case EGREATER:
-            case ELESSEQU:
-            case EGREATEREQU:
-            case EEQU:
-            case ENOTEQU:
-            case EAND:
-            case EXOR:
-            case EOR:
-            case ELAND:
-            case ELOR:
-            case ECOMMA:
-            case EROTL:
-            case EROTR:
-                if (CInline_IsTrivialExpression(expr->data.diadic.left))
-                    return 1;
-                expr = expr->data.diadic.right;
-                continue;
-
-            case ECOND:
-                if (CInline_IsTrivialExpression(expr->data.cond.cond))
-                    return 1;
-                if (CInline_IsTrivialExpression(expr->data.cond.expr1))
-                    return 1;
-                expr = expr->data.cond.expr2;
-                continue;
-
-            default:
-                CError_FATAL(582);
-        }
-    }
-}
-
-Boolean CInline_ExpressionHasSideEffect(ENode *expr) {
-    while (1) {
-        switch (expr->type) {
-            case EINTCONST:
-            case EFLOATCONST:
-            case ESTRINGCONST:
-            case EOBJREF:
-            case EPRECOMP:
-            case ETEMP:
-            case EARGOBJ:
-            case ELOCOBJ:
-            case ELABEL:
-            case EOBJLIST:
-            case EVECTOR128CONST:
-                return 0;
-
-            case EPOSTINC:
-            case EPOSTDEC:
-            case EPREINC:
-            case EPREDEC:
-            case EASS:
-            case EMULASS:
-            case EDIVASS:
-            case EMODASS:
-            case EADDASS:
-            case ESUBASS:
-            case ESHLASS:
-            case ESHRASS:
-            case EANDASS:
-            case EXORASS:
-            case EORASS:
-            case EFUNCCALL:
-            case EFUNCCALLP:
-            case EINSTRUCTION:
-                return 1;
-
-            case EINDIRECT:
-            case EMONMIN:
-            case EBINNOT:
-            case ELOGNOT:
-            case EFORCELOAD:
-            case ETYPCON:
-            case EBITFIELD:
-                expr = expr->data.monadic;
-                continue;
-
-            case EMUL:
-            case EDIV:
-            case EMODULO:
-            case EADD:
-            case ESUB:
-            case ESHL:
-            case ESHR:
-            case ELESS:
-            case EGREATER:
-            case ELESSEQU:
-            case EGREATEREQU:
-            case EEQU:
-            case ENOTEQU:
-            case EAND:
-            case EXOR:
-            case EOR:
-            case ELAND:
-            case ELOR:
-            case ECOMMA:
-            case EROTL:
-            case EROTR:
-                if (CInline_ExpressionHasSideEffect(expr->data.diadic.left))
-                    return 1;
-                expr = expr->data.diadic.right;
-                continue;
-
-            case EMEMBER:
-                if (expr->data.emember->expr)
-                    return CInline_ExpressionHasSideEffect(expr->data.emember->expr);
-                return 0;
-
-            case EMFPOINTER:
-                if (CInline_ExpressionHasSideEffect(expr->data.mfpointer.accessnode))
-                    return 1;
-                expr = expr->data.mfpointer.mfpointer;
-                continue;
-
-            case ENULLCHECK:
-                if (CInline_ExpressionHasSideEffect(expr->data.nullcheck.nullcheckexpr))
-                    return 1;
-                expr = expr->data.nullcheck.condexpr;
-                continue;
-
-            case ECOND:
-                if (CInline_ExpressionHasSideEffect(expr->data.cond.cond))
-                    return 1;
-                if (CInline_ExpressionHasSideEffect(expr->data.cond.expr1))
-                    return 1;
-                expr = expr->data.cond.expr2;
-                continue;
-
-            default:
-                CError_FATAL(689);
-        }
-    }
-}
-
-static ENode *CInline_CopyExpressionSave(ENode *expr) {
-    CInlineCopyMode save_copymode;
-    Boolean save_globalcopy;
-    IDTrans *save_idtrans;
-
-    save_globalcopy = enode_globalcopy;
-    enode_globalcopy = 1;
-
-    save_copymode = enode_copymode;
-    enode_copymode = CopyMode4;
-
-    save_idtrans = enode_idtrans;
-    enode_idtrans = NULL;
-
-    expr = CInline_CopyNodes(expr);
-
-    enode_globalcopy = save_globalcopy;
-    enode_copymode = save_copymode;
-    enode_idtrans = save_idtrans;
-
-    return expr;
-}
-
-static SInt32 CInline_TranslateID(SInt32 id) {
-    IDTrans *trans;
-
-    for (trans = enode_idtrans; trans; trans = trans->next) {
-        if (trans->from == id)
-            return trans->to;
-    }
-
-    trans = lalloc(sizeof(IDTrans));
-    trans->next = enode_idtrans;
-    enode_idtrans = trans;
-
-    trans->from = id;
-    trans->to = CParser_GetUniqueID();
-
-    return trans->to;
-}
-
-static short CInline_GetLabelStatementNumber(HashNameNode *name) {
-    Statement *stmt;
-    short i;
-
-    for (stmt = cinline_first_stmt, i = 0; stmt; stmt = stmt->next, i++) {
-        if (stmt->type == ST_LABEL && stmt->label->uniquename == name)
-            return i;
-    }
-
-    CError_FATAL(742);
-    return 0;
-}
-
-static ENodeList *CInline_CopyNodeList(ENodeList *list) {
-    ENodeList *copy;
-    ENodeList *first;
-    ENodeList *last;
-
-    first = NULL;
-    while (list) {
-        if (enode_globalcopy)
-            copy = galloc(sizeof(ENodeList));
-        else
-            copy = lalloc(sizeof(ENodeList));
-
-        copy->node = CInline_CopyNodes(list->node);
-        copy->next = NULL;
-
-        if (first) {
-            last->next = copy;
-            last = copy;
-        } else {
-            first = last = copy;
-        }
-
-        list = list->next;
-    }
-
-    return first;
-}
-
-static EMemberInfo *CInline_CopyEMemberInfo(EMemberInfo *mi) {
-    EMemberInfo *copy;
-
-    if (enode_globalcopy)
-        copy = galloc(sizeof(EMemberInfo));
-    else
-        copy = lalloc(sizeof(EMemberInfo));
-
-    *copy = *mi;
-    if (copy->path)
-        copy->path = CClass_GetPathCopy(copy->path, enode_globalcopy);
-    if (copy->expr)
-        copy->expr = CInline_CopyNodes(copy->expr);
-
-    return copy;
-}
-
-static ENode *CInline_CopyNodes(ENode *node) {
-    ENode *copy;
-
-    if (enode_globalcopy)
-        copy = galloc(sizeof(ENode));
-    else
-        copy = lalloc(sizeof(ENode));
-
-    while (1) {
-        *copy = *node;
-        switch (copy->type) {
-            case ETEMPLDEP:
-                switch (copy->data.templdep.subtype) {
-                    case TDE_PARAM:
-                    case TDE_SIZEOF:
-                    case TDE_ALIGNOF:
-                    case TDE_QUALNAME:
-                    case TDE_OBJ:
-                        break;
-                    case TDE_CAST:
-                        copy->data.templdep.u.cast.args = CInline_CopyNodeList(copy->data.templdep.u.cast.args);
-                        break;
-                    case TDE_SOURCEREF:
-                        copy->data.templdep.u.sourceref.expr = CInline_CopyNodes(copy->data.templdep.u.sourceref.expr);
-                        break;
-                    case TDE_ADDRESS_OF:
-                        copy->data.templdep.u.monadic = CInline_CopyNodes(copy->data.templdep.u.monadic);
-                        break;
-                    default:
-                        CError_FATAL(840);
-                }
-                break;
-
-            case ETEMP:
-                if (enode_copymode == CopyMode3 && copy->data.temp.uniqueid)
-                    copy->data.temp.uniqueid = CInline_TranslateID(copy->data.temp.uniqueid);
-                break;
-
-            case ELABEL:
-                switch (enode_copymode) {
-                    case CopyMode2:
-                        copy->data.precompid = CInline_GetLabelStatementNumber(copy->data.label->uniquename);
-                        return copy;
-                    case CopyMode3:
-                    case CopyMode4: {
-                        LabelTrans *trans = lalloc(sizeof(LabelTrans));
-                        trans->next = cinline_label_trans;
-                        cinline_label_trans = trans;
-                        trans->id = copy->data.precompid;
-                        trans->labelptr = &copy->data.label;
-                        return copy;
-                    }
-                }
-                break;
-
-            case EINTCONST:
-            case EFLOATCONST:
-            case ESTRINGCONST:
-            case EOBJLIST:
-            case EINSTRUCTION:
-            case EVECTOR128CONST:
-                break;
-
-            case EPOSTINC:
-            case EPOSTDEC:
-            case EPREINC:
-            case EPREDEC:
-            case EMONMIN:
-            case EBINNOT:
-            case ELOGNOT:
-            case EFORCELOAD:
-            case ETYPCON:
-            case EBITFIELD:
-                copy->data.monadic = CInline_CopyNodes(copy->data.monadic);
-                break;
-
-            ENODE_CASE_DIADIC_ALL:
-                copy->data.diadic.left = CInline_CopyNodes(copy->data.diadic.left);
-                copy->data.diadic.right = CInline_CopyNodes(copy->data.diadic.right);
-                break;
-
-            case ECOND:
-                copy->data.cond.cond = CInline_CopyNodes(copy->data.cond.cond);
-                copy->data.cond.expr1 = CInline_CopyNodes(copy->data.cond.expr1);
-                copy->data.cond.expr2 = CInline_CopyNodes(copy->data.cond.expr2);
-                break;
-
-            case EMFPOINTER:
-                copy->data.mfpointer.accessnode = CInline_CopyNodes(copy->data.mfpointer.accessnode);
-                copy->data.mfpointer.mfpointer = CInline_CopyNodes(copy->data.mfpointer.mfpointer);
-                break;
-
-            case EFUNCCALL:
-            case EFUNCCALLP:
-                copy->data.funccall.funcref = CInline_CopyNodes(copy->data.funccall.funcref);
-                copy->data.funccall.args = CInline_CopyNodeList(copy->data.funccall.args);
-                break;
-
-            case ENULLCHECK:
-                copy->data.nullcheck.precompid = CInline_TranslateID(copy->data.nullcheck.precompid);
-                copy->data.nullcheck.nullcheckexpr = CInline_CopyNodes(copy->data.nullcheck.nullcheckexpr);
-                copy->data.nullcheck.condexpr = CInline_CopyNodes(copy->data.nullcheck.condexpr);
-                break;
-
-            case EPRECOMP:
-                copy->data.precompid = CInline_TranslateID(copy->data.precompid);
-                break;
-
-            case EINDIRECT:
-                if (
-                    enode_copymode == CopyMode4 &&
-                    ENODE_IS(copy->data.monadic, EARGOBJ) &&
-                    local_aobjects[copy->data.monadic->data.longval].object == NULL
-                    )
-                {
-                    CError_ASSERT(910, local_aobjects[copy->data.monadic->data.longval].expr1);
-                    copy = CInline_CopyExpressionSave(local_aobjects[copy->data.monadic->data.longval].expr1);
-                    if (copy->rtype != node->rtype) {
-                        if (IS_TYPE_INT(copy->rtype) && IS_TYPE_INT(node->rtype))
-                            copy = makemonadicnode(copy, ETYPCON);
-                        copy->rtype = node->rtype;
-                    }
-                    return copy;
-                }
-
-                copy->data.monadic = CInline_CopyNodes(copy->data.monadic);
-                break;
-
-            case EOBJREF:
-                if (enode_copymode == CopyMode2) {
-                    ObjectList *list;
-                    int i;
-
-                    if (node->data.objref->datatype == DALIAS) {
-                        CExpr_AliasTransform(node);
-                        continue;
-                    }
-
-                    if (node->data.objref->datatype == DDATA)
-                        return copy;
-
-                    for (list = arguments, i = 0; list; list = list->next, i++) {
-                        if (list->object == copy->data.objref) {
-                            copy->type = EARGOBJ;
-                            copy->data.longval = i;
-                            return copy;
-                        }
-                    }
-
-                    i = CInline_GetLocalID2(copy->data.objref);
-                    if (i >= 0) {
-                        copy->type = ELOCOBJ;
-                        copy->data.longval = i;
-                        return copy;
-                    }
-
-                    if (node->data.objref->datatype == DLOCAL)
-                        CError_FATAL(949);
-                }
-                break;
-
-            case EARGOBJ:
-                switch (enode_copymode) {
-                    case CopyMode4:
-                        CError_ASSERT(957, local_aobjects[copy->data.longval].object);
-                        copy->type = EOBJREF;
-                        copy->data.objref = local_aobjects[copy->data.longval].object;
-                        return copy;
-
-                    case CopyMode3: {
-                        ObjectList *list;
-                        int i;
-                        for (list = arguments, i = 0; list; list = list->next, i++) {
-                            if (i == copy->data.longval) {
-                                copy->type = EOBJREF;
-                                copy->data.objref = list->object;
-                                CError_ASSERT(966, copy->data.objref);
-                                return copy;
-                            }
-                        }
-                    }
-
-                    default:
-                        CError_FATAL(971);
-                }
-
-            case ELOCOBJ:
-                switch (enode_copymode) {
-                    case CopyMode4:
-                        copy->type = EOBJREF;
-                        copy->data.objref = local_dobjects[copy->data.longval];
-                        return copy;
-
-                    case CopyMode3: {
-                        ObjectList *list;
-                        int i;
-                        for (list = locals, i = 0; list; list = list->next, i++) {
-                            if (i == copy->data.longval) {
-                                copy->type = EOBJREF;
-                                copy->data.objref = list->object;
-                                CError_ASSERT(986, copy->data.objref);
-                                return copy;
-                            }
-                        }
-                    }
-
-                    default:
-                        CError_FATAL(991);
-                }
-                break;
-
-            case ENEWEXCEPTION:
-            case ENEWEXCEPTIONARRAY:
-                copy->data.newexception.initexpr = CInline_CopyNodes(copy->data.newexception.initexpr);
-                copy->data.newexception.tryexpr = CInline_CopyNodes(copy->data.newexception.tryexpr);
-                break;
-
-            case EINITTRYCATCH:
-                copy->data.itc.initexpr = CInline_CopyNodes(copy->data.itc.initexpr);
-                copy->data.itc.tryexpr = CInline_CopyNodes(copy->data.itc.tryexpr);
-                copy->data.itc.catchexpr = CInline_CopyNodes(copy->data.itc.catchexpr);
-                copy->data.itc.result = CInline_CopyNodes(copy->data.itc.result);
-                break;
-
-            case EMEMBER:
-                copy->data.emember = CInline_CopyEMemberInfo(copy->data.emember);
-                break;
-
-            default:
-                CError_FATAL(1015);
-        }
-
-        return copy;
-    }
-}
-
-static void CInline_CheckUsage(ENode *expr, Boolean flag) {
-    ENodeList *list;
-    ENode *inner;
-
-    while (1) {
-        switch (expr->type) {
-            case EARGOBJ:
-                loc_args[expr->data.longval].xD = 1;
-                loc_args[expr->data.longval].xE = 0;
-                return;
-
-            case ELOCOBJ:
-                loc_vars[expr->data.longval].xD = 1;
-                return;
-
-            case EINDIRECT:
-                if (ENODE_IS((inner = expr->data.monadic), EARGOBJ)) {
-                    loc_args[inner->data.longval].xD = 1;
-                    if (flag)
-                        loc_args[inner->data.longval].xE = 0;
-                    return;
-                }
-                expr = expr->data.monadic;
-                flag = 0;
-                continue;
-
-            case EMONMIN:
-            case EBINNOT:
-            case ELOGNOT:
-            case EFORCELOAD:
-            case ETYPCON:
-            case EBITFIELD:
-                expr = expr->data.monadic;
-                flag = 0;
-                continue;
-
-            case EPOSTINC:
-            case EPOSTDEC:
-            case EPREINC:
-            case EPREDEC:
-                expr = expr->data.monadic;
-                flag = 1;
-                continue;
-
-            case EASS:
-            case EMULASS:
-            case EDIVASS:
-            case EMODASS:
-            case EADDASS:
-            case ESUBASS:
-            case ESHLASS:
-            case ESHRASS:
-            case EANDASS:
-            case EXORASS:
-            case EORASS:
-                CInline_CheckUsage(expr->data.diadic.left, 1);
-                expr = expr->data.diadic.right;
-                flag = 0;
-                continue;
-
-            case EMUL:
-            case EDIV:
-            case EMODULO:
-            case EADD:
-            case ESUB:
-            case ESHL:
-            case ESHR:
-            case ELESS:
-            case EGREATER:
-            case ELESSEQU:
-            case EGREATEREQU:
-            case EEQU:
-            case ENOTEQU:
-            case EAND:
-            case EXOR:
-            case EOR:
-            case ELAND:
-            case ELOR:
-            case ECOMMA:
-            case EROTL:
-            case EROTR:
-                CInline_CheckUsage(expr->data.diadic.left, 0);
-                expr = expr->data.diadic.right;
-                flag = 0;
-                continue;
-
-            case EINTCONST:
-            case EFLOATCONST:
-            case ESTRINGCONST:
-            case EOBJREF:
-            case EPRECOMP:
-            case ETEMP:
-            case ELABEL:
-            case EOBJLIST:
-            case EVECTOR128CONST:
-                return;
-
-            case EMEMBER:
-                if (expr->data.emember->expr)
-                    CInline_CheckUsage(expr->data.emember->expr, 0);
-                return;
-
-            case EFUNCCALL:
-            case EFUNCCALLP:
-                CInline_CheckUsage(expr->data.funccall.funcref, 0);
-                for (list = expr->data.funccall.args; list; list = list->next)
-                    CInline_CheckUsage(list->node, 0);
-                return;
-
-            case ENULLCHECK:
-                CInline_CheckUsage(expr->data.nullcheck.nullcheckexpr, 0);
-                expr = expr->data.nullcheck.condexpr;
-                flag = 0;
-                continue;
-
-            case EMFPOINTER:
-                CInline_CheckUsage(expr->data.mfpointer.accessnode, 0);
-                expr = expr->data.mfpointer.mfpointer;
-                flag = 0;
-                continue;
-
-            case ECOND:
-                CInline_CheckUsage(expr->data.cond.cond, 0);
-                CInline_CheckUsage(expr->data.cond.expr1, 0);
-                expr = expr->data.cond.expr2;
-                flag = 0;
-                continue;
-
-            case EINSTRUCTION:
-                return;
-
-            default:
-                CError_FATAL(1146);
-        }
-    }
-}
-
-ENode *CInline_CopyExpression(ENode *expr, CInlineCopyMode mode) {
-    enode_copymode = mode;
-
-    switch (mode) {
-        case CopyMode0:
-        case CopyMode4:
-            enode_idtrans = NULL;
-            enode_globalcopy = 0;
-            expr = CInline_CopyNodes(expr);
-            break;
-        case CopyMode3:
-            enode_globalcopy = 0;
-            expr = CInline_CopyNodes(expr);
-            break;
-        case CopyMode1:
-            enode_idtrans = NULL;
-            enode_globalcopy = 1;
-            expr = CInline_CopyNodes(expr);
-            break;
-        case CopyMode2:
-            enode_idtrans = NULL;
-            enode_globalcopy = 1;
-            expr = CInline_CopyNodes(expr);
-            CInline_CheckUsage(expr, 0);
-            break;
-    }
-
-    return expr;
-}
-
-static UInt8 CInline_GetObjectSFlags(Object *object) {
-    UInt8 flags;
-
-    switch (object->sclass) {
-        case 0:
-            flags = CI_SFLAGS_NoClass;
-            break;
-        case TK_REGISTER:
-            flags = CI_SFLAGS_Register;
-            break;
-        case TK_AUTO:
-            flags = CI_SFLAGS_Auto;
-            break;
-        default:
-            CError_FATAL(1204);
-    }
-
-    if (object->flags & OBJECT_FLAGS_2)
-        flags |= CI_SFLAGS_HasObjectFlag2;
-
-    return flags;
-}
-
-static void CInline_SetObjectSFlags(Object *object, UInt8 sflags) {
-    if (sflags & CI_SFLAGS_HasObjectFlag2) {
-        object->flags |= OBJECT_FLAGS_2;
-        sflags &= ~CI_SFLAGS_HasObjectFlag2;
-    }
-
-    switch (sflags) {
-        case CI_SFLAGS_NoClass:
-            object->sclass = 0;
-            break;
-        case CI_SFLAGS_Register:
-            object->sclass = TK_REGISTER;
-            break;
-        case CI_SFLAGS_Auto:
-            object->sclass = TK_AUTO;
-            break;
-        default:
-            CError_FATAL(1229);
-    }
-}
-
-static Object *CInline_NewLocalObject(Type *type, short qual, UInt8 sflags, int unk) {
-    Object *object = CParser_NewLocalDataObject(NULL, 1);
-    object->name = CParser_GetUniqueName();
-    object->type = type;
-    object->qual = qual;
-    CInline_SetObjectSFlags(object, sflags);
-    CFunc_SetupLocalVarInfo(object);
-    return object;
-}
-
-static ENode *CInline_FuncArgConvert(ENode *expr) {
-    ENode *copy;
-
-    switch (expr->type) {
-        case EOBJREF:
-            copy = lalloc(sizeof(ENode));
-            *copy = *expr;
-            return copy;
-        case ETEMP:
-            CError_FATAL(1272);
-    }
-
-    return NULL;
-}
-
-static ENode *CInline_RefArgTransform(ENode *expr, Boolean flag) {
-    ENodeList *arg;
-
-    while (ENODE_IS(expr, ECOMMA))
-        expr = expr->data.diadic.right;
-
-    switch (expr->type) {
-        case EOBJREF:
-        case ETEMP:
-            if (flag)
-                return CInline_FuncArgConvert(expr);
-            break;
-
-        case EFUNCCALL:
-            if (IS_TYPE_POINTER_ONLY(expr->rtype) && IS_TYPE_CLASS(TPTR_TARGET(expr->rtype))) {
-                if (
-                    ENODE_IS(expr->data.funccall.funcref, EOBJREF) &&
-                    CClass_IsConstructor(expr->data.funccall.funcref->data.objref) &&
-                    expr->data.funccall.args
-                    )
-                    return CInline_FuncArgConvert(expr->data.funccall.args->node);
-
-                if (
-                    TPTR_TARGET(expr->rtype) == expr->data.funccall.functype->functype &&
-                    CMach_GetFunctionResultClass(expr->data.funccall.functype) == 1 &&
-                    (arg = expr->data.funccall.args)
-                    )
-                {
-                    switch (CABI_GetStructResultArgumentIndex(expr->data.funccall.functype)) {
-                        case 0:
-                            break;
-                        case 1:
-                            if ((arg = arg->next))
-                                break;
-                            CError_FATAL(1313);
-                        default:
-                            CError_FATAL(1314);
-                    }
-
-                    return CInline_FuncArgConvert(arg->node);
-                }
-            }
-            break;
-    }
-
-    return NULL;
-}
-
-static ENode *CInline_SetupArgsExpression(Object *object, CI_FuncData *data, ENodeList *list) {
-    ENode *commaNodes;
-    CI_Var *var;
-    ENodeList *scan;
-    ENode *expr;
-    SInt32 i;
-    Boolean is_oldstyle;
-
-    is_oldstyle = 0;
-    if (TYPE_FUNC(object->type)->args == &oldstyle)
-        is_oldstyle = 1;
-
-    local_dobjects = lalloc(sizeof(Object *) * data->numlocals);
-    local_aobjects = lalloc(sizeof(AObject) * data->numarguments);
-
-    for (i = 0, var = data->locals; i < data->numlocals; i++, var++) {
-        if (var->xD) {
-            object = CInline_NewLocalObject(var->type, var->qual, var->sflags, 0);
-            local_dobjects[i] = object;
-            if (!var->xE)
-                object->flags |= OBJECT_FLAGS_2;
-        } else {
-            local_dobjects[i] = NULL;
-        }
-    }
-
-    for (i = 0, var = data->arguments, scan = list; i < data->numarguments; i++, var++) {
-        local_aobjects[i].expr2 = NULL;
-
-        if (!var->xD) {
-            local_aobjects[i].object = NULL;
-            local_aobjects[i].expr1 = NULL;
-        } else if (
-            scan &&
-            var->xE &&
-            !CInline_IsTrivialExpression(scan->node) &&
-            (!is_oldstyle || scan->node->rtype->size == var->type->size)
-            )
-        {
-            local_aobjects[i].object = NULL;
-            local_aobjects[i].expr1 = scan->node;
-        } else if (
-            scan &&
-            var->xE &&
-            IS_TYPE_REFERENCE(var->type) &&
-            (expr = CInline_RefArgTransform(scan->node, 1))
-            )
-        {
-            local_aobjects[i].object = NULL;
-            local_aobjects[i].expr1 = expr;
-            local_aobjects[i].expr2 = scan->node;
-        } else {
-            local_aobjects[i].object = CInline_NewLocalObject(var->type, var->qual, var->sflags, 0);
-            local_aobjects[i].expr1 = NULL;
-        }
-
-        if (scan)
-            scan = scan->next;
-    }
-
-    commaNodes = NULL;
-
-    for (i = 0, scan = list; scan; scan = scan->next, i++) {
-        if (i >= data->numarguments) {
-            if (!commaNodes)
-                commaNodes = scan->node;
-            else
-                commaNodes = makecommaexpression(scan->node, commaNodes);
-        } else if (!local_aobjects[i].object || local_aobjects[i].expr2) {
-            if (local_aobjects[i].expr2) {
-                if (!commaNodes)
-                    commaNodes = local_aobjects[i].expr2;
-                else
-                    commaNodes = makecommaexpression(local_aobjects[i].expr2, commaNodes);
-            } else if (!local_aobjects[i].expr1 && CInline_IsTrivialExpression(scan->node)) {
-                commaNodes = !commaNodes ? scan->node : makecommaexpression(scan->node, commaNodes);
-                CError_ASSERT(1470, !ENODE_IS(scan->node, EPRECOMP));
-            }
-        } else {
-            if (is_oldstyle && scan->node->rtype->size != local_aobjects[i].object->type->size) {
-                scan->node = makemonadicnode(scan->node, ETYPCON);
-                scan->node->rtype = local_aobjects[i].object->type;
-            }
-
-            expr = makediadicnode(create_objectnode2(local_aobjects[i].object), scan->node, EASS);
-            if (!commaNodes)
-                commaNodes = expr;
-            else
-                commaNodes = makecommaexpression(expr, commaNodes);
-        }
-    }
-
-    return commaNodes;
-}
-
-static void CInline_ReturnCheckCB(ENode *expr) {
-    cinline_has_sideeffect = 1;
-}
-
-static ENode *CInline_ReturnCheck(ENode *expr) {
-    ENode *copy;
-
-    if (ENODE_IS(expr, EFORCELOAD))
-        return expr;
-
-    cinline_has_sideeffect = 0;
-    CExpr_SearchExprTree(expr, CInline_ReturnCheckCB, 3, EINDIRECT, EFUNCCALL, EFUNCCALLP);
-
-    if (!cinline_has_sideeffect)
-        return expr;
-
-    copy = lalloc(sizeof(ENode));
-    *copy = *expr;
-    copy->type = EFORCELOAD;
-
-    copy->data.monadic = expr;
-    return copy;
-}
-
-static ENode *CInline_ReturnMemResult(Object *object) {
-    int index = CABI_GetStructResultArgumentIndex(TYPE_FUNC(object->type));
-    if (local_aobjects[index].object == NULL)
-        return CInline_CopyExpressionSave(local_aobjects[index].expr1);
-    else
-        return create_objectnode(local_aobjects[index].object);
-}
-
-static ENode *CInline_InlineFunctionExpression(ENode *expr) {
-    Object *object;
-    CI_FuncData *funcdata;
-    short i;
-    Boolean flag26;
-    ENode *argsExpr;
-
-    object = expr->data.funccall.funcref->data.objref;
-    if (object->datatype == DALIAS)
-        object = object->u.alias.object;
-
-    funcdata = object->u.func.u.ifuncdata;
-    if (!funcdata)
-        return expr;
-
-    if (funcdata->can_inline < CI_CanInline6) {
-        if (funcdata->can_inline == CI_CanInline3) {
-            if (cinline_unconditionalpart && cinline_stmtlevelexprs < 16)
-                cinline_stmtlevelexpr[cinline_stmtlevelexprs++] = expr;
-            cinline_serialize_stmt = 1;
-        }
-        return expr;
-    }
-
-    flag26 = CMach_GetFunctionResultClass(TYPE_FUNC(object->type)) == 1;
-    argsExpr = CInline_SetupArgsExpression(object, funcdata, expr->data.funccall.args);
-
-    for (i = 0; i < funcdata->numstatements; i++) {
-        switch (funcdata->statements[i].type) {
-            case ST_RETURN:
-                if (funcdata->statements[i].u.expr) {
-                    ENode *copy = CInline_CopyExpression(funcdata->statements[i].u.expr, CopyMode4);
-                    if (flag26) {
-                        if (argsExpr)
-                            argsExpr = makecommaexpression(argsExpr, copy);
-                        else
-                            argsExpr = copy;
-
-                        argsExpr = makecommaexpression(argsExpr, CInline_ReturnMemResult(object));
-                    } else {
-                        if (argsExpr)
-                            argsExpr = makecommaexpression(argsExpr, CInline_ReturnCheck(copy));
-                        else
-                            argsExpr = CInline_ReturnCheck(copy);
-                    }
-                }
-                break;
-            case ST_EXPRESSION:
-                if (argsExpr)
-                    argsExpr = makecommaexpression(argsExpr, CInline_CopyExpression(funcdata->statements[i].u.expr, CopyMode4));
-                else
-                    argsExpr = CInline_CopyExpression(funcdata->statements[i].u.expr, CopyMode4);
-                break;
-
-            default:
-                CError_FATAL(1632);
-        }
-    }
-
-    if (!argsExpr)
-        argsExpr = nullnode();
-    if (!IS_TYPE_VOID(expr->rtype))
-        argsExpr->rtype = expr->rtype;
-
-    inline_expanded = 1;
-    return CInline_FoldConst(argsExpr);
-}
-
-static Boolean CInline_CanExpand(ENode *expr) {
-    TypeFunc *tfunc;
-    Object *object;
-
-    object = expr->data.objref;
-    tfunc = TYPE_FUNC(object->type);
-
-    if (
-        IS_TYPE_FUNC(tfunc) &&
-        ((object->qual & Q_INLINE) || (tfunc->flags & FUNC_FLAGS_800)) &&
-        (object->datatype == DFUNC || (object->datatype == DVFUNC && (expr->flags & ENODE_FLAG_80)))
-        )
-        return 1;
-
-    return 0;
-}
-
-static SInt32 CInline_EstimateSizeOfExpr(ENode *expr, SInt32 size, SInt32 level) {
-    ENodeList *list;
-
-    switch (expr->type) {
-        ENODE_CASE_MONADIC:
-            size = CInline_EstimateSizeOfExpr(expr->data.monadic, size, level) + 1;
-            break;
-
-        ENODE_CASE_DIADIC_ALL:
-            size = CInline_EstimateSizeOfExpr(expr->data.diadic.left, size, level);
-            if (size <= inline_max_size)
-                size = CInline_EstimateSizeOfExpr(expr->data.diadic.right, size, level) + 1;
-            break;
-
-        case EFUNCCALL:
-        case EFUNCCALLP:
-            if (
-                ENODE_IS(expr->data.funccall.funcref, EOBJREF) &&
-                expr->data.funccall.funcref->data.objref->u.func.u.ifuncdata &&
-                CInline_CanExpand(expr->data.funccall.funcref)
-                )
-            {
-                recursive_inline |= expr->data.funccall.funcref->data.objref == expanding_function;
-                if (level == 0) {
-                    if (!recursive_inline)
-                        size = inline_max_size + 1;
-                } else {
-                    size = CInline_EstimateSizeOfFunc(expr->data.funccall.funcref->data.objref->u.func.u.ifuncdata, size, level - 1);
-                }
-            } else {
-                size++;
-            }
-
-            for (list = expr->data.funccall.args; list; list = list->next) {
-                if (size > inline_max_size)
-                    break;
-
-                size = CInline_EstimateSizeOfExpr(list->node, size, level);
-            }
-            break;
-
-        case ECOND:
-            size = CInline_EstimateSizeOfExpr(expr->data.cond.cond, size, level);
-            if (size <= inline_max_size)
-                size = CInline_EstimateSizeOfExpr(expr->data.cond.expr1, size, level) + 1;
-            if (size <= inline_max_size)
-                size = CInline_EstimateSizeOfExpr(expr->data.cond.expr2, size, level) + 1;
-            break;
-
-        case ENULLCHECK:
-            size = CInline_EstimateSizeOfExpr(expr->data.nullcheck.nullcheckexpr, size, level);
-            if (size <= inline_max_size)
-                size = CInline_EstimateSizeOfExpr(expr->data.nullcheck.condexpr, size, level) + 1;
-            break;
-
-        case EMFPOINTER:
-            size = CInline_EstimateSizeOfExpr(expr->data.mfpointer.accessnode, size, level);
-            if (size <= inline_max_size)
-                size = CInline_EstimateSizeOfExpr(expr->data.mfpointer.mfpointer, size, level) + 1;
-            break;
-
-        case EMEMBER:
-            if (expr->data.emember->expr)
-                size = CInline_EstimateSizeOfExpr(expr->data.emember->expr, size, level) + 1;
-            break;
-
-        default:
-            size++;
-    }
-
-    return size;
-}
-
-static SInt32 CInline_EstimateSizeOfFunc(CI_FuncData *funcdata, SInt32 size, SInt32 level) {
-    CI_Statement *stmt;
-    SInt32 i;
-
-    size += funcdata->numstatements;
-    if (size > inline_max_size)
-        return size;
-
-    for (i = 0, stmt = funcdata->statements; i < funcdata->numstatements; i++, stmt++) {
-        switch (stmt->type) {
-            case ST_NOP:
-            case ST_LABEL:
-            case ST_GOTO:
-            case ST_ASM:
-                break;
-            case ST_EXPRESSION:
-            case ST_IFGOTO:
-            case ST_IFNGOTO:
-            case ST_BEGINCATCH:
-            case ST_ENDCATCH:
-            case ST_ENDCATCHDTOR:
-            case ST_GOTOEXPR:
-                size = CInline_EstimateSizeOfExpr(stmt->u.expr, size, level);
-                break;
-            case ST_SWITCH:
-                size = CInline_EstimateSizeOfExpr(stmt->u.switchdata->expr, size, level);
-                break;
-            case ST_RETURN:
-                if (stmt->u.expr)
-                    size = CInline_EstimateSizeOfExpr(stmt->u.expr, size, level);
-                break;
-            default:
-                CError_FATAL(1840);
-        }
-
-        if (size > inline_max_size)
-            break;
-    }
-
-    return size;
-}
-
-static SInt32 EstimateExpandedSizeOfExpr(ENode *expr, SInt32 level) {
-    ENodeList *list;
-    SInt32 size;
-
-    size = 0;
-
-    switch (expr->type) {
-        ENODE_CASE_MONADIC:
-            size = EstimateExpandedSizeOfExpr(expr->data.monadic, level) + 1;
-            break;
-
-        ENODE_CASE_DIADIC_ALL:
-            size = EstimateExpandedSizeOfExpr(expr->data.diadic.left, level) + 1;
-            size += EstimateExpandedSizeOfExpr(expr->data.diadic.right, level);
-            break;
-
-        case EFUNCCALL:
-        case EFUNCCALLP:
-            if (
-                ENODE_IS(expr->data.funccall.funcref, EOBJREF) &&
-                expr->data.funccall.funcref->data.objref->u.func.u.ifuncdata &&
-                CInline_CanExpand(expr->data.funccall.funcref)
-                )
-            {
-                if (level) {
-                    SInt32 est = CInline_EstimateSizeOfFunc(expr->data.funccall.funcref->data.objref->u.func.u.ifuncdata, size, level - 1);
-                    if (est > inline_max_size)
-                        size++;
-                    else
-                        size += est;
-                } else {
-                    size++;
-                }
-            } else {
-                size++;
-            }
-
-            for (list = expr->data.funccall.args; list; list = list->next)
-                size += EstimateExpandedSizeOfExpr(list->node, level);
-            break;
-
-        case ECOND:
-            size = EstimateExpandedSizeOfExpr(expr->data.cond.cond, level) + 1;
-            size += EstimateExpandedSizeOfExpr(expr->data.cond.expr1, level);
-            size += EstimateExpandedSizeOfExpr(expr->data.cond.expr2, level);
-            break;
-
-        case ENULLCHECK:
-            size = EstimateExpandedSizeOfExpr(expr->data.nullcheck.nullcheckexpr, level) + 1;
-            size += EstimateExpandedSizeOfExpr(expr->data.nullcheck.condexpr, level);
-            break;
-
-        case EMFPOINTER:
-            size = EstimateExpandedSizeOfExpr(expr->data.mfpointer.accessnode, level) + 1;
-            size += EstimateExpandedSizeOfExpr(expr->data.mfpointer.mfpointer, level);
-            break;
-
-        case EMEMBER:
-            if (expr->data.emember->expr)
-                size = EstimateExpandedSizeOfExpr(expr->data.emember->expr, level);
-            break;
-
-        default:
-            size++;
-    }
-
-    return size;
-}
-
-static SInt32 EstimateExpandedSizeOfFunction(Statement *stmt) {
-    SInt32 size;
-    SInt32 level;
-
-    level = copts.inlinelevel;
-    if (!level)
-        level = 8;
-
-    size = 0;
-
-    while (stmt) {
-        switch (stmt->type) {
-            case ST_NOP:
-                break;
-            case ST_EXPRESSION:
-            case ST_SWITCH:
-            case ST_IFGOTO:
-            case ST_IFNGOTO:
-            case ST_BEGINCATCH:
-            case ST_ENDCATCH:
-            case ST_ENDCATCHDTOR:
-            case ST_GOTOEXPR:
-                size++;
-                size += EstimateExpandedSizeOfExpr(stmt->expr, level);
-                break;
-            case ST_RETURN:
-                size++;
-                if (stmt->expr)
-                    size = EstimateExpandedSizeOfExpr(stmt->expr, level);
-                break;
-            case ST_LABEL:
-            case ST_GOTO:
-            case ST_ASM:
-                size++;
-                break;
-            default:
-                CError_FATAL(2015);
-        }
-
-        stmt = stmt->next;
-    }
-
-    return size;
-}
-
-static Boolean CInline_InlineFunctionCheck(ENode *expr) {
-    Object *object;
-    SInt32 level;
-    CI_FuncData *funcdata;
-
-    object = expr->data.objref;
-    if (object->datatype == DALIAS)
-        object = object->u.alias.object;
-
-    if (
-        IS_TYPE_FUNC(object->type) &&
-        ((object->qual & Q_INLINE) || (TYPE_FUNC(object->type)->flags & FUNC_FLAGS_800)) &&
-        (object->datatype == DFUNC || (object->datatype == DVFUNC && (expr->flags & ENODE_FLAG_80)))
-        )
-    {
-        if (copts.alwaysinline)
-            return 1;
-
-        if (copts.inline_bottom_up) {
-            if (!object->u.func.u.ifuncdata)
-                return 0;
-
-            level = (copts.inlinelevel == 0) ? (7 - cinline_level) : (copts.inlinelevel - cinline_level - 1);
-            if ((object->qual & Q_INLINE) && level == 0)
-                return 1;
-
-            if (CInline_EstimateSizeOfFunc(object->u.func.u.ifuncdata, 0, level) > inline_max_size)
-                return 0;
-        } else if (cinline_level > 0 && copts.inlinelevel == 0) {
-            funcdata = object->u.func.u.ifuncdata;
-            if (!funcdata)
-                return 0;
-
-            if (funcdata->numstatements > 10)
-                return 0;
-            if (cinline_level > 1 && funcdata->numstatements > 7)
-                return 0;
-            if (cinline_level > 2 && funcdata->numstatements > 3)
-                return 0;
-        }
-
-        return 1;
-    } else {
-        return 0;
-    }
-
-    return 0;
-}
-
-static ENode *CInline_ExpandExpression(ENode *expr) {
-    ENodeList *list;
-    Boolean save;
-
-    switch (expr->type) {
-        case EPOSTINC:
-        case EPOSTDEC:
-        case EPREINC:
-        case EPREDEC:
-        case EINDIRECT:
-        case EMONMIN:
-        case EBINNOT:
-        case ELOGNOT:
-        case ETYPCON:
-        case EBITFIELD:
-            expr->data.monadic = CInline_ExpandExpression(expr->data.monadic);
-            break;
-
-        case EFORCELOAD:
-            expr->data.monadic = CInline_ExpandExpression(expr->data.monadic);
-            if (ENODE_IS(expr->data.monadic, EFORCELOAD))
-                expr->data.monadic = expr->data.monadic->data.monadic;
-            break;
-
-        case EMUL:
-        case EDIV:
-        case EMODULO:
-        case EADD:
-        case ESUB:
-        case ESHL:
-        case ESHR:
-        case ELESS:
-        case EGREATER:
-        case ELESSEQU:
-        case EGREATEREQU:
-        case EEQU:
-        case ENOTEQU:
-        case EAND:
-        case EXOR:
-        case EOR:
-        case EASS:
-        case EMULASS:
-        case EDIVASS:
-        case EMODASS:
-        case EADDASS:
-        case ESUBASS:
-        case ESHLASS:
-        case ESHRASS:
-        case EANDASS:
-        case EXORASS:
-        case EORASS:
-        case EPMODULO:
-        case EROTL:
-        case EROTR:
-            expr->data.diadic.left = CInline_ExpandExpression(expr->data.diadic.left);
-            expr->data.diadic.right = CInline_ExpandExpression(expr->data.diadic.right);
-            break;
-
-        case ELAND:
-        case ELOR:
-        case ECOMMA:
-            expr->data.diadic.left = CInline_ExpandExpression(expr->data.diadic.left);
-            save = cinline_unconditionalpart;
-            cinline_unconditionalpart = 0;
-            expr->data.diadic.right = CInline_ExpandExpression(expr->data.diadic.right);
-            cinline_unconditionalpart = save;
-            break;
-
-        case EFUNCCALL:
-        case EFUNCCALLP:
-            expr->data.funccall.funcref = CInline_ExpandExpression(expr->data.funccall.funcref);
-            for (list = expr->data.funccall.args; list; list = list->next)
-                list->node = CInline_ExpandExpression(list->node);
-
-            if (ENODE_IS(expr->data.funccall.funcref, EOBJREF) && CInline_InlineFunctionCheck(expr->data.funccall.funcref))
-                expr = CInline_InlineFunctionExpression(expr);
-            break;
-
-        case ENULLCHECK:
-            expr->data.nullcheck.nullcheckexpr = CInline_ExpandExpression(expr->data.nullcheck.nullcheckexpr);
-            save = cinline_unconditionalpart;
-            cinline_unconditionalpart = 0;
-            expr->data.nullcheck.condexpr = CInline_ExpandExpression(expr->data.nullcheck.condexpr);
-            cinline_unconditionalpart = save;
-            break;
-
-        case EMFPOINTER:
-            expr->data.mfpointer.accessnode = CInline_ExpandExpression(expr->data.mfpointer.accessnode);
-            expr->data.mfpointer.mfpointer = CInline_ExpandExpression(expr->data.mfpointer.mfpointer);
-            break;
-
-        case ECOND:
-            expr->data.cond.cond = CInline_ExpandExpression(expr->data.cond.cond);
-            save = cinline_unconditionalpart;
-            cinline_unconditionalpart = 0;
-            expr->data.cond.expr1 = CInline_ExpandExpression(expr->data.cond.expr1);
-            expr->data.cond.expr2 = CInline_ExpandExpression(expr->data.cond.expr2);
-            cinline_unconditionalpart = save;
-            break;
-
-        case EMEMBER:
-            if (expr->data.emember->expr)
-                expr = CInline_ExpandExpression(expr->data.emember->expr);
-            else
-                expr = nullnode();
-            break;
-
-        case EINTCONST:
-        case EFLOATCONST:
-        case ESTRINGCONST:
-        case EOBJREF:
-        case EPRECOMP:
-        case ELABEL:
-        case EOBJLIST:
-        case EINSTRUCTION:
-        case EVECTOR128CONST:
-            break;
-
-        default:
-            CError_FATAL(2235);
-    }
-
-    return expr;
-}
-
-static Statement *CInline_NewStatement(StatementType sttype) {
-    Statement *stmt = lalloc(sizeof(Statement));
-    memclrw(stmt, sizeof(Statement));
-
-    stmt->type = sttype;
-    if (cinline_serial_stmt)
-        cinline_cur_serial_stmt->next = stmt;
-    else
-        cinline_serial_stmt = stmt;
-    cinline_cur_serial_stmt = stmt;
-
-    return stmt;
-}
-
-static ENode *CInline_LoadToTemp(ENode *expr, Object **objectptr) {
-    Object *object;
-
-    object = *objectptr;
-    if (!object) {
-        switch (expr->rtype->type) {
-            case TYPEVOID:
-                return expr;
-            case TYPEINT:
-            case TYPEFLOAT:
-            case TYPEENUM:
-            case TYPESTRUCT:
-            case TYPECLASS:
-            case TYPEMEMBERPOINTER:
-            case TYPEPOINTER:
-                object = create_temp_object(expr->rtype);
-                *objectptr = object;
-                break;
-            default:
-                CError_FATAL(2288);
-        }
-    }
-
-    return makediadicnode(create_objectnode(object), expr, EASS);
-}
-
-static ENode *CInline_SerializeEFORCELOAD(ENode *expr) {
-    Statement *stmt;
-    Object *temp = NULL;
-
-    while (ENODE_IS(expr->data.monadic, EFORCELOAD)) {
-        expr->data.monadic = expr->data.monadic->data.monadic;
-    }
-
-    expr->data.monadic = CInline_SerializeExpr(expr->data.monadic);
-    stmt = CInline_NewStatement(ST_EXPRESSION);
-    stmt->expr = CInline_LoadToTemp(expr->data.monadic, &temp);
-    return create_objectnode(temp);
-}
-
-static ENode *CInline_SerializeECOMMA(ENode *expr) {
-    Statement *stmt;
-
-    expr->data.diadic.left = CInline_SerializeExpr(expr->data.diadic.left);
-    stmt = CInline_NewStatement(ST_EXPRESSION);
-    stmt->expr = expr->data.diadic.left;
-    return CInline_SerializeExpr(expr->data.diadic.right);
-}
-
-static ENode *CInline_SerializeELOR(ENode *expr) {
-    ENode *n;
-    Statement *stmt;
-    CLabel *label;
-    Object *temp = NULL;
-
-    label = newlabel();
-
-    n = makemonadicnode(CInline_SerializeExpr(expr->data.diadic.left), ELOGNOT);
-    n->rtype = expr->rtype;
-    n = makemonadicnode(n, ELOGNOT);
-    n = CInline_LoadToTemp(n, &temp);
-    stmt = CInline_NewStatement(ST_IFGOTO);
-    stmt->expr = n;
-    stmt->label = label;
-
-    n = makemonadicnode(CInline_SerializeExpr(expr->data.diadic.right), ELOGNOT);
-    n->rtype = expr->rtype;
-    n = makemonadicnode(n, ELOGNOT);
-    n = CInline_LoadToTemp(n, &temp);
-    stmt = CInline_NewStatement(ST_EXPRESSION);
-    stmt->expr = n;
-
-    stmt = CInline_NewStatement(ST_LABEL);
-    stmt->label = label;
-    label->stmt = stmt;
-
-    return create_objectnode(temp);
-}
-
-static ENode *CInline_SerializeELAND(ENode *expr) {
-    ENode *n;
-    Statement *stmt;
-    CLabel *label;
-    Object *temp = NULL;
-
-    label = newlabel();
-
-    n = makemonadicnode(CInline_SerializeExpr(expr->data.diadic.left), ELOGNOT);
-    n->rtype = expr->rtype;
-    n = makemonadicnode(n, ELOGNOT);
-    n = CInline_LoadToTemp(n, &temp);
-    stmt = CInline_NewStatement(ST_IFNGOTO);
-    stmt->expr = n;
-    stmt->label = label;
-
-    n = makemonadicnode(CInline_SerializeExpr(expr->data.diadic.right), ELOGNOT);
-    n->rtype = expr->rtype;
-    n = makemonadicnode(n, ELOGNOT);
-    n = CInline_LoadToTemp(n, &temp);
-    stmt = CInline_NewStatement(ST_EXPRESSION);
-    stmt->expr = n;
-
-    stmt = CInline_NewStatement(ST_LABEL);
-    stmt->label = label;
-    label->stmt = stmt;
-
-    return create_objectnode(temp);
-}
-
-static ENode *CInline_SerializeEPRECOMP(ENode *expr) {
-    UIDTemp *uidtemp;
-
-    uidtemp = cinline_uid_temps;
-    while (1) {
-        if (!uidtemp)
-            CError_FATAL(2449);
-        if (uidtemp->uid == expr->data.precompid)
-            return create_objectnode(uidtemp->object);
-        uidtemp = uidtemp->next;
-    }
-}
-
-static ENode *CInline_SerializeENULLCHECK(ENode *expr) {
-    Statement *stmt;
-    CLabel *label;
-    ENode *n;
-    Object *temp = NULL;
-    UIDTemp uidtemp;
-
-    label = newlabel();
-
-    n = CInline_SerializeExpr(expr->data.nullcheck.nullcheckexpr);
-    stmt = CInline_NewStatement(ST_IFNGOTO);
-    stmt->expr = CInline_LoadToTemp(n, &temp);
-    stmt->label = label;
-
-    uidtemp.next = cinline_uid_temps;
-    uidtemp.object = temp;
-    uidtemp.uid = expr->data.nullcheck.precompid;
-    cinline_uid_temps = &uidtemp;
-
-    n = CInline_SerializeExpr(expr->data.nullcheck.condexpr);
-    stmt = CInline_NewStatement(ST_EXPRESSION);
-    stmt->expr = CInline_LoadToTemp(n, &temp);
-
-    cinline_uid_temps = uidtemp.next;
-
-    stmt = CInline_NewStatement(ST_LABEL);
-    stmt->label = label;
-    label->stmt = stmt;
-
-    return create_objectnode(temp);
-}
-
-static ENode *CInline_SerializeECOND(ENode *expr) {
-    Statement *stmt;
-    CLabel *label1;
-    CLabel *label2;
-    ENode *n;
-    Object *temp = NULL;
-
-    label1 = newlabel();
-    label2 = newlabel();
-
-    n = CInline_SerializeExpr(expr->data.cond.cond);
-    stmt = CInline_NewStatement(ST_IFNGOTO);
-    stmt->expr = n;
-    stmt->label = label1;
-
-    n = CInline_SerializeExpr(expr->data.cond.expr1);
-    n = CInline_LoadToTemp(n, &temp);
-    stmt = CInline_NewStatement(ST_EXPRESSION);
-    stmt->expr = n;
-
-    stmt = CInline_NewStatement(ST_GOTO);
-    stmt->label = label2;
-
-    stmt = CInline_NewStatement(ST_LABEL);
-    stmt->label = label1;
-    label1->stmt = stmt;
-
-    n = CInline_SerializeExpr(expr->data.cond.expr2);
-    n = CInline_LoadToTemp(n, &temp);
-    stmt = CInline_NewStatement(ST_EXPRESSION);
-    stmt->expr = n;
-
-    stmt = CInline_NewStatement(ST_LABEL);
-    stmt->label = label2;
-    label2->stmt = stmt;
-
-    if (!temp) {
-        n = nullnode();
-        n->rtype = &stvoid;
-        return n;
-    }
-
-    return create_objectnode(temp);
-}
-
-static ENode *CInline_SerializeExpr(ENode *expr) {
-    ENodeList *list;
-
-    switch (expr->type) {
-        case EFORCELOAD:
-            return CInline_SerializeEFORCELOAD(expr);
-        case ECOMMA:
-            return CInline_SerializeECOMMA(expr);
-        case ELAND:
-            return CInline_SerializeELAND(expr);
-        case ELOR:
-            return CInline_SerializeELOR(expr);
-        case EPRECOMP:
-            return CInline_SerializeEPRECOMP(expr);
-        case ENULLCHECK:
-            return CInline_SerializeENULLCHECK(expr);
-        case ECOND:
-            return CInline_SerializeECOND(expr);
-
-        case EINITTRYCATCH:
-            expr->data.itc.initexpr = CInline_SerializeExpr(expr->data.itc.initexpr);
-            expr->data.itc.tryexpr = CInline_SerializeExpr(expr->data.itc.tryexpr);
-            expr->data.itc.catchexpr = CInline_SerializeExpr(expr->data.itc.catchexpr);
-            expr->data.itc.result = CInline_SerializeExpr(expr->data.itc.result);
-            return expr;
-
-        case EPOSTINC:
-        case EPOSTDEC:
-        case EPREINC:
-        case EPREDEC:
-        case EINDIRECT:
-        case EMONMIN:
-        case EBINNOT:
-        case ELOGNOT:
-        case ETYPCON:
-        case EBITFIELD:
-            expr->data.monadic = CInline_SerializeExpr(expr->data.monadic);
-            return expr;
-
-        case EMUL:
-        case EDIV:
-        case EMODULO:
-        case EADD:
-        case ESUB:
-        case ESHL:
-        case ESHR:
-        case ELESS:
-        case EGREATER:
-        case ELESSEQU:
-        case EGREATEREQU:
-        case EEQU:
-        case ENOTEQU:
-        case EAND:
-        case EXOR:
-        case EOR:
-        case EASS:
-        case EMULASS:
-        case EDIVASS:
-        case EMODASS:
-        case EADDASS:
-        case ESUBASS:
-        case ESHLASS:
-        case ESHRASS:
-        case EANDASS:
-        case EXORASS:
-        case EORASS:
-        case EPMODULO:
-        case EROTL:
-        case EROTR:
-            expr->data.diadic.left = CInline_SerializeExpr(expr->data.diadic.left);
-            expr->data.diadic.right = CInline_SerializeExpr(expr->data.diadic.right);
-            return expr;
-
-        case EINTCONST:
-        case EFLOATCONST:
-        case ESTRINGCONST:
-        case EOBJREF:
-        case ELABEL:
-        case EOBJLIST:
-        case EINSTRUCTION:
-        case EVECTOR128CONST:
-            return expr;
-
-        case EFUNCCALL:
-        case EFUNCCALLP:
-            expr->data.funccall.funcref = CInline_SerializeExpr(expr->data.funccall.funcref);
-            for (list = expr->data.funccall.args; list; list = list->next)
-                list->node = CInline_SerializeExpr(list->node);
-            return expr;
-
-        case EMFPOINTER:
-            // bug???
-            expr->data.mfpointer.accessnode = CInline_SerializeExpr(expr->data.mfpointer.accessnode);
-            expr->data.mfpointer.accessnode = CInline_SerializeExpr(expr->data.mfpointer.mfpointer);
-            return expr;
-
-        case EMEMBER:
-            if (expr->data.emember->expr)
-                return CInline_SerializeExpr(expr->data.emember->expr);
-            return expr;
-
-        default:
-            CError_FATAL(2684);
-            return expr;
-    }
-}
-
-void CInline_SerializeStatement(Statement *stmt) {
-    Statement *scan;
-    Statement *copy;
-
-    cinline_serial_stmt = NULL;
-    cinline_uid_temps = NULL;
-    stmt->expr = CInline_SerializeExpr(stmt->expr);
-
-    if (cinline_serial_stmt) {
-        for (scan = cinline_serial_stmt; scan; scan = scan->next) {
-            scan->value = stmt->value;
-            scan->dobjstack = stmt->dobjstack;
-            scan->sourceoffset = stmt->sourceoffset;
-            scan->sourcefilepath = stmt->sourcefilepath;
-        }
-
-        copy = CInline_NewStatement(ST_EXPRESSION);
-        *copy = *stmt;
-
-        *stmt = *cinline_serial_stmt;
-    }
-}
-
-static void CInline_UnpackSwitch(Statement *stmt, CI_Statement *packstmt, CLabel **labels) {
-    SwitchInfo *info;
-    SwitchCase *swcase;
-    short i;
-
-    info = lalloc(sizeof(SwitchInfo));
-    stmt->label = (CLabel *) info;
-    CError_ASSERT(2730, info->defaultlabel = labels[packstmt->u.switchdata->defaultlabelID]);
-    info->x8 = packstmt->u.switchdata->unkSwitch8;
-
-    for (i = 0; i < packstmt->u.switchdata->numcases; i++) {
-        if (i == 0) {
-            swcase = lalloc(sizeof(SwitchCase));
-            info->cases = swcase;
-        } else {
-            swcase->next = lalloc(sizeof(SwitchCase));
-            swcase = swcase->next;
-        }
-
-        swcase->next = NULL;
-        swcase->min = packstmt->u.switchdata->cases[i].min;
-        swcase->max = packstmt->u.switchdata->cases[i].max;
-        CError_ASSERT(2740, swcase->label = labels[packstmt->u.switchdata->cases[i].labelID]);
-    }
-}
-
-Object *CInline_GetLocalObj(SInt32 id, Boolean flag) {
-    ObjectList *list;
-
-    if (id) {
-        if (id & 0x80000000) {
-            id = (id & 0x7FFFFFFF) - 1;
-            if (flag) {
-                CError_ASSERT(2761, local_aobjects[id].object);
-                return local_aobjects[id].object;
-            }
-
-            for (list = arguments; list; list = list->next, id--) {
-                if (id == 0)
-                    return list->object;
-            }
-
-            CError_FATAL(2765);
-        } else {
-            id--;
-            if (flag) {
-                CError_ASSERT(2772, local_dobjects[id]);
-                return local_dobjects[id];
-            }
-
-            for (list = locals; list; list = list->next, id--) {
-                if (id == 0)
-                    return list->object;
-            }
-
-            CError_FATAL(2776);
-        }
-    }
-
-    return NULL;
-}
-
-static ExceptionAction *CInline_UnpackActions(CI_Statement *packstmt, Boolean flag) {
-    ExceptionAction *packexc;
-    ExceptionAction *last;
-    ExceptionAction *exc;
-
-    packexc = packstmt->dobjstack;
-    last = NULL;
-
-    while (packexc) {
-        exc = galloc(sizeof(ExceptionAction));
-        exc->prev = last;
-        last = exc;
-
-        exc->type = packexc->type;
-
-        switch (packexc->type) {
-            case EAT_DESTROYLOCAL:
-                exc->data.destroy_local.local = CInline_GetLocalObj((SInt32) packexc->data.destroy_local.local, flag);
-                exc->data.destroy_local.dtor = packexc->data.destroy_local.dtor;
-                break;
-            case EAT_DESTROYLOCALCOND:
-                exc->data.destroy_local_cond.local = CInline_GetLocalObj((SInt32) packexc->data.destroy_local_cond.local, flag);
-                exc->data.destroy_local_cond.dtor = packexc->data.destroy_local_cond.dtor;
-                exc->data.destroy_local_cond.cond = CInline_GetLocalObj((SInt32) packexc->data.destroy_local_cond.cond, flag);
-                break;
-            case EAT_DESTROYLOCALOFFSET:
-                exc->data.destroy_local_offset.local = CInline_GetLocalObj((SInt32) packexc->data.destroy_local_offset.local, flag);
-                exc->data.destroy_local_offset.dtor = packexc->data.destroy_local_offset.dtor;
-                exc->data.destroy_local_offset.offset = packexc->data.destroy_local_offset.offset;
-                break;
-            case EAT_DESTROYLOCALPOINTER:
-                exc->data.destroy_local_pointer.pointer = CInline_GetLocalObj((SInt32) packexc->data.destroy_local_pointer.pointer, flag);
-                exc->data.destroy_local_pointer.dtor = packexc->data.destroy_local_pointer.dtor;
-                break;
-            case EAT_DESTROYLOCALARRAY:
-                exc->data.destroy_local_array.localarray = CInline_GetLocalObj((SInt32) packexc->data.destroy_local_array.localarray, flag);
-                exc->data.destroy_local_array.dtor = packexc->data.destroy_local_array.dtor;
-                exc->data.destroy_local_array.elements = packexc->data.destroy_local_array.elements;
-                exc->data.destroy_local_array.element_size = packexc->data.destroy_local_array.element_size;
-                break;
-            case EAT_DESTROYPARTIALARRAY:
-                exc->data.destroy_partial_array.arraypointer = CInline_GetLocalObj((SInt32) packexc->data.destroy_partial_array.arraypointer, flag);
-                exc->data.destroy_partial_array.arraycounter = CInline_GetLocalObj((SInt32) packexc->data.destroy_partial_array.arraycounter, flag);
-                exc->data.destroy_partial_array.dtor = CInline_GetLocalObj((SInt32) packexc->data.destroy_partial_array.dtor, flag);
-                exc->data.destroy_partial_array.element_size = CInline_GetLocalObj((SInt32) packexc->data.destroy_partial_array.element_size, flag);
-                break;
-            case EAT_DESTROYMEMBER:
-            case EAT_DESTROYBASE:
-                exc->data.destroy_member.objectptr = CInline_GetLocalObj((SInt32) packexc->data.destroy_member.objectptr, flag);
-                exc->data.destroy_member.dtor = packexc->data.destroy_member.dtor;
-                exc->data.destroy_member.offset = packexc->data.destroy_member.offset;
-                break;
-            case EAT_DESTROYMEMBERCOND:
-                exc->data.destroy_member_cond.objectptr = CInline_GetLocalObj((SInt32) packexc->data.destroy_member_cond.objectptr, flag);
-                exc->data.destroy_member_cond.cond = CInline_GetLocalObj((SInt32) packexc->data.destroy_member_cond.cond, flag);
-                exc->data.destroy_member_cond.dtor = packexc->data.destroy_member_cond.dtor;
-                exc->data.destroy_member_cond.offset = packexc->data.destroy_member_cond.offset;
-                break;
-            case EAT_DESTROYMEMBERARRAY:
-                exc->data.destroy_member_array.objectptr = CInline_GetLocalObj((SInt32) packexc->data.destroy_member_array.objectptr, flag);
-                exc->data.destroy_member_array.dtor = packexc->data.destroy_member_array.dtor;
-                exc->data.destroy_member_array.offset = packexc->data.destroy_member_array.offset;
-                exc->data.destroy_member_array.elements = packexc->data.destroy_member_array.elements;
-                exc->data.destroy_member_array.element_size = packexc->data.destroy_member_array.element_size;
-                break;
-            case EAT_DELETEPOINTER:
-            case EAT_DELETELOCALPOINTER:
-                exc->data.delete_pointer.pointerobject = CInline_GetLocalObj((SInt32) packexc->data.delete_pointer.pointerobject, flag);
-                exc->data.delete_pointer.deletefunc = packexc->data.delete_pointer.deletefunc;
-                break;
-            case EAT_DELETEPOINTERCOND:
-                exc->data.delete_pointer_cond.pointerobject = CInline_GetLocalObj((SInt32) packexc->data.delete_pointer_cond.pointerobject, flag);
-                exc->data.delete_pointer_cond.deletefunc = packexc->data.delete_pointer_cond.deletefunc;
-                exc->data.delete_pointer_cond.cond = CInline_GetLocalObj((SInt32) packexc->data.delete_pointer_cond.cond, flag);
-                break;
-            case EAT_CATCHBLOCK: {
-                LabelTrans *trans;
-                exc->data.catch_block.catch_object = CInline_GetLocalObj((SInt32) packexc->data.catch_block.catch_object, flag);
-                exc->data.catch_block.catch_info_object = CInline_GetLocalObj((SInt32) packexc->data.catch_block.catch_info_object, flag);
-
-                trans = lalloc(sizeof(LabelTrans));
-                trans->next = cinline_label_trans;
-                cinline_label_trans = trans;
-
-                trans->id = (SInt32) packexc->data.catch_block.catch_label;
-                trans->labelptr = &exc->data.catch_block.catch_label;
-
-                exc->data.catch_block.catch_typeid = packexc->data.catch_block.catch_typeid;
-                exc->data.catch_block.catch_type = packexc->data.catch_block.catch_type;
-                exc->data.catch_block.catch_qual = packexc->data.catch_block.catch_qual;
-                break;
-            }
-            case EAT_ACTIVECATCHBLOCK:
-                exc->data.active_catch_block.catch_info_object = CInline_GetLocalObj((SInt32) packexc->data.active_catch_block.catch_info_object, flag);
-                break;
-            case EAT_SPECIFICATION: {
-                LabelTrans *trans;
-                exc->data.specification.unexp_ids = packexc->data.specification.unexp_ids;
-                exc->data.specification.unexp_id = packexc->data.specification.unexp_id;
-
-                trans = lalloc(sizeof(LabelTrans));
-                trans->next = cinline_label_trans;
-                cinline_label_trans = trans;
-
-                trans->id = (SInt32) packexc->data.specification.unexp_label;
-                trans->labelptr = &exc->data.specification.unexp_label;
-
-                exc->data.specification.unexp_info_object = CInline_GetLocalObj((SInt32) packexc->data.specification.unexp_info_object, flag);
-                break;
-            }
-            case EAT_TERMINATE:
-                break;
-            default:
-                CError_FATAL(2904);
-        }
-
-        packexc = packexc->prev;
-    }
-
-    return last;
-}
-
-static Statement *CInline_ExpandStatements(Object *funcobj, Statement *stmt, CI_FuncData *funcdata, ENode *funccall, CLabel *label, Object *resultobj, Boolean flag) {
-    CLabel **labels;
-    CI_Statement *packstmt;
-    short i;
-    CI_StmtLink *stmtLinks;
-    CI_StmtLink *link;
-    ENode *setupArgs;
-    Boolean is_result_class_1;
-    Statement origStmt;
-
-    origStmt = *stmt;
-    is_result_class_1 = CMach_GetFunctionResultClass(TYPE_FUNC(funcobj->type)) == 1;
-
-    if ((setupArgs = CInline_SetupArgsExpression(funcobj, funcdata, funccall->data.funccall.args))) {
-        stmt->type = ST_EXPRESSION;
-        stmt->expr = CInline_FoldConst(setupArgs);
-    } else {
-        stmt->type = ST_NOP;
-    }
-
-    stmtLinks = NULL;
-    cinline_label_trans = NULL;
-
-    labels = lalloc(sizeof(CLabel *) * funcdata->numstatements);
-    memclrw(labels, sizeof(CLabel *) * funcdata->numstatements);
-
-    for (i = 0, packstmt = funcdata->statements; i < funcdata->numstatements; i++, packstmt++) {
-        stmt->next = lalloc(sizeof(Statement));
-        stmt = stmt->next;
-        *stmt = origStmt;
-
-        stmt->type = packstmt->type;
-        stmt->flags = packstmt->flags;
-        stmt->value += packstmt->value;
-
-        if (packstmt->dobjstack) {
-            ExceptionAction *unpacked = CInline_UnpackActions(packstmt, 1);
-            if (stmt->dobjstack) {
-                ExceptionAction *scan = unpacked;
-                while (scan->prev)
-                    scan = scan->prev;
-                scan->prev = stmt->dobjstack;
-            }
-            stmt->dobjstack = unpacked;
-        }
-
-        switch (stmt->type) {
-            case ST_NOP:
-                break;
-
-            case ST_EXPRESSION:
-            case ST_BEGINCATCH:
-            case ST_ENDCATCH:
-            case ST_ENDCATCHDTOR:
-            case ST_GOTOEXPR:
-                stmt->expr = CInline_FoldConst(CInline_CopyExpression(packstmt->u.expr, CopyMode4));
-                break;
-
-            case ST_RETURN:
-                if (packstmt->u.expr) {
-                    stmt->expr = CInline_FoldConst(CInline_CopyExpression(packstmt->u.expr, CopyMode4));
-                    if (is_result_class_1)
-                        stmt->expr = makecommaexpression(stmt->expr, CInline_ReturnMemResult(funcobj));
-
-                    if (resultobj) {
-                        stmt->type = ST_EXPRESSION;
-                        stmt->expr = makediadicnode(create_objectnode2(resultobj), stmt->expr, EASS);
-                    } else {
-                        stmt->type = origStmt.type;
-                        if (stmt->type == ST_EXPRESSION && !CInline_ExpressionHasSideEffect(stmt->expr))
-                            stmt->type = ST_NOP;
-                    }
-
-                    if (label) {
-                        stmt->next = lalloc(sizeof(Statement));
-                        stmt = stmt->next;
-                        *stmt = origStmt;
-                        stmt->type = ST_GOTO;
-                        stmt->label = label;
-                    }
-                } else {
-                    if (label) {
-                        stmt->type = ST_GOTO;
-                        stmt->label = label;
-                    } else {
-                        stmt->type = ST_NOP;
-                    }
-                }
-                break;
-
-            case ST_LABEL:
-                labels[i] = stmt->label = newlabel();
-                stmt->label->stmt = stmt;
-                break;
-
-            case ST_IFGOTO:
-            case ST_IFNGOTO:
-                stmt->expr = CInline_FoldConst(CInline_CopyExpression(packstmt->u.ifgoto.expr, CopyMode4));
-            case ST_GOTO:
-                link = lalloc(sizeof(CI_StmtLink));
-                link->next = stmtLinks;
-                stmtLinks = link;
-
-                link->stmt = stmt;
-                link->ciStmt = packstmt;
-                break;
-
-            case ST_SWITCH:
-                stmt->expr = CInline_FoldConst(CInline_CopyExpression(packstmt->u.switchdata->expr, CopyMode4));
-            case ST_ASM:
-                link = lalloc(sizeof(CI_StmtLink));
-                link->next = stmtLinks;
-                stmtLinks = link;
-
-                link->stmt = stmt;
-                link->ciStmt = packstmt;
-                break;
-
-            default:
-                CError_FATAL(3040);
-        }
-    }
-
-    if (label) {
-        stmt->next = lalloc(sizeof(Statement));
-        stmt = stmt->next;
-        *stmt = origStmt;
-
-        stmt->type = ST_LABEL;
-        stmt->label = label;
-        label->stmt = stmt;
-
-        if (flag) {
-            stmt->next = lalloc(sizeof(Statement));
-            stmt = stmt->next;
-            *stmt = origStmt;
-        }
-    }
-
-    while (stmtLinks) {
-        Statement *linkstmt = stmtLinks->stmt;
-        packstmt = stmtLinks->ciStmt;
-
-        switch (linkstmt->type) {
-            case ST_GOTO:
-                CError_ASSERT(3060, linkstmt->label = labels[packstmt->u.statementnum]);
-                break;
-            case ST_IFGOTO:
-            case ST_IFNGOTO:
-                CError_ASSERT(3065, linkstmt->label = labels[packstmt->u.ifgoto.statementnum]);
-                break;
-            case ST_SWITCH:
-                CInline_UnpackSwitch(linkstmt, packstmt, labels);
-                break;
-            case ST_ASM:
-                InlineAsm_UnpackAsmStatement(linkstmt, labels, 1, packstmt->u.asmdata.data, packstmt->u.asmdata.size);
-                break;
-            default:
-                CError_FATAL(3076);
-        }
-
-        stmtLinks = stmtLinks->next;
-    }
-
-    while (cinline_label_trans) {
-        CError_ASSERT(3083, *cinline_label_trans->labelptr = labels[cinline_label_trans->id]);
-        cinline_label_trans = cinline_label_trans->next;
-    }
-
-    return stmt;
-}
-
-static Statement *CInline_InlineFunctionStatement(Statement *stmt, Boolean *changed) {
-    Object *object;
-    CI_FuncData *funcdata;
-    CLabel *label;
-
-    *changed = 0;
-
-    object = stmt->expr->data.funccall.funcref->data.objref;
-    if (object->datatype == DALIAS)
-        object = object->u.alias.object;
-
-    funcdata = object->u.func.u.ifuncdata;
-    if (!funcdata || funcdata->can_inline < CI_CanInline3)
-        return stmt;
-
-    if (stmt->type != ST_EXPRESSION) {
-        short i;
-        for (i = 0; i < (funcdata->numstatements - 1); i++) {
-            if (funcdata->statements[i].type == ST_RETURN)
-                return stmt;
-        }
-
-        if (funcdata->statements[funcdata->numstatements - 1].type != ST_RETURN)
-            return stmt;
-
-        label = NULL;
-    } else {
-        label = newlabel();
-    }
-
-    *changed = 1;
-    return CInline_ExpandStatements(object, stmt, funcdata, stmt->expr, label, NULL, 0);
-}
-
-static Statement *CInline_ExtractInlineFunction(Statement *stmt) {
-    ENode *expr;
-    CI_FuncData *funcdata;
-    short i;
-    Object *funcObject;
-    Object *resultObject;
-
-    for (i = 0; i < cinline_stmtlevelexprs; i++) {
-        expr = cinline_stmtlevelexpr[i];
-
-        funcObject = expr->data.funccall.funcref->data.objref;
-        if (funcObject->datatype == DALIAS)
-            funcObject = funcObject->u.alias.object;
-
-        if ((funcdata = funcObject->u.func.u.ifuncdata)) {
-            TypeFunc *tfunc = TYPE_FUNC(funcObject->type);
-            CError_ASSERT(3141, IS_TYPE_FUNC(tfunc));
-
-            if (!IS_TYPE_VOID(tfunc->functype)) {
-                if (CMach_GetFunctionResultClass(TYPE_FUNC(funcObject->type)) == 1)
-                    resultObject = CInline_NewLocalObject(CDecl_NewPointerType(tfunc->functype), 0, 0, 0);
-                else
-                    resultObject = CInline_NewLocalObject(tfunc->functype, 0, 0, 0);
-            } else {
-                resultObject = NULL;
-            }
-
-            stmt = CInline_ExpandStatements(funcObject, stmt, funcdata, expr, newlabel(), resultObject, 1);
-
-            if (resultObject)
-                *expr = *create_objectnode2(resultObject);
-            else
-                *expr = *nullnode();
-        }
-    }
-
-    return stmt;
-}
-
-static Statement *CInline_ExpandStatement(Statement *stmt) {
-    Boolean changed;
-
-    do {
-        changed = 0;
-
-        if (
-            stmt->type == ST_EXPRESSION &&
-            ENODE_IS(stmt->expr, EINDIRECT) &&
-            !CParser_IsVolatile(stmt->expr->rtype, ENODE_QUALS(stmt->expr))
-            )
-        {
-            stmt->expr = stmt->expr->data.monadic;
-            changed = 1;
-            if (ENODE_IS2(stmt->expr, EOBJREF, EBITFIELD))
-                stmt->expr = nullnode();
-        }
-
-        if (ENODE_IS(stmt->expr, ECOMMA)) {
-            Statement *newStmt = lalloc(sizeof(Statement));
-            *newStmt = *stmt;
-
-            stmt->next = newStmt;
-            stmt->type = ST_EXPRESSION;
-            stmt->expr = stmt->expr->data.diadic.left;
-            newStmt->expr = newStmt->expr->data.diadic.right;
-
-            changed = 1;
-        }
-    } while (changed);
-
-    if (
-        ENODE_IS2(stmt->expr, EFUNCCALL, EFUNCCALLP) &&
-        ENODE_IS(stmt->expr->data.funccall.funcref, EOBJREF) &&
-        CInline_InlineFunctionCheck(stmt->expr->data.funccall.funcref)
-        )
-    {
-        stmt = CInline_InlineFunctionStatement(stmt, &changed);
-        if (changed) {
-            any_inline_expanded = 1;
-            return stmt;
-        }
-    }
-
-    inline_expanded = 0;
-    cinline_unconditionalpart = 1;
-    cinline_serialize_stmt = 0;
-    cinline_stmtlevelexprs = 0;
-    stmt->expr = CInline_ExpandExpression(stmt->expr);
-
-    if (cinline_serialize_stmt) {
-        cinline_unconditionalpart = 1;
-        cinline_serialize_stmt = 0;
-        cinline_stmtlevelexprs = 0;
-        CInline_SerializeStatement(stmt);
-        stmt->expr = CInline_ExpandExpression(stmt->expr);
-    }
-
-    if (inline_expanded) {
-        stmt->expr = CInline_FoldConst(stmt->expr);
-        any_inline_expanded = 1;
-    }
-
-    if (cinline_stmtlevelexprs) {
-        stmt = CInline_ExtractInlineFunction(stmt);
-        any_inline_expanded = 1;
-    }
-
-    return stmt;
-}
-
-static void CInline_ForceReverseSearch(ENode *) {
-    cinline_funccallfound = 1;
-}
-
-static ENode *CInline_ForceReverseEvaluation(ENode *expr) {
-    ENode *commanodes;
-    ENodeList *list;
-    int counter;
-    ENode *ass;
-    ENode *inner;
-    ENode *copy;
-
-    list = expr->data.funccall.args;
-    counter = 0;
-    commanodes = NULL;
-
-    while (list) {
-        cinline_funccallfound = 0;
-        inner = list->node;
-        CExpr_SearchExprTree(inner, CInline_ForceReverseSearch, 2, EFUNCCALL, EFUNCCALLP);
-
-        if (cinline_funccallfound && ++counter > 0) {
-            inner = create_objectrefnode(create_temp_object(inner->rtype));
-            copy = lalloc(sizeof(ENode));
-            *copy = *inner;
-
-            copy = makemonadicnode(copy, EINDIRECT);
-            copy->rtype = TPTR_TARGET(copy->rtype);
-
-            inner = makemonadicnode(inner, EINDIRECT);
-            inner->rtype = TPTR_TARGET(inner->rtype);
-
-            ass = makediadicnode(inner, copy, EASS);
-            list->node = copy;
-
-            if (commanodes)
-                commanodes = makediadicnode(ass, commanodes, ECOMMA);
-            else
-                commanodes = ass;
-        }
-
-        list = list->next;
-    }
-
-    if (commanodes) {
-        commanodes = makediadicnode(commanodes, expr, ECOMMA);
-        commanodes->rtype = expr->rtype;
-        return commanodes;
-    }
-
-    return expr;
-}
-
-static void CInline_ExportCheck(ENode *expr) {
-    while (1) {
-        switch (expr->type) {
-            case EOBJREF:
-                CInline_ObjectAddrRef(expr->data.objref);
-                if (expr->data.objref->datatype == DALIAS) {
-                    CExpr_AliasTransform(expr);
-                    continue;
-                }
-                return;
-
-            ENODE_CASE_MONADIC:
-                expr = expr->data.monadic;
-                continue;
-
-            ENODE_CASE_DIADIC_ALL:
-                CInline_ExportCheck(expr->data.diadic.left);
-                expr = expr->data.diadic.right;
-                continue;
-
-            case EINTCONST:
-            case EFLOATCONST:
-            case ESTRINGCONST:
-            case EPRECOMP:
-            case EINSTRUCTION:
-            case EVECTOR128CONST:
-                return;
-
-            case ELABEL:
-                if (expr->data.label->stmt)
-                    expr->data.label->stmt->flags |= StmtFlag_1;
-                return;
-
-            case EFUNCCALL:
-            case EFUNCCALLP: {
-                ENodeList *list;
-                TypeClass *tclass;
-                SInt32 index;
-
-                for (list = expr->data.funccall.args; list; list = list->next)
-                    CInline_ExportCheck(list->node);
-
-                expr = expr->data.funccall.funcref;
-                if (
-                    copts.warn_notinlined &&
-                    !copts.dontinline &&
-                    ENODE_IS(expr, EOBJREF) &&
-                    (expr->data.objref->qual & Q_INLINE) &&
-                    expr->data.objref->datatype != DINLINEFUNC &&
-                    !CParser_IsVirtualFunction(expr->data.objref, &tclass, &index)
-                    )
-                    CError_Warning(CErrorStr342, expr->data.objref);
-
-                continue;
-            }
-
-            case ENULLCHECK:
-                CInline_ExportCheck(expr->data.nullcheck.nullcheckexpr);
-                expr = expr->data.nullcheck.condexpr;
-                continue;
-
-            case EMFPOINTER:
-                *expr = *nullnode();
-                continue;
-
-            case ECOND:
-                CInline_ExportCheck(expr->data.cond.cond);
-                CInline_ExportCheck(expr->data.cond.expr1);
-                expr = expr->data.cond.expr2;
-                continue;
-
-            case EMEMBER:
-                if (expr->data.emember->expr) {
-                    *expr = *expr->data.emember->expr;
-                    continue;
-                }
-            case EOBJLIST:
-                *expr = *nullnode();
-                continue;
-
-            default:
-                CError_FATAL(3372);
-        }
-    }
-}
-
-static void CInline_Expand(Statement *stmt) {
-    Statement *scan;
-
-    if (!copts.dontinline && copts.inlinelevel >= 0) {
-        if (copts.inline_bottom_up) {
-            inline_max_size = copts.inlinemaxsize;
-            while (inline_max_size > 1 && EstimateExpandedSizeOfFunction(stmt) > copts.inlinemaxtotalsize)
-                inline_max_size >>= 1;
-        }
-
-        cinline_level = 0;
-        while (1) {
-            any_inline_expanded = 0;
-            for (scan = stmt; scan; scan = scan->next) {
-                switch (scan->type) {
-                    case ST_NOP:
-                    case ST_LABEL:
-                    case ST_GOTO:
-                    case ST_BEGINCATCH:
-                    case ST_ENDCATCH:
-                    case ST_ENDCATCHDTOR:
-                    case ST_ASM:
-                        break;
-                    case ST_RETURN:
-                        if (!scan->expr)
-                            break;
-                    case ST_EXPRESSION:
-                    case ST_SWITCH:
-                    case ST_IFGOTO:
-                    case ST_IFNGOTO:
-                    case ST_GOTOEXPR:
-                        scan = CInline_ExpandStatement(scan);
-                        break;
-                    default:
-                        CError_FATAL(3438);
-                }
-            }
-
-            if (!copts.inline_bottom_up && !any_inline_expanded)
-                break;
-
-            if (!copts.alwaysinline || copts.inline_bottom_up) {
-                if (copts.inlinelevel == 0) {
-                    if (copts.inline_bottom_up) {
-                        if ((cinline_level + 1) >= 8)
-                            break;
-                    } else {
-                        if (cinline_level >= 3)
-                            break;
-                    }
-                } else {
-                    if ((cinline_level + 1) >= copts.inlinelevel)
-                        break;
-                }
-            }
-
-            if (CWDisplayLines(cparamblkptr->context, lines) != cwNoErr)
-                CError_UserBreak();
-
-            cinline_level++;
-        }
-    }
-
-    while (stmt) {
-        if (stmt->dobjstack)
-            CExcept_CheckStackRefs(stmt->dobjstack);
-
-        switch (stmt->type) {
-            case ST_NOP:
-            case ST_LABEL:
-            case ST_GOTO:
-            case ST_BEGINCATCH:
-            case ST_ENDCATCH:
-            case ST_ENDCATCHDTOR:
-            case ST_ASM:
-                break;
-            case ST_RETURN:
-                if (!stmt->expr)
-                    break;
-            case ST_EXPRESSION:
-            case ST_SWITCH:
-            case ST_IFGOTO:
-            case ST_IFNGOTO:
-            case ST_GOTOEXPR:
-                CInline_ExportCheck(stmt->expr);
-                break;
-            default:
-                CError_FATAL(3501);
-        }
-
-        stmt = stmt->next;
-    }
-}
-
-SInt16 CInline_GetStatementNumber(Statement *first, Statement *stmt) {
-    SInt16 number = 0;
-
-    while (first) {
-        if (first == stmt)
-            return number;
-
-        first = first->next;
-        number++;
-    }
-
-    CError_FATAL(3517);
-    return 0;
-}
-
-static CI_Switch *CInline_PackSwitch(Statement *start, Statement *stmt) {
-    SwitchInfo *info;
-    SwitchCase *swcase;
-    short numcases;
-    CI_Switch *packed;
-
-    info = (SwitchInfo *) stmt->label;
-    swcase = info->cases;
-    numcases = 0;
-    while (swcase) {
-        swcase = swcase->next;
-        numcases++;
-    }
-
-    packed = galloc(sizeof(CI_Switch) + numcases * sizeof(CI_SwitchCase));
-    packed->expr = CInline_CopyExpression(stmt->expr, CopyMode2);
-    packed->defaultlabelID = CInline_GetStatementNumber(start, info->defaultlabel->stmt);
-    packed->unkSwitch8 = info->x8;
-    packed->numcases = numcases;
-
-    for (swcase = info->cases, numcases = 0; swcase; swcase = swcase->next, numcases++) {
-        packed->cases[numcases].labelID = CInline_GetStatementNumber(start, swcase->label->stmt);
-        packed->cases[numcases].min = swcase->min;
-        packed->cases[numcases].max = swcase->max;
-    }
-
-    return packed;
-}
-
-static UInt8 CInline_CanInline(Object *object, Statement *stmt) {
-    UInt8 resultClass;
-    FuncArg *arg;
-    UInt8 result;
-
-    resultClass = CMach_GetFunctionResultClass(TYPE_FUNC(object->type));
-    if (
-        resultClass &&
-        (resultClass != 1 || (IS_TYPE_CLASS(TYPE_FUNC(object->type)->functype) && CClass_Destructor(TYPE_CLASS(TYPE_FUNC(object->type)->functype))))
-        )
-        return CI_CanInline0;
-
-    for (arg = TYPE_FUNC(object->type)->args; arg; arg = arg->next) {
-        if (arg == &elipsis)
-            return CI_CanInline0;
-        if (arg == &oldstyle)
-            break;
-
-        if (IS_TYPE_CLASS(arg->type) && CClass_Destructor(TYPE_CLASS(arg->type)))
-            return CI_CanInline0;
-    }
-
-    result = CI_CanInline6;
-
-    while (stmt) {
-        if (stmt->dobjstack)
-            return CI_CanInline3;
-
-        switch (stmt->type) {
-            case ST_EXPRESSION:
-                break;
-            case ST_RETURN:
-                if (stmt->next || (stmt->expr == NULL && TYPE_FUNC(object->type)->functype != &stvoid))
-                    result = CI_CanInline3;
-                break;
-            default:
-                result = CI_CanInline3;
-        }
-
-        stmt = stmt->next;
-    }
-
-    return result;
-}
-
-static ExceptionAction *CInline_PackActions(Statement *start, Statement *stmt) {
-    ExceptionAction *exc;
-    ExceptionAction *last;
-    ExceptionAction *packexc;
-
-    exc = stmt->dobjstack;
-    last = NULL;
-
-    while (exc) {
-        packexc = galloc(sizeof(ExceptionAction));
-        packexc->prev = last;
-        last = packexc;
-
-        packexc->type = exc->type;
-
-        switch (exc->type) {
-            case EAT_DESTROYLOCAL:
-                packexc->data.destroy_local.local = (void *) CInline_GetLocalID(exc->data.destroy_local.local);
-                packexc->data.destroy_local.dtor = exc->data.destroy_local.dtor;
-                break;
-            case EAT_DESTROYLOCALCOND:
-                packexc->data.destroy_local_cond.local = (void *) CInline_GetLocalID(exc->data.destroy_local_cond.local);
-                packexc->data.destroy_local_cond.dtor = exc->data.destroy_local_cond.dtor;
-                packexc->data.destroy_local_cond.cond = (void *) CInline_GetLocalID(exc->data.destroy_local_cond.cond);
-                break;
-            case EAT_DESTROYLOCALOFFSET:
-                packexc->data.destroy_local_offset.local = (void *) CInline_GetLocalID(exc->data.destroy_local_offset.local);
-                packexc->data.destroy_local_offset.dtor = exc->data.destroy_local_offset.dtor;
-                packexc->data.destroy_local_offset.offset = exc->data.destroy_local_offset.offset;
-                break;
-            case EAT_DESTROYLOCALPOINTER:
-                packexc->data.destroy_local_pointer.pointer = (void *) CInline_GetLocalID(exc->data.destroy_local_pointer.pointer);
-                packexc->data.destroy_local_pointer.dtor = exc->data.destroy_local_pointer.dtor;
-                break;
-            case EAT_DESTROYLOCALARRAY:
-                packexc->data.destroy_local_array.localarray = (void *) CInline_GetLocalID(exc->data.destroy_local_array.localarray);
-                packexc->data.destroy_local_array.dtor = exc->data.destroy_local_array.dtor;
-                packexc->data.destroy_local_array.elements = exc->data.destroy_local_array.elements;
-                packexc->data.destroy_local_array.element_size = exc->data.destroy_local_array.element_size;
-                break;
-            case EAT_DESTROYPARTIALARRAY:
-                packexc->data.destroy_partial_array.arraypointer = (void *) CInline_GetLocalID(exc->data.destroy_partial_array.arraypointer);
-                packexc->data.destroy_partial_array.arraycounter = (void *) CInline_GetLocalID(exc->data.destroy_partial_array.arraycounter);
-                packexc->data.destroy_partial_array.dtor = (void *) CInline_GetLocalID(exc->data.destroy_partial_array.dtor);
-                packexc->data.destroy_partial_array.element_size = (void *) CInline_GetLocalID(exc->data.destroy_partial_array.element_size);
-                break;
-            case EAT_DESTROYMEMBER:
-            case EAT_DESTROYBASE:
-                packexc->data.destroy_member.objectptr = (void *) CInline_GetLocalID(exc->data.destroy_member.objectptr);
-                packexc->data.destroy_member.dtor = exc->data.destroy_member.dtor;
-                packexc->data.destroy_member.offset = exc->data.destroy_member.offset;
-                break;
-            case EAT_DESTROYMEMBERCOND:
-                packexc->data.destroy_member_cond.objectptr = (void *) CInline_GetLocalID(exc->data.destroy_member_cond.objectptr);
-                packexc->data.destroy_member_cond.cond = (void *) CInline_GetLocalID(exc->data.destroy_member_cond.cond);
-                packexc->data.destroy_member_cond.dtor = exc->data.destroy_member_cond.dtor;
-                packexc->data.destroy_member_cond.offset = exc->data.destroy_member_cond.offset;
-                break;
-            case EAT_DESTROYMEMBERARRAY:
-                packexc->data.destroy_member_array.objectptr = (void *) CInline_GetLocalID(exc->data.destroy_member_array.objectptr);
-                packexc->data.destroy_member_array.dtor = exc->data.destroy_member_array.dtor;
-                packexc->data.destroy_member_array.offset = exc->data.destroy_member_array.offset;
-                packexc->data.destroy_member_array.elements = exc->data.destroy_member_array.elements;
-                packexc->data.destroy_member_array.element_size = exc->data.destroy_member_array.element_size;
-                break;
-            case EAT_DELETEPOINTER:
-            case EAT_DELETELOCALPOINTER:
-                packexc->data.delete_pointer.pointerobject = (void *) CInline_GetLocalID(exc->data.delete_pointer.pointerobject);
-                packexc->data.delete_pointer.deletefunc = exc->data.delete_pointer.deletefunc;
-                break;
-            case EAT_DELETEPOINTERCOND:
-                packexc->data.delete_pointer_cond.pointerobject = (void *) CInline_GetLocalID(exc->data.delete_pointer_cond.pointerobject);
-                packexc->data.delete_pointer_cond.deletefunc = exc->data.delete_pointer_cond.deletefunc;
-                packexc->data.delete_pointer_cond.cond = (void *) CInline_GetLocalID(exc->data.delete_pointer_cond.cond);
-                break;
-            case EAT_CATCHBLOCK:
-                packexc->data.catch_block.catch_object = (void *) CInline_GetLocalID(exc->data.catch_block.catch_object);
-                packexc->data.catch_block.catch_info_object = (void *) CInline_GetLocalID(exc->data.catch_block.catch_info_object);
-                packexc->data.catch_block.catch_label = (void *) CInline_GetStatementNumber(start->next, exc->data.catch_block.catch_label->stmt);
-                packexc->data.catch_block.catch_typeid = exc->data.catch_block.catch_typeid;
-                packexc->data.catch_block.catch_type = exc->data.catch_block.catch_type;
-                packexc->data.catch_block.catch_qual = exc->data.catch_block.catch_qual;
-                break;
-            case EAT_ACTIVECATCHBLOCK:
-                packexc->data.active_catch_block.catch_info_object = (void *) CInline_GetLocalID(exc->data.active_catch_block.catch_info_object);
-                packexc->data.active_catch_block.call_dtor = exc->data.active_catch_block.call_dtor;
-                break;
-            case EAT_SPECIFICATION:
-                packexc->data.specification.unexp_ids = exc->data.specification.unexp_ids;
-                packexc->data.specification.unexp_id = exc->data.specification.unexp_id;
-                packexc->data.specification.unexp_label = (void *) CInline_GetStatementNumber(start->next, exc->data.specification.unexp_label->stmt);
-                packexc->data.specification.unexp_info_object = (void *) CInline_GetLocalID(exc->data.specification.unexp_info_object);
-                break;
-            case EAT_TERMINATE:
-                break;
-            default:
-                CError_FATAL(3720);
-        }
-
-        exc = exc->prev;
-    }
-
-    return last;
-}
-
-void CInline_PackIFunctionData(CI_FuncData *funcdata, Statement *stmt, Object *object) {
-    ObjectList *list;
-    CI_Var *var;
-    Statement *scan;
-    CI_Statement *packstmt;
-    int i;
-
-    cinline_first_stmt = stmt->next;
-    memclrw(funcdata, sizeof(CI_FuncData));
-
-    funcdata->can_inline = CInline_CanInline(object, stmt->next);
-
-    if (copts.filesyminfo) {
-        funcdata->fileoffset = cparser_fileoffset;
-        funcdata->fileoffset.is_inline = 1;
-        funcdata->symdecloffset = symdecloffset;
-        funcdata->functionbodyoffset = functionbodyoffset;
-        funcdata->functionbodypath = functionbodypath;
-        funcdata->symdeclend = symdeclend;
-    }
-
-    list = arguments;
-    i = 0;
-    while (list) {
-        list = list->next;
-        i++;
-    }
-
-    if ((funcdata->numarguments = i) > 0) {
-        loc_args = funcdata->arguments = galloc(sizeof(CI_Var) * i);
-        memclrw(funcdata->arguments, sizeof(CI_Var) * i);
-
-        for (list = arguments, var = funcdata->arguments; list; list = list->next, var++) {
-            var->name = list->object->name;
-            var->type = list->object->type;
-            var->qual = list->object->qual;
-            var->sflags = CInline_GetObjectSFlags(list->object);
-            var->xD = 0;
-            var->xE = 1;
-        }
-    }
-
-    list = locals;
-    i = 0;
-    while (list) {
-        if (list->object->datatype == DLOCAL)
-            i++;
-        list = list->next;
-    }
-
-    if ((funcdata->numlocals = i) > 0) {
-        loc_vars = funcdata->locals = galloc(sizeof(CI_Var) * i);
-        memclrw(funcdata->locals, sizeof(CI_Var) * i);
-
-        for (list = locals, var = funcdata->locals; list; list = list->next) {
-            if (list->object->datatype == DLOCAL) {
-                var->name = list->object->name;
-                var->type = list->object->type;
-                var->qual = list->object->qual;
-                var->sflags = CInline_GetObjectSFlags(list->object);
-                var->xD = 0;
-                var->xE = 0;
-                var++;
-            }
-        }
-    }
-
-    scan = stmt->next;
-    i = 0;
-    while (scan) {
-        scan = scan->next;
-        i++;
-    }
-
-    funcdata->numstatements = i;
-    funcdata->statements = galloc(sizeof(CI_Statement) * i);
-
-    for (scan = stmt->next, packstmt = funcdata->statements; scan; scan = scan->next, packstmt++) {
-        packstmt->type = scan->type;
-        packstmt->flags = scan->flags;
-        packstmt->value = scan->value;
-        packstmt->dobjstack = CInline_PackActions(stmt, scan);
-        packstmt->sourceoffset = scan->sourceoffset;
-        packstmt->sourcefilepath = scan->sourcefilepath;
-
-        switch (scan->type) {
-            case ST_NOP:
-            case ST_LABEL:
-                break;
-            case ST_EXPRESSION:
-            case ST_BEGINCATCH:
-            case ST_ENDCATCH:
-            case ST_ENDCATCHDTOR:
-            case ST_GOTOEXPR:
-                packstmt->u.expr = CInline_CopyExpression(scan->expr, CopyMode2);
-                break;
-            case ST_RETURN:
-                if (scan->expr)
-                    packstmt->u.expr = CInline_CopyExpression(scan->expr, CopyMode2);
-                else
-                    packstmt->u.expr = NULL;
-                break;
-            case ST_GOTO:
-                packstmt->u.statementnum = CInline_GetStatementNumber(stmt->next, scan->label->stmt);
-                break;
-            case ST_IFGOTO:
-            case ST_IFNGOTO:
-                packstmt->u.ifgoto.expr = CInline_CopyExpression(scan->expr, CopyMode2);
-                packstmt->u.ifgoto.statementnum = CInline_GetStatementNumber(stmt->next, scan->label->stmt);
-                break;
-            case ST_SWITCH:
-                packstmt->u.switchdata = CInline_PackSwitch(stmt->next, scan);
-                break;
-            case ST_ASM:
-                InlineAsm_PackAsmStatement(scan, stmt->next, &packstmt->u.asmdata.data, &packstmt->u.asmdata.size);
-                break;
-            default:
-                CError_FATAL(3862);
-        }
-    }
-}
-
-void CInline_UnpackIFunctionData(Object *object, CI_FuncData *funcdata, Statement *firstStmt) {
-    CLabel **labels;
-    CI_Var *var;
-    ObjectList *last;
-    Statement *stmt;
-    CI_Statement *packstmt;
-    int i;
-
-    cparser_fileoffset = funcdata->fileoffset;
-    symdecloffset = funcdata->symdecloffset;
-    functionbodyoffset = funcdata->functionbodyoffset;
-    functionbodypath = funcdata->functionbodypath;
-    symdeclend = funcdata->symdeclend;
-
-    for (i = 0, var = funcdata->arguments; i < funcdata->numarguments; i++, var++) {
-        if (i == 0) {
-            last = lalloc(sizeof(ObjectList));
-            arguments = last;
-        } else {
-            last->next = lalloc(sizeof(ObjectList));
-            last = last->next;
-        }
-
-        object = galloc(sizeof(Object));
-        memclrw(object, sizeof(Object));
-        last->object = object;
-        last->next = NULL;
-
-        object->otype = OT_OBJECT;
-        object->access = ACCESSPUBLIC;
-        object->datatype = DLOCAL;
-        object->name = var->name;
-        object->type = var->type;
-        object->qual = var->qual;
-        CInline_SetObjectSFlags(object, var->sflags);
-        CFunc_SetupLocalVarInfo(object);
-
-        if (funcdata->fileoffset.file) {
-            object->u.var.info->deftoken.tokenfile = funcdata->fileoffset.file;
-            object->u.var.info->deftoken.tokenoffset = funcdata->functionbodyoffset;
-        }
-    }
-
-    for (i = 0, var = funcdata->locals; i < funcdata->numlocals; i++, var++) {
-        if (i == 0) {
-            last = lalloc(sizeof(ObjectList));
-            locals = last;
-        } else {
-            last->next = lalloc(sizeof(ObjectList));
-            last = last->next;
-        }
-
-        object = galloc(sizeof(Object));
-        memclrw(object, sizeof(Object));
-        last->object = object;
-        last->next = NULL;
-
-        object->otype = OT_OBJECT;
-        object->access = ACCESSPUBLIC;
-        object->datatype = DLOCAL;
-        object->name = var->name;
-        object->type = var->type;
-        object->qual = var->qual;
-        CInline_SetObjectSFlags(object, var->sflags);
-        CFunc_SetupLocalVarInfo(object);
-
-        if (funcdata->fileoffset.file) {
-            object->u.var.info->deftoken.tokenfile = funcdata->fileoffset.file;
-            object->u.var.info->deftoken.tokenoffset = funcdata->functionbodyoffset;
-        }
-    }
-
-    enode_idtrans = NULL;
-    cinline_label_trans = NULL;
-
-    labels = lalloc(sizeof(CLabel *) * funcdata->numstatements);
-    memclrw(labels, sizeof(CLabel *) * funcdata->numstatements);
-
-    for (i = 0, stmt = firstStmt, packstmt = funcdata->statements; i < funcdata->numstatements; i++, packstmt++) {
-        stmt->next = lalloc(sizeof(Statement));
-        stmt = stmt->next;
-
-        stmt->type = packstmt->type;
-        stmt->flags = packstmt->flags;
-        stmt->value = packstmt->value;
-        stmt->sourceoffset = packstmt->sourceoffset;
-        stmt->sourcefilepath = packstmt->sourcefilepath;
-        stmt->dobjstack = CInline_UnpackActions(packstmt, 0);
-        stmt->next = NULL;
-
-        switch (stmt->type) {
-            case ST_NOP:
-            case ST_GOTO:
-            case ST_ASM:
-                break;
-            case ST_EXPRESSION:
-            case ST_BEGINCATCH:
-            case ST_ENDCATCH:
-            case ST_ENDCATCHDTOR:
-            case ST_GOTOEXPR:
-                stmt->expr = CInline_CopyExpression(packstmt->u.expr, CopyMode3);
-                break;
-            case ST_RETURN:
-                if (packstmt->u.expr)
-                    stmt->expr = CInline_CopyExpression(packstmt->u.expr, CopyMode3);
-                else
-                    stmt->expr = NULL;
-                break;
-            case ST_LABEL:
-                labels[i] = stmt->label = newlabel();
-                stmt->label->stmt = stmt;
-                break;
-            case ST_IFGOTO:
-            case ST_IFNGOTO:
-                stmt->expr = CInline_CopyExpression(packstmt->u.ifgoto.expr, CopyMode3);
-                break;
-            case ST_SWITCH:
-                stmt->expr = CInline_CopyExpression(packstmt->u.switchdata->expr, CopyMode3);
-                break;
-            default:
-                CError_FATAL(4017);
-        }
-    }
-
-    for (stmt = firstStmt->next, packstmt = funcdata->statements; stmt; stmt = stmt->next, packstmt++) {
-        switch (stmt->type) {
-            case ST_GOTO:
-                CError_ASSERT(4024, stmt->label = labels[packstmt->u.statementnum]);
-                break;
-            case ST_IFGOTO:
-            case ST_IFNGOTO:
-                CError_ASSERT(4029, stmt->label = labels[packstmt->u.ifgoto.statementnum]);
-                break;
-            case ST_SWITCH:
-                CInline_UnpackSwitch(stmt, packstmt, labels);
-                break;
-            case ST_ASM:
-                InlineAsm_UnpackAsmStatement(stmt, labels, 0, packstmt->u.asmdata.data, packstmt->u.asmdata.size);
-                break;
-        }
-    }
-
-    cinline_first_stmt = firstStmt->next;
-
-    while (cinline_label_trans) {
-        CError_ASSERT(4045, *cinline_label_trans->labelptr = labels[cinline_label_trans->id]);
-        cinline_label_trans = cinline_label_trans->next;
-    }
-}
-
-static void CInline_GenIFunctionCode(Object *object, CI_FuncData *func, UInt8 unk) {
-    Boolean saveDebugInfo;
-    CScopeSave saveScope;
-    Statement firstStmt;
-
-    if (cparamblkptr->precompile != 1 && func) {
-        ObjGen_SetupSym();
-        CScope_SetFunctionScope(object, &saveScope);
-        CFunc_FuncGenSetup(&firstStmt, object);
-        CInline_UnpackIFunctionData(object, func, &firstStmt);
-
-        saveDebugInfo = copts.filesyminfo;
-        if (copts.nosyminline || (!symdecloffset && !symdeclend))
-            copts.filesyminfo = 0;
-
-        expanding_function = object;
-        recursive_inline = 0;
-        CInline_Expand(&firstStmt);
-
-        if (!anyerrors) {
-            if (copts.filesyminfo)
-                CPrep_SetSourceFile(&cparser_fileoffset);
-            CodeGen_Generator(&firstStmt, object, unk, 0);
-        }
-
-        CScope_RestoreScope(&saveScope);
-        copts.filesyminfo = saveDebugInfo;
-    }
-}
-
-void CInline_AddDefaultFunctionAction(Object *object) {
-    CI_Action *action;
-
-    for (action = cinline_actionlist; action; action = action->next) {
-        if (action->obj == object)
-            return;
-    }
-
-    action = galloc(sizeof(CI_Action));
-    memclrw(action, sizeof(CI_Action));
-
-    action->actiontype = CI_ActionDefaultFunc;
-    action->obj = object;
-
-    action->next = cinline_actionlist;
-    cinline_actionlist = action;
-}
-
-void CInline_AddInlineFunctionAction(Object *object, TypeClass *tclass, FileOffsetInfo *fileoffset, TokenStream *stream, Boolean flag) {
-    CI_Action *action;
-
-    for (action = flag ? cinline_tactionlist : cinline_actionlist; action; action = action->next) {
-        if (action->obj == object)
-            return;
-    }
-
-    CError_ASSERT(4132, IS_TYPE_FUNC(object->type));
-
-    TYPE_FUNC(object->type)->flags |= FUNC_IS_TEMPL_INSTANCE;
-
-    action = galloc(sizeof(CI_Action));
-    memclrw(action, sizeof(CI_Action));
-
-    action->actiontype = CI_ActionInlineFunc;
-    action->obj = object;
-    action->u.inlinefunc.tclass = tclass;
-    action->u.inlinefunc.fileoffset = *fileoffset;
-    action->u.inlinefunc.stream = *stream;
-
-    if (flag) {
-        action->next = cinline_tactionlist;
-        cinline_tactionlist = action;
-        TYPE_FUNC(object->type)->flags |= FUNC_FLAGS_200000;
-    } else {
-        action->next = cinline_actionlist;
-        cinline_actionlist = action;
-    }
-}
-
-void CInline_AddMemberFunctionAction(Object *object, TemplClass *templ, TemplClassInst *inst, TemplateMember *tmemb) {
-    CI_Action *action;
-
-    for (action = cinline_tactionlist; action; action = action->next) {
-        if (action->obj == object)
-            return;
-    }
-
-    action = galloc(sizeof(CI_Action));
-    memclrw(action, sizeof(CI_Action));
-
-    action->actiontype = CI_ActionMemberFunc;
-    action->obj = object;
-    action->u.memberfunc.templ = templ;
-    action->u.memberfunc.inst = inst;
-    action->u.memberfunc.tmemb = tmemb;
-
-    action->next = cinline_tactionlist;
-    cinline_tactionlist = action;
-
-    TYPE_FUNC(object->type)->flags |= FUNC_FLAGS_200000;
-}
-
-void CInline_AddTemplateFunctionAction(Object *object, TemplateFunction *func, TemplFuncInstance *inst) {
-    CI_Action *action;
-
-    for (action = cinline_tactionlist; action; action = action->next) {
-        if (action->obj == object)
-            return;
-    }
-
-    action = galloc(sizeof(CI_Action));
-    memclrw(action, sizeof(CI_Action));
-
-    action->actiontype = CI_ActionTemplateFunc;
-    action->obj = object;
-    action->u.templatefunc.func = func;
-    action->u.templatefunc.inst = inst;
-
-    action->next = cinline_tactionlist;
-    cinline_tactionlist = action;
-
-    TYPE_FUNC(object->type)->flags |= FUNC_FLAGS_200000;
-}
-
-static void CInline_AddFRefList_Object(Object *object) {
-    ObjectList *list;
-
-    if (
-        !(object->datatype == DFUNC || object->datatype == DVFUNC) ||
-        (object->flags & OBJECT_DEFINED) ||
-        IS_TEMPL_FUNC(object->type)
-        )
-        return;
-
-    for (list = cinline_freflist; list; list = list->next) {
-        if (list->object == object)
-            return;
-    }
-
-    list = lalloc(sizeof(ObjectList));
-    list->object = object;
-    list->next = cinline_freflist;
-    cinline_freflist = list;
-
-    if ((object->qual & Q_INLINE) && object->u.func.u.ifuncdata)
-        CInline_AddFRefList_InlineFunc(object->u.func.u.ifuncdata);
-}
-
-static void CInline_AddFRefList_ExAction(ExceptionAction *exc) {
-    while (exc) {
-        switch (exc->type) {
-            case EAT_DESTROYLOCAL:
-                CInline_AddFRefList_Object(exc->data.destroy_local.dtor);
-                break;
-            case EAT_DESTROYLOCALCOND:
-                CInline_AddFRefList_Object(exc->data.destroy_local_cond.dtor);
-                break;
-            case EAT_DESTROYLOCALOFFSET:
-                CInline_AddFRefList_Object(exc->data.destroy_local_offset.dtor);
-                break;
-            case EAT_DESTROYLOCALPOINTER:
-                CInline_AddFRefList_Object(exc->data.destroy_local_pointer.dtor);
-                break;
-            case EAT_DESTROYLOCALARRAY:
-                CInline_AddFRefList_Object(exc->data.destroy_local_array.dtor);
-                break;
-            case EAT_DESTROYPARTIALARRAY:
-                CInline_AddFRefList_Object(exc->data.destroy_partial_array.dtor);
-                break;
-            case EAT_DESTROYMEMBER:
-            case EAT_DESTROYBASE:
-                CInline_AddFRefList_Object(exc->data.destroy_member.dtor);
-                break;
-            case EAT_DESTROYMEMBERCOND:
-                CInline_AddFRefList_Object(exc->data.destroy_member_cond.dtor);
-                break;
-            case EAT_DESTROYMEMBERARRAY:
-                CInline_AddFRefList_Object(exc->data.destroy_member_array.dtor);
-                break;
-            case EAT_DELETEPOINTER:
-            case EAT_DELETELOCALPOINTER:
-                CInline_AddFRefList_Object(exc->data.delete_pointer.deletefunc);
-                break;
-            case EAT_DELETEPOINTERCOND:
-                CInline_AddFRefList_Object(exc->data.delete_pointer_cond.deletefunc);
-                break;
-            case EAT_CATCHBLOCK:
-            case EAT_ACTIVECATCHBLOCK:
-            case EAT_SPECIFICATION:
-            case EAT_TERMINATE:
-                break;
-            default:
-                CError_FATAL(4307);
-        }
-        exc = exc->prev;
-    }
-}
-
-static void CInline_AddFRefList_ExprCB(ENode *expr) {
-    CInline_AddFRefList_Object(expr->data.objref);
-}
-
-static void CInline_AddFRefList_Expr(ENode *expr) {
-    CExpr_SearchExprTree(expr, CInline_AddFRefList_ExprCB, 1, EOBJREF);
-}
-
-static void CInline_AddFRefList_Statement(Statement *stmt) {
-    while (stmt) {
-        if (stmt->dobjstack)
-            CInline_AddFRefList_ExAction(stmt->dobjstack);
-
-        switch (stmt->type) {
-            case ST_NOP:
-            case ST_LABEL:
-            case ST_GOTO:
-            case ST_BEGINCATCH:
-            case ST_ENDCATCH:
-            case ST_ENDCATCHDTOR:
-            case ST_ASM:
-                break;
-            case ST_RETURN:
-                if (!stmt->expr)
-                    break;
-            case ST_EXPRESSION:
-            case ST_SWITCH:
-            case ST_IFGOTO:
-            case ST_IFNGOTO:
-            case ST_GOTOEXPR:
-                CInline_AddFRefList_Expr(stmt->expr);
-                break;
-            default:
-                CError_FATAL(4368);
-        }
-
-        stmt = stmt->next;
-    }
-}
-
-static void CInline_AddFRefList_InlineFunc(CI_FuncData *data) {
-    short i;
-    CI_Statement *stmt;
-    ExceptionAction *exc;
-
-    for (i = 0; i < data->numstatements; i++) {
-        stmt = data->statements + i;
-
-        switch (stmt->type) {
-            case ST_NOP:
-            case ST_LABEL:
-            case ST_GOTO:
-            case ST_ASM:
-                break;
-            case ST_EXPRESSION:
-            case ST_BEGINCATCH:
-            case ST_ENDCATCH:
-            case ST_ENDCATCHDTOR:
-            case ST_GOTOEXPR:
-                CInline_AddFRefList_Expr(stmt->u.expr);
-                break;
-            case ST_RETURN:
-                if (stmt->u.expr)
-                    CInline_AddFRefList_Expr(stmt->u.expr);
-                break;
-            case ST_IFGOTO:
-            case ST_IFNGOTO:
-                CInline_AddFRefList_Expr(stmt->u.ifgoto.expr);
-                break;
-            case ST_SWITCH:
-                CInline_AddFRefList_Expr(stmt->u.switchdata->expr);
-                break;
-            default:
-                CError_FATAL(4420);
-        }
-
-        for (exc = data->statements[i].dobjstack; exc; exc = exc->prev) {
-            switch (exc->type) {
-                case EAT_DESTROYLOCAL:
-                    CInline_AddFRefList_Object(exc->data.destroy_local.dtor);
-                    break;
-                case EAT_DESTROYLOCALCOND:
-                    CInline_AddFRefList_Object(exc->data.destroy_local_cond.dtor);
-                    break;
-                case EAT_DESTROYLOCALOFFSET:
-                    CInline_AddFRefList_Object(exc->data.destroy_local_offset.dtor);
-                    break;
-                case EAT_DESTROYLOCALPOINTER:
-                    CInline_AddFRefList_Object(exc->data.destroy_local_pointer.dtor);
-                    break;
-                case EAT_DESTROYLOCALARRAY:
-                    CInline_AddFRefList_Object(exc->data.destroy_local_array.dtor);
-                    break;
-                case EAT_DESTROYPARTIALARRAY:
-                    break;
-                case EAT_DESTROYMEMBER:
-                case EAT_DESTROYBASE:
-                    CInline_AddFRefList_Object(exc->data.destroy_member.dtor);
-                    break;
-                case EAT_DESTROYMEMBERCOND:
-                    CInline_AddFRefList_Object(exc->data.destroy_member_cond.dtor);
-                    break;
-                case EAT_DESTROYMEMBERARRAY:
-                    CInline_AddFRefList_Object(exc->data.destroy_member_array.dtor);
-                    break;
-                case EAT_DELETEPOINTER:
-                case EAT_DELETELOCALPOINTER:
-                    CInline_AddFRefList_Object(exc->data.delete_pointer.deletefunc);
-                    break;
-                case EAT_DELETEPOINTERCOND:
-                    CInline_AddFRefList_Object(exc->data.delete_pointer_cond.deletefunc);
-                    break;
-                case EAT_CATCHBLOCK:
-                case EAT_ACTIVECATCHBLOCK:
-                case EAT_SPECIFICATION:
-                case EAT_TERMINATE:
-                    break;
-                default:
-                    CError_FATAL(4470);
-            }
-        }
-    }
-}
-
-static void CInline_GenerateTemplateInline(Object *object) {
-    CI_Action **ptr;
-    CI_Action *action;
-
-    ptr = &cinline_tactionlist;
-    while ((action = *ptr)) {
-        if (object == action->obj) {
-            *ptr = action->next;
-            action->next = cinline_actionlist;
-            cinline_actionlist = action;
-
-            TYPE_FUNC(object->type)->flags &= ~FUNC_FLAGS_200000;
-            return;
-        }
-
-        ptr = &action->next;
-    }
-
-    CError_FATAL(4499);
-}
-
-void CInline_ObjectAddrRef(Object *object) {
-    CI_FuncData *funcdata;
-
-    object->flags |= OBJECT_FLAGS_2;
-
-    switch (object->datatype) {
-        case DFUNC:
-        case DVFUNC:
-            if (
-                (object->qual & Q_INLINE) &&
-                (funcdata = object->u.func.u.ifuncdata) &&
-                !(object->flags & OBJECT_DEFINED) &&
-                !(TYPE_FUNC(object->type)->flags & FUNC_IS_TEMPL)
-                )
-            {
-                CI_Export *export = galloc(sizeof(CI_Export));
-
-                export->object = object;
-                export->funcdata = funcdata;
-                export->xC = 0;
-
-                export->next = cinline_exportlist;
-                cinline_exportlist = export;
-
-                object->flags |= OBJECT_DEFINED;
-                return;
-            }
-            else if (
-                (TYPE_FUNC(object->type)->flags & FUNC_AUTO_GENERATED) &&
-                !(TYPE_FUNC(object->type)->flags & FUNC_DEFINED)
-                )
-            {
-                CInline_AddDefaultFunctionAction(object);
-                return;
-            }
-            else if (TYPE_FUNC(object->type)->flags & FUNC_FLAGS_200000)
-            {
-                CInline_GenerateTemplateInline(object);
-                return;
-            }
-            return;
-
-        case DALIAS:
-            CInline_ObjectAddrRef(object->u.alias.object);
-            return;
-
-        case DDATA:
-            if (object->qual & Q_INLINE_DATA)
-                CInit_ExportConst(object);
-
-            if (object->flags & OBJECT_LAZY) {
-                object->flags &= ~OBJECT_LAZY;
-                CParser_CallBackAction(object);
-            }
-            return;
-    }
-}
-
-static Boolean CInline_CheckDependencies(ObjectList *list) {
-    Object *object;
-    Boolean result;
-
-    result = 0;
-
-    while (list) {
-        object = list->object;
-
-        if (
-            (TYPE_FUNC(object->type)->flags & FUNC_AUTO_GENERATED) &&
-            !(TYPE_FUNC(object->type)->flags & FUNC_DEFINED)
-            )
-        {
-            CInline_AddDefaultFunctionAction(object);
-            result = 1;
-        }
-        else if (
-            (object->qual & Q_IS_TEMPLATED) &&
-            CTempl_InlineFunctionCheck(object)
-            )
-        {
-            result = 1;
-        }
-        else {
-            CI_Action *action;
-            for (action = cinline_actionlist; action; action = action->next) {
-                if (object == action->obj) {
-                    result = 1;
-                    break;
-                }
-            }
-
-            if (TYPE_FUNC(object->type)->flags & FUNC_FLAGS_200000) {
-                CInline_GenerateTemplateInline(object);
-                result = 1;
-            }
-        }
-
-        list = list->next;
-    }
-
-    return result;
-}
-
-static Boolean CInline_IsSmallFunction(Object *object, Statement *stmt) {
-    SInt32 statementCount;
-    ObjectList *list;
-    SInt32 localSize;
-
-    statementCount = 0;
-    while (stmt) {
-        if (stmt->type != ST_NOP && stmt->type != ST_LABEL)
-            statementCount++;
-        if (statementCount > 15)
-            return 0;
-        stmt = stmt->next;
-    }
-
-    for (list = locals, localSize = 0; list; list = list->next)
-        localSize += list->object->type->size;
-
-    if (localSize > 1024)
-        return 0;
-
-    return 1;
-}
-
-static Boolean CInline_NoFPLocals(void) {
-    ObjectList *list;
-
-    for (list = locals; list; list = list->next) {
-        if (IS_TYPE_FLOAT(list->object->type))
-            return 0;
-    }
-
-    return 1;
-}
-
-void CInline_GenFunc(Statement *stmt, Object *object, UInt8 unk) {
-    CI_FuncData *funcdata;
-    CI_Export *export;
-    Boolean flag24;
-    Boolean flag30;
-
-    TYPE_FUNC(object->type)->flags |= OBJECT_FLAGS_2;
-
-    flag24 = 0;
-    flag30 = 0;
-    if (!(object->qual & Q_INLINE)) {
-        if (
-            copts.auto_inline &&
-            !copts.dontinline &&
-            CInline_CanInline(object, stmt->next) &&
-            CInline_IsSmallFunction(object, stmt->next)
-            )
-        {
-            flag24 = 1;
-            flag30 = 1;
-            TYPE_FUNC(object->type)->flags |= FUNC_FLAGS_800;
-        }
-    } else {
-        flag30 = 1;
-    }
-
-    if (flag30) {
-        COpt_SimpleOptimizer(object, stmt);
-
-        funcdata = galloc(sizeof(CI_FuncData));
-        CInline_PackIFunctionData(funcdata, stmt, object);
-
-        object->u.func.u.ifuncdata = funcdata;
-
-        if (!flag24 && !(object->flags & OBJECT_FLAGS_2)) {
-            if (cinline_gendeps) {
-                cinline_freflist = NULL;
-                CInline_AddFRefList_Statement(stmt);
-                CInline_CheckDependencies(cinline_freflist);
-            }
-            return;
-        }
-    }
-
-    object->flags |= OBJECT_DEFINED;
-
-    cinline_freflist = NULL;
-    CInline_AddFRefList_Statement(stmt);
-
-    if (CInline_CheckDependencies(cinline_freflist) || copts.defer_codegen) {
-        if (!flag30) {
-            funcdata = galloc(sizeof(CI_FuncData));
-            CInline_PackIFunctionData(funcdata, stmt, object);
-        } else {
-            funcdata = object->u.func.u.ifuncdata;
-        }
-
-        export = galloc(sizeof(CI_Export));
-        export->object = object;
-        export->funcdata = funcdata;
-        export->xC = unk;
-
-        export->next = cinline_exportlist;
-        cinline_exportlist = export;
-
-        return;
-    }
-
-    expanding_function = object;
-    recursive_inline = 0;
-    CInline_Expand(stmt);
-
-    if (copts.filesyminfo)
-        CPrep_SetSourceFile(&cparser_fileoffset);
-
-    if (!anyerrors)
-        CodeGen_Generator(stmt, object, unk, 0);
-}
-
-static void CInline_GenerateDefaultFunc(Object *object) {
-    TypeClass *tclass;
-
-    CError_ASSERT(4770, TYPE_FUNC(object->type)->flags & FUNC_AUTO_GENERATED);
-    CError_ASSERT(4771, TYPE_FUNC(object->type)->flags & FUNC_METHOD);
-
-    tclass = TYPE_METHOD(object->type)->theclass;
-
-    if (object == CClass_DefaultConstructor(tclass)) {
-        if (object->u.func.defargdata)
-            CABI_MakeDefaultArgConstructor(tclass, object);
-        else
-            CABI_MakeDefaultConstructor(tclass, object);
-    } else if (object == CClass_CopyConstructor(tclass)) {
-        CABI_MakeDefaultCopyConstructor(tclass, object);
-    } else if (object == CClass_AssignmentOperator(tclass)) {
-        CABI_MakeDefaultAssignmentOperator(tclass, object);
-    } else if (object == CClass_Destructor(tclass)) {
-        CABI_MakeDefaultDestructor(tclass, object);
-    } else {
-        CError_FATAL(4805);
-    }
-}
-
-static TemplClassInst *CInline_FindNestedTemplInst(TypeClass *tclass) {
-    NameSpace *nspace;
-
-    while (tclass) {
-        if ((tclass->flags & CLASS_IS_TEMPL_INST))
-            return TEMPL_CLASS_INST(tclass);
-
-        if (!copts.template_patch)
-            break;
-
-        nspace = tclass->nspace->parent;
-        tclass = NULL;
-        while (nspace) {
-            if (nspace->theclass) {
-                tclass = nspace->theclass;
-                break;
-            }
-            nspace = nspace->parent;
-        }
-    }
-
-    return NULL;
-}
-
-static void CInline_GenerateInlineFunc(CI_Action *action) {
-    Object *object;
-    TemplClassInst *inst;
-    DeclInfo di;
-    SInt32 streamState;
-
-    object = action->obj;
-
-    CPrep_StreamInsert(&action->u.inlinefunc.stream, &streamState);
-    cparser_fileoffset = action->u.inlinefunc.fileoffset;
-    symdecloffset = cparser_fileoffset.tokenline;
-
-    switch ((tk = lex())) {
-        case ':':
-        case '{':
-        case TK_TRY:
-            break;
-        default:
-            CError_FATAL(4860);
-    }
-
-    symdecltoken = *CPrep_CurStreamElement();
-
-    TYPE_FUNC(object->type)->flags &= ~FUNC_DEFINED;
-    if (IS_TYPE_METHOD(object->type) && (inst = CInline_FindNestedTemplInst(TYPE_METHOD(object->type)->theclass))) {
-        CTempl_ParseInstanceScopeFunction(object, inst, NULL);
-    } else {
-        memclrw(&di, sizeof(di));
-        if (action->u.inlinefunc.tclass) {
-            if ((inst = CInline_FindNestedTemplInst(action->u.inlinefunc.tclass))) {
-                CTempl_ParseInstanceScopeFunction(object, inst, action->u.inlinefunc.tclass);
-            } else {
-                CFunc_ParseFuncDef(object, &di, action->u.inlinefunc.tclass, 0, 0, NULL);
-            }
-        } else {
-            CFunc_ParseFuncDef(object, &di, NULL, 0, 0, NULL);
-        }
-    }
-
-    CPrep_StreamRemove(&action->u.inlinefunc.stream, &streamState);
-}
-
-Boolean CInline_CanFreeLHeap(void) {
-    CI_Action *action;
-
-    if (!anyerrors) {
-        for (action = cinline_actionlist; action; action = action->next) {
-            if (action->actiontype == CI_ActionInlineFunc)
-                return 0;
-        }
-    }
-
-    return 1;
-}
-
-Boolean CInline_GenerateDeferredFuncs(void) {
-    CI_Action *action;
-    CI_Export *export;
-
-    if (!anyerrors) {
-        if ((action = cinline_actionlist)) {
-            cinline_actionlist = action->next;
-            cinline_gendeps = 1;
-
-            switch (action->actiontype) {
-                case CI_ActionDefaultFunc:
-                    CInline_GenerateDefaultFunc(action->obj);
-                    break;
-                case CI_ActionInlineFunc:
-                    if (!(action->obj->flags & OBJECT_DEFINED))
-                        CInline_GenerateInlineFunc(action);
-                    break;
-                case CI_ActionMemberFunc:
-                    if (!(TYPE_FUNC(action->obj->type)->flags & FUNC_DEFINED))
-                        CTempl_InstantiateMember(
-                            action->u.memberfunc.templ, action->u.memberfunc.inst,
-                            action->u.memberfunc.tmemb, action->obj, 0);
-                    break;
-                case CI_ActionTemplateFunc:
-                    if (!(TYPE_FUNC(action->obj->type)->flags & FUNC_DEFINED) && !action->u.templatefunc.inst->is_specialized)
-                        CTempl_GenFuncInstance(action->u.templatefunc.func, action->u.templatefunc.inst, 0);
-                    break;
-                default:
-                    CError_FATAL(5001);
-            }
-
-            cinline_gendeps = 0;
-            return 1;
-        } else {
-            if ((export = cinline_exportlist) && !copts.defer_codegen) {
-                cinline_exportlist = export->next;
-                CInline_GenIFunctionCode(export->object, export->funcdata, export->xC);
-                return 1;
-            }
-        }
-    }
-
-    return 0;
-}
-
-static InitExpr *CInline_InitTemplateData(InitExpr *init) {
-    Statement *stmt;
-    CLabel *label;
-    Object *object;
-    Object *data;
-
-    object = init->object;
-
-    data = CParser_NewCompilerDefDataObject();
-    data->type = TYPE(&stsignedchar);
-    data->name = CParser_NameConcat("__init__", CMangler_GetLinkName(object)->name);
-    data->qual = Q_WEAK;
-    CInit_DeclareData(data, NULL, NULL, data->type->size);
-
-    stmt = CFunc_AppendStatement(ST_IFGOTO);
-    stmt->expr = create_objectnode(data);
-    label = newlabel();
-    stmt->label = label;
-
-    do {
-        stmt = CFunc_AppendStatement(ST_EXPRESSION);
-        stmt->expr = CInline_CopyExpression(init->expr, CopyMode0);
-        init = init->next;
-    } while (init && init->object == object);
-
-    stmt = CFunc_AppendStatement(ST_EXPRESSION);
-    stmt->expr = makediadicnode(create_objectnode(data), intconstnode(TYPE(&stsignedchar), 1), EASS);
-
-    stmt = CFunc_AppendStatement(ST_LABEL);
-    stmt->label = label;
-    label->stmt = stmt;
-
-    return init;
-}
-
-void CInline_Finish(void) {
-    NameSpace *nspace;
-    Boolean saveDebugInfo;
-    Statement firstStmt;
-    Statement *stmt;
-    InitExpr *init;
-    Boolean doMore;
-
-    if (!init_expressions || anyerrors)
-        return;
-
-    cinline_freflist = NULL;
-
-    for (init = init_expressions; init; init = init->next)
-        CInline_AddFRefList_Expr(init->expr);
-
-    CInline_CheckDependencies(cinline_freflist);
-
-    do {
-        doMore = CInline_GenerateDeferredFuncs();
-    } while (doMore);
-
-    nspace = CFunc_FuncGenSetup(&firstStmt, NULL);
-    saveDebugInfo = copts.filesyminfo;
-    copts.filesyminfo = 0;
-
-    init = init_expressions;
-    while (init) {
-        if (init->object->nspace->theclass && (init->object->nspace->theclass->flags & CLASS_IS_TEMPL_INST)) {
-            init = CInline_InitTemplateData(init);
-        } else {
-            stmt = CFunc_AppendStatement(ST_EXPRESSION);
-            stmt->expr = CInline_CopyExpression(init->expr, CopyMode0);
-            init = init->next;
-        }
-    }
-
-    CFunc_CodeCleanup(&firstStmt);
-
-    expanding_function = NULL;
-    recursive_inline = 0;
-    CInline_Expand(&firstStmt);
-
-    if (!anyerrors) {
-        if (copts.filesyminfo)
-            CPrep_SetSourceFile(&cparser_fileoffset);
-        CodeGen_Generator(&firstStmt, NULL, 0, 1);
-    }
-
-    cscope_current = nspace->parent;
-    copts.filesyminfo = saveDebugInfo;
-}