quinn-os/my-basic
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

*polished code.

Browse Source
This commit is contained in:
paladin-t 2016-03-03 10:40:26 +08:00
parent 80fe1da2a4
commit 6d579b2478
3 changed files with 145 additions and 115 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

236
core/my_basic.c
View File

@ -172,6 +172,7 @@ typedef int (* _common_compare)(void*, void*);
/* Container operation */ /* Container operation */
#define _OP_RESULT_NORMAL 0 #define _OP_RESULT_NORMAL 0
#define _OP_RESULT_DEL_NODE -1 #define _OP_RESULT_DEL_NODE -1
typedef int (* _common_operation)(void*, void*); typedef int (* _common_operation)(void*, void*);
/** List */ /** List */
@ -320,26 +321,20 @@ typedef enum _data_e {
_DT_EOS /* End of statement */ _DT_EOS /* End of statement */
} _data_e; } _data_e;
typedef struct _func_t { #ifdef MB_ENABLE_COLLECTION_LIB
char* name; # define _HAS_REF_OBJ_LOCK
mb_func_t pointer; #endif /* MB_ENABLE_COLLECTION_LIB */
} _func_t;
typedef struct _var_t { #ifdef _HAS_REF_OBJ_LOCK
char* name; typedef short _lock_t;
struct _object_t* data; #endif /* _HAS_REF_OBJ_LOCK */
#ifdef MB_ENABLE_CLASS
int pathing;
bool_t isme;
#endif /* MB_ENABLE_CLASS */
} _var_t;
struct _ref_t; struct _ref_t;
#define _NONE_REF 1
typedef void (* _unref_func_t)(struct _ref_t*, void*); typedef void (* _unref_func_t)(struct _ref_t*, void*);
#define _NONE_REF 1
typedef unsigned _ref_count_t; typedef unsigned _ref_count_t;
typedef struct _ref_t { typedef struct _ref_t {
@ -350,8 +345,6 @@ typedef struct _ref_t {
struct mb_interpreter_t* s; struct mb_interpreter_t* s;
} _ref_t; } _ref_t;
typedef short _lock_t;
typedef struct _gc_t { typedef struct _gc_t {
_ht_node_t* table; _ht_node_t* table;
_ht_node_t* recursive_table; _ht_node_t* recursive_table;
@ -379,6 +372,20 @@ typedef struct _usertype_ref_t {
_override_func_info_t overrides; _override_func_info_t overrides;
} _usertype_ref_t; } _usertype_ref_t;
typedef struct _func_t {
char* name;
mb_func_t pointer;
} _func_t;
typedef struct _var_t {
char* name;
struct _object_t* data;
#ifdef MB_ENABLE_CLASS
int pathing;
bool_t isme;
#endif /* MB_ENABLE_CLASS */
} _var_t;
typedef struct _array_t { typedef struct _array_t {
#ifdef MB_ENABLE_ARRAY_REF #ifdef MB_ENABLE_ARRAY_REF
_ref_t ref; _ref_t ref;
@ -429,6 +436,8 @@ typedef struct _dict_t {
_ht_node_t* dict; _ht_node_t* dict;
} _dict_t; } _dict_t;
#define _INVALID_DICT_IT ((_ls_node_t*)(intptr_t)~0)
typedef struct _dict_it_t { typedef struct _dict_it_t {
_ref_t weak_ref; _ref_t weak_ref;
_dict_t* dict; _dict_t* dict;
@ -444,13 +453,12 @@ typedef struct _label_t {
} _label_t; } _label_t;
#ifdef MB_ENABLE_CLASS #ifdef MB_ENABLE_CLASS
# define _CLASS_ME "ME" #define _CLASS_ME "ME"
# define _CLASS_HASH_FUNC "HASH"
# define _CLASS_COMPARE_FUNC "COMPARE" #define _CLASS_HASH_FUNC "HASH"
# define _CLASS_TO_STRING_FUNC "TOSTRING" #define _CLASS_COMPARE_FUNC "COMPARE"
#endif /* MB_ENABLE_CLASS */ #define _CLASS_TO_STRING_FUNC "TOSTRING"
#ifdef MB_ENABLE_CLASS
typedef struct _class_t { typedef struct _class_t {
_ref_t ref; _ref_t ref;
char* name; char* name;
@ -599,21 +607,21 @@ MBAPI const size_t MB_SIZEOF_LSN = _MB_MEM_TAG_SIZE + sizeof(_ls_node_t);
MBAPI const size_t MB_SIZEOF_HTN = _MB_MEM_TAG_SIZE + sizeof(_ht_node_t); MBAPI const size_t MB_SIZEOF_HTN = _MB_MEM_TAG_SIZE + sizeof(_ht_node_t);
MBAPI const size_t MB_SIZEOF_HTA = _MB_MEM_TAG_SIZE + sizeof(_ht_node_t*) * _HT_ARRAY_SIZE_DEFAULT; MBAPI const size_t MB_SIZEOF_HTA = _MB_MEM_TAG_SIZE + sizeof(_ht_node_t*) * _HT_ARRAY_SIZE_DEFAULT;
MBAPI const size_t MB_SIZEOF_OBJ = _MB_MEM_TAG_SIZE + sizeof(_object_t); MBAPI const size_t MB_SIZEOF_OBJ = _MB_MEM_TAG_SIZE + sizeof(_object_t);
MBAPI const size_t MB_SIZEOF_FUN = _MB_MEM_TAG_SIZE + sizeof(_func_t);
MBAPI const size_t MB_SIZEOF_VAR = _MB_MEM_TAG_SIZE + sizeof(_var_t);
#ifdef MB_ENABLE_USERTYPE_REF #ifdef MB_ENABLE_USERTYPE_REF
MBAPI const size_t MB_SIZEOF_UTR = _MB_MEM_TAG_SIZE + sizeof(_usertype_ref_t); MBAPI const size_t MB_SIZEOF_UTR = _MB_MEM_TAG_SIZE + sizeof(_usertype_ref_t);
#endif /* MB_ENABLE_USERTYPE_REF */ #endif /* MB_ENABLE_USERTYPE_REF */
MBAPI const size_t MB_SIZEOF_FUN = _MB_MEM_TAG_SIZE + sizeof(_func_t);
MBAPI const size_t MB_SIZEOF_VAR = _MB_MEM_TAG_SIZE + sizeof(_var_t);
MBAPI const size_t MB_SIZEOF_ARR = _MB_MEM_TAG_SIZE + sizeof(_array_t); MBAPI const size_t MB_SIZEOF_ARR = _MB_MEM_TAG_SIZE + sizeof(_array_t);
MBAPI const size_t MB_SIZEOF_LBL = _MB_MEM_TAG_SIZE + sizeof(_label_t);
#ifdef MB_ENABLE_COLLECTION_LIB #ifdef MB_ENABLE_COLLECTION_LIB
MBAPI const size_t MB_SIZEOF_LST = _MB_MEM_TAG_SIZE + sizeof(_list_t); MBAPI const size_t MB_SIZEOF_LST = _MB_MEM_TAG_SIZE + sizeof(_list_t);
MBAPI const size_t MB_SIZEOF_DCT = _MB_MEM_TAG_SIZE + sizeof(_dict_t); MBAPI const size_t MB_SIZEOF_DCT = _MB_MEM_TAG_SIZE + sizeof(_dict_t);
#endif /* MB_ENABLE_COLLECTION_LIB */ #endif /* MB_ENABLE_COLLECTION_LIB */
MBAPI const size_t MB_SIZEOF_RTN = _MB_MEM_TAG_SIZE + sizeof(_routine_t); MBAPI const size_t MB_SIZEOF_LBL = _MB_MEM_TAG_SIZE + sizeof(_label_t);
#ifdef MB_ENABLE_CLASS #ifdef MB_ENABLE_CLASS
MBAPI const size_t MB_SIZEOF_CLS = _MB_MEM_TAG_SIZE + sizeof(_class_t); MBAPI const size_t MB_SIZEOF_CLS = _MB_MEM_TAG_SIZE + sizeof(_class_t);
#endif /* MB_ENABLE_CLASS */ #endif /* MB_ENABLE_CLASS */
MBAPI const size_t MB_SIZEOF_RTN = _MB_MEM_TAG_SIZE + sizeof(_routine_t);
#else /* MB_ENABLE_ALLOC_STAT */ #else /* MB_ENABLE_ALLOC_STAT */
MBAPI const size_t MB_SIZEOF_INT = sizeof(int); MBAPI const size_t MB_SIZEOF_INT = sizeof(int);
MBAPI const size_t MB_SIZEOF_PTR = sizeof(intptr_t); MBAPI const size_t MB_SIZEOF_PTR = sizeof(intptr_t);
@ -621,21 +629,21 @@ MBAPI const size_t MB_SIZEOF_LSN = sizeof(_ls_node_t);
MBAPI const size_t MB_SIZEOF_HTN = sizeof(_ht_node_t); MBAPI const size_t MB_SIZEOF_HTN = sizeof(_ht_node_t);
MBAPI const size_t MB_SIZEOF_HTA = sizeof(_ht_node_t*) * _HT_ARRAY_SIZE_DEFAULT; MBAPI const size_t MB_SIZEOF_HTA = sizeof(_ht_node_t*) * _HT_ARRAY_SIZE_DEFAULT;
MBAPI const size_t MB_SIZEOF_OBJ = sizeof(_object_t); MBAPI const size_t MB_SIZEOF_OBJ = sizeof(_object_t);
MBAPI const size_t MB_SIZEOF_FUN = sizeof(_func_t);
MBAPI const size_t MB_SIZEOF_VAR = sizeof(_var_t);
#ifdef MB_ENABLE_USERTYPE_REF #ifdef MB_ENABLE_USERTYPE_REF
MBAPI const size_t MB_SIZEOF_UTR = sizeof(_usertype_ref_t); MBAPI const size_t MB_SIZEOF_UTR = sizeof(_usertype_ref_t);
#endif /* MB_ENABLE_USERTYPE_REF */ #endif /* MB_ENABLE_USERTYPE_REF */
MBAPI const size_t MB_SIZEOF_FUN = sizeof(_func_t);
MBAPI const size_t MB_SIZEOF_VAR = sizeof(_var_t);
MBAPI const size_t MB_SIZEOF_ARR = sizeof(_array_t); MBAPI const size_t MB_SIZEOF_ARR = sizeof(_array_t);
MBAPI const size_t MB_SIZEOF_LBL = sizeof(_label_t);
#ifdef MB_ENABLE_COLLECTION_LIB #ifdef MB_ENABLE_COLLECTION_LIB
MBAPI const size_t MB_SIZEOF_LST = sizeof(_list_t); MBAPI const size_t MB_SIZEOF_LST = sizeof(_list_t);
MBAPI const size_t MB_SIZEOF_DCT = sizeof(_dict_t); MBAPI const size_t MB_SIZEOF_DCT = sizeof(_dict_t);
#endif /* MB_ENABLE_COLLECTION_LIB */ #endif /* MB_ENABLE_COLLECTION_LIB */
MBAPI const size_t MB_SIZEOF_RTN = sizeof(_routine_t); MBAPI const size_t MB_SIZEOF_LBL = sizeof(_label_t);
#ifdef MB_ENABLE_CLASS #ifdef MB_ENABLE_CLASS
MBAPI const size_t MB_SIZEOF_CLS = sizeof(_class_t); MBAPI const size_t MB_SIZEOF_CLS = sizeof(_class_t);
#endif /* MB_ENABLE_CLASS */ #endif /* MB_ENABLE_CLASS */
MBAPI const size_t MB_SIZEOF_RTN = sizeof(_routine_t);
#endif /* MB_ENABLE_ALLOC_STAT */ #endif /* MB_ENABLE_ALLOC_STAT */
#ifdef MB_ENABLE_SOURCE_TRACE #ifdef MB_ENABLE_SOURCE_TRACE
@ -1256,17 +1264,24 @@ static mb_input_func_t _get_inputer(mb_interpreter_t* s);
static char* _load_file(mb_interpreter_t* s, const char* f, const char* prefix); static char* _load_file(mb_interpreter_t* s, const char* f, const char* prefix);
static void _end_of_file(_parsing_context_t* context); static void _end_of_file(_parsing_context_t* context);
static bool_t _is_blank(char c); #define _ZERO_CHAR '\0'
static bool_t _is_eof(char c); #define _NEWLINE_CHAR '\n'
static bool_t _is_newline(char c); #define _RETURN_CHAR '\r'
static bool_t _is_separator(char c); #define _STRING_POSTFIX '$'
static bool_t _is_bracket(char c); #define _DUMMY_ASSIGN "#"
static bool_t _is_quotation_mark(char c);
static bool_t _is_comment(char c); static bool_t _is_blank_char(char c);
static bool_t _is_accessor(char c); static bool_t _is_eof_char(char c);
static bool_t _is_newline_char(char c);
static bool_t _is_separator_char(char c);
static bool_t _is_bracket_char(char c);
static bool_t _is_quotation_char(char c);
static bool_t _is_comment_char(char c);
static bool_t _is_accessor_char(char c);
static bool_t _is_numeric_char(char c); static bool_t _is_numeric_char(char c);
static bool_t _is_identifier_char(char c); static bool_t _is_identifier_char(char c);
static bool_t _is_operator_char(char c); static bool_t _is_operator_char(char c);
static bool_t _is_exponential_char(char c);
static bool_t _is_using_char(char c); static bool_t _is_using_char(char c);
static bool_t _is_exponent_prefix(char* s, int begin, int end); static bool_t _is_exponent_prefix(char* s, int begin, int end);
@ -1454,9 +1469,11 @@ static char* _extract_string(_object_t* obj);
} \ } \
} }
#ifdef _HAS_REF_OBJ_LOCK
static bool_t _lock_ref_object(_lock_t* lk, _ref_t* ref, void* obj); static bool_t _lock_ref_object(_lock_t* lk, _ref_t* ref, void* obj);
static bool_t _unlock_ref_object(_lock_t* lk, _ref_t* ref, void* obj); static bool_t _unlock_ref_object(_lock_t* lk, _ref_t* ref, void* obj);
static bool_t _write_on_ref_object(_lock_t* lk, _ref_t* ref, void* obj); static bool_t _write_on_ref_object(_lock_t* lk, _ref_t* ref, void* obj);
#endif /* _HAS_REF_OBJ_LOCK */
static _ref_count_t _ref(_ref_t* ref, void* data); static _ref_count_t _ref(_ref_t* ref, void* data);
static bool_t _unref(_ref_t* ref, void* data); static bool_t _unref(_ref_t* ref, void* data);
@ -1837,7 +1854,7 @@ static int _coll_move_next(mb_interpreter_t* s, void** l);
/** Lib information */ /** Lib information */
static const _func_t _core_libs[] = { static const _func_t _core_libs[] = {
{ "#", _core_dummy_assign }, { _DUMMY_ASSIGN, _core_dummy_assign },
{ "+", _core_add }, { "+", _core_add },
{ "-", _core_min }, { "-", _core_min },
{ "*", _core_mul }, { "*", _core_mul },
@ -2973,7 +2990,7 @@ static int mb_uu_substr(char* ch, int begin, int count, char** o) {
l = (int)(e - b); l = (int)(e - b);
*o = (char*)mb_malloc(l + 1); *o = (char*)mb_malloc(l + 1);
memcpy(*o, b, l); memcpy(*o, b, l);
(*o)[l] = '\0'; (*o)[l] = _ZERO_CHAR;
return l; return l;
} }
@ -3053,7 +3070,7 @@ static bool_t _is_binary(mb_func_t op) {
static char _get_priority(mb_func_t op1, mb_func_t op2) { static char _get_priority(mb_func_t op1, mb_func_t op2) {
/* Get the priority of two operators */ /* Get the priority of two operators */
char result = '\0'; char result = _ZERO_CHAR;
int idx1 = 0; int idx1 = 0;
int idx2 = 0; int idx2 = 0;
@ -3179,7 +3196,7 @@ static int _calc_expression(mb_interpreter_t* s, _ls_node_t** l, _object_t** val
_object_t* b = 0; _object_t* b = 0;
_object_t* r = 0; _object_t* r = 0;
_object_t* theta = 0; _object_t* theta = 0;
char pri = '\0'; char pri = _ZERO_CHAR;
int* inep = 0; int* inep = 0;
int f = 0; int f = 0;
@ -3221,8 +3238,8 @@ static int _calc_expression(mb_interpreter_t* s, _ls_node_t** l, _object_t** val
ast = ast->next; ast = ast->next;
_ls_pushback(optr, _exp_assign); _ls_pushback(optr, _exp_assign);
while( while(
!(c->type == _DT_FUNC && strcmp(c->data.func->name, "#") == 0) || !(c->type == _DT_FUNC && strcmp(c->data.func->name, _DUMMY_ASSIGN) == 0) ||
!(((_object_t*)(_ls_back(optr)->data))->type == _DT_FUNC && strcmp(((_object_t*)(_ls_back(optr)->data))->data.func->name, "#") == 0)) { !(((_object_t*)(_ls_back(optr)->data))->type == _DT_FUNC && strcmp(((_object_t*)(_ls_back(optr)->data))->data.func->name, _DUMMY_ASSIGN) == 0)) {
if(!hack) { if(!hack) {
if(_IS_FUNC(c, _core_open_bracket)) { if(_IS_FUNC(c, _core_open_bracket)) {
++bracket_count; ++bracket_count;
@ -4189,7 +4206,7 @@ static char* _load_file(mb_interpreter_t* s, const char* f, const char* prefix)
} }
fread(buf + i, 1, l, fp); fread(buf + i, 1, l, fp);
fclose(fp); fclose(fp);
buf[l] = '\0'; buf[l] = _ZERO_CHAR;
} }
} }
@ -4205,7 +4222,7 @@ static void _end_of_file(_parsing_context_t* context) {
context->parsing_state = _PS_NORMAL; context->parsing_state = _PS_NORMAL;
} }
static bool_t _is_blank(char c) { static bool_t _is_blank_char(char c) {
/* Determine whether a character is blank */ /* Determine whether a character is blank */
return return
(c == ' ') || (c == '\t') || (c == ' ') || (c == '\t') ||
@ -4213,44 +4230,44 @@ static bool_t _is_blank(char c) {
(c == -2) || (c == -1); (c == -2) || (c == -1);
} }
static bool_t _is_eof(char c) { static bool_t _is_eof_char(char c) {
/* Determine whether a character is end of file */ /* Determine whether a character is end of file */
return (c == EOF); return (c == EOF);
} }
static bool_t _is_newline(char c) { static bool_t _is_newline_char(char c) {
/* Determine whether a character is newline */ /* Determine whether a character is newline */
return (c == '\r') || (c == '\n') || _is_eof(c); return (c == _RETURN_CHAR) || (c == _NEWLINE_CHAR) || _is_eof_char(c);
} }
static bool_t _is_separator(char c) { static bool_t _is_separator_char(char c) {
/* Determine whether a character is separator */ /* Determine whether a character is separator */
return (c == ',') || (c == ';') || (c == ':'); return (c == ',') || (c == ';') || (c == ':');
} }
static bool_t _is_bracket(char c) { static bool_t _is_bracket_char(char c) {
/* Determine whether a character is bracket */ /* Determine whether a character is bracket */
return (c == '(') || (c == ')'); return (c == '(') || (c == ')');
} }
static bool_t _is_quotation_mark(char c) { static bool_t _is_quotation_char(char c) {
/* Determine whether a character is quotation mark */ /* Determine whether a character is quotation mark */
return (c == '"'); return (c == '"');
} }
static bool_t _is_comment(char c) { static bool_t _is_comment_char(char c) {
/* Determine whether a character is comment mark */ /* Determine whether a character is comment mark */
return (c == '\''); return (c == '\'');
} }
static bool_t _is_accessor(char c) { static bool_t _is_accessor_char(char c) {
/* Determine whether a character is accessor char */ /* Determine whether a character is accessor char */
return (c == '.'); return (c == '.');
} }
static bool_t _is_numeric_char(char c) { static bool_t _is_numeric_char(char c) {
/* Determine whether a character is numeric char */ /* Determine whether a character is numeric char */
return (c >= '0' && c <= '9') || _is_accessor(c); return (c >= '0' && c <= '9') || _is_accessor_char(c);
} }
static bool_t _is_identifier_char(char c) { static bool_t _is_identifier_char(char c) {
@ -4259,7 +4276,7 @@ static bool_t _is_identifier_char(char c) {
(c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') ||
(c == '_') || (c == '_') ||
_is_numeric_char(c) || _is_numeric_char(c) ||
(c == '$'); (c == _STRING_POSTFIX);
} }
static bool_t _is_operator_char(char c) { static bool_t _is_operator_char(char c) {
@ -4272,6 +4289,11 @@ static bool_t _is_operator_char(char c) {
(c == '>') || (c == '<'); (c == '>') || (c == '<');
} }
static bool_t _is_exponential_char(char c) {
/* Determine whether a character is a exponential char */
return (c == 'e') || (c == 'E');
}
static bool_t _is_using_char(char c) { static bool_t _is_using_char(char c) {
/* Determine whether a character is module using char */ /* Determine whether a character is module using char */
return (c == '@'); return (c == '@');
@ -4303,7 +4325,7 @@ static int _append_char_to_symbol(mb_interpreter_t* s, char c) {
context = s->parsing_context; context = s->parsing_context;
if(_is_accessor(c)) if(_is_accessor_char(c))
context->current_symbol_contains_accessor++; context->current_symbol_contains_accessor++;
if(context->current_symbol_nonius + 1 >= _SINGLE_SYMBOL_MAX_LENGTH) { if(context->current_symbol_nonius + 1 >= _SINGLE_SYMBOL_MAX_LENGTH) {
@ -4329,7 +4351,7 @@ static int _cut_symbol(mb_interpreter_t* s, int pos, unsigned short row, unsigne
mb_assert(s); mb_assert(s);
context = s->parsing_context; context = s->parsing_context;
if(context->current_symbol_nonius && context->current_symbol[0] != '\0') { if(context->current_symbol_nonius && context->current_symbol[0] != _ZERO_CHAR) {
sym = (char*)mb_malloc(context->current_symbol_nonius + 1); sym = (char*)mb_malloc(context->current_symbol_nonius + 1);
memcpy(sym, context->current_symbol, context->current_symbol_nonius + 1); memcpy(sym, context->current_symbol, context->current_symbol_nonius + 1);
@ -4450,7 +4472,7 @@ static int _create_symbol(mb_interpreter_t* s, _ls_node_t* l, char* sym, _object
size_t _sl = strlen(sym); size_t _sl = strlen(sym);
(*obj)->data.string = (char*)mb_malloc(_sl - 2 + 1); (*obj)->data.string = (char*)mb_malloc(_sl - 2 + 1);
memcpy((*obj)->data.string, sym + sizeof(char), _sl - 2); memcpy((*obj)->data.string, sym + sizeof(char), _sl - 2);
(*obj)->data.string[_sl - 2] = '\0'; (*obj)->data.string[_sl - 2] = _ZERO_CHAR;
*delsym = true; *delsym = true;
} }
@ -4580,7 +4602,7 @@ static int _create_symbol(mb_interpreter_t* s, _ls_node_t* l, char* sym, _object
memset(tmp.var, 0, sizeof(_var_t)); memset(tmp.var, 0, sizeof(_var_t));
tmp.var->name = sym; tmp.var->name = sym;
tmp.var->data = _create_object(); tmp.var->data = _create_object();
tmp.var->data->type = (sym[strlen(sym) - 1] == '$') ? _DT_STRING : _DT_INT; tmp.var->data->type = (sym[strlen(sym) - 1] == _STRING_POSTFIX) ? _DT_STRING : _DT_INT;
tmp.var->data->data.integer = 0; tmp.var->data->data.integer = 0;
#ifdef MB_ENABLE_CLASS #ifdef MB_ENABLE_CLASS
if(context->class_state != _CLASS_STATE_NONE) if(context->class_state != _CLASS_STATE_NONE)
@ -4667,7 +4689,7 @@ static _data_e _get_symbol_type(mb_interpreter_t* s, char* sym, _raw_t* value) {
/* int_t */ /* int_t */
tmp.integer = (int_t)mb_strtol(sym, &conv_suc, 0); tmp.integer = (int_t)mb_strtol(sym, &conv_suc, 0);
if(*conv_suc == '\0') { if(*conv_suc == _ZERO_CHAR) {
memcpy(*value, tmp.any, sizeof(_raw_t)); memcpy(*value, tmp.any, sizeof(_raw_t));
result = _DT_INT; result = _DT_INT;
@ -4676,7 +4698,7 @@ static _data_e _get_symbol_type(mb_interpreter_t* s, char* sym, _raw_t* value) {
} }
/* real_t */ /* real_t */
tmp.float_point = (real_t)mb_strtod(sym, &conv_suc); tmp.float_point = (real_t)mb_strtod(sym, &conv_suc);
if(*conv_suc == '\0') { if(*conv_suc == _ZERO_CHAR) {
memcpy(*value, tmp.any, sizeof(_raw_t)); memcpy(*value, tmp.any, sizeof(_raw_t));
result = _DT_REAL; result = _DT_REAL;
@ -4684,7 +4706,7 @@ static _data_e _get_symbol_type(mb_interpreter_t* s, char* sym, _raw_t* value) {
goto _exit; goto _exit;
} }
/* String */ /* String */
if(sym[0] == '"' && sym[_sl - 1] == '"' && _sl >= 2) { if(_is_quotation_char(sym[0]) && _is_quotation_char(sym[_sl - 1]) && _sl >= 2) {
result = _DT_STRING; result = _DT_STRING;
if(context->last_symbol && _IS_FUNC(context->last_symbol, _core_import)) { if(context->last_symbol && _IS_FUNC(context->last_symbol, _core_import)) {
@ -4696,7 +4718,7 @@ static _data_e _get_symbol_type(mb_interpreter_t* s, char* sym, _raw_t* value) {
memset(context->current_symbol, 0, sizeof(current_symbol)); memset(context->current_symbol, 0, sizeof(current_symbol));
context->current_symbol_nonius = 0; context->current_symbol_nonius = 0;
context->last_symbol = 0; context->last_symbol = 0;
sym[_sl - 1] = '\0'; sym[_sl - 1] = _ZERO_CHAR;
context->parsing_state = _PS_NORMAL; context->parsing_state = _PS_NORMAL;
/* Using a module */ /* Using a module */
if(_is_using_char(*(sym + 1))) { if(_is_using_char(*(sym + 1))) {
@ -4738,7 +4760,7 @@ static _data_e _get_symbol_type(mb_interpreter_t* s, char* sym, _raw_t* value) {
_end_import: _end_import:
context->parsing_state = _PS_STRING; context->parsing_state = _PS_STRING;
sym[_sl - 1] = '\"'; sym[_sl - 1] = '"';
context->current_symbol_nonius = n; context->current_symbol_nonius = n;
memcpy(context->current_symbol, current_symbol, sizeof(current_symbol)); memcpy(context->current_symbol, current_symbol, sizeof(current_symbol));
result = _DT_NIL; result = _DT_NIL;
@ -4747,7 +4769,7 @@ _end_import:
goto _exit; goto _exit;
} }
/* Nil */ /* Nil */
if(!strcmp(sym, "NIL")) { if(!strcmp(sym, MB_NIL)) {
tmp.integer = ~0; tmp.integer = ~0;
memcpy(*value, tmp.any, sizeof(_raw_t)); memcpy(*value, tmp.any, sizeof(_raw_t));
@ -4767,7 +4789,7 @@ _end_import:
} }
if(context->last_symbol && _IS_FUNC(context->last_symbol, _core_dim)) { if(context->last_symbol && _IS_FUNC(context->last_symbol, _core_dim)) {
#ifdef MB_SIMPLE_ARRAY #ifdef MB_SIMPLE_ARRAY
en = (sym[_sl - 1] == '$' ? _DT_STRING : _DT_REAL); en = (sym[_sl - 1] == _STRING_POSTFIX ? _DT_STRING : _DT_REAL);
#else /* MB_SIMPLE_ARRAY */ #else /* MB_SIMPLE_ARRAY */
en = _DT_REAL; en = _DT_REAL;
#endif /* MB_SIMPLE_ARRAY */ #endif /* MB_SIMPLE_ARRAY */
@ -4823,7 +4845,7 @@ _end_import:
} }
#endif /* MB_ENABLE_CLASS */ #endif /* MB_ENABLE_CLASS */
/* _routine_t */ /* _routine_t */
if(context->last_symbol && !_is_bracket(sym[0])) { if(context->last_symbol && !_is_bracket_char(sym[0])) {
glbsyminscope = _search_identifier_in_scope_chain(s, 0, sym, 0, 0, 0); glbsyminscope = _search_identifier_in_scope_chain(s, 0, sym, 0, 0, 0);
if(glbsyminscope && ((_object_t*)glbsyminscope->data)->type == _DT_ROUTINE) { if(glbsyminscope && ((_object_t*)glbsyminscope->data)->type == _DT_ROUTINE) {
if(_IS_FUNC(context->last_symbol, _core_def)) if(_IS_FUNC(context->last_symbol, _core_def))
@ -4914,7 +4936,7 @@ _end_import:
goto _exit; goto _exit;
} }
/* Separator */ /* Separator */
if(_sl == 1 && _is_separator(sym[0])) { if(_sl == 1 && _is_separator_char(sym[0])) {
result = _DT_SEP; result = _DT_SEP;
goto _exit; goto _exit;
@ -4959,7 +4981,7 @@ static int _parse_char(mb_interpreter_t* s, char c, int pos, unsigned short row,
/* Parse a character */ /* Parse a character */
int result = MB_FUNC_OK; int result = MB_FUNC_OK;
_parsing_context_t* context = 0; _parsing_context_t* context = 0;
char last_char = '\0'; char last_char = _ZERO_CHAR;
mb_assert(s && s->parsing_context); mb_assert(s && s->parsing_context);
@ -4972,21 +4994,21 @@ static int _parse_char(mb_interpreter_t* s, char c, int pos, unsigned short row,
case _PS_NORMAL: case _PS_NORMAL:
c = toupper(c); c = toupper(c);
if(_is_blank(c)) { /* \t ' ' */ if(_is_blank_char(c)) { /* \t space */
_mb_check(result = _cut_symbol(s, pos, row, col), _exit); _mb_check(result = _cut_symbol(s, pos, row, col), _exit);
} else if(_is_newline(c)) { /* \r \n EOF */ } else if(_is_newline_char(c)) { /* \r \n EOF */
_mb_check(result = _cut_symbol(s, pos, row, col), _exit); _mb_check(result = _cut_symbol(s, pos, row, col), _exit);
_mb_check(result = _append_char_to_symbol(s, MB_EOS), _exit); _mb_check(result = _append_char_to_symbol(s, MB_EOS), _exit);
_mb_check(result = _cut_symbol(s, pos, row, col), _exit); _mb_check(result = _cut_symbol(s, pos, row, col), _exit);
} else if(_is_separator(c) || _is_bracket(c)) { /* , ; : ( ) */ } else if(_is_separator_char(c) || _is_bracket_char(c)) { /* , ; : ( ) */
_mb_check(result = _cut_symbol(s, pos, row, col), _exit); _mb_check(result = _cut_symbol(s, pos, row, col), _exit);
_mb_check(result = _append_char_to_symbol(s, c), _exit); _mb_check(result = _append_char_to_symbol(s, c), _exit);
_mb_check(result = _cut_symbol(s, pos, row, col), _exit); _mb_check(result = _cut_symbol(s, pos, row, col), _exit);
} else if(_is_quotation_mark(c)) { /* " */ } else if(_is_quotation_char(c)) { /* " */
_mb_check(result = _cut_symbol(s, pos, row, col), _exit); _mb_check(result = _cut_symbol(s, pos, row, col), _exit);
_mb_check(result = _append_char_to_symbol(s, c), _exit); _mb_check(result = _append_char_to_symbol(s, c), _exit);
context->parsing_state = _PS_STRING; context->parsing_state = _PS_STRING;
} else if(_is_comment(c)) { /* ' */ } else if(_is_comment_char(c)) { /* ' */
_mb_check(result = _cut_symbol(s, pos, row, col), _exit); _mb_check(result = _cut_symbol(s, pos, row, col), _exit);
_mb_check(result = _append_char_to_symbol(s, MB_EOS), _exit); _mb_check(result = _append_char_to_symbol(s, MB_EOS), _exit);
_mb_check(result = _cut_symbol(s, pos, row, col), _exit); _mb_check(result = _cut_symbol(s, pos, row, col), _exit);
@ -4997,7 +5019,7 @@ static int _parse_char(mb_interpreter_t* s, char c, int pos, unsigned short row,
if(_is_identifier_char(c)) { if(_is_identifier_char(c)) {
_mb_check(result = _append_char_to_symbol(s, c), _exit); _mb_check(result = _append_char_to_symbol(s, c), _exit);
} else if(_is_operator_char(c)) { } else if(_is_operator_char(c)) {
if(_is_exponent_prefix(context->current_symbol, 0, context->current_symbol_nonius - 2) && (last_char == 'e' || last_char == 'E') && c == '-') { if(_is_exponent_prefix(context->current_symbol, 0, context->current_symbol_nonius - 2) && _is_exponential_char(last_char) && c == '-') {
_mb_check(result = _append_char_to_symbol(s, c), _exit); _mb_check(result = _append_char_to_symbol(s, c), _exit);
} else { } else {
context->symbol_state = _SS_OPERATOR; context->symbol_state = _SS_OPERATOR;
@ -5026,7 +5048,7 @@ static int _parse_char(mb_interpreter_t* s, char c, int pos, unsigned short row,
break; break;
case _PS_STRING: case _PS_STRING:
if(_is_quotation_mark(c)) { /* " */ if(_is_quotation_char(c)) { /* " */
_mb_check(result = _append_char_to_symbol(s, c), _exit); _mb_check(result = _append_char_to_symbol(s, c), _exit);
_mb_check(result = _cut_symbol(s, pos, row, col), _exit); _mb_check(result = _cut_symbol(s, pos, row, col), _exit);
context->parsing_state = _PS_NORMAL; context->parsing_state = _PS_NORMAL;
@ -5036,7 +5058,7 @@ static int _parse_char(mb_interpreter_t* s, char c, int pos, unsigned short row,
break; break;
case _PS_COMMENT: case _PS_COMMENT:
if(_is_eof(c)) { /* EOF */ if(_is_eof_char(c)) { /* EOF */
context->parsing_state = _PS_NORMAL; context->parsing_state = _PS_NORMAL;
break; break;
@ -5053,17 +5075,17 @@ static int _parse_char(mb_interpreter_t* s, char c, int pos, unsigned short row,
} else { } else {
context->multi_line_comment_count = 0; context->multi_line_comment_count = 0;
} }
if(_is_newline(c)) /* \r \n EOF */ if(_is_newline_char(c)) /* \r \n EOF */
context->parsing_state = _PS_NORMAL; context->parsing_state = _PS_NORMAL;
break; break;
case _PS_MULTI_LINE_COMMENT: case _PS_MULTI_LINE_COMMENT:
if(_is_eof(c)) { /* EOF */ if(_is_eof_char(c)) { /* EOF */
context->parsing_state = _PS_NORMAL; context->parsing_state = _PS_NORMAL;
break; break;
} }
if(_is_comment(c) && context->multi_line_comment_count == 0) { if(_is_comment_char(c) && context->multi_line_comment_count == 0) {
context->multi_line_comment_count = 1; context->multi_line_comment_count = 1;
} else if(context->multi_line_comment_count != 0 && c == _MULTI_LINE_COMMENT_POSTFIX[context->multi_line_comment_count++]) { } else if(context->multi_line_comment_count != 0 && c == _MULTI_LINE_COMMENT_POSTFIX[context->multi_line_comment_count++]) {
if(context->multi_line_comment_count >= _countof(_MULTI_LINE_COMMENT_POSTFIX) - 1) { if(context->multi_line_comment_count >= _countof(_MULTI_LINE_COMMENT_POSTFIX) - 1) {
@ -5273,6 +5295,7 @@ static char* _extract_string(_object_t* obj) {
return result; return result;
} }
#ifdef _HAS_REF_OBJ_LOCK
static bool_t _lock_ref_object(_lock_t* lk, _ref_t* ref, void* obj) { static bool_t _lock_ref_object(_lock_t* lk, _ref_t* ref, void* obj) {
/* Lock a referenced object */ /* Lock a referenced object */
mb_assert(lk); mb_assert(lk);
@ -5318,6 +5341,7 @@ static bool_t _write_on_ref_object(_lock_t* lk, _ref_t* ref, void* obj) {
return result; return result;
} }
#endif /* _HAS_REF_OBJ_LOCK */
static _ref_count_t _ref(_ref_t* ref, void* data) { static _ref_count_t _ref(_ref_t* ref, void* data) {
/* Increase the reference of a stub by 1 */ /* Increase the reference of a stub by 1 */
@ -6325,7 +6349,7 @@ static _dict_it_t* _create_dict_it(_dict_t* coll, bool_t lock) {
result->dict = coll; result->dict = coll;
result->locking = lock; result->locking = lock;
result->curr_bucket = 0; result->curr_bucket = 0;
result->curr_node = (_ls_node_t*)(intptr_t)~0; result->curr_node = _INVALID_DICT_IT;
if(lock) if(lock)
_lock_ref_object(&coll->lock, &coll->ref, coll); _lock_ref_object(&coll->lock, &coll->ref, coll);
_weak_ref(&coll->ref, coll, &result->weak_ref); _weak_ref(&coll->ref, coll, &result->weak_ref);
@ -6356,12 +6380,12 @@ static _dict_it_t* _move_dict_it_next(_dict_it_t* it) {
if(!it->dict->lock) if(!it->dict->lock)
goto _exit; goto _exit;
if(it->curr_node && it->curr_node != (_ls_node_t*)(intptr_t)~0) { if(it->curr_node && it->curr_node != _INVALID_DICT_IT) {
it->curr_node = it->curr_node->next; it->curr_node = it->curr_node->next;
if(!it->curr_node) if(!it->curr_node)
++it->curr_bucket; ++it->curr_bucket;
} }
if(!it->curr_node || it->curr_node == (_ls_node_t*)(intptr_t)~0) { if(!it->curr_node || it->curr_node == _INVALID_DICT_IT) {
for( ; it->curr_bucket < it->dict->dict->array_size; ++it->curr_bucket) { for( ; it->curr_bucket < it->dict->dict->array_size; ++it->curr_bucket) {
it->curr_node = it->dict->dict->array[it->curr_bucket]; it->curr_node = it->dict->dict->array[it->curr_bucket];
if(it->curr_node && it->curr_node->next) { if(it->curr_node && it->curr_node->next) {
@ -7222,7 +7246,7 @@ static bool_t _is_valid_class_accessor_following_routine(mb_interpreter_t* s, _v
if(out) *out = 0; if(out) *out = 0;
if(_is_accessor(*var->name) && (ast && ast->prev && _IS_FUNC(ast->prev->data, _core_close_bracket)) && running->intermediate_value.type == MB_DT_CLASS) { if(_is_accessor_char(*var->name) && (ast && ast->prev && _IS_FUNC(ast->prev->data, _core_close_bracket)) && running->intermediate_value.type == MB_DT_CLASS) {
_class_t* instance = (_class_t*)running->intermediate_value.value.instance; _class_t* instance = (_class_t*)running->intermediate_value.value.instance;
_ls_node_t* fn = _search_identifier_in_class(s, instance, var->name + 1, 0, 0); _ls_node_t* fn = _search_identifier_in_class(s, instance, var->name + 1, 0, 0);
result = true; result = true;
@ -7778,8 +7802,8 @@ static _ls_node_t* _search_identifier_accessor(mb_interpreter_t* s, _running_con
while((i == 0) || (i > 0 && n[i - 1])) { while((i == 0) || (i > 0 && n[i - 1])) {
acc[j] = n[i]; acc[j] = n[i];
if(_is_accessor(acc[j]) || acc[j] == '\0') { if(_is_accessor_char(acc[j]) || acc[j] == _ZERO_CHAR) {
acc[j] = '\0'; acc[j] = _ZERO_CHAR;
if(instance) if(instance)
result = _search_identifier_in_class(s, instance, acc, ht, sp); result = _search_identifier_in_class(s, instance, acc, ht, sp);
else else
@ -9937,9 +9961,9 @@ static int _open_constant(mb_interpreter_t* s) {
running = s->running_context; running = s->running_context;
ul = _ht_set_or_insert(running->var_dict, "TRUE", _OBJ_BOOL_TRUE); ul = _ht_set_or_insert(running->var_dict, MB_TRUE, _OBJ_BOOL_TRUE);
mb_assert(ul); mb_assert(ul);
ul = _ht_set_or_insert(running->var_dict, "FALSE", _OBJ_BOOL_FALSE); ul = _ht_set_or_insert(running->var_dict, MB_FALSE, _OBJ_BOOL_FALSE);
mb_assert(ul); mb_assert(ul);
return result; return result;
@ -10060,19 +10084,19 @@ int mb_init(void) {
_exp_assign->type = _DT_FUNC; _exp_assign->type = _DT_FUNC;
_exp_assign->data.func = (_func_t*)mb_malloc(sizeof(_func_t)); _exp_assign->data.func = (_func_t*)mb_malloc(sizeof(_func_t));
memset(_exp_assign->data.func, 0, sizeof(_func_t)); memset(_exp_assign->data.func, 0, sizeof(_func_t));
_exp_assign->data.func->name = (char*)mb_malloc(strlen("#") + 1); _exp_assign->data.func->name = (char*)mb_malloc(strlen(_DUMMY_ASSIGN) + 1);
memcpy(_exp_assign->data.func->name, "#", strlen("#") + 1); memcpy(_exp_assign->data.func->name, _DUMMY_ASSIGN, strlen(_DUMMY_ASSIGN) + 1);
_exp_assign->data.func->pointer = _core_dummy_assign; _exp_assign->data.func->pointer = _core_dummy_assign;
mb_assert(!_OBJ_BOOL_TRUE); mb_assert(!_OBJ_BOOL_TRUE);
if(!_OBJ_BOOL_TRUE) { if(!_OBJ_BOOL_TRUE) {
_var_t* bvar = _create_var(&_OBJ_BOOL_TRUE, "TRUE", strlen("TRUE") + 1, true); _var_t* bvar = _create_var(&_OBJ_BOOL_TRUE, MB_TRUE, strlen(MB_TRUE) + 1, true);
bvar->data->type = _DT_INT; bvar->data->type = _DT_INT;
bvar->data->data.integer = 1; bvar->data->data.integer = 1;
} }
mb_assert(!_OBJ_BOOL_FALSE); mb_assert(!_OBJ_BOOL_FALSE);
if(!_OBJ_BOOL_FALSE) { if(!_OBJ_BOOL_FALSE) {
_var_t* bvar = _create_var(&_OBJ_BOOL_FALSE, "FALSE", strlen("FALSE") + 1, true); _var_t* bvar = _create_var(&_OBJ_BOOL_FALSE, MB_FALSE, strlen(MB_FALSE) + 1, true);
bvar->data->type = _DT_INT; bvar->data->type = _DT_INT;
bvar->data->data.integer = 0; bvar->data->data.integer = 0;
} }
@ -11585,7 +11609,7 @@ int mb_load_string(struct mb_interpreter_t* s, const char* l, bool_t reset) {
int i = 0; int i = 0;
unsigned short _row = 0; unsigned short _row = 0;
unsigned short _col = 0; unsigned short _col = 0;
char wrapped = '\0'; char wrapped = _ZERO_CHAR;
_parsing_context_t* context = 0; _parsing_context_t* context = 0;
mb_assert(s && s->parsing_context); mb_assert(s && s->parsing_context);
@ -11594,12 +11618,12 @@ int mb_load_string(struct mb_interpreter_t* s, const char* l, bool_t reset) {
while(l[i]) { while(l[i]) {
ch = l[i]; ch = l[i];
if((ch == '\n' || ch == '\r') && (!wrapped || wrapped == ch)) { if((ch == _NEWLINE_CHAR || ch == _RETURN_CHAR) && (!wrapped || wrapped == ch)) {
wrapped = ch; wrapped = ch;
++context->parsing_row; ++context->parsing_row;
context->parsing_col = 0; context->parsing_col = 0;
} else { } else {
wrapped = '\0'; wrapped = _ZERO_CHAR;
++context->parsing_col; ++context->parsing_col;
} }
status = _parse_char(s, ch, context->parsing_pos, _row, _col); status = _parse_char(s, ch, context->parsing_pos, _row, _col);
@ -12007,8 +12031,8 @@ int mb_gets(char* buf, int s) {
exit(1); exit(1);
} }
result = (int)strlen(buf); result = (int)strlen(buf);
if(buf[result - 1] == '\n') if(buf[result - 1] == _NEWLINE_CHAR)
buf[result - 1] = '\0'; buf[result - 1] = _ZERO_CHAR;
return result; return result;
} }
@ -14546,7 +14570,7 @@ static int _std_asc(mb_interpreter_t* s, void** l) {
mb_check(mb_attempt_close_bracket(s, l)); mb_check(mb_attempt_close_bracket(s, l));
if(arg[0] == '\0') { if(arg[0] == _ZERO_CHAR) {
result = MB_FUNC_ERR; result = MB_FUNC_ERR;
goto _exit; goto _exit;
@ -14616,7 +14640,7 @@ static int _std_left(mb_interpreter_t* s, void** l) {
#else /* MB_ENABLE_UNICODE */ #else /* MB_ENABLE_UNICODE */
sub = (char*)mb_malloc(count + 1); sub = (char*)mb_malloc(count + 1);
memcpy(sub, arg, count); memcpy(sub, arg, count);
sub[count] = '\0'; sub[count] = _ZERO_CHAR;
#endif /* MB_ENABLE_UNICODE */ #endif /* MB_ENABLE_UNICODE */
mb_check(mb_push_string(s, l, sub)); mb_check(mb_push_string(s, l, sub));
@ -14662,7 +14686,7 @@ static int _std_mid(mb_interpreter_t* s, void** l) {
#else /* MB_ENABLE_UNICODE */ #else /* MB_ENABLE_UNICODE */
sub = (char*)mb_malloc(count + 1); sub = (char*)mb_malloc(count + 1);
memcpy(sub, arg + start, count); memcpy(sub, arg + start, count);
sub[count] = '\0'; sub[count] = _ZERO_CHAR;
#endif /* MB_ENABLE_UNICODE */ #endif /* MB_ENABLE_UNICODE */
mb_check(mb_push_string(s, l, sub)); mb_check(mb_push_string(s, l, sub));
@ -14706,7 +14730,7 @@ static int _std_right(mb_interpreter_t* s, void** l) {
#else /* MB_ENABLE_UNICODE */ #else /* MB_ENABLE_UNICODE */
sub = (char*)mb_malloc(count + 1); sub = (char*)mb_malloc(count + 1);
memcpy(sub, arg + (strlen(arg) - count), count); memcpy(sub, arg + (strlen(arg) - count), count);
sub[count] = '\0'; sub[count] = _ZERO_CHAR;
#endif /* MB_ENABLE_UNICODE */ #endif /* MB_ENABLE_UNICODE */
mb_check(mb_push_string(s, l, sub)); mb_check(mb_push_string(s, l, sub));
@ -14771,14 +14795,14 @@ static int _std_val(mb_interpreter_t* s, void** l) {
switch(arg.type) { switch(arg.type) {
case MB_DT_STRING: case MB_DT_STRING:
ret.value.integer = (int_t)mb_strtol(arg.value.string, &conv_suc, 0); ret.value.integer = (int_t)mb_strtol(arg.value.string, &conv_suc, 0);
if(*conv_suc == '\0') { if(*conv_suc == _ZERO_CHAR) {
ret.type = MB_DT_INT; ret.type = MB_DT_INT;
mb_check(mb_push_value(s, l, ret)); mb_check(mb_push_value(s, l, ret));
goto _exit; goto _exit;
} }
ret.value.float_point = (real_t)mb_strtod(arg.value.string, &conv_suc); ret.value.float_point = (real_t)mb_strtod(arg.value.string, &conv_suc);
if(*conv_suc == '\0') { if(*conv_suc == _ZERO_CHAR) {
ret.type = MB_DT_REAL; ret.type = MB_DT_REAL;
mb_check(mb_push_value(s, l, ret)); mb_check(mb_push_value(s, l, ret));
@ -15159,10 +15183,10 @@ static int _std_input(mb_interpreter_t* s, void** l) {
_get_inputer(s)(line, sizeof(line)); _get_inputer(s)(line, sizeof(line));
obj->data.variable->data->type = _DT_INT; obj->data.variable->data->type = _DT_INT;
obj->data.variable->data->data.integer = (int_t)mb_strtol(line, &conv_suc, 0); obj->data.variable->data->data.integer = (int_t)mb_strtol(line, &conv_suc, 0);
if(*conv_suc != '\0') { if(*conv_suc != _ZERO_CHAR) {
obj->data.variable->data->type = _DT_REAL; obj->data.variable->data->type = _DT_REAL;
obj->data.variable->data->data.float_point = (real_t)mb_strtod(line, &conv_suc); obj->data.variable->data->data.float_point = (real_t)mb_strtod(line, &conv_suc);
if(*conv_suc != '\0') { if(*conv_suc != _ZERO_CHAR) {
result = MB_FUNC_ERR; result = MB_FUNC_ERR;
goto _exit; goto _exit;

10
core/my_basic.h
View File

@ -203,10 +203,16 @@ extern "C" {
# define MB_EOS '\n' # define MB_EOS '\n'
#endif /* MB_EOS */ #endif /* MB_EOS */
#ifndef MB_NIL #ifndef MB_NIL
# define MB_NIL "nil" # define MB_NIL "NIL"
#endif /* MB_NIL */ #endif /* MB_NIL */
#ifndef MB_TRUE
# define MB_TRUE "TRUE"
#endif /* MB_TRUE */
#ifndef MB_FALSE
# define MB_FALSE "FALSE"
#endif /* MB_FALSE */
#ifndef MB_NULL_STRING #ifndef MB_NULL_STRING
# define MB_NULL_STRING "(empty)" # define MB_NULL_STRING "(EMPTY)"
#endif /* MB_NULL_STRING */ #endif /* MB_NULL_STRING */
#ifndef mb_stricmp #ifndef mb_stricmp

14
shell/main.c
View File

@ -133,15 +133,14 @@ extern MBAPI const size_t MB_SIZEOF_LSN;
extern MBAPI const size_t MB_SIZEOF_HTN; extern MBAPI const size_t MB_SIZEOF_HTN;
extern MBAPI const size_t MB_SIZEOF_HTA; extern MBAPI const size_t MB_SIZEOF_HTA;
extern MBAPI const size_t MB_SIZEOF_OBJ; extern MBAPI const size_t MB_SIZEOF_OBJ;
extern MBAPI const size_t MB_SIZEOF_FUN;
extern MBAPI const size_t MB_SIZEOF_VAR;
#ifdef MB_ENABLE_USERTYPE_REF #ifdef MB_ENABLE_USERTYPE_REF
extern MBAPI const size_t MB_SIZEOF_UTR; extern MBAPI const size_t MB_SIZEOF_UTR;
#else /* MB_ENABLE_USERTYPE_REF */ #else /* MB_ENABLE_USERTYPE_REF */
static const size_t MB_SIZEOF_UTR = 16; static const size_t MB_SIZEOF_UTR = 16;
#endif /* MB_ENABLE_USERTYPE_REF */ #endif /* MB_ENABLE_USERTYPE_REF */
extern MBAPI const size_t MB_SIZEOF_FUN;
extern MBAPI const size_t MB_SIZEOF_VAR;
extern MBAPI const size_t MB_SIZEOF_ARR; extern MBAPI const size_t MB_SIZEOF_ARR;
extern MBAPI const size_t MB_SIZEOF_LBL;
#ifdef MB_ENABLE_COLLECTION_LIB #ifdef MB_ENABLE_COLLECTION_LIB
extern MBAPI const size_t MB_SIZEOF_LST; extern MBAPI const size_t MB_SIZEOF_LST;
extern MBAPI const size_t MB_SIZEOF_DCT; extern MBAPI const size_t MB_SIZEOF_DCT;
@ -149,12 +148,13 @@ extern MBAPI const size_t MB_SIZEOF_DCT;
static const size_t MB_SIZEOF_LST = 16; static const size_t MB_SIZEOF_LST = 16;
static const size_t MB_SIZEOF_DCT = 16; static const size_t MB_SIZEOF_DCT = 16;
#endif /* MB_ENABLE_COLLECTION_LIB */ #endif /* MB_ENABLE_COLLECTION_LIB */
extern MBAPI const size_t MB_SIZEOF_RTN; extern MBAPI const size_t MB_SIZEOF_LBL;
#ifdef MB_ENABLE_CLASS #ifdef MB_ENABLE_CLASS
extern MBAPI const size_t MB_SIZEOF_CLS; extern MBAPI const size_t MB_SIZEOF_CLS;
#else /* MB_ENABLE_CLASS */ #else /* MB_ENABLE_CLASS */
static const size_t MB_SIZEOF_CLS = 16; static const size_t MB_SIZEOF_CLS = 16;
#endif /* MB_ENABLE_CLASS */ #endif /* MB_ENABLE_CLASS */
extern MBAPI const size_t MB_SIZEOF_RTN;
typedef unsigned _pool_chunk_size_t; typedef unsigned _pool_chunk_size_t;
@ -244,15 +244,15 @@ static void _open_mem_pool(void) {
szs[i++] = MB_SIZEOF_HTN; szs[i++] = MB_SIZEOF_HTN;
szs[i++] = MB_SIZEOF_HTA; szs[i++] = MB_SIZEOF_HTA;
szs[i++] = MB_SIZEOF_OBJ; szs[i++] = MB_SIZEOF_OBJ;
szs[i++] = MB_SIZEOF_UTR;
szs[i++] = MB_SIZEOF_FUN; szs[i++] = MB_SIZEOF_FUN;
szs[i++] = MB_SIZEOF_VAR; szs[i++] = MB_SIZEOF_VAR;
szs[i++] = MB_SIZEOF_UTR;
szs[i++] = MB_SIZEOF_ARR; szs[i++] = MB_SIZEOF_ARR;
szs[i++] = MB_SIZEOF_LBL;
szs[i++] = MB_SIZEOF_LST; szs[i++] = MB_SIZEOF_LST;
szs[i++] = MB_SIZEOF_DCT; szs[i++] = MB_SIZEOF_DCT;
szs[i++] = MB_SIZEOF_RTN; szs[i++] = MB_SIZEOF_LBL;
szs[i++] = MB_SIZEOF_CLS; szs[i++] = MB_SIZEOF_CLS;
szs[i++] = MB_SIZEOF_RTN;
mb_assert(i == N); mb_assert(i == N);