MIRROR: javascript for 🐜's, a tiny runtime with big ambitions
raw typeof
+111
-5
+1
include/ant.h
+1
include/ant.h
+1
-1
meson.build
+1
-1
meson.build
···
74
74
build_date = run_command('date', '+%Y-%m-%d', check: true).stdout().strip()
75
75
76
76
version_conf = configuration_data()
77
-
version_conf.set('ANT_VERSION', '0.0.8.17')
77
+
version_conf.set('ANT_VERSION', '0.0.8.18')
78
78
version_conf.set('ANT_GIT_HASH', git_hash)
79
79
version_conf.set('ANT_BUILD_DATE', build_date)
80
80
+72
-4
src/ant.c
+72
-4
src/ant.c
···
254
254
T_PROMISE, T_GENERATOR, T_BIGINT, T_PROPREF
255
255
};
256
256
257
-
static const char *typestr(uint8_t t) {
257
+
static const char *typestr_raw(uint8_t t) {
258
258
const char *names[] = {
259
259
"object", "prop", "string", "undefined", "null", "number",
260
-
"boolean", "function", "coderef", "cfunc", "err", "array", "promise", "generator", "bigint"
260
+
"boolean", "function", "coderef", "cfunc", "err", "array",
261
+
"promise", "generator", "bigint", "propref"
261
262
};
262
263
263
264
return (t < sizeof(names) / sizeof(names[0])) ? names[t] : "??";
···
266
267
static jsval_t tov(double d) { union { double d; jsval_t v; } u = {d}; return u.v; }
267
268
static double tod(jsval_t v) { union { jsval_t v; double d; } u = {v}; return u.d; }
268
269
static bool is_nan(jsval_t v) { return (v >> 52U) == 0x7feU; }
269
-
static uint8_t vtype(jsval_t v) { return is_nan(v) ? ((v >> 48U) & 15U) : (uint8_t) T_NUM; }
270
270
static size_t vdata(jsval_t v) { return (size_t) (v & ~((jsval_t) 0x7fffUL << 48U)); }
271
271
static jsoff_t coderefoff(jsval_t v) { return v & 0xffffffU; }
272
272
static jsoff_t codereflen(jsval_t v) { return (v >> 24U) & 0xffffffU; }
273
273
static jsoff_t propref_obj(jsval_t v) { return v & 0xffffffU; }
274
274
static jsoff_t propref_key(jsval_t v) { return (v >> 24U) & 0xffffffU; }
275
+
276
+
static const char *typestr(uint8_t t) {
277
+
return t == T_CFUNC ? "function" : typestr_raw(t);
278
+
}
279
+
280
+
uint8_t vtype(jsval_t v) {
281
+
return is_nan(v) ? ((v >> 48U) & 15U) : (uint8_t) T_NUM;
282
+
}
275
283
276
284
static jsval_t mkval(uint8_t type, uint64_t data) {
277
285
return ((jsval_t) 0x7fe0U << 48U) | ((jsval_t) (type) << 48) | (data & 0xffffffffffffUL);
···
4659
4667
}
4660
4668
return js_mkerr(js, "unexpected token after async");
4661
4669
}
4670
+
4662
4671
case TOK_NULL: return js_mknull();
4663
4672
case TOK_UNDEF: return js_mkundef();
4664
4673
case TOK_TRUE: return js_mktrue();
4665
4674
case TOK_FALSE: return js_mkfalse();
4666
4675
case TOK_THIS: return js->this_val;
4676
+
4677
+
case TOK_TYPEOF: return mkcoderef((jsoff_t) js->toff, (jsoff_t) js->tlen);
4667
4678
case TOK_FROM: return mkcoderef((jsoff_t) js->toff, (jsoff_t) js->tlen);
4668
4679
case TOK_VOID: return mkcoderef((jsoff_t) js->toff, (jsoff_t) js->tlen);
4669
4680
case TOK_DELETE: return mkcoderef((jsoff_t) js->toff, (jsoff_t) js->tlen);
···
4672
4683
case TOK_CATCH: return mkcoderef((jsoff_t) js->toff, (jsoff_t) js->tlen);
4673
4684
case TOK_TRY: return mkcoderef((jsoff_t) js->toff, (jsoff_t) js->tlen);
4674
4685
case TOK_FINALLY: return mkcoderef((jsoff_t) js->toff, (jsoff_t) js->tlen);
4686
+
4675
4687
default: return js_mkerr(js, "bad expr");
4676
4688
}
4677
4689
}
···
6351
6363
6352
6364
static jsval_t js_return(struct js *js) {
6353
6365
uint8_t exe = !(js->flags & F_NOEXEC);
6366
+
uint8_t in_func = js->flags & F_CALL;
6354
6367
js->consumed = 1;
6355
-
if (exe && !(js->flags & F_CALL)) return js_mkerr(js, "not in func");
6356
6368
jsval_t res = js_mkundef();
6357
6369
6358
6370
uint8_t nxt = next(js);
6359
6371
if (nxt != TOK_SEMICOLON && nxt != TOK_RBRACE && nxt != TOK_EOF) {
6360
6372
res = resolveprop(js, js_expr(js));
6361
6373
}
6374
+
6375
+
if (exe && !in_func) return js_mkundef();
6362
6376
6363
6377
if (exe) {
6364
6378
js->pos = js->clen;
···
7947
7961
return mkval(T_ARR, vdata(arr));
7948
7962
}
7949
7963
7964
+
static jsval_t builtin_object_values(struct js *js, jsval_t *args, int nargs) {
7965
+
if (nargs == 0) return mkarr(js);
7966
+
jsval_t obj = args[0];
7967
+
7968
+
if (vtype(obj) != T_OBJ && vtype(obj) != T_ARR && vtype(obj) != T_FUNC) return mkarr(js);
7969
+
if (vtype(obj) == T_FUNC) obj = mkval(T_OBJ, vdata(obj));
7970
+
7971
+
jsval_t arr = mkarr(js);
7972
+
jsoff_t idx = 0;
7973
+
jsoff_t next = loadoff(js, (jsoff_t) vdata(obj)) & ~(3U | CONSTMASK);
7974
+
7975
+
while (next < js->brk && next != 0) {
7976
+
jsoff_t koff = loadoff(js, next + (jsoff_t) sizeof(next));
7977
+
jsoff_t klen = offtolen(loadoff(js, koff));
7978
+
const char *key = (char *) &js->mem[koff + sizeof(koff)];
7979
+
jsval_t val = loadval(js, next + (jsoff_t) (sizeof(next) + sizeof(koff)));
7980
+
7981
+
next = loadoff(js, next) & ~(3U | CONSTMASK);
7982
+
7983
+
if (streq(key, klen, "__proto__", 9)) continue;
7984
+
if (klen > 7 && memcmp(key, "__desc_", 7) == 0) continue;
7985
+
7986
+
bool should_include = true;
7987
+
char desc_key[128];
7988
+
snprintf(desc_key, sizeof(desc_key), "__desc_%.*s", (int)klen, key);
7989
+
jsoff_t desc_off = lkp(js, obj, desc_key, strlen(desc_key));
7990
+
7991
+
if (desc_off != 0) {
7992
+
jsval_t desc_obj = resolveprop(js, mkval(T_PROP, desc_off));
7993
+
if (vtype(desc_obj) == T_OBJ) {
7994
+
jsoff_t enum_off = lkp(js, desc_obj, "enumerable", 10);
7995
+
if (enum_off != 0) {
7996
+
jsval_t enum_val = resolveprop(js, mkval(T_PROP, enum_off));
7997
+
should_include = js_truthy(js, enum_val);
7998
+
}
7999
+
}
8000
+
}
8001
+
8002
+
if (should_include) {
8003
+
char idxstr[16];
8004
+
snprintf(idxstr, sizeof(idxstr), "%u", (unsigned) idx);
8005
+
jsval_t idx_key = js_mkstr(js, idxstr, strlen(idxstr));
8006
+
setprop(js, arr, idx_key, val);
8007
+
idx++;
8008
+
}
8009
+
}
8010
+
8011
+
jsval_t len_key = js_mkstr(js, "length", 6);
8012
+
jsval_t len_val = tov((double) idx);
8013
+
setprop(js, arr, len_key, len_val);
8014
+
return mkval(T_ARR, vdata(arr));
8015
+
}
8016
+
7950
8017
static jsval_t builtin_object_getPrototypeOf(struct js *js, jsval_t *args, int nargs) {
7951
8018
if (nargs == 0) return js_mkerr(js, "Object.getPrototypeOf requires an argument");
7952
8019
jsval_t obj = args[0];
···
11324
11391
set_proto(js, obj_func_obj, function_proto);
11325
11392
setprop(js, obj_func_obj, js_mkstr(js, "__code", 6), js_mkstr(js, "__builtin_Object", 16));
11326
11393
setprop(js, obj_func_obj, js_mkstr(js, "keys", 4), js_mkfun(builtin_object_keys));
11394
+
setprop(js, obj_func_obj, js_mkstr(js, "values", 6), js_mkfun(builtin_object_values));
11327
11395
setprop(js, obj_func_obj, js_mkstr(js, "getPrototypeOf", 14), js_mkfun(builtin_object_getPrototypeOf));
11328
11396
setprop(js, obj_func_obj, js_mkstr(js, "setPrototypeOf", 14), js_mkfun(builtin_object_setPrototypeOf));
11329
11397
setprop(js, obj_func_obj, js_mkstr(js, "create", 6), js_mkfun(builtin_object_create));
+26
src/core/index.js
+26
src/core/index.js
···
3
3
Ant.version = '{{VERSION}}';
4
4
Ant.revision = '{{GIT_HASH}}';
5
5
Ant.buildDate = '{{BUILD_DATE}}';
6
+
7
+
Ant.typeof = function (t) {
8
+
const value = Ant.raw.typeof(t);
9
+
10
+
const types = {
11
+
T_OBJ: 'object',
12
+
T_PROP: 'prop',
13
+
T_STR: 'string',
14
+
T_UNDEF: 'undefined',
15
+
T_NULL: 'null',
16
+
T_NUM: 'number',
17
+
T_BOOL: 'boolean',
18
+
T_FUNC: 'function',
19
+
T_CODEREF: 'coderef',
20
+
T_CFUNC: 'cfunc',
21
+
T_ERR: 'err',
22
+
T_ARR: 'array',
23
+
T_PROMISE: 'promise',
24
+
T_GENERATOR: 'generator',
25
+
T_BIGINT: 'bigint',
26
+
T_PROPREF: 'propref'
27
+
};
28
+
29
+
const names = Object.values(types);
30
+
return value < names.length ? names[value] : '??';
31
+
};
+11
src/modules/builtin.c
+11
src/modules/builtin.c
···
91
91
return result;
92
92
}
93
93
94
+
// Ant.raw.typeof()
95
+
static jsval_t js_raw_typeof(struct js *js, jsval_t *args, int nargs) {
96
+
if (nargs < 1) return js_mkerr(js, "Ant.raw.typeof() requires 1 argument");
97
+
const uint8_t type = vtype(args[0]);
98
+
return js_mknum((double)type);
99
+
}
100
+
94
101
// Ant.stats()
95
102
static jsval_t js_stats_fn(struct js *js, jsval_t *args, int nargs) {
96
103
(void) args; (void) nargs;
···
114
121
js_set(js, ant_obj, "alloc", js_mkfun(js_alloc));
115
122
js_set(js, ant_obj, "stats", js_mkfun(js_stats_fn));
116
123
js_set(js, rt->ant_obj, "signal", js_mkfun(js_signal));
124
+
125
+
jsval_t raw_obj = js_mkobj(js);
126
+
js_set(js, raw_obj, "typeof", js_mkfun(js_raw_typeof));
127
+
js_set(js, ant_obj, "raw", raw_obj);
117
128
}