MIRROR: javascript for 🐜's, a tiny runtime with big ambitions
migrate to js_true/js_false
+226
-222
+6
-3
examples/embed/embed.c
+6
-3
examples/embed/embed.c
···
137
137
jsval_t global = js_glob(js);
138
138
139
139
jsval_t config = js_mkobj(js);
140
-
js_set(js, config, "debug", js_mktrue());
140
+
js_set(js, config, "debug", js_true);
141
141
js_set(js, config, "version", js_mknum(1.0));
142
142
js_set(js, config, "name", js_mkstr(js, "MyApp", 5));
143
143
js_set(js, global, "config", config);
···
153
153
printf(" Result: %s\n", js_str(js, result));
154
154
155
155
jsval_t name_val = js_get(js, config, "name");
156
-
printf(" config.name from C: %s\n", js_str(js, name_val));
156
+
printf(" config.name: %s\n", js_str(js, name_val));
157
+
158
+
jsval_t debug_val = js_get(js, config, "debug");
159
+
printf(" config.debug: %s\n", js_str(js, debug_val));
157
160
158
161
js_destroy(js);
159
162
}
···
421
424
jsval_t global = js_glob(js);
422
425
js_set(js, global, "myNumber", js_mknum(42));
423
426
js_set(js, global, "myString", js_mkstr(js, "hello from C", 12));
424
-
js_set(js, global, "myBool", js_mktrue());
427
+
js_set(js, global, "myBool", js_true);
425
428
426
429
jsval_t myObj = js_mkobj(js);
427
430
js_set(js, myObj, "a", js_mknum(1));
+5
-3
include/ant.h
+5
-3
include/ant.h
···
17
17
#define STR_PROTO "__proto__"
18
18
#define STR_PROTO_LEN 9
19
19
20
+
#define ANT_LIMIT_SIZE_CACHE 16384
21
+
20
22
#define ANT_STRING(s) js_mkstr(js, s, sizeof(s) - 1)
21
23
#define ANT_PTR(ptr) js_mknum((double)(uintptr_t)(ptr))
22
24
#define ANT_COPY(buf, len, s) cpy(buf, len, s, sizeof(s) - 1)
···
27
29
#define JS_INF ((double)INFINITY)
28
30
#define JS_NEG_INF ((double)(-INFINITY))
29
31
30
-
#define ANT_LIMIT_SIZE_CACHE 16384
32
+
#define js_true (NANBOX_PREFIX | ((jsval_t)T_BOOL << NANBOX_TYPE_SHIFT) | 1)
33
+
#define js_false (NANBOX_PREFIX | ((jsval_t)T_BOOL << NANBOX_TYPE_SHIFT))
34
+
#define js_bool(x) (js_false | (jsval_t)!!(x))
31
35
32
36
#define JS_DESC_W (1 << 0)
33
37
#define JS_DESC_E (1 << 1)
···
63
67
64
68
jsval_t js_mkundef(void);
65
69
jsval_t js_mknull(void);
66
-
jsval_t js_mktrue(void);
67
-
jsval_t js_mkfalse(void);
68
70
jsval_t js_mknum(double);
69
71
70
72
jsval_t js_getthis(ant_t *);
-3
include/internal.h
-3
include/internal.h
+77
-80
src/ant.c
+77
-80
src/ant.c
···
2792
2792
static void set_func_code(struct js *js, jsval_t func_obj, const char *code, size_t len) {
2793
2793
const char *arena_code = code_arena_alloc(code, len);
2794
2794
if (!arena_code) return;
2795
-
2796
2795
set_func_code_ptr(js, func_obj, arena_code, len);
2797
-
if (!code_has_function_decl(code, len)) set_slot(js, func_obj, SLOT_NO_FUNC_DECLS, js_mktrue());
2798
2796
2797
+
if (!code_has_function_decl(code, len)) set_slot(js, func_obj, SLOT_NO_FUNC_DECLS, js_true);
2799
2798
if (!memmem(code, len, "var", 3)) return;
2800
2799
2801
2800
size_t vars_buf_len;
···
6372
6371
6373
6372
jsval_t closure_scope = get_slot(js, func_obj, SLOT_SCOPE);
6374
6373
jsval_t async_slot = get_slot(js, func_obj, SLOT_ASYNC);
6375
-
bool is_async = vtype(async_slot) == T_BOOL && vdata(async_slot) == 1;
6374
+
bool is_async = (async_slot == js_true);
6376
6375
6377
6376
jsval_t captured_this = js_mkundef();
6378
6377
bool is_arrow = false;
···
7858
7857
js_set_descriptor(js, func_obj, "length", 6, JS_DESC_C);
7859
7858
7860
7859
if (is_async) {
7861
-
set_slot(js, func_obj, SLOT_ASYNC, js_mktrue());
7860
+
set_slot(js, func_obj, SLOT_ASYNC, js_true);
7862
7861
jsval_t async_proto = get_slot(js, js_glob(js), SLOT_ASYNC_PROTO);
7863
7862
if (vtype(async_proto) == T_FUNC) set_proto(js, func_obj, async_proto);
7864
7863
} else {
···
7880
7879
jsval_t closure_scope = for_let_capture_scope(js);
7881
7880
if (is_err(closure_scope)) return closure_scope;
7882
7881
set_slot(js, func_obj, SLOT_SCOPE, closure_scope);
7883
-
if (flags & F_STRICT) set_slot(js, func_obj, SLOT_STRICT, js_mktrue());
7882
+
if (flags & F_STRICT) set_slot(js, func_obj, SLOT_STRICT, js_true);
7884
7883
}
7885
7884
7886
7885
jsval_t func = mkval(T_FUNC, (unsigned long) vdata(func_obj));
···
8009
8008
if (is_err(func_obj)) { free(fn_str); return func_obj; }
8010
8009
set_func_code(js, func_obj, fn_str, fn_pos);
8011
8010
free(fn_str);
8012
-
set_slot(js, func_obj, SLOT_ASYNC, js_mktrue());
8013
-
set_slot(js, func_obj, SLOT_ARROW, tov(1));
8011
+
set_slot(js, func_obj, SLOT_ASYNC, js_true);
8012
+
set_slot(js, func_obj, SLOT_ARROW, js_true);
8014
8013
jsval_t async_proto = get_slot(js, js_glob(js), SLOT_ASYNC_PROTO);
8015
8014
if (vtype(async_proto) == T_FUNC) set_proto(js, func_obj, async_proto);
8016
8015
if (!(flags & F_NOEXEC)) {
···
8079
8078
return super_ctor;
8080
8079
}
8081
8080
8081
+
case TOK_TRUE: return js_true;
8082
+
case TOK_FALSE: return js_false;
8083
+
8082
8084
case TOK_NULL: return js_mknull();
8083
8085
case TOK_UNDEF: return js_mkundef();
8084
-
case TOK_TRUE: return js_mktrue();
8085
-
case TOK_FALSE: return js_mkfalse();
8086
8086
case TOK_THIS: return js->this_val;
8087
8087
8088
8088
default:
···
8161
8161
free(fn_str);
8162
8162
8163
8163
if (is_async) {
8164
-
set_slot(js, func_obj, SLOT_ASYNC, js_mktrue());
8164
+
set_slot(js, func_obj, SLOT_ASYNC, js_true);
8165
8165
jsval_t async_proto = get_slot(js, js_glob(js), SLOT_ASYNC_PROTO);
8166
8166
if (vtype(async_proto) == T_FUNC) set_proto(js, func_obj, async_proto);
8167
8167
} else {
···
8176
8176
set_slot(js, func_obj, SLOT_THIS, js->this_val);
8177
8177
}
8178
8178
8179
-
set_slot(js, func_obj, SLOT_ARROW, tov(1));
8179
+
set_slot(js, func_obj, SLOT_ARROW, js_true);
8180
8180
return mkval(T_FUNC, (unsigned long) vdata(func_obj));
8181
8181
}
8182
8182
···
8473
8473
static jsval_t check_frozen_sealed(struct js *js, jsval_t obj, const char *action) {
8474
8474
if (js_truthy(js, get_slot(js, obj, SLOT_FROZEN))) {
8475
8475
if (js->flags & F_STRICT) return js_mkerr(js, "cannot %s property of frozen object", action);
8476
-
return js_mkfalse();
8476
+
return js_false;
8477
8477
}
8478
8478
if (js_truthy(js, get_slot(js, obj, SLOT_SEALED))) {
8479
8479
if (js->flags & F_STRICT) return js_mkerr(js, "cannot %s property of sealed object", action);
8480
-
return js_mkfalse();
8480
+
return js_false;
8481
8481
}
8482
8482
return js_mkundef();
8483
8483
}
···
8633
8633
js->flags = (saved_flags & ~F_THROW) | F_NOEXEC;
8634
8634
js_postfix(js);
8635
8635
js->flags = saved_flags;
8636
-
return js_mktrue();
8636
+
return js_true;
8637
8637
}
8638
-
if (js->flags & F_NOEXEC) return js_mktrue();
8638
+
if (js->flags & F_NOEXEC) return js_true;
8639
8639
8640
8640
if (vtype(operand) == T_PROPREF) {
8641
8641
jsoff_t obj_off = propref_obj(operand);
···
8647
8647
8648
8648
if (is_proxy(js, obj)) {
8649
8649
jsval_t result = proxy_delete(js, obj, key_str, len);
8650
-
return is_err(result) ? result : (js_truthy(js, result) ? js_mktrue() : js_mkfalse());
8650
+
return is_err(result) ? result : js_bool(js_truthy(js, result));
8651
8651
}
8652
8652
8653
8653
jsval_t err = check_frozen_sealed(js, obj, "delete");
8654
8654
if (vtype(err) != T_UNDEF) return err;
8655
8655
8656
8656
jsoff_t prop_off = lkp(js, obj, key_str, len);
8657
-
if (prop_off == 0) return js_mktrue();
8657
+
if (prop_off == 0) return js_true;
8658
8658
8659
8659
if (is_nonconfig_prop(js, prop_off)) {
8660
8660
if (js->flags & F_STRICT) return js_mkerr_typed(js, JS_ERR_TYPE, "cannot delete non-configurable property");
8661
-
return js_mkfalse();
8661
+
return js_false;
8662
8662
}
8663
8663
8664
8664
descriptor_entry_t *desc = lookup_descriptor(obj_off, key_str, len);
8665
8665
if (desc && !desc->configurable) {
8666
8666
if (js->flags & F_STRICT) return js_mkerr_typed(js, JS_ERR_TYPE, "cannot delete non-configurable property");
8667
-
return js_mkfalse();
8667
+
return js_false;
8668
8668
}
8669
8669
8670
8670
jsoff_t first_prop = loadoff(js, obj_off) & ~(3U | FLAGMASK);
8671
8671
if (first_prop == prop_off) {
8672
8672
unlink_prop(js, obj_off, prop_off, 0);
8673
-
return js_mktrue();
8673
+
return js_true;
8674
8674
}
8675
8675
for (jsoff_t prev = first_prop; prev != 0; ) {
8676
8676
jsoff_t next_prop = loadoff(js, prev) & ~(3U | FLAGMASK);
8677
8677
if (next_prop == prop_off) {
8678
8678
unlink_prop(js, obj_off, prop_off, prev);
8679
-
return js_mktrue();
8679
+
return js_true;
8680
8680
}
8681
8681
prev = next_prop;
8682
8682
}
8683
-
return js_mktrue();
8683
+
return js_true;
8684
8684
}
8685
8685
8686
-
if (vtype(operand) != T_PROP) return js_mktrue();
8686
+
if (vtype(operand) != T_PROP) return js_true;
8687
8687
8688
8688
jsoff_t prop_off = (jsoff_t)vdata(operand);
8689
8689
if (is_nonconfig_prop(js, prop_off)) {
8690
8690
if (js->flags & F_STRICT) return js_mkerr(js, "cannot delete non-configurable property");
8691
-
return js_mkfalse();
8691
+
return js_false;
8692
8692
}
8693
8693
8694
8694
jsoff_t owner_obj_off = 0, prev_prop_off = 0;
···
8721
8721
descriptor_entry_t *desc = lookup_descriptor(owner_obj_off, key_str, key_len);
8722
8722
if (desc && !desc->configurable) {
8723
8723
if (js->flags & F_STRICT) return js_mkerr_typed(js, JS_ERR_TYPE, "cannot delete non-configurable property");
8724
-
return js_mkfalse();
8724
+
return js_false;
8725
8725
}
8726
8726
unlink_prop(js, owner_obj_off, prop_off, is_first_prop ? 0 : prev_prop_off);
8727
8727
}
8728
-
return js_mktrue();
8728
+
return js_true;
8729
8729
}
8730
8730
8731
8731
do_await: {
···
9617
9617
if (is_err(closure_scope)) return closure_scope;
9618
9618
set_slot(js, func_obj, SLOT_SCOPE, closure_scope);
9619
9619
if (flags & F_STRICT) {
9620
-
set_slot(js, func_obj, SLOT_STRICT, js_mktrue());
9620
+
set_slot(js, func_obj, SLOT_STRICT, js_true);
9621
9621
}
9622
9622
}
9623
9623
···
9665
9665
jsval_t func_obj = mkobj(js, 0);
9666
9666
if (is_err(func_obj)) return func_obj;
9667
9667
set_func_code(js, func_obj, &js->code[pos], js->pos - pos);
9668
-
set_slot(js, func_obj, SLOT_ASYNC, js_mktrue());
9668
+
set_slot(js, func_obj, SLOT_ASYNC, js_true);
9669
9669
jsval_t async_proto = get_slot(js, js_glob(js), SLOT_ASYNC_PROTO);
9670
9670
if (vtype(async_proto) == T_FUNC) set_proto(js, func_obj, async_proto);
9671
9671
jsval_t len_key = js_mkstr(js, "length", 6);
···
9684
9684
jsval_t closure_scope = for_let_capture_scope(js);
9685
9685
if (is_err(closure_scope)) return closure_scope;
9686
9686
set_slot(js, func_obj, SLOT_SCOPE, closure_scope);
9687
-
if (flags & F_STRICT) set_slot(js, func_obj, SLOT_STRICT, js_mktrue());
9687
+
if (flags & F_STRICT) set_slot(js, func_obj, SLOT_STRICT, js_true);
9688
9688
}
9689
9689
jsval_t func = mkval(T_FUNC, (unsigned long) vdata(func_obj));
9690
9690
···
11497
11497
set_slot(js, method_obj, SLOT_SCOPE, func_scope);
11498
11498
11499
11499
if (m->is_async) {
11500
-
set_slot(js, method_obj, SLOT_ASYNC, js_mktrue());
11500
+
set_slot(js, method_obj, SLOT_ASYNC, js_true);
11501
11501
jsval_t async_proto = get_slot(js, js_glob(js), SLOT_ASYNC_PROTO);
11502
11502
if (vtype(async_proto) == T_FUNC) set_proto(js, method_obj, async_proto);
11503
11503
} else {
···
11531
11531
set_func_code(js, func_obj, &js->code[constructor_params_start], code_len);
11532
11532
} else {
11533
11533
set_func_code_ptr(js, func_obj, "(){}", 4);
11534
-
if (super_len > 0) set_slot(js, func_obj, SLOT_DEFAULT_CTOR, js_mktrue());
11534
+
if (super_len > 0) set_slot(js, func_obj, SLOT_DEFAULT_CTOR, js_true);
11535
11535
}
11536
11536
11537
11537
int instance_field_count = 0;
···
12196
12196
12197
12197
set_func_code_ptr(js, func_obj, "(){}", 4);
12198
12198
set_slot(js, func_obj, SLOT_SCOPE, js_glob(js));
12199
-
set_slot(js, func_obj, SLOT_ASYNC, js_mktrue());
12199
+
set_slot(js, func_obj, SLOT_ASYNC, js_true);
12200
12200
12201
12201
jsval_t async_proto = get_slot(js, js_glob(js), SLOT_ASYNC_PROTO);
12202
12202
if (vtype(async_proto) == T_FUNC) set_proto(js, func_obj, async_proto);
···
12259
12259
set_func_code(js, func_obj, code_buf, pos);
12260
12260
free(code_buf);
12261
12261
set_slot(js, func_obj, SLOT_SCOPE, js_glob(js));
12262
-
set_slot(js, func_obj, SLOT_ASYNC, js_mktrue());
12262
+
set_slot(js, func_obj, SLOT_ASYNC, js_true);
12263
12263
12264
12264
jsval_t async_proto = get_slot(js, js_glob(js), SLOT_ASYNC_PROTO);
12265
12265
if (vtype(async_proto) == T_FUNC) set_proto(js, func_obj, async_proto);
···
12346
12346
12347
12347
if (code && code_len > 0) {
12348
12348
jsval_t async_slot = get_slot(js, func_obj, SLOT_ASYNC);
12349
+
jsval_t arrow_slot = get_slot(js, func_obj, SLOT_ARROW);
12349
12350
12350
12351
bool is_async = (async_slot == js_true);
12351
-
bool is_arrow = vtype(get_slot(js, func_obj, SLOT_ARROW)) != T_UNDEF;
12352
+
bool is_arrow = (arrow_slot == js_true);
12352
12353
12353
12354
if (is_arrow) {
12354
12355
const char *brace = memchr(code, '{', code_len);
···
12522
12523
12523
12524
jsval_t async_slot = get_slot(js, func_obj, SLOT_ASYNC);
12524
12525
if (vtype(async_slot) == T_BOOL && vdata(async_slot) == 1) {
12525
-
set_slot(js, bound_func, SLOT_ASYNC, js_mktrue());
12526
+
set_slot(js, bound_func, SLOT_ASYNC, js_true);
12526
12527
jsval_t async_proto = get_slot(js, js_glob(js), SLOT_ASYNC_PROTO);
12527
12528
if (vtype(async_proto) == T_FUNC) set_proto(js, bound_func, async_proto);
12528
12529
} else {
···
14242
14243
return js_mkerr(js, "Cannot define property %.*s, object is not extensible", (int)prop_len, prop_str);
14243
14244
if (js_truthy(js, get_slot(js, as_obj, SLOT_SEALED)))
14244
14245
return js_mkerr(js, "Cannot define property %.*s, object is not extensible", (int)prop_len, prop_str);
14245
-
if (get_slot(js, as_obj, SLOT_EXTENSIBLE) == js_mkfalse())
14246
+
if (get_slot(js, as_obj, SLOT_EXTENSIBLE) == js_false)
14246
14247
return js_mkerr(js, "Cannot define property %.*s, object is not extensible", (int)prop_len, prop_str);
14247
14248
}
14248
14249
···
14447
14448
js_set_descriptor(js, as_obj, key, klen, JS_DESC_E);
14448
14449
}
14449
14450
14450
-
set_slot(js, as_obj, SLOT_FROZEN, js_mktrue());
14451
+
set_slot(js, as_obj, SLOT_FROZEN, js_true);
14451
14452
return obj;
14452
14453
}
14453
14454
14454
14455
static jsval_t builtin_object_isFrozen(struct js *js, jsval_t *args, int nargs) {
14455
-
if (nargs == 0) return js_mktrue();
14456
+
if (nargs == 0) return js_true;
14456
14457
14457
14458
jsval_t obj = args[0];
14458
14459
uint8_t t = vtype(obj);
14459
14460
14460
-
if (t != T_OBJ && t != T_ARR && t != T_FUNC) return js_mktrue();
14461
+
if (t != T_OBJ && t != T_ARR && t != T_FUNC) return js_true;
14461
14462
jsval_t as_obj = (t == T_OBJ) ? obj : mkval(T_OBJ, vdata(obj));
14462
14463
14463
-
return js_truthy(js, get_slot(js, as_obj, SLOT_FROZEN)) ? js_mktrue() : js_mkfalse();
14464
+
return js_bool(js_truthy(js, get_slot(js, as_obj, SLOT_FROZEN)));
14464
14465
}
14465
14466
14466
14467
static jsval_t builtin_object_seal(struct js *js, jsval_t *args, int nargs) {
···
14472
14473
if (t != T_OBJ && t != T_ARR && t != T_FUNC) return obj;
14473
14474
jsval_t as_obj = (t == T_OBJ) ? obj : mkval(T_OBJ, vdata(obj));
14474
14475
14475
-
set_slot(js, as_obj, SLOT_SEALED, js_mktrue());
14476
+
set_slot(js, as_obj, SLOT_SEALED, js_true);
14476
14477
jsoff_t next = loadoff(js, (jsoff_t) vdata(as_obj)) & ~(3U | FLAGMASK);
14477
14478
14478
14479
while (next < js->brk && next != 0) {
···
14504
14505
}
14505
14506
14506
14507
static jsval_t builtin_object_isSealed(struct js *js, jsval_t *args, int nargs) {
14507
-
if (nargs == 0) return js_mktrue();
14508
+
if (nargs == 0) return js_true;
14508
14509
14509
14510
jsval_t obj = args[0];
14510
14511
uint8_t t = vtype(obj);
14511
14512
14512
-
if (t != T_OBJ && t != T_ARR && t != T_FUNC) return js_mktrue();
14513
+
if (t != T_OBJ && t != T_ARR && t != T_FUNC) return js_true;
14513
14514
jsval_t as_obj = (t == T_OBJ) ? obj : mkval(T_OBJ, vdata(obj));
14514
14515
14515
-
if (js_truthy(js, get_slot(js, as_obj, SLOT_SEALED))) return js_mktrue();
14516
-
if (js_truthy(js, get_slot(js, as_obj, SLOT_FROZEN))) return js_mktrue();
14516
+
if (js_truthy(js, get_slot(js, as_obj, SLOT_SEALED))) return js_true;
14517
+
if (js_truthy(js, get_slot(js, as_obj, SLOT_FROZEN))) return js_true;
14517
14518
14518
-
return js_mkfalse();
14519
+
return js_false;
14519
14520
}
14520
14521
14521
14522
static jsval_t builtin_object_fromEntries(struct js *js, jsval_t *args, int nargs) {
···
14601
14602
if (desc->has_setter) {
14602
14603
setprop(js, result, js_mkstr(js, "set", 3), desc->setter);
14603
14604
}
14604
-
setprop(js, result, js_mkstr(js, "enumerable", 10), desc->enumerable ? js_mktrue() : js_mkfalse());
14605
-
setprop(js, result, js_mkstr(js, "configurable", 12), desc->configurable ? js_mktrue() : js_mkfalse());
14605
+
setprop(js, result, js_mkstr(js, "enumerable", 10), js_bool(desc->enumerable));
14606
+
setprop(js, result, js_mkstr(js, "configurable", 12), js_bool(desc->configurable));
14606
14607
} else {
14607
14608
if (prop_off != 0) {
14608
14609
jsval_t prop_val = resolveprop(js, mkval(T_PROP, prop_off));
14609
14610
setprop(js, result, js_mkstr(js, "value", 5), prop_val);
14610
14611
}
14611
-
setprop(js, result, js_mkstr(js, "writable", 8), desc ? (desc->writable ? js_mktrue() : js_mkfalse()) : js_mktrue());
14612
-
setprop(js, result, js_mkstr(js, "enumerable", 10), desc ? (desc->enumerable ? js_mktrue() : js_mkfalse()) : js_mktrue());
14613
-
setprop(js, result, js_mkstr(js, "configurable", 12), desc ? (desc->configurable ? js_mktrue() : js_mkfalse()) : js_mktrue());
14612
+
setprop(js, result, js_mkstr(js, "writable", 8), desc ? (js_bool(desc->writable)) : js_true);
14613
+
setprop(js, result, js_mkstr(js, "enumerable", 10), desc ? (js_bool(desc->enumerable)) : js_true);
14614
+
setprop(js, result, js_mkstr(js, "configurable", 12), desc ? (js_bool(desc->configurable)) : js_true);
14614
14615
}
14615
14616
14616
14617
return result;
···
14676
14677
}
14677
14678
14678
14679
static jsval_t builtin_object_isExtensible(struct js *js, jsval_t *args, int nargs) {
14679
-
if (nargs == 0) return js_mktrue();
14680
+
if (nargs == 0) return js_true;
14680
14681
14681
14682
jsval_t obj = args[0];
14682
14683
uint8_t t = vtype(obj);
14683
14684
14684
-
if (t != T_OBJ && t != T_ARR && t != T_FUNC) return js_mktrue();
14685
+
if (t != T_OBJ && t != T_ARR && t != T_FUNC) return js_true;
14685
14686
jsval_t as_obj = (t == T_OBJ) ? obj : mkval(T_OBJ, vdata(obj));
14686
14687
14687
-
if (js_truthy(js, get_slot(js, as_obj, SLOT_FROZEN))) return js_mkfalse();
14688
-
if (js_truthy(js, get_slot(js, as_obj, SLOT_SEALED))) return js_mkfalse();
14688
+
if (js_truthy(js, get_slot(js, as_obj, SLOT_FROZEN))) return js_false;
14689
+
if (js_truthy(js, get_slot(js, as_obj, SLOT_SEALED))) return js_false;
14689
14690
14690
14691
jsval_t ext_slot = get_slot(js, as_obj, SLOT_EXTENSIBLE);
14691
-
if (vtype(ext_slot) != T_UNDEF) {
14692
-
return js_truthy(js, ext_slot) ? js_mktrue() : js_mkfalse();
14693
-
}
14692
+
if (vtype(ext_slot) != T_UNDEF) return js_bool(js_truthy(js, ext_slot));
14694
14693
14695
-
return js_mktrue();
14694
+
return js_true;
14696
14695
}
14697
14696
14698
14697
static jsval_t builtin_object_preventExtensions(struct js *js, jsval_t *args, int nargs) {
···
14704
14703
if (t != T_OBJ && t != T_ARR && t != T_FUNC) return obj;
14705
14704
jsval_t as_obj = (t == T_OBJ) ? obj : mkval(T_OBJ, vdata(obj));
14706
14705
14707
-
set_slot(js, as_obj, SLOT_EXTENSIBLE, js_mkfalse());
14706
+
set_slot(js, as_obj, SLOT_EXTENSIBLE, js_false);
14708
14707
return obj;
14709
14708
}
14710
14709
···
19286
19285
19287
19286
static bool promise_any_try_resolve(struct js *js, jsval_t tracker, jsval_t value) {
19288
19287
if (js_truthy(js, js_get(js, tracker, "resolved"))) return false;
19289
-
js_set(js, tracker, "resolved", js_mktrue());
19288
+
js_set(js, tracker, "resolved", js_true);
19290
19289
resolve_promise(js, get_slot(js, tracker, SLOT_DATA), value);
19291
19290
return true;
19292
19291
}
···
19340
19339
19341
19340
setprop(js, tracker, js_mkstr(js, "remaining", 9), tov((double)len));
19342
19341
setprop(js, tracker, js_mkstr(js, "errors", 6), errors);
19343
-
setprop(js, tracker, js_mkstr(js, "resolved", 8), js_mkfalse());
19342
+
setprop(js, tracker, js_mkstr(js, "resolved", 8), js_false);
19344
19343
setprop(js, errors, js_mkstr(js, "length", 6), tov((double)len));
19345
19344
19346
19345
for (int i = 0; i < len; i++) {
···
19470
19469
if (is_proxy(js, r)) {
19471
19470
jsval_t result = proxy_has(js, r, prop_name, prop_len);
19472
19471
if (is_err(result)) return result;
19473
-
return js_truthy(js, result) ? js_mktrue() : js_mkfalse();
19472
+
return js_bool(js_truthy(js, result));
19474
19473
}
19475
19474
19476
19475
jsoff_t found = lkp_proto(js, r, prop_name, prop_len);
···
20036
20035
}
20037
20036
}
20038
20037
20039
-
setprop(js, import_meta, js_mkstr(js, "main", 4), js_mktrue());
20038
+
setprop(js, import_meta, js_mkstr(js, "main", 4), js_true);
20040
20039
jsval_t resolve_fn = js_mkfun(builtin_import_meta_resolve);
20041
20040
setprop(js, import_meta, js_mkstr(js, "resolve", 7), resolve_fn);
20042
20041
···
20689
20688
20690
20689
jsval_t result = js_mkobj(js);
20691
20690
if (idx >= len) {
20692
-
js_set(js, result, "done", js_mktrue());
20691
+
js_set(js, result, "done", js_true);
20693
20692
js_set(js, result, "value", js_mkundef());
20694
20693
} else {
20695
20694
char idxstr[16];
···
20700
20699
js_arr_push(js, entry, k);
20701
20700
js_arr_push(js, entry, v);
20702
20701
js_set(js, result, "value", entry);
20703
-
js_set(js, result, "done", js_mkfalse());
20702
+
js_set(js, result, "done", js_false);
20704
20703
js_set(js, this_val, "__idx", js_mknum(idx + 1));
20705
20704
}
20706
20705
return result;
···
20745
20744
20746
20745
jsval_t result = js_mkobj(js);
20747
20746
if (idx >= len) {
20748
-
js_set(js, result, "done", js_mktrue());
20747
+
js_set(js, result, "done", js_true);
20749
20748
js_set(js, result, "value", js_mkundef());
20750
20749
} else {
20751
20750
char idxstr[16];
20752
20751
uint_to_str(idxstr, sizeof(idxstr), (unsigned)idx);
20753
20752
jsval_t v = js_get(js, vals, idxstr);
20754
20753
js_set(js, result, "value", v);
20755
-
js_set(js, result, "done", js_mkfalse());
20754
+
js_set(js, result, "done", js_false);
20756
20755
js_set(js, this_val, "__idx", js_mknum(idx + 1));
20757
20756
}
20758
20757
return result;
···
21029
21028
21030
21029
static jsval_t finreg_unregister(struct js *js, jsval_t *args, int nargs) {
21031
21030
jsval_t this_val = js->this_val;
21032
-
if (vtype(this_val) != T_OBJ) return js_mkfalse();
21031
+
if (vtype(this_val) != T_OBJ) return js_false;
21033
21032
21034
21033
if (nargs < 1 || vtype(args[0]) != T_OBJ) {
21035
21034
return js_mkerr(js, "FinalizationRegistry.unregister token must be an object");
···
21037
21036
21038
21037
jsval_t token = args[0];
21039
21038
jsval_t registrations = get_slot(js, this_val, SLOT_MAP);
21040
-
if (vtype(registrations) != T_ARR) return js_mkfalse();
21039
+
if (vtype(registrations) != T_ARR) return js_false;
21041
21040
21042
21041
jsoff_t len = js_arr_len(js, registrations);
21043
21042
bool removed = false;
···
21053
21052
}
21054
21053
}
21055
21054
21056
-
return removed ? js_mktrue() : js_mkfalse();
21055
+
return js_bool(removed);
21057
21056
}
21058
21057
21059
21058
static proxy_data_t *get_proxy_data(jsval_t obj) {
···
21124
21123
jsval_t args[4] = { target, key_val, value, proxy };
21125
21124
jsval_t result = js_call(js, set_trap, args, 4);
21126
21125
if (is_err(result)) return result;
21127
-
return js_mktrue();
21126
+
return js_true;
21128
21127
}
21129
21128
}
21130
21129
21131
21130
jsval_t key_str = js_mkstr(js, key, key_len);
21132
21131
setprop(js, target, key_str, value);
21133
-
return js_mktrue();
21132
+
return js_true;
21134
21133
}
21135
21134
21136
21135
static jsval_t proxy_has(struct js *js, jsval_t proxy, const char *key, size_t key_len) {
21137
21136
proxy_data_t *data = get_proxy_data(proxy);
21138
-
if (!data) return js_mkfalse();
21137
+
if (!data) return js_false;
21139
21138
if (data->revoked) return throw_proxy_error(js, "Cannot perform 'has' on a proxy that has been revoked");
21140
21139
21141
21140
jsval_t target = data->target;
···
21157
21156
key_buf[len] = '\0';
21158
21157
21159
21158
jsoff_t off = lkp_proto(js, target, key_buf, len);
21160
-
return off != 0 ? js_mktrue() : js_mkfalse();
21159
+
return js_bool(off != 0);
21161
21160
}
21162
21161
21163
21162
static jsval_t proxy_delete(struct js *js, jsval_t proxy, const char *key, size_t key_len) {
21164
21163
proxy_data_t *data = get_proxy_data(proxy);
21165
-
if (!data) return js_mktrue();
21164
+
if (!data) return js_true;
21166
21165
if (data->revoked) return throw_proxy_error(js, "Cannot perform 'deleteProperty' on a proxy that has been revoked");
21167
21166
21168
21167
jsval_t target = data->target;
···
21180
21179
21181
21180
jsval_t key_str = js_mkstr(js, key, key_len);
21182
21181
setprop(js, target, key_str, js_mkundef());
21183
-
return js_mktrue();
21182
+
return js_true;
21184
21183
}
21185
21184
21186
21185
static jsval_t mkproxy(struct js *js, jsval_t target, jsval_t handler) {
···
21762
21761
21763
21762
jsval_t async_func_proto_obj = js_mkobj(js);
21764
21763
set_proto(js, async_func_proto_obj, function_proto);
21765
-
set_slot(js, async_func_proto_obj, SLOT_ASYNC, js_mktrue());
21764
+
set_slot(js, async_func_proto_obj, SLOT_ASYNC, js_true);
21766
21765
jsval_t async_func_proto = mkval(T_FUNC, vdata(async_func_proto_obj));
21767
21766
set_slot(js, glob, SLOT_ASYNC_PROTO, async_func_proto);
21768
21767
···
22079
22078
inline void js_setstackbase(struct js *js, void *base) { js->cstk = base; }
22080
22079
inline void js_set_filename(struct js *js, const char *filename) { js->filename = filename; }
22081
22080
22082
-
inline jsval_t js_mktrue(void) { return mkval(T_BOOL, 1); }
22083
-
inline jsval_t js_mkfalse(void) { return mkval(T_BOOL, 0); }
22084
22081
inline jsval_t js_mkundef(void) { return mkval(T_UNDEF, 0); }
22085
22082
inline jsval_t js_mknull(void) { return mkval(T_NULL, 0); }
22086
22083
inline jsval_t js_mknum(double value) { return tov(value); }
+2
src/core/ant.ts
+2
src/core/ant.ts
+3
-3
src/modules/atomics.c
+3
-3
src/modules/atomics.c
···
360
360
is_lock_free = false;
361
361
}
362
362
363
-
return is_lock_free ? js_mktrue() : js_mkfalse();
363
+
return js_bool(is_lock_free);
364
364
}
365
365
366
366
// Atomics.load(typedArray, index)
···
785
785
786
786
jsval_t result_obj = js_mkobj(js);
787
787
if (current_value != expected_value) {
788
-
js_set(js, result_obj, "async", js_mkfalse());
788
+
js_set(js, result_obj, "async", js_false);
789
789
js_set(js, result_obj, "value", js_mkstr(js, "not-equal", 9));
790
790
return result_obj;
791
791
}
792
792
793
793
jsval_t promise = js_mkpromise(js);
794
-
js_set(js, result_obj, "async", js_mktrue());
794
+
js_set(js, result_obj, "async", js_true);
795
795
js_set(js, result_obj, "value", promise);
796
796
js_resolve_promise(js, promise, js_mkstr(js, "ok", 2));
797
797
+9
-12
src/modules/buffer.c
+9
-12
src/modules/buffer.c
···
340
340
static jsval_t js_arraybuffer_detached_getter(struct js *js, jsval_t *args, int nargs) {
341
341
jsval_t this_val = js_getthis(js);
342
342
jsval_t data_val = js_get_slot(js, this_val, SLOT_BUFFER);
343
-
344
-
if (vtype(data_val) != T_NUM) {
345
-
return js_mkfalse();
346
-
}
343
+
if (vtype(data_val) != T_NUM) return js_false;
347
344
348
345
ArrayBufferData *data = (ArrayBufferData *)(uintptr_t)js_getnum(data_val);
349
-
if (!data) return js_mktrue();
346
+
if (!data) return js_true;
350
347
351
-
return data->is_detached ? js_mktrue() : js_mkfalse();
348
+
return js_bool(data->is_detached);
352
349
}
353
350
354
351
static jsval_t typedarray_index_getter(struct js *js, jsval_t obj, const char *key, size_t key_len) {
···
1503
1500
1504
1501
// Buffer.isBuffer(obj)
1505
1502
static jsval_t js_buffer_isBuffer(struct js *js, jsval_t *args, int nargs) {
1506
-
if (nargs < 1) return js_mkfalse();
1507
-
if (!is_special_object(args[0])) return js_mkfalse();
1503
+
if (nargs < 1) return js_false;
1504
+
if (!is_special_object(args[0])) return js_false;
1508
1505
1509
1506
jsval_t proto = js_get_proto(js, args[0]);
1510
1507
jsval_t buffer_proto = js_get_ctor_proto(js, "Buffer", 6);
1511
1508
1512
-
return (proto == buffer_proto) ? js_mktrue() : js_mkfalse();
1509
+
return js_bool(proto == buffer_proto);
1513
1510
}
1514
1511
1515
1512
// Buffer.isEncoding(encoding)
1516
1513
static jsval_t js_buffer_isEncoding(struct js *js, jsval_t *args, int nargs) {
1517
-
if (nargs < 1 || vtype(args[0]) != T_STR) return js_mkfalse();
1514
+
if (nargs < 1 || vtype(args[0]) != T_STR) return js_false;
1518
1515
1519
1516
size_t len;
1520
1517
char *enc = js_getstr(js, args[0], &len);
···
1530
1527
(len == 5 && strncasecmp(enc, "ucs-2", 5) == 0) ||
1531
1528
(len == 7 && strncasecmp(enc, "utf16le", 7) == 0) ||
1532
1529
(len == 8 && strncasecmp(enc, "utf-16le", 8) == 0)) {
1533
-
return js_mktrue();
1530
+
return js_true;
1534
1531
}
1535
1532
1536
-
return js_mkfalse();
1533
+
return js_false;
1537
1534
}
1538
1535
1539
1536
// Buffer.byteLength(string, encoding)
+9
-9
src/modules/child_process.c
+9
-9
src/modules/child_process.c
···
209
209
js_set(cp->js, cp->child_obj, "exitCode", js_mknum((double)exit_status));
210
210
if (term_signal) {
211
211
js_set(cp->js, cp->child_obj, "signalCode", js_mknum((double)term_signal));
212
-
js_set(cp->js, cp->child_obj, "killed", js_mktrue());
212
+
js_set(cp->js, cp->child_obj, "killed", js_true);
213
213
}
214
214
215
215
jsval_t exit_args[2] = { js_mknum((double)exit_status), term_signal ? js_mknum((double)term_signal) : js_mknull() };
···
377
377
jsval_t this_obj = js_getthis(js);
378
378
379
379
jsval_t cp_ptr = js_get_slot(js, this_obj, SLOT_DATA);
380
-
if (vtype(cp_ptr) == T_UNDEF) return js_mkfalse();
380
+
if (vtype(cp_ptr) == T_UNDEF) return js_false;
381
381
382
382
child_process_t *cp = (child_process_t *)(uintptr_t)js_getnum(cp_ptr);
383
-
if (cp->exited) return js_mkfalse();
383
+
if (cp->exited) return js_false;
384
384
385
385
int sig = SIGTERM;
386
386
if (nargs > 0) {
···
398
398
}
399
399
400
400
int result = uv_process_kill(&cp->process, sig);
401
-
return result == 0 ? js_mktrue() : js_mkfalse();
401
+
return js_bool(result == 0);
402
402
}
403
403
404
404
static jsval_t child_write(struct js *js, jsval_t *args, int nargs) {
···
409
409
if (vtype(cp_ptr) == T_UNDEF) return js_mkerr(js, "Invalid child process object");
410
410
411
411
child_process_t *cp = (child_process_t *)(uintptr_t)js_getnum(cp_ptr);
412
-
if (cp->stdin_closed) return js_mkfalse();
412
+
if (cp->stdin_closed) return js_false;
413
413
414
414
size_t data_len;
415
415
char *data = js_getstr(js, args[0], &data_len);
···
426
426
if (result < 0) {
427
427
free(buf_data);
428
428
free(write_req);
429
-
return js_mkfalse();
429
+
return js_false;
430
430
}
431
431
432
-
return js_mktrue();
432
+
return js_true;
433
433
}
434
434
435
435
static jsval_t child_end(struct js *js, jsval_t *args, int nargs) {
···
455
455
js_set(js, obj, "pid", js_mknum((double)cp->process.pid));
456
456
js_set(js, obj, "exitCode", js_mknull());
457
457
js_set(js, obj, "signalCode", js_mknull());
458
-
js_set(js, obj, "killed", js_mkfalse());
459
-
js_set(js, obj, "connected", js_mktrue());
458
+
js_set(js, obj, "killed", js_false);
459
+
js_set(js, obj, "connected", js_true);
460
460
461
461
js_set(js, obj, "on", js_mkfun(child_on));
462
462
js_set(js, obj, "once", js_mkfun(child_once));
+7
-7
src/modules/events.c
+7
-7
src/modules/events.c
···
228
228
if (event_type == NULL) return js_mkerr(js, "eventType must be a string");
229
229
230
230
EventType *evt = find_emitter_event_type(js, this_obj, event_type);
231
-
if (evt == NULL || evt->listener_count == 0) return js_mktrue();
231
+
if (evt == NULL || evt->listener_count == 0) return js_true;
232
232
233
233
jsval_t event_obj = js_mkobj(js);
234
234
js_set(js, event_obj, "type", args[0]);
···
254
254
} else i++;
255
255
}
256
256
257
-
return js_mktrue();
257
+
return js_true;
258
258
}
259
259
260
260
// dispatchEvent(eventType, eventData)
···
268
268
269
269
EventType *evt = find_global_event_type(event_type);
270
270
if (evt == NULL || evt->listener_count == 0) {
271
-
return js_mktrue();
271
+
return js_true;
272
272
}
273
273
274
274
jsval_t event_obj = js_mkobj(js);
···
294
294
} else i++;
295
295
}
296
296
297
-
return js_mktrue();
297
+
return js_true;
298
298
}
299
299
300
300
static jsval_t js_get_event_listeners(struct js *js, jsval_t *args, int nargs) {
···
312
312
313
313
jsval_t listener_info = js_mkobj(js);
314
314
js_set(js, listener_info, "listener", evt->listeners[j].listener);
315
-
js_set(js, listener_info, "once", evt->listeners[j].once ? js_mktrue() : js_mkfalse());
315
+
js_set(js, listener_info, "once", js_bool(evt->listeners[j].once));
316
316
317
317
js_set(js, listeners_array, key, listener_info);
318
318
}
···
432
432
433
433
EventType *evt = find_emitter_event_type(js, this_obj, event_type);
434
434
if (evt == NULL || evt->listener_count == 0) {
435
-
return js_mkfalse();
435
+
return js_false;
436
436
}
437
437
438
438
int listener_nargs = nargs - 1;
···
452
452
} else i++;
453
453
}
454
454
455
-
return js_mktrue();
455
+
return js_true;
456
456
}
457
457
458
458
// EventEmitter.prototype.removeAllListeners(event)
+1
-1
src/modules/fetch.c
+1
-1
src/modules/fetch.c
···
101
101
jsval_t response_obj = js_mkobj(js);
102
102
jsval_t body_str = js_mkstr(js, body, body_len);
103
103
104
-
js_set(js, response_obj, "ok", status >= 200 && status < 300 ? js_mktrue() : js_mkfalse());
104
+
js_set(js, response_obj, "ok", js_bool(status >= 200 && status < 300));
105
105
js_set(js, response_obj, "status", js_mknum(status));
106
106
107
107
js_set_slot(js, response_obj, SLOT_DATA, body_str);
+1
-1
src/modules/ffi.c
+1
-1
src/modules/ffi.c
+9
-9
src/modules/fs.c
+9
-9
src/modules/fs.c
···
292
292
293
293
static void on_exists_complete(uv_fs_t *uv_req) {
294
294
fs_request_t *req = (fs_request_t *)uv_req->data;
295
-
jsval_t result = (uv_req->result >= 0) ? js_mktrue() : js_mkfalse();
295
+
jsval_t result = js_bool(uv_req->result >= 0);
296
296
297
297
req->completed = 1;
298
298
js_resolve_promise(req->js, req->promise, result);
···
938
938
jsval_t this = js_getthis(js);
939
939
jsval_t mode_val = js_get_slot(js, this, SLOT_DATA);
940
940
941
-
if (vtype(mode_val) != T_NUM) return js_mkfalse();
941
+
if (vtype(mode_val) != T_NUM) return js_false;
942
942
mode_t mode = (mode_t)js_getnum(mode_val);
943
943
944
-
return S_ISREG(mode) ? js_mktrue() : js_mkfalse();
944
+
return js_bool(S_ISREG(mode));
945
945
}
946
946
947
947
static jsval_t stat_isDirectory(struct js *js, jsval_t *args, int nargs) {
948
948
jsval_t this = js_getthis(js);
949
949
jsval_t mode_val = js_get_slot(js, this, SLOT_DATA);
950
950
951
-
if (vtype(mode_val) != T_NUM) return js_mkfalse();
951
+
if (vtype(mode_val) != T_NUM) return js_false;
952
952
mode_t mode = (mode_t)js_getnum(mode_val);
953
953
954
-
return S_ISDIR(mode) ? js_mktrue() : js_mkfalse();
954
+
return js_bool(S_ISDIR(mode));
955
955
}
956
956
957
957
static jsval_t stat_isSymbolicLink(struct js *js, jsval_t *args, int nargs) {
958
958
jsval_t this = js_getthis(js);
959
959
jsval_t mode_val = js_get_slot(js, this, SLOT_DATA);
960
960
961
-
if (vtype(mode_val) != T_NUM) return js_mkfalse();
961
+
if (vtype(mode_val) != T_NUM) return js_false;
962
962
mode_t mode = (mode_t)js_getnum(mode_val);
963
963
964
-
return S_ISLNK(mode) ? js_mktrue() : js_mkfalse();
964
+
return js_bool(S_ISLNK(mode));
965
965
}
966
966
967
967
static jsval_t create_stats_object(struct js *js, struct stat *st) {
···
1073
1073
int result = stat(path_cstr, &st);
1074
1074
free(path_cstr);
1075
1075
1076
-
return (result == 0) ? js_mktrue() : js_mkfalse();
1076
+
return js_bool(result == 0);
1077
1077
}
1078
1078
1079
1079
static jsval_t builtin_fs_exists(struct js *js, jsval_t *args, int nargs) {
···
1101
1101
1102
1102
if (result < 0) {
1103
1103
req->completed = 1;
1104
-
js_resolve_promise(req->js, req->promise, js_mkfalse());
1104
+
js_resolve_promise(req->js, req->promise, js_false);
1105
1105
remove_pending_request(req);
1106
1106
free_fs_request(req);
1107
1107
}
+1
-1
src/modules/json.c
+1
-1
src/modules/json.c
···
24
24
25
25
switch (yyjson_get_type(val)) {
26
26
case YYJSON_TYPE_NULL: return js_mknull();
27
-
case YYJSON_TYPE_BOOL: return yyjson_get_bool(val) ? js_mktrue() : js_mkfalse();
27
+
case YYJSON_TYPE_BOOL: return js_bool(yyjson_get_bool(val));
28
28
case YYJSON_TYPE_STR: return js_mkstr(js, yyjson_get_str(val), yyjson_get_len(val));
29
29
30
30
case YYJSON_TYPE_NUM: {
+2
-2
src/modules/observable.c
+2
-2
src/modules/observable.c
···
45
45
if (!is_special_object(subscription)) {
46
46
return js_mkerr_typed(js, JS_ERR_TYPE, "Subscription.closed getter called on non-object");
47
47
}
48
-
return subscription_closed(js, subscription) ? js_mktrue() : js_mkfalse();
48
+
return js_bool(subscription_closed(js, subscription));
49
49
}
50
50
51
51
static jsval_t js_subscription_unsubscribe(struct js *js, jsval_t *args, int nargs) {
···
83
83
return js_mkerr_typed(js, JS_ERR_TYPE, "Invalid SubscriptionObserver");
84
84
}
85
85
86
-
return subscription_closed(js, subscription) ? js_mktrue() : js_mkfalse();
86
+
return js_bool(subscription_closed(js, subscription));
87
87
}
88
88
89
89
static jsval_t js_subobs_next(struct js *js, jsval_t *args, int nargs) {
+2
-2
src/modules/os.c
+2
-2
src/modules/os.c
···
541
541
for (pUnicast = pCurrAddresses->FirstUnicastAddress; pUnicast; pUnicast = pUnicast->Next) {
542
542
jsval_t entry = js_mkobj(js);
543
543
js_set(js, entry, "mac", js_mkstr(js, mac_str, strlen(mac_str)));
544
-
js_set(js, entry, "internal", internal ? js_mktrue() : js_mkfalse());
544
+
js_set(js, entry, "internal", js_bool(internal));
545
545
546
546
char addr_str[INET6_ADDRSTRLEN] = "";
547
547
struct sockaddr *sa = pUnicast->Address.lpSockaddr;
···
641
641
642
642
jsval_t entry = js_mkobj(js);
643
643
js_set(js, entry, "mac", js_mkstr(js, "00:00:00:00:00:00", 17));
644
-
js_set(js, entry, "internal", internal ? js_mktrue() : js_mkfalse());
644
+
js_set(js, entry, "internal", js_bool(internal));
645
645
646
646
if (family == AF_INET) {
647
647
struct sockaddr_in *sa = (struct sockaddr_in *)ifa->ifa_addr;
+5
-5
src/modules/path.c
+5
-5
src/modules/path.c
···
343
343
344
344
size_t path_len;
345
345
char *path = js_getstr(js, args[0], &path_len);
346
-
if (!path || path_len == 0) return js_mkfalse();
346
+
if (!path || path_len == 0) return js_false;
347
347
348
348
#ifdef _WIN32
349
-
if (path_len >= 2 && path[1] == ':') return js_mktrue();
350
-
if (path_len >= 2 && path[0] == '\\' && path[1] == '\\') return js_mktrue();
351
-
return js_mkfalse();
349
+
if (path_len >= 2 && path[1] == ':') return js_true;
350
+
if (path_len >= 2 && path[0] == '\\' && path[1] == '\\') return js_true;
351
+
return js_false;
352
352
#else
353
-
return path[0] == '/' ? js_mktrue() : js_mkfalse();
353
+
return js_bool(path[0] == '/');
354
354
#endif
355
355
}
356
356
+17
-17
src/modules/process.c
+17
-17
src/modules/process.c
···
425
425
js_set(js, key_obj, "name", js_mkundef());
426
426
}
427
427
428
-
js_set(js, key_obj, "ctrl", ctrl ? js_mktrue() : js_mkfalse());
429
-
js_set(js, key_obj, "meta", meta ? js_mktrue() : js_mkfalse());
430
-
js_set(js, key_obj, "shift", shift ? js_mktrue() : js_mkfalse());
428
+
js_set(js, key_obj, "ctrl", js_bool(ctrl));
429
+
js_set(js, key_obj, "meta", js_bool(meta));
430
+
js_set(js, key_obj, "shift", js_bool(shift));
431
431
432
432
if (sequence) {
433
433
js_set(js, key_obj, "sequence", js_mkstr(js, sequence, sequence_len));
···
665
665
666
666
static jsval_t js_stdin_set_raw_mode(ant_t *js, jsval_t *args, int nargs) {
667
667
bool enable = nargs > 0 ? js_truthy(js, args[0]) : true;
668
-
return stdin_set_raw_mode(enable) ? js_mktrue() : js_mkfalse();
668
+
return js_bool(stdin_set_raw_mode(enable));
669
669
}
670
670
671
671
static jsval_t js_stdin_resume(ant_t *js, jsval_t *args, int nargs) {
···
736
736
}
737
737
738
738
static jsval_t js_stdout_write(ant_t *js, jsval_t *args, int nargs) {
739
-
if (nargs < 1) return js_mkfalse();
739
+
if (nargs < 1) return js_false;
740
740
size_t len = 0;
741
741
char *data = js_getstr(js, args[0], &len);
742
-
if (!data) return js_mkfalse();
742
+
if (!data) return js_false;
743
743
fwrite(data, 1, len, stdout);
744
744
fflush(stdout);
745
-
return js_mktrue();
745
+
return js_true;
746
746
}
747
747
748
748
static jsval_t js_stdout_on(ant_t *js, jsval_t *args, int nargs) {
···
854
854
}
855
855
856
856
static jsval_t js_stderr_write(ant_t *js, jsval_t *args, int nargs) {
857
-
if (nargs < 1) return js_mkfalse();
857
+
if (nargs < 1) return js_false;
858
858
size_t len = 0;
859
859
char *data = js_getstr(js, args[0], &len);
860
-
if (!data) return js_mkfalse();
860
+
if (!data) return js_false;
861
861
fwrite(data, 1, len, stderr);
862
862
fflush(stderr);
863
-
return js_mktrue();
863
+
return js_true;
864
864
}
865
865
866
866
static jsval_t js_stderr_on(ant_t *js, jsval_t *args, int nargs) {
···
1055
1055
1056
1056
int result = uv_kill(pid, sig);
1057
1057
if (result != 0) return js_mkerr(js, "Failed to send signal");
1058
-
return js_mktrue();
1058
+
return js_true;
1059
1059
}
1060
1060
1061
1061
static jsval_t process_abort(ant_t *js, jsval_t *args, int nargs) {
···
1478
1478
}
1479
1479
1480
1480
static jsval_t process_emit(ant_t *js, jsval_t *args, int nargs) {
1481
-
if (nargs < 1) return js_mkfalse();
1481
+
if (nargs < 1) return js_false;
1482
1482
1483
1483
char *event = js_getstr(js, args[0], NULL);
1484
-
if (!event) return js_mkfalse();
1484
+
if (!event) return js_false;
1485
1485
1486
1486
emit_process_event(event, nargs > 1 ? &args[1] : NULL, nargs - 1);
1487
-
return js_mktrue();
1487
+
return js_true;
1488
1488
}
1489
1489
1490
1490
static jsval_t process_listener_count(ant_t *js, jsval_t *args, int nargs) {
···
1639
1639
1640
1640
jsval_t stdin_obj = js_mkobj(js);
1641
1641
js_set_proto(js, stdin_obj, stdin_proto);
1642
-
js_set(js, stdin_obj, "isTTY", stdin_is_tty() ? js_mktrue() : js_mkfalse());
1642
+
js_set(js, stdin_obj, "isTTY", js_bool(stdin_is_tty()));
1643
1643
js_set(js, process_obj, "stdin", stdin_obj);
1644
1644
1645
1645
jsval_t stdout_proto = js_mkobj(js);
···
1654
1654
1655
1655
jsval_t stdout_obj = js_mkobj(js);
1656
1656
js_set_proto(js, stdout_obj, stdout_proto);
1657
-
js_set(js, stdout_obj, "isTTY", stdout_is_tty() ? js_mktrue() : js_mkfalse());
1657
+
js_set(js, stdout_obj, "isTTY", js_bool(stdout_is_tty()));
1658
1658
js_set_getter_desc(js, stdout_obj, "rows", 4, js_mkfun(js_stdout_rows_getter), JS_DESC_E | JS_DESC_C);
1659
1659
js_set_getter_desc(js, stdout_obj, "columns", 7, js_mkfun(js_stdout_columns_getter), JS_DESC_E | JS_DESC_C);
1660
1660
js_set(js, process_obj, "stdout", stdout_obj);
···
1670
1670
1671
1671
jsval_t stderr_obj = js_mkobj(js);
1672
1672
js_set_proto(js, stderr_obj, stderr_proto);
1673
-
js_set(js, stderr_obj, "isTTY", stderr_is_tty() ? js_mktrue() : js_mkfalse());
1673
+
js_set(js, stderr_obj, "isTTY", js_bool(stderr_is_tty()));
1674
1674
js_set(js, process_obj, "stderr", stderr_obj);
1675
1675
1676
1676
js_set(js, global, "process", process_obj);
+14
-14
src/modules/readline.c
+14
-14
src/modules/readline.c
···
699
699
rl_interface_t *iface = get_interface(js, this_obj);
700
700
701
701
if (!iface) return js_mkerr(js, "Invalid Interface");
702
-
if (nargs < 1) return js_mkfalse();
702
+
if (nargs < 1) return js_false;
703
703
704
704
char *event = js_getstr(js, args[0], NULL);
705
-
if (!event) return js_mkfalse();
705
+
if (!event) return js_false;
706
706
707
707
emit_event(js, iface, event, nargs > 1 ? &args[1] : NULL, nargs - 1);
708
-
return js_mktrue();
708
+
return js_true;
709
709
}
710
710
711
711
static jsval_t rl_interface_close(struct js *js, jsval_t *args, int nargs) {
···
1028
1028
jsval_t this_obj = js_getthis(js);
1029
1029
rl_interface_t *iface = get_interface(js, this_obj);
1030
1030
1031
-
if (!iface) return js_mktrue();
1032
-
return iface->closed ? js_mktrue() : js_mkfalse();
1031
+
if (!iface) return js_true;
1032
+
return js_bool(iface->closed);
1033
1033
}
1034
1034
1035
1035
static jsval_t rl_interface_async_iterator(struct js *js, jsval_t *args, int nargs) {
···
1042
1042
jsval_t iterator = js_mkobj(js);
1043
1043
js_set(js, iterator, "_rl_id", js_mknum((double)iface->id));
1044
1044
js_set(js, iterator, "_lines", js_mkarr(js));
1045
-
js_set(js, iterator, "_done", js_mkfalse());
1045
+
js_set(js, iterator, "_done", js_false);
1046
1046
1047
1047
return iterator;
1048
1048
}
···
1174
1174
js_set_getter_desc(js, obj, "cursor", 6, js_mkfun(rl_interface_cursor_getter), JS_DESC_E | JS_DESC_C);
1175
1175
js_set_getter_desc(js, obj, "closed", 6, js_mkfun(rl_interface_closed_getter), JS_DESC_E | JS_DESC_C);
1176
1176
1177
-
js_set(js, obj, "terminal", iface->terminal ? js_mktrue() : js_mkfalse());
1177
+
js_set(js, obj, "terminal", js_bool(iface->terminal));
1178
1178
js_set(js, obj, get_asyncIterator_sym_key(), js_mkfun(rl_interface_async_iterator));
1179
1179
js_set(js, obj, get_toStringTag_sym_key(), js_mkstr(js, "Interface", 9));
1180
1180
···
1190
1190
}
1191
1191
1192
1192
static jsval_t rl_clear_line(struct js *js, jsval_t *args, int nargs) {
1193
-
if (nargs < 2) return js_mkfalse();
1193
+
if (nargs < 2) return js_false;
1194
1194
int dir = (int)js_getnum(args[1]);
1195
1195
1196
1196
const char *seq;
···
1204
1204
printf("%s", seq);
1205
1205
fflush(stdout);
1206
1206
1207
-
return js_mktrue();
1207
+
return js_true;
1208
1208
}
1209
1209
1210
1210
static jsval_t rl_clear_screen_down(struct js *js, jsval_t *args, int nargs) {
···
1213
1213
printf("\033[J");
1214
1214
fflush(stdout);
1215
1215
1216
-
return js_mktrue();
1216
+
return js_true;
1217
1217
}
1218
1218
1219
1219
static jsval_t rl_cursor_to(struct js *js, jsval_t *args, int nargs) {
1220
-
if (nargs < 2) return js_mkfalse();
1220
+
if (nargs < 2) return js_false;
1221
1221
int x = (int)js_getnum(args[1]);
1222
1222
1223
1223
if (nargs >= 3 && vtype(args[2]) == T_NUM) {
···
1228
1228
}
1229
1229
fflush(stdout);
1230
1230
1231
-
return js_mktrue();
1231
+
return js_true;
1232
1232
}
1233
1233
1234
1234
static jsval_t rl_move_cursor(struct js *js, jsval_t *args, int nargs) {
1235
-
if (nargs < 3) return js_mkfalse();
1235
+
if (nargs < 3) return js_false;
1236
1236
1237
1237
int dx = (int)js_getnum(args[1]);
1238
1238
int dy = (int)js_getnum(args[2]);
···
1244
1244
else if (dy < 0) printf("\033[%dA", -dy);
1245
1245
1246
1246
fflush(stdout);
1247
-
return js_mktrue();
1247
+
return js_true;
1248
1248
}
1249
1249
1250
1250
static jsval_t rl_emit_keypress_events(struct js *js, jsval_t *args, int nargs) {
+35
-35
src/modules/reflect.c
+35
-35
src/modules/reflect.c
···
27
27
}
28
28
29
29
static jsval_t reflect_set(struct js *js, jsval_t *args, int nargs) {
30
-
if (nargs < 3) return js_mkfalse();
30
+
if (nargs < 3) return js_false;
31
31
32
32
jsval_t target = args[0];
33
33
jsval_t key = args[1];
34
34
jsval_t value = args[2];
35
35
36
36
int t = vtype(target);
37
-
if (t != T_OBJ && t != T_FUNC) return js_mkfalse();
37
+
if (t != T_OBJ && t != T_FUNC) return js_false;
38
38
39
-
if (vtype(key) != T_STR) return js_mkfalse();
39
+
if (vtype(key) != T_STR) return js_false;
40
40
41
41
char *key_str = js_getstr(js, key, NULL);
42
-
if (!key_str) return js_mkfalse();
42
+
if (!key_str) return js_false;
43
43
44
44
js_set(js, target, key_str, value);
45
-
return js_mktrue();
45
+
return js_true;
46
46
}
47
47
48
48
static jsval_t reflect_has(struct js *js, jsval_t *args, int nargs) {
49
-
if (nargs < 2) return js_mkfalse();
49
+
if (nargs < 2) return js_false;
50
50
51
51
jsval_t target = args[0];
52
52
jsval_t key = args[1];
53
53
54
54
int t = vtype(target);
55
-
if (t != T_OBJ && t != T_FUNC) return js_mkfalse();
55
+
if (t != T_OBJ && t != T_FUNC) return js_false;
56
56
57
-
if (vtype(key) != T_STR) return js_mkfalse();
57
+
if (vtype(key) != T_STR) return js_false;
58
58
59
59
size_t key_len;
60
60
char *key_str = js_getstr(js, key, &key_len);
61
-
if (!key_str) return js_mkfalse();
61
+
if (!key_str) return js_false;
62
62
63
63
jsoff_t off = lkp_proto(js, target, key_str, key_len);
64
-
return off > 0 ? js_mktrue() : js_mkfalse();
64
+
return js_bool(off > 0);
65
65
}
66
66
67
67
static jsval_t reflect_delete_property(struct js *js, jsval_t *args, int nargs) {
68
-
if (nargs < 2) return js_mkfalse();
68
+
if (nargs < 2) return js_false;
69
69
70
70
jsval_t target = args[0];
71
71
jsval_t key = args[1];
72
72
73
73
int t = vtype(target);
74
-
if (t != T_OBJ && t != T_FUNC) return js_mkfalse();
74
+
if (t != T_OBJ && t != T_FUNC) return js_false;
75
75
76
-
if (vtype(key) != T_STR) return js_mkfalse();
76
+
if (vtype(key) != T_STR) return js_false;
77
77
78
78
char *key_str = js_getstr(js, key, NULL);
79
-
if (!key_str) return js_mkfalse();
79
+
if (!key_str) return js_false;
80
80
81
81
bool deleted = js_del(js, target, key_str);
82
-
return deleted ? js_mktrue() : js_mkfalse();
82
+
return js_bool(deleted);
83
83
}
84
84
85
85
static jsval_t reflect_own_keys(struct js *js, jsval_t *args, int nargs) {
···
206
206
jsval_t value = js_get(js, target, key_str);
207
207
jsval_t desc = js_mkobj(js);
208
208
js_set(js, desc, "value", value);
209
-
js_set(js, desc, "writable", js_mktrue());
210
-
js_set(js, desc, "enumerable", js_mktrue());
211
-
js_set(js, desc, "configurable", js_mktrue());
209
+
js_set(js, desc, "writable", js_true);
210
+
js_set(js, desc, "enumerable", js_true);
211
+
js_set(js, desc, "configurable", js_true);
212
212
213
213
return desc;
214
214
}
215
215
216
216
static jsval_t reflect_define_property(struct js *js, jsval_t *args, int nargs) {
217
-
if (nargs < 3) return js_mkfalse();
217
+
if (nargs < 3) return js_false;
218
218
219
219
jsval_t target = args[0];
220
220
jsval_t key = args[1];
221
221
jsval_t descriptor = args[2];
222
222
223
223
int t = vtype(target);
224
-
if (t != T_OBJ && t != T_FUNC) return js_mkfalse();
224
+
if (t != T_OBJ && t != T_FUNC) return js_false;
225
225
226
-
if (vtype(key) != T_STR) return js_mkfalse();
227
-
if (!is_special_object(descriptor)) return js_mkfalse();
226
+
if (vtype(key) != T_STR) return js_false;
227
+
if (!is_special_object(descriptor)) return js_false;
228
228
229
229
char *key_str = js_getstr(js, key, NULL);
230
-
if (!key_str) return js_mkfalse();
230
+
if (!key_str) return js_false;
231
231
232
232
jsval_t value = js_get(js, descriptor, "value");
233
233
js_set(js, target, key_str, value);
234
234
235
-
return js_mktrue();
235
+
return js_true;
236
236
}
237
237
238
238
static jsval_t reflect_get_prototype_of(struct js *js, jsval_t *args, int nargs) {
···
250
250
}
251
251
252
252
static jsval_t reflect_set_prototype_of(struct js *js, jsval_t *args, int nargs) {
253
-
if (nargs < 2) return js_mkfalse();
253
+
if (nargs < 2) return js_false;
254
254
255
255
jsval_t target = args[0];
256
256
jsval_t proto = args[1];
257
257
258
258
int t = vtype(target);
259
-
if (t != T_OBJ && t != T_FUNC) return js_mkfalse();
259
+
if (t != T_OBJ && t != T_FUNC) return js_false;
260
260
261
261
int pt = vtype(proto);
262
-
if (pt != T_OBJ && pt != T_FUNC && pt != T_NULL) return js_mkfalse();
262
+
if (pt != T_OBJ && pt != T_FUNC && pt != T_NULL) return js_false;
263
263
264
264
js_set_proto(js, target, proto);
265
-
return js_mktrue();
265
+
return js_true;
266
266
}
267
267
268
268
static jsval_t reflect_is_extensible(struct js *js, jsval_t *args, int nargs) {
269
-
if (nargs < 1) return js_mkfalse();
269
+
if (nargs < 1) return js_false;
270
270
271
271
jsval_t target = args[0];
272
272
int t = vtype(target);
273
273
274
-
if (t != T_OBJ && t != T_FUNC) return js_mkfalse();
274
+
if (t != T_OBJ && t != T_FUNC) return js_false;
275
275
276
276
if (js_get_slot(js, target, SLOT_EXTENSIBLE) == js_false) return js_false;
277
277
if (js_get_slot(js, target, SLOT_FROZEN) == js_true) return js_false;
278
278
if (js_get_slot(js, target, SLOT_SEALED) == js_true) return js_false;
279
279
280
-
return js_mktrue();
280
+
return js_true;
281
281
}
282
282
283
283
static jsval_t reflect_prevent_extensions(struct js *js, jsval_t *args, int nargs) {
284
-
if (nargs < 1) return js_mkfalse();
284
+
if (nargs < 1) return js_false;
285
285
286
286
jsval_t target = args[0];
287
287
int t = vtype(target);
288
288
289
-
if (t != T_OBJ && t != T_FUNC) return js_mkfalse();
289
+
if (t != T_OBJ && t != T_FUNC) return js_false;
290
290
291
-
js_set_slot(js, target, SLOT_EXTENSIBLE, js_mkfalse());
292
-
return js_mktrue();
291
+
js_set_slot(js, target, SLOT_EXTENSIBLE, js_false);
292
+
return js_true;
293
293
}
294
294
295
295
void init_reflect_module(void) {
+4
-4
src/modules/symbol.c
+4
-4
src/modules/symbol.c
···
72
72
jsval_t result = js_mkobj(js);
73
73
74
74
if (idx >= len) {
75
-
js_set(js, result, "done", js_mktrue());
75
+
js_set(js, result, "done", js_true);
76
76
js_set(js, result, "value", js_mkundef());
77
77
} else {
78
78
char idxstr[16];
79
79
snprintf(idxstr, sizeof(idxstr), "%d", idx);
80
80
jsval_t value = js_get(js, arr, idxstr);
81
81
js_set(js, result, "value", value);
82
-
js_set(js, result, "done", js_mkfalse());
82
+
js_set(js, result, "done", js_false);
83
83
js_set(js, this_val, "__idx", js_mknum(idx + 1));
84
84
}
85
85
···
116
116
jsval_t result = js_mkobj(js);
117
117
118
118
if (idx >= len) {
119
-
js_set(js, result, "done", js_mktrue());
119
+
js_set(js, result, "done", js_true);
120
120
js_set(js, result, "value", js_mkundef());
121
121
} else {
122
122
char *s = js_getstr(js, str, NULL);
123
123
char ch[2] = {s[idx], 0};
124
124
js_set(js, result, "value", js_mkstr(js, ch, 1));
125
-
js_set(js, result, "done", js_mkfalse());
125
+
js_set(js, result, "done", js_false);
126
126
js_set(js, this_val, "__idx", js_mknum(idx + 1));
127
127
}
128
128
+4
-4
src/modules/textcodec.c
+4
-4
src/modules/textcodec.c
···
127
127
128
128
jsval_t obj = js_mkobj(js);
129
129
js_set(js, obj, "encoding", js_mkstr(js, encoding, encoding_len));
130
-
js_set(js, obj, "fatal", js_mkfalse());
131
-
js_set(js, obj, "ignoreBOM", js_mkfalse());
130
+
js_set(js, obj, "fatal", js_false);
131
+
js_set(js, obj, "ignoreBOM", js_false);
132
132
js_set(js, obj, "decode", js_mkfun(js_textdecoder_decode));
133
133
js_set(js, obj, get_toStringTag_sym_key(), js_mkstr(js, "TextDecoder", 11));
134
134
···
153
153
154
154
js_set(js, textdecoder_proto, "decode", js_mkfun(js_textdecoder_decode));
155
155
js_set(js, textdecoder_proto, "encoding", js_mkstr(js, "utf-8", 5));
156
-
js_set(js, textdecoder_proto, "fatal", js_mkfalse());
157
-
js_set(js, textdecoder_proto, "ignoreBOM", js_mkfalse());
156
+
js_set(js, textdecoder_proto, "fatal", js_false);
157
+
js_set(js, textdecoder_proto, "ignoreBOM", js_false);
158
158
js_set(js, textdecoder_constructor, "prototype", textdecoder_proto);
159
159
js_set(js, glob, "TextDecoder", textdecoder_constructor);
160
160
}
+5
-5
src/modules/url.c
+5
-5
src/modules/url.c
···
399
399
}
400
400
401
401
static jsval_t usp_has(struct js *js, jsval_t *args, int nargs) {
402
-
if (nargs < 1) return js_mkfalse();
402
+
if (nargs < 1) return js_false;
403
403
jsval_t this_val = js_getthis(js);
404
404
char *key = js_getstr(js, args[0], NULL);
405
-
if (!key) return js_mkfalse();
405
+
if (!key) return js_false;
406
406
407
407
jsval_t entries = js_get(js, this_val, "_entries");
408
-
if (!is_special_object(entries)) return js_mkfalse();
408
+
if (!is_special_object(entries)) return js_false;
409
409
410
410
jsval_t len_val = js_get(js, entries, "length");
411
411
int len = (vtype(len_val) == T_NUM) ? (int)js_getnum(len_val) : 0;
···
416
416
jsval_t entry = js_get(js, entries, idx);
417
417
jsval_t k = js_get(js, entry, "0");
418
418
char *ks = js_getstr(js, k, NULL);
419
-
if (ks && strcmp(ks, key) == 0) return js_mktrue();
419
+
if (ks && strcmp(ks, key) == 0) return js_true;
420
420
}
421
-
return js_mkfalse();
421
+
return js_false;
422
422
}
423
423
424
424
static void usp_sync_url(struct js *js, jsval_t this_val) {
+1
-1
src/snapshot.c
+1
-1
src/snapshot.c
+1
src/types/ant.d.ts
+1
src/types/ant.d.ts
+3
-1
src/types/index.d.ts
+3
-1
src/types/index.d.ts
···
2
2
/// <reference path="buffer.d.ts" />
3
3
/// <reference path="fetch.d.ts" />
4
4
/// <reference path="process.d.ts" />
5
-
/// <reference path="snapshot.d.ts" />
5
+
/// <reference path="import.d.ts" />
6
+
/// <reference path="process.d.ts" />
6
7
/// <reference path="timers.d.ts" />
7
8
/// <reference path="url.d.ts" />
8
9
9
10
/// <reference path="modules/fs.d.ts" />
10
11
/// <reference path="modules/path.d.ts" />
11
12
/// <reference path="modules/os.d.ts" />
13
+
/// <reference path="modules/console.d.ts" />
12
14
/// <reference path="modules/child_process.d.ts" />
13
15
/// <reference path="modules/crypto.d.ts" />
14
16
/// <reference path="modules/events.d.ts" />