+177 -24

examples/embed/embed.c

reviewed

··· 2 2 * Ant JavaScript Engine - Embedding Example 3 3 * This demonstrates how to embed the Ant JS engine in a C application. 4 4 * 5 5 - * meson setup build -Dbuild_examples=true 6 6 - * meson compile -C build 5 5 + * to build: 6 6 + * ./libant/build.sh 7 7 + * ./libant/example.sh 7 8 * 8 8 - * ./build/embed_example 9 9 + * to run: 10 10 + * ./libant/dist/embed 9 11 */ 10 12 13 13 + #include <ant.h> 11 14 #include <stdio.h> 12 15 #include <stdlib.h> 13 16 #include <string.h> 14 14 - #include <ant.h> 15 17 16 18 #define SEPARATOR "════════════════════════════════════════════════════════════" 17 19 #define SUBSEP "────────────────────────────────────────────────────────────" ··· 22 24 printf("%s\n\n", SUBSEP); 23 25 } 24 26 25 25 - static void example_basic_eval(void) { 26 26 - print_header(1, "Basic Evaluation"); 27 27 - 27 27 + static struct js *create_js_runtime(void *stack_base) { 28 28 struct js *js = js_create_dynamic(0, 0); 29 29 if (!js) { 30 30 fprintf(stderr, "Failed to create JS runtime\n"); 31 31 - return; 31 31 + return NULL; 32 32 } 33 33 34 34 + js_setstackbase(js, stack_base); 35 35 + 36 36 + static char *default_argv[] = { "embed_example", NULL }; 37 37 + ant_runtime_init(js, 1, default_argv, NULL); 38 38 + 39 39 + return js; 40 40 + } 41 41 + 42 42 + static void example_basic_eval(void) { 43 43 + print_header(1, "Basic Evaluation"); 44 44 + 45 45 + volatile char stack_base; 46 46 + struct js *js = create_js_runtime((void *)&stack_base); 47 47 + if (!js) return; 48 48 + 34 49 js_mkscope(js); 35 50 36 51 const char *code = "1 + 2 * 3"; 37 52 jsval_t result = js_eval(js, code, strlen(code)); 38 53 39 39 - if (js_type(result) == JS_NUM) { 54 54 + if (vtype(result) == T_NUM) { 40 55 printf(" Result: %g\n", js_getnum(result)); 41 41 - } else if (js_type(result) == JS_ERR) { 56 56 + } else if (vtype(result) == T_ERR) { 42 57 printf(" Error: %s\n", js_str(js, result)); 43 58 } 44 59 ··· 57 72 } 58 73 59 74 static jsval_t my_greet(struct js *js, jsval_t *args, int nargs) { 60 60 - if (nargs < 1 || js_type(args[0]) != JS_STR) { 75 75 + if (nargs < 1 || vtype(args[0]) != T_STR) { 61 76 return js_mkerr(js, "greet() expects a string"); 62 77 } 63 78 ··· 85 100 static void example_c_functions(void) { 86 101 print_header(2, "C Functions"); 87 102 88 88 - struct js *js = js_create_dynamic(0, 0); 103 103 + volatile char stack_base; 104 104 + struct js *js = create_js_runtime((void *)&stack_base); 89 105 if (!js) return; 90 106 91 107 js_mkscope(js); ··· 113 129 static void example_objects_arrays(void) { 114 130 print_header(3, "Objects and Arrays"); 115 131 116 116 - struct js *js = js_create_dynamic(0, 0); 132 132 + volatile char stack_base; 133 133 + struct js *js = create_js_runtime((void *)&stack_base); 117 134 if (!js) return; 118 135 119 136 js_mkscope(js); ··· 144 161 static void example_error_handling(void) { 145 162 print_header(4, "Error Handling"); 146 163 147 147 - struct js *js = js_create_dynamic(0, 0); 164 164 + volatile char stack_base; 165 165 + struct js *js = create_js_runtime((void *)&stack_base); 148 166 if (!js) return; 149 167 150 168 js_mkscope(js); 151 169 152 170 const char *bad_code = "let x = {"; 153 171 jsval_t r1 = js_eval(js, bad_code, strlen(bad_code)); 154 154 - if (js_type(r1) == JS_ERR) { 172 172 + if (vtype(r1) == T_ERR) { 155 173 printf(" Syntax error: %s\n", js_str(js, r1)); 156 174 } 157 175 158 176 const char *ref_err = "undefinedVariable + 1"; 159 177 jsval_t r2 = js_eval(js, ref_err, strlen(ref_err)); 160 160 - if (js_type(r2) == JS_ERR) { 178 178 + if (vtype(r2) == T_ERR) { 161 179 printf(" Reference error: %s\n", js_str(js, r2)); 162 180 } 163 181 ··· 166 184 167 185 const char *type_err = "add('not', 'numbers')"; 168 186 jsval_t r3 = js_eval(js, type_err, strlen(type_err)); 169 169 - if (js_type(r3) == JS_ERR) { 187 187 + if (vtype(r3) == T_ERR) { 170 188 printf(" Type error: %s\n", js_str(js, r3)); 171 189 } 172 190 ··· 176 194 static void example_call_js_from_c(void) { 177 195 print_header(5, "Calling JS from C"); 178 196 179 179 - struct js *js = js_create_dynamic(0, 0); 197 197 + volatile char stack_base; 198 198 + struct js *js = create_js_runtime((void *)&stack_base); 180 199 if (!js) return; 181 200 182 201 jsval_t scope = js_mkscope(js); ··· 185 204 "function multiply(a, b) {" 186 205 " return a * b;" 187 206 "}" 188 188 - 189 207 "function formatName(first, last) {" 190 208 " return last + ', ' + first;" 191 209 "}"; ··· 213 231 static void example_iterate_properties(void) { 214 232 print_header(6, "Iterating Properties"); 215 233 216 216 - struct js *js = js_create_dynamic(0, 0); 234 234 + volatile char stack_base; 235 235 + struct js *js = create_js_runtime((void *)&stack_base); 217 236 if (!js) return; 218 237 219 238 js_mkscope(js); ··· 221 240 const char *code = "({ name: 'Alice', age: 30, city: 'NYC' })"; 222 241 jsval_t obj = js_eval(js, code, strlen(code)); 223 242 224 224 - js_prop_iter_t iter = js_prop_iter_begin(js, obj); 243 243 + ant_iter_t iter = js_prop_iter_begin(js, obj); 225 244 const char *key; 226 245 size_t key_len; 227 246 jsval_t value; ··· 256 275 static void example_this_context(void) { 257 276 print_header(7, "'this' Context"); 258 277 259 259 - struct js *js = js_create_dynamic(0, 0); 278 278 + volatile char stack_base; 279 279 + struct js *js = create_js_runtime((void *)&stack_base); 260 280 if (!js) return; 261 281 262 282 js_mkscope(js); ··· 278 298 static void example_stateful_session(void) { 279 299 print_header(8, "Stateful Session"); 280 300 281 281 - struct js *js = js_create_dynamic(0, 0); 301 301 + volatile char stack_base; 302 302 + struct js *js = create_js_runtime((void *)&stack_base); 282 303 if (!js) return; 283 304 284 305 js_mkscope(js); ··· 294 315 jsval_t result = js_mkundef(); 295 316 for (int i = 0; i < 5; i++) { 296 317 result = js_eval(js, scripts[i], strlen(scripts[i])); 297 297 - if (js_type(result) == JS_ERR) { 318 318 + if (vtype(result) == T_ERR) { 298 319 printf(" Error in script %d: %s\n", i, js_str(js, result)); 299 320 break; 300 321 } ··· 305 326 js_destroy(js); 306 327 } 307 328 329 329 + static void example_async_event_loop(void) { 330 330 + print_header(9, "Async & Event Loop"); 331 331 + 332 332 + volatile char stack_base; 333 333 + struct js *js = create_js_runtime((void *)&stack_base); 334 334 + if (!js) return; 335 335 + 336 336 + init_symbol_module(); 337 337 + init_builtin_module(); 338 338 + init_timer_module(); 339 339 + 340 340 + jsval_t scope = js_mkscope(js); 341 341 + 342 342 + const char *code = 343 343 + "let results = [];" 344 344 + "" 345 345 + "setTimeout(() => {" 346 346 + " results.push('timer 1 (50ms)');" 347 347 + "}, 50);" 348 348 + "" 349 349 + "setTimeout(() => {" 350 350 + " results.push('timer 2 (10ms)');" 351 351 + "}, 10);" 352 352 + "" 353 353 + "Promise.resolve('promise 1').then(v => {" 354 354 + " results.push(v);" 355 355 + "});" 356 356 + "" 357 357 + "queueMicrotask(() => {" 358 358 + " results.push('microtask');" 359 359 + "});" 360 360 + "" 361 361 + "results.push('sync');"; 362 362 + 363 363 + jsval_t result = js_eval(js, code, strlen(code)); 364 364 + if (vtype(result) == T_ERR) { 365 365 + printf(" Error: %s\n", js_str(js, result)); 366 366 + js_destroy(js); 367 367 + return; 368 368 + } 369 369 + 370 370 + js_run_event_loop(js); 371 371 + 372 372 + jsval_t results = js_get(js, scope, "results"); 373 373 + 374 374 + printf(" Execution order:\n"); 375 375 + jsoff_t len = js_arr_len(js, results); 376 376 + for (jsoff_t i = 0; i < len; i++) { 377 377 + jsval_t item = js_arr_get(js, results, i); 378 378 + printf(" %llu. %s\n", (unsigned long long)i + 1, js_str(js, item)); 379 379 + } 380 380 + 381 381 + js_destroy(js); 382 382 + } 383 383 + 384 384 + static void example_console_logging(void) { 385 385 + print_header(10, "Console Logging"); 386 386 + 387 387 + volatile char stack_base; 388 388 + struct js *js = create_js_runtime((void *)&stack_base); 389 389 + if (!js) return; 390 390 + 391 391 + init_console_module(); 392 392 + js_mkscope(js); 393 393 + 394 394 + const char *code = 395 395 + "console.log('Hello from JavaScript!');" 396 396 + "console.log('Number:', 42, 'Boolean:', true);" 397 397 + "console.log('Object:', { name: 'test', value: 123 });" 398 398 + "console.log('Array:', [1, 2, 3]);" 399 399 + "console.warn('This is a warning');" 400 400 + "console.error('This is an error');" 401 401 + "'done'"; 402 402 + 403 403 + jsval_t result = js_eval(js, code, strlen(code)); 404 404 + if (vtype(result) == T_ERR) { 405 405 + printf(" Error: %s\n", js_str(js, result)); 406 406 + } 407 407 + 408 408 + js_destroy(js); 409 409 + } 410 410 + 411 411 + static void example_global_this(void) { 412 412 + print_header(11, "GlobalThis"); 413 413 + 414 414 + volatile char stack_base; 415 415 + struct js *js = create_js_runtime((void *)&stack_base); 416 416 + if (!js) return; 417 417 + 418 418 + init_console_module(); 419 419 + js_mkscope(js); 420 420 + 421 421 + jsval_t global = js_glob(js); 422 422 + js_set(js, global, "myNumber", js_mknum(42)); 423 423 + js_set(js, global, "myString", js_mkstr(js, "hello from C", 12)); 424 424 + js_set(js, global, "myBool", js_mktrue()); 425 425 + 426 426 + jsval_t myObj = js_mkobj(js); 427 427 + js_set(js, myObj, "a", js_mknum(1)); 428 428 + js_set(js, myObj, "b", js_mknum(2)); 429 429 + js_set(js, global, "myObject", myObj); 430 430 + 431 431 + const char *code = 432 432 + "console.log('globalThis.myNumber:', globalThis.myNumber);" 433 433 + "console.log('globalThis.myString:', globalThis.myString);" 434 434 + "console.log('globalThis.myBool:', globalThis.myBool);" 435 435 + "console.log('globalThis.myObject:', globalThis.myObject);" 436 436 + "" 437 437 + "globalThis.addedFromJS = 'I was added from JavaScript';" 438 438 + "console.log('globalThis.addedFromJS:', globalThis.addedFromJS);" 439 439 + "" 440 440 + "console.log('\\nAll custom globals:');" 441 441 + "console.log(' myNumber:', myNumber);" 442 442 + "console.log(' myString:', myString);" 443 443 + "console.log(' myBool:', myBool);" 444 444 + "console.log(' myObject:', myObject);" 445 445 + "console.log(' addedFromJS:', addedFromJS);" 446 446 + "console.log(this)"; 447 447 + 448 448 + jsval_t result = js_eval(js, code, strlen(code)); 449 449 + if (vtype(result) == T_ERR) { 450 450 + printf(" Error: %s\n", js_str(js, result)); 451 451 + } 452 452 + 453 453 + jsval_t added = js_get(js, global, "addedFromJS"); 454 454 + printf("\n Read from C: addedFromJS = %s\n", js_str(js, added)); 455 455 + 456 456 + js_destroy(js); 457 457 + } 308 458 309 459 int main(void) { 310 460 printf("\n%s\n", SEPARATOR); ··· 319 469 example_iterate_properties(); 320 470 example_this_context(); 321 471 example_stateful_session(); 472 472 + example_async_event_loop(); 473 473 + example_console_logging(); 474 474 + example_global_this(); 322 475 323 476 return EXIT_SUCCESS; 324 477 }

+15 -11

include/ant.h

reviewed

··· 33 33 #define GC_FWD_ARGS jsval_t (*fwd_val)(void *ctx, jsval_t old), void *ctx 34 34 #define GC_UPDATE_ARGS ant_t *js, jsoff_t (*fwd_off)(void *ctx, jsoff_t old), GC_FWD_ARGS 35 35 36 36 - enum { 37 37 - JS_UNDEF, JS_NULL, JS_TRUE, JS_FALSE, JS_STR, JS_NUM, 38 38 - JS_ERR, JS_PRIV, JS_PROMISE, JS_OBJ, JS_FUNC, JS_SYMBOL 39 39 - }; 40 40 - 41 36 #define JS_DESC_W (1 << 0) 42 37 #define JS_DESC_E (1 << 1) 43 38 #define JS_DESC_C (1 << 2) ··· 82 77 jsval_t js_getcurrentfunc(ant_t *); 83 78 jsval_t js_get(ant_t *, jsval_t, const char *); 84 79 jsval_t js_getprop_proto(ant_t *, jsval_t, const char *); 85 85 - bool js_iter(ant_t *js, jsval_t iterable, bool (*callback)(ant_t *js, jsval_t value, void *udata), void *udata); 80 80 + 81 81 + jsoff_t js_arr_len(struct js *js, jsval_t arr); 82 82 + jsval_t js_arr_get(struct js *js, jsval_t arr, jsoff_t idx); 83 83 + 84 84 + bool js_iter( 85 85 + ant_t *js, 86 86 + jsval_t iterable, 87 87 + bool (*callback)( 88 88 + ant_t *js, 89 89 + jsval_t value, 90 90 + void *udata 91 91 + ), 92 92 + void *udata 93 93 + ); 86 94 87 95 uint64_t js_sym_id(jsval_t sym); 88 96 const char *js_sym_desc(ant_t *js, jsval_t sym); ··· 93 101 jsval_t js_mkobj(ant_t *); 94 102 jsval_t js_newobj(ant_t *); 95 103 jsval_t js_mkarr(ant_t *); 96 96 - void js_arr_push(ant_t *, jsval_t arr, jsval_t val); 97 104 jsval_t js_mkstr(ant_t *, const void *, size_t); 98 105 jsval_t js_mkbigint(ant_t *, const char *digits, size_t len, bool negative); 99 106 jsval_t js_mksym(ant_t *, const char *desc); ··· 110 117 void js_saveval(ant_t *js, jsoff_t off, jsval_t v); 111 118 bool js_del(ant_t *, jsval_t obj, const char *key); 112 119 void js_merge_obj(ant_t *, jsval_t dst, jsval_t src); 120 120 + void js_arr_push(ant_t *, jsval_t arr, jsval_t val); 113 121 114 122 jsval_t js_setprop(ant_t *, jsval_t obj, jsval_t key, jsval_t val); 115 123 jsval_t js_setprop_nonconfigurable(ant_t *, jsval_t obj, const char *key, size_t keylen, jsval_t val); ··· 119 127 jsval_t js_get_ctor_proto(ant_t *, const char *name, size_t len); 120 128 jsval_t js_tostring_val(ant_t *js, jsval_t value); 121 129 122 122 - int js_type(jsval_t val); 123 123 - int js_type_ex(ant_t *js, jsval_t val); 124 124 - 125 125 - int js_getbool(jsval_t val); 126 130 uint8_t vtype(jsval_t val); 127 131 size_t vdata(jsval_t val); 128 132

+19 -1

include/internal.h

reviewed

··· 84 84 #define NANBOX_DATA_MASK 0x0000FFFFFFFFFFFFULL 85 85 86 86 #define TYPE_FLAG(t) (1u << (t)) 87 87 + 87 88 #define T_NEEDS_PROTO_FALLBACK (TYPE_FLAG(T_FUNC) | TYPE_FLAG(T_ARR) | TYPE_FLAG(T_PROMISE)) 88 88 - #define T_NON_NUMERIC_MASK (TYPE_FLAG(T_STR) | TYPE_FLAG(T_ARR) | TYPE_FLAG(T_FUNC) | TYPE_FLAG(T_CFUNC) | TYPE_FLAG(T_OBJ)) 89 89 + #define T_OBJECT_MASK (TYPE_FLAG(T_OBJ) | TYPE_FLAG(T_ARR) | TYPE_FLAG(T_FUNC) | TYPE_FLAG(T_PROMISE)) 90 90 + #define T_NON_NUMERIC_MASK (TYPE_FLAG(T_STR) | TYPE_FLAG(T_ARR) | TYPE_FLAG(T_FUNC) | TYPE_FLAG(T_CFUNC) | TYPE_FLAG(T_OBJ)) 89 91 90 92 jsoff_t esize(jsoff_t w); 91 93 ··· 102 104 jsval_t resolveprop(struct js *js, jsval_t v); 103 105 104 106 #define is_non_numeric(v) ((1u << vtype(v)) & T_NON_NUMERIC_MASK) 107 107 + #define is_object_type(v) ((1u << vtype(v)) & T_OBJECT_MASK) 108 108 + 109 109 + static inline bool is_err(jsval_t v) { 110 110 + return vtype(v) == T_ERR; 111 111 + } 112 112 + 113 113 + static inline bool is_null(jsval_t v) { 114 114 + return vtype(v) == T_NULL; 115 115 + } 116 116 + 117 117 + static inline bool is_undefined(jsval_t v) { 118 118 + return vtype(v) == T_UNDEF; 119 119 + } 120 120 + 121 121 + #define js_true (NANBOX_PREFIX | ((jsval_t)T_BOOL << NANBOX_TYPE_SHIFT) | 1) 122 122 + #define js_false (NANBOX_PREFIX | ((jsval_t)T_BOOL << NANBOX_TYPE_SHIFT)) 105 123 106 124 #endif

+8 -2

libant/scripts/header.sh

reviewed

··· 17 17 HEADERS=( 18 18 "config.h:$CONFIG_H" 19 19 "common.h:$INCLUDE_DIR/common.h" 20 20 - "compat.h:$INCLUDE_DIR/compat.h" 20 20 + "types.h:$INCLUDE_DIR/types.h" 21 21 "ant.h:$INCLUDE_DIR/ant.h" 22 22 + "internal.h:$INCLUDE_DIR/internal.h" 23 23 + "roots.h:$INCLUDE_DIR/roots.h" 24 24 + "tokens.h:$INCLUDE_DIR/tokens.h" 25 25 + "stack.h:$INCLUDE_DIR/stack.h" 26 26 + "errors.h:$INCLUDE_DIR/errors.h" 27 27 + "compat.h:$INCLUDE_DIR/compat.h" 22 28 "utils.h:$INCLUDE_DIR/utils.h" 23 29 "minicoro.h:$VENDOR_DIR/minicoro/minicoro.h" 24 30 "runtime.h:$INCLUDE_DIR/runtime.h" ··· 90 96 continue 91 97 fi 92 98 93 93 - if [[ "$line" =~ ^[[:space:]]*#[[:space:]]*include[[:space:]]+\"(config\.h|compat\.h|ant\.h|utils\.h|arena\.h|runtime\.h|internal\.h)\" ]]; then 99 99 + if [[ "$line" =~ ^[[:space:]]*#[[:space:]]*include[[:space:]]+\"(config\.h|common\.h|types\.h|compat\.h|ant\.h|utils\.h|arena\.h|runtime\.h|internal\.h)\" ]]; then 94 100 continue 95 101 fi 96 102 if [[ "$line" =~ ^[[:space:]]*#[[:space:]]*include[[:space:]]+\"esm/ ]]; then

+45 -94

src/ant.c

reviewed

··· 594 594 return (size_t) js->brk; 595 595 } 596 596 597 597 - static inline bool is_err(jsval_t v) { 598 598 - return vtype(v) == T_ERR; 599 599 - } 600 600 - 601 601 - static inline bool is_null(jsval_t v) { 602 602 - return vtype(v) == T_NULL; 603 603 - } 604 604 - 605 605 - static inline bool is_undefined(jsval_t v) { 606 606 - return vtype(v) == T_UNDEF; 607 607 - } 608 608 - 609 609 - #define T_OBJECT_MASK (TYPE_FLAG(T_OBJ) | TYPE_FLAG(T_ARR) | TYPE_FLAG(T_FUNC) | TYPE_FLAG(T_PROMISE)) 610 610 - #define is_object_type(v) ((1u << vtype(v)) & T_OBJECT_MASK) 611 611 - 612 612 - static inline bool is_true(jsval_t v) { 613 613 - return vtype(v) == T_BOOL && vdata(v) != 0; 614 614 - } 615 615 - 616 616 - static inline bool is_false(jsval_t v) { 617 617 - return vtype(v) == T_BOOL && vdata(v) == 0; 618 618 - } 619 619 - 620 597 static inline uint8_t unhex(uint8_t c) { 621 598 return (c & 0xF) + (c >> 6) * 9; 622 599 } ··· 1881 1858 bool is_dataview = (tlen == 8 && memcmp(tag_str, "DataView", 8) == 0); 1882 1859 if (is_dataview) { 1883 1860 jsval_t dv_data_val = js_get_slot(js, obj, SLOT_DATA); 1884 1884 - if (js_type(dv_data_val) == JS_NUM) { 1861 1861 + if (vtype(dv_data_val) == T_NUM) { 1885 1862 DataViewData *dv = (DataViewData *)(uintptr_t)tod(dv_data_val); 1886 1863 if (dv && dv->buffer) { 1887 1864 n += cpy(buf + n, REMAIN(n, len), "DataView {\n", 11); ··· 2276 2253 jsval_t builtin_slot = get_slot(js, func_obj, SLOT_BUILTIN); 2277 2254 jsval_t async_slot = get_slot(js, func_obj, SLOT_ASYNC); 2278 2255 2279 2279 - bool is_async = is_true(async_slot); 2256 2256 + bool is_async = (async_slot == js_true); 2280 2257 bool has_code = (vtype(code_slot) == T_CFUNC); 2281 2258 2282 2259 const struct func_format *fmt = &formats[is_async]; ··· 2957 2934 return obj; 2958 2935 } 2959 2936 2960 2960 - static jsoff_t arr_length(struct js *js, jsval_t arr) { 2937 2937 + jsoff_t js_arr_len(struct js *js, jsval_t arr) { 2961 2938 if (vtype(arr) != T_ARR) return 0; 2962 2939 jsoff_t max_idx = 0; 2963 2940 bool found_length_prop = false; ··· 2983 2960 return max_idx; 2984 2961 } 2985 2962 2986 2986 - static jsval_t arr_get(struct js *js, jsval_t arr, jsoff_t idx) { 2963 2963 + jsval_t js_arr_get(struct js *js, jsval_t arr, jsoff_t idx) { 2987 2964 if (vtype(arr) != T_ARR) return js_mkundef(); 2988 2965 char idxstr[16]; 2989 2966 size_t idxlen = uint_to_str(idxstr, sizeof(idxstr), (unsigned)idx); ··· 5366 5343 5367 5344 if (is_arr_off(js, obj_off) && streq(key_str, len, "length", 6)) { 5368 5345 jsval_t arr = mkval(T_ARR, obj_off); 5369 5369 - return tov(D(arr_length(js, arr))); 5346 5346 + return tov(D(js_arr_len(js, arr))); 5370 5347 } 5371 5348 5372 5349 jsval_t obj = mkval(T_OBJ, obj_off); ··· 5633 5610 return mkval(T_PROP, len_off); 5634 5611 } 5635 5612 jsval_t key = js_mkstr(js, "length", 6); 5636 5636 - jsval_t len_val = tov(D(arr_length(js, obj))); 5613 5613 + jsval_t len_val = tov(D(js_arr_len(js, obj))); 5637 5614 jsval_t prop = setprop(js, obj, key, len_val); 5638 5615 return prop; 5639 5616 } ··· 5912 5889 jsval_t arg = resolveprop(js, js_expr(js)); 5913 5890 if (is_err(arg)) { *err_out = arg; return -1; } 5914 5891 if (is_spread && vtype(arg) == T_ARR) { 5915 5915 - jsoff_t len = arr_length(js, arg); 5892 5892 + jsoff_t len = js_arr_len(js, arg); 5916 5893 for (jsoff_t i = 0; i < len; i++) { 5917 5917 - jsval_t elem = arr_get(js, arg, i); 5894 5894 + jsval_t elem = js_arr_get(js, arg, i); 5918 5895 utarray_push_back(args, &elem); 5919 5896 } 5920 5897 } else utarray_push_back(args, &arg); ··· 6045 6022 if (is_rest && is_arr) { 6046 6023 jsval_t rest = js_mkarr(js); 6047 6024 if (is_err(rest)) return rest; 6048 6048 - jsoff_t alen = arr_length(js, val); 6049 6049 - for (jsoff_t i = idx; i < alen; i++) js_arr_push(js, rest, arr_get(js, val, i)); 6025 6025 + jsoff_t alen = js_arr_len(js, val); 6026 6026 + for (jsoff_t i = idx; i < alen; i++) js_arr_push(js, rest, js_arr_get(js, val, i)); 6050 6027 prop_val = rest; 6051 6028 } else if (is_rest) { 6052 6029 prop_val = mkobj(js, 0); 6053 6030 } else if (is_arr) { 6054 6054 - prop_val = arr_get(js, val, idx); 6031 6031 + prop_val = js_arr_get(js, val, idx); 6055 6032 } else { 6056 6033 jsoff_t off = lkp(js, val, &p[src_pos], src_len); 6057 6034 prop_val = off > 0 ? resolveprop(js, mkval(T_PROP, off)) : js_mkundef(); ··· 6300 6277 jsval_t arg = resolveprop(js, js_expr(js)); 6301 6278 caller_pos = js->pos; 6302 6279 if (is_spread && vtype(arg) == T_ARR) { 6303 6303 - jsoff_t len = arr_length(js, arg); 6280 6280 + jsoff_t len = js_arr_len(js, arg); 6304 6281 for (jsoff_t i = 0; i < len; i++) { 6305 6305 - jsval_t elem = arr_get(js, arg, i); 6282 6282 + jsval_t elem = js_arr_get(js, arg, i); 6306 6283 utarray_push_back(args_arr, &elem); 6307 6284 } 6308 6285 } else { ··· 6893 6870 push_this(captured_this); 6894 6871 } 6895 6872 6896 6896 - if (is_true(get_slot(js, func_obj, SLOT_DEFAULT_CTOR))) { 6873 6873 + if (get_slot(js, func_obj, SLOT_DEFAULT_CTOR) == js_true) { 6897 6874 jsval_t super_ctor = js->super_val; 6898 6875 uint8_t st = vtype(super_ctor); 6899 6876 if (st == T_FUNC || st == T_CFUNC) { ··· 7689 7666 if (is_rest) { 7690 7667 jsval_t rest_arr = js_mkarr(js); 7691 7668 if (is_err(rest_arr)) return rest_arr; 7692 7692 - jsoff_t total_len = vtype(arr) == T_STR ? 0 : arr_length(js, arr); 7669 7669 + jsoff_t total_len = vtype(arr) == T_STR ? 0 : js_arr_len(js, arr); 7693 7670 if (vtype(arr) == T_STR) { 7694 7671 jsoff_t slen; 7695 7672 vstr(js, arr, &slen); ··· 7701 7678 jsoff_t slen, soff = vstr(js, arr, &slen); 7702 7679 elem = js_mkstr(js, (char *)&js->mem[soff + i], 1); 7703 7680 } else { 7704 7704 - elem = arr_get(js, arr, i); 7681 7681 + elem = js_arr_get(js, arr, i); 7705 7682 } 7706 7683 js_arr_push(js, rest_arr, elem); 7707 7684 } ··· 7715 7692 prop_val = js_mkundef(); 7716 7693 } 7717 7694 } else { 7718 7718 - prop_val = arr_get(js, arr, index); 7695 7695 + prop_val = js_arr_get(js, arr, index); 7719 7696 } 7720 7697 7721 7698 if (vtype(prop_val) == T_UNDEF && default_len > 0) { ··· 7826 7803 goto next_elem; 7827 7804 } 7828 7805 7829 7829 - jsoff_t len = arr_length(js, resolved); 7806 7806 + jsoff_t len = js_arr_len(js, resolved); 7830 7807 for (jsoff_t i = 0; i < len; i++) { 7831 7808 char src_idx[16], dst_idx[16]; 7832 7809 snprintf(src_idx, sizeof(src_idx), "%u", (unsigned)i); ··· 9716 9693 const char *key; jsoff_t klen; 9717 9694 get_prop_key(js, scan, &key, &klen); 9718 9695 bool is_picked = false; 9719 9719 - jsoff_t picked_len = arr_length(js, picked_keys); 9696 9696 + jsoff_t picked_len = js_arr_len(js, picked_keys); 9720 9697 for (jsoff_t i = 0; i < picked_len; i++) { 9721 9721 - jsval_t pk = arr_get(js, picked_keys, i); 9698 9698 + jsval_t pk = js_arr_get(js, picked_keys, i); 9722 9699 if (vtype(pk) != T_STR) continue; 9723 9700 jsoff_t pklen, pkoff = vstr(js, pk, &pklen); 9724 9701 if (klen == pklen && memcmp(key, &js->mem[pkoff], klen) == 0) { is_picked = true; break; } ··· 9898 9875 if (is_rest) { 9899 9876 jsval_t rest_arr = js_mkarr(js); 9900 9877 if (is_err(rest_arr)) return rest_arr; 9901 9901 - jsoff_t total_len = vtype(arr) == T_STR ? 0 : arr_length(js, arr); 9878 9878 + jsoff_t total_len = vtype(arr) == T_STR ? 0 : js_arr_len(js, arr); 9902 9879 if (vtype(arr) == T_STR) { 9903 9880 jsoff_t slen; 9904 9881 vstr(js, arr, &slen); ··· 9910 9887 jsoff_t slen, soff = vstr(js, arr, &slen); 9911 9888 elem = js_mkstr(js, (char *)&js->mem[soff + i], 1); 9912 9889 } else { 9913 9913 - elem = arr_get(js, arr, i); 9890 9890 + elem = js_arr_get(js, arr, i); 9914 9891 } 9915 9892 js_arr_push(js, rest_arr, elem); 9916 9893 } ··· 9924 9901 prop_val = js_mkundef(); 9925 9902 } 9926 9903 } else { 9927 9927 - prop_val = arr_get(js, arr, index); 9904 9904 + prop_val = js_arr_get(js, arr, index); 9928 9905 } 9929 9906 9930 9907 if (vtype(prop_val) == T_UNDEF && default_len > 0) { ··· 12797 12774 12798 12775 if (code && code_len > 0) { 12799 12776 jsval_t async_slot = get_slot(js, func_obj, SLOT_ASYNC); 12800 12800 - bool is_async = is_true(async_slot); 12777 12777 + 12778 12778 + bool is_async = (async_slot == js_true); 12801 12779 bool is_arrow = vtype(get_slot(js, func_obj, SLOT_ARROW)) != T_UNDEF; 12802 12780 12803 12781 if (is_arrow) { ··· 20336 20314 } 20337 20315 20338 20316 jsval_t default_val = js_get_slot(js, ns, SLOT_DEFAULT); 20339 20339 - mod->default_export = js_type(default_val) != JS_UNDEF ? default_val : ns; 20317 20317 + mod->default_export = vtype(default_val) != T_UNDEF ? default_val : ns; 20340 20318 20341 20319 mod->is_loaded = true; 20342 20320 mod->is_loading = false; ··· 20621 20599 jsval_t default_val; 20622 20600 if (vtype(ns) == T_OBJ) { 20623 20601 jsval_t slot_val = js_get_slot(js, ns, SLOT_DEFAULT); 20624 20624 - default_val = js_type(slot_val) != JS_UNDEF ? slot_val : ns; 20602 20602 + default_val = vtype(slot_val) != T_UNDEF ? slot_val : ns; 20625 20603 } else default_val = ns; 20626 20604 setprop(js, js->scope, js_mkstr(js, default_name, default_len), default_val); 20627 20605 ··· 20945 20923 if (nargs == 0 || vtype(args[0]) != T_ARR) return map_obj; 20946 20924 20947 20925 jsval_t iterable = args[0]; 20948 20948 - jsoff_t length = arr_length(js, iterable); 20926 20926 + jsoff_t length = js_arr_len(js, iterable); 20949 20927 20950 20928 for (jsoff_t i = 0; i < length; i++) { 20951 20951 - jsval_t entry = arr_get(js, iterable, i); 20929 20929 + jsval_t entry = js_arr_get(js, iterable, i); 20952 20930 if (vtype(entry) != T_ARR) continue; 20953 20931 20954 20954 - jsoff_t entry_len = arr_length(js, entry); 20932 20932 + jsoff_t entry_len = js_arr_len(js, entry); 20955 20933 if (entry_len < 2) continue; 20956 20934 20957 20957 - jsval_t key = arr_get(js, entry, 0); 20958 20958 - jsval_t value = arr_get(js, entry, 1); 20935 20935 + jsval_t key = js_arr_get(js, entry, 0); 20936 20936 + jsval_t value = js_arr_get(js, entry, 1); 20959 20937 const char *key_str = jsval_to_key(js, key); 20960 20938 20961 20939 map_entry_t *map_entry; ··· 20997 20975 if (nargs == 0 || vtype(args[0]) != T_ARR) return set_obj; 20998 20976 20999 20977 jsval_t iterable = args[0]; 21000 21000 - jsoff_t length = arr_length(js, iterable); 20978 20978 + jsoff_t length = js_arr_len(js, iterable); 21001 20979 21002 20980 for (jsoff_t i = 0; i < length; i++) { 21003 21003 - jsval_t value = arr_get(js, iterable, i); 20981 20981 + jsval_t value = js_arr_get(js, iterable, i); 21004 20982 const char *key_str = jsval_to_key(js, value); 21005 20983 21006 20984 set_entry_t *entry; ··· 21353 21331 if (nargs == 0 || vtype(args[0]) != T_ARR) return wm_obj; 21354 21332 21355 21333 jsval_t iterable = args[0]; 21356 21356 - jsoff_t length = arr_length(js, iterable); 21334 21334 + jsoff_t length = js_arr_len(js, iterable); 21357 21335 21358 21336 for (jsoff_t i = 0; i < length; i++) { 21359 21359 - jsval_t entry = arr_get(js, iterable, i); 21337 21337 + jsval_t entry = js_arr_get(js, iterable, i); 21360 21338 if (vtype(entry) != T_ARR) continue; 21361 21339 21362 21362 - jsoff_t entry_len = arr_length(js, entry); 21340 21340 + jsoff_t entry_len = js_arr_len(js, entry); 21363 21341 if (entry_len < 2) continue; 21364 21342 21365 21365 - jsval_t key = arr_get(js, entry, 0); 21366 21366 - jsval_t value = arr_get(js, entry, 1); 21343 21343 + jsval_t key = js_arr_get(js, entry, 0); 21344 21344 + jsval_t value = js_arr_get(js, entry, 1); 21367 21345 21368 21346 if (vtype(key) != T_OBJ) return js_mkerr(js, "WeakMap key must be an object"); 21369 21347 ··· 21401 21379 if (nargs == 0 || vtype(args[0]) != T_ARR) return ws_obj; 21402 21380 21403 21381 jsval_t iterable = args[0]; 21404 21404 - jsoff_t length = arr_length(js, iterable); 21382 21382 + jsoff_t length = js_arr_len(js, iterable); 21405 21383 21406 21384 for (jsoff_t i = 0; i < length; i++) { 21407 21407 - jsval_t value = arr_get(js, iterable, i); 21385 21385 + jsval_t value = js_arr_get(js, iterable, i); 21408 21386 21409 21387 if (vtype(value) != T_OBJ) return js_mkerr(js, "WeakSet value must be an object"); 21410 21388 ··· 21480 21458 if (vtype(registrations) != T_ARR) return js_mkundef(); 21481 21459 21482 21460 jsval_t entry = mkarr(js); 21483 21483 - jsoff_t len = arr_length(js, registrations); 21461 21461 + jsoff_t len = js_arr_len(js, registrations); 21484 21462 21485 21463 char idx[16]; 21486 21464 size_t idx_len = uint_to_str(idx, sizeof(idx), 0); ··· 21510 21488 jsval_t registrations = get_slot(js, this_val, SLOT_MAP); 21511 21489 if (vtype(registrations) != T_ARR) return js_mkfalse(); 21512 21490 21513 21513 - jsoff_t len = arr_length(js, registrations); 21491 21491 + jsoff_t len = js_arr_len(js, registrations); 21514 21492 bool removed = false; 21515 21493 21516 21494 for (jsoff_t i = 0; i < len; i++) { 21517 21517 - jsval_t entry = arr_get(js, registrations, i); 21495 21495 + jsval_t entry = js_arr_get(js, registrations, i); 21518 21496 if (vtype(entry) != T_ARR) continue; 21519 21519 - jsval_t entry_token = arr_get(js, entry, 2); 21497 21497 + jsval_t entry_token = js_arr_get(js, entry, 2); 21520 21498 if (vtype(entry_token) == T_OBJ && vdata(entry_token) == vdata(token)) { 21521 21499 char idx[16]; size_t idx_len = uint_to_str(idx, sizeof(idx), i); 21522 21500 setprop(js, registrations, js_mkstr(js, idx, idx_len), js_mkundef()); ··· 22531 22509 } 22532 22510 22533 22511 inline double js_getnum(jsval_t value) { return tod(value); } 22534 22534 - inline int js_getbool(jsval_t value) { return vdata(value) & 1 ? 1 : 0; } 22535 22535 - 22536 22512 inline void js_setstacklimit(struct js *js, size_t max) { js->stack_limit = max; } 22537 22513 inline void js_setstackbase(struct js *js, void *base) { js->cstk = base; } 22538 22514 inline void js_set_filename(struct js *js, const char *filename) { js->filename = filename; } ··· 22729 22705 setprop(js, dst, mkval(T_STR, koff), val); 22730 22706 next = next_prop(header); 22731 22707 } 22732 22732 - } 22733 22733 - 22734 22734 - int js_type(jsval_t val) { 22735 22735 - switch (vtype(val)) { 22736 22736 - case T_UNDEF: return JS_UNDEF; 22737 22737 - case T_NULL: return JS_NULL; 22738 22738 - case T_BOOL: return vdata(val) == 0 ? JS_FALSE: JS_TRUE; 22739 22739 - case T_STR: return JS_STR; 22740 22740 - case T_NUM: return JS_NUM; 22741 22741 - case T_ERR: return JS_ERR; 22742 22742 - case T_PROMISE: return JS_PROMISE; 22743 22743 - case T_SYMBOL: return JS_SYMBOL; 22744 22744 - 22745 22745 - case T_OBJ: 22746 22746 - case T_ARR: return JS_OBJ; 22747 22747 - case T_FUNC: return JS_FUNC; 22748 22748 - 22749 22749 - default: return JS_PRIV; 22750 22750 - } 22751 22751 - } 22752 22752 - 22753 22753 - int js_type_ex(struct js *js, jsval_t val) { 22754 22754 - (void)js; 22755 22755 - if (vtype(val) == T_SYMBOL) return JS_SYMBOL; 22756 22756 - return js_type(val); 22757 22708 } 22758 22709 22759 22710 #define UTARRAY_EACH(arr, type, var) \

+5 -4

src/main.c

reviewed

··· 14 14 #include "runtime.h" 15 15 #include "snapshot.h" 16 16 #include "esm/remote.h" 17 17 + #include "internal.h" 17 18 18 19 #include "modules/builtin.h" 19 20 #include "modules/buffer.h" ··· 60 61 jsval_t result = js_eval(js, script, len); 61 62 js_run_event_loop(js); 62 63 63 63 - if (js_type(result) == JS_ERR) { 64 64 + if (vtype(result) == T_ERR) { 64 65 fprintf(stderr, "%s\n", js_str(js, result)); 65 66 js_result = EXIT_FAILURE; 66 67 } else if (print->count > 0) { 67 67 - if (js_type(result) == JS_STR) { 68 68 + if (vtype(result) == T_STR) { 68 69 char *str = js_getstr(js, result, NULL); 69 70 if (str) printf("%s\n", str); 70 71 } else { ··· 150 151 jsval_t result = js_eval(js, js_code, js_len); 151 152 free(js_code); 152 153 153 153 - if (js_type(result) == JS_ERR) { 154 154 + if (vtype(result) == T_ERR) { 154 155 fprintf(stderr, "%s\n", js_str(js, result)); 155 156 return EXIT_FAILURE; 156 157 } ··· 254 255 ant_standard_library("child_process", child_process_library); 255 256 256 257 jsval_t snapshot_result = ant_load_snapshot(js); 257 257 - if (js_type(snapshot_result) == JS_ERR) { 258 258 + if (vtype(snapshot_result) == T_ERR) { 258 259 fprintf(stderr, "Warning: Failed to load snapshot: %s\n", js_str(js, snapshot_result)); 259 260 } 260 261

+3 -2

src/modules/atomics.c

reviewed

··· 8 8 9 9 #include "ant.h" 10 10 #include "errors.h" 11 11 + #include "internal.h" 11 12 #include "runtime.h" 12 13 13 14 #include "modules/buffer.h" ··· 676 677 int32_t expected_value = (int32_t)js_getnum(args[2]); 677 678 int64_t timeout_ms = -1; 678 679 679 679 - if (nargs > 3 && js_type(args[3]) == JS_NUM) { 680 680 + if (nargs > 3 && vtype(args[3]) == T_NUM) { 680 681 timeout_ms = (int64_t)js_getnum(args[3]); 681 682 } 682 683 ··· 747 748 } 748 749 749 750 int count = -1; 750 750 - if (nargs > 2 && js_type(args[2]) == JS_NUM) { 751 751 + if (nargs > 2 && vtype(args[2]) == T_NUM) { 751 752 count = (int)js_getnum(args[2]); 752 753 } 753 754

+61 -60

src/modules/buffer.c

reviewed

··· 12 12 #include "ant.h" 13 13 #include "errors.h" 14 14 #include "arena.h" 15 15 + #include "internal.h" 15 16 #include "runtime.h" 16 17 17 18 #include "modules/buffer.h" ··· 185 186 // ArrayBuffer constructor 186 187 static jsval_t js_arraybuffer_constructor(struct js *js, jsval_t *args, int nargs) { 187 188 size_t length = 0; 188 188 - if (nargs > 0 && js_type(args[0]) == JS_NUM) { 189 189 + if (nargs > 0 && vtype(args[0]) == T_NUM) { 189 190 length = (size_t)js_getnum(args[0]); 190 191 } 191 192 ··· 197 198 jsval_t obj = js_mkobj(js); 198 199 jsval_t proto = js_get_ctor_proto(js, "ArrayBuffer", 11); 199 200 200 200 - if (js_type(proto) == JS_OBJ) js_set_proto(js, obj, proto); 201 201 + if (vtype(proto) == T_OBJ) js_set_proto(js, obj, proto); 201 202 js_set_slot(js, obj, SLOT_BUFFER, ANT_PTR(data)); 202 203 js_set(js, obj, "byteLength", js_mknum((double)length)); 203 204 ··· 209 210 jsval_t this_val = js_getthis(js); 210 211 jsval_t data_val = js_get_slot(js, this_val, SLOT_BUFFER); 211 212 212 212 - if (js_type(data_val) != JS_NUM) { 213 213 + if (vtype(data_val) != T_NUM) { 213 214 return js_mkerr(js, "Not an ArrayBuffer"); 214 215 } 215 216 ··· 218 219 219 220 ssize_t len = (ssize_t)data->length; 220 221 ssize_t begin = 0, end = len; 221 221 - if (nargs > 0 && js_type(args[0]) == JS_NUM) begin = (ssize_t)js_getnum(args[0]); 222 222 - if (nargs > 1 && js_type(args[1]) == JS_NUM) end = (ssize_t)js_getnum(args[1]); 222 222 + if (nargs > 0 && vtype(args[0]) == T_NUM) begin = (ssize_t)js_getnum(args[0]); 223 223 + if (nargs > 1 && vtype(args[1]) == T_NUM) end = (ssize_t)js_getnum(args[1]); 223 224 224 225 begin = normalize_index(begin, len); 225 226 end = normalize_index(end, len); ··· 234 235 jsval_t new_obj = js_mkobj(js); 235 236 jsval_t proto = js_get_ctor_proto(js, "ArrayBuffer", 11); 236 237 237 237 - if (js_type(proto) == JS_OBJ) js_set_proto(js, new_obj, proto); 238 238 + if (vtype(proto) == T_OBJ) js_set_proto(js, new_obj, proto); 238 239 js_set_slot(js, new_obj, SLOT_BUFFER, ANT_PTR(new_data)); 239 240 js_set(js, new_obj, "byteLength", js_mknum((double)new_length)); 240 241 ··· 292 293 TypedArrayData *ta_data = (TypedArrayData *)js_gettypedarray(ta_val); 293 294 if (!ta_data || index >= ta_data->length) return false; 294 295 295 295 - double num_val = js_type(value) == JS_NUM ? js_getnum(value) : 0; 296 296 + double num_val = vtype(value) == T_NUM ? js_getnum(value) : 0; 296 297 uint8_t *data = ta_data->buffer->data + ta_data->byte_offset; 297 298 298 299 static const void *dispatch[] = { ··· 318 319 static jsval_t create_arraybuffer_obj(struct js *js, ArrayBufferData *buffer) { 319 320 jsval_t ab_obj = js_mkobj(js); 320 321 jsval_t ab_proto = js_get_ctor_proto(js, "ArrayBuffer", 11); 321 321 - if (js_type(ab_proto) == JS_OBJ) js_set_proto(js, ab_obj, ab_proto); 322 322 + if (vtype(ab_proto) == T_OBJ) js_set_proto(js, ab_obj, ab_proto); 322 323 323 324 js_set_slot(js, ab_obj, SLOT_BUFFER, js_mknum((double)(uintptr_t)buffer)); 324 325 js_set(js, ab_obj, "byteLength", js_mknum((double)buffer->length)); ··· 344 345 345 346 jsval_t obj = js_mkobj(js); 346 347 jsval_t proto = js_get_ctor_proto(js, type_name, strlen(type_name)); 347 347 - if (js_type(proto) == JS_OBJ) js_set_proto(js, obj, proto); 348 348 + if (vtype(proto) == T_OBJ) js_set_proto(js, obj, proto); 348 349 349 350 js_set_slot(js, obj, SLOT_BUFFER, js_mktypedarray(ta_data)); 350 351 js_set(js, obj, "length", js_mknum((double)length)); ··· 392 393 return create_typed_array(js, type, buffer, 0, 0, type_name); 393 394 } 394 395 395 395 - if (js_type(args[0]) == JS_NUM) { 396 396 + if (vtype(args[0]) == T_NUM) { 396 397 size_t length = (size_t)js_getnum(args[0]); 397 398 size_t element_size = get_element_size(type); 398 399 ArrayBufferData *buffer = create_array_buffer_data(length * element_size); ··· 401 402 } 402 403 403 404 jsval_t buffer_data_val = js_get_slot(js, args[0], SLOT_BUFFER); 404 404 - if (js_type(buffer_data_val) == JS_NUM) { 405 405 + if (vtype(buffer_data_val) == T_NUM) { 405 406 ArrayBufferData *buffer = (ArrayBufferData *)(uintptr_t)js_getnum(buffer_data_val); 406 407 size_t byte_offset = 0; 407 408 size_t length = buffer->length; 408 409 409 409 - if (nargs > 1 && js_type(args[1]) == JS_NUM) { 410 410 + if (nargs > 1 && vtype(args[1]) == T_NUM) { 410 411 byte_offset = (size_t)js_getnum(args[1]); 411 412 } 412 413 413 414 size_t element_size = get_element_size(type); 414 414 - if (nargs > 2 && js_type(args[2]) == JS_NUM) { 415 415 + if (nargs > 2 && vtype(args[2]) == T_NUM) { 415 416 length = (size_t)js_getnum(args[2]); 416 417 } else { 417 418 length = (buffer->length - byte_offset) / element_size; ··· 420 421 return create_typed_array_with_buffer(js, type, buffer, byte_offset, length, type_name, args[0]); 421 422 } 422 423 423 423 - int arg_type = js_type(args[0]); 424 424 - if (arg_type == JS_OBJ) { 424 424 + int arg_type = vtype(args[0]); 425 425 + if (arg_type == T_OBJ) { 425 426 jsval_t len_val = js_get(js, args[0], "length"); 426 427 size_t length = 0; jsval_t *values = NULL; 427 428 bool is_iterable = false; 428 429 429 429 - if (js_type(len_val) == JS_NUM) length = (size_t)js_getnum(len_val); else { 430 430 + if (vtype(len_val) == T_NUM) length = (size_t)js_getnum(len_val); else { 430 431 iter_collect_ctx_t ctx = { .values = NULL, .length = 0, .capacity = 16 }; 431 432 ctx.values = malloc(ctx.capacity * sizeof(jsval_t)); 432 433 if (!ctx.values) return js_mkerr(js, "Failed to allocate memory"); ··· 438 439 } else free(ctx.values); 439 440 } 440 441 441 441 - if (length > 0 || is_iterable || js_type(len_val) == JS_NUM) { 442 442 + if (length > 0 || is_iterable || vtype(len_val) == T_NUM) { 442 443 size_t element_size = get_element_size(type); 443 444 ArrayBufferData *buffer = create_array_buffer_data(length * element_size); 444 445 if (!buffer) { if (values) free(values); return js_mkerr(js, "Failed to allocate buffer"); } ··· 458 459 snprintf(idx_str, sizeof(idx_str), "%zu", i); 459 460 elem = js_get(js, args[0], idx_str); 460 461 } 461 461 - double val = js_type(elem) == JS_NUM ? js_getnum(elem) : 0; 462 462 + double val = vtype(elem) == T_NUM ? js_getnum(elem) : 0; 462 463 463 464 if (type > TYPED_ARRAY_BIGUINT64) goto W_DONE; 464 465 goto *write_dispatch[type]; ··· 493 494 ssize_t len = (ssize_t)ta_data->length; 494 495 ssize_t begin = 0, end = len; 495 496 496 496 - if (nargs > 0 && js_type(args[0]) == JS_NUM) begin = (ssize_t)js_getnum(args[0]); 497 497 - if (nargs > 1 && js_type(args[1]) == JS_NUM) end = (ssize_t)js_getnum(args[1]); 497 497 + if (nargs > 0 && vtype(args[0]) == T_NUM) begin = (ssize_t)js_getnum(args[0]); 498 498 + if (nargs > 1 && vtype(args[1]) == T_NUM) end = (ssize_t)js_getnum(args[1]); 498 499 499 500 begin = normalize_index(begin, len); 500 501 end = normalize_index(end, len); ··· 525 526 ssize_t len = (ssize_t)ta_data->length; 526 527 ssize_t begin = 0, end = len; 527 528 528 528 - if (nargs > 0 && js_type(args[0]) == JS_NUM) begin = (ssize_t)js_getnum(args[0]); 529 529 - if (nargs > 1 && js_type(args[1]) == JS_NUM) end = (ssize_t)js_getnum(args[1]); 529 529 + if (nargs > 0 && vtype(args[0]) == T_NUM) begin = (ssize_t)js_getnum(args[0]); 530 530 + if (nargs > 1 && vtype(args[1]) == T_NUM) end = (ssize_t)js_getnum(args[1]); 530 531 531 532 begin = normalize_index(begin, len); 532 533 end = normalize_index(end, len); ··· 548 549 if (!ta_data) return js_mkerr(js, "Invalid TypedArray"); 549 550 550 551 double value = 0; 551 551 - if (nargs > 0 && js_type(args[0]) == JS_NUM) value = js_getnum(args[0]); 552 552 + if (nargs > 0 && vtype(args[0]) == T_NUM) value = js_getnum(args[0]); 552 553 553 554 ssize_t len = (ssize_t)ta_data->length; 554 555 ssize_t start = 0, end = len; 555 556 556 556 - if (nargs > 1 && js_type(args[1]) == JS_NUM) start = (ssize_t)js_getnum(args[1]); 557 557 - if (nargs > 2 && js_type(args[2]) == JS_NUM) end = (ssize_t)js_getnum(args[2]); 557 557 + if (nargs > 1 && vtype(args[1]) == T_NUM) start = (ssize_t)js_getnum(args[1]); 558 558 + if (nargs > 2 && vtype(args[2]) == T_NUM) end = (ssize_t)js_getnum(args[2]); 558 559 559 560 start = normalize_index(start, len); 560 561 end = normalize_index(end, len); ··· 642 643 TypedArrayData *result_ta = (TypedArrayData *)js_gettypedarray(result_ta_val); 643 644 uint8_t *data = result_ta->buffer->data; 644 645 645 645 - jsval_t comparefn = (nargs > 0 && js_type(args[0]) == JS_FUNC) ? args[0] : js_mkundef(); 646 646 - bool has_comparefn = js_type(comparefn) == JS_FUNC; 646 646 + jsval_t comparefn = (nargs > 0 && vtype(args[0]) == T_FUNC) ? args[0] : js_mkundef(); 647 647 + bool has_comparefn = vtype(comparefn) == T_FUNC; 647 648 648 649 for (size_t i = 1; i < length; i++) { 649 650 for (size_t j = i; j > 0; j--) { ··· 774 775 } 775 776 776 777 jsval_t buffer_data_val = js_get_slot(js, args[0], SLOT_BUFFER); 777 777 - if (js_type(buffer_data_val) != JS_NUM) { 778 778 + if (vtype(buffer_data_val) != T_NUM) { 778 779 return js_mkerr(js, "First argument must be an ArrayBuffer"); 779 780 } 780 781 ··· 782 783 size_t byte_offset = 0; 783 784 size_t byte_length = buffer->length; 784 785 785 785 - if (nargs > 1 && js_type(args[1]) == JS_NUM) { 786 786 + if (nargs > 1 && vtype(args[1]) == T_NUM) { 786 787 byte_offset = (size_t)js_getnum(args[1]); 787 788 } 788 789 789 789 - if (nargs > 2 && js_type(args[2]) == JS_NUM) { 790 790 + if (nargs > 2 && vtype(args[2]) == T_NUM) { 790 791 byte_length = (size_t)js_getnum(args[2]); 791 792 } else { 792 793 byte_length = buffer->length - byte_offset; ··· 802 803 803 804 jsval_t obj = js_mkobj(js); 804 805 jsval_t proto = js_get_ctor_proto(js, "DataView", 8); 805 805 - if (js_type(proto) == JS_OBJ) js_set_proto(js, obj, proto); 806 806 + if (vtype(proto) == T_OBJ) js_set_proto(js, obj, proto); 806 807 807 808 js_set_slot(js, obj, SLOT_DATA, ANT_PTR(dv_data)); 808 809 js_mkprop_fast(js, obj, "buffer", 6, args[0]); ··· 821 822 jsval_t this_val = js_getthis(js); 822 823 jsval_t dv_data_val = js_get_slot(js, this_val, SLOT_DATA); 823 824 824 824 - if (js_type(dv_data_val) != JS_NUM) { 825 825 + if (vtype(dv_data_val) != T_NUM) { 825 826 return js_mkerr(js, "Not a DataView"); 826 827 } 827 828 ··· 843 844 jsval_t this_val = js_getthis(js); 844 845 jsval_t dv_data_val = js_get_slot(js, this_val, SLOT_DATA); 845 846 846 846 - if (js_type(dv_data_val) != JS_NUM) { 847 847 + if (vtype(dv_data_val) != T_NUM) { 847 848 return js_mkerr(js, "Not a DataView"); 848 849 } 849 850 ··· 866 867 jsval_t this_val = js_getthis(js); 867 868 jsval_t dv_data_val = js_get_slot(js, this_val, SLOT_DATA); 868 869 869 869 - if (js_type(dv_data_val) != JS_NUM) { 870 870 + if (vtype(dv_data_val) != T_NUM) { 870 871 return js_mkerr(js, "Not a DataView"); 871 872 } 872 873 ··· 897 898 jsval_t this_val = js_getthis(js); 898 899 jsval_t dv_data_val = js_get_slot(js, this_val, SLOT_DATA); 899 900 900 900 - if (js_type(dv_data_val) != JS_NUM) { 901 901 + if (vtype(dv_data_val) != T_NUM) { 901 902 return js_mkerr(js, "Not a DataView"); 902 903 } 903 904 ··· 928 929 jsval_t this_val = js_getthis(js); 929 930 jsval_t dv_data_val = js_get_slot(js, this_val, SLOT_DATA); 930 931 931 931 - if (js_type(dv_data_val) != JS_NUM) { 932 932 + if (vtype(dv_data_val) != T_NUM) { 932 933 return js_mkerr(js, "Not a DataView"); 933 934 } 934 935 ··· 961 962 jsval_t this_val = js_getthis(js); 962 963 jsval_t dv_data_val = js_get_slot(js, this_val, SLOT_DATA); 963 964 964 964 - if (js_type(dv_data_val) != JS_NUM) { 965 965 + if (vtype(dv_data_val) != T_NUM) { 965 966 return js_mkerr(js, "Not a DataView"); 966 967 } 967 968 ··· 994 995 jsval_t this_val = js_getthis(js); 995 996 jsval_t dv_data_val = js_get_slot(js, this_val, SLOT_DATA); 996 997 997 997 - if (js_type(dv_data_val) != JS_NUM) { 998 998 + if (vtype(dv_data_val) != T_NUM) { 998 999 return js_mkerr(js, "Not a DataView"); 999 1000 } 1000 1001 ··· 1031 1032 jsval_t this_val = js_getthis(js); 1032 1033 jsval_t dv_data_val = js_get_slot(js, this_val, SLOT_DATA); 1033 1034 1034 1034 - if (js_type(dv_data_val) != JS_NUM) { 1035 1035 + if (vtype(dv_data_val) != T_NUM) { 1035 1036 return js_mkerr(js, "Not a DataView"); 1036 1037 } 1037 1038 ··· 1070 1071 jsval_t this_val = js_getthis(js); 1071 1072 jsval_t dv_data_val = js_get_slot(js, this_val, SLOT_DATA); 1072 1073 1073 1073 - if (js_type(dv_data_val) != JS_NUM) { 1074 1074 + if (vtype(dv_data_val) != T_NUM) { 1074 1075 return js_mkerr(js, "Not a DataView"); 1075 1076 } 1076 1077 ··· 1105 1106 jsval_t this_val = js_getthis(js); 1106 1107 jsval_t dv_data_val = js_get_slot(js, this_val, SLOT_DATA); 1107 1108 1108 1108 - if (js_type(dv_data_val) != JS_NUM) { 1109 1109 + if (vtype(dv_data_val) != T_NUM) { 1109 1110 return js_mkerr(js, "Not a DataView"); 1110 1111 } 1111 1112 ··· 1195 1196 static jsval_t js_buffer_from(struct js *js, jsval_t *args, int nargs) { 1196 1197 if (nargs < 1) return js_mkerr(js, "Buffer.from requires at least one argument"); 1197 1198 1198 1198 - if (js_type(args[0]) == JS_STR) { 1199 1199 + if (vtype(args[0]) == T_STR) { 1199 1200 size_t len; 1200 1201 char *str = js_getstr(js, args[0], &len); 1201 1202 1202 1203 BufferEncoding encoding = ENC_UTF8; 1203 1203 - if (nargs >= 2 && js_type(args[1]) == JS_STR) { 1204 1204 + if (nargs >= 2 && vtype(args[1]) == T_STR) { 1204 1205 size_t enc_len; 1205 1206 char *enc_str = js_getstr(js, args[1], &enc_len); 1206 1207 encoding = parse_encoding(enc_str, enc_len); ··· 1249 1250 } 1250 1251 1251 1252 jsval_t length_val = js_get(js, args[0], "length"); 1252 1252 - if (js_type(length_val) == JS_NUM) { 1253 1253 + if (vtype(length_val) == T_NUM) { 1253 1254 size_t len = (size_t)js_getnum(length_val); 1254 1255 ArrayBufferData *buffer = create_array_buffer_data(len); 1255 1256 if (!buffer) return js_mkerr(js, "Failed to allocate buffer"); ··· 1258 1259 char idx_str[32]; 1259 1260 snprintf(idx_str, sizeof(idx_str), "%zu", i); 1260 1261 jsval_t elem = js_get(js, args[0], idx_str); 1261 1261 - if (js_type(elem) == JS_NUM) { 1262 1262 + if (vtype(elem) == T_NUM) { 1262 1263 buffer->data[i] = (uint8_t)js_getnum(elem); 1263 1264 } 1264 1265 } ··· 1304 1305 if (!ta_data) return js_mkerr(js, "Invalid Buffer"); 1305 1306 1306 1307 BufferEncoding encoding = ENC_UTF8; 1307 1307 - if (nargs > 0 && js_type(args[0]) == JS_STR) { 1308 1308 + if (nargs > 0 && vtype(args[0]) == T_STR) { 1308 1309 size_t enc_len; 1309 1310 char *enc_str = js_getstr(js, args[0], &enc_len); 1310 1311 encoding = parse_encoding(enc_str, enc_len); ··· 1370 1371 size_t offset = 0; 1371 1372 size_t length = ta_data->byte_length; 1372 1373 1373 1373 - if (nargs > 1 && js_type(args[1]) == JS_NUM) { 1374 1374 + if (nargs > 1 && vtype(args[1]) == T_NUM) { 1374 1375 offset = (size_t)js_getnum(args[1]); 1375 1376 } 1376 1377 1377 1377 - if (nargs > 2 && js_type(args[2]) == JS_NUM) { 1378 1378 + if (nargs > 2 && vtype(args[2]) == T_NUM) { 1378 1379 length = (size_t)js_getnum(args[2]); 1379 1380 } 1380 1381 ··· 1393 1394 // Buffer.isBuffer(obj) 1394 1395 static jsval_t js_buffer_isBuffer(struct js *js, jsval_t *args, int nargs) { 1395 1396 if (nargs < 1) return js_mkfalse(); 1396 1396 - if (js_type(args[0]) != JS_OBJ) return js_mkfalse(); 1397 1397 + if (vtype(args[0]) != T_OBJ) return js_mkfalse(); 1397 1398 1398 1399 jsval_t proto = js_get_proto(js, args[0]); 1399 1400 jsval_t buffer_proto = js_get_ctor_proto(js, "Buffer", 6); ··· 1403 1404 1404 1405 // Buffer.isEncoding(encoding) 1405 1406 static jsval_t js_buffer_isEncoding(struct js *js, jsval_t *args, int nargs) { 1406 1406 - if (nargs < 1 || js_type(args[0]) != JS_STR) return js_mkfalse(); 1407 1407 + if (nargs < 1 || vtype(args[0]) != T_STR) return js_mkfalse(); 1407 1408 1408 1409 size_t len; 1409 1410 char *enc = js_getstr(js, args[0], &len); ··· 1431 1432 1432 1433 jsval_t arg = args[0]; 1433 1434 1434 1434 - if (js_type(arg) == JS_OBJ) { 1435 1435 + if (vtype(arg) == T_OBJ) { 1435 1436 jsval_t bytelen = js_get(js, arg, "byteLength"); 1436 1436 - if (js_type(bytelen) == JS_NUM) return bytelen; 1437 1437 + if (vtype(bytelen) == T_NUM) return bytelen; 1437 1438 1438 1439 jsval_t len = js_get(js, arg, "length"); 1439 1439 - if (js_type(len) == JS_NUM) return len; 1440 1440 + if (vtype(len) == T_NUM) return len; 1440 1441 } 1441 1442 1442 1442 - if (js_type(arg) == JS_STR) { 1443 1443 + if (vtype(arg) == T_STR) { 1443 1444 size_t len; 1444 1445 js_getstr(js, arg, &len); 1445 1446 return js_mknum((double)len); ··· 1450 1451 1451 1452 // Buffer.concat(list, totalLength) 1452 1453 static jsval_t js_buffer_concat(struct js *js, jsval_t *args, int nargs) { 1453 1453 - if (nargs < 1 || js_type(args[0]) != JS_OBJ) { 1454 1454 + if (nargs < 1 || vtype(args[0]) != T_OBJ) { 1454 1455 return js_mkerr(js, "First argument must be an array"); 1455 1456 } 1456 1457 1457 1458 jsval_t list = args[0]; 1458 1459 jsval_t len_val = js_get(js, list, "length"); 1459 1459 - if (js_type(len_val) != JS_NUM) { 1460 1460 + if (vtype(len_val) != T_NUM) { 1460 1461 return js_mkerr(js, "First argument must be an array"); 1461 1462 } 1462 1463 1463 1464 size_t list_len = (size_t)js_getnum(len_val); 1464 1465 size_t total_length = 0; 1465 1466 1466 1466 - if (nargs > 1 && js_type(args[1]) == JS_NUM) { 1467 1467 + if (nargs > 1 && vtype(args[1]) == T_NUM) { 1467 1468 total_length = (size_t)js_getnum(args[1]); 1468 1469 } else { 1469 1470 for (size_t i = 0; i < list_len; i++) { ··· 1471 1472 snprintf(idx, sizeof(idx), "%zu", i); 1472 1473 jsval_t buf = js_get(js, list, idx); 1473 1474 jsval_t buf_len = js_get(js, buf, "length"); 1474 1474 - if (js_type(buf_len) == JS_NUM) total_length += (size_t)js_getnum(buf_len); 1475 1475 + if (vtype(buf_len) == T_NUM) total_length += (size_t)js_getnum(buf_len); 1475 1476 } 1476 1477 } 1477 1478 ··· 1531 1532 1532 1533 static jsval_t js_sharedarraybuffer_constructor(struct js *js, jsval_t *args, int nargs) { 1533 1534 size_t length = 0; 1534 1534 - if (nargs > 0 && js_type(args[0]) == JS_NUM) { 1535 1535 + if (nargs > 0 && vtype(args[0]) == T_NUM) { 1535 1536 length = (size_t)js_getnum(args[0]); 1536 1537 } 1537 1538 ··· 1543 1544 jsval_t obj = js_mkobj(js); 1544 1545 jsval_t proto = js_get_ctor_proto(js, "SharedArrayBuffer", 17); 1545 1546 1546 1546 - if (js_type(proto) == JS_OBJ) js_set_proto(js, obj, proto); 1547 1547 + if (vtype(proto) == T_OBJ) js_set_proto(js, obj, proto); 1547 1548 js_set_slot(js, obj, SLOT_BUFFER, ANT_PTR(data)); 1548 1549 js_set(js, obj, "byteLength", js_mknum((double)length)); 1549 1550

+1 -1

src/modules/builtin.c

reviewed

··· 29 29 struct js *js = signal_handlers[signum].js; 30 30 jsval_t handler = signal_handlers[signum].handler; 31 31 32 32 - if (js && js_type(handler) != JS_UNDEF) { 32 32 + if (js && vtype(handler) != T_UNDEF) { 33 33 jsval_t args[] = {js_mknum(signum)}; 34 34 js_call(js, handler, args, 1); 35 35 }

+38 -36

src/modules/child_process.c

reviewed

··· 24 24 25 25 #include "ant.h" 26 26 #include "errors.h" 27 27 + #include "internal.h" 28 28 + 27 29 #include "modules/child_process.h" 28 30 #include "modules/symbol.h" 29 31 ··· 135 137 while (i < evt->count) { 136 138 child_listener_t *l = &evt->listeners[i]; 137 139 jsval_t result = js_call(cp->js, l->callback, args, nargs); 138 138 - if (js_type(result) == JS_ERR) { 140 140 + if (vtype(result) == T_ERR) { 139 141 fprintf(stderr, "Error in child_process '%s' listener: %s\n", name, js_str(cp->js, result)); 140 142 } 141 143 if (l->once) { ··· 169 171 jsval_t close_args[2] = { js_mknum((double)cp->exit_code), cp->term_signal ? js_mknum((double)cp->term_signal) : js_mknull() }; 170 172 emit_event(cp, "close", close_args, 2); 171 173 172 172 - if (js_type(cp->promise) != JS_UNDEF) { 174 174 + if (vtype(cp->promise) != T_UNDEF) { 173 175 jsval_t result = js_mkobj(cp->js); 174 176 js_set(cp->js, result, "stdout", stdout_val); 175 177 js_set(cp->js, result, "stderr", stderr_val); ··· 316 318 static jsval_t child_on(struct js *js, jsval_t *args, int nargs) { 317 319 jsval_t this_obj = js_getthis(js); 318 320 if (nargs < 2) return js_mkerr(js, "on() requires event name and callback"); 319 319 - if (js_type(args[0]) != JS_STR) return js_mkerr(js, "Event name must be a string"); 320 320 - if (js_type(args[1]) != JS_FUNC) return js_mkerr(js, "Callback must be a function"); 321 321 + if (vtype(args[0]) != T_STR) return js_mkerr(js, "Event name must be a string"); 322 322 + if (vtype(args[1]) != T_FUNC) return js_mkerr(js, "Callback must be a function"); 321 323 322 324 jsval_t cp_ptr = js_get_slot(js, this_obj, SLOT_DATA); 323 323 - if (js_type(cp_ptr) == JS_UNDEF) return js_mkerr(js, "Invalid child process object"); 325 325 + if (vtype(cp_ptr) == T_UNDEF) return js_mkerr(js, "Invalid child process object"); 324 326 325 327 child_process_t *cp = (child_process_t *)(uintptr_t)js_getnum(cp_ptr); 326 328 ··· 345 347 static jsval_t child_once(struct js *js, jsval_t *args, int nargs) { 346 348 jsval_t this_obj = js_getthis(js); 347 349 if (nargs < 2) return js_mkerr(js, "once() requires event name and callback"); 348 348 - if (js_type(args[0]) != JS_STR) return js_mkerr(js, "Event name must be a string"); 349 349 - if (js_type(args[1]) != JS_FUNC) return js_mkerr(js, "Callback must be a function"); 350 350 + if (vtype(args[0]) != T_STR) return js_mkerr(js, "Event name must be a string"); 351 351 + if (vtype(args[1]) != T_FUNC) return js_mkerr(js, "Callback must be a function"); 350 352 351 353 jsval_t cp_ptr = js_get_slot(js, this_obj, SLOT_DATA); 352 352 - if (js_type(cp_ptr) == JS_UNDEF) return js_mkerr(js, "Invalid child process object"); 354 354 + if (vtype(cp_ptr) == T_UNDEF) return js_mkerr(js, "Invalid child process object"); 353 355 354 356 child_process_t *cp = (child_process_t *)(uintptr_t)js_getnum(cp_ptr); 355 357 ··· 375 377 jsval_t this_obj = js_getthis(js); 376 378 377 379 jsval_t cp_ptr = js_get_slot(js, this_obj, SLOT_DATA); 378 378 - if (js_type(cp_ptr) == JS_UNDEF) return js_mkfalse(); 380 380 + if (vtype(cp_ptr) == T_UNDEF) return js_mkfalse(); 379 381 380 382 child_process_t *cp = (child_process_t *)(uintptr_t)js_getnum(cp_ptr); 381 383 if (cp->exited) return js_mkfalse(); 382 384 383 385 int sig = SIGTERM; 384 386 if (nargs > 0) { 385 385 - if (js_type(args[0]) == JS_NUM) { 387 387 + if (vtype(args[0]) == T_NUM) { 386 388 sig = (int)js_getnum(args[0]); 387 387 - } else if (js_type(args[0]) == JS_STR) { 389 389 + } else if (vtype(args[0]) == T_STR) { 388 390 size_t sig_len; 389 391 char *sig_str = js_getstr(js, args[0], &sig_len); 390 392 if (strncmp(sig_str, "SIGTERM", sig_len) == 0) sig = SIGTERM; ··· 404 406 if (nargs < 1) return js_mkerr(js, "write() requires data argument"); 405 407 406 408 jsval_t cp_ptr = js_get_slot(js, this_obj, SLOT_DATA); 407 407 - if (js_type(cp_ptr) == JS_UNDEF) return js_mkerr(js, "Invalid child process object"); 409 409 + if (vtype(cp_ptr) == T_UNDEF) return js_mkerr(js, "Invalid child process object"); 408 410 409 411 child_process_t *cp = (child_process_t *)(uintptr_t)js_getnum(cp_ptr); 410 412 if (cp->stdin_closed) return js_mkfalse(); ··· 435 437 jsval_t this_obj = js_getthis(js); 436 438 437 439 jsval_t cp_ptr = js_get_slot(js, this_obj, SLOT_DATA); 438 438 - if (js_type(cp_ptr) == JS_UNDEF) return js_mkundef(); 440 440 + if (vtype(cp_ptr) == T_UNDEF) return js_mkundef(); 439 441 440 442 child_process_t *cp = (child_process_t *)(uintptr_t)js_getnum(cp_ptr); 441 443 if (!cp->stdin_closed) { ··· 481 483 char idx[16]; 482 484 snprintf(idx, sizeof(idx), "%d", i); 483 485 jsval_t val = js_get(js, arr, idx); 484 484 - if (js_type(val) == JS_STR) { 486 486 + if (vtype(val) == T_STR) { 485 487 size_t arg_len; 486 488 char *arg = js_getstr(js, val, &arg_len); 487 489 args[i] = strndup(arg, arg_len); ··· 503 505 504 506 static jsval_t builtin_spawn(struct js *js, jsval_t *args, int nargs) { 505 507 if (nargs < 1) return js_mkerr(js, "spawn() requires a command"); 506 506 - if (js_type(args[0]) != JS_STR) return js_mkerr(js, "Command must be a string"); 508 508 + if (vtype(args[0]) != T_STR) return js_mkerr(js, "Command must be a string"); 507 509 508 510 ensure_cp_loop(); 509 511 ··· 517 519 bool use_shell = false; 518 520 bool detached = false; 519 521 520 520 - if (nargs >= 2 && js_type(args[1]) == JS_OBJ) { 522 522 + if (nargs >= 2 && vtype(args[1]) == T_OBJ) { 521 523 jsval_t len_val = js_get(js, args[1], "length"); 522 522 - if (js_type(len_val) == JS_NUM) { 524 524 + if (vtype(len_val) == T_NUM) { 523 525 spawn_args = parse_args_array(js, args[1], &spawn_argc); 524 526 } 525 527 } 526 528 527 527 - if (nargs >= 3 && js_type(args[2]) == JS_OBJ) { 529 529 + if (nargs >= 3 && vtype(args[2]) == T_OBJ) { 528 530 jsval_t cwd_val = js_get(js, args[2], "cwd"); 529 529 - if (js_type(cwd_val) == JS_STR) { 531 531 + if (vtype(cwd_val) == T_STR) { 530 532 size_t cwd_len; 531 533 char *cwd_str = js_getstr(js, cwd_val, &cwd_len); 532 534 cwd = strndup(cwd_str, cwd_len); ··· 648 650 649 651 static jsval_t builtin_exec(struct js *js, jsval_t *args, int nargs) { 650 652 if (nargs < 1) return js_mkerr(js, "exec() requires a command"); 651 651 - if (js_type(args[0]) != JS_STR) return js_mkerr(js, "Command must be a string"); 653 653 + if (vtype(args[0]) != T_STR) return js_mkerr(js, "Command must be a string"); 652 654 653 655 ensure_cp_loop(); 654 656 ··· 657 659 char *cmd_str = strndup(cmd, cmd_len); 658 660 659 661 char *cwd = NULL; 660 660 - if (nargs >= 2 && js_type(args[1]) == JS_OBJ) { 662 662 + if (nargs >= 2 && vtype(args[1]) == T_OBJ) { 661 663 jsval_t cwd_val = js_get(js, args[1], "cwd"); 662 662 - if (js_type(cwd_val) == JS_STR) { 664 664 + if (vtype(cwd_val) == T_STR) { 663 665 size_t cwd_len; 664 666 char *cwd_s = js_getstr(js, cwd_val, &cwd_len); 665 667 cwd = strndup(cwd_s, cwd_len); ··· 730 732 731 733 static jsval_t builtin_execSync(struct js *js, jsval_t *args, int nargs) { 732 734 if (nargs < 1) return js_mkerr(js, "execSync() requires a command"); 733 733 - if (js_type(args[0]) != JS_STR) return js_mkerr(js, "Command must be a string"); 735 735 + if (vtype(args[0]) != T_STR) return js_mkerr(js, "Command must be a string"); 734 736 735 737 size_t cmd_len; 736 738 char *cmd = js_getstr(js, args[0], &cmd_len); ··· 795 797 #ifdef _WIN32 796 798 static jsval_t builtin_spawnSync(struct js *js, jsval_t *args, int nargs) { 797 799 if (nargs < 1) return js_mkerr(js, "spawnSync() requires a command"); 798 798 - if (js_type(args[0]) != JS_STR) return js_mkerr(js, "Command must be a string"); 800 800 + if (vtype(args[0]) != T_STR) return js_mkerr(js, "Command must be a string"); 799 801 800 802 size_t cmd_len; 801 803 char *cmd = js_getstr(js, args[0], &cmd_len); ··· 806 808 char *input = NULL; 807 809 size_t input_len = 0; 808 810 809 809 - if (nargs >= 2 && js_type(args[1]) == JS_OBJ) { 811 811 + if (nargs >= 2 && vtype(args[1]) == T_OBJ) { 810 812 jsval_t len_val = js_get(js, args[1], "length"); 811 811 - if (js_type(len_val) == JS_NUM) { 813 813 + if (vtype(len_val) == T_NUM) { 812 814 spawn_args = parse_args_array(js, args[1], &spawn_argc); 813 815 } 814 816 } 815 817 816 816 - if (nargs >= 3 && js_type(args[2]) == JS_OBJ) { 818 818 + if (nargs >= 3 && vtype(args[2]) == T_OBJ) { 817 819 jsval_t input_val = js_get(js, args[2], "input"); 818 818 - if (js_type(input_val) == JS_STR) { 820 820 + if (vtype(input_val) == T_STR) { 819 821 input = js_getstr(js, input_val, &input_len); 820 822 } 821 823 } ··· 940 942 #else 941 943 static jsval_t builtin_spawnSync(struct js *js, jsval_t *args, int nargs) { 942 944 if (nargs < 1) return js_mkerr(js, "spawnSync() requires a command"); 943 943 - if (js_type(args[0]) != JS_STR) return js_mkerr(js, "Command must be a string"); 945 945 + if (vtype(args[0]) != T_STR) return js_mkerr(js, "Command must be a string"); 944 946 945 947 size_t cmd_len; 946 948 char *cmd = js_getstr(js, args[0], &cmd_len); ··· 951 953 char *input = NULL; 952 954 size_t input_len = 0; 953 955 954 954 - if (nargs >= 2 && js_type(args[1]) == JS_OBJ) { 956 956 + if (nargs >= 2 && vtype(args[1]) == T_OBJ) { 955 957 jsval_t len_val = js_get(js, args[1], "length"); 956 956 - if (js_type(len_val) == JS_NUM) { 958 958 + if (vtype(len_val) == T_NUM) { 957 959 spawn_args = parse_args_array(js, args[1], &spawn_argc); 958 960 } 959 961 } 960 962 961 961 - if (nargs >= 3 && js_type(args[2]) == JS_OBJ) { 963 963 + if (nargs >= 3 && vtype(args[2]) == T_OBJ) { 962 964 jsval_t input_val = js_get(js, args[2], "input"); 963 963 - if (js_type(input_val) == JS_STR) { 965 965 + if (vtype(input_val) == T_STR) { 964 966 input = js_getstr(js, input_val, &input_len); 965 967 } 966 968 } ··· 1080 1082 1081 1083 static jsval_t builtin_fork(struct js *js, jsval_t *args, int nargs) { 1082 1084 if (nargs < 1) return js_mkerr(js, "fork() requires a module path"); 1083 1083 - if (js_type(args[0]) != JS_STR) return js_mkerr(js, "Module path must be a string"); 1085 1085 + if (vtype(args[0]) != T_STR) return js_mkerr(js, "Module path must be a string"); 1084 1086 size_t path_len; 1085 1087 1086 1088 char *path = js_getstr(js, args[0], &path_len); ··· 1110 1112 jsval_t args_arr = js_mkarr(js); 1111 1113 js_arr_push(js, args_arr, js_mkstr(js, path_str, path_len)); 1112 1114 1113 1113 - if (nargs >= 2 && js_type(args[1]) == JS_OBJ) { 1115 1115 + if (nargs >= 2 && vtype(args[1]) == T_OBJ) { 1114 1116 jsval_t exec_args = js_get(js, args[1], "execArgv"); 1115 1115 - if (js_type(exec_args) == JS_OBJ) { 1117 1117 + if (vtype(exec_args) == T_OBJ) { 1116 1118 jsval_t len_val = js_get(js, exec_args, "length"); 1117 1119 int arr_len = (int)js_getnum(len_val); 1118 1120 for (int i = 0; i < arr_len; i++) {

+15 -14

src/modules/events.c

reviewed

··· 8 8 #include "errors.h" 9 9 #include "arena.h" 10 10 #include "runtime.h" 11 11 + #include "internal.h" 11 12 12 13 #include "modules/events.h" 13 14 #include "modules/symbol.h" ··· 39 40 static EventType **get_or_create_emitter_events(struct js *js, jsval_t this_obj) { 40 41 jsval_t slot = js_get_slot(js, this_obj, SLOT_DATA); 41 42 42 42 - if (js_type(slot) == JS_UNDEF) { 43 43 + if (vtype(slot) == T_UNDEF) { 43 44 EventType **events = ant_calloc(sizeof(EventType *)); 44 45 *events = NULL; 45 46 js_set_slot(js, this_obj, SLOT_DATA, ANT_PTR(events)); ··· 109 110 110 111 char *event_type = js_getstr(js, args[0], NULL); 111 112 if (event_type == NULL) return js_mkerr(js, "eventType must be a string"); 112 112 - if (js_type(args[1]) != JS_FUNC) return js_mkerr(js, "listener must be a function"); 113 113 + if (vtype(args[1]) != T_FUNC) return js_mkerr(js, "listener must be a function"); 113 114 114 115 EventType *evt = find_or_create_emitter_event_type(js, this_obj, event_type); 115 116 if (evt == NULL) return js_mkerr(js, "failed to create event type"); ··· 119 120 } 120 121 121 122 bool once = false; 122 122 - if (nargs >= 3 && js_type(args[2]) != JS_UNDEF) { 123 123 + if (nargs >= 3 && vtype(args[2]) != T_UNDEF) { 123 124 jsval_t once_val = js_get(js, args[2], "once"); 124 124 - if (js_type(once_val) != JS_UNDEF) once = js_truthy(js, once_val); 125 125 + if (vtype(once_val) != T_UNDEF) once = js_truthy(js, once_val); 125 126 } 126 127 127 128 EventListener *listener = &evt->listeners[evt->listener_count++]; ··· 142 143 return js_mkerr(js, "eventType must be a string"); 143 144 } 144 145 145 145 - if (js_type(args[1]) != JS_FUNC) { 146 146 + if (vtype(args[1]) != T_FUNC) { 146 147 return js_mkerr(js, "listener must be a function"); 147 148 } 148 149 ··· 156 157 } 157 158 158 159 bool once = false; 159 159 - if (nargs >= 3 && js_type(args[2]) != JS_UNDEF) { 160 160 + if (nargs >= 3 && vtype(args[2]) != T_UNDEF) { 160 161 jsval_t once_val = js_get(js, args[2], "once"); 161 161 - if (js_type(once_val) != JS_UNDEF) once = js_truthy(js, once_val); 162 162 + if (vtype(once_val) != T_UNDEF) once = js_truthy(js, once_val); 162 163 } 163 164 164 165 EventListener *listener = &evt->listeners[evt->listener_count++]; ··· 231 232 js_set(js, event_obj, "target", this_obj); 232 233 js_set(js, event_obj, get_toStringTag_sym_key(), js_mkstr(js, "Event", 5)); 233 234 234 234 - if (nargs >= 2 && js_type(args[1]) != JS_UNDEF) { 235 235 + if (nargs >= 2 && vtype(args[1]) != T_UNDEF) { 235 236 js_set(js, event_obj, "detail", args[1]); 236 237 } 237 238 ··· 241 242 EventListener *listener = &evt->listeners[i]; 242 243 jsval_t result = js_call(js, listener->listener, listener_args, 1); 243 244 244 244 - if (js_type(result) == JS_ERR) { 245 245 + if (vtype(result) == T_ERR) { 245 246 fprintf(stderr, "Error in event listener for '%s': %s\n", event_type, js_str(js, result)); 246 247 } 247 248 ··· 271 272 js_set(js, event_obj, "type", args[0]); 272 273 js_set(js, event_obj, get_toStringTag_sym_key(), js_mkstr(js, "Event", 5)); 273 274 274 274 - if (nargs >= 2 && js_type(args[1]) != JS_UNDEF) { 275 275 + if (nargs >= 2 && vtype(args[1]) != T_UNDEF) { 275 276 js_set(js, event_obj, "detail", args[1]); 276 277 } 277 278 ··· 281 282 EventListener *listener = &evt->listeners[i]; 282 283 jsval_t result = js_call(js, listener->listener, listener_args, 1); 283 284 284 284 - if (js_type(result) == JS_ERR) { 285 285 + if (vtype(result) == T_ERR) { 285 286 fprintf(stderr, "Error in event listener for '%s': %s\n", event_type, js_str(js, result)); 286 287 } 287 288 ··· 333 334 return js_mkerr(js, "event must be a string"); 334 335 } 335 336 336 336 - if (js_type(args[1]) != JS_FUNC) { 337 337 + if (vtype(args[1]) != T_FUNC) { 337 338 return js_mkerr(js, "listener must be a function"); 338 339 } 339 340 ··· 366 367 return js_mkerr(js, "event must be a string"); 367 368 } 368 369 369 369 - if (js_type(args[1]) != JS_FUNC) { 370 370 + if (vtype(args[1]) != T_FUNC) { 370 371 return js_mkerr(js, "listener must be a function"); 371 372 } 372 373 ··· 439 440 EventListener *listener = &evt->listeners[i]; 440 441 jsval_t result = js_call(js, listener->listener, listener_args, listener_nargs); 441 442 442 442 - if (js_type(result) == JS_ERR) { 443 443 + if (vtype(result) == T_ERR) { 443 444 fprintf(stderr, "Error in event listener for '%s': %s\n", event_type, js_str(js, result)); 444 445 } 445 446

+8 -7

src/modules/fetch.c

reviewed

··· 12 12 #include "errors.h" 13 13 #include "config.h" 14 14 #include "common.h" 15 15 + #include "internal.h" 15 16 #include "runtime.h" 16 17 #include "modules/fetch.h" 17 18 #include "modules/json.h" ··· 76 77 jsval_t parsed = js_json_parse(js, &body, 1); 77 78 jsval_t promise = js_mkpromise(js); 78 79 79 79 - if (js_type(parsed) == JS_ERR) { 80 80 + if (vtype(parsed) == T_ERR) { 80 81 js_reject_promise(js, promise, parsed); 81 82 } else js_resolve_promise(js, promise, parsed); 82 83 ··· 270 271 char *body = NULL; 271 272 size_t body_len = 0; 272 273 273 273 - if (js_type(options_val) == JS_OBJ) { 274 274 + if (vtype(options_val) == T_OBJ) { 274 275 jsval_t method_val = js_get(js, options_val, "method"); 275 275 - if (js_type(method_val) == JS_STR) { 276 276 + if (vtype(method_val) == T_STR) { 276 277 char *method_str = js_getstr(js, method_val, NULL); 277 278 if (method_str) method = method_str; 278 279 } 279 280 280 281 jsval_t body_val = js_get(js, options_val, "body"); 281 281 - if (js_type(body_val) == JS_STR) { 282 282 + if (vtype(body_val) == T_STR) { 282 283 body = js_getstr(js, body_val, NULL); 283 284 if (body) body_len = strlen(body); 284 285 } ··· 301 302 snprintf(user_agent, sizeof(user_agent), "ant/%s", ANT_VERSION); 302 303 tlsuv_http_req_header(req->http_req, "User-Agent", user_agent); 303 304 304 304 - if (js_type(options_val) == JS_OBJ) { 305 305 + if (vtype(options_val) == T_OBJ) { 305 306 jsval_t headers_val = js_get(js, options_val, "headers"); 306 306 - if (js_type(headers_val) == JS_OBJ) { 307 307 + if (vtype(headers_val) == T_OBJ) { 307 308 ant_iter_t iter = js_prop_iter_begin(js, headers_val); 308 309 const char *key; 309 310 size_t key_len; ··· 329 330 330 331 static jsval_t js_fetch(struct js *js, jsval_t *args, int nargs) { 331 332 if (nargs < 1) return js_mkerr(js, "fetch requires at least 1 argument"); 332 332 - if (js_type(args[0]) != JS_STR) return js_mkerr(js, "fetch URL must be a string"); 333 333 + if (vtype(args[0]) != T_STR) return js_mkerr(js, "fetch URL must be a string"); 333 334 334 335 jsval_t url_val = args[0]; 335 336 jsval_t options_val = nargs > 1 ? args[1] : js_mkundef();

+34 -32

src/modules/ffi.c

reviewed

··· 16 16 #include <uthash.h> 17 17 18 18 #include "errors.h" 19 19 + #include "internal.h" 20 20 + 19 21 #include "modules/ffi.h" 20 22 #include "modules/symbol.h" 21 23 ··· 151 153 } 152 154 153 155 static jsval_t ffi_dlopen(struct js *js, jsval_t *args, int nargs) { 154 154 - if (nargs < 1 || js_type(args[0]) != JS_STR) { 156 156 + if (nargs < 1 || vtype(args[0]) != T_STR) { 155 157 return js_mkerr(js, "dlopen() requires library name string"); 156 158 } 157 159 ··· 200 202 } 201 203 202 204 static jsval_t ffi_define(struct js *js, jsval_t *args, int nargs) { 203 203 - if (nargs < 2 || js_type(args[0]) != JS_STR) { 205 205 + if (nargs < 2 || vtype(args[0]) != T_STR) { 204 206 return js_mkerr(js, "define() requires function name string and signature"); 205 207 } 206 208 207 209 jsval_t this_obj = js_getthis(js); 208 210 jsval_t lib_ptr_val = js_get(js, this_obj, "__lib_ptr"); 209 209 - if (js_type(lib_ptr_val) != JS_NUM) { 211 211 + if (vtype(lib_ptr_val) != T_NUM) { 210 212 return js_mkerr(js, "Invalid library object"); 211 213 } 212 214 ··· 214 216 const char *func_name = js_getstr(js, args[0], &func_name_len); 215 217 216 218 jsval_t sig = args[1]; 217 217 - int sig_type = js_type(sig); 218 218 - if (sig_type == JS_STR || sig_type == JS_NUM || sig_type == JS_NULL || 219 219 - sig_type == JS_UNDEF) { 219 219 + int sig_type = vtype(sig); 220 220 + if (sig_type == T_STR || sig_type == T_NUM || sig_type == T_NULL || 221 221 + sig_type == T_UNDEF) { 220 222 return js_mkerr(js, 221 223 "Signature must be an array [returnType, [argTypes...]] or " 222 224 "an object {args: [...], returns: type}"); ··· 229 231 jsval_t returns_val = js_get(js, sig, "returns"); 230 232 jsval_t args_val = js_get(js, sig, "args"); 231 233 232 232 - if (js_type(returns_val) != JS_UNDEF && js_type(args_val) != JS_UNDEF) { 233 233 - if (js_type(returns_val) != JS_STR) { 234 234 + if (vtype(returns_val) != T_UNDEF && vtype(args_val) != T_UNDEF) { 235 235 + if (vtype(returns_val) != T_STR) { 234 236 return js_mkerr(js, "Return type must be a string"); 235 237 } 236 238 ret_type_str = js_getstr(js, returns_val, NULL); 237 239 arg_types_arr = args_val; 238 240 239 239 - if (js_type(arg_types_arr) == JS_STR || js_type(arg_types_arr) == JS_NUM || 240 240 - js_type(arg_types_arr) == JS_NULL || 241 241 - js_type(arg_types_arr) == JS_UNDEF) { 241 241 + if (vtype(arg_types_arr) == T_STR || vtype(arg_types_arr) == T_NUM || 242 242 + vtype(arg_types_arr) == T_NULL || 243 243 + vtype(arg_types_arr) == T_UNDEF) { 242 244 return js_mkerr(js, "Argument types must be an array"); 243 245 } 244 246 ··· 246 248 arg_count = (int)js_getnum(length_val); 247 249 } else { 248 250 jsval_t ret_type_val = js_get(js, sig, "0"); 249 249 - if (js_type(ret_type_val) != JS_STR) { 251 251 + if (vtype(ret_type_val) != T_STR) { 250 252 return js_mkerr(js, "Return type must be a string"); 251 253 } 252 254 253 255 ret_type_str = js_getstr(js, ret_type_val, NULL); 254 256 arg_types_arr = js_get(js, sig, "1"); 255 257 256 256 - int arg_arr_type = js_type(arg_types_arr); 257 257 - if (arg_arr_type == JS_STR || arg_arr_type == JS_NUM || 258 258 - arg_arr_type == JS_NULL || arg_arr_type == JS_UNDEF) { 258 258 + int arg_arr_type = vtype(arg_types_arr); 259 259 + if (arg_arr_type == T_STR || arg_arr_type == T_NUM || 260 260 + arg_arr_type == T_NULL || arg_arr_type == T_UNDEF) { 259 261 return js_mkerr(js, "Argument types must be an array"); 260 262 } 261 263 ··· 300 302 snprintf(idx_str, sizeof(idx_str), "%d", i); 301 303 jsval_t arg_type_val = js_get(js, arg_types_arr, idx_str); 302 304 303 303 - if (js_type(arg_type_val) != JS_STR) { 305 305 + if (vtype(arg_type_val) != T_STR) { 304 306 free(func->arg_types); 305 307 free(func); 306 308 return js_mkerr(js, "Argument type must be a string"); ··· 348 350 349 351 static jsval_t ffi_lib_call(struct js *js, jsval_t *args, int nargs) { 350 352 jsval_t lib_obj = js_getthis(js); 351 351 - if (nargs < 1 || js_type(args[0]) != JS_STR) 353 353 + if (nargs < 1 || vtype(args[0]) != T_STR) 352 354 return js_mkerr(js, "call() requires function name string"); 353 355 354 356 size_t func_name_len; ··· 442 444 } 443 445 444 446 static jsval_t ffi_alloc_memory(struct js *js, jsval_t *args, int nargs) { 445 445 - if (nargs < 1 || js_type(args[0]) != JS_NUM) { 447 447 + if (nargs < 1 || vtype(args[0]) != T_NUM) { 446 448 return js_mkerr(js, "alloc() requires size"); 447 449 } 448 450 ··· 475 477 } 476 478 477 479 static jsval_t ffi_free_memory(struct js *js, jsval_t *args, int nargs) { 478 478 - if (nargs < 1 || js_type(args[0]) != JS_NUM) { 480 480 + if (nargs < 1 || vtype(args[0]) != T_NUM) { 479 481 return js_mkerr(js, "free() requires pointer"); 480 482 } 481 483 ··· 502 504 } 503 505 504 506 static jsval_t ffi_read_memory(struct js *js, jsval_t *args, int nargs) { 505 505 - if (nargs < 2 || js_type(args[0]) != JS_NUM || js_type(args[1]) != JS_STR) { 507 507 + if (nargs < 2 || vtype(args[0]) != T_NUM || vtype(args[1]) != T_STR) { 506 508 return js_mkerr(js, "read() requires pointer and type"); 507 509 } 508 510 ··· 530 532 } 531 533 532 534 static jsval_t ffi_write_memory(struct js *js, jsval_t *args, int nargs) { 533 533 - if (nargs < 3 || js_type(args[0]) != JS_NUM || js_type(args[1]) != JS_STR) { 535 535 + if (nargs < 3 || vtype(args[0]) != T_NUM || vtype(args[1]) != T_STR) { 534 536 return js_mkerr(js, "write() requires pointer, type, and value"); 535 537 } 536 538 ··· 560 562 } 561 563 562 564 static jsval_t ffi_get_pointer(struct js *js, jsval_t *args, int nargs) { 563 563 - if (nargs < 1 || js_type(args[0]) != JS_NUM) return js_mkerr(js, "pointer() requires pointer"); 565 565 + if (nargs < 1 || vtype(args[0]) != T_NUM) return js_mkerr(js, "pointer() requires pointer"); 564 566 uint64_t ptr_key = (uint64_t)js_getnum(args[0]); 565 567 566 568 pthread_mutex_lock(&ffi_pointers_mutex); ··· 573 575 } 574 576 575 577 static jsval_t ffi_read_ptr(struct js *js, jsval_t *args, int nargs) { 576 576 - if (nargs < 2 || js_type(args[0]) != JS_NUM || js_type(args[1]) != JS_STR) { 578 578 + if (nargs < 2 || vtype(args[0]) != T_NUM || vtype(args[1]) != T_STR) { 577 579 return js_mkerr(js, "readPtr() requires pointer and type"); 578 580 } 579 581 ··· 627 629 } else if (cb->ret_type == &ffi_type_double) { 628 630 *(double *)ret = js_getnum(result); 629 631 } else if (cb->ret_type == &ffi_type_pointer) { 630 630 - if (js_type(result) == JS_NUM) { 632 632 + if (vtype(result) == T_NUM) { 631 633 *(void **)ret = (void *)(uint64_t)js_getnum(result); 632 634 } else { 633 635 *(void **)ret = NULL; ··· 641 643 642 644 jsval_t js_func = args[0]; 643 645 jsval_t sig = args[1]; 644 644 - int sig_type = js_type(sig); 645 645 - if (sig_type == JS_STR || sig_type == JS_NUM || sig_type == JS_NULL || sig_type == JS_UNDEF) { 646 646 + int sig_type = vtype(sig); 647 647 + if (sig_type == T_STR || sig_type == T_NUM || sig_type == T_NULL || sig_type == T_UNDEF) { 646 648 return js_mkerr(js, "Signature must be an object {args: [...], returns: type}"); 647 649 } 648 650 ··· 653 655 jsval_t returns_val = js_get(js, sig, "returns"); 654 656 jsval_t args_val = js_get(js, sig, "args"); 655 657 656 656 - if (js_type(returns_val) != JS_UNDEF && js_type(args_val) != JS_UNDEF) { 657 657 - if (js_type(returns_val) != JS_STR) return js_mkerr(js, "Return type must be a string"); 658 658 + if (vtype(returns_val) != T_UNDEF && vtype(args_val) != T_UNDEF) { 659 659 + if (vtype(returns_val) != T_STR) return js_mkerr(js, "Return type must be a string"); 658 660 ret_type_str = js_getstr(js, returns_val, NULL); 659 661 arg_types_arr = args_val; 660 662 jsval_t length_val = js_get(js, arg_types_arr, "length"); 661 663 arg_count = (int)js_getnum(length_val); 662 664 } else { 663 665 jsval_t ret_type_val = js_get(js, sig, "0"); 664 664 - if (js_type(ret_type_val) != JS_STR) return js_mkerr(js, "Return type must be a string"); 666 666 + if (vtype(ret_type_val) != T_STR) return js_mkerr(js, "Return type must be a string"); 665 667 ret_type_str = js_getstr(js, ret_type_val, NULL); 666 668 arg_types_arr = js_get(js, sig, "1"); 667 669 jsval_t length_val = js_get(js, arg_types_arr, "length"); ··· 696 698 snprintf(idx_str, sizeof(idx_str), "%d", i); 697 699 jsval_t arg_type_val = js_get(js, arg_types_arr, idx_str); 698 700 699 699 - if (js_type(arg_type_val) != JS_STR) { 701 701 + if (vtype(arg_type_val) != T_STR) { 700 702 for (int j = 0; j < i; j++) free(cb->arg_type_strs[j]); 701 703 free(cb->arg_types); 702 704 free(cb->arg_type_strs); ··· 758 760 } 759 761 760 762 static jsval_t ffi_free_callback(struct js *js, jsval_t *args, int nargs) { 761 761 - if (nargs < 1 || js_type(args[0]) != JS_NUM) { 763 763 + if (nargs < 1 || vtype(args[0]) != T_NUM) { 762 764 return js_mkerr(js, "freeCallback() requires callback pointer"); 763 765 } 764 766 ··· 919 921 goto do_done; 920 922 } 921 923 do_pointer: { 922 922 - if (js_type(val) == JS_STR) { 924 924 + if (vtype(val) == T_STR) { 923 925 size_t str_len; 924 926 const char *str = js_getstr(js, val, &str_len); 925 927 void *ptr = (void *)str;

+41 -41

src/modules/fs.c

reviewed

··· 275 275 276 276 jsval_t stat_obj = js_mkobj(req->js); 277 277 jsval_t proto = js_get_ctor_proto(req->js, "Stats", 5); 278 278 - if (js_type(proto) == JS_OBJ) js_set_proto(req->js, stat_obj, proto); 278 278 + if (vtype(proto) == T_OBJ) js_set_proto(req->js, stat_obj, proto); 279 279 280 280 uv_stat_t *st = &uv_req->statbuf; 281 281 js_set_slot(req->js, stat_obj, SLOT_DATA, js_mknum((double)st->st_mode)); ··· 360 360 static jsval_t builtin_fs_readFileSync(struct js *js, jsval_t *args, int nargs) { 361 361 if (nargs < 1) return js_mkerr(js, "readFileSync() requires a path argument"); 362 362 363 363 - if (js_type(args[0]) != JS_STR) return js_mkerr(js, "readFileSync() path must be a string"); 363 363 + if (vtype(args[0]) != T_STR) return js_mkerr(js, "readFileSync() path must be a string"); 364 364 365 365 size_t path_len; 366 366 char *path = js_getstr(js, args[0], &path_len); ··· 411 411 412 412 static jsval_t builtin_fs_readBytesSync(struct js *js, jsval_t *args, int nargs) { 413 413 if (nargs < 1) return js_mkerr(js, "readBytesSync() requires a path argument"); 414 414 - if (js_type(args[0]) != JS_STR) return js_mkerr(js, "readBytesSync() path must be a string"); 414 414 + if (vtype(args[0]) != T_STR) return js_mkerr(js, "readBytesSync() path must be a string"); 415 415 416 416 size_t path_len; 417 417 char *path = js_getstr(js, args[0], &path_len); ··· 462 462 static jsval_t builtin_fs_readFile(struct js *js, jsval_t *args, int nargs) { 463 463 if (nargs < 1) return js_mkerr(js, "readFile() requires a path argument"); 464 464 465 465 - if (js_type(args[0]) != JS_STR) return js_mkerr(js, "readFile() path must be a string"); 465 465 + if (vtype(args[0]) != T_STR) return js_mkerr(js, "readFile() path must be a string"); 466 466 467 467 size_t path_len; 468 468 char *path = js_getstr(js, args[0], &path_len); ··· 495 495 static jsval_t builtin_fs_readBytes(struct js *js, jsval_t *args, int nargs) { 496 496 if (nargs < 1) return js_mkerr(js, "readBytes() requires a path argument"); 497 497 498 498 - if (js_type(args[0]) != JS_STR) return js_mkerr(js, "readBytes() path must be a string"); 498 498 + if (vtype(args[0]) != T_STR) return js_mkerr(js, "readBytes() path must be a string"); 499 499 500 500 size_t path_len; 501 501 char *path = js_getstr(js, args[0], &path_len); ··· 528 528 static jsval_t builtin_fs_writeFileSync(struct js *js, jsval_t *args, int nargs) { 529 529 if (nargs < 2) return js_mkerr(js, "writeFileSync() requires path and data arguments"); 530 530 531 531 - if (js_type(args[0]) != JS_STR) return js_mkerr(js, "writeFileSync() path must be a string"); 532 532 - if (js_type(args[1]) != JS_STR) return js_mkerr(js, "writeFileSync() data must be a string"); 531 531 + if (vtype(args[0]) != T_STR) return js_mkerr(js, "writeFileSync() path must be a string"); 532 532 + if (vtype(args[1]) != T_STR) return js_mkerr(js, "writeFileSync() data must be a string"); 533 533 534 534 size_t path_len, data_len; 535 535 char *path = js_getstr(js, args[0], &path_len); ··· 561 561 static jsval_t builtin_fs_copyFileSync(struct js *js, jsval_t *args, int nargs) { 562 562 if (nargs < 2) return js_mkerr(js, "copyFileSync() requires src and dest arguments"); 563 563 564 564 - if (js_type(args[0]) != JS_STR) return js_mkerr(js, "copyFileSync() src must be a string"); 565 565 - if (js_type(args[1]) != JS_STR) return js_mkerr(js, "copyFileSync() dest must be a string"); 564 564 + if (vtype(args[0]) != T_STR) return js_mkerr(js, "copyFileSync() src must be a string"); 565 565 + if (vtype(args[1]) != T_STR) return js_mkerr(js, "copyFileSync() dest must be a string"); 566 566 567 567 size_t src_len, dest_len; 568 568 char *src = js_getstr(js, args[0], &src_len); ··· 618 618 static jsval_t builtin_fs_renameSync(struct js *js, jsval_t *args, int nargs) { 619 619 if (nargs < 2) return js_mkerr(js, "renameSync() requires oldPath and newPath arguments"); 620 620 621 621 - if (js_type(args[0]) != JS_STR) return js_mkerr(js, "renameSync() oldPath must be a string"); 622 622 - if (js_type(args[1]) != JS_STR) return js_mkerr(js, "renameSync() newPath must be a string"); 621 621 + if (vtype(args[0]) != T_STR) return js_mkerr(js, "renameSync() oldPath must be a string"); 622 622 + if (vtype(args[1]) != T_STR) return js_mkerr(js, "renameSync() newPath must be a string"); 623 623 624 624 size_t old_len, new_len; 625 625 char *old_path = js_getstr(js, args[0], &old_len); ··· 651 651 static jsval_t builtin_fs_appendFileSync(struct js *js, jsval_t *args, int nargs) { 652 652 if (nargs < 2) return js_mkerr(js, "appendFileSync() requires path and data arguments"); 653 653 654 654 - if (js_type(args[0]) != JS_STR) return js_mkerr(js, "appendFileSync() path must be a string"); 655 655 - if (js_type(args[1]) != JS_STR) return js_mkerr(js, "appendFileSync() data must be a string"); 654 654 + if (vtype(args[0]) != T_STR) return js_mkerr(js, "appendFileSync() path must be a string"); 655 655 + if (vtype(args[1]) != T_STR) return js_mkerr(js, "appendFileSync() data must be a string"); 656 656 657 657 size_t path_len, data_len; 658 658 char *path = js_getstr(js, args[0], &path_len); ··· 684 684 static jsval_t builtin_fs_writeFile(struct js *js, jsval_t *args, int nargs) { 685 685 if (nargs < 2) return js_mkerr(js, "writeFile() requires path and data arguments"); 686 686 687 687 - if (js_type(args[0]) != JS_STR) return js_mkerr(js, "writeFile() path must be a string"); 688 688 - if (js_type(args[1]) != JS_STR) return js_mkerr(js, "writeFile() data must be a string"); 687 687 + if (vtype(args[0]) != T_STR) return js_mkerr(js, "writeFile() path must be a string"); 688 688 + if (vtype(args[1]) != T_STR) return js_mkerr(js, "writeFile() data must be a string"); 689 689 690 690 size_t path_len, data_len; 691 691 char *path = js_getstr(js, args[0], &path_len); ··· 729 729 static jsval_t builtin_fs_unlinkSync(struct js *js, jsval_t *args, int nargs) { 730 730 if (nargs < 1) return js_mkerr(js, "unlinkSync() requires a path argument"); 731 731 732 732 - if (js_type(args[0]) != JS_STR) return js_mkerr(js, "unlinkSync() path must be a string"); 732 732 + if (vtype(args[0]) != T_STR) return js_mkerr(js, "unlinkSync() path must be a string"); 733 733 734 734 size_t path_len; 735 735 char *path = js_getstr(js, args[0], &path_len); ··· 753 753 static jsval_t builtin_fs_unlink(struct js *js, jsval_t *args, int nargs) { 754 754 if (nargs < 1) return js_mkerr(js, "unlink() requires a path argument"); 755 755 756 756 - if (js_type(args[0]) != JS_STR) return js_mkerr(js, "unlink() path must be a string"); 756 756 + if (vtype(args[0]) != T_STR) return js_mkerr(js, "unlink() path must be a string"); 757 757 758 758 size_t path_len; 759 759 char *path = js_getstr(js, args[0], &path_len); ··· 786 786 static jsval_t builtin_fs_mkdirSync(struct js *js, jsval_t *args, int nargs) { 787 787 if (nargs < 1) return js_mkerr(js, "mkdirSync() requires a path argument"); 788 788 789 789 - if (js_type(args[0]) != JS_STR) return js_mkerr(js, "mkdirSync() path must be a string"); 789 789 + if (vtype(args[0]) != T_STR) return js_mkerr(js, "mkdirSync() path must be a string"); 790 790 791 791 size_t path_len; 792 792 char *path = js_getstr(js, args[0], &path_len); ··· 797 797 798 798 if (nargs < 2) goto do_mkdir; 799 799 800 800 - switch (js_type(args[1])) { 801 801 - case JS_NUM: 800 800 + switch (vtype(args[1])) { 801 801 + case T_NUM: 802 802 mode = (int)js_getnum(args[1]); 803 803 break; 804 804 - case JS_OBJ: { 804 804 + case T_OBJ: { 805 805 jsval_t opt = args[1]; 806 806 - recursive = js_type(js_get(js, opt, "recursive")) == JS_TRUE; 806 806 + recursive = js_get(js, opt, "recursive") == js_true; 807 807 jsval_t mode_val = js_get(js, opt, "mode"); 808 808 - if (js_type(mode_val) == JS_NUM) mode = (int)js_getnum(mode_val); 808 808 + if (vtype(mode_val) == T_NUM) mode = (int)js_getnum(mode_val); 809 809 break; 810 810 } 811 811 } ··· 838 838 static jsval_t builtin_fs_mkdir(struct js *js, jsval_t *args, int nargs) { 839 839 if (nargs < 1) return js_mkerr(js, "mkdir() requires a path argument"); 840 840 841 841 - if (js_type(args[0]) != JS_STR) return js_mkerr(js, "mkdir() path must be a string"); 841 841 + if (vtype(args[0]) != T_STR) return js_mkerr(js, "mkdir() path must be a string"); 842 842 843 843 size_t path_len; 844 844 char *path = js_getstr(js, args[0], &path_len); 845 845 if (!path) return js_mkerr(js, "Failed to get path string"); 846 846 847 847 int mode = 0755; 848 848 - if (nargs >= 2 && js_type(args[1]) == JS_NUM) { 848 848 + if (nargs >= 2 && vtype(args[1]) == T_NUM) { 849 849 mode = (int)js_getnum(args[1]); 850 850 } 851 851 ··· 876 876 static jsval_t builtin_fs_rmdirSync(struct js *js, jsval_t *args, int nargs) { 877 877 if (nargs < 1) return js_mkerr(js, "rmdirSync() requires a path argument"); 878 878 879 879 - if (js_type(args[0]) != JS_STR) return js_mkerr(js, "rmdirSync() path must be a string"); 879 879 + if (vtype(args[0]) != T_STR) return js_mkerr(js, "rmdirSync() path must be a string"); 880 880 881 881 size_t path_len; 882 882 char *path = js_getstr(js, args[0], &path_len); ··· 904 904 static jsval_t builtin_fs_rmdir(struct js *js, jsval_t *args, int nargs) { 905 905 if (nargs < 1) return js_mkerr(js, "rmdir() requires a path argument"); 906 906 907 907 - if (js_type(args[0]) != JS_STR) return js_mkerr(js, "rmdir() path must be a string"); 907 907 + if (vtype(args[0]) != T_STR) return js_mkerr(js, "rmdir() path must be a string"); 908 908 909 909 size_t path_len; 910 910 char *path = js_getstr(js, args[0], &path_len); ··· 938 938 jsval_t this = js_getthis(js); 939 939 jsval_t mode_val = js_get_slot(js, this, SLOT_DATA); 940 940 941 941 - if (js_type(mode_val) != JS_NUM) return js_mkfalse(); 941 941 + if (vtype(mode_val) != T_NUM) return js_mkfalse(); 942 942 mode_t mode = (mode_t)js_getnum(mode_val); 943 943 944 944 return S_ISREG(mode) ? js_mktrue() : js_mkfalse(); ··· 948 948 jsval_t this = js_getthis(js); 949 949 jsval_t mode_val = js_get_slot(js, this, SLOT_DATA); 950 950 951 951 - if (js_type(mode_val) != JS_NUM) return js_mkfalse(); 951 951 + if (vtype(mode_val) != T_NUM) return js_mkfalse(); 952 952 mode_t mode = (mode_t)js_getnum(mode_val); 953 953 954 954 return S_ISDIR(mode) ? js_mktrue() : js_mkfalse(); ··· 958 958 jsval_t this = js_getthis(js); 959 959 jsval_t mode_val = js_get_slot(js, this, SLOT_DATA); 960 960 961 961 - if (js_type(mode_val) != JS_NUM) return js_mkfalse(); 961 961 + if (vtype(mode_val) != T_NUM) return js_mkfalse(); 962 962 mode_t mode = (mode_t)js_getnum(mode_val); 963 963 964 964 return S_ISLNK(mode) ? js_mktrue() : js_mkfalse(); ··· 967 967 static jsval_t create_stats_object(struct js *js, struct stat *st) { 968 968 jsval_t stat_obj = js_mkobj(js); 969 969 jsval_t proto = js_get_ctor_proto(js, "Stats", 5); 970 970 - if (js_type(proto) == JS_OBJ) js_set_proto(js, stat_obj, proto); 970 970 + if (vtype(proto) == T_OBJ) js_set_proto(js, stat_obj, proto); 971 971 972 972 js_set_slot(js, stat_obj, SLOT_DATA, js_mknum((double)st->st_mode)); 973 973 js_set(js, stat_obj, "size", js_mknum((double)st->st_size)); ··· 1002 1002 static jsval_t builtin_fs_statSync(struct js *js, jsval_t *args, int nargs) { 1003 1003 if (nargs < 1) return js_mkerr(js, "statSync() requires a path argument"); 1004 1004 1005 1005 - if (js_type(args[0]) != JS_STR) return js_mkerr(js, "statSync() path must be a string"); 1005 1005 + if (vtype(args[0]) != T_STR) return js_mkerr(js, "statSync() path must be a string"); 1006 1006 1007 1007 size_t path_len; 1008 1008 char *path = js_getstr(js, args[0], &path_len); ··· 1027 1027 static jsval_t builtin_fs_stat(struct js *js, jsval_t *args, int nargs) { 1028 1028 if (nargs < 1) return js_mkerr(js, "stat() requires a path argument"); 1029 1029 1030 1030 - if (js_type(args[0]) != JS_STR) return js_mkerr(js, "stat() path must be a string"); 1030 1030 + if (vtype(args[0]) != T_STR) return js_mkerr(js, "stat() path must be a string"); 1031 1031 1032 1032 size_t path_len; 1033 1033 char *path = js_getstr(js, args[0], &path_len); ··· 1060 1060 static jsval_t builtin_fs_existsSync(struct js *js, jsval_t *args, int nargs) { 1061 1061 if (nargs < 1) return js_mkerr(js, "existsSync() requires a path argument"); 1062 1062 1063 1063 - if (js_type(args[0]) != JS_STR) return js_mkerr(js, "existsSync() path must be a string"); 1063 1063 + if (vtype(args[0]) != T_STR) return js_mkerr(js, "existsSync() path must be a string"); 1064 1064 1065 1065 size_t path_len; 1066 1066 char *path = js_getstr(js, args[0], &path_len); ··· 1079 1079 static jsval_t builtin_fs_exists(struct js *js, jsval_t *args, int nargs) { 1080 1080 if (nargs < 1) return js_mkerr(js, "exists() requires a path argument"); 1081 1081 1082 1082 - if (js_type(args[0]) != JS_STR) return js_mkerr(js, "exists() path must be a string"); 1082 1082 + if (vtype(args[0]) != T_STR) return js_mkerr(js, "exists() path must be a string"); 1083 1083 1084 1084 size_t path_len; 1085 1085 char *path = js_getstr(js, args[0], &path_len); ··· 1112 1112 static jsval_t builtin_fs_accessSync(struct js *js, jsval_t *args, int nargs) { 1113 1113 if (nargs < 1) return js_mkerr(js, "accessSync() requires a path argument"); 1114 1114 1115 1115 - if (js_type(args[0]) != JS_STR) return js_mkerr(js, "accessSync() path must be a string"); 1115 1115 + if (vtype(args[0]) != T_STR) return js_mkerr(js, "accessSync() path must be a string"); 1116 1116 1117 1117 size_t path_len; 1118 1118 char *path = js_getstr(js, args[0], &path_len); 1119 1119 if (!path) return js_mkerr(js, "Failed to get path string"); 1120 1120 1121 1121 int mode = F_OK; 1122 1122 - if (nargs >= 2 && js_type(args[1]) == JS_NUM) { 1122 1122 + if (nargs >= 2 && vtype(args[1]) == T_NUM) { 1123 1123 mode = (int)js_getnum(args[1]); 1124 1124 } 1125 1125 ··· 1140 1140 static jsval_t builtin_fs_access(struct js *js, jsval_t *args, int nargs) { 1141 1141 if (nargs < 1) return js_mkerr(js, "access() requires a path argument"); 1142 1142 1143 1143 - if (js_type(args[0]) != JS_STR) return js_mkerr(js, "access() path must be a string"); 1143 1143 + if (vtype(args[0]) != T_STR) return js_mkerr(js, "access() path must be a string"); 1144 1144 1145 1145 size_t path_len; 1146 1146 char *path = js_getstr(js, args[0], &path_len); 1147 1147 if (!path) return js_mkerr(js, "Failed to get path string"); 1148 1148 1149 1149 int mode = F_OK; 1150 1150 - if (nargs >= 2 && js_type(args[1]) == JS_NUM) { 1150 1150 + if (nargs >= 2 && vtype(args[1]) == T_NUM) { 1151 1151 mode = (int)js_getnum(args[1]); 1152 1152 } 1153 1153 ··· 1178 1178 static jsval_t builtin_fs_readdirSync(struct js *js, jsval_t *args, int nargs) { 1179 1179 if (nargs < 1) return js_mkerr(js, "readdirSync() requires a path argument"); 1180 1180 1181 1181 - if (js_type(args[0]) != JS_STR) return js_mkerr(js, "readdirSync() path must be a string"); 1181 1181 + if (vtype(args[0]) != T_STR) return js_mkerr(js, "readdirSync() path must be a string"); 1182 1182 1183 1183 size_t path_len; 1184 1184 char *path = js_getstr(js, args[0], &path_len); ··· 1212 1212 static jsval_t builtin_fs_readdir(struct js *js, jsval_t *args, int nargs) { 1213 1213 if (nargs < 1) return js_mkerr(js, "readdir() requires a path argument"); 1214 1214 1215 1215 - if (js_type(args[0]) != JS_STR) return js_mkerr(js, "readdir() path must be a string"); 1215 1215 + if (vtype(args[0]) != T_STR) return js_mkerr(js, "readdir() path must be a string"); 1216 1216 1217 1217 size_t path_len; 1218 1218 char *path = js_getstr(js, args[0], &path_len);

+7 -7

src/modules/io.c

reviewed

··· 280 280 const char *space = i == 0 ? "" : " "; 281 281 io_puts(space, stream); 282 282 283 283 - if (js_type(args[i]) == JS_STR) { 283 283 + if (vtype(args[i]) == T_STR) { 284 284 char *str = js_getstr(js, args[i], NULL); 285 285 io_print(str, stream); 286 286 } else { ··· 324 324 const char *space = i == 1 ? "" : " "; 325 325 io_puts(space, stderr); 326 326 327 327 - if (js_type(args[i]) == JS_STR) { 327 327 + if (vtype(args[i]) == T_STR) { 328 328 char *str = js_getstr(js, args[i], NULL); 329 329 io_print(str, stderr); 330 330 } else { ··· 341 341 342 342 static jsval_t js_console_trace(struct js *js, jsval_t *args, int nargs) { 343 343 fprintf(stderr, "Console Trace"); 344 344 - if (nargs > 0 && js_type(args[0]) == JS_STR) { 344 344 + if (nargs > 0 && vtype(args[0]) == T_STR) { 345 345 fprintf(stderr, ": "); 346 346 char *str = js_getstr(js, args[0], NULL); 347 347 fprintf(stderr, "%s", str); ··· 378 378 379 379 static jsval_t js_console_time(struct js *js, jsval_t *args, int nargs) { 380 380 const char *label = "default"; 381 381 - if (nargs > 0 && js_type(args[0]) == JS_STR) { 381 381 + if (nargs > 0 && vtype(args[0]) == T_STR) { 382 382 label = js_getstr(js, args[0], NULL); 383 383 } 384 384 ··· 400 400 401 401 static jsval_t js_console_timeEnd(struct js *js, jsval_t *args, int nargs) { 402 402 const char *label = "default"; 403 403 - if (nargs > 0 && js_type(args[0]) == JS_STR) { 403 403 + if (nargs > 0 && vtype(args[0]) == T_STR) { 404 404 label = js_getstr(js, args[0], NULL); 405 405 } 406 406 ··· 528 528 529 529 if (t == T_UNDEF) { fprintf(stream, "undefined"); return; } 530 530 if (t == T_NULL) { fprintf(stream, "null"); return; } 531 531 - if (t == T_BOOL) { fprintf(stream, js_getbool(val) ? "true" : "false"); return; } 531 531 + if (t == T_BOOL) { fprintf(stream, val == js_true ? "true" : "false"); return; } 532 532 if (t == T_NUM) { fprintf(stream, "%g", js_getnum(val)); return; } 533 533 if (t == T_ERR) { fprintf(stream, "[Error]"); return; } 534 534 ··· 632 632 jsval_t proto = js_get_proto(js, obj); 633 633 inspect_print_indent(stream, inner_depth); 634 634 fprintf(stream, "[[Prototype]]: "); 635 635 - if (js_type(proto) == JS_NULL) { 635 635 + if (vtype(proto) == T_NULL) { 636 636 fprintf(stream, "null\n"); 637 637 } else { 638 638 fprintf(stream, "\n");

+38 -37

src/modules/json.c

reviewed

··· 8 8 #include "errors.h" 9 9 #include "runtime.h" 10 10 #include "internal.h" 11 11 + 11 12 #include "modules/json.h" 12 13 #include "modules/symbol.h" 13 14 ··· 108 109 109 110 static int should_skip_prop(struct js *js, const char *key, size_t key_len, jsval_t value) { 110 111 if (is_internal_prop(key, (jsoff_t)key_len)) return 1; 111 111 - if (js_type(value) != JS_OBJ) return 0; 112 112 + if (vtype(value) != T_OBJ) return 0; 112 113 return vtype(js_get_slot(js, value, SLOT_CODE)) == T_CFUNC; 113 114 } 114 115 ··· 151 152 } 152 153 153 154 static int is_key_in_replacer_arr(struct js *js, json_cycle_ctx *ctx, const char *key, size_t key_len) { 154 154 - if (js_type(ctx->replacer_arr) != JS_OBJ) return 1; 155 155 + if (vtype(ctx->replacer_arr) != T_OBJ) return 1; 155 156 156 157 for (int i = 0; i < ctx->replacer_arr_len; i++) { 157 158 char idxstr[32]; 158 159 snprintf(idxstr, sizeof(idxstr), "%d", i); 159 160 jsval_t item = js_get(js, ctx->replacer_arr, idxstr); 160 160 - int type = js_type(item); 161 161 + int type = vtype(item); 161 162 162 162 - if (type == JS_STR) { 163 163 + if (type == T_STR) { 163 164 size_t item_len; 164 165 char *item_str = js_getstr(js, item, &item_len); 165 166 if (key_matches(item_str, item_len, key, key_len)) return 1; 166 166 - } else if (type == JS_NUM) { 167 167 + } else if (type == T_NUM) { 167 168 char numstr[32]; 168 169 snprintf(numstr, sizeof(numstr), "%.0f", js_getnum(item)); 169 170 if (key_matches(numstr, strlen(numstr), key, key_len)) return 1; ··· 175 176 static yyjson_mut_val *jsval_to_yyjson_with_key(struct js *js, yyjson_mut_doc *doc, const char *key, jsval_t val, json_cycle_ctx *ctx, int in_array); 176 177 177 178 static yyjson_mut_val *jsval_to_yyjson_impl(struct js *js, yyjson_mut_doc *doc, jsval_t val, json_cycle_ctx *ctx, int in_array) { 178 178 - int type = js_type(val); 179 179 + int type = vtype(val); 179 180 yyjson_mut_val *result = NULL; 180 181 181 181 - if (type == JS_OBJ) { 182 182 + if (type == T_OBJ) { 182 183 jsval_t toJSON = js_get(js, val, "toJSON"); 183 183 - if (js_type(toJSON) == JS_FUNC) { 184 184 + if (vtype(toJSON) == T_FUNC) { 184 185 jsval_t r = js_call(js, toJSON, &val, 1); 185 185 - if (js_type(r) == JS_ERR) { ctx->has_cycle = 1; return NULL; } 186 186 + if (vtype(r) == T_ERR) { ctx->has_cycle = 1; return NULL; } 186 187 return jsval_to_yyjson_impl(js, doc, r, ctx, in_array); 187 188 } 188 189 } 189 190 190 191 switch (type) { 191 191 - case JS_UNDEF: return in_array ? yyjson_mut_null(doc) : YYJSON_SKIP_VALUE; 192 192 - case JS_NULL: return yyjson_mut_null(doc); 193 193 - case JS_TRUE: return yyjson_mut_bool(doc, true); 194 194 - case JS_FALSE: return yyjson_mut_bool(doc, false); 195 195 - case JS_FUNC: return in_array ? yyjson_mut_null(doc) : YYJSON_SKIP_VALUE; 192 192 + case T_NULL: return yyjson_mut_null(doc); 193 193 + case T_BOOL: return yyjson_mut_bool(doc, val == js_true); 194 194 + 195 195 + case T_UNDEF: return in_array ? yyjson_mut_null(doc) : YYJSON_SKIP_VALUE; 196 196 + case T_FUNC: return in_array ? yyjson_mut_null(doc) : YYJSON_SKIP_VALUE; 196 197 197 197 - case JS_NUM: { 198 198 + case T_NUM: { 198 199 double num = js_getnum(val); 199 200 if (isnan(num) || isinf(num)) return yyjson_mut_null(doc); 200 201 if ( ··· 205 206 return yyjson_mut_real(doc, num); 206 207 } 207 208 208 208 - case JS_STR: { 209 209 + case T_STR: { 209 210 size_t len; 210 211 char *str = js_getstr(js, val, &len); 211 212 return yyjson_mut_strncpy(doc, str, len); 212 213 } 213 214 214 214 - case JS_OBJ: break; 215 215 + case T_OBJ: break; 215 216 default: return yyjson_mut_null(doc); 216 217 } 217 218 ··· 220 221 221 222 jsval_t length_val = js_get(js, val, "length"); 222 223 223 223 - if (js_type(length_val) == JS_NUM) { 224 224 + if (vtype(length_val) == T_NUM) { 224 225 yyjson_mut_val *arr = yyjson_mut_arr(doc); 225 226 int length = (int)js_getnum(length_val); 226 227 ··· 254 255 free(p->key); continue; 255 256 } 256 257 257 257 - int ptype = js_type(p->value); 258 258 - if (ptype == JS_UNDEF || ptype == JS_FUNC) { free(p->key); continue; } 258 258 + int ptype = vtype(p->value); 259 259 + if (ptype == T_UNDEF || ptype == T_FUNC) { free(p->key); continue; } 259 260 260 261 yyjson_mut_val *jval = jsval_to_yyjson_with_key(js, doc, p->key, p->value, ctx, 0); 261 262 if (ctx->has_cycle) { free_props(props, 0, i); ctx->holder = saved_holder; goto done; } ··· 275 276 } 276 277 277 278 static yyjson_mut_val *jsval_to_yyjson_with_key(struct js *js, yyjson_mut_doc *doc, const char *key, jsval_t val, json_cycle_ctx *ctx, int in_array) { 278 278 - if (js_type(ctx->replacer_func) != JS_FUNC) 279 279 + if (vtype(ctx->replacer_func) != T_FUNC) 279 280 return jsval_to_yyjson_impl(js, doc, val, ctx, in_array); 280 281 281 282 jsval_t key_str = js_mkstr(js, key, strlen(key)); 282 283 jsval_t call_args[2] = { key_str, val }; 283 284 jsval_t transformed = js_call(js, ctx->replacer_func, call_args, 2); 284 285 285 285 - if (js_type(transformed) == JS_ERR) { 286 286 + if (vtype(transformed) == T_ERR) { 286 287 ctx->has_cycle = 1; 287 288 return NULL; 288 289 } ··· 297 298 static jsval_t apply_reviver(struct js *js, jsval_t holder, const char *key, jsval_t reviver) { 298 299 jsval_t val = js_get(js, holder, key); 299 300 300 300 - if (js_type(val) == JS_OBJ) { 301 301 + if (vtype(val) == T_OBJ) { 301 302 jsval_t len_val = js_get(js, val, "length"); 302 302 - if (js_type(len_val) == JS_NUM) { 303 303 + if (vtype(len_val) == T_NUM) { 303 304 int length = (int)js_getnum(len_val); 304 305 for (int i = 0; i < length; i++) { 305 306 char idxstr[32]; 306 307 snprintf(idxstr, sizeof(idxstr), "%d", i); 307 308 jsval_t new_elem = apply_reviver(js, val, idxstr, reviver); 308 308 - if (js_type(new_elem) == JS_UNDEF) js_del(js, val, idxstr); 309 309 + if (vtype(new_elem) == T_UNDEF) js_del(js, val, idxstr); 309 310 else js_set(js, val, idxstr, new_elem); 310 311 } 311 312 } else { ··· 332 333 size_t klen; 333 334 char *kstr = js_getstr(js, key_str, &klen); 334 335 jsval_t new_val = apply_reviver(js, val, kstr, reviver); 335 335 - if (js_type(new_val) == JS_UNDEF) js_del(js, val, kstr); 336 336 + if (vtype(new_val) == T_UNDEF) js_del(js, val, kstr); 336 337 else js_set(js, val, kstr, new_val); 337 338 } 338 339 } ··· 346 347 347 348 jsval_t js_json_parse(struct js *js, jsval_t *args, int nargs) { 348 349 if (nargs < 1) return js_mkerr(js, "JSON.parse() requires at least 1 argument"); 349 349 - if (js_type(args[0]) != JS_STR) return js_mkerr(js, "JSON.parse() argument must be a string"); 350 350 + if (vtype(args[0]) != T_STR) return js_mkerr(js, "JSON.parse() argument must be a string"); 350 351 351 352 size_t len; 352 353 char *json_str = js_getstr(js, args[0], &len); ··· 357 358 jsval_t result = yyjson_to_jsval(js, yyjson_doc_get_root(doc)); 358 359 yyjson_doc_free(doc); 359 360 360 360 - if (nargs >= 2 && js_type(args[1]) == JS_FUNC) { 361 361 + if (nargs >= 2 && vtype(args[1]) == T_FUNC) { 361 362 jsval_t reviver = args[1]; 362 363 jsval_t root = js_mkobj(js); 363 364 js_set(js, root, "", result); ··· 370 371 static yyjson_write_flag get_write_flags(jsval_t *args, int nargs) { 371 372 if (nargs < 3) return 0; 372 373 373 373 - int type = js_type(args[2]); 374 374 - if (type == JS_UNDEF || type == JS_NULL) return 0; 375 375 - if (type != JS_NUM) return YYJSON_WRITE_PRETTY; 374 374 + int type = vtype(args[2]); 375 375 + if (type == T_UNDEF || type == T_NULL) return 0; 376 376 + if (type != T_NUM) return YYJSON_WRITE_PRETTY; 376 377 377 378 int indent = (int)js_getnum(args[2]); 378 379 if (indent <= 0) return 0; ··· 390 391 391 392 if (nargs < 1) return js_mkerr(js, "JSON.stringify() requires at least 1 argument"); 392 393 393 393 - int top_type = js_type(args[0]); 394 394 - if (top_type == JS_UNDEF || top_type == JS_FUNC || top_type == JS_SYMBOL) 394 394 + int top_type = vtype(args[0]); 395 395 + if (top_type == T_UNDEF || top_type == T_FUNC || top_type == T_SYMBOL) 395 396 return js_mkundef(); 396 397 397 398 ctx.js = js; ··· 402 403 403 404 if (nargs >= 2) { 404 405 jsval_t replacer = args[1]; 405 405 - int replacer_type = js_type(replacer); 406 406 + int replacer_type = vtype(replacer); 406 407 407 407 - if (replacer_type == JS_FUNC) { 408 408 + if (replacer_type == T_FUNC) { 408 409 ctx.replacer_func = replacer; 409 409 - } else if (replacer_type == JS_OBJ) { 410 410 + } else if (replacer_type == T_OBJ) { 410 411 jsval_t len_val = js_get(js, replacer, "length"); 411 411 - if (js_type(len_val) == JS_NUM) { 412 412 + if (vtype(len_val) == T_NUM) { 412 413 ctx.replacer_arr = replacer; 413 414 ctx.replacer_arr_len = (int)js_getnum(len_val); 414 415 }

+2 -1

src/modules/localstorage.c

reviewed

··· 8 8 #include "errors.h" 9 9 #include "arena.h" 10 10 #include "runtime.h" 11 11 + #include "internal.h" 11 12 12 13 #include "modules/symbol.h" 13 14 #include "modules/localstorage.h" ··· 221 222 return js_mkerr(js, "Failed to execute 'key' on 'Storage': 1 argument required"); 222 223 } 223 224 224 224 - if (js_type(args[0]) != JS_NUM) { 225 225 + if (vtype(args[0]) != T_NUM) { 225 226 return js_mknull(); 226 227 } 227 228

+10 -10

src/modules/navigator.c

reviewed

··· 15 15 #include "errors.h" 16 16 #include "config.h" 17 17 #include "runtime.h" 18 18 + #include "internal.h" 18 19 #include "modules/navigator.h" 19 20 #include "modules/symbol.h" 20 21 ··· 159 160 160 161 jsval_t result = js_call(js, callback, &lock_obj, 1); 161 162 162 162 - if (js_type(result) == JS_ERR) { 163 163 + if (vtype(result) == T_ERR) { 163 164 release_lock(name); 164 165 js_reject_promise(js, outer_promise, result); 165 166 process_pending_requests(js); 166 167 return; 167 168 } 168 169 169 169 - if (js_type(result) == JS_PROMISE) { 170 170 + if (vtype(result) == T_PROMISE) { 170 171 jsval_t then_fn = js_get(js, result, "then"); 171 172 172 172 - if (js_type(then_fn) == JS_FUNC) { 173 173 + if (vtype(then_fn) == T_FUNC) { 173 174 jsval_t name_str = js_mkstr(js, name, strlen(name)); 174 175 175 176 jsval_t on_resolve = js_mkfun(lock_then_handler); ··· 247 248 options = args[1]; 248 249 callback = args[2]; 249 250 250 250 - if (js_type(options) == JS_OBJ) { 251 251 + if (vtype(options) == T_OBJ) { 251 252 jsval_t mode_val = js_get(js, options, "mode"); 252 252 - if (js_type(mode_val) == JS_STR) { 253 253 + if (vtype(mode_val) == T_STR) { 253 254 size_t mode_len; 254 255 char *mode_str = js_getstr(js, mode_val, &mode_len); 255 256 if (mode_str && strcmp(mode_str, "shared") == 0) mode = LOCK_MODE_SHARED; 256 257 } 257 258 258 258 - jsval_t if_avail_val = js_get(js, options, "ifAvailable"); 259 259 - if (js_type(if_avail_val) == JS_TRUE) if_available = true; 259 259 + if (js_get(js, options, "ifAvailable") == js_true) if_available = true; 260 260 } 261 261 } 262 262 263 263 - if (js_type(callback) != JS_FUNC) { 263 263 + if (vtype(callback) != T_FUNC) { 264 264 return js_mkerr_typed(js, JS_ERR_TYPE, "Callback must be a function"); 265 265 } 266 266 ··· 270 270 jsval_t null_val = js_mknull(); 271 271 jsval_t result = js_call(js, callback, &null_val, 1); 272 272 273 273 - if (js_type(result) == JS_PROMISE) { 273 273 + if (vtype(result) == T_PROMISE) { 274 274 jsval_t then_fn = js_get(js, result, "then"); 275 275 - if (js_type(then_fn) == JS_FUNC) { 275 275 + if (vtype(then_fn) == T_FUNC) { 276 276 jsval_t on_resolve = js_mkfun(lock_then_handler); 277 277 js_set(js, on_resolve, "_lockName", js_mkstr(js, "", 0)); 278 278 js_set(js, on_resolve, "_outerPromise", promise);

+36 -36

src/modules/observable.c

reviewed

··· 16 16 17 17 static bool subscription_closed(struct js *js, jsval_t subscription) { 18 18 jsval_t observer = js_get_slot(js, subscription, SLOT_SUBSCRIPTION_OBSERVER); 19 19 - return js_type(observer) == JS_UNDEF; 19 19 + return vtype(observer) == T_UNDEF; 20 20 } 21 21 22 22 static void cleanup_subscription(struct js *js, jsval_t subscription) { 23 23 jsval_t cleanup = js_get_slot(js, subscription, SLOT_SUBSCRIPTION_CLEANUP); 24 24 - if (js_type(cleanup) == JS_UNDEF) return; 24 24 + if (vtype(cleanup) == T_UNDEF) return; 25 25 if (!is_callable(cleanup)) return; 26 26 27 27 js_set_slot(js, subscription, SLOT_SUBSCRIPTION_CLEANUP, js_mkundef()); 28 28 jsval_t result = js_call(js, cleanup, NULL, 0); 29 29 30 30 - if (js_type(result) == JS_ERR) fprintf(stderr, "Error in subscription cleanup: %s\n", js_str(js, result)); 30 30 + if (vtype(result) == T_ERR) fprintf(stderr, "Error in subscription cleanup: %s\n", js_str(js, result)); 31 31 } 32 32 33 33 static jsval_t create_subscription(struct js *js, jsval_t observer) { ··· 42 42 (void)args; (void)nargs; 43 43 jsval_t subscription = js_getthis(js); 44 44 45 45 - if (js_type(subscription) != JS_OBJ) return js_mkerr_typed(js, JS_ERR_TYPE, "Subscription.closed getter called on non-object"); 45 45 + if (vtype(subscription) != T_OBJ) return js_mkerr_typed(js, JS_ERR_TYPE, "Subscription.closed getter called on non-object"); 46 46 return subscription_closed(js, subscription) ? js_mktrue() : js_mkfalse(); 47 47 } 48 48 ··· 50 50 (void)args; (void)nargs; 51 51 jsval_t subscription = js_getthis(js); 52 52 53 53 - if (js_type(subscription) != JS_OBJ) { 53 53 + if (vtype(subscription) != T_OBJ) { 54 54 return js_mkerr_typed(js, JS_ERR_TYPE, "Subscription.unsubscribe called on non-object"); 55 55 } 56 56 ··· 72 72 (void)args; (void)nargs; 73 73 jsval_t O = js_getthis(js); 74 74 75 75 - if (js_type(O) != JS_OBJ) { 75 75 + if (vtype(O) != T_OBJ) { 76 76 return js_mkerr_typed(js, JS_ERR_TYPE, "SubscriptionObserver.closed getter called on non-object"); 77 77 } 78 78 79 79 jsval_t subscription = js_get_slot(js, O, SLOT_DATA); 80 80 - if (js_type(subscription) != JS_OBJ) { 80 80 + if (vtype(subscription) != T_OBJ) { 81 81 return js_mkerr_typed(js, JS_ERR_TYPE, "Invalid SubscriptionObserver"); 82 82 } 83 83 ··· 87 87 static jsval_t js_subobs_next(struct js *js, jsval_t *args, int nargs) { 88 88 jsval_t O = js_getthis(js); 89 89 90 90 - if (js_type(O) != JS_OBJ) { 90 90 + if (vtype(O) != T_OBJ) { 91 91 return js_mkerr_typed(js, JS_ERR_TYPE, "SubscriptionObserver.next called on non-object"); 92 92 } 93 93 94 94 jsval_t subscription = js_get_slot(js, O, SLOT_DATA); 95 95 - if (js_type(subscription) != JS_OBJ) { 95 95 + if (vtype(subscription) != T_OBJ) { 96 96 return js_mkerr_typed(js, JS_ERR_TYPE, "Invalid SubscriptionObserver"); 97 97 } 98 98 99 99 if (subscription_closed(js, subscription)) return js_mkundef(); 100 100 101 101 jsval_t observer = js_get_slot(js, subscription, SLOT_SUBSCRIPTION_OBSERVER); 102 102 - if (js_type(observer) != JS_OBJ) return js_mkundef(); 102 102 + if (vtype(observer) != T_OBJ) return js_mkundef(); 103 103 104 104 jsval_t nextMethod = js_get(js, observer, "next"); 105 105 if (is_callable(nextMethod)) { 106 106 jsval_t value = (nargs > 0) ? args[0] : js_mkundef(); 107 107 jsval_t call_args[1] = {value}; 108 108 jsval_t result = js_call_with_this(js, nextMethod, observer, call_args, 1); 109 109 - if (js_type(result) == JS_ERR) fprintf(stderr, "Error in observer.next: %s\n", js_str(js, result)); 109 109 + if (vtype(result) == T_ERR) fprintf(stderr, "Error in observer.next: %s\n", js_str(js, result)); 110 110 } 111 111 112 112 return js_mkundef(); ··· 115 115 static jsval_t js_subobs_error(struct js *js, jsval_t *args, int nargs) { 116 116 jsval_t O = js_getthis(js); 117 117 118 118 - if (js_type(O) != JS_OBJ) { 118 118 + if (vtype(O) != T_OBJ) { 119 119 return js_mkerr_typed(js, JS_ERR_TYPE, "SubscriptionObserver.error called on non-object"); 120 120 } 121 121 122 122 jsval_t subscription = js_get_slot(js, O, SLOT_DATA); 123 123 - if (js_type(subscription) != JS_OBJ) { 123 123 + if (vtype(subscription) != T_OBJ) { 124 124 return js_mkerr_typed(js, JS_ERR_TYPE, "Invalid SubscriptionObserver"); 125 125 } 126 126 ··· 129 129 jsval_t observer = js_get_slot(js, subscription, SLOT_SUBSCRIPTION_OBSERVER); 130 130 js_set_slot(js, subscription, SLOT_SUBSCRIPTION_OBSERVER, js_mkundef()); 131 131 132 132 - if (js_type(observer) == JS_OBJ) { 132 132 + if (vtype(observer) == T_OBJ) { 133 133 jsval_t errorMethod = js_get(js, observer, "error"); 134 134 if (is_callable(errorMethod)) { 135 135 jsval_t exception = (nargs > 0) ? args[0] : js_mkundef(); 136 136 jsval_t call_args[1] = {exception}; 137 137 jsval_t result = js_call_with_this(js, errorMethod, observer, call_args, 1); 138 138 - if (js_type(result) == JS_ERR) fprintf(stderr, "Error in observer.error: %s\n", js_str(js, result)); 138 138 + if (vtype(result) == T_ERR) fprintf(stderr, "Error in observer.error: %s\n", js_str(js, result)); 139 139 } 140 140 } 141 141 ··· 147 147 (void)args; (void)nargs; 148 148 jsval_t O = js_getthis(js); 149 149 150 150 - if (js_type(O) != JS_OBJ) { 150 150 + if (vtype(O) != T_OBJ) { 151 151 return js_mkerr_typed(js, JS_ERR_TYPE, "SubscriptionObserver.complete called on non-object"); 152 152 } 153 153 154 154 jsval_t subscription = js_get_slot(js, O, SLOT_DATA); 155 155 - if (js_type(subscription) != JS_OBJ) { 155 155 + if (vtype(subscription) != T_OBJ) { 156 156 return js_mkerr_typed(js, JS_ERR_TYPE, "Invalid SubscriptionObserver"); 157 157 } 158 158 ··· 161 161 jsval_t observer = js_get_slot(js, subscription, SLOT_SUBSCRIPTION_OBSERVER); 162 162 js_set_slot(js, subscription, SLOT_SUBSCRIPTION_OBSERVER, js_mkundef()); 163 163 164 164 - if (js_type(observer) == JS_OBJ) { 164 164 + if (vtype(observer) == T_OBJ) { 165 165 jsval_t completeMethod = js_get(js, observer, "complete"); 166 166 if (is_callable(completeMethod)) { 167 167 jsval_t result = js_call_with_this(js, completeMethod, observer, NULL, 0); 168 168 - if (js_type(result) == JS_ERR) fprintf(stderr, "Error in observer.complete: %s\n", js_str(js, result)); 168 168 + if (vtype(result) == T_ERR) fprintf(stderr, "Error in observer.complete: %s\n", js_str(js, result)); 169 169 } 170 170 } 171 171 ··· 193 193 jsval_t F = js_getcurrentfunc(js); 194 194 jsval_t subscription = js_get_slot(js, F, SLOT_DATA); 195 195 196 196 - if (js_type(subscription) != JS_OBJ) return js_mkundef(); 196 196 + if (vtype(subscription) != T_OBJ) return js_mkundef(); 197 197 198 198 jsval_t unsubscribe = js_get(js, subscription, "unsubscribe"); 199 199 if (is_callable(unsubscribe)) { ··· 207 207 jsval_t call_args[1] = {observer}; 208 208 jsval_t subscriberResult = js_call(js, subscriber, call_args, 1); 209 209 210 210 - if (js_type(subscriberResult) == JS_ERR) return subscriberResult; 211 211 - if (js_type(subscriberResult) == JS_NULL || js_type(subscriberResult) == JS_UNDEF) return js_mkundef(); 210 210 + if (vtype(subscriberResult) == T_ERR) return subscriberResult; 211 211 + if (vtype(subscriberResult) == T_NULL || vtype(subscriberResult) == T_UNDEF) return js_mkundef(); 212 212 if (is_callable(subscriberResult)) return subscriberResult; 213 213 214 214 - if (js_type(subscriberResult) == JS_OBJ) { 214 214 + if (vtype(subscriberResult) == T_OBJ) { 215 215 jsval_t result = js_get(js, subscriberResult, "unsubscribe"); 216 216 - if (js_type(result) == JS_UNDEF) { 216 216 + if (vtype(result) == T_UNDEF) { 217 217 return js_mkerr_typed(js, JS_ERR_TYPE, "Subscriber return value must have an unsubscribe method"); 218 218 } 219 219 ··· 229 229 static jsval_t js_observable_subscribe(struct js *js, jsval_t *args, int nargs) { 230 230 jsval_t O = js_getthis(js); 231 231 232 232 - if (js_type(O) != JS_OBJ) { 232 232 + if (vtype(O) != T_OBJ) { 233 233 return js_mkerr_typed(js, JS_ERR_TYPE, "Observable.prototype.subscribe called on non-object"); 234 234 } 235 235 ··· 249 249 js_set(js, observer, "next", nextCallback); 250 250 js_set(js, observer, "error", errorCallback); 251 251 js_set(js, observer, "complete", completeCallback); 252 252 - } else if (nargs > 0 && js_type(args[0]) == JS_OBJ) { 252 252 + } else if (nargs > 0 && vtype(args[0]) == T_OBJ) { 253 253 observer = args[0]; 254 254 } else observer = js_mkobj(js); 255 255 ··· 260 260 if (is_callable(start)) { 261 261 jsval_t start_args[1] = {subscription}; 262 262 jsval_t result = js_call_with_this(js, start, observer, start_args, 1); 263 263 - if (js_type(result) == JS_ERR) { 263 263 + if (vtype(result) == T_ERR) { 264 264 fprintf(stderr, "Error in observer.start: %s\n", js_str(js, result)); 265 265 } 266 266 if (subscription_closed(js, subscription)) return subscription; ··· 269 269 jsval_t subscriptionObserver = create_subscription_observer(js, subscription); 270 270 jsval_t subscriberResult = execute_subscriber(js, subscriber, subscriptionObserver); 271 271 272 272 - if (js_type(subscriberResult) == JS_ERR) { 272 272 + if (vtype(subscriberResult) == T_ERR) { 273 273 jsval_t thrown_error = js->thrown_value; 274 274 js->thrown_value = js_mkundef(); 275 275 js->flags &= ~F_THROW; ··· 318 318 jsval_t subscription = js_get_slot(js, observer, SLOT_DATA); 319 319 320 320 jsval_t length_val = js_get(js, items, "length"); 321 321 - int length = (js_type(length_val) == JS_NUM) ? (int)js_getnum(length_val) : 0; 321 321 + int length = (vtype(length_val) == T_NUM) ? (int)js_getnum(length_val) : 0; 322 322 323 323 for (int i = 0; i < length; i++) { 324 324 char key[16]; ··· 331 331 js_call_with_this(js, next, observer, next_args, 1); 332 332 } 333 333 334 334 - if (js_type(subscription) == JS_OBJ && subscription_closed(js, subscription)) return js_mkundef(); 334 334 + if (vtype(subscription) == T_OBJ && subscription_closed(js, subscription)) return js_mkundef(); 335 335 } 336 336 337 337 jsval_t complete = js_get(js, observer, "complete"); ··· 354 354 jsval_t F = js_getcurrentfunc(js); 355 355 356 356 jsval_t observable = js_get_slot(js, F, SLOT_DATA); 357 357 - if (js_type(observable) != JS_OBJ) return js_mkundef(); 357 357 + if (vtype(observable) != T_OBJ) return js_mkundef(); 358 358 359 359 jsval_t subscribe = js_get(js, observable, "subscribe"); 360 360 if (is_callable(subscribe)) { ··· 381 381 } 382 382 383 383 jsval_t iterator = js_call_with_this(js, iteratorMethod, iterable, NULL, 0); 384 384 - if (js_type(iterator) != JS_OBJ) { 384 384 + if (vtype(iterator) != T_OBJ) { 385 385 return js_mkerr_typed(js, JS_ERR_TYPE, "Iterator must return an object"); 386 386 } 387 387 ··· 392 392 393 393 while (true) { 394 394 jsval_t next = js_call_with_this(js, nextMethod, iterator, NULL, 0); 395 395 - if (js_type(next) == JS_ERR) return next; 395 395 + if (vtype(next) == T_ERR) return next; 396 396 397 397 jsval_t done = js_get(js, next, "done"); 398 398 if (js_truthy(js, done)) { ··· 408 408 js_call_with_this(js, obs_next, observer, next_args, 1); 409 409 } 410 410 411 411 - if (js_type(subscription) == JS_OBJ && subscription_closed(js, subscription)) { 411 411 + if (vtype(subscription) == T_OBJ && subscription_closed(js, subscription)) { 412 412 jsval_t returnMethod = js_get(js, iterator, "return"); 413 413 if (is_callable(returnMethod)) js_call_with_this(js, returnMethod, iterator, NULL, 0); 414 414 return js_mkundef(); ··· 420 420 if (nargs < 1) return js_mkerr_typed(js, JS_ERR_TYPE, "Observable.from requires an argument"); 421 421 jsval_t x = args[0]; 422 422 423 423 - if (js_type(x) == JS_NULL || js_type(x) == JS_UNDEF) { 423 423 + if (vtype(x) == T_NULL || vtype(x) == T_UNDEF) { 424 424 return js_mkerr_typed(js, JS_ERR_TYPE, "Cannot convert null or undefined to observable"); 425 425 } 426 426 ··· 429 429 if (is_callable(observableMethod)) { 430 430 jsval_t observable = js_call_with_this(js, observableMethod, x, NULL, 0); 431 431 432 432 - if (js_type(observable) != JS_OBJ) { 432 432 + if (vtype(observable) != T_OBJ) { 433 433 return js_mkerr_typed(js, JS_ERR_TYPE, "@@observable must return an object"); 434 434 } 435 435

+9 -8

src/modules/os.c

reviewed

··· 35 35 36 36 #include "ant.h" 37 37 #include "errors.h" 38 38 + #include "internal.h" 38 39 #include "modules/symbol.h" 39 40 40 41 #ifdef _WIN32 ··· 522 523 523 524 for (pCurrAddresses = pAddresses; pCurrAddresses; pCurrAddresses = pCurrAddresses->Next) { 524 525 jsval_t iface_arr = js_get(js, result, pCurrAddresses->AdapterName); 525 525 - if (js_type(iface_arr) != JS_OBJ) { 526 526 + if (vtype(iface_arr) != T_OBJ) { 526 527 iface_arr = js_mkarr(js); 527 528 js_set(js, result, pCurrAddresses->AdapterName, iface_arr); 528 529 } ··· 700 701 format_mac_address(mac_str, sizeof(mac_str), mac_bytes); 701 702 702 703 jsval_t iface_arr = js_get(js, result, name); 703 703 - if (js_type(iface_arr) != JS_OBJ) return; 704 704 + if (vtype(iface_arr) != T_OBJ) return; 704 705 705 706 jsval_t len_val = js_get(js, iface_arr, "length"); 706 706 - int len = (js_type(len_val) == JS_NUM) ? (int)js_getnum(len_val) : 0; 707 707 + int len = (vtype(len_val) == T_NUM) ? (int)js_getnum(len_val) : 0; 707 708 708 709 for (int i = 0; i < len; i++) { 709 710 char idx[16]; 710 711 snprintf(idx, sizeof(idx), "%d", i); 711 712 jsval_t entry = js_get(js, iface_arr, idx); 712 712 - if (js_type(entry) == JS_OBJ) 713 713 + if (vtype(entry) == T_OBJ) 713 714 js_set(js, entry, "mac", js_mkstr(js, mac_str, strlen(mac_str))); 714 715 } 715 716 } ··· 728 729 if (family != AF_INET && family != AF_INET6) continue; 729 730 730 731 jsval_t iface_arr = js_get(js, result, ifa->ifa_name); 731 731 - if (js_type(iface_arr) != JS_OBJ) { 732 732 + if (vtype(iface_arr) != T_OBJ) { 732 733 iface_arr = js_mkarr(js); 733 734 js_set(js, result, ifa->ifa_name, iface_arr); 734 735 } ··· 779 780 780 781 static jsval_t os_getPriority(struct js *js, jsval_t *args, int nargs) { 781 782 int pid = 0; 782 782 - if (nargs > 0 && js_type(args[0]) == JS_NUM) { 783 783 + if (nargs > 0 && vtype(args[0]) == T_NUM) { 783 784 pid = (int)js_getnum(args[0]); 784 785 } 785 786 ··· 796 797 int priority = 0; 797 798 798 799 if (nargs == 1) { 799 799 - if (js_type(args[0]) != JS_NUM) { 800 800 + if (vtype(args[0]) != T_NUM) { 800 801 return js_mkerr_typed(js, JS_ERR_TYPE, "priority must be a number"); 801 802 } 802 803 priority = (int)js_getnum(args[0]); 803 804 } else if (nargs >= 2) { 804 804 - if (js_type(args[0]) != JS_NUM || js_type(args[1]) != JS_NUM) { 805 805 + if (vtype(args[0]) != T_NUM || vtype(args[1]) != T_NUM) { 805 806 return js_mkerr_typed(js, JS_ERR_TYPE, "pid and priority must be numbers"); 806 807 } 807 808 pid = (int)js_getnum(args[0]);

+18 -17

src/modules/path.c

reviewed

··· 6 6 7 7 #include "ant.h" 8 8 #include "errors.h" 9 9 + #include "internal.h" 9 10 #include "modules/symbol.h" 10 11 11 12 #ifndef PATH_MAX ··· 39 40 40 41 static jsval_t builtin_path_basename(struct js *js, jsval_t *args, int nargs) { 41 42 if (nargs < 1) return js_mkerr(js, "basename() requires a path argument"); 42 42 - if (js_type(args[0]) != JS_STR) return js_mkerr(js, "basename() path must be a string"); 43 43 + if (vtype(args[0]) != T_STR) return js_mkerr(js, "basename() path must be a string"); 43 44 44 45 size_t path_len; 45 46 char *path = js_getstr(js, args[0], &path_len); ··· 49 50 if (!path_copy) return js_mkerr(js, "Out of memory"); 50 51 char *base = basename(path_copy); 51 52 52 52 - if (nargs >= 2 && js_type(args[1]) == JS_STR) { 53 53 + if (nargs >= 2 && vtype(args[1]) == T_STR) { 53 54 size_t ext_len; 54 55 char *ext = js_getstr(js, args[1], &ext_len); 55 56 ··· 67 68 // path.dirname(path) 68 69 static jsval_t builtin_path_dirname(struct js *js, jsval_t *args, int nargs) { 69 70 if (nargs < 1) return js_mkerr(js, "dirname() requires a path argument"); 70 70 - if (js_type(args[0]) != JS_STR) return js_mkerr(js, "dirname() path must be a string"); 71 71 + if (vtype(args[0]) != T_STR) return js_mkerr(js, "dirname() path must be a string"); 71 72 72 73 size_t path_len; 73 74 char *path = js_getstr(js, args[0], &path_len); ··· 85 86 // path.extname(path) 86 87 static jsval_t builtin_path_extname(struct js *js, jsval_t *args, int nargs) { 87 88 if (nargs < 1) return js_mkerr(js, "extname() requires a path argument"); 88 88 - if (js_type(args[0]) != JS_STR) return js_mkerr(js, "extname() path must be a string"); 89 89 + if (vtype(args[0]) != T_STR) return js_mkerr(js, "extname() path must be a string"); 89 90 90 91 size_t path_len; 91 92 char *path = js_getstr(js, args[0], &path_len); ··· 193 194 // path.normalize(path) 194 195 static jsval_t builtin_path_normalize(struct js *js, jsval_t *args, int nargs) { 195 196 if (nargs < 1) return js_mkerr(js, "normalize() requires a path argument"); 196 196 - if (js_type(args[0]) != JS_STR) return js_mkerr(js, "normalize() path must be a string"); 197 197 + if (vtype(args[0]) != T_STR) return js_mkerr(js, "normalize() path must be a string"); 197 198 198 199 size_t path_len; 199 200 char *path = js_getstr(js, args[0], &path_len); ··· 224 225 int valid_segments = 0; 225 226 226 227 for (int i = 0; i < nargs; i++) { 227 227 - if (js_type(args[i]) == JS_STR) { 228 228 + if (vtype(args[i]) == T_STR) { 228 229 segments[valid_segments] = js_getstr(js, args[i], &lengths[valid_segments]); 229 230 if (segments[valid_segments] && lengths[valid_segments] > 0) { 230 231 total_len += lengths[valid_segments] + 1; // +1 for separator ··· 289 290 if (!result) return js_mkerr(js, "Out of memory"); 290 291 291 292 for (int i = 0; i < nargs; i++) { 292 292 - if (js_type(args[i]) != JS_STR) continue; 293 293 + if (vtype(args[i]) != T_STR) continue; 293 294 294 295 size_t seg_len; 295 296 char *segment = js_getstr(js, args[i], &seg_len); ··· 322 323 // path.relative(from, to) 323 324 static jsval_t builtin_path_relative(struct js *js, jsval_t *args, int nargs) { 324 325 if (nargs < 2) return js_mkerr(js, "relative() requires from and to arguments"); 325 325 - if (js_type(args[0]) != JS_STR) return js_mkerr(js, "relative() from must be a string"); 326 326 - if (js_type(args[1]) != JS_STR) return js_mkerr(js, "relative() to must be a string"); 326 326 + if (vtype(args[0]) != T_STR) return js_mkerr(js, "relative() from must be a string"); 327 327 + if (vtype(args[1]) != T_STR) return js_mkerr(js, "relative() to must be a string"); 327 328 328 329 size_t from_len, to_len; 329 330 char *from = js_getstr(js, args[0], &from_len); ··· 338 339 // path.isAbsolute(path) 339 340 static jsval_t builtin_path_isAbsolute(struct js *js, jsval_t *args, int nargs) { 340 341 if (nargs < 1) return js_mkerr(js, "isAbsolute() requires a path argument"); 341 341 - if (js_type(args[0]) != JS_STR) return js_mkerr(js, "isAbsolute() path must be a string"); 342 342 + if (vtype(args[0]) != T_STR) return js_mkerr(js, "isAbsolute() path must be a string"); 342 343 343 344 size_t path_len; 344 345 char *path = js_getstr(js, args[0], &path_len); ··· 356 357 // path.parse(path) 357 358 static jsval_t builtin_path_parse(struct js *js, jsval_t *args, int nargs) { 358 359 if (nargs < 1) return js_mkerr(js, "parse() requires a path argument"); 359 359 - if (js_type(args[0]) != JS_STR) return js_mkerr(js, "parse() path must be a string"); 360 360 + if (vtype(args[0]) != T_STR) return js_mkerr(js, "parse() path must be a string"); 360 361 361 362 size_t path_len; 362 363 char *path = js_getstr(js, args[0], &path_len); ··· 398 399 // path.format(pathObject) 399 400 static jsval_t builtin_path_format(struct js *js, jsval_t *args, int nargs) { 400 401 if (nargs < 1) return js_mkerr(js, "format() requires a path object argument"); 401 401 - if (js_type(args[0]) != JS_OBJ) return js_mkerr(js, "format() argument must be an object"); 402 402 + if (vtype(args[0]) != T_OBJ) return js_mkerr(js, "format() argument must be an object"); 402 403 403 404 jsval_t obj = args[0]; 404 405 ··· 411 412 char result[PATH_MAX] = {0}; 412 413 size_t pos = 0; 413 414 414 414 - if (js_type(dir_val) == JS_STR) { 415 415 + if (vtype(dir_val) == T_STR) { 415 416 size_t len; 416 417 char *str = js_getstr(js, dir_val, &len); 417 418 if (str && len > 0 && pos + len < PATH_MAX) { ··· 421 422 result[pos++] = PATH_SEP; 422 423 } 423 424 } 424 424 - } else if (js_type(root_val) == JS_STR) { 425 425 + } else if (vtype(root_val) == T_STR) { 425 426 size_t len; 426 427 char *str = js_getstr(js, root_val, &len); 427 428 if (str && len > 0 && pos + len < PATH_MAX) { ··· 430 431 } 431 432 } 432 433 433 433 - if (js_type(base_val) == JS_STR) { 434 434 + if (vtype(base_val) == T_STR) { 434 435 size_t len; 435 436 char *str = js_getstr(js, base_val, &len); 436 437 if (str && len > 0 && pos + len < PATH_MAX) { ··· 438 439 pos += len; 439 440 } 440 441 } else { 441 441 - if (js_type(name_val) == JS_STR) { 442 442 + if (vtype(name_val) == T_STR) { 442 443 size_t len; 443 444 char *str = js_getstr(js, name_val, &len); 444 445 if (str && len > 0 && pos + len < PATH_MAX) { ··· 446 447 pos += len; 447 448 } 448 449 } 449 449 - if (js_type(ext_val) == JS_STR) { 450 450 + if (vtype(ext_val) == T_STR) { 450 451 size_t len; 451 452 char *str = js_getstr(js, ext_val, &len); 452 453 if (str && len > 0 && pos + len < PATH_MAX) {

+32 -32

src/modules/process.c

reviewed

··· 414 414 if (!rt->js) return; 415 415 416 416 jsval_t process_obj = js_get(rt->js, js_glob(rt->js), "process"); 417 417 - if (js_type(process_obj) != JS_OBJ) return; 417 417 + if (vtype(process_obj) != T_OBJ) return; 418 418 419 419 jsval_t stdout_obj = js_get(rt->js, process_obj, "stdout"); 420 420 - if (js_type(stdout_obj) != JS_OBJ) return; 420 420 + if (vtype(stdout_obj) != T_OBJ) return; 421 421 422 422 int rows = 0, cols = 0; 423 423 get_tty_size(STDOUT_FILENO, &rows, &cols); ··· 464 464 if (nargs < 2) return this_obj; 465 465 466 466 char *event = js_getstr(js, args[0], NULL); 467 467 - if (!event || js_type(args[1]) != JS_FUNC) return this_obj; 467 467 + if (!event || vtype(args[1]) != T_FUNC) return this_obj; 468 468 469 469 ProcessEventType *evt = find_or_create_stdin_event(event); 470 470 if (!ensure_listener_capacity(evt)) return this_obj; ··· 516 516 if (nargs < 2) return this_obj; 517 517 518 518 char *event = js_getstr(js, args[0], NULL); 519 519 - if (!event || js_type(args[1]) != JS_FUNC) return this_obj; 519 519 + if (!event || vtype(args[1]) != T_FUNC) return this_obj; 520 520 521 521 ProcessEventType *evt = find_or_create_stdout_event(event); 522 522 if (!ensure_listener_capacity(evt)) return this_obj; ··· 535 535 if (nargs < 2) return this_obj; 536 536 537 537 char *event = js_getstr(js, args[0], NULL); 538 538 - if (!event || js_type(args[1]) != JS_FUNC) return this_obj; 538 538 + if (!event || vtype(args[1]) != T_FUNC) return this_obj; 539 539 540 540 ProcessEventType *evt = find_or_create_stdout_event(event); 541 541 if (!ensure_listener_capacity(evt)) return this_obj; ··· 623 623 if (nargs < 2) return this_obj; 624 624 625 625 char *event = js_getstr(js, args[0], NULL); 626 626 - if (!event || js_type(args[1]) != JS_FUNC) return this_obj; 626 626 + if (!event || vtype(args[1]) != T_FUNC) return this_obj; 627 627 628 628 ProcessEventType *evt = find_or_create_stderr_event(event); 629 629 if (!ensure_listener_capacity(evt)) return this_obj; ··· 640 640 if (nargs < 2) return this_obj; 641 641 642 642 char *event = js_getstr(js, args[0], NULL); 643 643 - if (!event || js_type(args[1]) != JS_FUNC) return this_obj; 643 643 + if (!event || vtype(args[1]) != T_FUNC) return this_obj; 644 644 645 645 ProcessEventType *evt = find_or_create_stderr_event(event); 646 646 if (!ensure_listener_capacity(evt)) return this_obj; ··· 686 686 if (nargs > 0 && vtype(args[0]) == T_ARR) { 687 687 jsval_t prev_sec = js_get(js, args[0], "0"); 688 688 jsval_t prev_nsec = js_get(js, args[0], "1"); 689 689 - if (js_type(prev_sec) == JS_NUM && js_type(prev_nsec) == JS_NUM) { 689 689 + if (vtype(prev_sec) == T_NUM && vtype(prev_nsec) == T_NUM) { 690 690 uint64_t prev = (uint64_t)js_getnum(prev_sec) * 1000000000ULL + (uint64_t)js_getnum(prev_nsec); 691 691 now = now - prev; 692 692 } ··· 760 760 int64_t user_usec = rusage.ru_utime.tv_sec * 1000000LL + rusage.ru_utime.tv_usec; 761 761 int64_t sys_usec = rusage.ru_stime.tv_sec * 1000000LL + rusage.ru_stime.tv_usec; 762 762 763 763 - if (nargs > 0 && js_type(args[0]) == JS_OBJ) { 763 763 + if (nargs > 0 && vtype(args[0]) == T_OBJ) { 764 764 jsval_t prev_user = js_get(js, args[0], "user"); 765 765 jsval_t prev_system = js_get(js, args[0], "system"); 766 766 - if (js_type(prev_user) == JS_NUM) user_usec -= (int64_t)js_getnum(prev_user); 767 767 - if (js_type(prev_system) == JS_NUM) sys_usec -= (int64_t)js_getnum(prev_system); 766 766 + if (vtype(prev_user) == T_NUM) user_usec -= (int64_t)js_getnum(prev_user); 767 767 + if (vtype(prev_system) == T_NUM) sys_usec -= (int64_t)js_getnum(prev_system); 768 768 } 769 769 770 770 js_set(js, obj, "user", js_mknum((double)user_usec)); ··· 779 779 780 780 static jsval_t process_kill(ant_t *js, jsval_t *args, int nargs) { 781 781 if (nargs < 1) return js_mkerr(js, "process.kill requires at least 1 argument"); 782 782 - if (js_type(args[0]) != JS_NUM) return js_mkerr(js, "pid must be a number"); 782 782 + if (vtype(args[0]) != T_NUM) return js_mkerr(js, "pid must be a number"); 783 783 784 784 int pid = (int)js_getnum(args[0]); 785 785 int sig = SIGTERM; 786 786 787 787 if (nargs > 1) { 788 788 - if (js_type(args[1]) == JS_NUM) { 788 788 + if (vtype(args[1]) == T_NUM) { 789 789 sig = (int)js_getnum(args[1]); 790 790 - } else if (js_type(args[1]) == JS_STR) { 790 790 + } else if (vtype(args[1]) == T_STR) { 791 791 char *sig_name = js_getstr(js, args[1], NULL); 792 792 if (sig_name) { 793 793 int signum = get_signal_number(sig_name); ··· 824 824 (void)args; (void)nargs; 825 825 return js_mknum(0); 826 826 #else 827 827 - if (nargs > 0 && js_type(args[0]) == JS_NUM) { 827 827 + if (nargs > 0 && vtype(args[0]) == T_NUM) { 828 828 int new_mask = (int)js_getnum(args[0]); 829 829 int old_mask = umask((mode_t)new_mask); 830 830 return js_mknum(old_mask); ··· 877 877 if (nargs < 1) return js_mkerr(js, "process.setuid requires 1 argument"); 878 878 879 879 uid_t uid; 880 880 - if (js_type(args[0]) == JS_NUM) { 880 880 + if (vtype(args[0]) == T_NUM) { 881 881 uid = (uid_t)js_getnum(args[0]); 882 882 - } else if (js_type(args[0]) == JS_STR) { 882 882 + } else if (vtype(args[0]) == T_STR) { 883 883 char *name = js_getstr(js, args[0], NULL); 884 884 struct passwd *pwd = getpwnam(name); 885 885 if (!pwd) return js_mkerr(js, "setuid user not found"); ··· 896 896 if (nargs < 1) return js_mkerr(js, "process.setgid requires 1 argument"); 897 897 898 898 gid_t gid; 899 899 - if (js_type(args[0]) == JS_NUM) { 899 899 + if (vtype(args[0]) == T_NUM) { 900 900 gid = (gid_t)js_getnum(args[0]); 901 901 - } else if (js_type(args[0]) == JS_STR) { 901 901 + } else if (vtype(args[0]) == T_STR) { 902 902 char *name = js_getstr(js, args[0], NULL); 903 903 struct group *grp = getgrnam(name); 904 904 if (!grp) return js_mkerr(js, "setgid group not found"); ··· 915 915 if (nargs < 1) return js_mkerr(js, "process.seteuid requires 1 argument"); 916 916 917 917 uid_t uid; 918 918 - if (js_type(args[0]) == JS_NUM) { 918 918 + if (vtype(args[0]) == T_NUM) { 919 919 uid = (uid_t)js_getnum(args[0]); 920 920 - } else if (js_type(args[0]) == JS_STR) { 920 920 + } else if (vtype(args[0]) == T_STR) { 921 921 char *name = js_getstr(js, args[0], NULL); 922 922 struct passwd *pwd = getpwnam(name); 923 923 if (!pwd) return js_mkerr(js, "seteuid user not found"); ··· 934 934 if (nargs < 1) return js_mkerr(js, "process.setegid requires 1 argument"); 935 935 936 936 gid_t gid; 937 937 - if (js_type(args[0]) == JS_NUM) { 937 937 + if (vtype(args[0]) == T_NUM) { 938 938 gid = (gid_t)js_getnum(args[0]); 939 939 - } else if (js_type(args[0]) == JS_STR) { 939 939 + } else if (vtype(args[0]) == T_STR) { 940 940 char *name = js_getstr(js, args[0], NULL); 941 941 struct group *grp = getgrnam(name); 942 942 if (!grp) return js_mkerr(js, "setegid group not found"); ··· 964 964 char idx[16]; 965 965 snprintf(idx, sizeof(idx), "%d", i); 966 966 jsval_t val = js_get(js, args[0], idx); 967 967 - if (js_type(val) == JS_NUM) { 967 967 + if (vtype(val) == T_NUM) { 968 968 groups[i] = (gid_t)js_getnum(val); 969 969 - } else if (js_type(val) == JS_STR) { 969 969 + } else if (vtype(val) == T_STR) { 970 970 char *name = js_getstr(js, val, NULL); 971 971 struct group *grp = getgrnam(name); 972 972 if (!grp) { free(groups); return js_mkerr(js, "group not found"); } ··· 992 992 if (!user) return js_mkerr(js, "user must be a string"); 993 993 994 994 gid_t gid; 995 995 - if (js_type(args[1]) == JS_NUM) { 995 995 + if (vtype(args[1]) == T_NUM) { 996 996 gid = (gid_t)js_getnum(args[1]); 997 997 - } else if (js_type(args[1]) == JS_STR) { 997 997 + } else if (vtype(args[1]) == T_STR) { 998 998 char *name = js_getstr(js, args[1], NULL); 999 999 struct group *grp = getgrnam(name); 1000 1000 if (!grp) return js_mkerr(js, "group not found"); ··· 1076 1076 static jsval_t process_exit(ant_t *js, jsval_t *args, int nargs) { 1077 1077 int code = 0; 1078 1078 1079 1079 - if (nargs > 0 && js_type(args[0]) == JS_NUM) { 1079 1079 + if (nargs > 0 && vtype(args[0]) == T_NUM) { 1080 1080 code = (int)js_getnum(args[0]); 1081 1081 } 1082 1082 ··· 1120 1120 1121 1121 char *event = js_getstr(js, args[0], NULL); 1122 1122 if (!event) return js_mkerr(js, "event must be a string"); 1123 1123 - if (js_type(args[1]) != JS_FUNC) return js_mkerr(js, "listener must be a function"); 1123 1123 + if (vtype(args[1]) != T_FUNC) return js_mkerr(js, "listener must be a function"); 1124 1124 1125 1125 int signum = get_signal_number(event); 1126 1126 if (signum > 0) { ··· 1146 1146 1147 1147 char *event = js_getstr(js, args[0], NULL); 1148 1148 if (!event) return js_mkerr(js, "event must be a string"); 1149 1149 - if (js_type(args[1]) != JS_FUNC) return js_mkerr(js, "listener must be a function"); 1149 1149 + if (vtype(args[1]) != T_FUNC) return js_mkerr(js, "listener must be a function"); 1150 1150 1151 1151 int signum = get_signal_number(event); 1152 1152 if (signum > 0) { ··· 1198 1198 static jsval_t process_remove_all_listeners(ant_t *js, jsval_t *args, int nargs) { 1199 1199 jsval_t process_obj = js_get(js, js_glob(js), "process"); 1200 1200 1201 1201 - if (nargs > 0 && js_type(args[0]) == JS_STR) { 1201 1201 + if (nargs > 0 && vtype(args[0]) == T_STR) { 1202 1202 char *event = js_getstr(js, args[0], NULL); 1203 1203 if (event) { 1204 1204 ProcessEventType *evt = NULL; ··· 1245 1245 1246 1246 static jsval_t process_set_max_listeners(ant_t *js, jsval_t *args, int nargs) { 1247 1247 if (nargs < 1) return js_mkerr(js, "setMaxListeners requires 1 argument"); 1248 1248 - if (js_type(args[0]) != JS_NUM) return js_mkerr(js, "n must be a number"); 1248 1248 + if (vtype(args[0]) != T_NUM) return js_mkerr(js, "n must be a number"); 1249 1249 1250 1250 int n = (int)js_getnum(args[0]); 1251 1251 if (n < 0) return js_mkerr(js, "n must be non-negative");

+23 -22

src/modules/readline.c

reviewed

··· 24 24 #include "ant.h" 25 25 #include "errors.h" 26 26 #include "runtime.h" 27 27 + #include "internal.h" 28 28 + 27 29 #include "modules/readline.h" 28 30 #include "modules/symbol.h" 29 31 ··· 493 495 jsval_t line_val = js_mkstr(js, line, strlen(line)); 494 496 emit_event(js, iface, "line", &line_val, 1); 495 497 496 496 - if (js_type(iface->pending_question_resolve) == JS_FUNC) { 498 498 + if (vtype(iface->pending_question_resolve) == T_FUNC) { 497 499 js_call(js, iface->pending_question_resolve, &line_val, 1); 498 500 iface->pending_question_resolve = js_mkundef(); 499 501 iface->pending_question_reject = js_mkundef(); ··· 586 588 jsval_t line_val = js_mkstr(js, line, strlen(line)); 587 589 emit_event(js, iface, "line", &line_val, 1); 588 590 589 589 - if (js_type(iface->pending_question_resolve) == JS_FUNC) { 591 591 + if (vtype(iface->pending_question_resolve) == T_FUNC) { 590 592 js_call(js, iface->pending_question_resolve, &line_val, 1); 591 593 iface->pending_question_resolve = js_mkundef(); 592 594 iface->pending_question_reject = js_mkundef(); ··· 601 603 602 604 static rl_interface_t *get_interface(struct js *js, jsval_t this_obj) { 603 605 jsval_t id_val = js_get(js, this_obj, "_rl_id"); 604 604 - if (js_type(id_val) != JS_NUM) return NULL; 606 606 + if (vtype(id_val) != T_NUM) return NULL; 605 607 606 608 uint64_t id = (uint64_t)js_getnum(id_val); 607 609 rl_interface_t *iface = NULL; ··· 618 620 619 621 char *event = js_getstr(js, args[0], NULL); 620 622 if (!event) return js_mkerr(js, "event must be a string"); 621 621 - if (js_type(args[1]) != JS_FUNC) return js_mkerr(js, "listener must be a function"); 623 623 + if (vtype(args[1]) != T_FUNC) return js_mkerr(js, "listener must be a function"); 622 624 623 625 RLEventType *evt = find_or_create_event_type(iface, event); 624 626 if (evt->listener_count >= MAX_LISTENERS_PER_EVENT) { ··· 641 643 642 644 char *event = js_getstr(js, args[0], NULL); 643 645 if (!event) return js_mkerr(js, "event must be a string"); 644 644 - if (js_type(args[1]) != JS_FUNC) return js_mkerr(js, "listener must be a function"); 646 646 + if (vtype(args[1]) != T_FUNC) return js_mkerr(js, "listener must be a function"); 645 647 646 648 RLEventType *evt = find_or_create_event_type(iface, event); 647 649 if (evt->listener_count >= MAX_LISTENERS_PER_EVENT) { ··· 861 863 emit_event(js, iface, "resume", NULL, 0); 862 864 } 863 865 864 864 - if (nargs >= 2 && js_type(args[1]) == JS_OBJ) { 866 866 + if (nargs >= 2 && vtype(args[1]) == T_OBJ) { 865 867 jsval_t key = args[1]; 866 868 jsval_t name_val = js_get(js, key, "name"); 867 869 jsval_t ctrl_val = js_get(js, key, "ctrl"); 868 870 jsval_t meta_val = js_get(js, key, "meta"); 869 871 jsval_t shift_val = js_get(js, key, "shift"); 870 872 871 871 - char *name = (js_type(name_val) == JS_STR) ? js_getstr(js, name_val, NULL) : NULL; 873 873 + char *name = (vtype(name_val) == T_STR) ? js_getstr(js, name_val, NULL) : NULL; 872 874 bool ctrl = js_truthy(js, ctrl_val); 873 875 bool meta = js_truthy(js, meta_val); 874 876 bool shift = js_truthy(js, shift_val); ··· 879 881 } 880 882 } 881 883 882 882 - if (nargs < 1 || js_type(args[0]) == JS_NULL || js_type(args[0]) == JS_UNDEF) { 884 884 + if (nargs < 1 || vtype(args[0]) == T_NULL || vtype(args[0]) == T_UNDEF) { 883 885 return js_mkundef(); 884 886 } 885 887 ··· 934 936 char *query = js_getstr(js, args[0], &query_len); 935 937 if (!query) return js_mkerr(js, "query must be a string"); 936 938 937 937 - if (js_type(args[1]) != JS_FUNC) { 939 939 + if (vtype(args[1]) != T_FUNC) { 938 940 return js_mkerr(js, "callback must be a function"); 939 941 } 940 942 ··· 1057 1059 if (nargs < 1) return js_mkerr(js, "createInterface requires options"); 1058 1060 1059 1061 jsval_t options = args[0]; 1060 1060 - if (js_type(options) != JS_OBJ) return js_mkerr(js, "options must be an object"); 1062 1062 + if (vtype(options) != T_OBJ) return js_mkerr(js, "options must be an object"); 1061 1063 1062 1064 rl_interface_t *iface = calloc(1, sizeof(rl_interface_t)); 1063 1065 if (!iface) return js_mkerr(js, "out of memory"); ··· 1086 1088 iface->output_stream = js_get(js, options, "output"); 1087 1089 1088 1090 jsval_t terminal_val = js_get(js, options, "terminal"); 1089 1089 - iface->terminal = (js_type(terminal_val) == JS_TRUE) || 1090 1090 - (js_type(terminal_val) == JS_UNDEF); 1091 1091 + iface->terminal = terminal_val == js_true || vtype(terminal_val) == T_UNDEF; 1091 1092 1092 1093 jsval_t history_size_val = js_get(js, options, "historySize"); 1093 1093 - iface->history_size = (js_type(history_size_val) == JS_NUM) 1094 1094 + iface->history_size = (vtype(history_size_val) == T_NUM) 1094 1095 ? (int)js_getnum(history_size_val) 1095 1096 : DEFAULT_HISTORY_SIZE; 1096 1097 ··· 1098 1099 iface->remove_history_duplicates = js_truthy(js, remove_dup_val); 1099 1100 1100 1101 jsval_t prompt_val = js_get(js, options, "prompt"); 1101 1101 - if (js_type(prompt_val) == JS_STR) { 1102 1102 + if (vtype(prompt_val) == T_STR) { 1102 1103 free(iface->prompt); 1103 1104 iface->prompt = strdup(js_getstr(js, prompt_val, NULL)); 1104 1105 } 1105 1106 1106 1107 jsval_t crlf_delay_val = js_get(js, options, "crlfDelay"); 1107 1107 - iface->crlf_delay = (js_type(crlf_delay_val) == JS_NUM) 1108 1108 + iface->crlf_delay = (vtype(crlf_delay_val) == T_NUM) 1108 1109 ? (int)js_getnum(crlf_delay_val) 1109 1110 : 100; 1110 1111 if (iface->crlf_delay < 100) iface->crlf_delay = 100; 1111 1112 1112 1113 jsval_t tab_size_val = js_get(js, options, "tabSize"); 1113 1113 - iface->tab_size = (js_type(tab_size_val) == JS_NUM) 1114 1114 + iface->tab_size = (vtype(tab_size_val) == T_NUM) 1114 1115 ? (int)js_getnum(tab_size_val) 1115 1116 : DEFAULT_TAB_SIZE; 1116 1117 if (iface->tab_size < 1) iface->tab_size = 1; 1117 1118 1118 1119 jsval_t completer_val = js_get(js, options, "completer"); 1119 1119 - iface->completer = (js_type(completer_val) == JS_FUNC) ? completer_val : js_mkundef(); 1120 1120 + iface->completer = (vtype(completer_val) == T_FUNC) ? completer_val : js_mkundef(); 1120 1121 1121 1122 jsval_t history_val = js_get(js, options, "history"); 1122 1122 - if (js_type(history_val) == JS_OBJ) { 1123 1123 + if (vtype(history_val) == T_OBJ) { 1123 1124 jsval_t len_val = js_get(js, history_val, "length"); 1124 1124 - int len = (js_type(len_val) == JS_NUM) ? (int)js_getnum(len_val) : 0; 1125 1125 + int len = (vtype(len_val) == T_NUM) ? (int)js_getnum(len_val) : 0; 1125 1126 1126 1127 rl_history_init(&iface->history, iface->history_size); 1127 1128 ··· 1129 1130 char key[16]; 1130 1131 snprintf(key, sizeof(key), "%d", i); 1131 1132 jsval_t item = js_get(js, history_val, key); 1132 1132 - if (js_type(item) == JS_STR) { 1133 1133 + if (vtype(item) == T_STR) { 1133 1134 char *line = js_getstr(js, item, NULL); 1134 1135 if (line) rl_history_add(&iface->history, line, false); 1135 1136 } ··· 1173 1174 1174 1175 static jsval_t rl_create_interface_promises(struct js *js, jsval_t *args, int nargs) { 1175 1176 jsval_t iface_obj = rl_create_interface(js, args, nargs); 1176 1176 - if (js_type(iface_obj) == JS_ERR) return iface_obj; 1177 1177 + if (vtype(iface_obj) == T_ERR) return iface_obj; 1177 1178 js_set(js, iface_obj, "question", js_mkfun(rl_interface_question_promise)); 1178 1179 1179 1180 return iface_obj; ··· 1210 1211 if (nargs < 2) return js_mkfalse(); 1211 1212 int x = (int)js_getnum(args[1]); 1212 1213 1213 1213 - if (nargs >= 3 && js_type(args[2]) == JS_NUM) { 1214 1214 + if (nargs >= 3 && vtype(args[2]) == T_NUM) { 1214 1215 int y = (int)js_getnum(args[2]); 1215 1216 printf("\033[%d;%dH", y + 1, x + 1); 1216 1217 } else {

+42 -43

src/modules/reflect.c

reviewed

··· 4 4 #include "ant.h" 5 5 #include "errors.h" 6 6 #include "runtime.h" 7 7 + #include "internal.h" 8 8 + 7 9 #include "modules/reflect.h" 8 10 #include "modules/symbol.h" 9 11 ··· 13 15 jsval_t target = args[0]; 14 16 jsval_t key = args[1]; 15 17 16 16 - int t = js_type(target); 17 17 - if (t != JS_OBJ && t != JS_FUNC) return js_mkundef(); 18 18 + int t = vtype(target); 19 19 + if (t != T_OBJ && t != T_FUNC) return js_mkundef(); 18 20 19 19 - if (js_type(key) != JS_STR) return js_mkundef(); 21 21 + if (vtype(key) != T_STR) return js_mkundef(); 20 22 21 23 char *key_str = js_getstr(js, key, NULL); 22 24 if (!key_str) return js_mkundef(); ··· 31 33 jsval_t key = args[1]; 32 34 jsval_t value = args[2]; 33 35 34 34 - int t = js_type(target); 35 35 - if (t != JS_OBJ && t != JS_FUNC) return js_mkfalse(); 36 36 + int t = vtype(target); 37 37 + if (t != T_OBJ && t != T_FUNC) return js_mkfalse(); 36 38 37 37 - if (js_type(key) != JS_STR) return js_mkfalse(); 39 39 + if (vtype(key) != T_STR) return js_mkfalse(); 38 40 39 41 char *key_str = js_getstr(js, key, NULL); 40 42 if (!key_str) return js_mkfalse(); ··· 49 51 jsval_t target = args[0]; 50 52 jsval_t key = args[1]; 51 53 52 52 - int t = js_type(target); 53 53 - if (t != JS_OBJ && t != JS_FUNC) return js_mkfalse(); 54 54 + int t = vtype(target); 55 55 + if (t != T_OBJ && t != T_FUNC) return js_mkfalse(); 54 56 55 55 - if (js_type(key) != JS_STR) return js_mkfalse(); 57 57 + if (vtype(key) != T_STR) return js_mkfalse(); 56 58 57 59 char *key_str = js_getstr(js, key, NULL); 58 60 if (!key_str) return js_mkfalse(); 59 61 60 62 jsval_t val = js_get(js, target, key_str); 61 61 - return js_type(val) != JS_UNDEF ? js_mktrue() : js_mkfalse(); 63 63 + return vtype(val) != T_UNDEF ? js_mktrue() : js_mkfalse(); 62 64 } 63 65 64 66 static jsval_t reflect_delete_property(struct js *js, jsval_t *args, int nargs) { ··· 67 69 jsval_t target = args[0]; 68 70 jsval_t key = args[1]; 69 71 70 70 - int t = js_type(target); 71 71 - if (t != JS_OBJ && t != JS_FUNC) return js_mkfalse(); 72 72 + int t = vtype(target); 73 73 + if (t != T_OBJ && t != T_FUNC) return js_mkfalse(); 72 74 73 73 - if (js_type(key) != JS_STR) return js_mkfalse(); 75 75 + if (vtype(key) != T_STR) return js_mkfalse(); 74 76 75 77 size_t key_len; 76 78 char *key_str = js_getstr(js, key, &key_len); ··· 87 89 88 90 jsval_t target = args[0]; 89 91 90 90 - int t = js_type(target); 91 91 - if (t != JS_OBJ && t != JS_FUNC) { 92 92 + int t = vtype(target); 93 93 + if (t != T_OBJ && t != T_FUNC) { 92 94 return js_mkerr(js, "Reflect.ownKeys called on non-object"); 93 95 } 94 96 ··· 114 116 jsval_t target = args[0]; 115 117 jsval_t args_arr = args[1]; 116 118 117 117 - if (js_type(target) != JS_FUNC) { 119 119 + if (vtype(target) != T_FUNC) { 118 120 return js_mkerr(js, "Reflect.construct: first argument must be a constructor"); 119 121 } 120 122 121 123 jsval_t length_val = js_get(js, args_arr, "length"); 122 124 int arg_count = 0; 123 123 - if (js_type(length_val) == JS_NUM) { 125 125 + if (vtype(length_val) == T_NUM) { 124 126 arg_count = (int)js_getnum(length_val); 125 127 } 126 128 ··· 141 143 142 144 if (call_args) free(call_args); 143 145 144 144 - if (js_type(result) == JS_OBJ || js_type(result) == JS_FUNC) { 146 146 + if (vtype(result) == T_OBJ || vtype(result) == T_FUNC) { 145 147 return result; 146 148 } 147 149 return new_obj; ··· 156 158 jsval_t this_arg = args[1]; 157 159 jsval_t args_arr = args[2]; 158 160 159 159 - if (js_type(target) != JS_FUNC) { 161 161 + if (vtype(target) != T_FUNC) { 160 162 return js_mkerr(js, "Reflect.apply: first argument must be a function"); 161 163 } 162 164 163 165 jsval_t length_val = js_get(js, args_arr, "length"); 164 166 int arg_count = 0; 165 165 - if (js_type(length_val) == JS_NUM) { 167 167 + if (vtype(length_val) == T_NUM) { 166 168 arg_count = (int)js_getnum(length_val); 167 169 } 168 170 ··· 190 192 jsval_t target = args[0]; 191 193 jsval_t key = args[1]; 192 194 193 193 - int t = js_type(target); 194 194 - if (t != JS_OBJ && t != JS_FUNC) return js_mkundef(); 195 195 + int t = vtype(target); 196 196 + if (t != T_OBJ && t != T_FUNC) return js_mkundef(); 195 197 196 196 - if (js_type(key) != JS_STR) return js_mkundef(); 198 198 + if (vtype(key) != T_STR) return js_mkundef(); 197 199 198 200 char *key_str = js_getstr(js, key, NULL); 199 201 if (!key_str) return js_mkundef(); 200 202 201 203 jsval_t value = js_get(js, target, key_str); 202 202 - if (js_type(value) == JS_UNDEF) return js_mkundef(); 204 204 + if (vtype(value) == T_UNDEF) return js_mkundef(); 203 205 204 206 jsval_t desc = js_mkobj(js); 205 207 js_set(js, desc, "value", value); ··· 217 219 jsval_t key = args[1]; 218 220 jsval_t descriptor = args[2]; 219 221 220 220 - int t = js_type(target); 221 221 - if (t != JS_OBJ && t != JS_FUNC) return js_mkfalse(); 222 222 + int t = vtype(target); 223 223 + if (t != T_OBJ && t != T_FUNC) return js_mkfalse(); 222 224 223 223 - if (js_type(key) != JS_STR) return js_mkfalse(); 224 224 - if (js_type(descriptor) != JS_OBJ) return js_mkfalse(); 225 225 + if (vtype(key) != T_STR) return js_mkfalse(); 226 226 + if (vtype(descriptor) != T_OBJ) return js_mkfalse(); 225 227 226 228 char *key_str = js_getstr(js, key, NULL); 227 229 if (!key_str) return js_mkfalse(); ··· 238 240 } 239 241 240 242 jsval_t target = args[0]; 241 241 - int t = js_type(target); 243 243 + int t = vtype(target); 242 244 243 243 - if (t != JS_OBJ && t != JS_FUNC) { 245 245 + if (t != T_OBJ && t != T_FUNC) { 244 246 return js_mkerr(js, "Reflect.getPrototypeOf: argument must be an object"); 245 247 } 246 248 ··· 253 255 jsval_t target = args[0]; 254 256 jsval_t proto = args[1]; 255 257 256 256 - int t = js_type(target); 257 257 - if (t != JS_OBJ && t != JS_FUNC) return js_mkfalse(); 258 258 + int t = vtype(target); 259 259 + if (t != T_OBJ && t != T_FUNC) return js_mkfalse(); 258 260 259 259 - int pt = js_type(proto); 260 260 - if (pt != JS_OBJ && pt != JS_FUNC && pt != JS_NULL) return js_mkfalse(); 261 261 + int pt = vtype(proto); 262 262 + if (pt != T_OBJ && pt != T_FUNC && pt != T_NULL) return js_mkfalse(); 261 263 262 264 js_set_proto(js, target, proto); 263 265 return js_mktrue(); ··· 267 269 if (nargs < 1) return js_mkfalse(); 268 270 269 271 jsval_t target = args[0]; 270 270 - int t = js_type(target); 272 272 + int t = vtype(target); 271 273 272 272 - if (t != JS_OBJ && t != JS_FUNC) return js_mkfalse(); 274 274 + if (t != T_OBJ && t != T_FUNC) return js_mkfalse(); 273 275 274 274 - jsval_t frozen = js_get_slot(js, target, SLOT_FROZEN); 275 275 - if (js_type(frozen) == JS_TRUE) return js_mkfalse(); 276 276 - 277 277 - jsval_t sealed = js_get_slot(js, target, SLOT_SEALED); 278 278 - if (js_type(sealed) == JS_TRUE) return js_mkfalse(); 276 276 + if (js_get_slot(js, target, SLOT_FROZEN) == js_true) return js_false; 277 277 + if (js_get_slot(js, target, SLOT_SEALED) == js_true) return js_false; 279 278 280 279 return js_mktrue(); 281 280 } ··· 284 283 if (nargs < 1) return js_mkfalse(); 285 284 286 285 jsval_t target = args[0]; 287 287 - int t = js_type(target); 286 286 + int t = vtype(target); 288 287 289 289 - if (t != JS_OBJ && t != JS_FUNC) return js_mkfalse(); 288 288 + if (t != T_OBJ && t != T_FUNC) return js_mkfalse(); 290 289 291 290 js_set_slot(js, target, SLOT_EXTENSIBLE, js_mkfalse()); 292 291 return js_mktrue();

+31 -29

src/modules/server.c

reviewed

··· 12 12 #include "ant.h" 13 13 #include "config.h" 14 14 #include "runtime.h" 15 15 + #include "internal.h" 16 16 + 15 17 #include "modules/server.h" 16 18 #include "modules/timer.h" 17 19 #include "modules/json.h" ··· 344 346 345 347 jsval_t fn = js_getcurrentfunc(js); 346 348 jsval_t store_obj = js_get_slot(js, fn, SLOT_DATA); 347 347 - if (js_type(store_obj) == JS_UNDEF) return js_mkundef(); 349 349 + if (vtype(store_obj) == T_UNDEF) return js_mkundef(); 348 350 349 349 - if (js_type(args[0]) == JS_STR) { 351 351 + if (vtype(args[0]) == T_STR) { 350 352 size_t key_len; 351 353 const char *key = js_getstr(js, args[0], &key_len); 352 354 js_set(js, store_obj, key, args[1]); ··· 360 362 361 363 jsval_t fn = js_getcurrentfunc(js); 362 364 jsval_t store_obj = js_get_slot(js, fn, SLOT_DATA); 363 363 - if (js_type(store_obj) == JS_UNDEF) return js_mkundef(); 365 365 + if (vtype(store_obj) == T_UNDEF) return js_mkundef(); 364 366 365 365 - if (js_type(args[0]) == JS_STR) { 367 367 + if (vtype(args[0]) == T_STR) { 366 368 size_t key_len; 367 369 const char *key = js_getstr(js, args[0], &key_len); 368 370 return js_get(js, store_obj, key); ··· 376 378 377 379 jsval_t fn = js_getcurrentfunc(js); 378 380 jsval_t headers_val = js_get_slot(js, fn, SLOT_DATA); 379 379 - if (js_type(headers_val) != JS_NUM) return js_mkundef(); 381 381 + if (vtype(headers_val) != T_NUM) return js_mkundef(); 380 382 381 383 UT_array *headers = (UT_array *)(unsigned long)js_getnum(headers_val); 382 384 if (!headers) return js_mkundef(); 383 385 384 384 - if (js_type(args[0]) != JS_STR) return js_mkundef(); 386 386 + if (vtype(args[0]) != T_STR) return js_mkundef(); 385 387 size_t name_len; 386 388 const char *search_name = js_getstr(js, args[0], &name_len); 387 389 ··· 400 402 401 403 jsval_t fn = js_getcurrentfunc(js); 402 404 jsval_t ctx_val = js_get_slot(js, fn, SLOT_DATA); 403 403 - if (js_type(ctx_val) != JS_NUM) return js_mkundef(); 405 405 + if (vtype(ctx_val) != T_NUM) return js_mkundef(); 404 406 405 407 response_ctx_t *ctx = (response_ctx_t *)(unsigned long)js_getnum(ctx_val); 406 408 if (!ctx || !ctx->custom_headers) return js_mkundef(); 407 409 408 408 - if (js_type(args[0]) == JS_STR && js_type(args[1]) == JS_STR) { 410 410 + if (vtype(args[0]) == T_STR && vtype(args[1]) == T_STR) { 409 411 custom_header_t header; 410 412 header.name = js_getstr(js, args[0], NULL); 411 413 header.value = js_getstr(js, args[1], NULL); ··· 420 422 421 423 jsval_t fn = js_getcurrentfunc(js); 422 424 jsval_t ctx_val = js_get_slot(js, fn, SLOT_DATA); 423 423 - if (js_type(ctx_val) != JS_NUM) return js_mkundef(); 425 425 + if (vtype(ctx_val) != T_NUM) return js_mkundef(); 424 426 425 427 response_ctx_t *ctx = (response_ctx_t *)(unsigned long)js_getnum(ctx_val); 426 428 if (!ctx) return js_mkundef(); 427 429 428 428 - if (js_type(args[0]) == JS_NUM) { 430 430 + if (vtype(args[0]) == T_NUM) { 429 431 ctx->status = (int)js_getnum(args[0]); 430 432 } 431 433 ··· 437 439 438 440 jsval_t fn = js_getcurrentfunc(js); 439 441 jsval_t ctx_val = js_get_slot(js, fn, SLOT_DATA); 440 440 - if (js_type(ctx_val) != JS_NUM) return js_mkundef(); 442 442 + if (vtype(ctx_val) != T_NUM) return js_mkundef(); 441 443 442 444 response_ctx_t *ctx = (response_ctx_t *)(unsigned long)js_getnum(ctx_val); 443 445 if (!ctx) return js_mkundef(); 444 446 445 445 - if (js_type(args[0]) == JS_STR) { 447 447 + if (vtype(args[0]) == T_STR) { 446 448 ctx->body = js_getstr(js, args[0], &ctx->body_len); 447 449 } 448 450 449 449 - if (nargs >= 2 && js_type(args[1]) == JS_NUM) { 451 451 + if (nargs >= 2 && vtype(args[1]) == T_NUM) { 450 452 ctx->status = (int)js_getnum(args[1]); 451 453 } 452 454 453 453 - if (nargs >= 3 && js_type(args[2]) == JS_STR) { 455 455 + if (nargs >= 3 && vtype(args[2]) == T_STR) { 454 456 ctx->content_type = js_getstr(js, args[2], NULL); 455 457 } else { 456 458 ctx->content_type = "text/plain"; ··· 466 468 467 469 jsval_t fn = js_getcurrentfunc(js); 468 470 jsval_t ctx_val = js_get_slot(js, fn, SLOT_DATA); 469 469 - if (js_type(ctx_val) != JS_NUM) return js_mkundef(); 471 471 + if (vtype(ctx_val) != T_NUM) return js_mkundef(); 470 472 471 473 response_ctx_t *ctx = (response_ctx_t *)(unsigned long)js_getnum(ctx_val); 472 474 if (!ctx) return js_mkundef(); 473 475 474 474 - if (js_type(args[0]) == JS_STR) { 476 476 + if (vtype(args[0]) == T_STR) { 475 477 ctx->body = js_getstr(js, args[0], &ctx->body_len); 476 478 } 477 479 478 478 - if (nargs >= 2 && js_type(args[1]) == JS_NUM) { 480 480 + if (nargs >= 2 && vtype(args[1]) == T_NUM) { 479 481 ctx->status = (int)js_getnum(args[1]); 480 482 } 481 483 ··· 490 492 491 493 jsval_t fn = js_getcurrentfunc(js); 492 494 jsval_t ctx_val = js_get_slot(js, fn, SLOT_DATA); 493 493 - if (js_type(ctx_val) != JS_NUM) return js_mkundef(); 495 495 + if (vtype(ctx_val) != T_NUM) return js_mkundef(); 494 496 495 497 response_ctx_t *ctx = (response_ctx_t *)(unsigned long)js_getnum(ctx_val); 496 498 if (!ctx) return js_mkundef(); ··· 498 500 jsval_t stringify_args[1] = { args[0] }; 499 501 jsval_t result = js_json_stringify(js, stringify_args, 1); 500 502 501 501 - if (js_type(result) == JS_STR) { 503 503 + if (vtype(result) == T_STR) { 502 504 ctx->body = js_getstr(js, result, &ctx->body_len); 503 503 - } else if (js_type(result) == JS_ERR) { 505 505 + } else if (vtype(result) == T_ERR) { 504 506 const char *json_str = js_str(js, args[0]); 505 507 if (json_str) { 506 508 ctx->body = (char *)json_str; ··· 508 510 } 509 511 } 510 512 511 511 - if (nargs >= 2 && js_type(args[1]) == JS_NUM) { 513 513 + if (nargs >= 2 && vtype(args[1]) == T_NUM) { 512 514 ctx->status = (int)js_getnum(args[1]); 513 515 } 514 516 ··· 523 525 524 526 jsval_t fn = js_getcurrentfunc(js); 525 527 jsval_t ctx_val = js_get_slot(js, fn, SLOT_DATA); 526 526 - if (js_type(ctx_val) != JS_NUM) return js_mkundef(); 528 528 + if (vtype(ctx_val) != T_NUM) return js_mkundef(); 527 529 528 530 response_ctx_t *ctx = (response_ctx_t *)(unsigned long)js_getnum(ctx_val); 529 531 if (!ctx) return js_mkundef(); ··· 542 544 543 545 jsval_t fn = js_getcurrentfunc(js); 544 546 jsval_t ctx_val = js_get_slot(js, fn, SLOT_DATA); 545 545 - if (js_type(ctx_val) != JS_NUM) return js_mkundef(); 547 547 + if (vtype(ctx_val) != T_NUM) return js_mkundef(); 546 548 547 549 response_ctx_t *ctx = (response_ctx_t *)(unsigned long)js_getnum(ctx_val); 548 550 if (!ctx) return js_mkundef(); 549 551 550 550 - if (js_type(args[0]) == JS_STR) { 552 552 + if (vtype(args[0]) == T_STR) { 551 553 ctx->redirect_location = js_getstr(js, args[0], NULL); 552 554 } 553 555 554 556 ctx->status = 302; 555 555 - if (nargs >= 2 && js_type(args[1]) == JS_NUM) { 557 557 + if (nargs >= 2 && vtype(args[1]) == T_NUM) { 556 558 ctx->status = (int)js_getnum(args[1]); 557 559 } 558 560 ··· 733 735 res_ctx->next = server->pending_responses; 734 736 server->pending_responses = res_ctx; 735 737 736 736 - if (server->handler != 0 && js_type(server->handler) != JS_UNDEF) { 738 738 + if (server->handler != 0 && vtype(server->handler) != T_UNDEF) { 737 739 jsval_t ctx = js_mkobj(server->js); 738 740 739 741 jsval_t req = js_mkobj(server->js); ··· 760 762 761 763 jsval_t args[1] = {ctx}; 762 764 result = js_call(server->js, server->handler, args, 1); 763 763 - if (js_type(result) == JS_PROMISE) return; 765 765 + if (vtype(result) == T_PROMISE) return; 764 766 765 765 - if (js_type(result) == JS_ERR) { 767 767 + if (vtype(result) == T_ERR) { 766 768 const char *error_msg = js_str(server->js, result); 767 769 fprintf(stderr, "Handler error: %s\n", error_msg); 768 770 ··· 937 939 } 938 940 939 941 int port = 8000; 940 940 - if (js_type(args[0]) == JS_NUM) { 942 942 + if (vtype(args[0]) == T_NUM) { 941 943 port = (int)js_getnum(args[0]); 942 944 } 943 945

+2 -1

src/modules/sessionstorage.c

reviewed

··· 6 6 #include "errors.h" 7 7 #include "arena.h" 8 8 #include "runtime.h" 9 9 + #include "internal.h" 9 10 10 11 #include "modules/symbol.h" 11 12 #include "modules/sessionstorage.h" ··· 138 139 return js_mkerr(js, "Failed to execute 'key' on 'Storage': 1 argument required"); 139 140 } 140 141 141 141 - if (js_type(args[0]) != JS_NUM) { 142 142 + if (vtype(args[0]) != T_NUM) { 142 143 return js_mknull(); 143 144 } 144 145

+6 -5

src/modules/shell.c

reviewed

··· 13 13 14 14 #include "ant.h" 15 15 #include "errors.h" 16 16 + #include "internal.h" 16 17 #include "modules/symbol.h" 17 18 18 19 static jsval_t builtin_shell_text(struct js *js, jsval_t *args, int nargs); ··· 111 112 static jsval_t builtin_shell_dollar(struct js *js, jsval_t *args, int nargs) { 112 113 if (nargs < 1) return js_mkerr(js, "$() requires at least one argument"); 113 114 114 114 - if (js_type(args[0]) != JS_OBJ) { 115 115 - if (js_type(args[0]) == JS_STR) { 115 115 + if (vtype(args[0]) != T_OBJ) { 116 116 + if (vtype(args[0]) == T_STR) { 116 117 size_t cmd_len; 117 118 char *cmd = js_getstr(js, args[0], &cmd_len); 118 119 if (!cmd) return js_mkerr(js, "Failed to get command string"); ··· 138 139 snprintf(idx_str, sizeof(idx_str), "%d", i); 139 140 140 141 jsval_t str_val = js_get(js, strings_array, idx_str); 141 141 - if (js_type(str_val) == JS_STR) { 142 142 + if (vtype(str_val) == T_STR) { 142 143 size_t str_len; 143 144 char *str = js_getstr(js, str_val, &str_len); 144 145 ··· 161 162 char val_str[256]; 162 163 size_t val_len = 0; 163 164 164 164 - if (js_type(val) == JS_STR) { 165 165 + if (vtype(val) == T_STR) { 165 166 size_t len; 166 167 char *s = js_getstr(js, val, &len); 167 168 val_len = len < sizeof(val_str) - 1 ? len : sizeof(val_str) - 1; 168 169 memcpy(val_str, s, val_len); 169 169 - } else if (js_type(val) == JS_NUM) { 170 170 + } else if (vtype(val) == T_NUM) { 170 171 val_len = snprintf(val_str, sizeof(val_str), "%g", js_getnum(val)); 171 172 } 172 173

+5 -4

src/modules/symbol.c

reviewed

··· 5 5 #include "ant.h" 6 6 #include "errors.h" 7 7 #include "runtime.h" 8 8 + #include "internal.h" 8 9 #include "modules/symbol.h" 9 10 10 11 static jsval_t g_iterator_sym = 0; ··· 29 30 30 31 static jsval_t builtin_Symbol(struct js *js, jsval_t *args, int nargs) { 31 32 const char *desc = NULL; 32 32 - if (nargs > 0 && js_type(args[0]) == JS_STR) { 33 33 + if (nargs > 0 && vtype(args[0]) == T_STR) { 33 34 desc = js_getstr(js, args[0], NULL); 34 35 } 35 36 return js_mksym(js, desc); 36 37 } 37 38 38 39 static jsval_t builtin_Symbol_for(struct js *js, jsval_t *args, int nargs) { 39 39 - if (nargs < 1 || js_type(args[0]) != JS_STR) { 40 40 + if (nargs < 1 || vtype(args[0]) != T_STR) { 40 41 return js_mkerr(js, "Symbol.for requires a string argument"); 41 42 } 42 43 ··· 47 48 } 48 49 49 50 static jsval_t builtin_Symbol_keyFor(struct js *js, jsval_t *args, int nargs) { 50 50 - if (nargs < 1 || js_type(args[0]) != JS_SYMBOL) { 51 51 + if (nargs < 1 || vtype(args[0]) != T_SYMBOL) { 51 52 return js_mkundef(); 52 53 } 53 54 ··· 90 91 jsval_t arr = js_getthis(js); 91 92 92 93 jsval_t len_val = js_get(js, arr, "length"); 93 93 - int len = js_type(len_val) == JS_NUM ? (int)js_getnum(len_val) : 0; 94 94 + int len = vtype(len_val) == T_NUM ? (int)js_getnum(len_val) : 0; 94 95 95 96 jsval_t iter = js_mkobj(js); 96 97 js_set(js, iter, "__arr", arr);

+8 -5

src/modules/textcodec.c

reviewed

··· 2 2 #include <stdio.h> 3 3 #include <string.h> 4 4 5 5 + #include "internal.h" 5 6 #include "runtime.h" 6 7 #include "errors.h" 8 8 + #include "internal.h" 9 9 + 7 10 #include "modules/textcodec.h" 8 11 #include "modules/buffer.h" 9 12 #include "modules/symbol.h" ··· 13 16 size_t str_len = 0; 14 17 const char *str = ""; 15 18 16 16 - if (nargs > 0 && js_type(args[0]) == JS_STR) { 19 19 + if (nargs > 0 && vtype(args[0]) == T_STR) { 17 20 str = js_getstr(js, args[0], &str_len); 18 21 if (!str) { 19 22 str = ""; ··· 27 30 jsval_t len_arg = js_mknum((double)str_len); 28 31 jsval_t arr = js_call(js, uint8array_ctor, &len_arg, 1); 29 32 30 30 - if (js_type(arr) == JS_ERR) return arr; 33 33 + if (vtype(arr) == T_ERR) return arr; 31 34 32 35 if (str_len > 0) { 33 36 jsval_t ta_data_val = js_get_slot(js, arr, SLOT_BUFFER); ··· 47 50 size_t str_len = 0; 48 51 const char *str = ""; 49 52 50 50 - if (js_type(args[0]) == JS_STR) { 53 53 + if (vtype(args[0]) == T_STR) { 51 54 str = js_getstr(js, args[0], &str_len); 52 55 if (!str) { 53 56 str = ""; ··· 102 105 } 103 106 104 107 jsval_t ab_data_val = js_get_slot(js, args[0], SLOT_BUFFER); 105 105 - if (js_type(ab_data_val) == JS_NUM) { 108 108 + if (vtype(ab_data_val) == T_NUM) { 106 109 ArrayBufferData *ab_data = (ArrayBufferData *)(uintptr_t)js_getnum(ab_data_val); 107 110 if (!ab_data || !ab_data->data) return js_mkstr(js, "", 0); 108 111 return js_mkstr(js, (const char *)ab_data->data, ab_data->length); ··· 115 118 const char *encoding = "utf-8"; 116 119 size_t encoding_len = 5; 117 120 118 118 - if (nargs > 0 && js_type(args[0]) == JS_STR) { 121 121 + if (nargs > 0 && vtype(args[0]) == T_STR) { 119 122 encoding = js_getstr(js, args[0], &encoding_len); 120 123 if (encoding && ( 121 124 strcasecmp(encoding, "utf-8") == 0 ||

+13 -12

src/modules/url.c

reviewed

··· 7 7 8 8 #include "ant.h" 9 9 #include "errors.h" 10 10 + #include "internal.h" 10 11 #include "runtime.h" 11 12 #include "modules/url.h" 12 13 ··· 353 354 if (!key) return js_mknull(); 354 355 355 356 jsval_t entries = js_get(js, this_val, "_entries"); 356 356 - if (js_type(entries) != JS_OBJ) return js_mknull(); 357 357 + if (vtype(entries) != T_OBJ) return js_mknull(); 357 358 358 359 jsval_t len_val = js_get(js, entries, "length"); 359 359 - int len = (js_type(len_val) == JS_NUM) ? (int)js_getnum(len_val) : 0; 360 360 + int len = (vtype(len_val) == T_NUM) ? (int)js_getnum(len_val) : 0; 360 361 361 362 for (int i = 0; i < len; i++) { 362 363 char idx[16]; ··· 379 380 380 381 jsval_t result = js_mkarr(js); 381 382 jsval_t entries = js_get(js, this_val, "_entries"); 382 382 - if (js_type(entries) != JS_OBJ) return result; 383 383 + if (vtype(entries) != T_OBJ) return result; 383 384 384 385 jsval_t len_val = js_get(js, entries, "length"); 385 385 - int len = (js_type(len_val) == JS_NUM) ? (int)js_getnum(len_val) : 0; 386 386 + int len = (vtype(len_val) == T_NUM) ? (int)js_getnum(len_val) : 0; 386 387 387 388 for (int i = 0; i < len; i++) { 388 389 char idx[16]; ··· 404 405 if (!key) return js_mkfalse(); 405 406 406 407 jsval_t entries = js_get(js, this_val, "_entries"); 407 407 - if (js_type(entries) != JS_OBJ) return js_mkfalse(); 408 408 + if (vtype(entries) != T_OBJ) return js_mkfalse(); 408 409 409 410 jsval_t len_val = js_get(js, entries, "length"); 410 410 - int len = (js_type(len_val) == JS_NUM) ? (int)js_getnum(len_val) : 0; 411 411 + int len = (vtype(len_val) == T_NUM) ? (int)js_getnum(len_val) : 0; 411 412 412 413 for (int i = 0; i < len; i++) { 413 414 char idx[16]; ··· 422 423 423 424 static void usp_sync_url(struct js *js, jsval_t this_val) { 424 425 jsval_t url_obj = js_get(js, this_val, "_url"); 425 425 - if (js_type(url_obj) != JS_OBJ) return; 426 426 + if (vtype(url_obj) != T_OBJ) return; 426 427 427 428 jsval_t entries = js_get(js, this_val, "_entries"); 428 429 jsval_t len_val = js_get(js, entries, "length"); 429 429 - int len = (js_type(len_val) == JS_NUM) ? (int)js_getnum(len_val) : 0; 430 430 + int len = (vtype(len_val) == T_NUM) ? (int)js_getnum(len_val) : 0; 430 431 431 432 size_t buf_size = 1024; 432 433 char *buf = malloc(buf_size); ··· 467 468 468 469 jsval_t entries = js_get(js, this_val, "_entries"); 469 470 jsval_t len_val = js_get(js, entries, "length"); 470 470 - int len = (js_type(len_val) == JS_NUM) ? (int)js_getnum(len_val) : 0; 471 471 + int len = (vtype(len_val) == T_NUM) ? (int)js_getnum(len_val) : 0; 471 472 472 473 jsval_t new_entries = js_mkarr(js); 473 474 int found = 0; ··· 524 525 525 526 jsval_t entries = js_get(js, this_val, "_entries"); 526 527 jsval_t len_val = js_get(js, entries, "length"); 527 527 - int len = (js_type(len_val) == JS_NUM) ? (int)js_getnum(len_val) : 0; 528 528 + int len = (vtype(len_val) == T_NUM) ? (int)js_getnum(len_val) : 0; 528 529 529 530 jsval_t new_entries = js_mkarr(js); 530 531 for (int i = 0; i < len; i++) { ··· 548 549 jsval_t this_val = js_getthis(js); 549 550 jsval_t entries = js_get(js, this_val, "_entries"); 550 551 jsval_t len_val = js_get(js, entries, "length"); 551 551 - int len = (js_type(len_val) == JS_NUM) ? (int)js_getnum(len_val) : 0; 552 552 + int len = (vtype(len_val) == T_NUM) ? (int)js_getnum(len_val) : 0; 552 553 553 554 size_t buf_size = 1024; 554 555 char *buf = malloc(buf_size); ··· 584 585 jsval_t entries = js_mkarr(js); 585 586 js_set(js, usp, "_entries", entries); 586 587 587 587 - if (nargs < 1 || js_type(args[0]) != JS_STR) goto done_parse; 588 588 + if (nargs < 1 || vtype(args[0]) != T_STR) goto done_parse; 588 589 char *init = js_getstr(js, args[0], NULL); 589 590 if (!init) goto done_parse; 590 591

+4 -3

src/repl.c

reviewed

··· 22 22 #include "repl.h" 23 23 #include "config.h" 24 24 #include "runtime.h" 25 25 + #include "internal.h" 25 26 #include "modules/io.h" 26 27 27 28 #define MAX_HISTORY 512 ··· 119 120 120 121 jsval_t result = js_eval(js, file_buffer, len); 121 122 js_run_event_loop(js); 122 122 - if (js_type(result) == JS_ERR) { 123 123 + if (vtype(result) == T_ERR) { 123 124 fprintf(stderr, "%s\n", js_str(js, result)); 124 124 - } else if (js_type(result) != JS_UNDEF) { 125 125 + } else if (vtype(result) != T_UNDEF) { 125 126 printf("%s\n", js_str(js, result)); 126 127 } 127 128 ··· 609 610 jsval_t eval_result = js_eval(js, multiline_buf, multiline_len); 610 611 js_run_event_loop(js); 611 612 612 612 - if (js_type(eval_result) == JS_ERR) { 613 613 + if (vtype(eval_result) == T_ERR) { 613 614 fprintf(stderr, "%s\n", js_str(js, eval_result)); 614 615 } else { 615 616 const char *str = js_str(js, eval_result);

+13 -11

src/runtime.c

reviewed

··· 91 91 } 92 92 93 93 struct ant_runtime *ant_runtime_init(struct js *js, int argc, char **argv, struct arg_file *ls_p) { 94 94 - runtime.js = js; 95 95 - runtime.ant_obj = js_newobj(js); 96 96 - runtime.flags = 0; 97 97 - 98 98 - runtime.argc = argc; 99 99 - runtime.argv = argv; 100 100 - runtime.ls_fp = ls_p->count > 0 ? ls_p->filename[0] : NULL; 94 94 + runtime = (struct ant_runtime){ 95 95 + .js = js, 96 96 + .ant_obj = js_newobj(js), 97 97 + .flags = 0, 98 98 + .argc = argc, 99 99 + .argv = argv, 100 100 + .ls_fp = (ls_p && ls_p->count > 0) ? ls_p->filename[0] : NULL, 101 101 + }; 101 102 102 102 - js_set(js, js_glob(js), "global", js_glob(js)); 103 103 - js_set(js, js_glob(js), "window", js_glob(js)); 104 104 - js_set(js, js_glob(js), "globalThis", js_glob(js)); 105 105 - js_set(js, js_glob(js), "Ant", runtime.ant_obj); 103 103 + jsval_t global = js_glob(js); 104 104 + js_set(js, global, "global", global); 105 105 + js_set(js, global, "window", global); 106 106 + js_set(js, global, "globalThis", global); 107 107 + js_set(js, global, "Ant", runtime.ant_obj); 106 108 107 109 return &runtime; 108 110 }

+2 -1

src/snapshot.c

reviewed

··· 3 3 #include "ant.h" 4 4 #include "errors.h" 5 5 #include "snapshot.h" 6 6 + #include "internal.h" 6 7 #include "snapshot_data.h" 7 8 8 9 jsval_t ant_load_snapshot(struct js *js) { 9 10 if (!js) return js_mkerr(js, "invalid js runtime"); 10 11 jsval_t result = js_eval(js, (const char *)ant_snapshot_source, ant_snapshot_source_len); 11 12 12 12 - if (js_type(result) == JS_ERR) return result; 13 13 + if (vtype(result) == T_ERR) return result; 13 14 return js_mktrue(); 14 15 } 15 16

+58

tests/test_closure_spec.js

reviewed

··· 1 1 + // test_closure.js - Test closure scoping across async boundaries 2 2 + 3 3 + let results = []; 4 4 + 5 5 + // Test 1: Sync push 6 6 + results.push('1. sync'); 7 7 + 8 8 + // Test 2: setTimeout with closure 9 9 + setTimeout(() => { 10 10 + results.push('4. timeout 50ms'); 11 11 + }, 50); 12 12 + 13 13 + setTimeout(() => { 14 14 + results.push('3. timeout 10ms'); 15 15 + }, 10); 16 16 + 17 17 + // Test 3: Promise with closure 18 18 + Promise.resolve('2. promise').then(v => { 19 19 + results.push(v); 20 20 + }); 21 21 + 22 22 + // Test 4: queueMicrotask with closure 23 23 + queueMicrotask(() => { 24 24 + results.push('2. microtask'); 25 25 + }); 26 26 + 27 27 + // Test 5: Nested closure 28 28 + const outer = 'outer-value'; 29 29 + setTimeout(() => { 30 30 + const inner = 'inner-value'; 31 31 + setTimeout(() => { 32 32 + results.push(`5. nested: ${outer}, ${inner}`); 33 33 + }, 10); 34 34 + }, 60); 35 35 + 36 36 + // Final timeout to print results 37 37 + setTimeout(() => { 38 38 + console.log('Results length:', results.length); 39 39 + console.log('Results:'); 40 40 + for (let i = 0; i < results.length; i++) { 41 41 + console.log(' ', results[i]); 42 42 + } 43 43 + 44 44 + // Expected order: 45 45 + // 1. sync 46 46 + // 2. promise (microtask) 47 47 + // 2. microtask (microtask) 48 48 + // 3. timeout 10ms 49 49 + // 4. timeout 50ms 50 50 + // 5. nested: outer-value, inner-value 51 51 + 52 52 + console.log('\nExpected 6 items, got:', results.length); 53 53 + if (results.length === 6) { 54 54 + console.log('✓ PASS: All closures captured correctly'); 55 55 + } else { 56 56 + console.log('✗ FAIL: Missing items - closure bug'); 57 57 + } 58 58 + }, 200);