MIRROR: javascript for 🐜's, a tiny runtime with big ambitions
remove 64 param limit
+67
-77
+1
-1
meson.build
+1
-1
meson.build
···
79
79
build_date = run_command('date', '+%Y-%m-%d', check: true).stdout().strip()
80
80
81
81
version_conf = configuration_data()
82
-
version_conf.set('ANT_VERSION', '0.2.2.32')
82
+
version_conf.set('ANT_VERSION', '0.2.2.33')
83
83
version_conf.set('ANT_GIT_HASH', git_hash)
84
84
version_conf.set('ANT_BUILD_DATE', build_date)
85
85
+66
-76
src/ant.c
+66
-76
src/ant.c
···
123
123
.dtor = NULL,
124
124
};
125
125
126
+
static const UT_icd jsval_icd = {
127
+
.sz = sizeof(jsval_t),
128
+
.init = NULL,
129
+
.copy = NULL,
130
+
.dtor = NULL,
131
+
};
132
+
126
133
static UT_array *global_scope_stack = NULL;
127
134
static this_stack_t global_this_stack = {NULL, 0, 0};
128
135
static call_stack_t global_call_stack = {NULL, 0, 0};
···
315
322
static const UT_icd propref_icd = { sizeof(propref_data_t), NULL, NULL, NULL };
316
323
static UT_array *propref_stack = NULL;
317
324
318
-
#define MAX_FUNC_PARAMS 64
319
-
320
325
typedef struct parsed_param {
321
326
jsoff_t name_off;
322
327
jsoff_t name_len;
···
331
336
uint64_t code_hash;
332
337
jsoff_t body_start;
333
338
jsoff_t body_len;
334
-
uint8_t param_count;
339
+
int param_count;
335
340
bool has_rest;
336
341
bool is_strict;
337
342
jsoff_t rest_param_start;
338
343
jsoff_t rest_param_len;
339
-
parsed_param_t params[MAX_FUNC_PARAMS];
344
+
UT_array *params;
340
345
UT_hash_handle hh;
341
346
} parsed_func_t;
347
+
348
+
static const UT_icd parsed_param_icd = {
349
+
.sz = sizeof(parsed_param_t),
350
+
.init = NULL,
351
+
.copy = NULL,
352
+
.dtor = NULL,
353
+
};
342
354
343
355
static parsed_func_t *func_parse_cache = NULL;
344
356
static ant_library_t *library_registry = NULL;
···
4655
4667
}
4656
4668
}
4657
4669
4658
-
static int parse_call_args(struct js *js, jsval_t *err_out) {
4659
-
int argc = 0;
4660
-
4670
+
static int parse_call_args(struct js *js, UT_array *args, jsval_t *err_out) {
4661
4671
while (js->pos < js->clen) {
4662
4672
if (next(js) == TOK_RPAREN) break;
4663
4673
bool is_spread = (next(js) == TOK_REST);
···
4668
4678
jsoff_t len = arr_length(js, arg);
4669
4679
for (jsoff_t i = 0; i < len; i++) {
4670
4680
jsval_t elem = arr_get(js, arg, i);
4671
-
if (js->brk + sizeof(elem) > js->size) {
4672
-
if (!js_try_grow_memory(js, sizeof(elem))) {
4673
-
*err_out = js_mkerr(js, "call oom");
4674
-
return -1;
4675
-
}
4676
-
}
4677
-
js->size -= (jsoff_t) sizeof(elem);
4678
-
memcpy(&js->mem[js->size], &elem, sizeof(elem));
4679
-
argc++;
4680
-
}
4681
-
} else {
4682
-
if (js->brk + sizeof(arg) > js->size) {
4683
-
if (!js_try_grow_memory(js, sizeof(arg))) {
4684
-
*err_out = js_mkerr(js, "call oom");
4685
-
return -1;
4686
-
}
4681
+
utarray_push_back(args, &elem);
4687
4682
}
4688
-
js->size -= (jsoff_t) sizeof(arg);
4689
-
memcpy(&js->mem[js->size], &arg, sizeof(arg));
4690
-
argc++;
4691
-
}
4683
+
} else utarray_push_back(args, &arg);
4692
4684
if (next(js) == TOK_COMMA) js->consumed = 1;
4693
4685
}
4694
4686
4695
-
reverse((jsval_t *) &js->mem[js->size], argc);
4696
-
return argc;
4687
+
return (int)utarray_len(args);
4697
4688
}
4698
4689
4699
4690
static jsval_t call_c(struct js *js, jsval_t (*fn)(struct js *, jsval_t *, int)) {
4700
-
jsoff_t saved_size = js->size;
4691
+
UT_array *args;
4692
+
utarray_new(args, &jsval_icd);
4701
4693
jsval_t err, res;
4702
4694
4703
-
int argc = parse_call_args(js, &err);
4704
-
if (argc < 0) { js->size = saved_size; return err; }
4695
+
int argc = parse_call_args(js, args, &err);
4696
+
if (argc < 0) { utarray_free(args); return err; }
4705
4697
4706
-
jsval_t stack_args[MAX_FUNC_PARAMS];
4707
-
jsval_t *heap_args = (jsval_t *) &js->mem[js->size];
4708
-
for (int i = 0; i < argc && i < MAX_FUNC_PARAMS; i++) {
4709
-
stack_args[i] = heap_args[i];
4710
-
}
4711
-
js->size = saved_size;
4712
-
4698
+
jsval_t *argv = (jsval_t *)utarray_front(args);
4713
4699
jsval_t saved_this = js->this_val;
4714
4700
js->this_val = peek_this();
4715
-
res = fn(js, stack_args, argc);
4701
+
res = fn(js, argv, argc);
4716
4702
js->this_val = saved_this;
4717
4703
setlwm(js);
4718
4704
4705
+
utarray_free(args);
4719
4706
return res;
4720
4707
}
4721
4708
···
4880
4867
if (!pf) return NULL;
4881
4868
memset(pf, 0, sizeof(*pf));
4882
4869
pf->code_hash = h;
4870
+
utarray_new(pf->params, &parsed_param_icd);
4883
4871
4884
4872
jsoff_t fnpos = 1;
4885
4873
···
4911
4899
}
4912
4900
jsoff_t pattern_len = fnpos - pattern_start;
4913
4901
4914
-
if (pf->param_count < MAX_FUNC_PARAMS) {
4915
-
parsed_param_t *pp = &pf->params[pf->param_count];
4916
-
pp->is_destruct = true;
4917
-
pp->pattern_off = pattern_start;
4918
-
pp->pattern_len = pattern_len;
4902
+
{
4903
+
parsed_param_t pp = {0};
4904
+
pp.is_destruct = true;
4905
+
pp.pattern_off = pattern_start;
4906
+
pp.pattern_len = pattern_len;
4919
4907
4920
4908
fnpos = skiptonext(fn, fnlen, fnpos, NULL);
4921
4909
if (fnpos < fnlen && fn[fnpos] == '=') {
4922
-
fnpos = extract_default_param_value(fn, fnlen, fnpos, &pp->default_start, &pp->default_len);
4910
+
fnpos = extract_default_param_value(fn, fnlen, fnpos, &pp.default_start, &pp.default_len);
4923
4911
}
4912
+
utarray_push_back(pf->params, &pp);
4924
4913
pf->param_count++;
4925
4914
}
4926
4915
···
4937
4926
break;
4938
4927
}
4939
4928
4940
-
if (pf->param_count < MAX_FUNC_PARAMS) {
4941
-
parsed_param_t *pp = &pf->params[pf->param_count];
4942
-
pp->name_off = fnpos;
4943
-
pp->name_len = identlen;
4944
-
pp->is_destruct = false;
4945
-
fnpos = extract_default_param_value(fn, fnlen, fnpos + identlen, &pp->default_start, &pp->default_len);
4929
+
{
4930
+
parsed_param_t pp = {0};
4931
+
pp.name_off = fnpos;
4932
+
pp.name_len = identlen;
4933
+
pp.is_destruct = false;
4934
+
fnpos = extract_default_param_value(fn, fnlen, fnpos + identlen, &pp.default_start, &pp.default_len);
4935
+
utarray_push_back(pf->params, &pp);
4946
4936
pf->param_count++;
4947
-
} else {
4948
-
fnpos = skiptonext(fn, fnlen, fnpos + identlen, NULL);
4949
4937
}
4950
4938
4951
4939
if (fnpos < fnlen && fn[fnpos] == ',') fnpos++;
···
5037
5025
jsoff_t caller_clen = js->clen;
5038
5026
jsoff_t caller_pos = js->pos;
5039
5027
5040
-
jsval_t args[MAX_FUNC_PARAMS];
5041
-
int argc = 0;
5028
+
UT_array *args_arr;
5029
+
utarray_new(args_arr, &jsval_icd);
5042
5030
5043
-
for (int i = 0; i < bound_argc && argc < MAX_FUNC_PARAMS; i++) { args[argc++] = bound_args[i]; }
5031
+
for (int i = 0; i < bound_argc; i++) { utarray_push_back(args_arr, &bound_args[i]); }
5044
5032
caller_pos = skiptonext(caller_code, caller_clen, caller_pos, NULL);
5045
5033
5046
-
while (caller_pos < caller_clen && caller_code[caller_pos] != ')' && argc < MAX_FUNC_PARAMS) {
5034
+
while (caller_pos < caller_clen && caller_code[caller_pos] != ')') {
5047
5035
bool is_spread = (
5048
5036
caller_code[caller_pos] == '.' && caller_pos + 2 < caller_clen &&
5049
5037
caller_code[caller_pos + 1] == '.' && caller_code[caller_pos + 2] == '.'
···
5055
5043
caller_pos = js->pos;
5056
5044
if (is_spread && vtype(arg) == T_ARR) {
5057
5045
jsoff_t len = arr_length(js, arg);
5058
-
for (jsoff_t i = 0; i < len && argc < MAX_FUNC_PARAMS; i++) {
5059
-
args[argc++] = arr_get(js, arg, i);
5046
+
for (jsoff_t i = 0; i < len; i++) {
5047
+
jsval_t elem = arr_get(js, arg, i);
5048
+
utarray_push_back(args_arr, &elem);
5060
5049
}
5061
5050
} else {
5062
-
args[argc++] = arg;
5051
+
utarray_push_back(args_arr, &arg);
5063
5052
}
5064
5053
caller_pos = skiptonext(caller_code, caller_clen, caller_pos, NULL);
5065
5054
if (caller_pos < caller_clen && caller_code[caller_pos] == ',') caller_pos++;
···
5067
5056
}
5068
5057
js->pos = caller_pos;
5069
5058
5059
+
jsval_t *args = (jsval_t *)utarray_front(args_arr);
5060
+
int argc = (int)utarray_len(args_arr);
5070
5061
js->scope = function_scope;
5071
5062
5072
5063
parsed_func_t *pf = get_or_parse_func(fn, fnlen);
5073
5064
if (!pf) {
5065
+
utarray_free(args_arr);
5074
5066
js->scope = saved_scope;
5075
5067
if (global_scope_stack && utarray_len(global_scope_stack) > 0) utarray_pop_back(global_scope_stack);
5076
5068
return js_mkerr(js, "failed to parse function");
5077
5069
}
5078
5070
5079
5071
int argi = 0;
5080
-
for (int i = 0; i < pf->param_count && i < MAX_FUNC_PARAMS; i++) {
5081
-
parsed_param_t *pp = &pf->params[i];
5072
+
for (int i = 0; i < pf->param_count; i++) {
5073
+
parsed_param_t *pp = (parsed_param_t *)utarray_eltptr(pf->params, i);
5082
5074
5083
5075
if (pp->is_destruct) {
5084
5076
jsval_t arg_val = (argi < argc) ? args[argi++] : js_mkundef();
···
5087
5079
}
5088
5080
jsval_t r = bind_destruct_pattern(js, &fn[pp->pattern_off], pp->pattern_len, arg_val, function_scope);
5089
5081
if (is_err(r)) {
5082
+
utarray_free(args_arr);
5090
5083
js->scope = saved_scope;
5091
5084
if (global_scope_stack && utarray_len(global_scope_stack) > 0) utarray_pop_back(global_scope_stack);
5092
5085
return r;
···
5163
5156
if (!is_err(res) && !(js->flags & F_RETURN)) res = js_mkundef();
5164
5157
if (global_scope_stack && utarray_len(global_scope_stack) > 0) utarray_pop_back(global_scope_stack);
5165
5158
5159
+
utarray_free(args_arr);
5166
5160
js->scope = saved_scope;
5167
5161
js->this_val = saved_this_val;
5168
5162
return res;
···
5440
5434
}
5441
5435
5442
5436
static jsval_t call_ffi(struct js *js, unsigned int func_index) {
5443
-
jsoff_t saved_size = js->size;
5437
+
UT_array *args;
5438
+
utarray_new(args, &jsval_icd);
5444
5439
jsval_t err, res;
5445
5440
5446
-
int argc = parse_call_args(js, &err);
5447
-
if (argc < 0) { js->size = saved_size; return err; }
5448
-
5449
-
jsval_t stack_args[MAX_FUNC_PARAMS];
5450
-
jsval_t *heap_args = (jsval_t *) &js->mem[js->size];
5451
-
for (int i = 0; i < argc && i < MAX_FUNC_PARAMS; i++) {
5452
-
stack_args[i] = heap_args[i];
5453
-
}
5454
-
js->size = saved_size;
5441
+
int argc = parse_call_args(js, args, &err);
5442
+
if (argc < 0) { utarray_free(args); return err; }
5455
5443
5456
-
res = ffi_call_by_index(js, func_index, stack_args, argc);
5444
+
jsval_t *argv = (jsval_t *)utarray_front(args);
5445
+
res = ffi_call_by_index(js, func_index, argv, argc);
5457
5446
setlwm(js);
5458
5447
5448
+
utarray_free(args);
5459
5449
return res;
5460
5450
}
5461
5451
···
20789
20779
}
20790
20780
20791
20781
int arg_idx = 0;
20792
-
for (int i = 0; i < pf->param_count && i < MAX_FUNC_PARAMS; i++) {
20793
-
parsed_param_t *pp = &pf->params[i];
20782
+
for (int i = 0; i < pf->param_count; i++) {
20783
+
parsed_param_t *pp = (parsed_param_t *)utarray_eltptr(pf->params, i);
20794
20784
20795
20785
if (pp->is_destruct) {
20796
20786
jsval_t arg_val = (arg_idx < nargs) ? args[arg_idx++] : js_mkundef();