From e2eaf24ab4c9d321930d840d31252555e774664f Mon Sep 17 00:00:00 2001 From: Benjamin Vedder Date: Fri, 10 May 2024 10:53:33 +0200 Subject: [PATCH] Squashed 'lispBM/lispBM/' changes from 85675e29..fe287450 fe287450 Fix bug in GC related to callcc using the lisp-array as its storage. Also renaming for compatibility with old C code that interfaces with LBM git-subtree-dir: lispBM/lispBM git-subtree-split: fe287450786605c3118397d25a7246e0c35eeedf --- include/heap.h | 8 ++--- include/lbm_defines.h | 58 +++++++++++++++---------------- repl/repl_exts.c | 11 ++++-- src/eval_cps.c | 10 +++--- src/extensions/array_extensions.c | 2 +- src/fundamental.c | 8 ++--- src/heap.c | 26 +++++++------- src/lbm_c_interop.c | 4 +-- src/lbm_flat_value.c | 12 +++---- src/print.c | 4 +-- src/symrepr.c | 8 ++--- 11 files changed, 79 insertions(+), 72 deletions(-) diff --git a/include/heap.h b/include/heap.h index 9323629c..4881f00b 100644 --- a/include/heap.h +++ b/include/heap.h @@ -830,20 +830,20 @@ static inline bool lbm_is_number(lbm_value x) { */ static inline bool lbm_is_array_r(lbm_value 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) { - 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) { 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) { - 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)); } diff --git a/include/lbm_defines.h b/include/lbm_defines.h index 3dd434c1..6f0dc32f 100644 --- a/include/lbm_defines.h +++ b/include/lbm_defines.h @@ -50,12 +50,12 @@ #define LBM_TYPE_U64 0x58000000u #define LBM_TYPE_FLOAT 0x68000000u #define LBM_TYPE_DOUBLE 0x78000000u -#define LBM_TYPE_BYTEARRAY 0x80000000u -#define LBM_TYPE_BYTEARRAY_CONST 0x84000000u +#define LBM_TYPE_ARRAY 0x80000000u // ByteArray +#define LBM_TYPE_ARRAY_CONST 0x84000000u #define LBM_TYPE_CHANNEL 0x90000000u #define LBM_TYPE_CUSTOM 0xA0000000u -#define LBM_TYPE_ARRAY 0xB0000000u // a "real" array -#define LBM_TYPE_ARRAY_CONST 0xB4000000u +#define LBM_TYPE_LISPARRAY 0xB0000000u // a "real" array +#define LBM_TYPE_LISPARRAY_CONST 0xB4000000u #define LBM_NON_CONS_POINTER_TYPE_LAST 0xBC000000u #define LBM_POINTER_TYPE_LAST 0xBC000000u @@ -103,12 +103,12 @@ #define LBM_TYPE_I64 (lbm_uint)0x2800000000000000 #define LBM_TYPE_U64 (lbm_uint)0x3800000000000000 #define LBM_TYPE_DOUBLE (lbm_uint)0x4800000000000000 -#define LBM_TYPE_BYTEARRAY (lbm_uint)0x5000000000000000 -#define LBM_TYPE_BYTEARRAY_CONST (lbm_uint)0x5400000000000000 +#define LBM_TYPE_ARRAY (lbm_uint)0x5000000000000000 +#define LBM_TYPE_ARRAY_CONST (lbm_uint)0x5400000000000000 #define LBM_TYPE_CHANNEL (lbm_uint)0x7000000000000000 #define LBM_TYPE_CUSTOM (lbm_uint)0x8000000000000000 -#define LBM_TYPE_ARRAY (lbm_uint)0x9000000000000000 -#define LBM_TYPE_ARRAY_CONST (lbm_uint)0x9400000000000000 +#define LBM_TYPE_LISPARRAY (lbm_uint)0x9000000000000000 +#define LBM_TYPE_LISPARRAY_CONST (lbm_uint)0x9400000000000000 #define LBM_NON_CONS_POINTER_TYPE_LAST (lbm_uint)0x9000000000000000 #define LBM_POINTER_TYPE_LAST (lbm_uint)0x9F00000000000000 @@ -162,7 +162,7 @@ //#define TYPE_CLASSIFIER_STARTS 0x30 -#define SYM_BYTEARRAY_TYPE 0x30 +#define SYM_ARRAY_TYPE 0x30 #define SYM_RAW_I_TYPE 0x31 #define SYM_RAW_U_TYPE 0x32 #define SYM_RAW_F_TYPE 0x33 @@ -171,7 +171,7 @@ #define SYM_IND_F_TYPE 0x36 #define SYM_CHANNEL_TYPE 0x37 #define SYM_CUSTOM_TYPE 0x38 -#define SYM_ARRAY_TYPE 0x39 +#define SYM_LISPARRAY_TYPE 0x39 //#define TYPE_CLASSIFIER_ENDS 0x39 #define SYM_NONSENSE 0x3A @@ -179,21 +179,21 @@ #define SYM_MATCH_ANY 0x41 // Type identifying symbols -#define SYM_TYPE_LIST 0x50 -#define SYM_TYPE_I 0x51 -#define SYM_TYPE_U 0x52 -#define SYM_TYPE_FLOAT 0x53 -#define SYM_TYPE_I32 0x54 -#define SYM_TYPE_U32 0x55 -#define SYM_TYPE_DOUBLE 0x56 -#define SYM_TYPE_I64 0x57 -#define SYM_TYPE_U64 0x58 -#define SYM_TYPE_BYTEARRAY 0x59 -#define SYM_TYPE_SYMBOL 0x5A -#define SYM_TYPE_CHAR 0x5B -#define SYM_TYPE_BYTE 0x5C -#define SYM_TYPE_CHANNEL 0x5E -#define SYM_TYPE_ARRAY 0x5F +#define SYM_TYPE_LIST 0x50 +#define SYM_TYPE_I 0x51 +#define SYM_TYPE_U 0x52 +#define SYM_TYPE_FLOAT 0x53 +#define SYM_TYPE_I32 0x54 +#define SYM_TYPE_U32 0x55 +#define SYM_TYPE_DOUBLE 0x56 +#define SYM_TYPE_I64 0x57 +#define SYM_TYPE_U64 0x58 +#define SYM_TYPE_ARRAY 0x59 +#define SYM_TYPE_SYMBOL 0x5A +#define SYM_TYPE_CHAR 0x5B +#define SYM_TYPE_BYTE 0x5C +#define SYM_TYPE_CHANNEL 0x5E +#define SYM_TYPE_LISPARRAY 0x5F //Relevant for the tokenizer and reader #define TOKENIZER_SYMBOLS_START 0x70 @@ -396,7 +396,7 @@ #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_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_U_TYPE ENC_SYM(SYM_RAW_U_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_CHANNEL_TYPE ENC_SYM(SYM_CHANNEL_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_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_I64 ENC_SYM(SYM_TYPE_I64) #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_CHAR ENC_SYM(SYM_TYPE_CHAR) #define ENC_SYM_TYPE_BYTE ENC_SYM(SYM_TYPE_BYTE) #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_CLOSEPAR ENC_SYM(SYM_CLOSEPAR) diff --git a/repl/repl_exts.c b/repl/repl_exts.c index e0cae3db..b8e25278 100644 --- a/repl/repl_exts.c +++ b/repl/repl_exts.c @@ -509,7 +509,7 @@ static lbm_value ext_exec(lbm_value *args, lbm_uint argn) { lbm_value res = ENC_SYM_TERROR; int pid; - + if (all_arrays(args, argn) && argn >= 1) { char **strs = malloc(argn * sizeof(char*) + 1); for (uint32_t i = 0; i < argn; i ++) { @@ -527,7 +527,7 @@ static lbm_value ext_exec(lbm_value *args, lbm_uint argn) { res = ENC_SYM_TRUE; } } - return res; + return res; } static lbm_value ext_unsafe_call_system(lbm_value *args, lbm_uint argn) { @@ -565,6 +565,13 @@ int init_exts(void) { 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("exec", ext_exec); lbm_add_extension("fopen", ext_fopen); diff --git a/src/eval_cps.c b/src/eval_cps.c index f9888a9e..ff0735bb 100644 --- a/src/eval_cps.c +++ b/src/eval_cps.c @@ -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), &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)); } @@ -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) { if (nargs == 1) { 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)) { gc(); 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) { - 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; 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); #endif } break; - case ENC_SYM_ARRAY_TYPE: { + case ENC_SYM_LISPARRAY_TYPE: { lbm_array_header_t *arr = (lbm_array_header_t*)ref->car; lbm_uint size = arr->size / sizeof(lbm_uint); lbm_uint flash_addr; @@ -4465,7 +4465,7 @@ static void cont_move_val_to_flash_dispatch(eval_context_t *ctx) { ctx->app_cont = true; return; } - case ENC_SYM_BYTEARRAY_TYPE: { + case ENC_SYM_ARRAY_TYPE: { lbm_array_header_t *arr = (lbm_array_header_t*)ref->car; // arbitrary address: flash_arr. lbm_uint flash_arr; diff --git a/src/extensions/array_extensions.c b/src/extensions/array_extensions.c index 6f3c5800..85c55eb1 100644 --- a/src/extensions/array_extensions.c +++ b/src/extensions/array_extensions.c @@ -98,7 +98,7 @@ lbm_value array_extension_unsafe_free_array(lbm_value *args, lbm_uint argn) { lbm_value res = ENC_SYM_EERROR; if (argn != 1 || - lbm_type_of(args[0]) != LBM_TYPE_BYTEARRAY) { + lbm_type_of(args[0]) != LBM_TYPE_ARRAY) { return res; } lbm_array_header_t *array = (lbm_array_header_t *)lbm_car(args[0]); diff --git a/src/fundamental.c b/src/fundamental.c index 68104a24..83bc4b99 100644 --- a/src/fundamental.c +++ b/src/fundamental.c @@ -315,9 +315,9 @@ bool struct_eq(lbm_value a, lbm_value b) { return (lbm_dec_u64(a) == lbm_dec_u64(b)); case LBM_TYPE_DOUBLE: return (lbm_dec_double(a) == lbm_dec_double(b)); - case LBM_TYPE_BYTEARRAY: - return bytearray_equality(a, b); case LBM_TYPE_ARRAY: + return bytearray_equality(a, b); + case LBM_TYPE_LISPARRAY: 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) { 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_U32: return ENC_SYM_TYPE_U32; 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_CHAR: return ENC_SYM_TYPE_CHAR; 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; } diff --git a/src/heap.c b/src/heap.c index 234dc044..f4a8e817 100644 --- a/src/heap.c +++ b/src/heap.c @@ -693,12 +693,12 @@ void lbm_gc_mark_phase(lbm_value root) { // 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 // has progressed. - if (t_ptr == LBM_TYPE_ARRAY) { + if (t_ptr == LBM_TYPE_LISPARRAY) { lbm_push(s, curr); // put array back as bookkeeping. lbm_array_header_extended_t *arr = (lbm_array_header_extended_t*)cell->car; lbm_value *arrdata = (lbm_value *)arr->data; 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)) { lbm_cons_t *elt = &lbm_heap_state.heap[lbm_dec_ptr(arrdata[index])]; if (!lbm_get_gc_mark(elt->cdr)) { @@ -791,8 +791,8 @@ int lbm_gc_sweep_phase(void) { case ENC_SYM_IND_F_TYPE: lbm_memory_free((lbm_uint*)heap[i].car); break; - case ENC_SYM_ARRAY_TYPE: /* fall through */ - case ENC_SYM_BYTEARRAY_TYPE:{ + case ENC_SYM_LISPARRAY_TYPE: /* fall through */ + case ENC_SYM_ARRAY_TYPE:{ lbm_array_header_t *arr = (lbm_array_header_t*)heap[i].car; if (lbm_memory_ptr_inside((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; - 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. 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) { @@ -1116,11 +1116,11 @@ int lbm_heap_allocate_array_base(lbm_value *res, bool byte_array, lbm_uint size) return 0; } - lbm_uint tag = ENC_SYM_BYTEARRAY_TYPE; - lbm_uint type = LBM_TYPE_BYTEARRAY; + lbm_uint tag = ENC_SYM_ARRAY_TYPE; + lbm_uint type = LBM_TYPE_ARRAY; if (!byte_array) { - tag = ENC_SYM_ARRAY_TYPE; - type = LBM_TYPE_ARRAY; + tag = ENC_SYM_LISPARRAY_TYPE; + type = LBM_TYPE_LISPARRAY; size = sizeof(lbm_value) * size; lbm_array_header_extended_t *ext_array = (lbm_array_header_extended_t*)array; 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) { 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 *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); - cell = lbm_set_ptr_type(cell, LBM_TYPE_BYTEARRAY); + cell = lbm_set_ptr_type(cell, LBM_TYPE_ARRAY); *value = cell; return 1; } diff --git a/src/lbm_c_interop.c b/src/lbm_c_interop.c index 0e3c2406..2d5a4955 100644 --- a/src/lbm_c_interop.c +++ b/src/lbm_c_interop.c @@ -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; s = write_const_car(flash_cell, flash_array_header_ptr); 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; return true; } int lbm_share_const_array(lbm_value *res, char *flash_ptr, lbm_uint num_elt) { lbm_value arr = 0; - arr = LBM_PTR_BIT | LBM_TYPE_BYTEARRAY; + arr = LBM_PTR_BIT | LBM_TYPE_ARRAY; lbm_value flash_arr = 0; lbm_flash_status r = request_flash_storage_cell(arr, &flash_arr); diff --git a/src/lbm_flat_value.c b/src/lbm_flat_value.c index e592ce33..b29330b5 100644 --- a/src/lbm_flat_value.c +++ b/src/lbm_flat_value.c @@ -272,7 +272,7 @@ int flatten_value_size_internal(jmp_buf jb, lbm_value v, int depth) { } return 0; // already terminated with error } - case LBM_TYPE_ARRAY: { + case LBM_TYPE_LISPARRAY: { int sum = 4 + 1; // sizeof(uint32_t) + 1; lbm_array_header_t *header = (lbm_array_header_t*)lbm_car(v); 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; flatten_error(jb, (int)s); } return 0; // already terminated with error - case LBM_TYPE_BYTEARRAY: { + case LBM_TYPE_ARRAY: { // Platform dependent size. // TODO: Something needs to be done to these inconsistencies. 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; } }break; - case LBM_TYPE_ARRAY: { + case LBM_TYPE_LISPARRAY: { lbm_array_header_t *header = (lbm_array_header_t*)lbm_car(v); lbm_value *arrdata = (lbm_value*)header->data; 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; } } break; - case LBM_TYPE_BYTEARRAY: { + case LBM_TYPE_ARRAY: { lbm_int s = lbm_heap_array_get_size(v); const uint8_t *d = lbm_heap_array_get_data_ro(v); if (s > 0 && d != NULL) { @@ -448,7 +448,7 @@ lbm_value flatten_value(lbm_value v) { 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) { lbm_set_car_and_cdr(array_cell, ENC_SYM_NIL, ENC_SYM_NIL); return ENC_SYM_MERROR; @@ -484,7 +484,7 @@ lbm_value flatten_value(lbm_value v) { array->data = (lbm_uint*)fv.buf; array->size = fv.buf_size; 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; } else { flatten_error(jb, FLATTEN_VALUE_ERROR_FATAL); diff --git a/src/print.c b/src/print.c index f0ef2244..e29794ff 100644 --- a/src/print.c +++ b/src/print.c @@ -464,10 +464,10 @@ static int lbm_print_internal(lbm_char_channel_t *chan, lbm_value v) { case LBM_TYPE_CHANNEL: r = print_emit_channel(chan, curr); break; - case LBM_TYPE_BYTEARRAY: + case LBM_TYPE_ARRAY: r = print_emit_bytearray(chan, curr); break; - case LBM_TYPE_ARRAY: { + case LBM_TYPE_LISPARRAY: { lbm_value cont[2] = {curr, START_ARRAY}; int res = push_n(&print_stack, cont, 2); if (!res) { diff --git a/src/symrepr.c b/src/symrepr.c index 84c5e8d5..77d676b0 100644 --- a/src/symrepr.c +++ b/src/symrepr.c @@ -97,7 +97,7 @@ special_sym const special_symbols[] = { {"flash_full" , SYM_ERROR_FLASH_HEAP_FULL}, // Special symbols with unparsable names - {"$barray" , SYM_BYTEARRAY_TYPE}, + {"$barray" , SYM_ARRAY_TYPE}, {"$raw_i" , SYM_RAW_I_TYPE}, {"$raw_u" , SYM_RAW_U_TYPE}, {"$raw_f" , SYM_RAW_F_TYPE}, @@ -107,7 +107,7 @@ special_sym const special_symbols[] = { {"$channel" , SYM_CHANNEL_TYPE}, {"$recovered" , SYM_RECOVERED}, {"$custom" , SYM_CUSTOM_TYPE}, - {"$array" , SYM_ARRAY_TYPE}, + {"$array" , SYM_LISPARRAY_TYPE}, {"$nonsense" , SYM_NONSENSE}, // tokenizer symbols with unparsable names @@ -136,12 +136,12 @@ special_sym const special_symbols[] = { {"type-double" , SYM_TYPE_DOUBLE}, {"type-i64" , SYM_TYPE_I64}, {"type-u64" , SYM_TYPE_U64}, - {"type-array" , SYM_TYPE_BYTEARRAY}, + {"type-array" , SYM_TYPE_ARRAY}, {"type-symbol" , SYM_TYPE_SYMBOL}, {"type-char" , SYM_TYPE_CHAR}, {"type-byte" , SYM_TYPE_BYTE}, {"type-channel" , SYM_TYPE_CHANNEL}, - {"type-lisparray" , SYM_TYPE_ARRAY}, + {"type-lisparray" , SYM_TYPE_LISPARRAY}, // Fundamental operations {"+" , SYM_ADD},