MIRROR: javascript for 🐜's, a tiny runtime with big ambitions
use slots for promise ID
+197
-130
+7
include/config.h
+7
include/config.h
···
19
19
#define GCMASK ~(((jsoff_t) ~0) >> 1)
20
20
#define CONSTMASK (~(((jsoff_t) ~0) >> 1) >> 1)
21
21
#define ARRMASK (~(((jsoff_t) ~0) >> 1) >> 2)
22
+
#define SLOTMASK (~(((jsoff_t) ~0) >> 1) >> 3)
23
+
24
+
typedef enum {
25
+
SLOT_NONE = 0,
26
+
SLOT_PID,
27
+
SLOT_MAX = 255
28
+
} internal_slot_t;
22
29
23
30
#endif
+7
include/config.h.in
+7
include/config.h.in
···
11
11
#define GCMASK ~(((jsoff_t) ~0) >> 1)
12
12
#define CONSTMASK (~(((jsoff_t) ~0) >> 1) >> 1)
13
13
#define ARRMASK (~(((jsoff_t) ~0) >> 1) >> 2)
14
+
#define SLOTMASK (~(((jsoff_t) ~0) >> 1) >> 3)
15
+
16
+
typedef enum {
17
+
SLOT_NONE = 0,
18
+
SLOT_PID,
19
+
SLOT_MAX = 255
20
+
} internal_slot_t;
14
21
15
22
#endif
+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.29')
82
+
version_conf.set('ANT_VERSION', '0.2.2.30')
83
83
version_conf.set('ANT_GIT_HASH', git_hash)
84
84
version_conf.set('ANT_BUILD_DATE', build_date)
85
85
+150
-129
src/ant.c
+150
-129
src/ant.c
···
231
231
static const char *INTERN_ARGUMENTS = NULL;
232
232
static const char *INTERN_CALLEE = NULL;
233
233
static const char *INTERN_IDX[10] = {NULL};
234
-
static const char *INTERN_STATE = NULL;
235
-
static const char *INTERN_PVALUE = NULL;
236
234
static const char *INTERN_PROMISE = NULL;
237
235
238
236
#define INTERN_PROP_CACHE_SIZE 4096
···
256
254
.dtor = NULL,
257
255
};
258
256
259
-
typedef struct promise_handlers_entry {
260
-
jsoff_t promise_off; // key
257
+
typedef struct promise_data_entry {
258
+
uint32_t promise_id;
259
+
int state;
260
+
jsval_t value;
261
261
UT_array *handlers;
262
262
UT_hash_handle hh;
263
-
} promise_handlers_entry_t;
263
+
} promise_data_entry_t;
264
+
265
+
static promise_data_entry_t *promise_registry = NULL;
266
+
static uint32_t next_promise_id = 1;
264
267
265
-
static promise_handlers_entry_t *promise_handlers_registry = NULL;
268
+
static promise_data_entry_t *get_promise_data(uint32_t promise_id, bool create);
269
+
static uint32_t get_promise_id(struct js *js, jsval_t p);
266
270
267
271
typedef struct map_entry {
268
272
char *key;
···
2812
2816
INTERN_THIS = intern_string("__this", 6);
2813
2817
INTERN_NATIVE_FUNC = intern_string("__native_func", 13);
2814
2818
INTERN_ASYNC = intern_string("__async", 7);
2815
-
INTERN_STATE = intern_string("__state", 7);
2816
-
INTERN_PVALUE = intern_string("__value", 7);
2817
2819
INTERN_PROMISE = intern_string("promise", 7);
2818
2820
INTERN_BOUND_THIS = intern_string("__bound_this", 12);
2819
2821
INTERN_BOUND_ARGS = intern_string("__bound_args", 12);
···
2909
2911
return mkentity(js, prop_header, buf, sizeof(buf));
2910
2912
}
2911
2913
2914
+
static jsval_t mkslot(struct js *js, jsval_t obj, internal_slot_t slot, jsval_t v) {
2915
+
jsoff_t b, head = (jsoff_t) vdata(obj);
2916
+
char buf[sizeof(jsoff_t) + sizeof(v)];
2917
+
memcpy(&b, &js->mem[head], sizeof(b));
2918
+
2919
+
jsoff_t slot_key = (jsoff_t)slot;
2920
+
memcpy(buf, &slot_key, sizeof(slot_key));
2921
+
memcpy(buf + sizeof(slot_key), &v, sizeof(v));
2922
+
2923
+
jsoff_t brk = js->brk | T_OBJ;
2924
+
if (b & ARRMASK) brk |= ARRMASK;
2925
+
memcpy(&js->mem[head], &brk, sizeof(brk));
2926
+
jsoff_t prop_header = (b & ~(3U | CONSTMASK | ARRMASK | SLOTMASK)) | T_PROP | SLOTMASK;
2927
+
2928
+
return mkentity(js, prop_header, buf, sizeof(buf));
2929
+
}
2930
+
2931
+
static jsoff_t search_slot(struct js *js, jsval_t obj, internal_slot_t slot) {
2932
+
jsoff_t off = (jsoff_t) vdata(obj);
2933
+
jsoff_t next = loadoff(js, off) & ~(3U | CONSTMASK | ARRMASK | SLOTMASK);
2934
+
jsoff_t header, koff;
2935
+
2936
+
check:
2937
+
if (next == 0 || next >= js->brk) return 0;
2938
+
header = loadoff(js, next);
2939
+
if ((header & SLOTMASK) == 0) return 0;
2940
+
koff = loadoff(js, next + sizeof(jsoff_t));
2941
+
if (koff == (jsoff_t)slot) return next;
2942
+
next = header & ~(3U | CONSTMASK | ARRMASK | SLOTMASK);
2943
+
goto check;
2944
+
}
2945
+
2946
+
static jsoff_t lkp_header_slot(struct js *js, jsval_t obj, internal_slot_t slot) {
2947
+
jsoff_t off = (jsoff_t) vdata(obj);
2948
+
jsoff_t next = loadoff(js, off) & ~(3U | CONSTMASK | ARRMASK | SLOTMASK);
2949
+
if (next == 0 || next >= js->brk) return 0;
2950
+
jsoff_t header = loadoff(js, next);
2951
+
if ((header & SLOTMASK) == 0) return 0;
2952
+
jsoff_t koff = loadoff(js, next + sizeof(jsoff_t));
2953
+
return (koff == (jsoff_t)slot) ? next : 0;
2954
+
}
2955
+
2956
+
static void set_slot(struct js *js, jsval_t obj, internal_slot_t slot, jsval_t val) {
2957
+
jsoff_t existing = search_slot(js, obj, slot);
2958
+
if (existing > 0) {
2959
+
saveval(js, existing + sizeof(jsoff_t) * 2, val);
2960
+
} else mkslot(js, obj, slot, val);
2961
+
}
2962
+
2963
+
static jsval_t get_slot(struct js *js, jsval_t obj, internal_slot_t slot) {
2964
+
jsoff_t off = search_slot(js, obj, slot);
2965
+
if (off == 0) return js_mkundef();
2966
+
return loadval(js, off + sizeof(jsoff_t) * 2);
2967
+
}
2968
+
2912
2969
static jsval_t setup_func_prototype(struct js *js, jsval_t func) {
2913
2970
jsval_t proto_obj = mkobj(js, 0);
2914
2971
if (is_err(proto_obj)) return proto_obj;
···
3998
4055
int depth = 0;
3999
4056
4000
4057
while (depth < 32) {
4001
-
if (t == T_OBJ || t == T_ARR || t == T_FUNC) {
4058
+
if (t == T_OBJ || t == T_ARR || t == T_FUNC || t == T_PROMISE) {
4002
4059
jsval_t as_obj = mkval(T_OBJ, vdata(cur));
4003
4060
jsoff_t off = lkp_interned(js, as_obj, key_intern, len);
4004
4061
if (off != 0) return off;
4005
4062
4006
4063
jsoff_t proto_off = lkp_interned(js, as_obj, INTERN_PROTO, 9);
4007
4064
if (proto_off == 0) {
4008
-
if (t == T_FUNC || t == T_ARR) {
4065
+
if (t == T_FUNC || t == T_ARR || t == T_PROMISE) {
4009
4066
cur = get_prototype_for_type(js, t);
4010
4067
t = vtype(cur);
4011
4068
if (t == T_NULL || t == T_UNDEF) break;
···
7851
7908
return resolved;
7852
7909
}
7853
7910
7854
-
jsval_t p_obj = mkval(T_OBJ, vdata(resolved));
7855
-
jsoff_t state_off = lkp(js, p_obj, "__state", 7);
7856
-
if (state_off == 0) return js_mkerr(js, "invalid promise state");
7911
+
uint32_t pid = get_promise_id(js, resolved);
7912
+
promise_data_entry_t *pd = get_promise_data(pid, false);
7913
+
if (!pd) return js_mkerr(js, "invalid promise state");
7857
7914
7858
-
int state = (int)tod(resolveprop(js, mkval(T_PROP, state_off)));
7859
-
7860
-
if (state != 0) {
7861
-
jsoff_t val_off = lkp(js, p_obj, "__value", 7);
7862
-
if (val_off == 0) return js_mkerr(js, "invalid promise value");
7863
-
jsval_t val = resolveprop(js, mkval(T_PROP, val_off));
7864
-
if (state == 1) {
7865
-
return val;
7866
-
} else if (state == 2) {
7867
-
return js_throw(js, val);
7868
-
}
7915
+
if (pd->state != 0) {
7916
+
if (pd->state == 1) { return pd->value;
7917
+
} else if (pd->state == 2) return js_throw(js, pd->value);
7869
7918
}
7870
7919
7871
7920
mco_coro* current_mco = mco_running();
···
8126
8175
if (tok == TOK_RPAREN || tok == TOK_RBRACE || tok == TOK_SEMICOLON ||
8127
8176
tok == TOK_COMMA || tok == TOK_EOF) {
8128
8177
body_end = js->toff;
8129
-
} else {
8130
-
body_end = js->pos;
8131
-
}
8178
+
} else body_end = js->pos;
8132
8179
} else {
8133
8180
body_end = js->pos;
8134
8181
}
···
13317
13364
jsval_t descriptor = loadval(js, next + (jsoff_t) (sizeof(next) + sizeof(koff)));
13318
13365
13319
13366
next = loadoff(js, next) & ~(3U | CONSTMASK | ARRMASK);
13320
-
13321
13367
if (is_internal_prop(key, klen)) continue;
13322
13368
13323
13369
jsval_t prop_key = js_mkstr(js, key, klen);
···
13399
13445
13400
13446
jsoff_t cur_prop = next;
13401
13447
next = loadoff(js, next) & ~(3U | CONSTMASK | ARRMASK);
13402
-
13403
13448
if (is_internal_prop(key, klen)) continue;
13404
13449
13405
13450
jsoff_t head = (jsoff_t) vdata(as_obj);
···
13613
13658
const char *key = (char *) &js->mem[koff + sizeof(koff)];
13614
13659
13615
13660
next = loadoff(js, next) & ~(3U | CONSTMASK | ARRMASK);
13616
-
13617
13661
if (is_internal_prop(key, klen)) continue;
13618
13662
13619
13663
char idxstr[16];
···
17500
17544
static void reject_promise(struct js *js, jsval_t p, jsval_t val);
17501
17545
17502
17546
static size_t strpromise(struct js *js, jsval_t value, char *buf, size_t len) {
17503
-
jsval_t prom_obj = mkval(T_OBJ, vdata(value));
17504
-
jsoff_t state_off = lkp(js, prom_obj, "__state", 7);
17505
-
int state = 0;
17506
-
if (state_off != 0) {
17507
-
jsval_t val = resolveprop(js, mkval(T_PROP, state_off));
17508
-
if (vtype(val) == T_NUM) state = (int)tod(val);
17509
-
}
17547
+
uint32_t pid = get_promise_id(js, value);
17548
+
promise_data_entry_t *pd = get_promise_data(pid, false);
17510
17549
17511
-
if (state == 0) {
17550
+
if (!pd || pd->state == 0) {
17512
17551
return (size_t)snprintf(buf, len, "Promise { <pending> }");
17513
17552
}
17514
17553
17515
-
jsoff_t value_off = lkp(js, prom_obj, "__value", 7);
17516
-
if (value_off == 0) {
17517
-
const char *s = (state == 1) ? "<fulfilled>" : "<rejected>";
17518
-
return (size_t)snprintf(buf, len, "Promise { %s }", s);
17519
-
}
17520
-
17521
-
jsval_t prom_val = resolveprop(js, mkval(T_PROP, value_off));
17522
17554
char value_buf[256];
17523
-
size_t value_len = tostr(js, prom_val, value_buf, sizeof(value_buf));
17555
+
size_t value_len = tostr(js, pd->value, value_buf, sizeof(value_buf));
17524
17556
if (value_len >= sizeof(value_buf)) value_len = sizeof(value_buf) - 1;
17525
17557
value_buf[value_len] = '\0';
17526
17558
17527
-
if (state == 1) {
17559
+
if (pd->state == 1) {
17528
17560
return (size_t)snprintf(buf, len, "Promise { %s }", value_buf);
17529
17561
} else {
17530
17562
return (size_t)snprintf(buf, len, "Promise { <rejected> %s }", value_buf);
17531
17563
}
17532
17564
}
17533
17565
17534
-
static UT_array *get_promise_handlers(jsoff_t promise_off, bool create) {
17535
-
promise_handlers_entry_t *entry = NULL;
17536
-
HASH_FIND(hh, promise_handlers_registry, &promise_off, sizeof(jsoff_t), entry);
17537
-
if (entry) return entry->handlers;
17566
+
static promise_data_entry_t *get_promise_data(uint32_t promise_id, bool create) {
17567
+
promise_data_entry_t *entry = NULL;
17568
+
HASH_FIND(hh, promise_registry, &promise_id, sizeof(uint32_t), entry);
17569
+
if (entry) return entry;
17538
17570
if (!create) return NULL;
17539
17571
17540
-
entry = (promise_handlers_entry_t *)malloc(sizeof(promise_handlers_entry_t));
17541
-
entry->promise_off = promise_off;
17572
+
entry = (promise_data_entry_t *)malloc(sizeof(promise_data_entry_t));
17573
+
entry->promise_id = promise_id;
17574
+
entry->state = 0;
17575
+
entry->value = js_mkundef();
17542
17576
utarray_new(entry->handlers, &promise_handler_icd);
17543
-
HASH_ADD(hh, promise_handlers_registry, promise_off, sizeof(jsoff_t), entry);
17544
-
return entry->handlers;
17577
+
HASH_ADD(hh, promise_registry, promise_id, sizeof(uint32_t), entry);
17578
+
17579
+
return entry;
17580
+
}
17581
+
17582
+
static uint32_t get_promise_id(struct js *js, jsval_t p) {
17583
+
jsval_t p_obj = mkval(T_OBJ, vdata(p));
17584
+
jsoff_t off = lkp_header_slot(js, p_obj, SLOT_PID);
17585
+
if (off == 0) return 0;
17586
+
jsval_t pid_val = loadval(js, off + sizeof(jsoff_t) * 2);
17587
+
return (uint32_t)tod(pid_val);
17545
17588
}
17546
17589
17547
17590
static jsval_t mkpromise(struct js *js) {
17548
17591
jsval_t obj = mkobj(js, 0);
17549
17592
if (is_err(obj)) return obj;
17550
-
setprop_fast(js, obj, "__state", 7, tov(0.0));
17551
-
setprop_fast(js, obj, "__value", 7, js_mkundef());
17593
+
17594
+
uint32_t pid = next_promise_id++;
17595
+
set_slot(js, obj, SLOT_PID, tov((double)pid));
17596
+
get_promise_data(pid, true);
17552
17597
17553
-
jsoff_t obj_off = vdata(obj);
17554
-
get_promise_handlers(obj_off, true);
17555
-
return mkval(T_PROMISE, obj_off);
17598
+
return mkval(T_PROMISE, vdata(obj));
17556
17599
}
17557
17600
17558
17601
static jsval_t builtin_trigger_handler_wrapper(struct js *js, jsval_t *args, int nargs);
···
17572
17615
jsval_t p = resolveprop(js, mkval(T_PROP, promise_prop_off));
17573
17616
if (vtype(p) != T_PROMISE) return js_mkundef();
17574
17617
17575
-
jsoff_t promise_off = vdata(p);
17576
-
jsval_t p_obj = mkval(T_OBJ, promise_off);
17577
-
jsoff_t state_off = lkp_interned(js, p_obj, INTERN_STATE, 7);
17578
-
int state = (int)tod(resolveprop(js, mkval(T_PROP, state_off)));
17579
-
17580
-
jsoff_t val_off = lkp_interned(js, p_obj, INTERN_PVALUE, 7);
17581
-
jsval_t val = resolveprop(js, mkval(T_PROP, val_off));
17618
+
uint32_t pid = get_promise_id(js, p);
17619
+
promise_data_entry_t *pd = get_promise_data(pid, false);
17620
+
if (!pd) return js_mkundef();
17582
17621
17583
-
UT_array *handlers = get_promise_handlers(promise_off, false);
17584
-
if (!handlers) return js_mkundef();
17622
+
int state = pd->state;
17623
+
jsval_t val = pd->value;
17585
17624
17586
-
unsigned int len = utarray_len(handlers);
17625
+
unsigned int len = utarray_len(pd->handlers);
17587
17626
for (unsigned int i = 0; i < len; i++) {
17588
-
promise_handler_t *h = (promise_handler_t *)utarray_eltptr(handlers, i);
17627
+
promise_handler_t *h = (promise_handler_t *)utarray_eltptr(pd->handlers, i);
17589
17628
jsval_t handler = (state == 1) ? h->onFulfilled : h->onRejected;
17590
17629
17591
17630
if (vtype(handler) == T_FUNC || vtype(handler) == T_CFUNC) {
···
17608
17647
}
17609
17648
}
17610
17649
17611
-
utarray_clear(handlers);
17650
+
utarray_clear(pd->handlers);
17612
17651
return js_mkundef();
17613
17652
}
17614
17653
17615
17654
static void resolve_promise(struct js *js, jsval_t p, jsval_t val) {
17616
-
jsval_t p_obj = mkval(T_OBJ, vdata(p));
17617
-
jsoff_t state_off = lkp_interned(js, p_obj, INTERN_STATE, 7);
17618
-
if (state_off == 0) return;
17619
-
jsval_t state_val = resolveprop(js, mkval(T_PROP, state_off));
17620
-
if ((int)tod(state_val) != 0) return;
17655
+
uint32_t pid = get_promise_id(js, p);
17656
+
promise_data_entry_t *pd = get_promise_data(pid, false);
17657
+
if (!pd || pd->state != 0) return;
17621
17658
17622
17659
if (vtype(val) == T_PROMISE) {
17623
-
if (vdata(val) == vdata(p)) {
17660
+
uint32_t val_pid = get_promise_id(js, val);
17661
+
if (val_pid == pid) {
17624
17662
jsval_t err = js_mkerr(js, "TypeError: Chaining cycle");
17625
17663
return reject_promise(js, p, err);
17626
17664
}
···
17635
17673
setprop_fast(js, rej_obj, "promise", 7, p);
17636
17674
jsval_t rej_fn = mkval(T_FUNC, vdata(rej_obj));
17637
17675
17638
-
jsval_t args[] = { res_fn, rej_fn };
17676
+
jsval_t call_args[] = { res_fn, rej_fn };
17639
17677
jsval_t then_prop = js_get(js, val, "then");
17640
17678
17641
17679
if (vtype(then_prop) == T_FUNC || vtype(then_prop) == T_CFUNC) {
17642
-
(void)js_call_with_this(js, then_prop, val, args, 2); return;
17680
+
(void)js_call_with_this(js, then_prop, val, call_args, 2); return;
17643
17681
}
17644
17682
}
17645
17683
17646
-
saveval(js, state_off + sizeof(jsoff_t) * 2, tov(1.0));
17647
-
jsoff_t val_off = lkp_interned(js, p_obj, INTERN_PVALUE, 7);
17648
-
if (val_off != 0) {
17649
-
saveval(js, val_off + sizeof(jsoff_t) * 2, val);
17650
-
}
17684
+
pd->state = 1;
17685
+
pd->value = val;
17651
17686
trigger_handlers(js, p);
17652
17687
}
17653
17688
17654
17689
static void reject_promise(struct js *js, jsval_t p, jsval_t val) {
17655
-
jsval_t p_obj = mkval(T_OBJ, vdata(p));
17656
-
jsoff_t state_off = lkp_interned(js, p_obj, INTERN_STATE, 7);
17657
-
if (state_off == 0) return;
17658
-
jsval_t state_val = resolveprop(js, mkval(T_PROP, state_off));
17659
-
if ((int)tod(state_val) != 0) return;
17690
+
uint32_t pid = get_promise_id(js, p);
17691
+
promise_data_entry_t *pd = get_promise_data(pid, false);
17692
+
if (!pd || pd->state != 0) return;
17660
17693
17661
-
saveval(js, state_off + sizeof(jsoff_t) * 2, tov(2.0));
17662
-
jsoff_t val_off = lkp_interned(js, p_obj, INTERN_PVALUE, 7);
17663
-
if (val_off != 0) {
17664
-
saveval(js, val_off + sizeof(jsoff_t) * 2, val);
17665
-
}
17694
+
pd->state = 2;
17695
+
pd->value = val;
17666
17696
trigger_handlers(js, p);
17667
17697
}
17668
17698
···
17721
17751
jsval_t onFulfilled = nargs > 0 ? args[0] : js_mkundef();
17722
17752
jsval_t onRejected = nargs > 1 ? args[1] : js_mkundef();
17723
17753
17724
-
jsoff_t promise_off = vdata(p);
17725
-
UT_array *handlers = get_promise_handlers(promise_off, true);
17726
-
if (handlers) {
17754
+
uint32_t pid = get_promise_id(js, p);
17755
+
promise_data_entry_t *pd = get_promise_data(pid, false);
17756
+
if (pd) {
17727
17757
promise_handler_t h = { onFulfilled, onRejected, nextP };
17728
-
utarray_push_back(handlers, &h);
17758
+
utarray_push_back(pd->handlers, &h);
17729
17759
}
17730
17760
17731
-
jsval_t p_obj = mkval(T_OBJ, promise_off);
17732
-
jsoff_t state_off = lkp_interned(js, p_obj, INTERN_STATE, 7);
17733
-
int state = (int)tod(resolveprop(js, mkval(T_PROP, state_off)));
17734
-
if (state != 0) trigger_handlers(js, p);
17761
+
if (pd && pd->state != 0) trigger_handlers(js, p);
17735
17762
return nextP;
17736
17763
}
17737
17764
···
17922
17949
return result_promise;
17923
17950
}
17924
17951
17925
-
jsval_t item_obj = mkval(T_OBJ, vdata(item));
17926
-
jsoff_t state_off = lkp(js, item_obj, "__state", 7);
17927
-
int state = (int)tod(resolveprop(js, mkval(T_PROP, state_off)));
17928
-
17929
-
if (state == 1) {
17930
-
jsoff_t val_off = lkp(js, item_obj, "__value", 7);
17931
-
jsval_t val = resolveprop(js, mkval(T_PROP, val_off));
17932
-
resolve_promise(js, result_promise, val);
17933
-
return result_promise;
17934
-
} else if (state == 2) {
17935
-
jsoff_t val_off = lkp(js, item_obj, "__value", 7);
17936
-
jsval_t val = resolveprop(js, mkval(T_PROP, val_off));
17937
-
reject_promise(js, result_promise, val);
17938
-
return result_promise;
17952
+
uint32_t item_pid = get_promise_id(js, item);
17953
+
promise_data_entry_t *pd = get_promise_data(item_pid, false);
17954
+
if (pd) {
17955
+
if (pd->state == 1) {
17956
+
resolve_promise(js, result_promise, pd->value);
17957
+
return result_promise;
17958
+
} else if (pd->state == 2) {
17959
+
reject_promise(js, result_promise, pd->value);
17960
+
return result_promise;
17961
+
}
17939
17962
}
17940
17963
17941
17964
jsval_t then_args[] = { resolve_fn, reject_fn };
···
18026
18049
return result_promise;
18027
18050
}
18028
18051
18029
-
jsval_t item_obj = mkval(T_OBJ, vdata(item));
18030
-
jsoff_t state_off = lkp(js, item_obj, "__state", 7);
18031
-
int state = (int)tod(resolveprop(js, mkval(T_PROP, state_off)));
18032
-
18033
-
if (state == 1) {
18034
-
jsoff_t val_off = lkp(js, item_obj, "__value", 7);
18035
-
promise_any_try_resolve(js, tracker, resolveprop(js, mkval(T_PROP, val_off)));
18036
-
return result_promise;
18037
-
} else if (state == 2) {
18038
-
jsoff_t val_off = lkp(js, item_obj, "__value", 7);
18039
-
promise_any_record_rejection(js, tracker, i, resolveprop(js, mkval(T_PROP, val_off)));
18040
-
continue;
18052
+
uint32_t item_pid = get_promise_id(js, item);
18053
+
promise_data_entry_t *pd = get_promise_data(item_pid, false);
18054
+
if (pd) {
18055
+
if (pd->state == 1) {
18056
+
promise_any_try_resolve(js, tracker, pd->value);
18057
+
return result_promise;
18058
+
} else if (pd->state == 2) {
18059
+
promise_any_record_rejection(js, tracker, i, pd->value);
18060
+
continue;
18061
+
}
18041
18062
}
18042
18063
18043
18064
jsval_t resolve_obj = mkobj(js, 0);
+20
tests/loop.async.js
+20
tests/loop.async.js
···
1
+
let count = 0;
2
+
3
+
async function meow() {
4
+
count++;
5
+
return 'hi';
6
+
}
7
+
8
+
async function server() {
9
+
return await meow();
10
+
}
11
+
12
+
async function main() {
13
+
await server();
14
+
}
15
+
16
+
for (let i = 0; i < 40000; i++) {
17
+
void main();
18
+
}
19
+
20
+
console.log('done', count);