rusefi
/
bldc
mirror of https://github.com/rusefi/bldc.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge commit 'e2eaf24ab4c9d321930d840d31252555e774664f'

This commit is contained in:
Benjamin Vedder 2024-05-10 10:53:33 +02:00
parent e2737ae21b e2eaf24ab4
commit 2daceff057
11 changed files with 79 additions and 72 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
lispBM/lispBM/include/heap.h
View File

@ -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));
}

32
lispBM/lispBM/include/lbm_defines.h
View File

@ -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
@ -188,12 +188,12 @@
#define SYM_TYPE_DOUBLE 0x56
#define SYM_TYPE_I64 0x57
#define SYM_TYPE_U64 0x58
#define SYM_TYPE_BYTEARRAY 0x59
#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_ARRAY 0x5F
#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)

7
lispBM/lispBM/repl/repl_exts.c
View File

@ -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);

10
lispBM/lispBM/src/eval_cps.c
View File

@ -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;

2
lispBM/lispBM/src/extensions/array_extensions.c
View File

@ -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]);

8
lispBM/lispBM/src/fundamental.c
View File

@ -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;
}

26
lispBM/lispBM/src/heap.c
View File

@ -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;
}

4
lispBM/lispBM/src/lbm_c_interop.c
View File

@ -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);

12
lispBM/lispBM/src/lbm_flat_value.c
View File

@ -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);

4
lispBM/lispBM/src/print.c
View File

@ -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) {

8
lispBM/lispBM/src/symrepr.c
View File

@ -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},