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