s4g_parse.h

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

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

#ifndef __S4G_PARSE_H
#define __S4G_PARSE_H

#define S4G_MAX_LEN_KEY_WORD_DEF 10
//#define S4G_MAX_LEN_SYM 4

#include "s4g_types.h"

const char g_aKeywordsLang[][S4G_MAX_LEN_KEY_WORD_DEF] = 
{
    "null",     
    "function", 
    "return",   
    "extern",
    "if",       
    "else",     
    "for",      
    "while",    
    "do",       
    "break",
    "continue",
    "class",
    //"table",
    "true",
    "false",
    "new",
    "var",
    "extends",
    
    // Reserved for future use
    "static",
    "public",
    "private",
    "protected",
    "const",
};

enum S4G_KW_LANG
{
    S4G_KW_LANG_NULL = 0,
    S4G_KW_LANG_FUNCTION,
    S4G_KW_LANG_RETURN,
    S4G_KW_LANG_EXTERN,
    S4G_KW_LANG_IF,
    S4G_KW_LANG_ELSE,
    S4G_KW_LANG_FOR,
    S4G_KW_LANG_WHILE,
    S4G_KW_LANG_DO,
    S4G_KW_LANG_BREAK,
    S4G_KW_LANG_CONTINUE,
    S4G_KW_LANG_CLASS,
//  S4G_KW_LANG_TABLE,
    S4G_KW_LANG_TRUE,
    S4G_KW_LANG_FALSE,
    S4G_KW_LANG_NEW,
    S4G_KW_LANG_VAR,
    S4G_KW_LANG_EXTENDS,

    // Reserved for future use
    S4G_KW_LANG_STATIC,
    S4G_KW_LANG_PUBLIC,
    S4G_KW_LANG_PRIVATE,
    S4G_KW_LANG_PROTECTED,
    S4G_KW_LANG_CONST,
};

const char g_aKeywordsPreproc[][S4G_MAX_LEN_KEY_WORD_DEF] = 
{
    "include",
    "define",
    "undef",
    "if",
    "ifdef",
    "defined",
    "elif",
    "else",
    "end",
    "line"
};

enum S4G_KW_PP
{
    S4G_KW_PP_USER = -1,
    S4G_KW_PP_INCLUDE = 0,
    S4G_KW_PP_DEFINE,
    S4G_KW_PP_UNDEF,
    S4G_KW_PP_IF,
    S4G_KW_PP_IFDEF,
    S4G_KW_PP_DEFINED,
    S4G_KW_PP_ELIF,
    S4G_KW_PP_ELSE,
    S4G_KW_PP_END,
    S4G_KW_PP_LINE
};

const char g_aKeycharsDelimiter[][S4G_MAX_LEN_KEY_WORD_DEF] = 
{
    ";",    //разделитель операций
    ","     //разделитель аргументов
};

enum S4G_KC_DELIMITER
{
    S4G_KC_DELIMITER_SEMICOLON = 0,
    S4G_KC_DELIMITER_COMMA
};

const char g_aKeycharsGroupExpr[][S4G_MAX_LEN_KEY_WORD_DEF] = 
{
    "(",    //начало группировки/вызова функции
    ")"     //конец группировки/вызова функции
};

enum S4G_KC_GROUPEXPR
{
    S4G_KC_GROUPEXPR_BEGIN = 0,
    S4G_KC_GROUPEXPR_END
};

const char g_aKeycharsGroupData[][S4G_MAX_LEN_KEY_WORD_DEF] = 
{
    "{", "}",//начало конец группировки данных (создания таблицы, объявления класса)
};

enum S4G_KC_GROUPDATA
{
    S4G_KC_GROUPDATA_BEGIN = 0,
    S4G_KC_GROUPDATA_END
};

const char g_aKeycharsAccess2Object[][S4G_MAX_LEN_KEY_WORD_DEF] = 
{
    "[", "]",   //начало конец обращение к элементу таблицы, переменной или методу класса по строке
    ".",        //обращение к эпеременной или методу класса по имени
    ":"         //доступ по числовому индексу как к массиву, после следует [num]
};

enum S4G_KC_A2O
{
    S4G_KC_A2O_TABLE_GETS_BEGIN = 0,
    S4G_KC_A2O_TABLE_GETS_END,
    S4G_KC_A2O_CLASS_GET,
    S4G_KC_A2O_TABLE_GETN
};

const char g_aKeycharsAssign[][S4G_MAX_LEN_KEY_WORD_DEF] = 
{
    "="
};

enum S4G_KC_AASSIGN
{
    S4G_KC_AASSIGN = 0,
};

const char g_aKeycharsArithmetic[][S4G_MAX_LEN_KEY_WORD_DEF] = 
{
    "+",
    "-",
    "*",
    "/",
    "%",
};

enum S4G_KC_ARITHMETIC
{
    S4G_KC_ARITHMETIC_ADD = 0,
    S4G_KC_ARITHMETIC_SUB,
    S4G_KC_ARITHMETIC_MUL,
    S4G_KC_ARITHMETIC_DIV,
    S4G_KC_ARITHMETIC_MOD,
};

const char g_aKeycharsLogic[][S4G_MAX_LEN_KEY_WORD_DEF] = 
{
    "&&",
    "||",
    "===",
    "!==",
    "==",
    "!=",
    ">=",
    "<=",
    ">",
    "<",
    "!",
};

enum S4G_KC_LOGIC
{
    S4G_KC_LOGIC_AND = 0,
    S4G_KC_LOGIC_OR,
    S4G_KC_LOGIC_EQT,
    S4G_KC_LOGIC_NEQT,
    S4G_KC_LOGIC_EQ,
    S4G_KC_LOGIC_NEQ,
    S4G_KC_LOGIC_GE,
    S4G_KC_LOGIC_LE,
    S4G_KC_LOGIC_GT,
    S4G_KC_LOGIC_LT,
    S4G_KC_LOGIC_NOT
};

const char g_aKeycharsBit[][S4G_MAX_LEN_KEY_WORD_DEF] = 
{
    "^",
    "~",
    ">>",
    "<<",
    "&",
    "|"
};

enum S4G_KC_BIT
{
    S4G_KC_BIT_XOR = 0,
    S4G_KC_BIT_NOT,
    S4G_KC_BIT_SHIFTR,
    S4G_KC_BIT_SHIFTL,
    S4G_KC_BIT_AND,
    S4G_KC_BIT_OR
};

const char g_aKeycharsAssignArithmetic[][S4G_MAX_LEN_KEY_WORD_DEF] =
{
    "+=",
    "-=",
    "*=",
    "/=",
    "%=",
    //"?=",
    "++",
    "--"
};

enum S4G_KC_ASSIGN_ARITHMETIC
{
    S4G_KC_ASSIGN_ARITHMETIC_ADD = 0,
    S4G_KC_ASSIGN_ARITHMETIC_SUB,
    S4G_KC_ASSIGN_ARITHMETIC_MUL,
    S4G_KC_ASSIGN_ARITHMETIC_DIV,
    S4G_KC_ASSIGN_ARITHMETIC_MOD,
    //S4G_KC_ASSIGN_ARITHMETIC_OPTSTORE,
    S4G_KC_ASSIGN_ARITHMETIC_INCR,
    S4G_KC_ASSIGN_ARITHMETIC_DECR
};

const char g_aKeycharsAssignBit[][S4G_MAX_LEN_KEY_WORD_DEF] =
{
    "^=",
    //"~=",
    ">>=",
    "<<=",
    "&=",
    "|="
};

enum S4G_KC_ASSIGN_BIT
{
    S4G_KC_ASSIGN_BIT_XOR = 0,
    //S4G_KC_ASSIGN_BIT_NOT,
    S4G_KC_ASSIGN_BIT_SHIFTR,
    S4G_KC_ASSIGN_BIT_SHIFTL,
    S4G_KC_ASSIGN_BIT_AND,
    S4G_KC_ASSIGN_BIT_OR
};


//однострочный комментарий
const char s4g_key_syms_comment_os[][S4G_MAX_LEN_KEY_WORD_DEF] = {
    "//"
};

//многострочный комментарий
const char s4g_key_syms_comment_ms[][S4G_MAX_LEN_KEY_WORD_DEF] = {
    "/*",   //начало
    "*/"    //конец
};

enum S4G_LEXEME_TYPE
{
    S4G_LEXEME_TYPE_WORD_USER,              
    S4G_LEXEME_TYPE_WORD_STRING,            
    S4G_LEXEME_TYPE_WORD_FLOAT,             
    S4G_LEXEME_TYPE_WORD_INT,               
    S4G_LEXEME_TYPE_WORD_UINT,              
    S4G_LEXEME_TYPE_WORD_KEY,               
    S4G_LEXEME_TYPE_WORD_PREP,              
    S4G_LEXEME_TYPE_MARG,                   
    S4G_LEXEME_TYPE_SYM_DELIMITER,          
    S4G_LEXEME_TYPE_SYM_ARITHMETIC,         
    S4G_LEXEME_TYPE_SYM_LOGIC,              
    S4G_LEXEME_TYPE_SYM_BIT,                
    S4G_LEXEME_TYPE_SYM_ASSIGN,             
    S4G_LEXEME_TYPE_SYM_ARITHMETIC_ASSIGN,  
    S4G_LEXEME_TYPE_SYM_BIT_ASSIGN,         
    S4G_LEXEME_TYPE_SYM_GROUP_EXPR,         
    S4G_LEXEME_TYPE_SYM_GROUP_DATA,         
    S4G_LEXEME_TYPE_SYM_A2O,                
};

struct s4g_Lexeme
{
    s4g_Lexeme(){}
    s4g_Lexeme(const char *szStr, int numStr, S4G_LEXEME_TYPE type, ID idWord, ID idFile)
    {
        m_sLexeme = szStr; m_numStr = numStr, m_type = type; m_idWord = idWord; m_idFile = idFile;
    }
    String m_sLexeme;       
    int m_numStr;           
    S4G_LEXEME_TYPE m_type; 
    ID m_idWord;            
    ID m_idFile;            
};

enum S4G_NODE_TYPE
{
    S4G_NODE_TYPE_BEGIN,    //начало программы
    //S4G_NODE_TYPE_EMPTY,  //путой нод, соединящее звено нодов

    S4G_NODE_TYPE_EXPR, //выражение
    S4G_NODE_TYPE_VAR,  //переменная
    S4G_NODE_TYPE_ARRAY,    //массив
    S4G_NODE_TYPE_STMT, //инструкция
    S4G_NODE_TYPE_STMT_CHAIN,   //инструкция
    S4G_NODE_TYPE_TBL_ITEM, //
    S4G_NODE_TYPE_ID,   //Идентификатор
    S4G_NODE_TYPE_DECLVAR,  //Идентификатор
    S4G_NODE_TYPE_DECLVAREND,   //Идентификатор

    S4G_NODE_TYPE_ACCESS_DOT,
    S4G_NODE_TYPE_ACCESS_SQUARE,
    S4G_NODE_TYPE_ACCESS_SQUARE_NUM,
    S4G_NODE_TYPE_ACCESS_SQUARE_APPEND,

    //пре и пост инкременты и декременты, для переменных
    S4G_NODE_TYPE_VAR_PREINCR,
    S4G_NODE_TYPE_VAR_PREDECR,
    S4G_NODE_TYPE_VAR_POSTINCR,
    S4G_NODE_TYPE_VAR_POSTDECR,

    //S4G_NODE_TYPE_CRVAR,  //создаваемая переменная

    S4G_NODE_TYPE_BLOCK,//блок инструкций, создает новый контекст
    S4G_NODE_TYPE_BLOCK_NO_CTX,//блок инструкций, не создает новый контекст

    //ноды содержащие в себе значения с типами
    S4G_NODE_TYPE_NULL,
    S4G_NODE_TYPE_FLOAT,
    S4G_NODE_TYPE_INT,
    //S4G_NODE_TYPE_INT_CR,
    S4G_NODE_TYPE_UINT,
    //S4G_NODE_TYPE_UINT_CR,
    S4G_NODE_TYPE_BOOL,
    S4G_NODE_TYPE_STRING,
    S4G_NODE_TYPE_CONST_DATA,
    //S4G_NODE_TYPE_STRING_CR,
    S4G_NODE_TYPE_FUNCTION,
    //S4G_NODE_TYPE_NNULL, //цифра 0 для выражений типа -123 = 0-123

    //нод содержит аргументы
    //S4G_NODE_TYPE_ARG,
    S4G_NODE_TYPE_MARG,

    //S4G_NODE_TYPE_SET,    //присваивание
    //S4G_NODE_TYPE_SETT,   //присваивание в таблице
    //S4G_NODE_TYPE_GET,    //получение переменной

    // присваивание
    S4G_NODE_TYPE_ASSIGN,
    S4G_NODE_TYPE_ASSIGN_ADD,
    S4G_NODE_TYPE_ASSIGN_SUB,
    S4G_NODE_TYPE_ASSIGN_MUL,
    S4G_NODE_TYPE_ASSIGN_DIV,
    S4G_NODE_TYPE_ASSIGN_MOD,
    S4G_NODE_TYPE_ASSIGN_BXOR,
    //S4G_NODE_TYPE_ASSIGN_BNOT,
    S4G_NODE_TYPE_ASSIGN_BRSH,
    S4G_NODE_TYPE_ASSIGN_BLSH,
    S4G_NODE_TYPE_ASSIGN_BAND,
    S4G_NODE_TYPE_ASSIGN_BOR,

    //пре и пост инкременты и декременты
    S4G_NODE_TYPE_PREINCR,
    S4G_NODE_TYPE_PREDECR,
    S4G_NODE_TYPE_POSTINCR,
    S4G_NODE_TYPE_POSTDECR,

    S4G_NODE_TYPE_NEGATE,

    //S4G_NODE_TYPE_GET_CR,//создание и получение переменной 
    S4G_NODE_TYPE_CALL, //вызов функции
    S4G_NODE_TYPE_ADD,//+
    S4G_NODE_TYPE_SUB,//-
    S4G_NODE_TYPE_MUL,//*
    S4G_NODE_TYPE_DIV,
    //S4G_NODE_TYPE_GROUP_B,//(
    //S4G_NODE_TYPE_GROUP_E,//)
    S4G_NODE_TYPE_RETURN,       //возвращение значений

    S4G_NODE_TYPE_TABLE,    //таблица
    //S4G_NODE_TYPE_TABLE_NEW,  //создание таблицы
    //S4G_NODE_TYPE_TABLE_INSERT,   //добавление в таблицу
    //S4G_NODE_TYPE_TABLE_APPEND,   //добавить в конец таблицы

    S4G_NODE_TYPE_IF,
    S4G_NODE_TYPE_WHILE,
    S4G_NODE_TYPE_FOR,
    S4G_NODE_TYPE_DO,

    S4G_NODE_TYPE_MOD,
    S4G_NODE_TYPE_BIT_AND,
    S4G_NODE_TYPE_BIT_OR,
    S4G_NODE_TYPE_BIT_XOR,
    S4G_NODE_TYPE_BIT_NOT,
    S4G_NODE_TYPE_BIT_SHIFTR,
    S4G_NODE_TYPE_BIT_SHIFTL,

    S4G_NODE_TYPE_LOG_NOT,
    S4G_NODE_TYPE_LOG_EQ,
    S4G_NODE_TYPE_LOG_NEQ,
    S4G_NODE_TYPE_LOG_GT,
    S4G_NODE_TYPE_LOG_LT,
    S4G_NODE_TYPE_LOG_GE,
    S4G_NODE_TYPE_LOG_LE,
    S4G_NODE_TYPE_LOG_NEQT,
    S4G_NODE_TYPE_LOG_EQT,
    S4G_NODE_TYPE_LOG_AND,
    S4G_NODE_TYPE_LOG_OR,

    S4G_NODE_TYPE_BREAK,
    S4G_NODE_TYPE_CONTINUE,

    S4G_NODE_TYPE_CHAIN,

    S4G_NODE_TYPE_CLASS,
    S4G_NODE_TYPE_CLASS_VAR,
    S4G_NODE_TYPE_NEW_OBJ,
};

const S4G_NODE_TYPE s4g_aop_map[] = {
    S4G_NODE_TYPE_ADD, //S4GLAO_ADD = 0,
    S4G_NODE_TYPE_SUB, //S4GLAO_SUB,
    S4G_NODE_TYPE_MUL, //S4GLAO_MUL,
    S4G_NODE_TYPE_DIV, //S4GLAO_DIV,
    S4G_NODE_TYPE_MOD, //S4GLAO_MOD,
    S4G_NODE_TYPE_LOG_AND, //S4GLAO_LOG_AND,
    S4G_NODE_TYPE_LOG_OR, //S4GLAO_LOG_OR,
    S4G_NODE_TYPE_BIT_XOR, //S4GLAO_BIT_XOR,
    S4G_NODE_TYPE_BIT_NOT, //S4GLAO_BIT_NOT,
    S4G_NODE_TYPE_BIT_SHIFTR, //S4GLAO_BIT_SHIFTR,
    S4G_NODE_TYPE_BIT_SHIFTL, //S4GLAO_BIT_SHIFTL,
    S4G_NODE_TYPE_LOG_NEQT, //S4GLAO_LOG_NEQT,
    S4G_NODE_TYPE_LOG_EQ, //S4GLAO_LOG_EQ,
    S4G_NODE_TYPE_LOG_NEQ, //S4GLAO_LOG_NEQ,
    S4G_NODE_TYPE_LOG_GE, //S4GLAO_LOG_GE,
    S4G_NODE_TYPE_LOG_LE, //S4GLAO_LOG_LE,
    S4G_NODE_TYPE_LOG_GT, //S4GLAO_LOG_GT,
    S4G_NODE_TYPE_LOG_LT, //S4GLAO_LOG_LT,
    S4G_NODE_TYPE_LOG_NOT, //S4GLAO_LOG_NOT,
    S4G_NODE_TYPE_LOG_EQT, //S4GLAO_LOG_EQT,
    S4G_NODE_TYPE_BIT_AND, //S4GLAO_BIT_AND,
    S4G_NODE_TYPE_BIT_OR, //S4GLAO_BIT_OR,
};

inline int s4g_get_priority(S4G_NODE_TYPE op)
{
    switch (op)
    {
    case S4G_NODE_TYPE_BIT_NOT:
        return 32;

    case S4G_NODE_TYPE_LOG_NOT:
        return 31;

    case S4G_NODE_TYPE_MUL:
    case S4G_NODE_TYPE_DIV:
    case S4G_NODE_TYPE_MOD:
        return 30;

    case S4G_NODE_TYPE_ADD:
    case S4G_NODE_TYPE_SUB:
        return 20;

    case S4G_NODE_TYPE_BIT_SHIFTR:
    case S4G_NODE_TYPE_BIT_SHIFTL:
        return 19;

    case S4G_NODE_TYPE_LOG_GT:
    case S4G_NODE_TYPE_LOG_GE:
    case S4G_NODE_TYPE_LOG_LT:
    case S4G_NODE_TYPE_LOG_LE:
        return 18;

    case S4G_NODE_TYPE_LOG_EQ:
    case S4G_NODE_TYPE_LOG_EQT:
    case S4G_NODE_TYPE_LOG_NEQ:
    case S4G_NODE_TYPE_LOG_NEQT:
        return 17;

    case S4G_NODE_TYPE_BIT_AND:
        return 16;

    case S4G_NODE_TYPE_BIT_XOR:
        return 15;

    case S4G_NODE_TYPE_BIT_OR:
        return 14;

    case S4G_NODE_TYPE_LOG_AND:
        return 13;

    case S4G_NODE_TYPE_LOG_OR:
        return 12;

    //case S4G_NODE_TYPE_GROUP_B:
    //case S4G_NODE_TYPE_GROUP_E:
    //  return 10;

    default:
        return -1;
    }
}

struct s4g_BaseNode
{
    s4g_BaseNode(s4g_Lexeme *pLexeme = NULL, s4g_Variable* pVariable = 0)
    {
        m_type = S4G_NODE_TYPE_BEGIN; m_pLexeme = pLexeme; m_pVariable = pVariable;
        ud = 0;
        m_pNext = 0;
    }
    S4G_NODE_TYPE m_type;       
    s4g_Lexeme *m_pLexeme;              
    s4g_Variable *m_pVariable;  

    s4g_BaseNode *m_pNext;  
    int ud;

    virtual void debugPrint()
    {
    }

    virtual String dumpChilds()
    {
        return("");
    }

    String Dump()
    {
        String out = "{type:'";
        out += TypeStr(m_type);
        out += "'";

        out += ",value:null";
        /*out += ",value:";
        if(value && int(value) >10)
        {
            out += "{name:'";
            out += value->m_szName;
            out += "',value:'";
            switch(value->m_pData->m_TypeValue)
            {
            case S4G_TYPE_NONE:
                out += "t_none";
                break;
            case S4G_TYPE_NULL:
                out += "t_null";
                break;
            case S4G_TYPE_TABLE:
                out += "t_table";
                break;
            case S4G_TYPE_STRING:
                {
                    String * _str = (String*)(value->m_pData->data.p);
                    for(int i = 0; i < _str->length(); ++i)
                    {
                        if(_str[0][i] == '\n')
                        {
                            out += "\\n";
                        }
                        else
                        {
                            out += _str[0][i];
                        }
                    }
                }
                break;
            case S4G_TYPE_FLOAT:
                out += value->m_pData->data.f;
                break;
            case S4G_TYPE_INT:
                out += value->m_pData->data.i;
                break;
            case S4G_TYPE_UINT:
                out += (DWORD)(value->m_pData->data.ui);
                break;
            case S4G_TYPE_BOOL:
                out += value->m_pData->data.b;
                break;
            case S4G_TYPE_PDATA:
                out += "t_pdata";
                break;
            case S4G_TYPE_CFUNC:
                out += "t_cfunc";
                break;
            case S4G_TYPE_SFUNC:
                out += "t_sfunc";
                break;
            case S4G_TYPE_NNULL:
                out += "0";
                break;
            }
            out += "'}";
        }
        else
        {
            out += "null";
        }*/

        out += dumpChilds();
        /*
        out += ",op1:";
        if(op1)
        {
            out += op1->Dump();
        }
        else
        {
            out += "null";
        }

        out += ",op2:";
        if(op2)
        {
            out += op2->Dump();
        }
        else
        {
            out += "null";
        }

        out += ",op3:";
        if(op3)
        {
            out += op3->Dump();
        }
        else
        {
            out += "null";
        }*/
        /*for(int i = 0, l = ops.size(); i < l; ++i)
        {
            out += String(",ops") + i + ":";
            if(ops[i])
            {
                out += ops[i]->Dump();
            }
            else
            {
                out += "null";
            }
        }*/
        out += ",next:";
        if(m_pNext)
        {
            out += m_pNext->Dump();
        }
        else
        {
            out += "null";
        }
        out += "}";
        return(out);
    }
    const char * TypeStr(S4G_NODE_TYPE t)
    {
        switch(t)
        {
        case S4G_NODE_TYPE_BEGIN:return("BEGIN");
        //case S4G_NODE_TYPE_EMPTY:return("EMPTY");
        case S4G_NODE_TYPE_BLOCK:return("BLOCK");
        case S4G_NODE_TYPE_EXPR:return("EXPR");
        case S4G_NODE_TYPE_VAR:return("VAR");
        case S4G_NODE_TYPE_DECLVAREND:return("DECLVAREND");
        case S4G_NODE_TYPE_ARRAY:return("ARRAY");
        case S4G_NODE_TYPE_NULL:return("NULL");
        case S4G_NODE_TYPE_FLOAT:return("FLOAT");
        case S4G_NODE_TYPE_INT:return("INT");
        //case S4G_NODE_TYPE_INT_CR:return("_int_cr");
        case S4G_NODE_TYPE_UINT:return("UINT");
        //case S4G_NODE_TYPE_UINT_CR:return("_uint_cr");
        case S4G_NODE_TYPE_STRING:return("STRING");
        //case S4G_NODE_TYPE_STRING_CR:return("_string_cr");
        case S4G_NODE_TYPE_FUNCTION:return("FUNCTION");
        //case S4G_NODE_TYPE_ARG:return("ARG");
        case S4G_NODE_TYPE_MARG:return("MARG");
        //case S4G_NODE_TYPE_SET:return("SET");
        //case S4G_NODE_TYPE_SETT:return("SETT");
        //case S4G_NODE_TYPE_GET:return("GET");
        //case S4G_NODE_TYPE_GET_CR:return("_get_cr");
        case S4G_NODE_TYPE_CALL:return("CALL");
        case S4G_NODE_TYPE_ADD:return("ADD");
        case S4G_NODE_TYPE_SUB:return("SUB");
        case S4G_NODE_TYPE_MUL:return("MUL");
        case S4G_NODE_TYPE_DIV:return("DIV");
        //case S4G_NODE_TYPE_GROUP_B:return("_group_b");
        //case S4G_NODE_TYPE_GROUP_E:return("_group_e");
        case S4G_NODE_TYPE_RETURN:return("RETURN");
        case S4G_NODE_TYPE_STMT:return("STMT");
        case S4G_NODE_TYPE_STMT_CHAIN:return("STMT_CHAIN");
        case S4G_NODE_TYPE_ID:return("ID");
        case S4G_NODE_TYPE_IF:return("IF");
        case S4G_NODE_TYPE_WHILE:return("WHILE");
        case S4G_NODE_TYPE_FOR:return("FOR");
        case S4G_NODE_TYPE_MOD:return("MOD");
        case S4G_NODE_TYPE_BIT_AND:return("BIT_AND");
        case S4G_NODE_TYPE_BIT_OR:return("BIT_OR");
        case S4G_NODE_TYPE_BIT_XOR:return("BIT_XOR");
        case S4G_NODE_TYPE_BIT_NOT:return("BIT_NOT");
        case S4G_NODE_TYPE_BIT_SHIFTR:return("BIT_SHIFTR");
        case S4G_NODE_TYPE_BIT_SHIFTL:return("BIT_SHIFTL");
        case S4G_NODE_TYPE_LOG_NOT:return("LOG_NOT");
        case S4G_NODE_TYPE_LOG_EQ:return("LOG_EQ");
        case S4G_NODE_TYPE_LOG_NEQ:return("LOG_NEQ");
        case S4G_NODE_TYPE_LOG_GT:return("LOG_GT");
        case S4G_NODE_TYPE_LOG_LT:return("LOG_LT");
        case S4G_NODE_TYPE_LOG_GE:return("LOG_GE");
        case S4G_NODE_TYPE_LOG_LE:return("LOG_LE");
        case S4G_NODE_TYPE_LOG_NEQT:return("LOG_NEQT");
        case S4G_NODE_TYPE_LOG_EQT:return("LOG_EQT");
        case S4G_NODE_TYPE_LOG_AND:return("LOG_AND");
        case S4G_NODE_TYPE_LOG_OR:return("LOG_OR");
        case S4G_NODE_TYPE_BREAK:return("BREAK");
        case S4G_NODE_TYPE_CONTINUE:return("CONTINUE");
        case S4G_NODE_TYPE_CHAIN:return("CHAIN");
        case S4G_NODE_TYPE_DO:return("DO");
        case S4G_NODE_TYPE_DECLVAR:return("DECLVAR");
        case S4G_NODE_TYPE_ACCESS_DOT:return("ACCESS_DOT");
        case S4G_NODE_TYPE_ACCESS_SQUARE:return("ACCESS_SQUARE");
        case S4G_NODE_TYPE_ASSIGN:return("ASSIGN");
        case S4G_NODE_TYPE_ASSIGN_ADD:return("ASSIGN_ADD");
        case S4G_NODE_TYPE_ASSIGN_SUB:return("ASSIGN_SUB");
        case S4G_NODE_TYPE_ASSIGN_MUL:return("ASSIGN_MUL");
        case S4G_NODE_TYPE_ASSIGN_DIV:return("ASSIGN_DIV");
        case S4G_NODE_TYPE_ASSIGN_MOD:return("ASSIGN_MOD");
        case S4G_NODE_TYPE_ASSIGN_BXOR:return("ASSIGN_BXOR");
//      case S4G_NODE_TYPE_ASSIGN_BNOT:return("ASSIGN_BNOT");
        case S4G_NODE_TYPE_ASSIGN_BRSH:return("ASSIGN_BRSH");
        case S4G_NODE_TYPE_ASSIGN_BLSH:return("ASSIGN_BLSH");
        case S4G_NODE_TYPE_ASSIGN_BAND:return("ASSIGN_BAND");
        case S4G_NODE_TYPE_ASSIGN_BOR:return("ASSIGN_BOR");
        case S4G_NODE_TYPE_PREINCR:return("PREINCR");
        case S4G_NODE_TYPE_PREDECR:return("PREDECR");
        case S4G_NODE_TYPE_POSTINCR:return("POSTINCR");
        case S4G_NODE_TYPE_POSTDECR:return("POSTDECR");
        case S4G_NODE_TYPE_NEGATE:return("NEGATE");
        case S4G_NODE_TYPE_CLASS:return("CLASS");
        case S4G_NODE_TYPE_CLASS_VAR:return("CLASS_VAR");
        case S4G_NODE_TYPE_NEW_OBJ:return("NEW_OBJ");
        case S4G_NODE_TYPE_TABLE:return("TABLE");
        case S4G_NODE_TYPE_CONST_DATA:return("CONST_DATA");
        case S4G_NODE_TYPE_BLOCK_NO_CTX:return("BLOCK_NO_CTX");
        case S4G_NODE_TYPE_BOOL:return("BOOL");
        case S4G_NODE_TYPE_TBL_ITEM:return("TBL_ITEM");
        case S4G_NODE_TYPE_ACCESS_SQUARE_NUM:return("ACCESS_SQUARE_NUM");
        case S4G_NODE_TYPE_ACCESS_SQUARE_APPEND:return("ACCESS_SQUARE_APPEND");
        default:return("UNKNOWN");
        }
    }
};

#define DEFINE_NODE(node) struct node: public s4g_BaseNode
#define DEFINE_NODE_CONSTRUCTOR(node, type) node(s4g_Lexeme *pLexeme = NULL, s4g_Variable *pVariable = 0): \
s4g_BaseNode(pLexeme, pVariable) \
{ \
    m_type = type; \
} 

DEFINE_NODE(s4g_ClassNode)
{
    DEFINE_NODE_CONSTRUCTOR(s4g_ClassNode, S4G_NODE_TYPE_CLASS);

    s4g_BaseNode *m_pName;
    s4g_BaseNode *m_pExtends;
    s4g_BaseNode *m_pVars;
    s4g_BaseNode *m_pFunctions;
    s4g_BaseNode *m_pClasses;

    virtual String dumpChilds()
    {
        String out;
        out += ",name:";
        if(m_pName)
        {
            out += m_pName->Dump();
        }
        else
        {
            out += "null";
        }
        out += ",extends:";
        if(m_pExtends)
        {
            out += m_pExtends->Dump();
        }
        else
        {
            out += "null";
        }
        out += ",vars:";
        if(m_pVars)
        {
            out += m_pVars->Dump();
        }
        else
        {
            out += "null";
        }
        out += ",funcs:";
        if(m_pFunctions)
        {
            out += m_pFunctions->Dump();
        }
        else
        {
            out += "null";
        }
        out += ",classes:";
        if(m_pClasses)
        {
            out += m_pClasses->Dump();
        }
        else
        {
            out += "null";
        }
        return(out);
    }
};

DEFINE_NODE(s4g_OpNode)
{
    s4g_OpNode(S4G_NODE_TYPE type, s4g_Lexeme *pLexeme = NULL, s4g_Variable *pVariable = 0):
        s4g_BaseNode(pLexeme, pVariable)
    {
        m_type = type;
    }

    s4g_BaseNode *m_pLeft;
    s4g_BaseNode *m_pRight;

    virtual String dumpChilds()
    {
        String out;
        out += ",left:";
        if(m_pLeft)
        {
            out += m_pLeft->Dump();
        }
        else
        {
            out += "null";
        }
        out += ",right:";
        if(m_pRight)
        {
            out += m_pRight->Dump();
        }
        else
        {
            out += "null";
        }
        return(out);
    }
};
DEFINE_NODE(s4g_AssignNode)
{
    s4g_AssignNode(S4G_NODE_TYPE type, s4g_Lexeme *pLexeme = NULL, s4g_Variable *pVariable = 0):
        s4g_BaseNode(pLexeme, pVariable)
    {
        m_type = type;
    }

    s4g_BaseNode *m_pLeft;
    s4g_BaseNode *m_pRight;

    virtual String dumpChilds()
    {
        String out;
        out += ",left:";
        if(m_pLeft)
        {
            out += m_pLeft->Dump();
        }
        else
        {
            out += "null";
        }
        out += ",right:";
        if(m_pRight)
        {
            out += m_pRight->Dump();
        }
        else
        {
            out += "null";
        }
        return(out);
    }
};
DEFINE_NODE(s4g_ExprTmpNode)
{
    s4g_ExprTmpNode(s4g_Lexeme *pLexeme = NULL, s4g_Variable *pVariable = 0):
        s4g_BaseNode(pLexeme, pVariable)
    {
        m_type = S4G_NODE_TYPE_EXPR; 
        m_pExpr = NULL;
        m_pExprNext = NULL;
    }

    s4g_BaseNode *m_pExpr;
    s4g_ExprTmpNode *m_pExprNext;

    virtual String dumpChilds()
    {
        String out;
        out += ",expr:";
        if(m_pExpr)
        {
            out += m_pExpr->Dump();
        }
        else
        {
            out += "null";
        }
        out += ",exprNext:";
        if(m_pExprNext)
        {
            out += m_pExprNext->Dump();
        }
        else
        {
            out += "null";
        }
        return(out);
    }
};

DEFINE_NODE(s4g_ConstNode)
{
    s4g_ConstNode(s4g_Lexeme *pLexeme, s4g_Variable *pVariable = 0):
        s4g_BaseNode(pLexeme, pVariable)
    {
        switch(pLexeme->m_type)
        {
        case S4G_LEXEME_TYPE_WORD_FLOAT:
            m_type = S4G_NODE_TYPE_FLOAT;
            break;
        case S4G_LEXEME_TYPE_WORD_STRING:
            m_type = S4G_NODE_TYPE_STRING;
            break;
        case S4G_LEXEME_TYPE_WORD_INT:
            m_type = S4G_NODE_TYPE_INT;
            break;
        case S4G_LEXEME_TYPE_WORD_UINT:
            m_type = S4G_NODE_TYPE_UINT;
            break;
        case S4G_LEXEME_TYPE_WORD_KEY:
            switch(pLexeme->m_idWord)
            {
            case S4G_KW_LANG_NULL:
                m_type = S4G_NODE_TYPE_NULL;
                break;
            case S4G_KW_LANG_TRUE:
            case S4G_KW_LANG_FALSE:
                m_type = S4G_NODE_TYPE_BOOL;
                break;
            }
        }
    }
};

DEFINE_NODE(s4g_ClassVarNode)
{
    DEFINE_NODE_CONSTRUCTOR(s4g_ClassVarNode, S4G_NODE_TYPE_CLASS_VAR);
};

DEFINE_NODE(s4g_VarNode)
{
    DEFINE_NODE_CONSTRUCTOR(s4g_VarNode, S4G_NODE_TYPE_VAR);
};

DEFINE_NODE(s4g_ArrayNode)
{
    DEFINE_NODE_CONSTRUCTOR(s4g_ArrayNode, S4G_NODE_TYPE_ARRAY);
    s4g_BaseNode *m_pItems;
    virtual String dumpChilds()
    {
        String out;
        out += ",items:";
        if(m_pItems)
        {
            out += m_pItems->Dump();
        }
        else
        {
            out += "null";
        }
        return(out);
    }
};

DEFINE_NODE(s4g_TableNode)
{
    DEFINE_NODE_CONSTRUCTOR(s4g_TableNode, S4G_NODE_TYPE_TABLE);
    s4g_BaseNode *m_pItems;
    virtual String dumpChilds()
    {
        String out;
        out += ",items:";
        if(m_pItems)
        {
            out += m_pItems->Dump();
        }
        else
        {
            out += "null";
        }
        return(out);
    }
};

DEFINE_NODE(s4g_BlockNode)
{
    DEFINE_NODE_CONSTRUCTOR(s4g_BlockNode, S4G_NODE_TYPE_BLOCK);
    s4g_BaseNode *m_pItems;
    virtual String dumpChilds()
    {
        String out;
        out += ",items:";
        if(m_pItems)
        {
            out += m_pItems->Dump();
        }
        else
        {
            out += "null";
        }
        return(out);
    }
};

DEFINE_NODE(s4g_StatementNode)
{
    DEFINE_NODE_CONSTRUCTOR(s4g_StatementNode, S4G_NODE_TYPE_STMT);
    s4g_BaseNode *m_pWhat;
    virtual String dumpChilds()
    {
        String out;
        out += ",what:";
        if(m_pWhat)
        {
            out += m_pWhat->Dump();
        }
        else
        {
            out += "null";
        }
        return(out);
    }
};

DEFINE_NODE(s4g_ReturnNode)
{
    DEFINE_NODE_CONSTRUCTOR(s4g_ReturnNode, S4G_NODE_TYPE_RETURN);
    s4g_BaseNode *m_pWhat;
    virtual String dumpChilds()
    {
        String out;
        out += ",what:";
        if(m_pWhat)
        {
            out += m_pWhat->Dump();
        }
        else
        {
            out += "null";
        }
        return(out);
    }
};

DEFINE_NODE(s4g_BreakNode)
{
    DEFINE_NODE_CONSTRUCTOR(s4g_BreakNode, S4G_NODE_TYPE_BREAK);
    s4g_BaseNode *m_pWhat;
    virtual String dumpChilds()
    {
        String out;
        out += ",what:";
        if(m_pWhat)
        {
            out += m_pWhat->Dump();
        }
        else
        {
            out += "null";
        }
        return(out);
    }
};
DEFINE_NODE(s4g_ContinueNode)
{
    DEFINE_NODE_CONSTRUCTOR(s4g_ContinueNode, S4G_NODE_TYPE_CONTINUE);
};

DEFINE_NODE(s4g_IDnode)
{
    DEFINE_NODE_CONSTRUCTOR(s4g_IDnode, S4G_NODE_TYPE_ID);
};

DEFINE_NODE(s4g_DeclVarNode)
{
    DEFINE_NODE_CONSTRUCTOR(s4g_DeclVarNode, S4G_NODE_TYPE_DECLVAR);
};

DEFINE_NODE(s4g_CallNode)
{
    DEFINE_NODE_CONSTRUCTOR(s4g_CallNode, S4G_NODE_TYPE_CALL);

    s4g_BaseNode *m_pWhat;
    s4g_BaseNode *m_pArgs;
    virtual String dumpChilds()
    {
        String out;
        out += ",what:";
        if(m_pWhat)
        {
            out += m_pWhat->Dump();
        }
        else
        {
            out += "null";
        }
        out += ",args:";
        if(m_pArgs)
        {
            out += m_pArgs->Dump();
        }
        else
        {
            out += "null";
        }
        return(out);
    }
};
DEFINE_NODE(s4g_NewObjNode)
{
    DEFINE_NODE_CONSTRUCTOR(s4g_NewObjNode, S4G_NODE_TYPE_NEW_OBJ);

    s4g_BaseNode *m_pWhat;
    s4g_BaseNode *m_pArgs;
    virtual String dumpChilds()
    {
        String out;
        out += ",what:";
        if(m_pWhat)
        {
            out += m_pWhat->Dump();
        }
        else
        {
            out += "null";
        }
        out += ",args:";
        if(m_pArgs)
        {
            out += m_pArgs->Dump();
        }
        else
        {
            out += "null";
        }
        return(out);
    }
};

DEFINE_NODE(s4g_FunctionNode)
{
    DEFINE_NODE_CONSTRUCTOR(s4g_FunctionNode, S4G_NODE_TYPE_FUNCTION);

    s4g_BaseNode *m_pName;
    s4g_BaseNode *m_pArgs;
    s4g_BaseNode *m_pExterns;
    s4g_BaseNode *m_pBody;

    virtual String dumpChilds()
    {
        String out;
        out += ",name:";
        if(m_pName)
        {
            out += m_pName->Dump();
        }
        else
        {
            out += "null";
        }
        out += ",args:";
        if(m_pArgs)
        {
            out += m_pArgs->Dump();
        }
        else
        {
            out += "null";
        }

        out += ",externs:";
        if(m_pExterns)
        {
            out += m_pExterns->Dump();
        }
        else
        {
            out += "null";
        }
        out += ",body:";
        if(m_pBody)
        {
            out += m_pBody->Dump();
        }
        else
        {
            out += "null";
        }
        return(out);
    }
};

DEFINE_NODE(s4g_IfNode)
{
    DEFINE_NODE_CONSTRUCTOR(s4g_IfNode, S4G_NODE_TYPE_IF);

    s4g_BaseNode *m_pCond;
    s4g_BaseNode *m_pThen;
    s4g_BaseNode *m_pElse;

    virtual String dumpChilds()
    {
        String out;
        out += ",cond:";
        if(m_pCond)
        {
            out += m_pCond->Dump();
        }
        else
        {
            out += "null";
        }
        out += ",then:";
        if(m_pThen)
        {
            out += m_pThen->Dump();
        }
        else
        {
            out += "null";
        }

        out += ",else:";
        if(m_pElse)
        {
            out += m_pElse->Dump();
        }
        else
        {
            out += "null";
        }
        return(out);
    }
};

DEFINE_NODE(s4g_WhileNode)
{
    DEFINE_NODE_CONSTRUCTOR(s4g_WhileNode, S4G_NODE_TYPE_WHILE);

    s4g_BaseNode *m_pCond;
    s4g_BaseNode *m_pBody;

    virtual String dumpChilds()
    {
        String out;
        out += ",cond:";
        if(m_pCond)
        {
            out += m_pCond->Dump();
        }
        else
        {
            out += "null";
        }
        
        out += ",body:";
        if(m_pBody)
        {
            out += m_pBody->Dump();
        }
        else
        {
            out += "null";
        }
        return(out);
    }
};

DEFINE_NODE(s4g_ForNode)
{
    DEFINE_NODE_CONSTRUCTOR(s4g_ForNode, S4G_NODE_TYPE_FOR);

    s4g_BaseNode *m_pInit;
    s4g_BaseNode *m_pCond;
    s4g_BaseNode *m_pStep;
    s4g_BaseNode *m_pBody;

    virtual String dumpChilds()
    {
        String out;
        out += ",init:";
        if(m_pInit)
        {
            out += m_pInit->Dump();
        }
        else
        {
            out += "null";
        }
        out += ",cond:";
        if(m_pCond)
        {
            out += m_pCond->Dump();
        }
        else
        {
            out += "null";
        }
        out += ",step:";
        if(m_pStep)
        {
            out += m_pStep->Dump();
        }
        else
        {
            out += "null";
        }

        out += ",body:";
        if(m_pBody)
        {
            out += m_pBody->Dump();
        }
        else
        {
            out += "null";
        }
        return(out);
    }
};

struct s4g_Node
{
    s4g_Node(S4G_NODE_TYPE type = S4G_NODE_TYPE_BEGIN, ID idLexeme = -1, s4g_Variable* pVariable = 0, s4g_Node* pOp1 = 0, s4g_Node* pOp2 = 0, s4g_Node* pOp3 = 0)
    {
        m_type = type; m_idLexeme = idLexeme; m_pVariable = pVariable; m_pOp1 = pOp1; m_pOp2 = pOp2; m_pOp3 = pOp3;
        ud = 0;
    }
    S4G_NODE_TYPE m_type;       //тип нода
    ID m_idLexeme;              //id лексемы которая способствовала генерации данного нода
    s4g_Variable* m_pVariable;  //значение если надо

    //содержимое нода или продолжение
    s4g_Node* m_pOp1;
    s4g_Node* m_pOp2;
    s4g_Node* m_pOp3;
    int ud;
    Array<s4g_Node*> ops;

/*#if defined(_DEBUG)
    String Dump()
    {
        String out = "{type:'";
        out += TypeStr(type);
        out += "'";

        out += ",value:";
        if (value && int(value) >10)
        {
            out += "{name:'";
            out += value->m_szName;
            out += "',value:'";
            switch (value->m_pData->m_TypeValue)
            {
            case S4G_TYPE_NONE:
                out += "t_none";
                break;
            case S4G_TYPE_NULL:
                out += "t_null";
                break;
            case S4G_TYPE_TABLE:
                out += "t_table";
                break;
            case S4G_TYPE_STRING:
            {
                String * _str = (String*)(value->m_pData->data.p);
                             for (int i = 0; i < _str->length(); ++i)
                             {
                                 if (_str[0][i] == '\n')
                                 {
                                     out += "\\n";
                                 }
                                 else
                                 {
                                     out += _str[0][i];
                                 }
                             }
            }
                break;
            case S4G_TYPE_FLOAT:
                out += value->m_pData->data.f;
                break;
            case S4G_TYPE_INT:
                out += value->m_pData->data.i;
                break;
            case S4G_TYPE_UINT:
                out += (DWORD)(value->m_pData->data.ui);
                break;
            case S4G_TYPE_BOOL:
                out += value->m_pData->data.b;
                break;
            case S4G_TYPE_PDATA:
                out += "t_pdata";
                break;
            case S4G_TYPE_CFUNC:
                out += "t_cfunc";
                break;
            case S4G_TYPE_SFUNC:
                out += "t_sfunc";
                break;
            case S4G_TYPE_NNULL:
                out += "0";
                break;
            }
            out += "'}";
        }
        else
        {
            out += "null";
        }

        out += ",op1:";
        if (op1)
        {
            out += op1->Dump();
        }
        else
        {
            out += "null";
        }

        out += ",op2:";
        if (op2)
        {
            out += op2->Dump();
        }
        else
        {
            out += "null";
        }

        out += ",op3:";
        if (op3)
        {
            out += op3->Dump();
        }
        else
        {
            out += "null";
        }
        for (int i = 0, l = ops.size(); i < l; ++i)
        {
            out += String(",ops") + i + ":";
            if (ops[i])
            {
                out += ops[i]->Dump();
            }
            else
            {
                out += "null";
            }
        }
        out += "}";
        return(out);
    }
    const char * TypeStr(S4G_NODE_TYPE t)
    {
        switch (t)
        {
        case S4G_NODE_TYPE_BEGIN:return("_begin");
        case S4G_NODE_TYPE_EMPTY:return("_empty");
        case S4G_NODE_TYPE_BLOCK:return("_block");
        case S4G_NODE_TYPE_EXPR:return("_expr");
        case S4G_NODE_TYPE_VAR:return("_var");
        case S4G_NODE_TYPE_CRVAR:return("_crvar");
        case S4G_NODE_TYPE_NULL:return("_null");
        case S4G_NODE_TYPE_FLOAT:return("_float");
        case S4G_NODE_TYPE_INT:return("_int");
        case S4G_NODE_TYPE_INT_CR:return("_int_cr");
        case S4G_NODE_TYPE_UINT:return("_uint");
        case S4G_NODE_TYPE_UINT_CR:return("_uint_cr");
        case S4G_NODE_TYPE_STRING:return("_string");
        case S4G_NODE_TYPE_STRING_CR:return("_string_cr");
        case S4G_NODE_TYPE_FUNCTION:return("_function");
        case S4G_NODE_TYPE_NNULL:return("_numnull");
        case S4G_NODE_TYPE_ARG:return("_arg");
        case S4G_NODE_TYPE_MARG:return("_marg");
        case S4G_NODE_TYPE_SET:return("_set");
        case S4G_NODE_TYPE_SETT:return("_sett");
        case S4G_NODE_TYPE_GET:return("_get");
        case S4G_NODE_TYPE_GET_CR:return("_get_cr");
        case S4G_NODE_TYPE_CALL:return("_call");
        case S4G_NODE_TYPE_ADD:return("_add");
        case S4G_NODE_TYPE_SUB:return("_sub");
        case S4G_NODE_TYPE_MUL:return("_mul");
        case S4G_NODE_TYPE_DIV:return("_div");
        case S4G_NODE_TYPE_GROUP_B:return("_group_b");
        case S4G_NODE_TYPE_GROUP_E:return("_group_e");
        case S4G_NODE_TYPE_RETURN:return("_return");
        case _create_table:return("_create_table");
        case _add_in_table:return("_add_in_table");
        case S4G_NODE_TYPE_IF:return("_if");
        case S4G_NODE_TYPE_WHILE:return("_while");
        case S4G_NODE_TYPE_FOR:return("_for");
        case S4G_NODE_TYPE_MOD:return("_mod");
        case S4G_NODE_TYPE_BIT_AND:return("_bit_and");
        case S4G_NODE_TYPE_BIT_OR:return("_bit_or");
        case S4G_NODE_TYPE_BIT_XOR:return("_bit_xor");
        case S4G_NODE_TYPE_BIT_NOT:return("_bit_not");
        case S4G_NODE_TYPE_BIT_SHIFTR:return("_bit_shiftr");
        case S4G_NODE_TYPE_BIT_SHIFTL:return("_bit_shiftl");
        case S4G_NODE_TYPE_LOG_NOT:return("_log_not");
        case S4G_NODE_TYPE_LOG_EQ:return("_log_eq");
        case S4G_NODE_TYPE_LOG_NEQ:return("_log_neq");
        case S4G_NODE_TYPE_LOG_GT:return("_log_gt");
        case S4G_NODE_TYPE_LOG_LT:return("_log_lt");
        case S4G_NODE_TYPE_LOG_GE:return("_log_ge");
        case S4G_NODE_TYPE_LOG_LE:return("_log_le");
        case S4G_NODE_TYPE_LOG_NEQT:return("_log_neqt");
        case S4G_NODE_TYPE_LOG_EQT:return("_log_eqt");
        case S4G_NODE_TYPE_LOG_AND:return("_log_and");
        case S4G_NODE_TYPE_LOG_OR:return("_log_or");
        case S4G_NODE_TYPE_BREAK:return("_break");
        case S4G_NODE_TYPE_CONTINUE:return("_continue");
        case S4G_NODE_TYPE_CHAIN:return("_chain");
        case S4G_NODE_TYPE_DO:return("_do");
        default:return("UNKNOWN");
        }
    }
#endif*/
};
//type == _expr:
//op1 - выражение, 
//op2 то что следует за выражением для целостности

//type == _call:
//op1 - _var
//op2 - значит у нас перечисление того что будем присваивать
//op3 - _arg
//op1 - аргумент
//op2 - _empty
//op1 - _ аргумент
//op2 - _empty
//...

//type == S4G_NODE_TYPE_FUNCTION:
//op1 - _arg первый аргумент:
//value
//op1 - следующий _arg
//...
//op2 - тело функции

//type == _set:
//op1 - чему присваиваем
//op2 - то что присваиваем

//type == _var
//op1 - _get если существует то значит идет обращение к элементу таблицы
//op1 - S4G_NODE_TYPE_STRING/_number/S4G_NODE_TYPE_CRVAR
//op2 - empty
//op1 - _get
//...
//op2 - _var/S4G_NODE_TYPE_CRVAR - если существует нод то значит у нас идет перечисление через запятую переменных которым или которые будем присваивать
//op3 - _var/value/operation - если существует нод значит у нас идут какие то арифметические операции или сравнения
//...

//type == _create_table
//либо op1 - _sett
//тоже самое что и _set (_sett указыает что манипулируем в таблице)
//либо op1 - _add_in_table
//op1 - то что добавляем в таблицу
//op2 - _empty
//op1 - _add_in_table
//...
//op2 - _empty
//op1 - _sett
//op2 - _empty
//...


#endif