Method simulate

src/ast/ast_simulate.cpp:620–683

    }

    SimNode * Function::simulate (Context & context) const {
        if ( builtIn ) {
            DAS_ASSERTF(0, "can only simulate non built-in function");
            return nullptr;
        }
        for ( auto & ann : annotations ) {
            if ( ann->annotation->rtti_isFunctionAnnotation() ) {
                auto fann = (FunctionAnnotation *)(ann->annotation);
                string err;
                auto node = fann->simulate(&context, (Function*)this, ann->arguments, err);
                if ( !node ) {
                    if ( !err.empty() ) {
                        context.thisProgram->error("integration error, function failed to simulate", err, "",
                            at, CompilationError::internal_function_annotation );
                        return nullptr;
                    }
                } else {
                    return node;
                }
            }
        }
        SimulateVisitor sv(context);
        sv.simulateExpression(body);
        if ( fastCall ) {
            DAS_ASSERT(totalStackSize == sizeof(Prologue) && "function can't allocate stack");
            DAS_ASSERT((result->isWorkhorseType() || result->isVoid()) && "fastcall can only return a workhorse type");
            DAS_ASSERT(body->rtti_isBlock() && "function must contain a block");
            auto block = static_cast<ExprBlock*>(body);
            if ( block->list.size()==0 ) {
                DAS_ASSERT(block->inFunction && block->inFunction->result->isVoid() && "only void function produces fastcall NOP");
                return context.code->makeNode<SimNode_NOP>(block->at);
            }
            if ( block->list.back()->rtti_isReturn() ) {
                DAS_ASSERT(block->list.back()->rtti_isReturn() && "fastcall body expr is return");
                auto retE = static_cast<ExprReturn*>(block->list.back());
                if ( retE->subexpr ) {
                    return sv.getE(retE->subexpr);
                } else {
                    return context.code->makeNode<SimNode_NOP>(retE->at);
                }
            } else {
                return sv.getE(block->list.back());
            }
        } else {
#if DAS_DEBUGGER
            if ( context.debugger ) {
                auto sbody = sv.getE(body);
                if ( !sbody->rtti_node_isBlock() ) {
                    auto block = context.code->makeNode<SimNodeDebug_BlockNF>(sbody->debugInfo);
                    block->total = 1;
                    block->list = (SimNode **) context.code->allocate(sizeof(SimNode *)*1);
                    block->list[0] = sbody;
                    return block;
                } else {
                    return sbody;
                }
            } else {
                return sv.getE(body);