s4g_vm.h

См. документацию.

/*
Copyright © Vitaliy Buturlin, Evgeny Danilovich, 2017
license MIT see in LICENSE or
https://s4g.su/
*/

#ifndef __S4G_VM_H
#define __S4G_VM_H

#include <math.h>
#include "s4g_types.h"
#include "s4g_main.h"

enum S4G_VM_LOCALEXE
{
    S4G_VM_LOCALEXE_EXIT,   
    S4G_VM_LOCALEXE_MAIN,   
    S4G_VM_LOCALEXE_FUNC,   
};

#define S4G_VM_OP_ARIF_ERROR_TYPE1(tval1) \
    sprintf(this->m_szError, "[%s]:%d - attempt to perform arithmetic on arg #1 (a '%s' value)", getCurrExeFile(), getCurrExeStr(), s4g_GetStrType(tval1->m_pData->m_TypeValue)); \
    return;

#define S4G_VM_OP_ARIF_ERROR_TYPE2(tval2) \
    sprintf(this->m_szError, "[%s]:%d - attempt to perform arithmetic on arg #2 (a '%s' value)", getCurrExeFile(), getCurrExeStr(), s4g_GetStrType(tval2->m_pData->m_TypeValue)); \
    return;

#define S4G_VM_OP_ARIF_ERROR_UNSUN_UNRES(tval2) \
    sprintf(this->m_szError, "[%s]:%d - unary symbol is unresolved to '%s' type", getCurrExeFile(), getCurrExeStr(), s4g_GetStrType(tval2->m_pData->m_TypeValue)); \
    return;

#define S4G_VM_OP_ARIF_INCR_DECR_ERR(tval) \
    sprintf(this->m_szError, "[%s]:%d - expected number type, but got '%s' type", getCurrExeFile(), getCurrExeStr(), s4g_GetStrType(tval->m_pData->m_TypeValue)); \
    return;

#define S4G_VM_PRECOND_STACKEXE(state, retval) if(!state) return retval;

#define S4G_VM_PRECOND_COMMANDARG(arg, funcname) \
    if(!arg) \
    { \
    m_iError = -1; \
    sprintf(this->m_szError, "[%s]:%d - argument of command is empty, vm function '%s'", getCurrExeFile(), getCurrExeStr(), funcname); \
    return; \
    }

//##########################################################################

struct s4g_CallData
{
    s4g_CallData()
    {
        m_pCurrArrCommand = 0;
        m_pTableVars = 0;
        m_idCurrPos2ArrCommand = m_idContextLastDeactivated = m_idContextNew = m_idContextExtern = -1;
        m_pVarFunc = 0;
        m_iCountCurrOpenBlocks = 0; 
        m_iStackSize = -1;
    }

    ~s4g_CallData(){}

    s4g_Stack<s4g_Command>* m_pCurrArrCommand;  
    s4g_Table *m_pTableVars;                    
    int m_idCurrPos2ArrCommand;                 
    ID m_idContextLastDeactivated;              
    ID m_idContextNew;                          
    ID m_idContextExtern;                       
    int m_iCountCurrOpenBlocks;                 
    int m_iStackSize;                           
    s4g_Variable *m_pVarFunc;                   
};

//##########################################################################

struct s4g_PrecallData
{
    s4g_PrecallData(){ m_iSizeStack = 0; m_pVar = 0; }
    s4g_PrecallData(int iSizeStack, s4g_Variable *pVar){ m_iSizeStack = iSizeStack; m_pVar = pVar; }

    int m_iSizeStack;

    s4g_Variable *m_pVar;
};

//##########################################################################

class s4g_VM
{
public:
    
    s4g_VM(s4g_Main *_s4gm);
    ~s4g_VM();

    void clear();

    int run(s4g_Stack<s4g_Command> *pCommands, s4g_Table *pCurrTable);

    void returnPrevState();

    bool precondStackExe(int iCountExpected, const char *szFuncName);

    //######################################################################

    void comObjectNew();

    void comVarNew();

    void comFetch();

    void comFetchIdx();

    void comAccess();

    void comStore();

    void comArrayNew();


    void comClassNew();

    void comClassParentAdd();

    void comClassVarAdd();

    void comClassMethodAdd();


    void comTableNew();

    void comTableInsert();

    void comTableAppend();


    void comHalt();

    void comDoubleTop();
    
    void comPush();

    void comPop();


    void comPrecall();

    void comCall();


    void comArithmeticAdd();

    void comArithmeticSub();

    void comArithmeticMul();

    void comArithmeticDiv();

    void comArithmeticMod();

    
    void comJump();

    void comJumpZero();

    void comJumpNonZero();


    void comLogicNeqt();

    void comLogicEq();

    void comLogicNeq();

    void comLogicGe();

    void comLogicLe();

    void comLogicGt();

    void comLogicLt();

    void comLogicNot();

    void comLogicEqt();


    void comBitXor();

    void comBitNot();

    void comBitShiftR();

    void comBitShiftL();

    void comBitAnd();

    void comBitOr();
    

    void comBlockNew();

    void comBlockDel();

    void comTopContextClear();


    void comPreincr();

    void comPostincr();

    void comPredecr();

    void comPostdecr();


    typedef void(s4g_VM::*opfunc) ();

    opfunc m_aOpFunc[S4G_VM_COMMAND_LAST];

    //######################################################################

    const char* getCurrExeFile(char *szStr = 0);

    int getCurrExeStr(char *szStr = 0);

    const char* getCurrExeFunc(char *szStr = 0);

    const char* stackTrace();


    void setError(const char *szStr);

    const char* getError();

    bool hasError(){ return (m_iError < 0); };

    int getStackArgsSize() { return m_aStackArgs.getSize(); };

    s4g_Variable* getArgFromStackArgs(int iNum){ return m_aStackArgs.get(iNum - 1); };

    void pushStackExecute(s4g_Variable *pVar) { m_oStackExecute.push(pVar); };

    void popStackExecute(int iCount = 1) { m_oStackExecute.pop(iCount); };

    s4g_Variable* getStackExecute(int iNum) { return m_oStackExecute.get(iNum); };

    int getSizeStackExecute(){ return m_oStackExecute.getSize(); };

    S4G_TYPE getTypeLastCall(){ return typeLastCallFunc; }

protected:
    friend s4g_Main;

    s4g_Main* s4gm;

    bool m_canExecute;              

    S4G_TYPE typeLastCallFunc;

    s4g_Stack<s4g_Command> *m_pCurrArrCommand;

    ID m_idCurrPos2ArrCommand;

    s4g_Table *m_pGtable;

    s4g_Variable *m_pGvar;

    s4g_Table *m_pCurrTable;

    s4g_Stack<s4g_Variable*, S4G_VM_MAX_SIZE_STACK_EXE> m_oStackExecute;


    String m_sStackTrace;   

    int m_iError;           
    char m_szError[1024];   

    s4g_Command *m_pCurrCommand;    

    S4G_VM_COMMAND m_vm_command;    
    s4g_Variable *pVarCurrArg;      

    

    s4g_Stack<s4g_CallData*> m_aStackBloks; 
    
    int m_iCountCurrOpenBlocks;     

    s4g_Stack<s4g_Variable*, 64> m_aStackArgs;  

    s4g_Stack<s4g_CallData*> m_aStackCall;      

    s4g_Stack<s4g_PrecallData*, S4G_MAX_CALL + 1> m_aStackSizesStackExe;

    MemAlloc<s4g_CallData, S4G_RESERVE_BLOCKS_MEM> m_oMemCallData;  
};

#endif

//!@} vm