MIRROR: javascript for 🐜's, a tiny runtime with big ambitions
add property name and length to descriptor entries
+58
-121
+55
-120
src/ant.c
+55
-120
src/ant.c
···
304
304
305
305
typedef struct descriptor_entry {
306
306
uint64_t key;
307
+
jsoff_t obj_off;
308
+
char *prop_name;
309
+
size_t prop_len;
307
310
bool writable;
308
311
bool enumerable;
309
312
bool configurable;
···
1645
1648
1646
1649
if (!should_hide) {
1647
1650
descriptor_entry_t *desc = lookup_descriptor(obj_off, key, klen);
1648
-
if (desc) if (desc->has_getter || desc->has_setter || !desc->enumerable) should_hide = true;
1651
+
if (desc && !desc->enumerable) should_hide = true;
1649
1652
}
1650
1653
1651
1654
if (!should_hide) {
···
1656
1659
}
1657
1660
1658
1661
next = next_prop(header);
1662
+
}
1663
+
1664
+
descriptor_entry_t *desc, *tmp;
1665
+
HASH_ITER(hh, desc_registry, desc, tmp) {
1666
+
if (desc->obj_off != obj_off) continue;
1667
+
if (!desc->enumerable) continue;
1668
+
if (!desc->has_getter && !desc->has_setter) continue;
1669
+
count++;
1659
1670
}
1660
1671
1661
1672
if (prop_count) *prop_count = count;
···
1854
1865
jsoff_t next = loadoff(js, (jsoff_t) vdata(obj)) & ~(3U | FLAGMASK);
1855
1866
bool first = true;
1856
1867
1868
+
jsoff_t obj_off = (jsoff_t)vdata(obj);
1857
1869
int prop_capacity = 64;
1870
+
1858
1871
jsoff_t *prop_offsets = malloc(prop_capacity * sizeof(jsoff_t));
1859
1872
int num_props = 0;
1860
1873
···
1870
1883
bool should_hide = streq(key, klen, tag_sym_key, strlen(tag_sym_key));
1871
1884
1872
1885
if (!should_hide) {
1873
-
jsoff_t obj_off = (jsoff_t)vdata(obj);
1874
1886
descriptor_entry_t *desc = lookup_descriptor(obj_off, key, klen);
1875
-
if (desc) if (desc->has_getter || desc->has_setter || !desc->enumerable) should_hide = true;
1887
+
if (desc && !desc->enumerable) should_hide = true;
1876
1888
}
1877
1889
1878
1890
if (!should_hide) {
···
1916
1928
}
1917
1929
free(prop_offsets);
1918
1930
1919
-
next = loadoff(js, (jsoff_t) vdata(obj)) & ~(3U | FLAGMASK);
1920
-
while (next < js->brk && next != 0) {
1921
-
jsoff_t header = loadoff(js, next);
1922
-
if (is_slot_prop(header)) { next = next_prop(header); continue; }
1931
+
descriptor_entry_t *desc, *tmp;
1932
+
HASH_ITER(hh, desc_registry, desc, tmp) {
1933
+
if (desc->obj_off != obj_off) continue;
1934
+
if (!desc->enumerable) continue;
1935
+
if (!desc->has_getter && !desc->has_setter) continue;
1923
1936
1924
-
jsoff_t koff = loadoff(js, next + (jsoff_t) sizeof(next));
1925
-
jsoff_t klen = offtolen(loadoff(js, koff));
1926
-
const char *key = (char *) &js->mem[koff + sizeof(koff)];
1937
+
if (!first) n += cpy(buf + n, len - n, inline_mode ? ", " : ",\n", 2);
1938
+
first = false;
1939
+
if (!inline_mode) n += add_indent(buf + n, len - n, stringify_indent);
1940
+
n += cpy(buf + n, len - n, desc->prop_name, desc->prop_len);
1941
+
n += cpy(buf + n, len - n, ": ", 2);
1927
1942
1928
-
bool is_desc = (klen > 7 && key[0] == '_' && key[1] == '_' && key[2] == 'd' && key[3] == 'e' && key[4] == 's' && key[5] == 'c' && key[6] == '_');
1929
-
if (is_desc) {
1930
-
jsval_t desc_obj = loadval(js, next + (jsoff_t) (sizeof(next) + sizeof(koff)));
1931
-
desc_obj = resolveprop(js, desc_obj);
1932
-
if (vtype(desc_obj) == T_OBJ) {
1933
-
jsoff_t get_off = lkp_interned(js, desc_obj, INTERN_GET, 3);
1934
-
jsoff_t set_off = lkp_interned(js, desc_obj, INTERN_SET, 3);
1935
-
bool has_getter = false, has_setter = false;
1936
-
1937
-
if (get_off != 0) {
1938
-
jsval_t get_val = resolveprop(js, mkval(T_PROP, get_off));
1939
-
has_getter = (vtype(get_val) == T_FUNC || vtype(get_val) == T_CFUNC);
1940
-
}
1941
-
if (set_off != 0) {
1942
-
jsval_t set_val = resolveprop(js, mkval(T_PROP, set_off));
1943
-
has_setter = (vtype(set_val) == T_FUNC || vtype(set_val) == T_CFUNC);
1944
-
}
1945
-
1946
-
if (has_getter || has_setter) {
1947
-
jsoff_t enumerable_off = lkp(js, desc_obj, "enumerable", 10);
1948
-
bool is_enumerable = true;
1949
-
if (enumerable_off != 0) {
1950
-
jsval_t enumerable_val = resolveprop(js, mkval(T_PROP, enumerable_off));
1951
-
is_enumerable = js_truthy(js, enumerable_val);
1952
-
}
1953
-
1954
-
if (is_enumerable) {
1955
-
const char *prop_name = key + 7;
1956
-
size_t prop_len = klen - 7;
1957
-
1958
-
if (!first) n += cpy(buf + n, len - n, ",\n", 2);
1959
-
first = false;
1960
-
n += add_indent(buf + n, len - n, stringify_indent);
1961
-
n += cpy(buf + n, len - n, prop_name, prop_len);
1962
-
n += cpy(buf + n, len - n, ": ", 2);
1963
-
1964
-
if (has_getter && has_setter) {
1965
-
n += cpy(buf + n, len - n, "[Getter/Setter]", 15);
1966
-
} else if (has_getter) {
1967
-
n += cpy(buf + n, len - n, "[Getter]", 8);
1968
-
} else {
1969
-
n += cpy(buf + n, len - n, "[Setter]", 8);
1970
-
}
1971
-
}
1972
-
}
1973
-
}
1974
-
}
1975
-
next = next_prop(header);
1943
+
if (desc->has_getter && desc->has_setter) {
1944
+
n += cpy(buf + n, len - n, "[Getter/Setter]", 15);
1945
+
} else if (desc->has_getter) {
1946
+
n += cpy(buf + n, len - n, "[Getter]", 8);
1947
+
} else n += cpy(buf + n, len - n, "[Setter]", 8);
1976
1948
}
1977
1949
1978
1950
if (!inline_mode) stringify_indent--;
···
8361
8333
} else if (js->tok == TOK_DOT || js->tok == TOK_OPTIONAL_CHAIN) {
8362
8334
uint8_t op = js->tok;
8363
8335
js->consumed = 1;
8364
-
if (vtype(res) != T_PROP) {
8336
+
if (vtype(res) != T_PROP && vtype(res) != T_PROPREF) {
8365
8337
obj = res;
8366
-
} else {
8367
-
obj = resolveprop(js, res);
8368
-
}
8338
+
} else obj = resolveprop(js, res);
8369
8339
jsval_t prop_name;
8370
8340
uint8_t nxt = next(js);
8371
8341
if (nxt == TOK_HASH) {
···
13631
13601
13632
13602
jsval_t arr = mkarr(js);
13633
13603
jsoff_t idx = 0;
13634
-
jsoff_t next = loadoff(js, (jsoff_t) vdata(obj)) & ~(3U | FLAGMASK);
13604
+
13605
+
jsoff_t obj_off = (jsoff_t)vdata(obj);
13606
+
jsoff_t next = loadoff(js, obj_off) & ~(3U | FLAGMASK);
13635
13607
13636
13608
while (next < js->brk && next != 0) {
13637
13609
jsoff_t header = loadoff(js, next);
···
13645
13617
if (is_internal_prop(key, klen)) continue;
13646
13618
13647
13619
bool should_include = true;
13648
-
jsoff_t obj_off = (jsoff_t)vdata(obj);
13649
13620
descriptor_entry_t *desc = lookup_descriptor(obj_off, key, klen);
13650
-
13651
-
if (desc) {
13652
-
if (desc->has_getter || desc->has_setter) {
13653
-
continue;
13654
-
}
13655
-
should_include = desc->enumerable;
13656
-
}
13621
+
if (desc) should_include = desc->enumerable;
13657
13622
13658
13623
if (should_include) {
13659
13624
char idxstr[16];
···
13665
13630
}
13666
13631
}
13667
13632
13668
-
next = loadoff(js, (jsoff_t) vdata(obj)) & ~(3U | FLAGMASK);
13669
-
while (next < js->brk && next != 0) {
13670
-
jsoff_t header = loadoff(js, next);
13671
-
if (is_slot_prop(header)) { next = next_prop(header); continue; }
13672
-
13673
-
jsoff_t koff = loadoff(js, next + (jsoff_t) sizeof(next));
13674
-
jsoff_t klen = offtolen(loadoff(js, koff));
13675
-
const char *key = (char *) &js->mem[koff + sizeof(koff)];
13676
-
13677
-
next = next_prop(header);
13633
+
descriptor_entry_t *desc, *tmp;
13634
+
HASH_ITER(hh, desc_registry, desc, tmp) {
13635
+
if (desc->obj_off != obj_off) continue;
13636
+
if (!desc->enumerable) continue;
13637
+
if (!desc->has_getter && !desc->has_setter) continue;
13678
13638
13679
-
if (klen > 7 && key[0] == '_' && key[1] == '_' && key[2] == 'd' &&
13680
-
key[3] == 'e' && key[4] == 's' && key[5] == 'c' && key[6] == '_') {
13681
-
jsval_t desc_obj = resolveprop(js, mkval(T_PROP, lkp(js, obj, key, klen)));
13682
-
if (vtype(desc_obj) == T_OBJ) {
13683
-
jsoff_t get_off = lkp_interned(js, desc_obj, INTERN_GET, 3);
13684
-
jsoff_t set_off = lkp_interned(js, desc_obj, INTERN_SET, 3);
13685
-
bool has_accessor = false;
13686
-
13687
-
if (get_off != 0) {
13688
-
jsval_t get_val = resolveprop(js, mkval(T_PROP, get_off));
13689
-
if (vtype(get_val) == T_FUNC || vtype(get_val) == T_CFUNC) has_accessor = true;
13690
-
}
13691
-
if (set_off != 0) {
13692
-
jsval_t set_val = resolveprop(js, mkval(T_PROP, set_off));
13693
-
if (vtype(set_val) == T_FUNC || vtype(set_val) == T_CFUNC) has_accessor = true;
13694
-
}
13695
-
13696
-
if (has_accessor) {
13697
-
jsoff_t enum_off = lkp(js, desc_obj, "enumerable", 10);
13698
-
bool is_enumerable = true;
13699
-
if (enum_off != 0) {
13700
-
jsval_t enum_val = resolveprop(js, mkval(T_PROP, enum_off));
13701
-
is_enumerable = js_truthy(js, enum_val);
13702
-
}
13703
-
13704
-
if (is_enumerable) {
13705
-
const char *prop_name = key + 7;
13706
-
size_t prop_len = klen - 7;
13707
-
13708
-
char idxstr[16];
13709
-
size_t idxlen = uint_to_str(idxstr, sizeof(idxstr), (unsigned)idx);
13710
-
jsval_t idx_key = js_mkstr(js, idxstr, idxlen);
13711
-
jsval_t key_val = js_mkstr(js, prop_name, prop_len);
13712
-
setprop(js, arr, idx_key, key_val);
13713
-
idx++;
13714
-
}
13715
-
}
13716
-
}
13717
-
}
13639
+
char idxstr[16];
13640
+
size_t idxlen = uint_to_str(idxstr, sizeof(idxstr), (unsigned)idx);
13641
+
jsval_t idx_key = js_mkstr(js, idxstr, idxlen);
13642
+
jsval_t key_val = js_mkstr(js, desc->prop_name, desc->prop_len);
13643
+
setprop(js, arr, idx_key, key_val);
13644
+
idx++;
13718
13645
}
13719
13646
13720
13647
for (jsoff_t i = 0; i < idx / 2; i++) {
···
21714
21641
if (desc->has_setter) FWD_VAL(desc->setter);
21715
21642
jsoff_t obj_off = fwd_off(ctx, (jsoff_t)(desc->key >> 32));
21716
21643
desc->key = ((uint64_t)obj_off << 32) | (uint32_t)(desc->key & 0xFFFFFFFF);
21644
+
desc->obj_off = obj_off;
21717
21645
});
21718
21646
21719
21647
for (coroutine_t *coro = pending_coroutines.head; coro; coro = coro->next) {
···
22135
22063
entry = (descriptor_entry_t *)malloc(sizeof(descriptor_entry_t));
22136
22064
if (!entry) return NULL;
22137
22065
entry->key = desc_key;
22066
+
entry->obj_off = obj_off;
22067
+
entry->prop_name = (char *)malloc(klen + 1);
22068
+
if (entry->prop_name) {
22069
+
memcpy(entry->prop_name, key, klen);
22070
+
entry->prop_name[klen] = '\0';
22071
+
}
22072
+
entry->prop_len = klen;
22138
22073
entry->writable = true;
22139
22074
entry->enumerable = true;
22140
22075
entry->configurable = true;
+3
-1
src/modules/io.c
+3
-1
src/modules/io.c
···
195
195
196
196
lt:
197
197
if (memcmp(p, "<ref", 4) == 0) { EMIT_UNTIL('>', JSON_REF) }
198
-
io_putc(*p++, stream); goto next;
198
+
while (*p && *p != '>') io_putc(*p++, stream);
199
+
if (*p == '>') io_putc(*p++, stream);
200
+
goto next;
199
201
200
202
alpha:
201
203
if (memcmp(p, "Object [", 8) == 0) {