s4g.h

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

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

#ifndef __S4G_H
#define __S4G_H

#include <common/string.h>
#include <limits.h>
#include <cstdio>

#if defined(_WINDOWS)
#   include <Windows.h>
#endif

    
#define S4G_VERSION     "0.9.2"

#define S4G_COPYRIGHT   "Copyright © Vitaliy Buturlin, Evgeny Danilovich, 2017"

#define S4G_SITE        "https://s4g.su"

#define _VOID

#if defined(S4G_BUILD_LIB)
    #if defined(S4G_EXE)
        #define S4G_API extern "C" __declspec (dllimport)
    #elif defined(S4G_LIB)
        #define S4G_API extern "C" __declspec (dllexport)
    #endif
#else
    #define S4G_API extern
#endif

#define S4G_ERROR   -1

#define S4G_OK      0

enum S4G_TYPE
{
    S4G_TYPE_NONE       = -1,   
    S4G_TYPE_NULL       = 0,    
    S4G_TYPE_TABLE      = 1,    
    S4G_TYPE_ARRAY      = 2,    
    S4G_TYPE_STRING     = 3,    
    S4G_TYPE_FLOAT      = 4,    
    S4G_TYPE_INT        = 5,    
    S4G_TYPE_UINT       = 6,    
    S4G_TYPE_BOOL       = 7,    
    S4G_TYPE_PDATA      = 8,    
    S4G_TYPE_CFUNC      = 9,    
    S4G_TYPE_SFUNC      = 10,   
    S4G_TYPE_CLASS      = 11,   
    S4G_TYPE_CLASS_OBJECT = 12, 
};

struct s4g_Main;        
struct s4g_Variable;    
struct s4g_Table;       
struct s4g_Array;       
struct String;
typedef int ID;


//const
#define S4G_MAX_LEN_TYPE_NAME   64      
#define S4G_MAX_LEN_VAR_NAME    64      
#define S4G_MAX_LEN_STR_IN_FILE 1024    
#define S4G_MAX_CALL                1000    
#define S4G_START_COUNT_CONTEXTS    100     
#define S4G_VM_MAX_SIZE_STACK_EXE   1000    
#define S4G_GLOBAL_NM   "_g"    
#define S4G_MARG        "args"  
#define S4G_RESERVE_VALUE           1000    
#define S4G_RESERVE_VALUE_MEM       1000    


#define S4G_RESERVE_DATA            1000    
#define S4G_RESERVE_DATA_MEM        1000    

#define S4G_RESERVE_BLOCKS          10      
#define S4G_RESERVE_BLOCKS_MEM      100     
#define S4G_RESERVE_CONTEXTS        100     
#define S4G_ADD_MEM_CONTEXTS        8       
#define S4G_RESERVE_CONTEXTS_MEM    100     

#define S4G_RESERVE_STRING_MEM      100     

#define S4G_RESERVE_SFUNC_MEM       100     

#define S4G_RESERVE_TABLE_MEM       100     
#define S4G_RESERVE_TABLE_ELEM      8       

#define S4G_RESERVE_CLASS_MEM       10  

#define S4G_RESERVE_CLASS_OBJECT_MEM        100 



#define S4G_MSG_LEVEL_NOTICE    0   

#define S4G_MSG_LEVEL_WARNING   1   

#define S4G_MSG_LEVEL_ERROR     2   


#if defined(_WINDOWS)
#define DBG_BREAK _asm { int 3 }
#else
#define DBG_BREAK asm("int $3");
#endif

typedef long s4g_int;

typedef unsigned long s4g_uint;

typedef float s4g_float;

typedef short int s4g_bool;

typedef void* s4g_pdata;


typedef int(*s4g_c_function) (s4g_Main* s4gm);

typedef void(*s4g_report_func) (s4g_Main* s4gm, int level, const char* format, ...);

S4G_API const char* s4g_MainGetName(s4g_Main *s4gm);


S4G_API const char* s4g_StackTrace(s4g_Main *s4gm);

inline void s4g_Report(s4g_Main* s4gm, int level, const char* format, ...)
{
#if defined(_WINDOWS)
    AllocConsole();
    freopen("CONOUT$", "wt", stdout);
#endif
    char buf[4096];
    va_list va;
    va_start(va, format);
    vsprintf_s(buf, sizeof(buf), format, va);
    va_end(va);

    if (!s4gm)
    {
        fprintf(stdout, "s4g null object s4g_Main! Message: %s", buf);
/*#ifndef S4G_FASTFAIL
        Sleep(S4G_COUNT_TIME_EXPECT_EXIT);
#endif
        exit(1);*/
    }

    if (level == 0)
        fprintf(stdout, "s4g %s notice: %s\n", s4g_MainGetName(s4gm), buf);
    else if (level == 1)
        fprintf(stdout, "s4g %s warning: %s\n", s4g_MainGetName(s4gm), buf);
    else
    {
        fprintf(stdout, "s4g %s error: %s\n", s4g_MainGetName(s4gm), buf);
        //fprintf(stdout, "stack trace: %s", s4g_StackTrace(s4gm));
/*#ifndef S4G_FASTFAIL
        Sleep(S4G_COUNT_TIME_EXPECT_EXIT);
#endif
        exit(1);*/
    }
}

const char g_aS4GtypeStr[][S4G_MAX_LEN_TYPE_NAME] = {
"none",
"null",
"table",
"array",
"string",
"float",
"int",
"uint",
"bool",
"pointer_data",
"cfunc",
"sfunc",
"class",
"class_object"
};

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

#define S4G_NM_GLOBAL INT_MIN   

#define S4G_NM_SYS INT_MIN+1    

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

S4G_API const char* s4g_GetStrType(S4G_TYPE type, char *szStrType = 0);

S4G_API void s4g_SetRf(s4g_report_func fnRf);   

S4G_API void s4g_GenMsg(s4g_Main *s4gm, int iLevel, const char *szFormat, ...); 

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

S4G_API s4g_Main* s4g_MainInit(const char *szName); 

S4G_API int s4g_MainGetState(s4g_Main *s4gm);

S4G_API const char* s4g_MainGetErrorStr(s4g_Main *s4gm);

S4G_API void s4g_MainClear(s4g_Main* s4gm);         

S4G_API void s4g_MainKill(s4g_Main *s4gm);              

S4G_API UINT s4g_MainGetTime(s4g_Main *s4gm);

S4G_API const char* s4g_MainGetName(s4g_Main *s4gm);


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

S4G_API int s4g_LoadCode(s4g_Main *s4gm, const char *szCode, bool isFile = true);


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

S4G_API void s4g_GCcall(s4g_Main *s4gm);

S4G_API int s4g_GCgetMemBusy(s4g_Main *s4gm);       

S4G_API int s4g_GCgetMemAllocated(s4g_Main *s4gm);  

S4G_API s4g_Variable* s4g_GCgetNull(s4g_Main *s4gm);

S4G_API s4g_Variable* s4g_GCgetBool(s4g_Main *s4gm, bool bf);

S4G_API s4g_Variable* s4g_GCgetTrue(s4g_Main *s4gm);

S4G_API s4g_Variable* s4g_GCgetFalse(s4g_Main *s4gm);


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

S4G_API void s4g_StackPush_TableEmpty(s4g_Main *s4gm, int iCountReserve);

S4G_API void s4g_StackPush_Cfunc(s4g_Main *s4gm, s4g_c_function fnFunc);

S4G_API void s4g_StackPush_Int(s4g_Main *s4gm, s4g_int num);

S4G_API void s4g_StackPush_Uint(s4g_Main *s4gm, s4g_uint num);

S4G_API void s4g_StackPush_Float(s4g_Main *s4gm, s4g_float num);

S4G_API void s4g_StackPush_Str(s4g_Main *s4gm, const char *szStr);

S4G_API void s4g_StackPush_Bool(s4g_Main *s4gm, s4g_bool bf);

S4G_API void s4g_StackPush_Pdata(s4g_Main *s4gm, s4g_pdata pData);

S4G_API void s4g_StackPush_Null(s4g_Main *s4gm);

S4G_API void s4g_StackPush_Var(s4g_Main *s4gm, s4g_Variable *pVar);

S4G_API void s4g_StackPush_ClassObject(s4g_Main *s4gm, s4g_pdata pData=0);

S4G_API void s4g_StackPush_Class(s4g_Main *s4gm);

S4G_API void s4g_StackPush_ClassVar(s4g_Main *s4gm, const char *szName);

S4G_API void s4g_StackPush_ClassMethod(s4g_Main *s4gm, const char *szName, s4g_c_function fnMethod);


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

S4G_API void s4g_StackStore(s4g_Main *s4gm, int iIndex, const char *szName);

S4G_API void s4g_StackGet2Top(s4g_Main *s4gm, int iIndex, const char *szName);


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

S4G_API int s4g_StackIs_Int(s4g_Main *s4gm, int iIndex);

S4G_API int s4g_StackIs_Uint(s4g_Main *s4gm, int iIndex);

S4G_API int s4g_StackIs_Float(s4g_Main *s4gm, int iIndex);

S4G_API int s4g_StackIs_Str(s4g_Main *s4gm, int iIndex);

S4G_API int s4g_StackIs_Bool(s4g_Main *s4gm, int iIndex);

S4G_API int s4g_StackIs_Cfunc(s4g_Main *s4gm, int iIndex);

S4G_API int s4g_StackIs_Sfunc(s4g_Main *s4gm, int iIndex);

S4G_API int s4g_StackIs_Table(s4g_Main *s4gm, int iIndex);

S4G_API int s4g_StackIs_Pdata(s4g_Main *s4gm, int iIndex);

S4G_API int s4g_StackIs_Null(s4g_Main *s4gm, int iIndex);

S4G_API int s4g_StackIs_Class(s4g_Main *s4gm, int iIndex);

S4G_API int s4g_StackIs_ClassObject(s4g_Main *s4gm, int iIndex);


S4G_API S4G_TYPE s4g_StackGet_Type(s4g_Main *s4gm, int iIndex);

S4G_API s4g_Variable* s4g_StackGet_Var(s4g_Main *s4gm, int iIndex);

S4G_API s4g_int s4g_StackGet_Int(s4g_Main *s4gm, int iIndex);

S4G_API s4g_uint s4g_StackGet_Uint(s4g_Main *s4gm, int iIndex);

S4G_API s4g_float s4g_StackGet_Float(s4g_Main *s4gm, int iIndex);

S4G_API s4g_bool s4g_StackGet_Bool(s4g_Main *s4gm, int iIndex);

S4G_API const char* s4g_StackGet_Str(s4g_Main *s4gm, int iIndex);

S4G_API s4g_c_function s4g_StackGet_Cfunc(s4g_Main *s4gm, int iIndex);

S4G_API s4g_pdata s4g_StackGet_Pdata(s4g_Main *s4gm, int iIndex);


S4G_API void s4g_StackPop(s4g_Main *s4gm, int iCount);  

S4G_API int s4g_StackGetTop(s4g_Main *s4gm);    


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

S4G_API void s4g_Call(s4g_Main *s4gm, bool isCallFunc = false);

S4G_API void s4g_Precall(s4g_Main *s4gm);


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

S4G_API int s4g_Cfunc_CountArg(s4g_Main *s4gm);                 

S4G_API s4g_Variable* s4g_CfuncGet_Arg(s4g_Main *s4gm, int nArg);   


S4G_API s4g_int s4g_CfuncGet_ArgInt(s4g_Main *s4gm, int nArg);

S4G_API s4g_uint s4g_CfuncGet_ArgUint(s4g_Main *s4gm, int nArg);

S4G_API s4g_float s4g_CfuncGet_ArgFloat(s4g_Main *s4gm, int nArg);

S4G_API s4g_bool s4g_CfuncGet_ArgBool(s4g_Main *s4gm, int nArg);

S4G_API const char* s4g_CfuncGet_ArgStr(s4g_Main *s4gm, int nArg);

S4G_API String* s4g_CfuncGet_ArgStr2(s4g_Main *s4gm, int nArg);

S4G_API s4g_c_function s4g_CfuncGet_ArgCfunc(s4g_Main *s4gm, int nArg);

S4G_API s4g_pdata s4g_CfuncGet_ArgPdata(s4g_Main *s4gm, int nArg);


S4G_API int s4g_CfuncIs_ArgNull(s4g_Main *s4gm, int nArg);

S4G_API int s4g_CfuncIs_ArgInt(s4g_Main *s4gm, int nArg);

S4G_API int s4g_CfuncIs_ArgUint(s4g_Main *s4gm, int nArg);

S4G_API int s4g_CfuncIs_ArgFloat(s4g_Main *s4gm, int nArg);

S4G_API int s4g_CfuncIs_ArgBool(s4g_Main *s4gm, int nArg);

S4G_API int s4g_CfuncIs_ArgStr(s4g_Main *s4gm, int nArg);

S4G_API int s4g_CfuncIs_ArgTable(s4g_Main *s4gm, int nArg);

S4G_API int s4g_CfuncIs_ArgArray(s4g_Main *s4gm, int nArg);

S4G_API int s4g_CfuncIs_ArgCfunc(s4g_Main *s4gm, int nArg);

S4G_API int s4g_CfuncIs_ArgSfunc(s4g_Main *s4gm, int nArg);

S4G_API int s4g_CfuncIs_ArgPdata(s4g_Main *s4gm, int nArg);

S4G_API int s4g_CfuncIs_ArgClassObject(s4g_Main *s4gm, int nArg);


S4G_API S4G_TYPE s4g_CfuncGet_Type(s4g_Main *s4gm, int nArg);   

S4G_API const char* s4g_CfuncGet_TypeStr(s4g_Main *s4gm, int nArg, char *szStr = 0);


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

S4G_API const char* s4g_VarGet_Name(s4g_Main *s4gm, s4g_Variable *pVar);

S4G_API S4G_TYPE s4g_VarGet_Type(s4g_Variable *pVar);

S4G_API int s4g_TableGet_Size(s4g_Table *pTable);

S4G_API void s4g_TableAdd_Var(s4g_Table *pTable, s4g_Variable *pVar, const char *szName);

S4G_API int s4g_ArrayGet_Size(s4g_Array *pArray);

S4G_API bool s4g_ClassObjectSet_Data(s4g_Variable *pVar, s4g_pdata pData);

S4G_API s4g_pdata s4g_ClassObjectGet_Data(s4g_Variable *pVar);

S4G_API s4g_Variable* s4g_TableGat_Var(s4g_Table *pTable, int iKey);


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

S4G_API const char* s4g_StackTrace(s4g_Main *s4gm); 

S4G_API const char* s4g_Dbg_GetFile(s4g_Main *s4gm, ID id, char *szStr = 0);

S4G_API const char* s4g_Dbg_GetCurrFile(s4g_Main *s4gm, char *szStr = 0);   

S4G_API int s4g_Dbg_GetCurrStr(s4g_Main *s4gm, char *szStr = 0);            

S4G_API const char* s4g_Dbg_GetCurrFunc(s4g_Main *s4gm, char *szStr = 0);   


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

S4G_API bool s4g_PP_Defined(s4g_Main *s4gm, const char *szDefine);

S4G_API void s4g_PP_Define(s4g_Main *s4gm, const char *szDefine);

S4G_API void s4g_PP_Undef(s4g_Main *s4gm, const char *szDefine);

S4G_API void s4g_PP_AddIncludePath(s4g_Main *s4gm, const char *szPath);



#endif