coroutines.h

/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

#ifndef MTROPOLIS_COROUTINES_H
#define MTROPOLIS_COROUTINES_H

#include "mtropolis/coroutine_protos.h"
#include "mtropolis/miniscript_protos.h"
#include "mtropolis/vthread.h"

namespace MTropolis {

struct CoroExecInstr;
struct CoroutineRuntimeState;

typedef VThreadState (*CoroutineFragmentFunction_t)(CoroutineRuntimeState &coroState);

struct CoroutineRuntimeState {
    CoroutineRuntimeState(VThread *vthread, CoroutineStackFrame2 *frame);

    VThread *_vthread;
    CoroutineStackFrame2 *_frame;
    bool _condition;
    MiniscriptInstructionOutcome _miniscriptOutcome;

private:
    CoroutineRuntimeState() = delete;
    CoroutineRuntimeState(const CoroutineRuntimeState &) = delete;
    CoroutineRuntimeState &operator=(const CoroutineRuntimeState&) = delete;
};

struct CompiledCoroutine {
    CompiledCoroutine();
    ~CompiledCoroutine();

    CoroutineFrameConstructor_t _frameConstructor;
    CoroutineGetFrameParametersFunction_t _getFrameParameters;
    bool _isVoidReturn;

    CoroExecInstr *_instructions;
    uint _numInstructions;

private:
    CompiledCoroutine(const CompiledCoroutine &) = delete;
    CompiledCoroutine &operator =(const CompiledCoroutine &) = delete;
};

struct CoroutineStackFrame2 : public VThreadTaskData {
    explicit CoroutineStackFrame2(const CompiledCoroutine *compiledCoro);
    virtual ~CoroutineStackFrame2();

    VThreadState execute(VThread *thread) override;

    const CompiledCoroutine *getCompiledCoroutine() const;

private:
    CoroutineStackFrame2() = delete;
    CoroutineStackFrame2(const CoroutineStackFrame2&) = delete;

    const CompiledCoroutine *_compiledCoro;
    uint _nextInstr;
};

enum class CoroOps {
    Invalid = 0,

    BeginFunction,
    EndFunction,

    IfCond,
    IfBody,
    Else,
    ElseIfCond,
    ElseIfBody,
    EndIf,

    WhileCond,
    WhileBody,
    EndWhile,

    ForNext,
    ForCond,
    ForBody,
    EndFor,

    Do,
    DoWhile,
    DoWhileCond,

    Return,

    Error,

    YieldToFunction,

    CheckMiniscript,

    Code,
};

struct ICoroutineCompiler {
    virtual ~ICoroutineCompiler();

    virtual void defineFunction(CoroutineFrameConstructor_t frameConstructor, CoroutineGetFrameParametersFunction_t frameGetParams) = 0;
    virtual void addOp(CoroOps op, CoroutineFragmentFunction_t fragmentFunc) = 0;
};

#define CORO_START_CODE_BLOCK(op) \
    compiler->addOp(op, [](CoroutineRuntimeState &coroRuntime) -> VThreadState {                        \
        Params *params = &static_cast<CoroStackFrame *>(coroRuntime._frame)->_params;                                           \
        Locals *locals = &static_cast<CoroStackFrame *>(coroRuntime._frame)->_locals;                                           \
        CoroutineReturnValueRef<ReturnValue_t> coroReturnValueRef = (static_cast<CoroStackFrame *>(coroRuntime._frame)->_rvRef);

#define CORO_AWAIT_PUSHED_TASK                  \
    return kVThreadReturn

#define CORO_DISUSE_CODE_BLOCK_VARS             \
        (void)params;                           \
        (void)locals;                           \
        (void)coroReturnValueRef;

#define CORO_END_CODE_BLOCK                     \
        CORO_DISUSE_CODE_BLOCK_VARS             \
        return kVThreadReturn;                  \
    });

#define CORO_BEGIN_DEFINITION(type) \
CompiledCoroutine *type::ms_compiledCoro = nullptr;\
void type::compileCoroutine(ICoroutineCompiler *compiler) {

#define CORO_END_DEFINITION \
    }

#define CORO_BEGIN_FUNCTION                         \
    struct CoroStackFrame : public CoroutineStackFrame2 {\
        Params _params;\
        Locals _locals;\
        CoroutineReturnValueRef<ReturnValue_t> _rvRef;\
        explicit CoroStackFrame(const CompiledCoroutine *compiledCoro, const Params &params, const CoroutineReturnValueRef<ReturnValue_t> &rvRef)\
            : CoroutineStackFrame2(compiledCoro), _params(params), _rvRef(rvRef) {\
        }\
        static CoroutineStackFrame2 *constructFrame(void *ptr, const CompiledCoroutine *compiledCoro, const CoroutineParamsBase &params, const CoroutineReturnValueRefBase &returnValueRef) {\
            return new (ptr) CoroStackFrame(compiledCoro, static_cast<const Params &>(params), static_cast<const CoroutineReturnValueRef<ReturnValue_t>&>(returnValueRef));\
        }\
        static void getFrameParameters(size_t &outSize, size_t &outAlignment) { \
            outSize = sizeof(CoroStackFrame); \
            outAlignment = alignof(CoroStackFrame); \
        }\
    };\
    compiler->defineFunction(CoroStackFrame::constructFrame, CoroStackFrame::getFrameParameters);   \
    CORO_START_CODE_BLOCK(CoroOps::BeginFunction)

#define CORO_END_FUNCTION                       \
    CORO_END_CODE_BLOCK                         \
    CORO_START_CODE_BLOCK(CoroOps::EndFunction) \
    CORO_END_CODE_BLOCK

#define CORO_AWAIT(expr)                            \
        (expr);                                     \
    CORO_END_CODE_BLOCK                             \
    CORO_START_CODE_BLOCK(CoroOps::YieldToFunction) \
    CORO_END_CODE_BLOCK                             \
    CORO_START_CODE_BLOCK(CoroOps::Code)

#define CORO_AWAIT_MINISCRIPT(expr)                 \
        coroRuntime._miniscriptOutcome = ((expr));  \
    CORO_END_CODE_BLOCK                             \
    CORO_START_CODE_BLOCK(CoroOps::CheckMiniscript) \
    CORO_END_CODE_BLOCK                             \
    CORO_START_CODE_BLOCK(CoroOps::Code)    

#define CORO_IF(expr)                           \
    CORO_END_CODE_BLOCK                         \
    CORO_START_CODE_BLOCK(CoroOps::IfCond)      \
        coroRuntime._condition = !!(expr);      \
    CORO_END_CODE_BLOCK                         \
    CORO_START_CODE_BLOCK(CoroOps::IfBody)

#define CORO_ELSE                               \
    CORO_END_CODE_BLOCK                         \
    CORO_START_CODE_BLOCK(CoroOps::Else)

#define CORO_ELSE_IF(expr)                      \
    CORO_END_CODE_BLOCK                         \
    CORO_START_CODE_BLOCK(CoroOps::ElseIfCond)  \
        coroRuntime._condition = !!(expr);      \
    CORO_END_CODE_BLOCK                         \
    CORO_START_CODE_BLOCK(CoroOps::ElseIfBody)

#define CORO_END_IF                             \
    CORO_END_CODE_BLOCK                         \
    CORO_START_CODE_BLOCK(CoroOps::EndIf)

#define CORO_WHILE(expr)                        \
    CORO_END_CODE_BLOCK                         \
    CORO_START_CODE_BLOCK(CoroOps::WhileCond)   \
        coroRuntime._condition = !!(expr);      \
    CORO_END_CODE_BLOCK                         \
    CORO_START_CODE_BLOCK(CoroOps::WhileBody)

#define CORO_END_WHILE                          \
    CORO_END_CODE_BLOCK                         \
    CORO_START_CODE_BLOCK(CoroOps::EndWhile)

#define CORO_DO                                 \
    CORO_END_CODE_BLOCK                         \
    CORO_START_CODE_BLOCK(CoroOps::Do)

#define CORO_DO_WHILE(expr)                     \
    CORO_END_CODE_BLOCK                         \
    CORO_START_CODE_BLOCK(CoroOps::DoWhileCond) \
        coroCondition = !(expr);                \
    CORO_END_CODE_BLOCK                         \
    CORO_START_CODE_BLOCK(CoroOps::DoWhile)

#define CORO_FOR(initExpr, condExpr, nextExpr)  \
        (initExpr);                             \
    CORO_END_CODE_BLOCK                         \
    CORO_START_CODE_BLOCK(CoroOps::ForNext)     \
        (nextExpr);                             \
    CORO_END_CODE_BLOCK                         \
    CORO_START_CODE_BLOCK(CoroOps::ForCond)     \
        coroRuntime._condition = !!(condExpr);  \
    CORO_END_CODE_BLOCK                         \
    CORO_START_CODE_BLOCK(CoroOps::ForBody)

#define CORO_END_FOR                            \
    CORO_END_CODE_BLOCK                         \
    CORO_START_CODE_BLOCK(CoroOps::EndFor)

#define CORO_RETURN_VALUE(expr)                 \
    coroReturnValueRef.set((expr));             \
    CORO_END_CODE_BLOCK                         \
    CORO_START_CODE_BLOCK(CoroOps::Return)

#define CORO_ERROR                              \
    CORO_END_CODE_BLOCK                         \
    CORO_START_CODE_BLOCK(CoroOps::Error)
    

#define CORO_RETURN                             \
    coroReturnValueRef.voidSet();               \
    CORO_END_CODE_BLOCK                         \
    CORO_START_CODE_BLOCK(CoroOps::Return)

#define CORO_RETURN_CALL(func, ...)             \
        coroFrame->pushFrame<CoroAutoFrame<func> >(coroReturnValueRef._returnValue, __VA_ARGS__);   \
    CORO_END_CODE_BLOCK                                                                             \
    CORO_START_CODE_BLOCK(CoroOps::YieldToFunction)                                                 \
    CORO_END_CODE_BLOCK                                                                             \
    CORO_START_CODE_BLOCK(CoroOps::Return)

#define CORO_SET_CALL(dest, func, ...)                                              \
    CORO_AWAIT(coroRuntime._vthread->pushCoroutineWithReturn<func>(&(dest), __VA_ARGS__))

#define CORO_CALL(func, ...)                                \
    CORO_AWAIT(coroRuntime._vthread->pushCoroutine<func>(__VA_ARGS__))

} // Namespace MTropolis

#endif