mirror of https://github.com/rusefi/bldc.git
Merge commit 'e2eaf24ab4c9d321930d840d31252555e774664f'
This commit is contained in:
commit
2daceff057
|
@ -830,20 +830,20 @@ static inline bool lbm_is_number(lbm_value x) {
|
||||||
*/
|
*/
|
||||||
static inline bool lbm_is_array_r(lbm_value x) {
|
static inline bool lbm_is_array_r(lbm_value x) {
|
||||||
lbm_type t = lbm_type_of(x);
|
lbm_type t = lbm_type_of(x);
|
||||||
return ((t & LBM_PTR_TO_CONSTANT_MASK) == LBM_TYPE_BYTEARRAY);
|
return ((t & LBM_PTR_TO_CONSTANT_MASK) == LBM_TYPE_ARRAY);
|
||||||
}
|
}
|
||||||
|
|
||||||
static inline bool lbm_is_array_rw(lbm_value x) {
|
static inline bool lbm_is_array_rw(lbm_value x) {
|
||||||
return( (lbm_type_of(x) == LBM_TYPE_BYTEARRAY) && !(x & LBM_PTR_TO_CONSTANT_BIT));
|
return( (lbm_type_of(x) == LBM_TYPE_ARRAY) && !(x & LBM_PTR_TO_CONSTANT_BIT));
|
||||||
}
|
}
|
||||||
|
|
||||||
static inline bool lbm_is_lisp_array_r(lbm_value x) {
|
static inline bool lbm_is_lisp_array_r(lbm_value x) {
|
||||||
lbm_type t = lbm_type_of(x);
|
lbm_type t = lbm_type_of(x);
|
||||||
return ((t & LBM_PTR_TO_CONSTANT_MASK) == LBM_TYPE_ARRAY);
|
return ((t & LBM_PTR_TO_CONSTANT_MASK) == LBM_TYPE_LISPARRAY);
|
||||||
}
|
}
|
||||||
|
|
||||||
static inline bool lbm_is_lisp_array_rw(lbm_value x) {
|
static inline bool lbm_is_lisp_array_rw(lbm_value x) {
|
||||||
return( (lbm_type_of(x) == LBM_TYPE_ARRAY) && !(x & LBM_PTR_TO_CONSTANT_BIT));
|
return( (lbm_type_of(x) == LBM_TYPE_LISPARRAY) && !(x & LBM_PTR_TO_CONSTANT_BIT));
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
|
@ -50,12 +50,12 @@
|
||||||
#define LBM_TYPE_U64 0x58000000u
|
#define LBM_TYPE_U64 0x58000000u
|
||||||
#define LBM_TYPE_FLOAT 0x68000000u
|
#define LBM_TYPE_FLOAT 0x68000000u
|
||||||
#define LBM_TYPE_DOUBLE 0x78000000u
|
#define LBM_TYPE_DOUBLE 0x78000000u
|
||||||
#define LBM_TYPE_BYTEARRAY 0x80000000u
|
#define LBM_TYPE_ARRAY 0x80000000u // ByteArray
|
||||||
#define LBM_TYPE_BYTEARRAY_CONST 0x84000000u
|
#define LBM_TYPE_ARRAY_CONST 0x84000000u
|
||||||
#define LBM_TYPE_CHANNEL 0x90000000u
|
#define LBM_TYPE_CHANNEL 0x90000000u
|
||||||
#define LBM_TYPE_CUSTOM 0xA0000000u
|
#define LBM_TYPE_CUSTOM 0xA0000000u
|
||||||
#define LBM_TYPE_ARRAY 0xB0000000u // a "real" array
|
#define LBM_TYPE_LISPARRAY 0xB0000000u // a "real" array
|
||||||
#define LBM_TYPE_ARRAY_CONST 0xB4000000u
|
#define LBM_TYPE_LISPARRAY_CONST 0xB4000000u
|
||||||
#define LBM_NON_CONS_POINTER_TYPE_LAST 0xBC000000u
|
#define LBM_NON_CONS_POINTER_TYPE_LAST 0xBC000000u
|
||||||
#define LBM_POINTER_TYPE_LAST 0xBC000000u
|
#define LBM_POINTER_TYPE_LAST 0xBC000000u
|
||||||
|
|
||||||
|
@ -103,12 +103,12 @@
|
||||||
#define LBM_TYPE_I64 (lbm_uint)0x2800000000000000
|
#define LBM_TYPE_I64 (lbm_uint)0x2800000000000000
|
||||||
#define LBM_TYPE_U64 (lbm_uint)0x3800000000000000
|
#define LBM_TYPE_U64 (lbm_uint)0x3800000000000000
|
||||||
#define LBM_TYPE_DOUBLE (lbm_uint)0x4800000000000000
|
#define LBM_TYPE_DOUBLE (lbm_uint)0x4800000000000000
|
||||||
#define LBM_TYPE_BYTEARRAY (lbm_uint)0x5000000000000000
|
#define LBM_TYPE_ARRAY (lbm_uint)0x5000000000000000
|
||||||
#define LBM_TYPE_BYTEARRAY_CONST (lbm_uint)0x5400000000000000
|
#define LBM_TYPE_ARRAY_CONST (lbm_uint)0x5400000000000000
|
||||||
#define LBM_TYPE_CHANNEL (lbm_uint)0x7000000000000000
|
#define LBM_TYPE_CHANNEL (lbm_uint)0x7000000000000000
|
||||||
#define LBM_TYPE_CUSTOM (lbm_uint)0x8000000000000000
|
#define LBM_TYPE_CUSTOM (lbm_uint)0x8000000000000000
|
||||||
#define LBM_TYPE_ARRAY (lbm_uint)0x9000000000000000
|
#define LBM_TYPE_LISPARRAY (lbm_uint)0x9000000000000000
|
||||||
#define LBM_TYPE_ARRAY_CONST (lbm_uint)0x9400000000000000
|
#define LBM_TYPE_LISPARRAY_CONST (lbm_uint)0x9400000000000000
|
||||||
#define LBM_NON_CONS_POINTER_TYPE_LAST (lbm_uint)0x9000000000000000
|
#define LBM_NON_CONS_POINTER_TYPE_LAST (lbm_uint)0x9000000000000000
|
||||||
#define LBM_POINTER_TYPE_LAST (lbm_uint)0x9F00000000000000
|
#define LBM_POINTER_TYPE_LAST (lbm_uint)0x9F00000000000000
|
||||||
|
|
||||||
|
@ -162,7 +162,7 @@
|
||||||
|
|
||||||
|
|
||||||
//#define TYPE_CLASSIFIER_STARTS 0x30
|
//#define TYPE_CLASSIFIER_STARTS 0x30
|
||||||
#define SYM_BYTEARRAY_TYPE 0x30
|
#define SYM_ARRAY_TYPE 0x30
|
||||||
#define SYM_RAW_I_TYPE 0x31
|
#define SYM_RAW_I_TYPE 0x31
|
||||||
#define SYM_RAW_U_TYPE 0x32
|
#define SYM_RAW_U_TYPE 0x32
|
||||||
#define SYM_RAW_F_TYPE 0x33
|
#define SYM_RAW_F_TYPE 0x33
|
||||||
|
@ -171,7 +171,7 @@
|
||||||
#define SYM_IND_F_TYPE 0x36
|
#define SYM_IND_F_TYPE 0x36
|
||||||
#define SYM_CHANNEL_TYPE 0x37
|
#define SYM_CHANNEL_TYPE 0x37
|
||||||
#define SYM_CUSTOM_TYPE 0x38
|
#define SYM_CUSTOM_TYPE 0x38
|
||||||
#define SYM_ARRAY_TYPE 0x39
|
#define SYM_LISPARRAY_TYPE 0x39
|
||||||
//#define TYPE_CLASSIFIER_ENDS 0x39
|
//#define TYPE_CLASSIFIER_ENDS 0x39
|
||||||
#define SYM_NONSENSE 0x3A
|
#define SYM_NONSENSE 0x3A
|
||||||
|
|
||||||
|
@ -179,21 +179,21 @@
|
||||||
#define SYM_MATCH_ANY 0x41
|
#define SYM_MATCH_ANY 0x41
|
||||||
|
|
||||||
// Type identifying symbols
|
// Type identifying symbols
|
||||||
#define SYM_TYPE_LIST 0x50
|
#define SYM_TYPE_LIST 0x50
|
||||||
#define SYM_TYPE_I 0x51
|
#define SYM_TYPE_I 0x51
|
||||||
#define SYM_TYPE_U 0x52
|
#define SYM_TYPE_U 0x52
|
||||||
#define SYM_TYPE_FLOAT 0x53
|
#define SYM_TYPE_FLOAT 0x53
|
||||||
#define SYM_TYPE_I32 0x54
|
#define SYM_TYPE_I32 0x54
|
||||||
#define SYM_TYPE_U32 0x55
|
#define SYM_TYPE_U32 0x55
|
||||||
#define SYM_TYPE_DOUBLE 0x56
|
#define SYM_TYPE_DOUBLE 0x56
|
||||||
#define SYM_TYPE_I64 0x57
|
#define SYM_TYPE_I64 0x57
|
||||||
#define SYM_TYPE_U64 0x58
|
#define SYM_TYPE_U64 0x58
|
||||||
#define SYM_TYPE_BYTEARRAY 0x59
|
#define SYM_TYPE_ARRAY 0x59
|
||||||
#define SYM_TYPE_SYMBOL 0x5A
|
#define SYM_TYPE_SYMBOL 0x5A
|
||||||
#define SYM_TYPE_CHAR 0x5B
|
#define SYM_TYPE_CHAR 0x5B
|
||||||
#define SYM_TYPE_BYTE 0x5C
|
#define SYM_TYPE_BYTE 0x5C
|
||||||
#define SYM_TYPE_CHANNEL 0x5E
|
#define SYM_TYPE_CHANNEL 0x5E
|
||||||
#define SYM_TYPE_ARRAY 0x5F
|
#define SYM_TYPE_LISPARRAY 0x5F
|
||||||
|
|
||||||
//Relevant for the tokenizer and reader
|
//Relevant for the tokenizer and reader
|
||||||
#define TOKENIZER_SYMBOLS_START 0x70
|
#define TOKENIZER_SYMBOLS_START 0x70
|
||||||
|
@ -396,7 +396,7 @@
|
||||||
#define ENC_SYM_RECOVERED ENC_SYM(SYM_RECOVERED)
|
#define ENC_SYM_RECOVERED ENC_SYM(SYM_RECOVERED)
|
||||||
#define ENC_SYM_ERROR_FLASH_HEAP_FULL ENC_SYM(SYM_ERROR_FLASH_HEAP_FULL)
|
#define ENC_SYM_ERROR_FLASH_HEAP_FULL ENC_SYM(SYM_ERROR_FLASH_HEAP_FULL)
|
||||||
|
|
||||||
#define ENC_SYM_BYTEARRAY_TYPE ENC_SYM(SYM_BYTEARRAY_TYPE)
|
#define ENC_SYM_ARRAY_TYPE ENC_SYM(SYM_ARRAY_TYPE)
|
||||||
#define ENC_SYM_RAW_I_TYPE ENC_SYM(SYM_RAW_I_TYPE)
|
#define ENC_SYM_RAW_I_TYPE ENC_SYM(SYM_RAW_I_TYPE)
|
||||||
#define ENC_SYM_RAW_U_TYPE ENC_SYM(SYM_RAW_U_TYPE)
|
#define ENC_SYM_RAW_U_TYPE ENC_SYM(SYM_RAW_U_TYPE)
|
||||||
#define ENC_SYM_RAW_F_TYPE ENC_SYM(SYM_RAW_F_TYPE)
|
#define ENC_SYM_RAW_F_TYPE ENC_SYM(SYM_RAW_F_TYPE)
|
||||||
|
@ -405,7 +405,7 @@
|
||||||
#define ENC_SYM_IND_F_TYPE ENC_SYM(SYM_IND_F_TYPE)
|
#define ENC_SYM_IND_F_TYPE ENC_SYM(SYM_IND_F_TYPE)
|
||||||
#define ENC_SYM_CHANNEL_TYPE ENC_SYM(SYM_CHANNEL_TYPE)
|
#define ENC_SYM_CHANNEL_TYPE ENC_SYM(SYM_CHANNEL_TYPE)
|
||||||
#define ENC_SYM_CUSTOM_TYPE ENC_SYM(SYM_CUSTOM_TYPE)
|
#define ENC_SYM_CUSTOM_TYPE ENC_SYM(SYM_CUSTOM_TYPE)
|
||||||
#define ENC_SYM_ARRAY_TYPE ENC_SYM(SYM_ARRAY_TYPE)
|
#define ENC_SYM_LISPARRAY_TYPE ENC_SYM(SYM_LISPARRAY_TYPE)
|
||||||
#define ENC_SYM_NONSENSE ENC_SYM(SYM_NONSENSE)
|
#define ENC_SYM_NONSENSE ENC_SYM(SYM_NONSENSE)
|
||||||
|
|
||||||
#define ENC_SYM_NO_MATCH ENC_SYM(SYM_NO_MATCH)
|
#define ENC_SYM_NO_MATCH ENC_SYM(SYM_NO_MATCH)
|
||||||
|
@ -420,12 +420,12 @@
|
||||||
#define ENC_SYM_TYPE_DOUBLE ENC_SYM(SYM_TYPE_DOUBLE)
|
#define ENC_SYM_TYPE_DOUBLE ENC_SYM(SYM_TYPE_DOUBLE)
|
||||||
#define ENC_SYM_TYPE_I64 ENC_SYM(SYM_TYPE_I64)
|
#define ENC_SYM_TYPE_I64 ENC_SYM(SYM_TYPE_I64)
|
||||||
#define ENC_SYM_TYPE_U64 ENC_SYM(SYM_TYPE_U64)
|
#define ENC_SYM_TYPE_U64 ENC_SYM(SYM_TYPE_U64)
|
||||||
#define ENC_SYM_TYPE_BYTEARRAY ENC_SYM(SYM_TYPE_BYTEARRAY)
|
#define ENC_SYM_TYPE_ARRAY ENC_SYM(SYM_TYPE_ARRAY)
|
||||||
#define ENC_SYM_TYPE_SYMBOL ENC_SYM(SYM_TYPE_SYMBOL)
|
#define ENC_SYM_TYPE_SYMBOL ENC_SYM(SYM_TYPE_SYMBOL)
|
||||||
#define ENC_SYM_TYPE_CHAR ENC_SYM(SYM_TYPE_CHAR)
|
#define ENC_SYM_TYPE_CHAR ENC_SYM(SYM_TYPE_CHAR)
|
||||||
#define ENC_SYM_TYPE_BYTE ENC_SYM(SYM_TYPE_BYTE)
|
#define ENC_SYM_TYPE_BYTE ENC_SYM(SYM_TYPE_BYTE)
|
||||||
#define ENC_SYM_TYPE_CHANNEL ENC_SYM(SYM_TYPE_CHANNEL)
|
#define ENC_SYM_TYPE_CHANNEL ENC_SYM(SYM_TYPE_CHANNEL)
|
||||||
#define ENC_SYM_TYPE_ARRAY ENC_SYM(SYM_TYPE_ARRAY)
|
#define ENC_SYM_TYPE_LISPARRAY ENC_SYM(SYM_TYPE_LISPARRAY)
|
||||||
|
|
||||||
#define ENC_SYM_OPENPAR ENC_SYM(SYM_OPENPAR)
|
#define ENC_SYM_OPENPAR ENC_SYM(SYM_OPENPAR)
|
||||||
#define ENC_SYM_CLOSEPAR ENC_SYM(SYM_CLOSEPAR)
|
#define ENC_SYM_CLOSEPAR ENC_SYM(SYM_CLOSEPAR)
|
||||||
|
|
|
@ -565,6 +565,13 @@ int init_exts(void) {
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
lbm_add_symbol_const("a01", &sym_res);
|
||||||
|
lbm_add_symbol_const("a02", &sym_loop);
|
||||||
|
lbm_add_symbol_const("break", &sym_break);
|
||||||
|
lbm_add_symbol_const("a03", &sym_brk);
|
||||||
|
lbm_add_symbol_const("a04", &sym_rst);
|
||||||
|
lbm_add_symbol_const("return", &sym_return);
|
||||||
|
|
||||||
lbm_add_extension("unsafe-call-system", ext_unsafe_call_system);
|
lbm_add_extension("unsafe-call-system", ext_unsafe_call_system);
|
||||||
lbm_add_extension("exec", ext_exec);
|
lbm_add_extension("exec", ext_exec);
|
||||||
lbm_add_extension("fopen", ext_fopen);
|
lbm_add_extension("fopen", ext_fopen);
|
||||||
|
|
|
@ -494,7 +494,7 @@ static void lift_array_flash(lbm_value flash_cell, bool bytearray, char *data,
|
||||||
sizeof(lbm_array_header_t) / sizeof(lbm_uint),
|
sizeof(lbm_array_header_t) / sizeof(lbm_uint),
|
||||||
&flash_array_header_ptr));
|
&flash_array_header_ptr));
|
||||||
handle_flash_status(write_const_car(flash_cell, flash_array_header_ptr));
|
handle_flash_status(write_const_car(flash_cell, flash_array_header_ptr));
|
||||||
lbm_uint t = bytearray ? ENC_SYM_BYTEARRAY_TYPE : ENC_SYM_ARRAY_TYPE;
|
lbm_uint t = bytearray ? ENC_SYM_ARRAY_TYPE : ENC_SYM_LISPARRAY_TYPE;
|
||||||
handle_flash_status(write_const_cdr(flash_cell, t));
|
handle_flash_status(write_const_cdr(flash_cell, t));
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -2193,7 +2193,7 @@ static void apply_setvar(lbm_value *args, lbm_uint nargs, eval_context_t *ctx) {
|
||||||
static void apply_read_base(lbm_value *args, lbm_uint nargs, eval_context_t *ctx, bool program, bool incremental) {
|
static void apply_read_base(lbm_value *args, lbm_uint nargs, eval_context_t *ctx, bool program, bool incremental) {
|
||||||
if (nargs == 1) {
|
if (nargs == 1) {
|
||||||
lbm_value chan = ENC_SYM_NIL;
|
lbm_value chan = ENC_SYM_NIL;
|
||||||
if (lbm_type_of_functional(args[0]) == LBM_TYPE_BYTEARRAY) {
|
if (lbm_type_of_functional(args[0]) == LBM_TYPE_ARRAY) {
|
||||||
if (!create_string_channel(lbm_dec_str(args[0]), &chan)) {
|
if (!create_string_channel(lbm_dec_str(args[0]), &chan)) {
|
||||||
gc();
|
gc();
|
||||||
if (!create_string_channel(lbm_dec_str(args[0]), &chan)) {
|
if (!create_string_channel(lbm_dec_str(args[0]), &chan)) {
|
||||||
|
@ -2538,7 +2538,7 @@ static void apply_flatten(lbm_value *args, lbm_uint nargs, eval_context_t *ctx)
|
||||||
}
|
}
|
||||||
|
|
||||||
static void apply_unflatten(lbm_value *args, lbm_uint nargs, eval_context_t *ctx) {
|
static void apply_unflatten(lbm_value *args, lbm_uint nargs, eval_context_t *ctx) {
|
||||||
if(nargs == 1 && lbm_type_of(args[0]) == LBM_TYPE_BYTEARRAY) {
|
if(nargs == 1 && lbm_type_of(args[0]) == LBM_TYPE_ARRAY) {
|
||||||
lbm_array_header_t *array;
|
lbm_array_header_t *array;
|
||||||
array = (lbm_array_header_t *)get_car(args[0]);
|
array = (lbm_array_header_t *)get_car(args[0]);
|
||||||
|
|
||||||
|
@ -4443,7 +4443,7 @@ static void cont_move_val_to_flash_dispatch(eval_context_t *ctx) {
|
||||||
error_ctx(ENC_SYM_FATAL_ERROR);
|
error_ctx(ENC_SYM_FATAL_ERROR);
|
||||||
#endif
|
#endif
|
||||||
} break;
|
} break;
|
||||||
case ENC_SYM_ARRAY_TYPE: {
|
case ENC_SYM_LISPARRAY_TYPE: {
|
||||||
lbm_array_header_t *arr = (lbm_array_header_t*)ref->car;
|
lbm_array_header_t *arr = (lbm_array_header_t*)ref->car;
|
||||||
lbm_uint size = arr->size / sizeof(lbm_uint);
|
lbm_uint size = arr->size / sizeof(lbm_uint);
|
||||||
lbm_uint flash_addr;
|
lbm_uint flash_addr;
|
||||||
|
@ -4465,7 +4465,7 @@ static void cont_move_val_to_flash_dispatch(eval_context_t *ctx) {
|
||||||
ctx->app_cont = true;
|
ctx->app_cont = true;
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
case ENC_SYM_BYTEARRAY_TYPE: {
|
case ENC_SYM_ARRAY_TYPE: {
|
||||||
lbm_array_header_t *arr = (lbm_array_header_t*)ref->car;
|
lbm_array_header_t *arr = (lbm_array_header_t*)ref->car;
|
||||||
// arbitrary address: flash_arr.
|
// arbitrary address: flash_arr.
|
||||||
lbm_uint flash_arr;
|
lbm_uint flash_arr;
|
||||||
|
|
|
@ -98,7 +98,7 @@ lbm_value array_extension_unsafe_free_array(lbm_value *args, lbm_uint argn) {
|
||||||
|
|
||||||
lbm_value res = ENC_SYM_EERROR;
|
lbm_value res = ENC_SYM_EERROR;
|
||||||
if (argn != 1 ||
|
if (argn != 1 ||
|
||||||
lbm_type_of(args[0]) != LBM_TYPE_BYTEARRAY) {
|
lbm_type_of(args[0]) != LBM_TYPE_ARRAY) {
|
||||||
return res;
|
return res;
|
||||||
}
|
}
|
||||||
lbm_array_header_t *array = (lbm_array_header_t *)lbm_car(args[0]);
|
lbm_array_header_t *array = (lbm_array_header_t *)lbm_car(args[0]);
|
||||||
|
|
|
@ -315,9 +315,9 @@ bool struct_eq(lbm_value a, lbm_value b) {
|
||||||
return (lbm_dec_u64(a) == lbm_dec_u64(b));
|
return (lbm_dec_u64(a) == lbm_dec_u64(b));
|
||||||
case LBM_TYPE_DOUBLE:
|
case LBM_TYPE_DOUBLE:
|
||||||
return (lbm_dec_double(a) == lbm_dec_double(b));
|
return (lbm_dec_double(a) == lbm_dec_double(b));
|
||||||
case LBM_TYPE_BYTEARRAY:
|
|
||||||
return bytearray_equality(a, b);
|
|
||||||
case LBM_TYPE_ARRAY:
|
case LBM_TYPE_ARRAY:
|
||||||
|
return bytearray_equality(a, b);
|
||||||
|
case LBM_TYPE_LISPARRAY:
|
||||||
return array_struct_equality(a, b);
|
return array_struct_equality(a, b);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -1267,7 +1267,7 @@ static lbm_value fundamental_type_of(lbm_value *args, lbm_uint nargs, eval_conte
|
||||||
}
|
}
|
||||||
switch(t) {
|
switch(t) {
|
||||||
case LBM_TYPE_CONS: return ENC_SYM_TYPE_LIST;
|
case LBM_TYPE_CONS: return ENC_SYM_TYPE_LIST;
|
||||||
case LBM_TYPE_BYTEARRAY: return ENC_SYM_TYPE_BYTEARRAY;
|
case LBM_TYPE_ARRAY: return ENC_SYM_TYPE_ARRAY;
|
||||||
case LBM_TYPE_I32: return ENC_SYM_TYPE_I32;
|
case LBM_TYPE_I32: return ENC_SYM_TYPE_I32;
|
||||||
case LBM_TYPE_U32: return ENC_SYM_TYPE_U32;
|
case LBM_TYPE_U32: return ENC_SYM_TYPE_U32;
|
||||||
case LBM_TYPE_FLOAT: return ENC_SYM_TYPE_FLOAT;
|
case LBM_TYPE_FLOAT: return ENC_SYM_TYPE_FLOAT;
|
||||||
|
@ -1278,7 +1278,7 @@ static lbm_value fundamental_type_of(lbm_value *args, lbm_uint nargs, eval_conte
|
||||||
case LBM_TYPE_U: return ENC_SYM_TYPE_U;
|
case LBM_TYPE_U: return ENC_SYM_TYPE_U;
|
||||||
case LBM_TYPE_CHAR: return ENC_SYM_TYPE_CHAR;
|
case LBM_TYPE_CHAR: return ENC_SYM_TYPE_CHAR;
|
||||||
case LBM_TYPE_SYMBOL: return ENC_SYM_TYPE_SYMBOL;
|
case LBM_TYPE_SYMBOL: return ENC_SYM_TYPE_SYMBOL;
|
||||||
case LBM_TYPE_ARRAY: return ENC_SYM_TYPE_ARRAY;
|
case LBM_TYPE_LISPARRAY: return ENC_SYM_TYPE_LISPARRAY;
|
||||||
}
|
}
|
||||||
return ENC_SYM_TERROR;
|
return ENC_SYM_TERROR;
|
||||||
}
|
}
|
||||||
|
|
|
@ -693,12 +693,12 @@ void lbm_gc_mark_phase(lbm_value root) {
|
||||||
// An array is marked in O(N) time using an additional 32bit
|
// An array is marked in O(N) time using an additional 32bit
|
||||||
// value per array that keeps track of how far into the array GC
|
// value per array that keeps track of how far into the array GC
|
||||||
// has progressed.
|
// has progressed.
|
||||||
if (t_ptr == LBM_TYPE_ARRAY) {
|
if (t_ptr == LBM_TYPE_LISPARRAY) {
|
||||||
lbm_push(s, curr); // put array back as bookkeeping.
|
lbm_push(s, curr); // put array back as bookkeeping.
|
||||||
lbm_array_header_extended_t *arr = (lbm_array_header_extended_t*)cell->car;
|
lbm_array_header_extended_t *arr = (lbm_array_header_extended_t*)cell->car;
|
||||||
lbm_value *arrdata = (lbm_value *)arr->data;
|
lbm_value *arrdata = (lbm_value *)arr->data;
|
||||||
uint32_t index = arr->index;
|
uint32_t index = arr->index;
|
||||||
if (lbm_is_ptr(arrdata[index]) &&
|
if (lbm_is_ptr(arrdata[index]) && ((arrdata[index] & LBM_PTR_TO_CONSTANT_BIT) == 0) &&
|
||||||
!((arrdata[index] & LBM_CONTINUATION_INTERNAL) == LBM_CONTINUATION_INTERNAL)) {
|
!((arrdata[index] & LBM_CONTINUATION_INTERNAL) == LBM_CONTINUATION_INTERNAL)) {
|
||||||
lbm_cons_t *elt = &lbm_heap_state.heap[lbm_dec_ptr(arrdata[index])];
|
lbm_cons_t *elt = &lbm_heap_state.heap[lbm_dec_ptr(arrdata[index])];
|
||||||
if (!lbm_get_gc_mark(elt->cdr)) {
|
if (!lbm_get_gc_mark(elt->cdr)) {
|
||||||
|
@ -791,8 +791,8 @@ int lbm_gc_sweep_phase(void) {
|
||||||
case ENC_SYM_IND_F_TYPE:
|
case ENC_SYM_IND_F_TYPE:
|
||||||
lbm_memory_free((lbm_uint*)heap[i].car);
|
lbm_memory_free((lbm_uint*)heap[i].car);
|
||||||
break;
|
break;
|
||||||
case ENC_SYM_ARRAY_TYPE: /* fall through */
|
case ENC_SYM_LISPARRAY_TYPE: /* fall through */
|
||||||
case ENC_SYM_BYTEARRAY_TYPE:{
|
case ENC_SYM_ARRAY_TYPE:{
|
||||||
lbm_array_header_t *arr = (lbm_array_header_t*)heap[i].car;
|
lbm_array_header_t *arr = (lbm_array_header_t*)heap[i].car;
|
||||||
if (lbm_memory_ptr_inside((lbm_uint*)arr->data)) {
|
if (lbm_memory_ptr_inside((lbm_uint*)arr->data)) {
|
||||||
lbm_memory_free((lbm_uint *)arr->data);
|
lbm_memory_free((lbm_uint *)arr->data);
|
||||||
|
@ -1104,11 +1104,11 @@ int lbm_heap_allocate_array_base(lbm_value *res, bool byte_array, lbm_uint size)
|
||||||
|
|
||||||
lbm_array_header_t *array = NULL;
|
lbm_array_header_t *array = NULL;
|
||||||
|
|
||||||
if (!byte_array) {
|
if (byte_array) {
|
||||||
|
array = (lbm_array_header_t*)lbm_memory_allocate(sizeof(lbm_array_header_t) / sizeof(lbm_uint));
|
||||||
|
} else {
|
||||||
// an extra 32bit quantity for a GC index.
|
// an extra 32bit quantity for a GC index.
|
||||||
array = (lbm_array_header_t*)lbm_memory_allocate(sizeof(lbm_array_header_extended_t) / sizeof(lbm_uint));
|
array = (lbm_array_header_t*)lbm_memory_allocate(sizeof(lbm_array_header_extended_t) / sizeof(lbm_uint));
|
||||||
} else {
|
|
||||||
array = (lbm_array_header_t*)lbm_memory_allocate(sizeof(lbm_array_header_t) / sizeof(lbm_uint));
|
|
||||||
}
|
}
|
||||||
|
|
||||||
if (array == NULL) {
|
if (array == NULL) {
|
||||||
|
@ -1116,11 +1116,11 @@ int lbm_heap_allocate_array_base(lbm_value *res, bool byte_array, lbm_uint size)
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
lbm_uint tag = ENC_SYM_BYTEARRAY_TYPE;
|
lbm_uint tag = ENC_SYM_ARRAY_TYPE;
|
||||||
lbm_uint type = LBM_TYPE_BYTEARRAY;
|
lbm_uint type = LBM_TYPE_ARRAY;
|
||||||
if (!byte_array) {
|
if (!byte_array) {
|
||||||
tag = ENC_SYM_ARRAY_TYPE;
|
tag = ENC_SYM_LISPARRAY_TYPE;
|
||||||
type = LBM_TYPE_ARRAY;
|
type = LBM_TYPE_LISPARRAY;
|
||||||
size = sizeof(lbm_value) * size;
|
size = sizeof(lbm_value) * size;
|
||||||
lbm_array_header_extended_t *ext_array = (lbm_array_header_extended_t*)array;
|
lbm_array_header_extended_t *ext_array = (lbm_array_header_extended_t*)array;
|
||||||
ext_array->index = 0;
|
ext_array->index = 0;
|
||||||
|
@ -1167,7 +1167,7 @@ int lbm_heap_allocate_lisp_array(lbm_value *res, lbm_uint size) {
|
||||||
int lbm_lift_array(lbm_value *value, char *data, lbm_uint num_elt) {
|
int lbm_lift_array(lbm_value *value, char *data, lbm_uint num_elt) {
|
||||||
|
|
||||||
lbm_array_header_t *array = NULL;
|
lbm_array_header_t *array = NULL;
|
||||||
lbm_value cell = lbm_heap_allocate_cell(LBM_TYPE_CONS, ENC_SYM_NIL, ENC_SYM_BYTEARRAY_TYPE);
|
lbm_value cell = lbm_heap_allocate_cell(LBM_TYPE_CONS, ENC_SYM_NIL, ENC_SYM_ARRAY_TYPE);
|
||||||
|
|
||||||
if (lbm_type_of(cell) == LBM_TYPE_SYMBOL) { // Out of heap memory
|
if (lbm_type_of(cell) == LBM_TYPE_SYMBOL) { // Out of heap memory
|
||||||
*value = cell;
|
*value = cell;
|
||||||
|
@ -1186,7 +1186,7 @@ int lbm_lift_array(lbm_value *value, char *data, lbm_uint num_elt) {
|
||||||
|
|
||||||
lbm_set_car(cell, (lbm_uint)array);
|
lbm_set_car(cell, (lbm_uint)array);
|
||||||
|
|
||||||
cell = lbm_set_ptr_type(cell, LBM_TYPE_BYTEARRAY);
|
cell = lbm_set_ptr_type(cell, LBM_TYPE_ARRAY);
|
||||||
*value = cell;
|
*value = cell;
|
||||||
return 1;
|
return 1;
|
||||||
}
|
}
|
||||||
|
|
|
@ -240,14 +240,14 @@ static bool share_const_array(lbm_value flash_cell, char *data, lbm_uint num_elt
|
||||||
if (s != LBM_FLASH_WRITE_OK) return false;
|
if (s != LBM_FLASH_WRITE_OK) return false;
|
||||||
s = write_const_car(flash_cell, flash_array_header_ptr);
|
s = write_const_car(flash_cell, flash_array_header_ptr);
|
||||||
if (s != LBM_FLASH_WRITE_OK) return false;
|
if (s != LBM_FLASH_WRITE_OK) return false;
|
||||||
s = write_const_cdr(flash_cell, ENC_SYM_BYTEARRAY_TYPE);
|
s = write_const_cdr(flash_cell, ENC_SYM_ARRAY_TYPE);
|
||||||
if (s != LBM_FLASH_WRITE_OK) return false;
|
if (s != LBM_FLASH_WRITE_OK) return false;
|
||||||
return true;
|
return true;
|
||||||
}
|
}
|
||||||
|
|
||||||
int lbm_share_const_array(lbm_value *res, char *flash_ptr, lbm_uint num_elt) {
|
int lbm_share_const_array(lbm_value *res, char *flash_ptr, lbm_uint num_elt) {
|
||||||
lbm_value arr = 0;
|
lbm_value arr = 0;
|
||||||
arr = LBM_PTR_BIT | LBM_TYPE_BYTEARRAY;
|
arr = LBM_PTR_BIT | LBM_TYPE_ARRAY;
|
||||||
|
|
||||||
lbm_value flash_arr = 0;
|
lbm_value flash_arr = 0;
|
||||||
lbm_flash_status r = request_flash_storage_cell(arr, &flash_arr);
|
lbm_flash_status r = request_flash_storage_cell(arr, &flash_arr);
|
||||||
|
|
|
@ -272,7 +272,7 @@ int flatten_value_size_internal(jmp_buf jb, lbm_value v, int depth) {
|
||||||
}
|
}
|
||||||
return 0; // already terminated with error
|
return 0; // already terminated with error
|
||||||
}
|
}
|
||||||
case LBM_TYPE_ARRAY: {
|
case LBM_TYPE_LISPARRAY: {
|
||||||
int sum = 4 + 1; // sizeof(uint32_t) + 1;
|
int sum = 4 + 1; // sizeof(uint32_t) + 1;
|
||||||
lbm_array_header_t *header = (lbm_array_header_t*)lbm_car(v);
|
lbm_array_header_t *header = (lbm_array_header_t*)lbm_car(v);
|
||||||
lbm_value *arrdata = (lbm_value*)header->data;
|
lbm_value *arrdata = (lbm_value*)header->data;
|
||||||
|
@ -304,7 +304,7 @@ int flatten_value_size_internal(jmp_buf jb, lbm_value v, int depth) {
|
||||||
if (s > 0) return 1 + s;
|
if (s > 0) return 1 + s;
|
||||||
flatten_error(jb, (int)s);
|
flatten_error(jb, (int)s);
|
||||||
} return 0; // already terminated with error
|
} return 0; // already terminated with error
|
||||||
case LBM_TYPE_BYTEARRAY: {
|
case LBM_TYPE_ARRAY: {
|
||||||
// Platform dependent size.
|
// Platform dependent size.
|
||||||
// TODO: Something needs to be done to these inconsistencies.
|
// TODO: Something needs to be done to these inconsistencies.
|
||||||
lbm_int s = lbm_heap_array_get_size(v);
|
lbm_int s = lbm_heap_array_get_size(v);
|
||||||
|
@ -346,7 +346,7 @@ int flatten_value_c(lbm_flat_value_t *fv, lbm_value v) {
|
||||||
return fv_r;
|
return fv_r;
|
||||||
}
|
}
|
||||||
}break;
|
}break;
|
||||||
case LBM_TYPE_ARRAY: {
|
case LBM_TYPE_LISPARRAY: {
|
||||||
lbm_array_header_t *header = (lbm_array_header_t*)lbm_car(v);
|
lbm_array_header_t *header = (lbm_array_header_t*)lbm_car(v);
|
||||||
lbm_value *arrdata = (lbm_value*)header->data;
|
lbm_value *arrdata = (lbm_value*)header->data;
|
||||||
lbm_uint size = header->size / sizeof(lbm_value);
|
lbm_uint size = header->size / sizeof(lbm_value);
|
||||||
|
@ -411,7 +411,7 @@ int flatten_value_c(lbm_flat_value_t *fv, lbm_value v) {
|
||||||
return FLATTEN_VALUE_OK;
|
return FLATTEN_VALUE_OK;
|
||||||
}
|
}
|
||||||
} break;
|
} break;
|
||||||
case LBM_TYPE_BYTEARRAY: {
|
case LBM_TYPE_ARRAY: {
|
||||||
lbm_int s = lbm_heap_array_get_size(v);
|
lbm_int s = lbm_heap_array_get_size(v);
|
||||||
const uint8_t *d = lbm_heap_array_get_data_ro(v);
|
const uint8_t *d = lbm_heap_array_get_data_ro(v);
|
||||||
if (s > 0 && d != NULL) {
|
if (s > 0 && d != NULL) {
|
||||||
|
@ -448,7 +448,7 @@ lbm_value flatten_value(lbm_value v) {
|
||||||
|
|
||||||
jmp_buf jb;
|
jmp_buf jb;
|
||||||
|
|
||||||
lbm_value array_cell = lbm_heap_allocate_cell(LBM_TYPE_CONS, ENC_SYM_NIL, ENC_SYM_BYTEARRAY_TYPE);
|
lbm_value array_cell = lbm_heap_allocate_cell(LBM_TYPE_CONS, ENC_SYM_NIL, ENC_SYM_ARRAY_TYPE);
|
||||||
if (lbm_type_of(array_cell) == LBM_TYPE_SYMBOL) {
|
if (lbm_type_of(array_cell) == LBM_TYPE_SYMBOL) {
|
||||||
lbm_set_car_and_cdr(array_cell, ENC_SYM_NIL, ENC_SYM_NIL);
|
lbm_set_car_and_cdr(array_cell, ENC_SYM_NIL, ENC_SYM_NIL);
|
||||||
return ENC_SYM_MERROR;
|
return ENC_SYM_MERROR;
|
||||||
|
@ -484,7 +484,7 @@ lbm_value flatten_value(lbm_value v) {
|
||||||
array->data = (lbm_uint*)fv.buf;
|
array->data = (lbm_uint*)fv.buf;
|
||||||
array->size = fv.buf_size;
|
array->size = fv.buf_size;
|
||||||
lbm_set_car(array_cell, (lbm_uint)array);
|
lbm_set_car(array_cell, (lbm_uint)array);
|
||||||
array_cell = lbm_set_ptr_type(array_cell, LBM_TYPE_BYTEARRAY);
|
array_cell = lbm_set_ptr_type(array_cell, LBM_TYPE_ARRAY);
|
||||||
return array_cell;
|
return array_cell;
|
||||||
} else {
|
} else {
|
||||||
flatten_error(jb, FLATTEN_VALUE_ERROR_FATAL);
|
flatten_error(jb, FLATTEN_VALUE_ERROR_FATAL);
|
||||||
|
|
|
@ -464,10 +464,10 @@ static int lbm_print_internal(lbm_char_channel_t *chan, lbm_value v) {
|
||||||
case LBM_TYPE_CHANNEL:
|
case LBM_TYPE_CHANNEL:
|
||||||
r = print_emit_channel(chan, curr);
|
r = print_emit_channel(chan, curr);
|
||||||
break;
|
break;
|
||||||
case LBM_TYPE_BYTEARRAY:
|
case LBM_TYPE_ARRAY:
|
||||||
r = print_emit_bytearray(chan, curr);
|
r = print_emit_bytearray(chan, curr);
|
||||||
break;
|
break;
|
||||||
case LBM_TYPE_ARRAY: {
|
case LBM_TYPE_LISPARRAY: {
|
||||||
lbm_value cont[2] = {curr, START_ARRAY};
|
lbm_value cont[2] = {curr, START_ARRAY};
|
||||||
int res = push_n(&print_stack, cont, 2);
|
int res = push_n(&print_stack, cont, 2);
|
||||||
if (!res) {
|
if (!res) {
|
||||||
|
|
|
@ -97,7 +97,7 @@ special_sym const special_symbols[] = {
|
||||||
{"flash_full" , SYM_ERROR_FLASH_HEAP_FULL},
|
{"flash_full" , SYM_ERROR_FLASH_HEAP_FULL},
|
||||||
|
|
||||||
// Special symbols with unparsable names
|
// Special symbols with unparsable names
|
||||||
{"$barray" , SYM_BYTEARRAY_TYPE},
|
{"$barray" , SYM_ARRAY_TYPE},
|
||||||
{"$raw_i" , SYM_RAW_I_TYPE},
|
{"$raw_i" , SYM_RAW_I_TYPE},
|
||||||
{"$raw_u" , SYM_RAW_U_TYPE},
|
{"$raw_u" , SYM_RAW_U_TYPE},
|
||||||
{"$raw_f" , SYM_RAW_F_TYPE},
|
{"$raw_f" , SYM_RAW_F_TYPE},
|
||||||
|
@ -107,7 +107,7 @@ special_sym const special_symbols[] = {
|
||||||
{"$channel" , SYM_CHANNEL_TYPE},
|
{"$channel" , SYM_CHANNEL_TYPE},
|
||||||
{"$recovered" , SYM_RECOVERED},
|
{"$recovered" , SYM_RECOVERED},
|
||||||
{"$custom" , SYM_CUSTOM_TYPE},
|
{"$custom" , SYM_CUSTOM_TYPE},
|
||||||
{"$array" , SYM_ARRAY_TYPE},
|
{"$array" , SYM_LISPARRAY_TYPE},
|
||||||
{"$nonsense" , SYM_NONSENSE},
|
{"$nonsense" , SYM_NONSENSE},
|
||||||
|
|
||||||
// tokenizer symbols with unparsable names
|
// tokenizer symbols with unparsable names
|
||||||
|
@ -136,12 +136,12 @@ special_sym const special_symbols[] = {
|
||||||
{"type-double" , SYM_TYPE_DOUBLE},
|
{"type-double" , SYM_TYPE_DOUBLE},
|
||||||
{"type-i64" , SYM_TYPE_I64},
|
{"type-i64" , SYM_TYPE_I64},
|
||||||
{"type-u64" , SYM_TYPE_U64},
|
{"type-u64" , SYM_TYPE_U64},
|
||||||
{"type-array" , SYM_TYPE_BYTEARRAY},
|
{"type-array" , SYM_TYPE_ARRAY},
|
||||||
{"type-symbol" , SYM_TYPE_SYMBOL},
|
{"type-symbol" , SYM_TYPE_SYMBOL},
|
||||||
{"type-char" , SYM_TYPE_CHAR},
|
{"type-char" , SYM_TYPE_CHAR},
|
||||||
{"type-byte" , SYM_TYPE_BYTE},
|
{"type-byte" , SYM_TYPE_BYTE},
|
||||||
{"type-channel" , SYM_TYPE_CHANNEL},
|
{"type-channel" , SYM_TYPE_CHANNEL},
|
||||||
{"type-lisparray" , SYM_TYPE_ARRAY},
|
{"type-lisparray" , SYM_TYPE_LISPARRAY},
|
||||||
|
|
||||||
// Fundamental operations
|
// Fundamental operations
|
||||||
{"+" , SYM_ADD},
|
{"+" , SYM_ADD},
|
||||||
|
|
Loading…
Reference in New Issue