s4g_types.h

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

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

#ifndef __S4G_TYPES_H
#define __S4G_TYPES_H

#include <common/array.h>
#include <common/assotiativearray.h>
#include <common/memalloc.h>
#include "s4g.h"
#include "s4g_Stack.h"
#include <common/sxtypes.h>

class s4g_GC;
class s4g_VM;


#define S4G_GC_TYPE_DATA_FREE       0   

#define S4G_GC_TYPE_DATA_PRIVATE    1   

#define S4G_GC_TYPE_DATA_SYS        2   



//#define S4G_GC_TYPE_VAR_DEL       -1  

#define S4G_GC_TYPE_VAR_FREE    0   

#define S4G_GC_TYPE_VAR_SYS     1   



enum S4G_OWNERVAR
{
    S4G_OWNERVAR_NONE = -1,
    S4G_OWNERVAR_CONTEXT = 0,
    S4G_OWNERVAR_DATA
};

class s4g_OwnerVar
{
public:
    virtual ~s4g_OwnerVar(){}

    virtual S4G_OWNERVAR getType() = 0;
};

struct s4g_Data : public s4g_OwnerVar
{
    s4g_Data();
    ~s4g_Data();

    virtual S4G_OWNERVAR getType();

    union
    {
        void *p;
        s4g_int i;
        s4g_uint ui;
        s4g_float f;
        s4g_bool b;
    } data;

    int m_iCurrNumCollect;  
    S4G_TYPE m_TypeValue;   
    int m_iTypeClass;       
    ID m_idData;            
};


struct s4g_Variable
{
    s4g_Variable();
    ~s4g_Variable();

    int m_iTypeClass;   
    ID m_idVar;         
    s4g_OwnerVar *m_pOwner;     
    int m_iCurrNumCollect;      

    s4g_Data* m_pData;
};


class s4g_Table
{
public:
    s4g_Table();
    ~s4g_Table();

    void clear();                       

    ID getKey(const char *szName);      

    ID getKeyByVar(const s4g_Variable *pVar);

    int getSize(){ return m_iCount; }                       
    const char* getNameByNum(ID key);   

    void reserve(int iCount);           

    void remove(const char *szName);    
    void remove(ID key);                

    ID getIdData(){ return m_idData; }

    s4g_Variable* getByNum(ID key);             
    s4g_Variable* getByName(const char *str);   
    
    ID isExistsName(const char *str);           
    bool isExistsNum(ID key);                   

    ID isExistsName2(const char *szName, s4g_Variable **ppVar); 

    //существует ли переменная по указанному ключу, если да то в ppVar запишет найденную переменную
    bool isExistsNum2(ID key, s4g_Variable **ppVar);

    void addVarName(const char *szName, s4g_Variable *pVar);
    void addVarNum(ID key, s4g_Variable *pVar);             
    void appendVar(s4g_Variable *pVar);                     

protected:
    friend class s4g_GC;
    struct item_name
    {
        mutable char Name[S4G_MAX_LEN_VAR_NAME];
        mutable const char * tmpName;
        __forceinline bool operator==(const item_name & str) const
        {
            return(strcmp(tmpName ? tmpName : Name, str.tmpName ? str.tmpName : str.Name) == 0);
        }

        __forceinline bool operator<(const item_name & str) const
        {
            return(strcmp(tmpName ? tmpName : Name, str.tmpName ? str.tmpName : str.Name) < 0);
        }

        __forceinline void SetName(const char * str)const
        {
            strcpy(Name, str);
            tmpName = NULL;
        }

        __forceinline const char * GetName() const
        {
            return(tmpName ? tmpName : Name);
        }

        __forceinline item_name(const char * str)
        {
            tmpName = str;
            Name[0] = 0;
        }

        __forceinline item_name()
        {
            tmpName = NULL;
            Name[0] = 0;
        }
    };
    struct table_desc
    {
        const item_name * name;
        s4g_Variable* Value;
    };
    int m_iCount;
    s4g_Stack<table_desc*, S4G_RESERVE_TABLE_ELEM> m_Arr;
    MemAlloc<table_desc, S4G_RESERVE_TABLE_ELEM, 8> m_Mem;
    typedef AssotiativeArray<item_name, long, false, S4G_RESERVE_TABLE_ELEM> IndexType;
    typedef const IndexType::Node * IndexNode;
    IndexType NameIndex;
    ID m_idData;
};


class s4g_Array
{
public:
    s4g_Array();
    ~s4g_Array();

    void clear();   

    ID getKeyByVar(const s4g_Variable *pVar);

    s4g_Variable* get(int iNum);
    
    void append(s4g_Variable *pVar);

    s4g_Variable* getNewLast();

    int getCount();

    ID getIdData(){ return m_idData; }

protected:
    friend s4g_GC;

    s4g_Main *s4gm;
    s4g_Stack<s4g_Variable*> m_aArr;

    ID m_idData;
};


class s4g_ClassObject;

class s4g_Class
{
public:
    s4g_Class();
    ~s4g_Class();

    ID getKeyByVar(const s4g_Variable *pVar);
    
    const char* getNameByNum(ID key);

    void setName(const char *szName);

    const char* getName();

    void addBaseClass(s4g_Variable *pVarBaseClass);

    void addVar(const char *szName);

    void addMethod(const char *szName, s4g_Variable *pVar);

    ID getIdData(){ return m_idData; }

    bool isExported(){ return m_isExported; }

protected:
    friend s4g_ClassObject;
    friend s4g_Class;
    friend s4g_GC;

    s4g_Main *s4gm;

    bool m_isExported;              

    String m_sName;                 
    s4g_Stack<String> m_aListVars;  

    s4g_Table *m_pTableMethods;
    s4g_Variable *m_pVarTableMethods;
    s4g_Stack<s4g_Variable*> m_aListVarBaseClass;   

    ID m_idData;
};


class s4g_ClassObject
{
public:

    s4g_ClassObject();
    ~s4g_ClassObject();

    ID getKeyByVar(const s4g_Variable *pVar);

    const char* getNameByNum(ID key);

    void Init(s4g_Variable *pVarMetaClass);

    s4g_Variable* getVar(const char *szName);

    s4g_Variable* getVarClass();

    s4g_pdata m_pData;              

    ID getIdData(){ return m_idData; }

protected:
    friend s4g_GC;
    friend s4g_VM;

    s4g_Main *s4gm;

    s4g_Variable *m_pVarMetaClass;  
    s4g_Variable *m_pVarTableVars;  
    s4g_Table *m_pTableVars;        

    ID m_idData;
};


class s4g_Command;

struct s4g_Sfunction
{
    s4g_Sfunction(){ m_pExternVar = 0; m_pExternTable = 0; m_isMarg = false; m_pMargVar = 0; m_pMargTable = 0; }
    ~s4g_Sfunction(){}
    s4g_Variable* m_pExternVar;         
    s4g_Table* m_pExternTable;          
    s4g_Stack<String> m_aExternStrs;    
    s4g_Stack<String> m_aArgsNames;     
    s4g_Stack<s4g_Command> m_aCommands; 
    bool m_isMarg;                      
    s4g_Variable* m_pMargVar;           
    s4g_Table* m_pMargTable;            
};


enum S4G_CONTEXT_TYPE_WORK
{
    S4G_CONTEXT_TYPE_WORK_OFFLINE,      
    S4G_CONTEXT_TYPE_WORK_ONLINE,       
    S4G_CONTEXT_TYPE_WORK_ONLINE_EVER,  
};


struct s4g_Context : public s4g_OwnerVar
{
    s4g_Context(){ m_pTable = 0; m_TypeWork = S4G_CONTEXT_TYPE_WORK_OFFLINE; m_pOldTable = 0; }
    ~s4g_Context() {}
    virtual S4G_OWNERVAR getType() { return S4G_OWNERVAR_CONTEXT; }
    s4g_Table *m_pTable;    

    s4g_Table* m_pOldTable; 

    S4G_CONTEXT_TYPE_WORK m_TypeWork;
    
};


enum S4G_VM_COMMAND
{
    S4G_VM_COMMAND_HALT = 0,    
    S4G_VM_COMMAND_DOUBLE_TOP,  
    S4G_VM_COMMAND_OBJECT_NEW,  
    S4G_VM_COMMAND_VAR_NEW,     
    S4G_VM_COMMAND_ARRAY_NEW,   
    S4G_VM_COMMAND_TABLE_NEW,   
    S4G_VM_COMMAND_TABLE_INSERT,
    S4G_VM_COMMAND_TABLE_APPEND,

    S4G_VM_COMMAND_CLASS_NEW,           
    S4G_VM_COMMAND_CLASS_PARENT_ADD,    
    S4G_VM_COMMAND_CLASS_VAR_ADD,       
    S4G_VM_COMMAND_CLASS_METHOD_ADD,    

    S4G_VM_COMMAND_FETCH,       
    S4G_VM_COMMAND_FETCH_IDX,   
    S4G_VM_COMMAND_ACCESS,      
    S4G_VM_COMMAND_STORE,       
    S4G_VM_COMMAND_PUSH,        
    S4G_VM_COMMAND_POP,         

    S4G_VM_COMMAND_ARITHMETIC_ADD,  
    S4G_VM_COMMAND_ARITHMETIC_SUB,  
    S4G_VM_COMMAND_ARITHMETIC_MUL,  
    S4G_VM_COMMAND_ARITHMETIC_DIV,  
    S4G_VM_COMMAND_ARITHMETIC_MOD,

    S4G_VM_COMMAND_PREINCR,     
    S4G_VM_COMMAND_PREDECR,     
    S4G_VM_COMMAND_POSTINCR,    
    S4G_VM_COMMAND_POSTDECR,    
    
    S4G_VM_COMMAND_PRECALL,     
    
    S4G_VM_COMMAND_CALL,        

    S4G_VM_COMMAND_BLOCK_NEW,           
    S4G_VM_COMMAND_BLOCK_DEL,           
    S4G_VM_COMMAND_TOPCONTEXT_CLEAR,    

    //переход относительный, относительно адреса (положения) в массиве команд
    S4G_VM_COMMAND_JUMP,        
    S4G_VM_COMMAND_JZ,          
    S4G_VM_COMMAND_JNZ,         

    //логические
    //S4G_VM_COMMAND_LOGIC_AND, //!< (-2) && (-1), оба выталкиваются, на стек ложится результат
    //S4G_VM_COMMAND_LOGIC_OR,  //!< (-2) || (-1), оба выталкиваются, на стек ложится результат
    S4G_VM_COMMAND_LOGIC_NEQT,  
    S4G_VM_COMMAND_LOGIC_EQ,    
    S4G_VM_COMMAND_LOGIC_NEQ,   
    S4G_VM_COMMAND_LOGIC_GE,    
    S4G_VM_COMMAND_LOGIC_LE,    
    S4G_VM_COMMAND_LOGIC_GT,    
    S4G_VM_COMMAND_LOGIC_LT,    
    S4G_VM_COMMAND_LOGIC_NOT,   
    S4G_VM_COMMAND_LOGIC_EQT,   

    S4G_VM_COMMAND_BIT_XOR,     
    S4G_VM_COMMAND_BIT_NOT,     
    S4G_VM_COMMAND_BIT_SHIFTR,  
    S4G_VM_COMMAND_BIT_SHIFTL,  
    S4G_VM_COMMAND_BIT_AND,     
    S4G_VM_COMMAND_BIT_OR,      

    S4G_VM_COMMAND_LAST         
};

#define S4G_COMMAND_EXTRADATA_FETCH_GET_STRING  0

#define S4G_COMMAND_EXTRADATA_FETCH_GET_NUMERIC 1



struct s4g_Command
{
    s4g_Command()
    {
        m_Command = S4G_VM_COMMAND_HALT; 
        m_pArg = 0; 
        m_numFile = m_numStr = -1;
        m_iExtraData = 0;
    }

    s4g_Command(S4G_VM_COMMAND Command, s4g_Variable* pVar, ID numFile, ID numStr, int iExtraData = 0)
    { 
        m_Command = Command;
        m_pArg = pVar;
        m_numFile = numFile;
        m_numStr = numStr;
        m_iExtraData = iExtraData;
    }

    ~s4g_Command(){}

    S4G_VM_COMMAND m_Command;   
    s4g_Variable* m_pArg;       
    ID m_numFile;               
    ID m_numStr;                
    int m_iExtraData;           
};

#endif

//!@} types