From fffb567dd882b06afb8dff09ad91699087819627 Mon Sep 17 00:00:00 2001 From: tony Date: Mon, 5 Oct 2015 17:22:00 +0800 Subject: [PATCH] +added LIST, DICT; +added TYPE; +added mb_get_type_string. --- HISTORY | 6 + README.md | 3 +- core/my_basic.c | 1731 ++++++++++++++++++++++++++++++++++++++++++- core/my_basic.h | 37 +- output/my_basic.exe | Bin 79872 -> 96256 bytes output/my_basic_mac | Bin 103576 -> 125496 bytes shell/main.c | 12 + 7 files changed, 1758 insertions(+), 31 deletions(-) diff --git a/HISTORY b/HISTORY index a914284..b15eea7 100755 --- a/HISTORY +++ b/HISTORY @@ -1,3 +1,9 @@ +Oct. 5 2015 +Added a LIST collection +Added a DICT collection +Added TYPE statement +Added an mb_get_type_string function + Sep. 30 2015 Improved UTF8 string manipulation diff --git a/README.md b/README.md index 96201f1..c80b4a7 100755 --- a/README.md +++ b/README.md @@ -20,7 +20,7 @@ Why are existing script interpreters so complex? Why is it so difficult to integ ## Introduction -MY-BASIC is a lightweight cross-platform easy extendable BASIC interpreter written in pure C with about 7000 lines of source code. Its grammar is similar to structured BASIC. It is aimed to be either an embeddable scripting language or a standalone interpreter. The core is pretty light; all in a C source file and an associated header file. You are able to easily combine MY-BASIC with an existing project in C, C++, Objective-C, etc. Scripting driven can make your projects more powerful, elegant and neat. +MY-BASIC is a lightweight cross-platform easy extendable BASIC interpreter written in pure C with about 10,000 lines of source code. Its grammar is similar to structured BASIC. It is aimed to be either an embeddable scripting language or a standalone interpreter. The core is pretty light; all in a C source file and an associated header file. You are able to easily combine MY-BASIC with an existing project in C, C++, Objective-C, etc. Scripting driven can make your projects more powerful, elegant and neat. ## Main features @@ -36,6 +36,7 @@ MY-BASIC is a lightweight cross-platform easy extendable BASIC interpreter writt * Structured user costomized sub routine definition by `DEF/ENDDEF` support, including tail recursion optimization * `GOTO/GOSUB-RETURN` support * Standard numeric functions, and standard string functions +* Collection manipulation functions for `LIST` and `DICT` * Debug APIs * Customizable memory pool * High expansibility, easy to use APIs, easy to write customized scripting interfaces diff --git a/core/my_basic.c b/core/my_basic.c index 6e43a64..6e47aa4 100755 --- a/core/my_basic.c +++ b/core/my_basic.c @@ -79,12 +79,16 @@ extern "C" { /** Macros */ #define _VER_MAJOR 1 #define _VER_MINOR 1 -#define _VER_REVISION 77 +#define _VER_REVISION 78 #define _VER_SUFFIX #define _MB_VERSION ((_VER_MAJOR * 0x01000000) + (_VER_MINOR * 0x00010000) + (_VER_REVISION)) #define _STRINGIZE(A) _MAKE_STRINGIZE(A) #define _MAKE_STRINGIZE(A) #A -#define _MB_VERSION_STRING _STRINGIZE(_VER_MAJOR._VER_MINOR._VER_REVISION _VER_SUFFIX) +#if _VER_REVISION == 0 +# define _MB_VERSION_STRING _STRINGIZE(_VER_MAJOR._VER_MINOR _VER_SUFFIX) +#else /* _VER_REVISION == 0 */ +# define _MB_VERSION_STRING _STRINGIZE(_VER_MAJOR._VER_MINOR._VER_REVISION _VER_SUFFIX) +#endif /* _VER_REVISION == 0 */ /* Uncomment the line below to treat warning as error */ /*#define _WARING_AS_ERROR*/ @@ -181,6 +185,7 @@ static const char* _ERR_DESC[] = { "Type does not match", "Invalid string", "Index out of bound", + "Cannot find with given index", "Illegal bound", "Too much dimensions", "Operation failed", @@ -220,6 +225,11 @@ static const char* _ERR_DESC[] = { "Don't mix instructional and structured sub routines", "Routine expected", "Duplicate routine", + "Collection expected", + "Iterator expected", + "Collection or iterator expected", + "Invalid iterator", + "Empty collection", /** Extended abort */ "Extended abort" }; @@ -230,6 +240,7 @@ mb_static_assert(_countof(_ERR_DESC) == SE_COUNT); typedef enum _data_e { _DT_NIL = -1, _DT_ANY = 0, + _DT_TYPE, _DT_INT, _DT_REAL, _DT_STRING, @@ -237,6 +248,12 @@ typedef enum _data_e { _DT_FUNC, _DT_VAR, _DT_ARRAY, +#ifdef MB_ENABLE_COLLECTION_LIB + _DT_LIST, + _DT_LIST_IT, + _DT_DICT, + _DT_DICT_IT, +#endif /* MB_ENABLE_COLLECTION_LIB */ _DT_LABEL, /* Label type, used for GOTO, GOSUB statement */ _DT_ROUTINE, /* User defined sub routine in script */ _DT_CLASS, /* Object instance */ @@ -266,6 +283,44 @@ typedef struct _array_t { int dimensions[MB_MAX_DIMENSION_COUNT]; } _array_t; +struct _ref_t; + +typedef void (* _unref_func_t)(struct _ref_t*, void*); + +typedef unsigned int _ref_count_t; + +typedef struct _ref_t { + _ref_count_t* count; + _unref_func_t on_unref; +} _ref_t; + +typedef unsigned short _lock_t; + +#ifdef MB_ENABLE_COLLECTION_LIB +typedef struct _list_t { + _ref_t ref; + _ls_node_t* list; + _lock_t lock; +} _list_t; + +typedef struct _list_it_t { + _list_t* list; + _ls_node_t* curr; +} _list_it_t; + +typedef struct _dict_t { + _ref_t ref; + _ht_node_t* dict; + _lock_t lock; +} _dict_t; + +typedef struct _dict_it_t { + _dict_t* dict; + unsigned int curr_bucket; + _ls_node_t* curr_node; +} _dict_it_t; +#endif /* MB_ENABLE_COLLECTION_LIB */ + typedef struct _label_t { char* name; _ls_node_t* node; @@ -284,13 +339,14 @@ typedef struct _routine_t { _ls_node_t* parameters; } _routine_t; -typedef union _raw_u { int_t i; real_t r; void* p; } _raw_u; +typedef union _raw_u { char c; int_t i; real_t r; void* p; } _raw_u; typedef unsigned char _raw_t[sizeof(_raw_u)]; typedef struct _object_t { _data_e type; union { + mb_data_e type; int_t integer; real_t float_point; char* string; @@ -298,6 +354,12 @@ typedef struct _object_t { _func_t* func; _var_t* variable; _array_t* array; +#ifdef MB_ENABLE_COLLECTION_LIB + _list_t* list; + _list_it_t* list_it; + _dict_t* dict; + _dict_it_t* dict_it; +#endif /* MB_ENABLE_COLLECTION_LIB */ _label_t* label; _routine_t* routine; _class_t* instance; @@ -672,15 +734,22 @@ static _object_t* _exp_assign = 0; /** List operations */ static int _ls_cmp_data(void* node, void* info); static int _ls_cmp_extra(void* node, void* info); +static int _ls_cmp_extra_object(void* node, void* info); static int _ls_cmp_extra_string(void* node, void* info); static _ls_node_t* _ls_create_node(void* data); static _ls_node_t* _ls_create(void); +static _ls_node_t* _ls_find(_ls_node_t* list, void* data, _ls_compare cmp); static _ls_node_t* _ls_back(_ls_node_t* node); static _ls_node_t* _ls_pushback(_ls_node_t* list, void* data); static void* _ls_popback(_ls_node_t* list); +static _ls_node_t* _ls_at(_ls_node_t* list, int index); +static _ls_node_t* _ls_insert_at(_ls_node_t* list, int index, void* data); +static unsigned int _ls_remove(_ls_node_t* list, _ls_node_t* node, _ls_operation op); static unsigned int _ls_try_remove(_ls_node_t* list, void* info, _ls_compare cmp, _ls_operation op); static unsigned int _ls_foreach(_ls_node_t* list, _ls_operation op); +static void _ls_sort(_ls_node_t* list, _ls_compare cmp); +static unsigned int _ls_count(_ls_node_t* list); static bool_t _ls_empty(_ls_node_t* list); static void _ls_clear(_ls_node_t* list); static void _ls_destroy(_ls_node_t* list); @@ -713,9 +782,11 @@ static int _ls_free_extra(void* data, void* extra); } while(0) /** Dictionary operations */ +static unsigned int _ht_hash_object(void* ht, void* d); static unsigned int _ht_hash_string(void* ht, void* d); static unsigned int _ht_hash_int(void* ht, void* d); +static int _ht_cmp_object(void* d1, void* d2); static int _ht_cmp_string(void* d1, void* d2); static int _ht_cmp_int(void* d1, void* d2); @@ -724,6 +795,7 @@ static _ls_node_t* _ht_find(_ht_node_t* ht, void* key); static unsigned int _ht_set_or_insert(_ht_node_t* ht, void* key, void* value); static unsigned int _ht_remove(_ht_node_t* ht, void* key, _ls_compare cmp); static unsigned int _ht_foreach(_ht_node_t* ht, _ht_operation op); +static unsigned int _ht_count(_ht_node_t* ht); static void _ht_clear(_ht_node_t* ht); static void _ht_destroy(_ht_node_t* ht); @@ -768,7 +840,7 @@ static int _calc_expression(mb_interpreter_t* s, _ls_node_t** l, _object_t** val static int _eval_routine(mb_interpreter_t* s, _ls_node_t** l, _routine_t* r); static bool_t _is_print_terminal(mb_interpreter_t* s, _object_t* obj); -/** Others */ +/** Handlers */ #ifdef _WARING_AS_ERROR # define _handle_error(__s, __err, __func, __pos, __row, __col, __ret, __exit, __result) \ do { \ @@ -809,6 +881,7 @@ static void _set_current_error(mb_interpreter_t* s, mb_error_e err, char* func); static mb_print_func_t _get_printer(mb_interpreter_t* s); static mb_input_func_t _get_inputer(mb_interpreter_t* s); +/** Parsing helpers */ static char* _load_file(const char* f, const char* prefix); static bool_t _is_blank(char c); @@ -829,6 +902,7 @@ static _data_e _get_symbol_type(mb_interpreter_t* s, char* sym, _raw_t* value); static int _parse_char(mb_interpreter_t* s, char c, int pos, unsigned short row, unsigned short col); static void _set_error_pos(mb_interpreter_t* s, int pos, unsigned short row, unsigned short col); +/** Object processors */ static int_t _get_size_of(_data_e type); static bool_t _try_get_value(_object_t* obj, mb_value_u* val, _data_e expected); @@ -844,6 +918,42 @@ static bool_t _is_array(void* obj); static bool_t _is_string(void* obj); static char* _extract_string(_object_t* obj); +#ifdef MB_ENABLE_COLLECTION_LIB +static _list_t* _create_list(void); +static void _destroy_list(_list_t* c); +static _dict_t* _create_dict(void); +static void _destroy_dict(_dict_t* c); +static _list_it_t* _create_list_it(_list_t* coll); +static bool_t _destroy_list_it(_list_it_t* it); +static _list_it_t* _move_list_it_next(_list_it_t* it); +static _dict_it_t* _create_dict_it(_dict_t* coll); +static bool_t _destroy_dict_it(_dict_it_t* it); +static _dict_it_t* _move_dict_it_next(_dict_it_t* it); +static void _unref_list(_ref_t* ref, void* data); +static void _unref_dict(_ref_t* ref, void* data); +static void _push_list(_list_t* coll, mb_value_t* val); +static bool_t _pop_list(_list_t* coll, mb_value_t* val, mb_interpreter_t* s); +static bool_t _insert_list(_list_t* coll, int_t idx, mb_value_t* val, _object_t** oval); +static bool_t _set_list(_list_t* coll, int_t idx, mb_value_t* val, _object_t** oval); +static bool_t _remove_at_list(_list_t* coll, int_t idx); +static bool_t _at_list(_list_t* coll, int_t idx, mb_value_t* oval); +static bool_t _find_list(_list_t* coll, mb_value_t* val); +static void _clear_list(_list_t* coll); +static void _sort_list(_list_t* coll); +static void _set_dict(_dict_t* coll, mb_value_t* key, mb_value_t *val); +static bool_t _remove_dict(_dict_t* coll, mb_value_t* key); +static bool_t _find_dict(_dict_t* coll, mb_value_t* val, mb_value_t* oval); +static void _clear_dict(_dict_t* coll); +#endif /* MB_ENABLE_COLLECTION_LIB */ +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 _write_on_ref_object(_lock_t* lk, _ref_t* ref, void* obj); + +static unsigned _ref(_ref_t* ref, void* data); +static unsigned _unref(_ref_t* ref, void* data); +static void _create_ref(_ref_t* ref, _unref_func_t dtor); +static void _destroy_ref(_ref_t* ref); + static void _init_class(mb_interpreter_t* s, _class_t* instance, char* n); static void _begin_class(mb_interpreter_t* s); static void _end_class(mb_interpreter_t* s); @@ -867,6 +977,7 @@ static _var_t* _search_var_in_scope_chain(mb_interpreter_t* s, _var_t* i); static int _dispose_object(_object_t* obj); static int _destroy_object(void* data, void* extra); +static int _destroy_object_with_extra(void* data, void* extra); static int _destroy_object_not_compile_time(void* data, void* extra); static int _destroy_object_capsule_only(void* data, void* extra); static int _destroy_object_nothing(void* data, void* extra); @@ -877,8 +988,10 @@ static _data_e _public_type_to_internal_type(mb_data_e t); static mb_data_e _internal_type_to_public_type(_data_e t); static int _public_value_to_internal_object(mb_value_t* pbl, _object_t* itn); static int _internal_object_to_public_value(_object_t* itn, mb_value_t* pbl); +static int _create_internal_object_from_public_value(mb_value_t* pbl, _object_t** itn); static void _try_clear_intermediate_value(void* data, void* extra, mb_interpreter_t* s); static void _mark_lazy_destroy_string(mb_interpreter_t* s, char* ch); +static void _assign_public_value(mb_value_t* tgt, mb_value_t* src); static void _stepped(mb_interpreter_t* s, _ls_node_t* ast); static int _execute_statement(mb_interpreter_t* s, _ls_node_t** l); @@ -899,6 +1012,10 @@ static int _open_core_lib(mb_interpreter_t* s); static int _close_core_lib(mb_interpreter_t* s); static int _open_std_lib(mb_interpreter_t* s); static int _close_std_lib(mb_interpreter_t* s); +#ifdef MB_ENABLE_COLLECTION_LIB +static int _open_coll_lib(mb_interpreter_t* s); +static int _close_coll_lib(mb_interpreter_t* s); +#endif /* MB_ENABLE_COLLECTION_LIB */ /* ========================================================} */ @@ -981,7 +1098,6 @@ static int _core_goto(mb_interpreter_t* s, void** l); static int _core_gosub(mb_interpreter_t* s, void** l); static int _core_return(mb_interpreter_t* s, void** l); static int _core_call(mb_interpreter_t* s, void** l); -static int _core_var(mb_interpreter_t* s, void** l); static int _core_def(mb_interpreter_t* s, void** l); static int _core_enddef(mb_interpreter_t* s, void** l); static int _core_class(mb_interpreter_t* s, void** l); @@ -989,10 +1105,11 @@ static int _core_endclass(mb_interpreter_t* s, void** l); #ifdef MB_ENABLE_ALLOC_STAT static int _core_mem(mb_interpreter_t* s, void** l); #endif /* MB_ENABLE_ALLOC_STAT */ +static int _core_type(mb_interpreter_t* s, void** l); static int _core_import(mb_interpreter_t* s, void** l); static int _core_end(mb_interpreter_t* s, void** l); -/** Std lib */ +/** Standard lib */ static int _std_abs(mb_interpreter_t* s, void** l); static int _std_sgn(mb_interpreter_t* s, void** l); static int _std_sqr(mb_interpreter_t* s, void** l); @@ -1020,6 +1137,24 @@ static int _std_len(mb_interpreter_t* s, void** l); static int _std_print(mb_interpreter_t* s, void** l); static int _std_input(mb_interpreter_t* s, void** l); +/** Collection lib */ +#ifdef MB_ENABLE_COLLECTION_LIB +static int _coll_list(mb_interpreter_t* s, void** l); +static int _coll_dict(mb_interpreter_t* s, void** l); +static int _coll_push(mb_interpreter_t* s, void** l); +static int _coll_pop(mb_interpreter_t* s, void** l); +static int _coll_peek(mb_interpreter_t* s, void** l); +static int _coll_insert(mb_interpreter_t* s, void** l); +static int _coll_sort(mb_interpreter_t* s, void** l); +static int _coll_exist(mb_interpreter_t* s, void** l); +static int _coll_get(mb_interpreter_t* s, void** l); +static int _coll_set(mb_interpreter_t* s, void** l); +static int _coll_remove(mb_interpreter_t* s, void** l); +static int _coll_clear(mb_interpreter_t* s, void** l); +static int _coll_iterator(mb_interpreter_t* s, void** l); +static int _coll_move_next(mb_interpreter_t* s, void** l); +#endif /* MB_ENABLE_COLLECTION_LIB */ + /** Lib information */ static const _func_t _core_libs[] = { { "#", _core_dummy_assign }, @@ -1068,7 +1203,6 @@ static const _func_t _core_libs[] = { { "RETURN", _core_return }, { "CALL", _core_call }, - { "VAR", _core_var }, { "DEF", _core_def }, { "ENDDEF", _core_enddef }, { "CLASS", _core_class }, @@ -1078,6 +1212,7 @@ static const _func_t _core_libs[] = { { "MEM", _core_mem }, #endif /* MB_ENABLE_ALLOC_STAT */ + { "TYPE", _core_type }, { "IMPORT", _core_import }, { "END", _core_end } }; @@ -1114,6 +1249,25 @@ static const _func_t _std_libs[] = { { "INPUT", _std_input } }; +#ifdef MB_ENABLE_COLLECTION_LIB +static const _func_t _coll_libs[] = { + { "LIST", _coll_list }, + { "DICT", _coll_dict }, + { "PUSH", _coll_push }, + { "POP", _coll_pop }, + { "PEEK", _coll_peek }, + { "INSERT", _coll_insert }, + { "SORT", _coll_sort }, + { "EXIST", _coll_exist }, + { "GET", _coll_get }, + { "SET", _coll_set }, + { "REMOVE", _coll_remove }, + { "CLEAR", _coll_clear }, + { "ITERATOR", _coll_iterator }, + { "MOVE_NEXT", _coll_move_next } +}; +#endif /* MB_ENABLE_COLLECTION_LIB */ + /* ========================================================} */ /* @@ -1134,6 +1288,12 @@ int _ls_cmp_extra(void* node, void* info) { return (n->extra == info) ? 0 : 1; } +int _ls_cmp_extra_object(void* node, void* info) { + _ls_node_t* n = (_ls_node_t*)node; + + return _ht_cmp_object(n->extra, info); +} + int _ls_cmp_extra_string(void* node, void* info) { _ls_node_t* n = (_ls_node_t*)node; char* s1 = (char*)n->extra; @@ -1161,6 +1321,24 @@ _ls_node_t* _ls_create(void) { return result; } +_ls_node_t* _ls_find(_ls_node_t* list, void* data, _ls_compare cmp) { + _ls_node_t* result = 0; + + mb_assert(list && data && cmp); + + list = list->next; + while(list) { + if(!cmp(list->data, data)) { + result = list; + + break; + } + list = list->next; + } + + return result; +} + _ls_node_t* _ls_back(_ls_node_t* node) { _ls_node_t* result = node; @@ -1207,6 +1385,69 @@ void* _ls_popback(_ls_node_t* list) { return result; } +_ls_node_t* _ls_at(_ls_node_t* list, int index) { + _ls_node_t* result = 0; + _ls_node_t* tmp = 0; + + mb_assert(list); + + tmp = list->next; + while(tmp && index) { + tmp = tmp->next; + --index; + } + if(tmp) + result = tmp; + + return result; +} + +_ls_node_t* _ls_insert_at(_ls_node_t* list, int index, void* data) { + _ls_node_t* result = 0; + _ls_node_t* tmp = 0; + + mb_assert(list); + + tmp = list->next; + while(tmp && index) { + tmp = tmp->next; + --index; + } + if(!tmp) { + if(index == 0) + result = _ls_pushback(list, data); + } else { + result = _ls_create_node(data); + tmp->prev->next = result; + result->prev = tmp->prev; + result->next = tmp; + tmp->prev = result; + } + + return result; +} + +unsigned int _ls_remove(_ls_node_t* list, _ls_node_t* node, _ls_operation op) { + unsigned int result = 0; + + mb_assert(list && node); + + if(node->prev) + node->prev->next = node->next; + if(node->next) + node->next->prev = node->prev; + if(list->prev == node) + list->prev = node->prev; + if(list->prev == list) + list->prev = 0; + if(op) + op(node->data, node->extra); + safe_free(node); + ++result; + + return result; +} + unsigned int _ls_try_remove(_ls_node_t* list, void* info, _ls_compare cmp, _ls_operation op) { unsigned int result = 0; _ls_node_t* tmp = 0; @@ -1221,6 +1462,8 @@ unsigned int _ls_try_remove(_ls_node_t* list, void* info, _ls_compare cmp, _ls_o if(tmp->next) tmp->next->prev = tmp->prev; if(list->prev == tmp) + list->prev = tmp->prev; + if(list->prev == list) list->prev = 0; if(op) op(tmp->data, tmp->extra); @@ -1264,6 +1507,38 @@ unsigned int _ls_foreach(_ls_node_t* list, _ls_operation op) { return idx; } +void _ls_sort(_ls_node_t* list, _ls_compare cmp) { + _ls_node_t* ptr = 0; + void* tmp = 0; + + mb_assert(list && cmp); + + list = list->next; + for( ; list; list = list->next) { + for(ptr = list; ptr; ptr = ptr->next) { + if(cmp(list->data, ptr->data) > 0) { + tmp = ptr->data; + ptr->data = list->data; + list->data = tmp; + } + } + } +} + +unsigned int _ls_count(_ls_node_t* list) { + unsigned int result = 0; + + mb_assert(list); + + list = list->next; + while(list) { + list = list->next; + ++result; + } + + return result; +} + bool_t _ls_empty(_ls_node_t* list) { bool_t result = false; @@ -1310,6 +1585,32 @@ int _ls_free_extra(void* data, void* extra) { } /** Dictionary operations */ +unsigned int _ht_hash_object(void* ht, void* d) { + unsigned int result = 0; + _ht_node_t* self = (_ht_node_t*)ht; + _object_t* o = (_object_t*)d; + size_t i = 0; + unsigned int h = 0; + + mb_assert(ht); + + h = o->type; + switch(o->type) { + case _DT_STRING: + result = 5 * h + _ht_hash_string(ht, o->data.string); + + break; + default: + for(i = 0; i < sizeof(_raw_t); ++i) + h = 5 * h + o->data.raw[i]; + result = h % self->array_size; + + break; + } + + return result; +} + unsigned int _ht_hash_string(void* ht, void* d) { unsigned int result = 0; _ht_node_t* self = (_ht_node_t*)ht; @@ -1338,6 +1639,32 @@ unsigned int _ht_hash_int(void* ht, void* d) { return result; } +int _ht_cmp_object(void* d1, void* d2) { + _object_t* o1 = (_object_t*)d1; + _object_t* o2 = (_object_t*)d2; + size_t i = 0; + + if(o1->type < o2->type) + return -1; + else if(o1->type > o2->type) + return 1; + + switch(o1->type) { + case _DT_STRING: + return _ht_cmp_string(o1->data.string, o2->data.string); + default: + for(i = 0; i < sizeof(_raw_t); ++i) { + if(o1->data.raw[i] < o2->data.raw[i]) + return -1; + else if(o1->data.raw[i] > o2->data.raw[i]) + return 1; + } + break; + } + + return 0; +} + int _ht_cmp_string(void* d1, void* d2) { char* s1 = (char*)d1; char* s2 = (char*)d2; @@ -1460,6 +1787,12 @@ unsigned int _ht_foreach(_ht_node_t* ht, _ht_operation op) { return result; } +unsigned int _ht_count(_ht_node_t* ht) { + mb_assert(ht); + + return ht->count; +} + void _ht_clear(_ht_node_t* ht) { unsigned int ul = 0; @@ -1654,7 +1987,7 @@ int mb_uu_substr(char* ch, int begin, int count, char** o) { if(!(*ch) && (cnt != begin + count)) return -1; - l = e - b; + l = (int)(e - b); *o = (char*)mb_malloc(l + 1); memcpy(*o, b, l); (*o)[l] = '\0'; @@ -2114,7 +2447,12 @@ int _calc_expression(mb_interpreter_t* s, _ls_node_t** l, _object_t** val) { } c = (_object_t*)(_ls_popback(opnd)); - if(!c || !(c->type == _DT_NIL || c->type == _DT_INT || c->type == _DT_REAL || c->type == _DT_STRING || c->type == _DT_VAR || c->type == _DT_USERTYPE || c->type == _DT_ARRAY)) { + if(!c || !(c->type == _DT_TYPE || c->type == _DT_NIL || + c->type == _DT_INT || c->type == _DT_REAL || c->type == _DT_STRING || +#ifdef MB_ENABLE_COLLECTION_LIB + c->type == _DT_LIST || c->type == _DT_LIST_IT || c->type == _DT_DICT || c->type == _DT_DICT_IT || +#endif /* MB_ENABLE_COLLECTION_LIB */ + c->type == _DT_VAR || c->type == _DT_USERTYPE || c->type == _DT_ARRAY)) { _set_current_error(s, SE_RN_INVALID_DATA_TYPE, 0); result = MB_FUNC_ERR; @@ -2143,7 +2481,14 @@ int _calc_expression(mb_interpreter_t* s, _ls_node_t** l, _object_t** val) { if(guard_val != c && _ls_try_remove(garbage, c, _ls_cmp_data, NULL)) { _try_clear_intermediate_value(c, 0, s); +#ifdef MB_ENABLE_COLLECTION_LIB + if(c->type == _DT_LIST || c->type == _DT_DICT || c->type == _DT_LIST_IT || c->type == _DT_DICT_IT) + _destroy_object_capsule_only(c, 0); + else + _destroy_object(c, 0); +#else /* MB_ENABLE_COLLECTION_LIB */ _destroy_object(c, 0); +#endif /* MB_ENABLE_COLLECTION_LIB */ } _exit: @@ -2287,11 +2632,11 @@ int _eval_routine(mb_interpreter_t* s, _ls_node_t** l, _routine_t* r) { } } while(ast); - inte = running->intermediate_value; + _assign_public_value(&inte, &running->intermediate_value); _pop_scope(s); - s->running_context->intermediate_value = inte; + _assign_public_value(&s->running_context->intermediate_value, &inte); _exit: s->last_routine = lastr; @@ -2361,7 +2706,7 @@ char* _load_file(const char* f, const char* prefix) { l = ftell(fp); fseek(fp, curpos, SEEK_SET); if(prefix) { - i = strlen(prefix); + i = (long)strlen(prefix); l += i; } buf = (char*)mb_malloc((size_t)(l + 1)); @@ -3488,6 +3833,455 @@ char* _extract_string(_object_t* obj) { return result; } +#ifdef MB_ENABLE_COLLECTION_LIB +_list_t* _create_list(void) { + /* Create a list */ + _list_t* result = (_list_t*)mb_malloc(sizeof(_list_t)); + memset(result, 0, sizeof(_list_t)); + result->list = _ls_create(); + _create_ref(&result->ref, _unref_list); + + return result; +} + +void _destroy_list(_list_t* c) { + /* Destroy a list */ + _ls_foreach(c->list, _destroy_object); + _ls_destroy(c->list); + _destroy_ref(&c->ref); + safe_free(c); +} + +_dict_t* _create_dict(void) { + /* Create a dictionary */ + _dict_t* result = (_dict_t*)mb_malloc(sizeof(_dict_t)); + memset(result, 0, sizeof(_dict_t)); + result->dict = _ht_create(0, _ht_cmp_object, _ht_hash_object, _destroy_object_with_extra); + _create_ref(&result->ref, _unref_dict); + + return result; +} + +void _destroy_dict(_dict_t* c) { + /* Destroy a dictionary */ + _ht_foreach(c->dict, _destroy_object_with_extra); + _ht_destroy(c->dict); + _destroy_ref(&c->ref); + safe_free(c); +} + +_list_it_t* _create_list_it(_list_t* coll) { + /* Create an iterator of a list */ + _list_it_t* result = 0; + + mb_assert(coll); + + result = (_list_it_t*)mb_malloc(sizeof(_list_it_t)); + memset(result, 0, sizeof(_list_it_t)); + result->list = coll; + result->curr = coll->list; + _lock_ref_object(&coll->lock, &coll->ref, coll); + + return result; +} + +bool_t _destroy_list_it(_list_it_t* it) { + /* Destroy an iterator of a list */ + bool_t result = true; + + mb_assert(it); + + _unlock_ref_object(&it->list->lock, &it->list->ref, it->list); + safe_free(it); + + return result; +} + +_list_it_t* _move_list_it_next(_list_it_t* it) { + /* Move an iterator of a list to next node */ + _list_it_t* result = 0; + + if(!it || !it->list || !it->list->list || !it->curr) + goto _exit; + + if(!it->list->lock) + goto _exit; + + it->curr = it->curr->next; + + if(it->curr) + result = it; + +_exit: + return result; +} + +_dict_it_t* _create_dict_it(_dict_t* coll) { + /* Create an iterator of a dictionary */ + _dict_it_t* result = 0; + + mb_assert(coll); + + result = (_dict_it_t*)mb_malloc(sizeof(_dict_it_t)); + memset(result, 0, sizeof(_dict_it_t)); + result->dict = coll; + result->curr_bucket = 0; + result->curr_node = (_ls_node_t*)(intptr_t)~0; + _lock_ref_object(&coll->lock, &coll->ref, coll); + + return result; +} + +bool_t _destroy_dict_it(_dict_it_t* it) { + /* Destroy an iterator of a dictionary */ + bool_t result = true; + + mb_assert(it); + + _unlock_ref_object(&it->dict->lock, &it->dict->ref, it->dict); + safe_free(it); + + return result; +} + +_dict_it_t* _move_dict_it_next(_dict_it_t* it) { + /* Move an iterator of a dictionary to next node */ + _dict_it_t* result = 0; + + if(!it || !it->dict || !it->dict->dict || !it->curr_node) + goto _exit; + + if(!it->dict->lock) + goto _exit; + + if(it->curr_node && it->curr_node != (_ls_node_t*)(intptr_t)~0) { + it->curr_node = it->curr_node->next; + if(!it->curr_node) + ++it->curr_bucket; + } + if(!it->curr_node || it->curr_node == (_ls_node_t*)(intptr_t)~0) { + for( ; it->curr_bucket < it->dict->dict->array_size; ++it->curr_bucket) { + it->curr_node = it->dict->dict->array[it->curr_bucket]; + if(it->curr_node && it->curr_node->next) { + it->curr_node = it->curr_node->next; + + break; + } + } + } + + if(it->curr_node && it->curr_node->extra) + result = it; + +_exit: + return result; +} + +void _unref_list(_ref_t* ref, void* data) { + /* Unreference a list */ + if(!(*(ref->count))) + _destroy_list((_list_t*)data); +} + +void _unref_dict(_ref_t* ref, void* data) { + /* Unreference a dictionary */ + if(!(*(ref->count))) + _destroy_dict((_dict_t*)data); +} + +void _push_list(_list_t* coll, mb_value_t* val) { + /* Push a value to a list */ + _object_t* oarg = 0; + + mb_assert(coll && val); + + _create_internal_object_from_public_value(val, &oarg); + _ls_pushback(coll->list, oarg); + + _write_on_ref_object(&coll->lock, &coll->ref, coll); +} + +bool_t _pop_list(_list_t* coll, mb_value_t* val, mb_interpreter_t* s) { + /* Pop a value from a list */ + _object_t* oval = 0; + + mb_assert(coll && val && s); + + oval = (_object_t*)_ls_popback(coll->list); + if(oval) { + _internal_object_to_public_value(oval, val); + _destroy_object_capsule_only(oval, 0); + + if(val->type == MB_DT_STRING) + _mark_lazy_destroy_string(s, val->value.string); + + _write_on_ref_object(&coll->lock, &coll->ref, coll); + + return true; + } else { + val->type = MB_DT_NIL; + + return false; + } +} + +bool_t _insert_list(_list_t* coll, int_t idx, mb_value_t* val, _object_t** oval) { + /* Insert a value into a list */ + _object_t* oarg = 0; + + mb_assert(coll && val); + + _create_internal_object_from_public_value(val, &oarg); + if(oval) + *oval = oarg; + + if(_ls_insert_at(coll->list, (int)idx, oarg)) { + _write_on_ref_object(&coll->lock, &coll->ref, coll); + + return true; + } + + return false; +} + +bool_t _set_list(_list_t* coll, int_t idx, mb_value_t* val, _object_t** oval) { + /* Set an element in a list with a specific index with a given value */ + _ls_node_t* result = 0; + _object_t* oarg = 0; + + mb_assert(coll && val); + + result = _ls_at(coll->list, (int)idx); + if(result) { + if(result->data) + _destroy_object(result->data, 0); + _create_internal_object_from_public_value(val, &oarg); + if(oval) + *oval = oarg; + result->data = oarg; + + _write_on_ref_object(&coll->lock, &coll->ref, coll); + } + + return !!(result && result->data); +} + +bool_t _remove_at_list(_list_t* coll, int_t idx) { + /* Remove an element in a list with a specific index */ + bool_t result = false; + _ls_node_t* node = 0; + + mb_assert(coll); + + node = _ls_at(coll->list, (int)idx); + if(node) { + if(node->data) { + _ls_remove(coll->list, node, _destroy_object); + + _write_on_ref_object(&coll->lock, &coll->ref, coll); + + result = true; + } + } + + return result; +} + +bool_t _at_list(_list_t* coll, int_t idx, mb_value_t* oval) { + /* Get the value in a list with a specific index */ + _ls_node_t* result = 0; + + mb_assert(coll && oval); + + result = _ls_at(coll->list, idx); + if(oval && result && result->data) + _internal_object_to_public_value(result->data, oval); + + return !!(result && result->data); +} + +bool_t _find_list(_list_t* coll, mb_value_t* val) { + /* Find a value in a list */ + bool_t result = false; + _object_t* oarg = 0; + + mb_assert(coll && val); + + _create_internal_object_from_public_value(val, &oarg); + result = !!_ls_find(coll->list, oarg, (_ls_compare)_ht_cmp_object); + _destroy_object(oarg, 0); + + return result; +} + +void _clear_list(_list_t* coll) { + /* Clear a list */ + mb_assert(coll); + + _ls_foreach(coll->list, _destroy_object); + _ls_clear(coll->list); + + _write_on_ref_object(&coll->lock, &coll->ref, coll); +} + +void _sort_list(_list_t* coll) { + /* Sort a list */ + mb_assert(coll); + + _ls_sort(coll->list, (_ls_compare)_ht_cmp_object); + + _write_on_ref_object(&coll->lock, &coll->ref, coll); +} + +void _set_dict(_dict_t* coll, mb_value_t* key, mb_value_t *val) { + /* Set an element to a dictionary with a key-value pair */ + _object_t* okey = 0; + _object_t* oval = 0; + _ls_node_t* exist = 0; + void* data = 0; + void* extra = 0; + + mb_assert(coll && key && val); + + _create_internal_object_from_public_value(key, &okey); + _create_internal_object_from_public_value(val, &oval); + exist = _ht_find(coll->dict, okey); + if(exist) { + data = exist->data; + extra = exist->extra; + _ht_remove(coll->dict, okey, (_ls_compare)_ls_cmp_extra_object); + } + _ht_set_or_insert(coll->dict, okey, oval); + + _write_on_ref_object(&coll->lock, &coll->ref, coll); +} + +bool_t _remove_dict(_dict_t* coll, mb_value_t* key) { + /* Remove an element to a dictionary with a specific key */ + _ls_node_t* result = 0; + _object_t* okey = 0; + void* data = 0; + void* extra = 0; + + mb_assert(coll && key); + + _create_internal_object_from_public_value(key, &okey); + result = _ht_find(coll->dict, okey); + if(result && result->data) { + data = result->data; + extra = result->extra; + _ht_remove(coll->dict, okey, _ls_cmp_extra_object); + _destroy_object(okey, 0); + + _write_on_ref_object(&coll->lock, &coll->ref, coll); + } + + return !!(result && result->data); +} + +bool_t _find_dict(_dict_t* coll, mb_value_t* val, mb_value_t* oval) { + /* Find a key in a dictionary */ + _ls_node_t* result = 0; + _object_t* oarg = 0; + + mb_assert(coll && val); + + _create_internal_object_from_public_value(val, &oarg); + result = _ht_find(coll->dict, oarg); + _destroy_object(oarg, 0); + if(oval && result && result->data) + _internal_object_to_public_value(result->data, oval); + + return !!(result && result->data); +} + +void _clear_dict(_dict_t* coll) { + /* Clear a dictionary */ + mb_assert(coll); + + _ht_foreach(coll->dict, _destroy_object_with_extra); + _ht_clear(coll->dict); + + _write_on_ref_object(&coll->lock, &coll->ref, coll); +} +#endif /* MB_ENABLE_COLLECTION_LIB */ + +bool_t _lock_ref_object(_lock_t* lk, _ref_t* ref, void* obj) { + /* Lock an object */ + mb_assert(lk); + + _ref(ref, obj); + ++(*lk); + + return true; +} + +bool_t _unlock_ref_object(_lock_t* lk, _ref_t* ref, void* obj) { + /* Unlock an object */ + bool_t result = true; + mb_assert(lk); + + if(*lk) + --(*lk); + else + result = false; + _unref(ref, obj); + + return result; +} + +bool_t _write_on_ref_object(_lock_t* lk, _ref_t* ref, void* obj) { + /* Write operation on a collection */ + bool_t result = true; + mb_unrefvar(ref); + mb_unrefvar(obj); + + mb_assert(lk); + + if(*lk) + *lk = 0; + else + result = false; + + return result; +} + +unsigned _ref(_ref_t* ref, void* data) { + /* Add a referenct to a stub */ + mb_unrefvar(data); + + return ++(*(ref->count)); +} + +unsigned _unref(_ref_t* ref, void* data) { + /* Remove a reference to a stub */ + unsigned result = 0; + + result = --(*(ref->count)); + ref->on_unref(ref, data); + + return result; +} + +void _create_ref(_ref_t* ref, _unref_func_t dtor) { + /* Create a reference stub */ + if(ref->count) + return; + + ref->count = (unsigned*)mb_malloc(sizeof(unsigned)); + *(ref->count) = 0; + ref->on_unref = dtor; +} + +void _destroy_ref(_ref_t* ref) { + /* Destroy a reference stub */ + if(!ref->count) + return; + + safe_free(ref->count); + ref->on_unref = 0; +} + void _init_class(mb_interpreter_t* s, _class_t* instance, char* n) { /* Initialize a class */ _running_context_t* running = 0; @@ -3825,6 +4619,24 @@ int _dispose_object(_object_t* obj) { _destroy_array(obj->data.array); break; +#ifdef MB_ENABLE_COLLECTION_LIB + case _DT_LIST: + _unref(&obj->data.list->ref, obj->data.list); + + break; + case _DT_LIST_IT: + _destroy_list_it(obj->data.list_it); + + break; + case _DT_DICT: + _unref(&obj->data.dict->ref, obj->data.dict); + + break; + case _DT_DICT_IT: + _destroy_dict_it(obj->data.dict_it); + + break; +#endif /* MB_ENABLE_COLLECTION_LIB */ case _DT_LABEL: if(!obj->ref) { safe_free(obj->data.label->name); @@ -3854,6 +4666,7 @@ int _dispose_object(_object_t* obj) { } break; + case _DT_TYPE: /* Fall through */ case _DT_NIL: /* Fall through */ case _DT_ANY: /* Fall through */ case _DT_INT: /* Fall through */ @@ -3902,6 +4715,28 @@ _exit: return result; } +int _destroy_object_with_extra(void* data, void* extra) { + /* Destroy an object, including its data and extra data */ + int result = _OP_RESULT_NORMAL; + _object_t* obj = 0; + + mb_assert(data); + + obj = (_object_t*)data; + if(!_dispose_object(obj)) + goto _exit; + safe_free(obj); + obj = (_object_t*)extra; + if(!_dispose_object(obj)) + goto _exit; + safe_free(obj); + +_exit: + result = _OP_RESULT_DEL_NODE; + + return result; +} + int _destroy_object_not_compile_time(void* data, void* extra) { /* Destroy an object which is not come from compile time */ int result = _OP_RESULT_NORMAL; @@ -4001,6 +4836,8 @@ bool_t _is_internal_object(_object_t* obj) { _data_e _public_type_to_internal_type(mb_data_e t) { /* Convert a public mb_data_e type to an internal _data_e */ switch(t) { + case MB_DT_TYPE: + return _DT_TYPE; case MB_DT_NIL: return _DT_NIL; case MB_DT_INT: @@ -4011,6 +4848,18 @@ _data_e _public_type_to_internal_type(mb_data_e t) { return _DT_STRING; case MB_DT_USERTYPE: return _DT_USERTYPE; + case MB_DT_ARRAY: + return _DT_ARRAY; +#ifdef MB_ENABLE_COLLECTION_LIB + case MB_DT_LIST: + return _DT_LIST; + case MB_DT_LIST_IT: + return _DT_LIST_IT; + case MB_DT_DICT: + return _DT_DICT; + case MB_DT_DICT_IT: + return _DT_DICT_IT; +#endif /* MB_ENABLE_COLLECTION_LIB */ default: return _DT_NIL; } @@ -4019,6 +4868,8 @@ _data_e _public_type_to_internal_type(mb_data_e t) { mb_data_e _internal_type_to_public_type(_data_e t) { /* Convert an internal mb_data_e type to a public _data_e */ switch(t) { + case _DT_TYPE: + return MB_DT_TYPE; case _DT_NIL: return MB_DT_NIL; case _DT_INT: @@ -4029,6 +4880,18 @@ mb_data_e _internal_type_to_public_type(_data_e t) { return MB_DT_STRING; case _DT_USERTYPE: return MB_DT_USERTYPE; + case _DT_ARRAY: + return MB_DT_ARRAY; +#ifdef MB_ENABLE_COLLECTION_LIB + case _DT_LIST: + return MB_DT_LIST; + case _DT_LIST_IT: + return MB_DT_LIST_IT; + case _DT_DICT: + return MB_DT_DICT; + case _DT_DICT_IT: + return MB_DT_DICT_IT; +#endif /* MB_ENABLE_COLLECTION_LIB */ default: return MB_DT_NIL; } @@ -4041,6 +4904,11 @@ int _public_value_to_internal_object(mb_value_t* pbl, _object_t* itn) { mb_assert(pbl && itn); switch(pbl->type) { + case MB_DT_TYPE: + itn->type = _DT_TYPE; + itn->data.type = pbl->value.type; + + break; case MB_DT_NIL: itn->type = _DT_NIL; itn->data.integer = false; @@ -4071,6 +4939,28 @@ int _public_value_to_internal_object(mb_value_t* pbl, _object_t* itn) { itn->data.array = pbl->value.array; break; +#ifdef MB_ENABLE_COLLECTION_LIB + case MB_DT_LIST: + itn->type = _DT_LIST; + itn->data.list = pbl->value.list; + + break; + case MB_DT_LIST_IT: + itn->type = _DT_LIST_IT; + itn->data.list_it = pbl->value.list_it; + + break; + case MB_DT_DICT: + itn->type = _DT_DICT; + itn->data.dict = pbl->value.dict; + + break; + case MB_DT_DICT_IT: + itn->type = _DT_DICT_IT; + itn->data.dict_it = pbl->value.dict_it; + + break; +#endif /* MB_ENABLE_COLLECTION_LIB */ default: result = MB_FUNC_ERR; @@ -4087,6 +4977,11 @@ int _internal_object_to_public_value(_object_t* itn, mb_value_t* pbl) { mb_assert(pbl && itn); switch(itn->type) { + case _DT_TYPE: + pbl->type = MB_DT_TYPE; + pbl->value.type = itn->data.type; + + break; case _DT_NIL: pbl->type = MB_DT_NIL; pbl->value.integer = false; @@ -4117,6 +5012,28 @@ int _internal_object_to_public_value(_object_t* itn, mb_value_t* pbl) { pbl->value.array = itn->data.array; break; +#ifdef MB_ENABLE_COLLECTION_LIB + case _DT_LIST: + pbl->type = MB_DT_LIST; + pbl->value.list = itn->data.list; + + break; + case _DT_LIST_IT: + pbl->type = MB_DT_LIST_IT; + pbl->value.list_it = itn->data.list; + + break; + case _DT_DICT: + pbl->type = MB_DT_DICT; + pbl->value.dict = itn->data.dict; + + break; + case _DT_DICT_IT: + pbl->type = MB_DT_DICT_IT; + pbl->value.dict_it = itn->data.dict_it; + + break; +#endif /* MB_ENABLE_COLLECTION_LIB */ default: result = MB_FUNC_ERR; @@ -4126,6 +5043,23 @@ int _internal_object_to_public_value(_object_t* itn, mb_value_t* pbl) { return result; } +int _create_internal_object_from_public_value(mb_value_t* pbl, _object_t** itn) { + /* Create an internal object from a public value */ + int result = MB_FUNC_OK; + + mb_assert(pbl && itn); + + *itn = (_object_t*)mb_malloc(sizeof(_object_t)); + memset(*itn, 0, sizeof(_object_t)); + _public_value_to_internal_object(pbl, *itn); + if((*itn)->type == _DT_STRING) { + (*itn)->ref = false; + (*itn)->data.string = mb_memdup((*itn)->data.string, (unsigned)(strlen((*itn)->data.string) + 1)); + } + + return result; +} + void _try_clear_intermediate_value(void* data, void* extra, mb_interpreter_t* s) { /* Try clear the intermediate value when destroying an object */ _object_t* obj = 0; @@ -4158,6 +5092,39 @@ void _mark_lazy_destroy_string(mb_interpreter_t* s, char* ch) { _ls_pushback(s->lazy_destroy_objects, temp_obj); } +void _assign_public_value(mb_value_t* tgt, mb_value_t* src) { + /* Assign a value with another */ + _object_t obj; + mb_value_t nil; + + mb_assert(tgt); + + if(src) { + _public_value_to_internal_object(src, &obj); +#ifdef MB_ENABLE_COLLECTION_LIB + if(obj.type == _DT_LIST) + _ref(&obj.data.list->ref, obj.data.list); + else if(obj.type == _DT_DICT) + _ref(&obj.data.dict->ref, obj.data.dict); +#endif /* MB_ENABLE_COLLECTION_LIB */ + } + + _public_value_to_internal_object(tgt, &obj); +#ifdef MB_ENABLE_COLLECTION_LIB + if(obj.type == _DT_LIST) + _unref(&obj.data.list->ref, obj.data.list); + else if(obj.type == _DT_DICT) + _unref(&obj.data.dict->ref, obj.data.dict); +#endif /* MB_ENABLE_COLLECTION_LIB */ + + if(!src) { + nil.type = MB_DT_NIL; + nil.value.usertype = 0; + src = &nil; + } + memcpy(tgt, src, sizeof(mb_value_t)); +} + void _stepped(mb_interpreter_t* s, _ls_node_t* ast) { /* Called each step */ _object_t* obj = 0; @@ -4551,6 +5518,34 @@ int _close_std_lib(mb_interpreter_t* s) { return result; } +#ifdef MB_ENABLE_COLLECTION_LIB +int _open_coll_lib(mb_interpreter_t* s) { + /* Open the collection functional libraries */ + int result = 0; + int i = 0; + + mb_assert(s); + + for(i = 0; i < _countof(_coll_libs); ++i) + result += _register_func(s, _coll_libs[i].name, _coll_libs[i].pointer, true); + + return result; +} + +int _close_coll_lib(mb_interpreter_t* s) { + /* Close the collection functional libraries */ + int result = 0; + int i = 0; + + mb_assert(s); + + for(i = 0; i < _countof(_coll_libs); ++i) + result += _remove_func(s, _coll_libs[i].name, true); + + return result; +} +#endif /* MB_ENABLE_COLLECTION_LIB */ + /* ========================================================} */ /* @@ -4687,6 +5682,9 @@ int mb_open(struct mb_interpreter_t** s) { _open_core_lib(*s); _open_std_lib(*s); +#ifdef MB_ENABLE_COLLECTION_LIB + _open_coll_lib(*s); +#endif /* MB_ENABLE_COLLECTION_LIB */ result = _open_constant(*s); mb_assert(MB_FUNC_OK == result); @@ -4706,6 +5704,9 @@ int mb_close(struct mb_interpreter_t** s) { context = (*s)->parsing_context; +#ifdef MB_ENABLE_COLLECTION_LIB + _close_coll_lib(*s); +#endif /* MB_ENABLE_COLLECTION_LIB */ _close_std_lib(*s); _close_core_lib(*s); @@ -5046,6 +6047,12 @@ int mb_pop_value(struct mb_interpreter_t* s, void** l, mb_value_t* val) { val_ptr = (_object_t*)mb_malloc(sizeof(_object_t)); memcpy(val_ptr, &val_obj, sizeof(_object_t)); _ls_pushback(s->temp_values, val_ptr); +#ifdef MB_ENABLE_COLLECTION_LIB + } else if(val_ptr->type == _DT_LIST) { + _ref(&val_ptr->data.list->ref, val_ptr->data.list); + } else if(val_ptr->type == _DT_DICT) { + _ref(&val_ptr->data.dict->ref, val_ptr->data.dict); +#endif /* MB_ENABLE_COLLECTION_LIB */ } if(s->no_eat_comma_mark < _NO_EAT_COMMA && (!inep || (inep && !(*inep)))) { @@ -5128,7 +6135,7 @@ int mb_push_value(struct mb_interpreter_t* s, void** l, mb_value_t val) { mb_assert(s && l); running = s->running_context; - running->intermediate_value = val; + _assign_public_value(&running->intermediate_value, &val); return result; } @@ -5338,6 +6345,8 @@ int mb_dispose_value(struct mb_interpreter_t* s, mb_value_t val) { if(val.type == MB_DT_STRING) safe_free(val.value.string); + _assign_public_value(&val, 0); + return result; } @@ -5577,6 +6586,40 @@ int mb_debug_set_stepped_handler(struct mb_interpreter_t* s, mb_debug_stepped_ha return result; } +const char* mb_get_type_string(mb_data_e t) { + /* Get type description text */ + switch(t) { + case MB_DT_NIL: + return "NIL"; + case MB_DT_UNKNOWN: + return "UNKNOWN"; + case MB_DT_TYPE: + return "TYPE"; + case MB_DT_INT: + return "INT"; + case MB_DT_REAL: + return "REAL"; + case MB_DT_STRING: + return "STRING"; + case MB_DT_USERTYPE: + return "USERTYPE"; + case MB_DT_ARRAY: + return "ARRAY"; +#ifdef MB_ENABLE_COLLECTION_LIB + case MB_DT_LIST: + return "LIST"; + case MB_DT_LIST_IT: + return "LIST_ITERATOR"; + case MB_DT_DICT: + return "DICT"; + case MB_DT_DICT_IT: + return "DICT_ITERATOR"; +#endif /* MB_ENABLE_COLLECTION_LIB */ + default: + return "UNKNOWN"; + } +} + mb_error_e mb_get_last_error(struct mb_interpreter_t* s) { /* Get last error information */ mb_error_e result = SE_NO_ERR; @@ -6158,6 +7201,13 @@ int _core_let(mb_interpreter_t* s, void** l) { safe_free(val->data.string); } } +#ifdef MB_ENABLE_COLLECTION_LIB + if(val->type == _DT_LIST) { + _ref(&val->data.list->ref, val->data.list); + } else if(val->type == _DT_DICT) { + _ref(&val->data.dict->ref, val->data.dict); + } +#endif /* MB_ENABLE_COLLECTION_LIB */ safe_free(val); _exit: @@ -6849,16 +7899,6 @@ int _core_call(mb_interpreter_t* s, void** l) { return result; } -int _core_var(mb_interpreter_t* s, void** l) { - /* VAR statement */ - int result = MB_FUNC_OK; - - _do_nothing(s, l, _exit, result); - -_exit: - return result; -} - int _core_def(mb_interpreter_t* s, void** l) { /* DEF statement */ int result = MB_FUNC_OK; @@ -6991,6 +8031,41 @@ int _core_mem(mb_interpreter_t* s, void** l) { } #endif /* MB_ENABLE_ALLOC_STAT */ +int _core_type(mb_interpreter_t* s, void** l) { + /* TYPE statement */ + int result = MB_FUNC_OK; + mb_value_t arg; + int i = 0; + unsigned e = 0; + + mb_assert(s && l); + + mb_check(mb_attempt_func_begin(s, l)); + + mb_check(mb_pop_value(s, l, &arg)); + + mb_check(mb_attempt_func_end(s, l)); + + if(arg.type == MB_DT_STRING) { + for(i = 0; i < sizeof(mb_data_e) * 8; i++) { + e = 1 << i; + if(!strcmp(mb_get_type_string((mb_data_e)e), arg.value.string)) { + arg.value.type = e; + arg.type = MB_DT_TYPE; + + goto _found; + } + } + } + arg.value.type = arg.type; + arg.type = MB_DT_TYPE; + +_found: + mb_check(mb_push_value(s, l, arg)); + + return result; +} + int _core_import(mb_interpreter_t* s, void** l) { /* IMPORT statement */ int result = MB_FUNC_OK; @@ -7015,7 +8090,7 @@ int _core_end(mb_interpreter_t* s, void** l) { return result; } -/** Std lib */ +/** Standard lib */ int _std_abs(mb_interpreter_t* s, void** l) { /* Get the absolute value of a number */ int result = MB_FUNC_OK; @@ -7684,6 +8759,10 @@ int _std_len(mb_interpreter_t* s, void** l) { _ls_node_t* ast = 0; mb_value_t arg; _array_t* arr = 0; +#ifdef MB_ENABLE_COLLECTION_LIB + _list_t* lst = 0; + _dict_t* dct = 0; +#endif /* MB_ENABLE_COLLECTION_LIB */ mb_assert(s && l); @@ -7709,6 +8788,20 @@ int _std_len(mb_interpreter_t* s, void** l) { mb_check(mb_push_int(s, l, (int_t)arr->count)); break; +#ifdef MB_ENABLE_COLLECTION_LIB + case MB_DT_LIST: + lst = (_list_t*)arg.value.list; + mb_check(mb_push_int(s, l, (int_t)_ls_count(lst->list))); + _assign_public_value(&arg, 0); + + break; + case MB_DT_DICT: + dct = (_dict_t*)arg.value.dict; + mb_check(mb_push_int(s, l, (int_t)_ht_count(dct->dict))); + _assign_public_value(&arg, 0); + + break; +#endif /* MB_ENABLE_COLLECTION_LIB */ default: _handle_error_on_obj(s, SE_RN_NOT_SUPPORTED, 0, DON(ast), MB_FUNC_ERR, _exit, result); @@ -7743,6 +8836,7 @@ int _std_print(mb_interpreter_t* s, void** l) { obj = (_object_t*)(ast->data); do { switch(obj->type) { + case _DT_TYPE: /* Fall through */ case _DT_NIL: /* Fall through */ case _DT_INT: /* Fall through */ case _DT_REAL: /* Fall through */ @@ -7763,6 +8857,8 @@ int _std_print(mb_interpreter_t* s, void** l) { if(!val_ptr->ref && val_ptr->data.string) { safe_free(val_ptr->data.string); } + } else if(val_ptr->type == _DT_TYPE) { + _get_printer(s)(mb_get_type_string(val_ptr->data.type)); } if(result != MB_FUNC_OK) goto _exit; @@ -7868,6 +8964,593 @@ _exit: return result; } +/** Collection lib */ +#ifdef MB_ENABLE_COLLECTION_LIB +int _coll_list(mb_interpreter_t* s, void** l) { + /* LIST statement */ + int result = MB_FUNC_OK; + mb_value_t arg; + _list_t* coll = 0; + + mb_assert(s && l); + + mb_check(mb_attempt_open_bracket(s, l)); + + coll = _create_list(); + + while(mb_has_arg(s, l)) { + mb_check(mb_pop_value(s, l, &arg)); + + _push_list(coll, &arg); + } + + mb_check(mb_attempt_close_bracket(s, l)); + + arg.type = MB_DT_LIST; + arg.value.list = coll; + mb_check(mb_push_value(s, l, arg)); + + return result; +} + +int _coll_dict(mb_interpreter_t* s, void** l) { + /* DICT statement */ + int result = MB_FUNC_OK; + mb_value_t arg; + mb_value_t val; + _dict_t* coll = 0; + + mb_assert(s && l); + + mb_check(mb_attempt_open_bracket(s, l)); + + coll = _create_dict(); + + while(mb_has_arg(s, l)) { + mb_check(mb_pop_value(s, l, &arg)); + mb_check(mb_pop_value(s, l, &val)); + + _set_dict(coll, &arg, &val); + } + + mb_check(mb_attempt_close_bracket(s, l)); + + arg.type = MB_DT_DICT; + arg.value.dict = coll; + mb_check(mb_push_value(s, l, arg)); + + return result; +} + +int _coll_push(mb_interpreter_t* s, void** l) { + /* PUSH statement */ + int result = MB_FUNC_OK; + mb_value_t lst; + mb_value_t arg; + _object_t olst; + + mb_assert(s && l); + + mb_check(mb_attempt_open_bracket(s, l)); + + mb_check(mb_pop_value(s, l, &lst)); + if(lst.type != MB_DT_LIST) { + _handle_error_on_obj(s, SE_RN_COLLECTION_EXPECTED, 0, TON(l), MB_FUNC_ERR, _exit, result); + } + _public_value_to_internal_object(&lst, &olst); + + while(mb_has_arg(s, l)) { + mb_check(mb_pop_value(s, l, &arg)); + + _push_list(olst.data.list, &arg); + } + + mb_check(mb_attempt_close_bracket(s, l)); + + mb_check(mb_push_value(s, l, lst)); + +_exit: + _assign_public_value(&lst, 0); + + return result; +} + +int _coll_pop(mb_interpreter_t* s, void** l) { + /* POP statement */ + int result = MB_FUNC_OK; + mb_value_t lst; + mb_value_t val; + _object_t olst; + + mb_assert(s && l); + + mb_check(mb_attempt_open_bracket(s, l)); + + mb_check(mb_pop_value(s, l, &lst)); + + mb_check(mb_attempt_close_bracket(s, l)); + + if(lst.type != MB_DT_LIST) { + _handle_error_on_obj(s, SE_RN_COLLECTION_EXPECTED, 0, TON(l), MB_FUNC_ERR, _exit, result); + } + + _public_value_to_internal_object(&lst, &olst); + if(_pop_list(olst.data.list, &val, s)) { + mb_check(mb_push_value(s, l, val)); + + _assign_public_value(&lst, 0); + } else { + mb_check(mb_push_value(s, l, val)); + + _assign_public_value(&lst, 0); + + _handle_error_on_obj(s, SE_RN_EMPTY_COLLECTION, 0, TON(l), MB_FUNC_WARNING, _exit, result); + } + +_exit: + return result; +} + +int _coll_peek(mb_interpreter_t* s, void** l) { + /* PEEK statement */ + int result = MB_FUNC_OK; + mb_value_t lst; + mb_value_t val; + _object_t olst; + _object_t* oval = 0; + + mb_assert(s && l); + + mb_check(mb_attempt_open_bracket(s, l)); + + mb_check(mb_pop_value(s, l, &lst)); + + mb_check(mb_attempt_close_bracket(s, l)); + + if(lst.type != MB_DT_LIST) { + _handle_error_on_obj(s, SE_RN_COLLECTION_EXPECTED, 0, TON(l), MB_FUNC_ERR, _exit, result); + } + + _public_value_to_internal_object(&lst, &olst); + oval = (_object_t*)(_ls_back(olst.data.list->list)->data); + if(oval) { + _internal_object_to_public_value(oval, &val); + + mb_check(mb_push_value(s, l, val)); + + _assign_public_value(&lst, 0); + } else { + val.type = MB_DT_NIL; + mb_check(mb_push_value(s, l, val)); + + _assign_public_value(&lst, 0); + + _handle_error_on_obj(s, SE_RN_EMPTY_COLLECTION, 0, TON(l), MB_FUNC_WARNING, _exit, result); + } + +_exit: + return result; +} + +int _coll_insert(mb_interpreter_t* s, void** l) { + /* INSERT statement */ + int result = MB_FUNC_OK; + mb_value_t lst; + int_t idx = 0; + mb_value_t arg; + _object_t olst; + _object_t* oval = 0; + + mb_assert(s && l); + + mb_check(mb_attempt_open_bracket(s, l)); + + mb_check(mb_pop_value(s, l, &lst)); + mb_check(mb_pop_int(s, l, &idx)); + mb_check(mb_pop_value(s, l, &arg)); + + mb_check(mb_attempt_close_bracket(s, l)); + + if(lst.type != MB_DT_LIST) { + _handle_error_on_obj(s, SE_RN_COLLECTION_EXPECTED, 0, TON(l), MB_FUNC_ERR, _exit, result); + } + _public_value_to_internal_object(&lst, &olst); + + if(!_insert_list(olst.data.list, idx, &arg, &oval)) { + _destroy_object(oval, 0); + + _handle_error_on_obj(s, SE_RN_INDEX_OUT_OF_BOUND, 0, TON(l), MB_FUNC_ERR, _exit, result); + } + + mb_check(mb_push_value(s, l, lst)); + +_exit: + _assign_public_value(&lst, 0); + + return result; +} + +int _coll_sort(mb_interpreter_t* s, void** l) { + /* SORT statement */ + int result = MB_FUNC_OK; + mb_value_t lst; + _object_t olst; + + mb_assert(s && l); + + mb_check(mb_attempt_open_bracket(s, l)); + + mb_check(mb_pop_value(s, l, &lst)); + + mb_check(mb_attempt_close_bracket(s, l)); + + if(lst.type != MB_DT_LIST) { + _handle_error_on_obj(s, SE_RN_COLLECTION_EXPECTED, 0, TON(l), MB_FUNC_ERR, _exit, result); + } + _public_value_to_internal_object(&lst, &olst); + + _sort_list(olst.data.list); + + mb_check(mb_push_value(s, l, lst)); + +_exit: + _assign_public_value(&lst, 0); + + return result; +} + +int _coll_exist(mb_interpreter_t* s, void** l){ + /* EXIST statement */ + int result = MB_FUNC_OK; + mb_value_t coll; + mb_value_t arg; + _object_t ocoll; + mb_value_t ret; + + mb_assert(s && l); + + mb_check(mb_attempt_open_bracket(s, l)); + + mb_check(mb_pop_value(s, l, &coll)); + mb_check(mb_pop_value(s, l, &arg)); + + mb_check(mb_attempt_close_bracket(s, l)); + + ret.type = MB_DT_INT; + switch(coll.type) { + case MB_DT_LIST: + _public_value_to_internal_object(&coll, &ocoll); + ret.value.integer = !!_find_list(ocoll.data.list, &arg); + + break; + case MB_DT_DICT: + _public_value_to_internal_object(&coll, &ocoll); + ret.value.integer = !!_find_dict(ocoll.data.dict, &arg, 0); + + break; + default: + _handle_error_on_obj(s, SE_RN_COLLECTION_EXPECTED, 0, TON(l), MB_FUNC_ERR, _exit, result); + + break; + } + mb_check(mb_push_value(s, l, ret)); + +_exit: + _assign_public_value(&coll, 0); + + return result; +} + +int _coll_get(mb_interpreter_t* s, void** l) { + /* GET statement */ + int result = MB_FUNC_OK; + mb_value_t coi; + int_t index = 0; + mb_value_t arg; + _object_t ocoi; + mb_value_t ret; + + mb_assert(s && l); + + mb_check(mb_attempt_open_bracket(s, l)); + + mb_check(mb_pop_value(s, l, &coi)); + ret.type = MB_DT_NIL; + switch(coi.type) { + case MB_DT_LIST: + _public_value_to_internal_object(&coi, &ocoi); + mb_check(mb_pop_int(s, l, &index)); + if(!_at_list(ocoi.data.list, index, &ret)) { + _handle_error_on_obj(s, SE_RN_CANNOT_FIND_WITH_GIVEN_INDEX, 0, TON(l), MB_FUNC_ERR, _exit, result); + } + + break; + case MB_DT_DICT: + _public_value_to_internal_object(&coi, &ocoi); + mb_check(mb_pop_value(s, l, &arg)); + if(!_find_dict(ocoi.data.dict, &arg, &ret)) { + _handle_error_on_obj(s, SE_RN_CANNOT_FIND_WITH_GIVEN_INDEX, 0, TON(l), MB_FUNC_ERR, _exit, result); + } + + break; + case MB_DT_LIST_IT: + _public_value_to_internal_object(&coi, &ocoi); + if(ocoi.data.list_it && ocoi.data.list_it->curr && ocoi.data.list_it->curr->data) { + _internal_object_to_public_value(ocoi.data.list_it->curr->data, &ret); + } else { + _handle_error_on_obj(s, SE_RN_INVALID_ITERATOR, 0, TON(l), MB_FUNC_ERR, _exit, result); + } + + break; + case MB_DT_DICT_IT: + _public_value_to_internal_object(&coi, &ocoi); + if(ocoi.data.dict_it && ocoi.data.dict_it->curr_node && ocoi.data.dict_it->curr_node->extra) { + _internal_object_to_public_value(ocoi.data.dict_it->curr_node->extra, &ret); + } else { + _handle_error_on_obj(s, SE_RN_INVALID_ITERATOR, 0, TON(l), MB_FUNC_ERR, _exit, result); + } + + break; + default: + _handle_error_on_obj(s, SE_RN_COLLECTION_OR_ITERATOR_EXPECTED, 0, TON(l), MB_FUNC_ERR, _exit, result); + + break; + } + + mb_check(mb_attempt_close_bracket(s, l)); + + mb_check(mb_push_value(s, l, ret)); + +_exit: + _assign_public_value(&coi, 0); + + return result; +} + +int _coll_set(mb_interpreter_t* s, void** l) { + /* SET statement */ + int result = MB_FUNC_OK; + mb_value_t coll; + int_t idx = 0; + mb_value_t key; + mb_value_t val; + _object_t ocoll; + _object_t* oval = 0; + + mb_assert(s && l); + + mb_check(mb_attempt_open_bracket(s, l)); + + mb_check(mb_pop_value(s, l, &coll)); + switch(coll.type) { + case MB_DT_LIST: + _public_value_to_internal_object(&coll, &ocoll); + while(mb_has_arg(s, l)) { + mb_check(mb_pop_int(s, l, &idx)); + mb_check(mb_pop_value(s, l, &val)); + + if(!_set_list(ocoll.data.list, idx, &val, &oval)) { + _destroy_object(oval, 0); + + _handle_error_on_obj(s, SE_RN_CANNOT_FIND_WITH_GIVEN_INDEX, 0, TON(l), MB_FUNC_ERR, _exit, result); + } + } + + break; + case MB_DT_DICT: + _public_value_to_internal_object(&coll, &ocoll); + while(mb_has_arg(s, l)) { + mb_check(mb_pop_value(s, l, &key)); + mb_check(mb_pop_value(s, l, &val)); + + _set_dict(ocoll.data.dict, &key, &val); + } + + break; + default: + _handle_error_on_obj(s, SE_RN_COLLECTION_EXPECTED, 0, TON(l), MB_FUNC_ERR, _exit, result); + + break; + } + + mb_check(mb_attempt_close_bracket(s, l)); + + mb_check(mb_push_value(s, l, coll)); + +_exit: + _assign_public_value(&coll, 0); + + return result; +} + +int _coll_remove(mb_interpreter_t* s, void** l) { + /* REMOVE statement */ + int result = MB_FUNC_OK; + mb_value_t coll; + int_t idx = 0; + mb_value_t key; + _object_t ocoll; + + mb_assert(s && l); + + mb_check(mb_attempt_open_bracket(s, l)); + + mb_check(mb_pop_value(s, l, &coll)); + switch(coll.type) { + case MB_DT_LIST: + _public_value_to_internal_object(&coll, &ocoll); + while(mb_has_arg(s, l)) { + mb_check(mb_pop_int(s, l, &idx)); + + if(!_remove_at_list(ocoll.data.list, idx)) { + _handle_error_on_obj(s, SE_RN_CANNOT_FIND_WITH_GIVEN_INDEX, 0, TON(l), MB_FUNC_ERR, _exit, result); + } + } + + break; + case MB_DT_DICT: + _public_value_to_internal_object(&coll, &ocoll); + while(mb_has_arg(s, l)) { + mb_check(mb_pop_value(s, l, &key)); + + if(!_remove_dict(ocoll.data.dict, &key)) { + _handle_error_on_obj(s, SE_RN_CANNOT_FIND_WITH_GIVEN_INDEX, 0, TON(l), MB_FUNC_ERR, _exit, result); + } + } + + break; + default: + _handle_error_on_obj(s, SE_RN_COLLECTION_EXPECTED, 0, TON(l), MB_FUNC_ERR, _exit, result); + + break; + } + + mb_check(mb_attempt_close_bracket(s, l)); + + mb_check(mb_push_value(s, l, coll)); + +_exit: + _assign_public_value(&coll, 0); + + return result; +} + +int _coll_clear(mb_interpreter_t* s, void** l) { + /* CLEAR statement */ + int result = MB_FUNC_OK; + mb_value_t coll; + _object_t ocoll; + + mb_assert(s && l); + + mb_check(mb_attempt_open_bracket(s, l)); + + mb_check(mb_pop_value(s, l, &coll)); + + mb_check(mb_attempt_close_bracket(s, l)); + + switch(coll.type) { + case MB_DT_LIST: + _public_value_to_internal_object(&coll, &ocoll); + _clear_list(ocoll.data.list); + + break; + case MB_DT_DICT: + _public_value_to_internal_object(&coll, &ocoll); + _clear_dict(ocoll.data.dict); + + break; + default: + _handle_error_on_obj(s, SE_RN_COLLECTION_EXPECTED, 0, TON(l), MB_FUNC_ERR, _exit, result); + + break; + } + + mb_check(mb_push_value(s, l, coll)); + +_exit: + _assign_public_value(&coll, 0); + + return result; +} + +int _coll_iterator(mb_interpreter_t* s, void** l) { + /* ITERATOR statement */ + int result = MB_FUNC_OK; + mb_value_t coll; + _object_t ocoll; + _list_it_t* lit = 0; + _dict_it_t* dit = 0; + mb_value_t ret; + + mb_assert(s && l); + + mb_check(mb_attempt_open_bracket(s, l)); + + mb_check(mb_pop_value(s, l, &coll)); + + mb_check(mb_attempt_close_bracket(s, l)); + + switch(coll.type) { + case MB_DT_LIST: + _public_value_to_internal_object(&coll, &ocoll); + lit = _create_list_it(ocoll.data.list); + ret.type = MB_DT_LIST_IT; + ret.value.list_it = lit; + + break; + case MB_DT_DICT: + _public_value_to_internal_object(&coll, &ocoll); + dit = _create_dict_it(ocoll.data.dict); + ret.type = MB_DT_DICT_IT; + ret.value.list_it = dit; + + break; + default: + _handle_error_on_obj(s, SE_RN_COLLECTION_EXPECTED, 0, TON(l), MB_FUNC_ERR, _exit, result); + + break; + } + + mb_check(mb_push_value(s, l, ret)); + +_exit: + _assign_public_value(&coll, 0); + + return result; +} + +int _coll_move_next(mb_interpreter_t* s, void** l) { + /* MOVE_NEXT statement */ + int result = MB_FUNC_OK; + mb_value_t it; + _object_t oit; + mb_value_t ret; + + mb_assert(s && l); + + mb_check(mb_attempt_open_bracket(s, l)); + + mb_check(mb_pop_value(s, l, &it)); + + mb_check(mb_attempt_close_bracket(s, l)); + + switch(it.type) { + case MB_DT_LIST_IT: + _public_value_to_internal_object(&it, &oit); + oit.data.list_it = _move_list_it_next(oit.data.list_it); + if(oit.data.list_it) { + ret.type = MB_DT_INT; + ret.value.integer = 1; + } else { + ret.type = MB_DT_NIL; + } + + break; + case MB_DT_DICT_IT: + _public_value_to_internal_object(&it, &oit); + oit.data.dict_it = _move_dict_it_next(oit.data.dict_it); + if(oit.data.dict_it) { + ret.type = MB_DT_INT; + ret.value.integer = 1; + } else { + ret.type = MB_DT_NIL; + } + + break; + default: + _handle_error_on_obj(s, SE_RN_ITERATOR_EXPECTED, 0, TON(l), MB_FUNC_ERR, _exit, result); + + break; + } + + mb_check(mb_push_value(s, l, ret)); + +_exit: + return result; +} +#endif /* MB_ENABLE_COLLECTION_LIB */ + /* ========================================================} */ #ifdef MB_COMPACT_MODE diff --git a/core/my_basic.h b/core/my_basic.h index c01fe7c..56af7c0 100755 --- a/core/my_basic.h +++ b/core/my_basic.h @@ -42,6 +42,10 @@ extern "C" { # define MB_MAX_DIMENSION_COUNT 4 #endif /* MB_MAX_DIMENSION_COUNT */ +#ifndef MB_ENABLE_COLLECTION_LIB +# define MB_ENABLE_COLLECTION_LIB +#endif /* MB_ENABLE_COLLECTION_LIB */ + #ifndef MB_ENABLE_ALLOC_STAT # define MB_ENABLE_ALLOC_STAT #endif /* MB_ENABLE_ALLOC_STAT */ @@ -215,6 +219,7 @@ typedef enum mb_error_e { SE_RN_TYPE_NOT_MATCH, SE_RN_INVALID_STRING, SE_RN_INDEX_OUT_OF_BOUND, + SE_RN_CANNOT_FIND_WITH_GIVEN_INDEX, SE_RN_ILLEGAL_BOUND, SE_RN_DIMENSION_TOO_MUCH, SE_RN_OPERATION_FAILED, @@ -254,6 +259,11 @@ typedef enum mb_error_e { SE_RN_DONT_MIX_INSTRUCTIONAL_AND_STRUCTURED, SE_RN_ROUTINE_EXPECTED, SE_RN_DUPLICATE_ROUTINE, + SE_RN_COLLECTION_EXPECTED, + SE_RN_ITERATOR_EXPECTED, + SE_RN_COLLECTION_OR_ITERATOR_EXPECTED, + SE_RN_INVALID_ITERATOR, + SE_RN_EMPTY_COLLECTION, /** Extended abort */ SE_EA_EXTENDED_ABORT, /** Extra */ @@ -262,21 +272,35 @@ typedef enum mb_error_e { typedef enum mb_data_e { MB_DT_NIL = 0, - MB_DT_INT = 1 << 1, - MB_DT_REAL = 1 << 2, - MB_DT_STRING = 1 << 3, - MB_DT_USERTYPE = 1 << 4, - MB_DT_CLASS = 1 << 5, - MB_DT_ARRAY = 1 << 12 + MB_DT_UNKNOWN = 1 << 1, + MB_DT_TYPE = 1 << 2, + MB_DT_INT = 1 << 3, + MB_DT_REAL = 1 << 4, + MB_DT_STRING = 1 << 5, + MB_DT_USERTYPE = 1 << 6, + MB_DT_ARRAY = 1 << 12, +#ifdef MB_ENABLE_COLLECTION_LIB + MB_DT_LIST = 1 << 13, + MB_DT_LIST_IT = 1 << 14, + MB_DT_DICT = 1 << 15, + MB_DT_DICT_IT = 1 << 16 +#endif /* MB_ENABLE_COLLECTION_LIB */ } mb_data_e; typedef union mb_value_u { + mb_data_e type; int_t integer; real_t float_point; char* string; void* usertype; void* instance; void* array; +#ifdef MB_ENABLE_COLLECTION_LIB + void* list; + void* list_it; + void* dict; + void* dict_it; +#endif /* MB_ENABLE_COLLECTION_LIB */ } mb_value_u; typedef struct mb_value_t { @@ -342,6 +366,7 @@ MBAPI int mb_debug_get(struct mb_interpreter_t* s, const char* n, mb_value_t* va MBAPI int mb_debug_set(struct mb_interpreter_t* s, const char* n, mb_value_t val); MBAPI int mb_debug_set_stepped_handler(struct mb_interpreter_t* s, mb_debug_stepped_handler_t h); +MBAPI const char* mb_get_type_string(mb_data_e t); MBAPI mb_error_e mb_get_last_error(struct mb_interpreter_t* s); MBAPI const char* mb_get_error_desc(mb_error_e err); MBAPI int mb_set_error_handler(struct mb_interpreter_t* s, mb_error_handler_t h); diff --git a/output/my_basic.exe b/output/my_basic.exe index cc73d82b78c66afa7ccd0c4270e3e4b091856159..be690deb7bfe4abdd5197c8e00a31e043b42db9c 100755 GIT binary patch literal 96256 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 t|P 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 literal 79872 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 diff --git a/output/my_basic_mac b/output/my_basic_mac index 8a775c5bb5686c2c3c2500819dd0722d5a307702..8421b87d9b53d009ec727d5289183455e6a20055 100755 GIT binary patch literal 125496 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ΠMF(miCY882;20$q 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 U#mZ_hLK;*$!`GyS@FnK|1CwpCivR!s diff --git a/shell/main.c b/shell/main.c index 7dbd394..d2cdc5f 100755 --- a/shell/main.c +++ b/shell/main.c @@ -131,6 +131,8 @@ static int pool_count = 0; static _pool_t* pool = 0; +static long alloc_count = 0; + #define _POOL_NODE_ALLOC(size) (((char*)malloc(sizeof(_pool_tag_t) + size)) + sizeof(_pool_tag_t)) #define _POOL_NODE_PTR(s) (s - sizeof(_pool_tag_t)) #define _POOL_NODE_NEXT(s) (*((void**)(s - sizeof(_pool_tag_t)))) @@ -217,12 +219,14 @@ static char* _pop_mem(unsigned s) { result = pl->stack; pl->stack = _POOL_NODE_NEXT(result); _POOL_NODE_SIZE(result) = (_pool_chunk_size_t)s; + ++alloc_count; return result; } else { /* Create a new node */ result = _POOL_NODE_ALLOC(s); _POOL_NODE_SIZE(result) = (_pool_chunk_size_t)s; + ++alloc_count; return result; } @@ -233,6 +237,7 @@ static char* _pop_mem(unsigned s) { /* Allocate directly */ result = _POOL_NODE_ALLOC(s); _POOL_NODE_SIZE(result) = (_pool_chunk_size_t)0; + ++alloc_count; return result; } @@ -241,6 +246,10 @@ static void _push_mem(char* p) { int i = 0; _pool_t* pl = 0; + if(--alloc_count < 0) { + mb_assert(0 && "Multiple free"); + } + if(pool_count) { for(i = 0; i < pool_count; i++) { pl = &pool[i]; @@ -840,6 +849,9 @@ static void _on_exit(void) { c = 0; #ifdef _USE_MEM_POOL + if(alloc_count > 0) { + mb_assert(0 && "Memory leak"); + } _close_mem_pool(); #endif /* _USE_MEM_POOL */