themackabu.com / ant
MIRROR: javascript for 🐜's, a tiny runtime with big ambitions
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

unified native tag api

theMackabu 511cdbeb 66c9a6e9

+368 -353
+5
examples/spec/async_iterators.js
··· 44 44 test('AsyncGeneratorFunction constructs async generator function', Object.getPrototypeOf(dynamicAsyncGen), AsyncGeneratorFunction.prototype); 45 45 test('AsyncGeneratorFunction instance uses function prototype', Object.getPrototypeOf(dynamicAsyncIter), dynamicAsyncGen.prototype); 46 46 test('AsyncGeneratorFunction yielded value', (await dynamicAsyncIter.next()).value, 4); 47 + test( 48 + 'strict async generator function expression has own prototype', 49 + Function('"use strict"; return (async function* () {}).hasOwnProperty("prototype");')(), 50 + true 51 + ); 47 52 48 53 class CustomAsyncIterator extends AsyncIterator { 49 54 constructor(values) {
+9 -5
include/object.h
··· 72 72 } ant_private_table_t; 73 73 74 74 typedef struct { 75 + void *ptr; 76 + uint32_t tag; 77 + } ant_native_entry_t; 78 + 79 + typedef struct { 75 80 ant_extra_slot_t *extra_slots; 81 + ant_native_entry_t *native_entries; 76 82 ant_private_table_t private_table; 77 83 ant_proxy_state_t *proxy_state; 78 84 85 + uint8_t native_count; 86 + uint8_t native_cap; 79 87 uint8_t extra_count; 80 88 uint8_t flags; 81 89 } ant_object_sidecar_t; ··· 101 109 102 110 void (*finalizer)(ant_t *, struct ant_object *); 103 111 ant_value_t inobj[ANT_INOBJ_MAX_SLOTS]; 104 - 105 - struct { 106 - void *ptr; 107 - uint32_t tag; 108 - } native; 112 + ant_native_entry_t native; 109 113 110 114 union { 111 115 struct { ant_value_t *data; uint32_t len; uint32_t cap; } array;
+69 -21
include/ptr.h
··· 4 4 #include "types.h" 5 5 #include "internal.h" // IWYU pragma: keep 6 6 7 - static inline void js_set_native_ptr(ant_value_t obj, void *ptr) { 7 + static inline void *js_get_native(ant_value_t obj, uint32_t tag) { 8 8 ant_object_t *o = js_obj_ptr(obj); 9 - if (!o) return; 10 - o->native.ptr = ptr; 9 + 10 + if (!o || !tag) return NULL; 11 + if (o->native.tag == tag) return o->native.ptr; 12 + 13 + ant_object_sidecar_t *sidecar = ant_object_sidecar(o); 14 + if (!sidecar) return NULL; 15 + 16 + for (uint8_t i = 0; i < sidecar->native_count; i++) 17 + if (sidecar->native_entries[i].tag == tag) return sidecar->native_entries[i].ptr; 18 + 19 + return NULL; 11 20 } 12 21 13 - static inline void *js_get_native_ptr(ant_value_t obj) { 22 + static inline void js_clear_native(ant_value_t obj, uint32_t tag) { 14 23 ant_object_t *o = js_obj_ptr(obj); 15 - return o ? o->native.ptr : NULL; 16 - } 24 + if (!o || !tag) return; 25 + 26 + ant_object_sidecar_t *sidecar = ant_object_sidecar(o); 27 + if (o->native.tag == tag) { 28 + if (sidecar && sidecar->native_count > 0) { 29 + sidecar->native_count--; 30 + o->native = sidecar->native_entries[sidecar->native_count]; 31 + } else { 32 + o->native.ptr = NULL; 33 + o->native.tag = 0; 34 + } 35 + return; 36 + } 17 37 18 - static inline void js_set_native_tag(ant_value_t obj, uint32_t tag) { 19 - ant_object_t *o = js_obj_ptr(obj); 20 - if (!o) return; 21 - o->native.tag = tag; 38 + if (!sidecar) return; 39 + for (uint8_t i = 0; i < sidecar->native_count; i++) { 40 + if (sidecar->native_entries[i].tag != tag) continue; 41 + sidecar->native_count--; 42 + sidecar->native_entries[i] = sidecar->native_entries[sidecar->native_count]; 43 + return; 44 + } 22 45 } 23 46 24 47 static inline void js_set_native(ant_value_t obj, void *ptr, uint32_t tag) { 25 48 ant_object_t *o = js_obj_ptr(obj); 26 - if (!o) return; 27 - o->native.ptr = ptr; 28 - o->native.tag = tag; 29 - } 49 + if (!o || !tag) return; 50 + 51 + if (o->native.tag == 0 || o->native.tag == tag) { 52 + o->native.ptr = ptr; 53 + o->native.tag = tag; 54 + return; 55 + } 56 + 57 + ant_object_sidecar_t *sidecar = ant_object_ensure_sidecar(o); 58 + if (!sidecar) return; 59 + 60 + for (uint8_t i = 0; i < sidecar->native_count; i++) { 61 + if (sidecar->native_entries[i].tag != tag) continue; 62 + sidecar->native_entries[i].ptr = ptr; 63 + return; 64 + } 65 + 66 + if (sidecar->native_count >= sidecar->native_cap) { 67 + uint8_t next_cap = sidecar->native_cap ? (uint8_t)(sidecar->native_cap * 2) : 2; 68 + ant_native_entry_t *next = realloc(sidecar->native_entries, next_cap * sizeof(*next)); 69 + 70 + if (!next) return; 71 + sidecar->native_entries = next; 72 + sidecar->native_cap = next_cap; 73 + } 30 74 31 - static inline void js_clear_native(ant_value_t obj) { 32 - js_set_native(obj, NULL, 0); 75 + sidecar->native_entries[sidecar->native_count++] = (ant_native_entry_t){ ptr, tag }; 33 76 } 34 77 35 - static inline uint32_t js_get_native_tag(ant_value_t obj) { 78 + static inline bool js_check_native_tag(ant_value_t obj, uint32_t tag) { 36 79 ant_object_t *o = js_obj_ptr(obj); 37 - return o ? o->native.tag : 0; 38 - } 80 + 81 + if (!o || !tag) return false; 82 + if (o->native.tag == tag) return true; 39 83 84 + ant_object_sidecar_t *sidecar = ant_object_sidecar(o); 85 + if (!sidecar) return false; 86 + 87 + for (uint8_t i = 0; i < sidecar->native_count; i++) 88 + if (sidecar->native_entries[i].tag == tag) return true; 40 89 41 - static inline bool js_check_native_tag(ant_value_t obj, uint32_t tag) { 42 - return js_get_native_tag(obj) == tag; 90 + return false; 43 91 } 44 92 45 93 #endif
+5 -7
src/ant.c
··· 2745 2745 2746 2746 static inline ant_arguments_state_t *js_arguments_state(ant_value_t obj) { 2747 2747 if (!js_check_native_tag(obj, ANT_ARGUMENTS_NATIVE_TAG)) return NULL; 2748 - return (ant_arguments_state_t *)js_get_native_ptr(obj); 2748 + return (ant_arguments_state_t *)js_get_native(obj, ANT_ARGUMENTS_NATIVE_TAG); 2749 2749 } 2750 2750 2751 2751 static ant_value_t js_arguments_getter(ant_t *js, ant_value_t obj, const char *key, size_t key_len) { ··· 2801 2801 } 2802 2802 2803 2803 static void js_arguments_finalizer(ant_t *js, ant_object_t *obj) { 2804 - if (!obj || obj->native.tag != ANT_ARGUMENTS_NATIVE_TAG) return; 2805 - free(obj->native.ptr); 2806 - obj->native.ptr = NULL; 2807 - obj->native.tag = 0; 2804 + ant_value_t value = js_obj_from_ptr(obj); 2805 + free(js_get_native(value, ANT_ARGUMENTS_NATIVE_TAG)); 2806 + js_clear_native(value, ANT_ARGUMENTS_NATIVE_TAG); 2808 2807 } 2809 2808 2810 2809 ant_value_t js_create_arguments_object( ··· 2849 2848 state->frame_index = (int)(frame - js->vm->frames); 2850 2849 state->mapped_count = (uint32_t)mapped_count; 2851 2850 2852 - js_set_native_ptr(arr, state); 2853 - js_set_native_tag(arr, ANT_ARGUMENTS_NATIVE_TAG); 2851 + js_set_native(arr, state, ANT_ARGUMENTS_NATIVE_TAG); 2854 2852 js_set_finalizer(arr, js_arguments_finalizer); 2855 2853 js_set_getter(arr, js_arguments_getter); 2856 2854 js_set_setter(arr, js_arguments_setter);
+43 -31
src/gc/objects.c
··· 1 + #include "ptr.h" 2 + #include "sugar.h" 3 + #include "shapes.h" 4 + #include "runtime.h" 1 5 #include "internal.h" 6 + 7 + #include "silver/engine.h" 8 + #include "modules/regex.h" 9 + #include "modules/generator.h" 10 + #include "modules/collections.h" 11 + 2 12 #include "gc.h" 3 13 #include "gc/objects.h" 4 14 #include "gc/roots.h" 5 15 #include "gc/modules.h" 6 - #include "sugar.h" 7 - #include "silver/engine.h" 8 - #include "shapes.h" 9 - #include "runtime.h" 10 - #include "modules/collections.h" 11 - #include "modules/generator.h" 12 - #include "modules/regex.h" 13 16 14 17 #include <stdlib.h> 15 18 #include <string.h> ··· 245 248 } 246 249 247 250 if (obj->type_tag == T_MAP) { 248 - map_entry_t **head = obj->native.tag == MAP_NATIVE_TAG 249 - ? (map_entry_t **)obj->native.ptr : NULL; 251 + ant_value_t value = js_obj_from_ptr(obj); 252 + map_entry_t **head = (map_entry_t **)js_get_native(value, MAP_NATIVE_TAG); 250 253 if (head) { 251 254 map_entry_t *e, *tmp; 252 255 HASH_ITER(hh, *head, e, tmp) { ··· 256 259 } 257 260 258 261 else if (obj->type_tag == T_WEAKMAP) { 259 - weakmap_entry_t **head = obj->native.tag == WEAKMAP_NATIVE_TAG 260 - ? (weakmap_entry_t **)obj->native.ptr : NULL; 262 + ant_value_t value = js_obj_from_ptr(obj); 263 + weakmap_entry_t **head = (weakmap_entry_t **)js_get_native(value, WEAKMAP_NATIVE_TAG); 261 264 if (head) { 262 265 weakmap_entry_t *e, *tmp; 263 266 HASH_ITER(hh, *head, e, tmp) { ··· 267 270 } 268 271 269 272 else if (obj->type_tag == T_SET) { 270 - set_entry_t **head = obj->native.tag == SET_NATIVE_TAG 271 - ? (set_entry_t **)obj->native.ptr : NULL; 273 + ant_value_t value = js_obj_from_ptr(obj); 274 + set_entry_t **head = (set_entry_t **)js_get_native(value, SET_NATIVE_TAG); 272 275 if (head) { 273 276 set_entry_t *e, *tmp; 274 277 HASH_ITER(hh, *head, e, tmp) { gc_mark_value(js, e->value); } ··· 568 571 obj->shape = NULL; 569 572 } 570 573 571 - if (ant_object_has_sidecar(obj)) { 572 - ant_object_sidecar_t *sidecar = ant_object_sidecar(obj); 573 - free(sidecar->extra_slots); 574 - free(sidecar->proxy_state); 575 - free(sidecar->private_table.entries); 576 - free(sidecar); 577 - obj->extra_slots = NULL; 578 - } 579 - 580 - else if (obj->extra_slots) { 581 - free(obj->extra_slots); 582 - obj->extra_slots = NULL; 583 - } 584 - 585 574 if (obj->promise_state && obj->promise_state->gc_pending_rooted) 586 575 gc_unroot_pending_promise(obj); 587 576 ··· 599 588 600 589 switch (obj->type_tag) { 601 590 case T_MAP: { 602 - map_entry_t **head = obj->native.tag == MAP_NATIVE_TAG ? (map_entry_t **)obj->native.ptr : NULL; 591 + ant_value_t value = js_obj_from_ptr(obj); 592 + map_entry_t **head = (map_entry_t **)js_get_native(value, MAP_NATIVE_TAG); 603 593 if (head) { 604 594 map_entry_t *e, *tmp; 605 595 HASH_ITER(hh, *head, e, tmp) { HASH_DEL(*head, e); free(e->key); free(e); } 606 596 free(head); 597 + js_clear_native(value, MAP_NATIVE_TAG); 607 598 } 608 599 break; 609 600 } 610 601 case T_SET: { 611 - set_entry_t **head = obj->native.tag == SET_NATIVE_TAG ? (set_entry_t **)obj->native.ptr : NULL; 602 + ant_value_t value = js_obj_from_ptr(obj); 603 + set_entry_t **head = (set_entry_t **)js_get_native(value, SET_NATIVE_TAG); 612 604 if (head) { 613 605 set_entry_t *e, *tmp; 614 606 HASH_ITER(hh, *head, e, tmp) { HASH_DEL(*head, e); free(e->key); free(e); } 615 607 free(head); 608 + js_clear_native(value, SET_NATIVE_TAG); 616 609 } 617 610 break; 618 611 } 619 612 case T_WEAKMAP: { 620 - weakmap_entry_t **head = obj->native.tag == WEAKMAP_NATIVE_TAG ? (weakmap_entry_t **)obj->native.ptr : NULL; 613 + ant_value_t value = js_obj_from_ptr(obj); 614 + weakmap_entry_t **head = (weakmap_entry_t **)js_get_native(value, WEAKMAP_NATIVE_TAG); 621 615 if (head) { 622 616 weakmap_entry_t *e, *tmp; 623 617 HASH_ITER(hh, *head, e, tmp) { HASH_DEL(*head, e); free(e); } 624 618 free(head); 619 + js_clear_native(value, WEAKMAP_NATIVE_TAG); 625 620 } 626 621 break; 627 622 } 628 623 case T_WEAKSET: { 629 - weakset_entry_t **head = obj->native.tag == WEAKSET_NATIVE_TAG ? (weakset_entry_t **)obj->native.ptr : NULL; 624 + ant_value_t value = js_obj_from_ptr(obj); 625 + weakset_entry_t **head = (weakset_entry_t **)js_get_native(value, WEAKSET_NATIVE_TAG); 630 626 if (head) { 631 627 weakset_entry_t *e, *tmp; 632 628 HASH_ITER(hh, *head, e, tmp) { HASH_DEL(*head, e); free(e); } 633 629 free(head); 630 + js_clear_native(value, WEAKSET_NATIVE_TAG); 634 631 } 635 632 break; 636 633 } 637 634 default: break; 635 + } 636 + 637 + if (ant_object_has_sidecar(obj)) { 638 + ant_object_sidecar_t *sidecar = ant_object_sidecar(obj); 639 + free(sidecar->extra_slots); 640 + free(sidecar->native_entries); 641 + free(sidecar->proxy_state); 642 + free(sidecar->private_table.entries); 643 + free(sidecar); 644 + obj->extra_slots = NULL; 645 + } 646 + 647 + else if (obj->extra_slots) { 648 + free(obj->extra_slots); 649 + obj->extra_slots = NULL; 638 650 } 639 651 640 652 free(obj->overflow_prop);
+1 -1
src/modules/abort.c
··· 53 53 54 54 static abort_signal_data_t *get_signal_data(ant_value_t obj) { 55 55 if (!js_check_native_tag(obj, ABORT_SIGNAL_NATIVE_TAG)) return NULL; 56 - return (abort_signal_data_t *)js_get_native_ptr(obj); 56 + return (abort_signal_data_t *)js_get_native(obj, ABORT_SIGNAL_NATIVE_TAG); 57 57 } 58 58 59 59 static abort_signal_data_t *get_signal_data_if_signal_object(ant_value_t obj) {
+4 -5
src/modules/blob.c
··· 30 30 31 31 blob_data_t *blob_get_data(ant_value_t obj) { 32 32 if (!js_check_native_tag(obj, BLOB_NATIVE_TAG)) return NULL; 33 - return (blob_data_t *)js_get_native_ptr(obj); 33 + return (blob_data_t *)js_get_native(obj, BLOB_NATIVE_TAG); 34 34 } 35 35 36 36 static blob_data_t *blob_data_new(const uint8_t *data, size_t size, const char *type) { ··· 152 152 } 153 153 154 154 static void blob_finalize(ant_t *js, ant_object_t *obj) { 155 - if (!obj || obj->native.tag != BLOB_NATIVE_TAG) return; 156 - blob_data_t *bd = (blob_data_t *)obj->native.ptr; 155 + ant_value_t value = js_obj_from_ptr(obj); 156 + blob_data_t *bd = (blob_data_t *)js_get_native(value, BLOB_NATIVE_TAG); 157 157 if (bd) { free(bd->data); free(bd->type); free(bd->name); free(bd); } 158 - obj->native.ptr = NULL; 159 - obj->native.tag = 0; 158 + js_clear_native(value, BLOB_NATIVE_TAG); 160 159 } 161 160 162 161 ant_value_t blob_create(ant_t *js, const uint8_t *data, size_t size, const char *type) {
+17 -28
src/modules/buffer.c
··· 57 57 ArrayBufferData *buffer_get_arraybuffer_data(ant_value_t value) { 58 58 if (!is_object_type(value) || buffer_is_dataview(value)) return NULL; 59 59 if (js_check_native_tag(value, BUFFER_ARRAYBUFFER_NATIVE_TAG)) 60 - return (ArrayBufferData *)js_get_native_ptr(value); 60 + return (ArrayBufferData *)js_get_native(value, BUFFER_ARRAYBUFFER_NATIVE_TAG); 61 61 return NULL; 62 62 } 63 63 ··· 66 66 return (TypedArrayData *)js_gettypedarray(value); 67 67 if (!is_object_type(value)) return NULL; 68 68 if (js_check_native_tag(value, BUFFER_TYPEDARRAY_NATIVE_TAG)) 69 - return (TypedArrayData *)js_get_native_ptr(value); 69 + return (TypedArrayData *)js_get_native(value, BUFFER_TYPEDARRAY_NATIVE_TAG); 70 70 return NULL; 71 71 } 72 72 73 73 DataViewData *buffer_get_dataview_data(ant_value_t value) { 74 74 if (!is_object_type(value)) return NULL; 75 75 if (js_check_native_tag(value, BUFFER_DATAVIEW_NATIVE_TAG)) 76 - return (DataViewData *)js_get_native_ptr(value); 76 + return (DataViewData *)js_get_native(value, BUFFER_DATAVIEW_NATIVE_TAG); 77 77 return NULL; 78 78 } 79 79 80 80 static void arraybuffer_finalize(ant_t *js, ant_object_t *obj) { 81 81 ant_value_t value = js_obj_from_ptr(obj); 82 82 if (!js_check_native_tag(value, BUFFER_ARRAYBUFFER_NATIVE_TAG)) return; 83 - ArrayBufferData *data = (ArrayBufferData *)js_get_native_ptr(value); 84 - js_set_native_ptr(value, NULL); 85 - js_set_native_tag(value, 0); 83 + ArrayBufferData *data = (ArrayBufferData *)js_get_native(value, BUFFER_ARRAYBUFFER_NATIVE_TAG); 84 + js_clear_native(value, BUFFER_ARRAYBUFFER_NATIVE_TAG); 86 85 if (data) free_array_buffer_data(data); 87 86 } 88 87 89 88 static void typedarray_finalize(ant_t *js, ant_object_t *obj) { 90 89 ant_value_t value = js_obj_from_ptr(obj); 91 90 if (!js_check_native_tag(value, BUFFER_TYPEDARRAY_NATIVE_TAG)) return; 92 - TypedArrayData *ta_data = (TypedArrayData *)js_get_native_ptr(value); 93 - js_set_native_ptr(value, NULL); 94 - js_set_native_tag(value, 0); 91 + TypedArrayData *ta_data = (TypedArrayData *)js_get_native(value, BUFFER_TYPEDARRAY_NATIVE_TAG); 92 + js_clear_native(value, BUFFER_TYPEDARRAY_NATIVE_TAG); 95 93 if (!ta_data) return; 96 94 97 95 if (ta_data->buffer) free_array_buffer_data(ta_data->buffer); ··· 101 99 static void dataview_finalize(ant_t *js, ant_object_t *obj) { 102 100 ant_value_t value = js_obj_from_ptr(obj); 103 101 if (!js_check_native_tag(value, BUFFER_DATAVIEW_NATIVE_TAG)) return; 104 - DataViewData *dv_data = (DataViewData *)js_get_native_ptr(value); 105 - js_set_native_ptr(value, NULL); 106 - js_set_native_tag(value, 0); 102 + DataViewData *dv_data = (DataViewData *)js_get_native(value, BUFFER_DATAVIEW_NATIVE_TAG); 103 + js_clear_native(value, BUFFER_DATAVIEW_NATIVE_TAG); 107 104 if (!dv_data) return; 108 105 109 106 if (dv_data->buffer) free_array_buffer_data(dv_data->buffer); ··· 386 383 ant_value_t proto = js_get_ctor_proto(js, "ArrayBuffer", 11); 387 384 388 385 if (is_special_object(proto)) js_set_proto_init(obj, proto); 389 - js_set_native_ptr(obj, data); 390 - js_set_native_tag(obj, BUFFER_ARRAYBUFFER_NATIVE_TAG); 386 + js_set_native(obj, data, BUFFER_ARRAYBUFFER_NATIVE_TAG); 391 387 js_set(js, obj, "byteLength", js_mknum((double)length)); 392 388 js_set_finalizer(obj, arraybuffer_finalize); 393 389 ··· 420 416 ant_value_t proto = js_get_ctor_proto(js, "ArrayBuffer", 11); 421 417 422 418 if (is_special_object(proto)) js_set_proto_init(new_obj, proto); 423 - js_set_native_ptr(new_obj, new_data); 424 - js_set_native_tag(new_obj, BUFFER_ARRAYBUFFER_NATIVE_TAG); 419 + js_set_native(new_obj, new_data, BUFFER_ARRAYBUFFER_NATIVE_TAG); 425 420 js_set(js, new_obj, "byteLength", js_mknum((double)new_length)); 426 421 js_set_finalizer(new_obj, arraybuffer_finalize); 427 422 ··· 461 456 ant_value_t proto = js_get_ctor_proto(js, "ArrayBuffer", 11); 462 457 463 458 if (is_special_object(proto)) js_set_proto_init(new_obj, proto); 464 - js_set_native_ptr(new_obj, new_data); 465 - js_set_native_tag(new_obj, BUFFER_ARRAYBUFFER_NATIVE_TAG); 459 + js_set_native(new_obj, new_data, BUFFER_ARRAYBUFFER_NATIVE_TAG); 466 460 js_set(js, new_obj, "byteLength", js_mknum((double)new_length)); 467 461 js_set_finalizer(new_obj, arraybuffer_finalize); 468 462 ··· 663 657 ant_value_t ab_proto = js_get_ctor_proto(js, "ArrayBuffer", 11); 664 658 if (is_special_object(ab_proto)) js_set_proto_init(ab_obj, ab_proto); 665 659 666 - js_set_native_ptr(ab_obj, buffer); 667 - js_set_native_tag(ab_obj, BUFFER_ARRAYBUFFER_NATIVE_TAG); 660 + js_set_native(ab_obj, buffer, BUFFER_ARRAYBUFFER_NATIVE_TAG); 668 661 js_set(js, ab_obj, "byteLength", js_mknum((double)buffer->length)); 669 662 js_set_finalizer(ab_obj, arraybuffer_finalize); 670 663 buffer->ref_count++; ··· 691 684 ant_value_t proto = js_get_ctor_proto(js, type_name, strlen(type_name)); 692 685 if (is_special_object(proto)) js_set_proto_init(obj, proto); 693 686 694 - js_set_native_ptr(obj, ta_data); 695 - js_set_native_tag(obj, BUFFER_TYPEDARRAY_NATIVE_TAG); 687 + js_set_native(obj, ta_data, BUFFER_TYPEDARRAY_NATIVE_TAG); 696 688 js_set(js, obj, "length", js_mknum((double)length)); 697 689 js_set(js, obj, "byteLength", js_mknum((double)(length * element_size))); 698 690 js_set(js, obj, "byteOffset", js_mknum((double)byte_offset)); ··· 732 724 ant_value_t proto = js_get_ctor_proto(js, "DataView", 8); 733 725 if (is_special_object(proto)) js_set_proto_init(obj, proto); 734 726 735 - js_set_native_ptr(obj, dv_data); 736 - js_set_native_tag(obj, BUFFER_DATAVIEW_NATIVE_TAG); 727 + js_set_native(obj, dv_data, BUFFER_DATAVIEW_NATIVE_TAG); 737 728 js_set_slot(obj, SLOT_BRAND, js_mknum(BRAND_DATAVIEW)); 738 729 js_mkprop_fast(js, obj, "buffer", 6, arraybuffer_obj); 739 730 js_set_descriptor(js, obj, "buffer", 6, 0); ··· 1435 1426 ant_value_t proto = js_get_ctor_proto(js, "DataView", 8); 1436 1427 if (is_special_object(proto)) js_set_proto_init(obj, proto); 1437 1428 1438 - js_set_native_ptr(obj, dv_data); 1439 - js_set_native_tag(obj, BUFFER_DATAVIEW_NATIVE_TAG); 1429 + js_set_native(obj, dv_data, BUFFER_DATAVIEW_NATIVE_TAG); 1440 1430 js_set_slot(obj, SLOT_BRAND, js_mknum(BRAND_DATAVIEW)); 1441 1431 js_mkprop_fast(js, obj, "buffer", 6, args[0]); 1442 1432 js_set_descriptor(js, obj, "buffer", 6, 0); ··· 2880 2870 ant_value_t proto = js_get_ctor_proto(js, "SharedArrayBuffer", 17); 2881 2871 2882 2872 if (is_special_object(proto)) js_set_proto_init(obj, proto); 2883 - js_set_native_ptr(obj, data); 2884 - js_set_native_tag(obj, BUFFER_ARRAYBUFFER_NATIVE_TAG); 2873 + js_set_native(obj, data, BUFFER_ARRAYBUFFER_NATIVE_TAG); 2885 2874 js_set(js, obj, "byteLength", js_mknum((double)length)); 2886 2875 js_set_finalizer(obj, arraybuffer_finalize); 2887 2876
+2 -2
src/modules/child_process.c
··· 117 117 118 118 static child_process_t *get_child_process(ant_value_t obj) { 119 119 if (!js_check_native_tag(obj, CHILD_PROCESS_NATIVE_TAG)) return NULL; 120 - return (child_process_t *)js_get_native_ptr(obj); 120 + return (child_process_t *)js_get_native(obj, CHILD_PROCESS_NATIVE_TAG); 121 121 } 122 122 123 123 static child_stream_ctx_t *get_child_stream_ctx(ant_value_t obj) { 124 124 if (!js_check_native_tag(obj, CHILD_STREAM_NATIVE_TAG)) return NULL; 125 - return (child_stream_ctx_t *)js_get_native_ptr(obj); 125 + return (child_stream_ctx_t *)js_get_native(obj, CHILD_STREAM_NATIVE_TAG); 126 126 } 127 127 static child_process_t *pending_children_tail = NULL; 128 128
+6 -6
src/modules/collections.c
··· 310 310 ant_object_t *ptr = js_obj_ptr(obj); 311 311 if (!ptr || ptr->type_tag != T_MAP) return NULL; 312 312 if (!js_check_native_tag(obj, MAP_NATIVE_TAG)) return NULL; 313 - return (map_entry_t **)js_get_native_ptr(obj); 313 + return (map_entry_t **)js_get_native(obj, MAP_NATIVE_TAG); 314 314 } 315 315 316 316 set_entry_t **get_set_from_obj(ant_value_t obj) { 317 317 ant_object_t *ptr = js_obj_ptr(obj); 318 318 if (!ptr || ptr->type_tag != T_SET) return NULL; 319 319 if (!js_check_native_tag(obj, SET_NATIVE_TAG)) return NULL; 320 - return (set_entry_t **)js_get_native_ptr(obj); 320 + return (set_entry_t **)js_get_native(obj, SET_NATIVE_TAG); 321 321 } 322 322 323 323 static weakmap_entry_t **get_weakmap_from_obj(ant_value_t obj) { 324 324 ant_object_t *ptr = js_obj_ptr(obj); 325 325 if (!ptr || ptr->type_tag != T_WEAKMAP) return NULL; 326 326 if (!js_check_native_tag(obj, WEAKMAP_NATIVE_TAG)) return NULL; 327 - return (weakmap_entry_t **)js_get_native_ptr(obj); 327 + return (weakmap_entry_t **)js_get_native(obj, WEAKMAP_NATIVE_TAG); 328 328 } 329 329 330 330 static weakset_entry_t **get_weakset_from_obj(ant_value_t obj) { 331 331 ant_object_t *ptr = js_obj_ptr(obj); 332 332 if (!ptr || ptr->type_tag != T_WEAKSET) return NULL; 333 333 if (!js_check_native_tag(obj, WEAKSET_NATIVE_TAG)) return NULL; 334 - return (weakset_entry_t **)js_get_native_ptr(obj); 334 + return (weakset_entry_t **)js_get_native(obj, WEAKSET_NATIVE_TAG); 335 335 } 336 336 337 337 map_iterator_state_t *get_map_iter_state(ant_value_t obj) { 338 338 if (!js_check_native_tag(obj, MAP_ITER_NATIVE_TAG)) return NULL; 339 - return (map_iterator_state_t *)js_get_native_ptr(obj); 339 + return (map_iterator_state_t *)js_get_native(obj, MAP_ITER_NATIVE_TAG); 340 340 } 341 341 342 342 set_iterator_state_t *get_set_iter_state(ant_value_t obj) { 343 343 if (!js_check_native_tag(obj, SET_ITER_NATIVE_TAG)) return NULL; 344 - return (set_iterator_state_t *)js_get_native_ptr(obj); 344 + return (set_iterator_state_t *)js_get_native(obj, SET_ITER_NATIVE_TAG); 345 345 } 346 346 347 347 static ant_value_t map_set(ant_t *js, ant_value_t *args, int nargs) {
+1 -1
src/modules/crypto.c
··· 223 223 224 224 static ant_hash_state_t *crypto_get_hash_state(ant_value_t value) { 225 225 if (!js_check_native_tag(value, CRYPTO_HASH_NATIVE_TAG)) return NULL; 226 - ant_hash_state_t *state = (ant_hash_state_t *)js_get_native_ptr(value); 226 + ant_hash_state_t *state = (ant_hash_state_t *)js_get_native(value, CRYPTO_HASH_NATIVE_TAG); 227 227 return (state && state->ctx) ? state : NULL; 228 228 } 229 229
+2 -2
src/modules/events.c
··· 42 42 43 43 static event_data_t *get_event_data(ant_value_t obj) { 44 44 if (!js_check_native_tag(obj, EVENT_NATIVE_TAG)) return NULL; 45 - return (event_data_t *)js_get_native_ptr(obj); 45 + return (event_data_t *)js_get_native(obj, EVENT_NATIVE_TAG); 46 46 } 47 47 48 48 static double get_timestamp_ms(void) { ··· 169 169 js_set_native(this_obj, events, EVENT_EMITTER_NATIVE_TAG); 170 170 return events; 171 171 } 172 - return (EventType **)js_get_native_ptr(this_obj); 172 + return (EventType **)js_get_native(this_obj, EVENT_EMITTER_NATIVE_TAG); 173 173 } 174 174 175 175 static EventType *find_or_create_global_event_type(ant_t *js, ant_value_t js_key) {
+3 -3
src/modules/fetch.c
··· 658 658 659 659 static ant_value_t fetch_upload_on_reject(ant_t *js, ant_value_t *args, int nargs) { 660 660 fetch_request_t *req = js_check_native_tag(js->current_func, FETCH_REQUEST_NATIVE_TAG) 661 - ? (fetch_request_t *)js_get_native_ptr(js->current_func) 661 + ? (fetch_request_t *)js_get_native(js->current_func, FETCH_REQUEST_NATIVE_TAG) 662 662 : NULL; 663 663 ant_value_t reason = (nargs > 0) ? args[0] : js_mkundef(); 664 664 ··· 678 678 static void fetch_upload_schedule_next_read(fetch_request_t *req); 679 679 static ant_value_t fetch_upload_on_read(ant_t *js, ant_value_t *args, int nargs) { 680 680 fetch_request_t *req = js_check_native_tag(js->current_func, FETCH_REQUEST_NATIVE_TAG) 681 - ? (fetch_request_t *)js_get_native_ptr(js->current_func) 681 + ? (fetch_request_t *)js_get_native(js->current_func, FETCH_REQUEST_NATIVE_TAG) 682 682 : NULL; 683 683 684 684 ant_value_t result = (nargs > 0) ? args[0] : js_mkundef(); ··· 839 839 840 840 static ant_value_t fetch_abort_listener(ant_t *js, ant_value_t *args, int nargs) { 841 841 fetch_request_t *req = js_check_native_tag(js->current_func, FETCH_REQUEST_NATIVE_TAG) 842 - ? (fetch_request_t *)js_get_native_ptr(js->current_func) 842 + ? (fetch_request_t *)js_get_native(js->current_func, FETCH_REQUEST_NATIVE_TAG) 843 843 : NULL; 844 844 ant_value_t signal = 0; 845 845 ant_value_t reason = 0;
+20 -28
src/modules/ffi.c
··· 347 347 348 348 static ffi_library_handle_t *ffi_library_data(ant_value_t value) { 349 349 if (!js_check_native_tag(value, FFI_LIBRARY_NATIVE_TAG)) return NULL; 350 - return (ffi_library_handle_t *)js_get_native_ptr(value); 350 + return (ffi_library_handle_t *)js_get_native(value, FFI_LIBRARY_NATIVE_TAG); 351 351 } 352 352 353 353 static ffi_function_handle_t *ffi_function_data(ant_value_t value) { 354 354 if (!js_check_native_tag(value, FFI_FUNCTION_NATIVE_TAG)) return NULL; 355 - return (ffi_function_handle_t *)js_get_native_ptr(value); 355 + return (ffi_function_handle_t *)js_get_native(value, FFI_FUNCTION_NATIVE_TAG); 356 356 } 357 357 358 358 static ffi_pointer_handle_t *ffi_pointer_data(ant_value_t value) { 359 359 if (!js_check_native_tag(value, FFI_POINTER_NATIVE_TAG)) return NULL; 360 - return (ffi_pointer_handle_t *)js_get_native_ptr(value); 360 + return (ffi_pointer_handle_t *)js_get_native(value, FFI_POINTER_NATIVE_TAG); 361 361 } 362 362 363 363 static ffi_callback_handle_t *ffi_callback_data(ant_value_t value) { 364 364 if (!js_check_native_tag(value, FFI_CALLBACK_NATIVE_TAG)) return NULL; 365 - return (ffi_callback_handle_t *)js_get_native_ptr(value); 365 + return (ffi_callback_handle_t *)js_get_native(value, FFI_CALLBACK_NATIVE_TAG); 366 366 } 367 367 368 368 static void ffi_library_close_handle(ffi_library_handle_t *library) { ··· 470 470 if (region) region->ref_count++; 471 471 472 472 if (g_ffi_pointer_proto) js_set_proto_init(obj, g_ffi_pointer_proto); 473 - js_set_native_ptr(obj, handle); 474 - js_set_native_tag(obj, FFI_POINTER_NATIVE_TAG); 473 + js_set_native(obj, handle, FFI_POINTER_NATIVE_TAG); 475 474 js_set_finalizer(obj, ffi_pointer_finalize); 476 475 477 476 return obj; ··· 773 772 774 773 if (g_ffi_function_proto) js_set_proto_init(obj, g_ffi_function_proto); 775 774 js_set_slot(obj, SLOT_CFUNC, js_mkfun(ffi_function_call)); 776 - js_set_native_ptr(obj, handle); 777 - js_set_native_tag(obj, FFI_FUNCTION_NATIVE_TAG); 775 + js_set_native(obj, handle, FFI_FUNCTION_NATIVE_TAG); 778 776 js_set_slot_wb(js, obj, SLOT_ENTRIES, library ? library->obj : js_mkundef()); 779 777 js_set_finalizer(obj, ffi_function_finalize); 780 778 ··· 784 782 785 783 void ffi_library_finalize(ant_t *js, ant_object_t *obj) { 786 784 ffi_library_handle_t *library; 787 - if (obj->native.tag != FFI_LIBRARY_NATIVE_TAG) return; 785 + ant_value_t value = js_obj_from_ptr(obj); 788 786 789 - library = (ffi_library_handle_t *)obj->native.ptr; 787 + library = (ffi_library_handle_t *)js_get_native(value, FFI_LIBRARY_NATIVE_TAG); 790 788 if (!library) return; 791 789 792 790 ffi_library_close_handle(library); 793 791 free(library->path); 794 792 free(library); 795 - obj->native.ptr = NULL; 796 - obj->native.tag = 0; 793 + js_clear_native(value, FFI_LIBRARY_NATIVE_TAG); 797 794 } 798 795 799 796 void ffi_function_finalize(ant_t *js, ant_object_t *obj) { 800 797 ffi_function_handle_t *handle; 801 - if (obj->native.tag != FFI_FUNCTION_NATIVE_TAG) return; 798 + ant_value_t value = js_obj_from_ptr(obj); 802 799 803 - handle = (ffi_function_handle_t *)obj->native.ptr; 800 + handle = (ffi_function_handle_t *)js_get_native(value, FFI_FUNCTION_NATIVE_TAG); 804 801 if (!handle) return; 805 802 806 803 free(handle->symbol_name); 807 804 ffi_signature_cleanup(&handle->signature); 808 805 free(handle); 809 - obj->native.ptr = NULL; 810 - obj->native.tag = 0; 806 + js_clear_native(value, FFI_FUNCTION_NATIVE_TAG); 811 807 } 812 808 813 809 void ffi_pointer_finalize(ant_t *js, ant_object_t *obj) { 814 810 ffi_pointer_handle_t *handle; 815 - if (obj->native.tag != FFI_POINTER_NATIVE_TAG) return; 811 + ant_value_t value = js_obj_from_ptr(obj); 816 812 817 - handle = (ffi_pointer_handle_t *)obj->native.ptr; 813 + handle = (ffi_pointer_handle_t *)js_get_native(value, FFI_POINTER_NATIVE_TAG); 818 814 if (!handle) return; 819 815 820 816 ffi_pointer_close_handle(handle, false); 821 817 free(handle); 822 - obj->native.ptr = NULL; 823 - obj->native.tag = 0; 818 + js_clear_native(value, FFI_POINTER_NATIVE_TAG); 824 819 } 825 820 826 821 void ffi_callback_finalize(ant_t *js, ant_object_t *obj) { 827 822 ffi_callback_handle_t *handle; 828 - if (obj->native.tag != FFI_CALLBACK_NATIVE_TAG) return; 823 + ant_value_t value = js_obj_from_ptr(obj); 829 824 830 - handle = (ffi_callback_handle_t *)obj->native.ptr; 825 + handle = (ffi_callback_handle_t *)js_get_native(value, FFI_CALLBACK_NATIVE_TAG); 831 826 if (!handle) return; 832 827 833 828 ffi_callback_close_handle(handle); 834 829 free(handle); 835 - obj->native.ptr = NULL; 836 - obj->native.tag = 0; 830 + js_clear_native(value, FFI_CALLBACK_NATIVE_TAG); 837 831 } 838 832 839 833 static bool ffi_callback_result_to_c( ··· 1003 997 obj = js_mkobj(js); 1004 998 if (g_ffi_library_proto) js_set_proto_init(obj, g_ffi_library_proto); 1005 999 library->obj = obj; 1006 - js_set_native_ptr(obj, library); 1007 - js_set_native_tag(obj, FFI_LIBRARY_NATIVE_TAG); 1000 + js_set_native(obj, library, FFI_LIBRARY_NATIVE_TAG); 1008 1001 js_set_finalizer(obj, ffi_library_finalize); 1009 1002 return obj; 1010 1003 } ··· 1402 1395 callback->owner_obj = obj; 1403 1396 callback->owner_thread = pthread_self(); 1404 1397 callback->closed = false; 1405 - js_set_native_ptr(obj, callback); 1406 - js_set_native_tag(obj, FFI_CALLBACK_NATIVE_TAG); 1398 + js_set_native(obj, callback, FFI_CALLBACK_NATIVE_TAG); 1407 1399 js_set_slot_wb(js, obj, SLOT_DATA, fn); 1408 1400 js_set_finalizer(obj, ffi_callback_finalize); 1409 1401 return obj;
+8 -10
src/modules/formdata.c
··· 71 71 72 72 static fd_data_t *get_fd_data(ant_value_t obj) { 73 73 if (!js_check_native_tag(obj, FORMDATA_NATIVE_TAG)) return NULL; 74 - return (fd_data_t *)js_get_native_ptr(obj); 74 + return (fd_data_t *)js_get_native(obj, FORMDATA_NATIVE_TAG); 75 75 } 76 76 77 77 // TODO: compact ··· 84 84 } 85 85 86 86 static void formdata_finalize(ant_t *js, ant_object_t *obj) { 87 - if (!obj || obj->native.tag != FORMDATA_NATIVE_TAG) return; 88 - fd_data_t *d = (fd_data_t *)obj->native.ptr; 87 + ant_value_t value = js_obj_from_ptr(obj); 88 + fd_data_t *d = (fd_data_t *)js_get_native(value, FORMDATA_NATIVE_TAG); 89 89 fd_data_free(d); 90 - obj->native.ptr = NULL; 91 - obj->native.tag = 0; 90 + js_clear_native(value, FORMDATA_NATIVE_TAG); 92 91 } 93 92 94 93 static bool fd_append_str(fd_data_t *d, const char *name, const char *value) { ··· 383 382 if (!js_check_native_tag(js->this_val, FORMDATA_ITER_NATIVE_TAG)) 384 383 return js_iter_result(js, false, js_mkundef()); 385 384 386 - fd_iter_t *st = (fd_iter_t *)js_get_native_ptr(js->this_val); 385 + fd_iter_t *st = (fd_iter_t *)js_get_native(js->this_val, FORMDATA_ITER_NATIVE_TAG); 387 386 ant_value_t fd_obj = js_get_slot(js->this_val, SLOT_DATA); 388 387 fd_data_t *d = get_fd_data(fd_obj); 389 388 if (!d) return js_iter_result(js, false, js_mkundef()); ··· 418 417 } 419 418 420 419 static void formdata_iter_finalize(ant_t *js, ant_object_t *obj) { 421 - if (!obj || obj->native.tag != FORMDATA_ITER_NATIVE_TAG) return; 422 - free(obj->native.ptr); 423 - obj->native.ptr = NULL; 424 - obj->native.tag = 0; 420 + ant_value_t value = js_obj_from_ptr(obj); 421 + free(js_get_native(value, FORMDATA_ITER_NATIVE_TAG)); 422 + js_clear_native(value, FORMDATA_ITER_NATIVE_TAG); 425 423 } 426 424 427 425 static ant_value_t make_formdata_iter(ant_t *js, ant_value_t fd_obj, int kind) {
+8 -9
src/modules/fs.c
··· 158 158 159 159 static fs_watcher_t *fs_watcher_data(ant_value_t value) { 160 160 if (!js_check_native_tag(value, FS_WATCHER_NATIVE_TAG)) return NULL; 161 - return (fs_watcher_t *)js_get_native_ptr(value); 161 + return (fs_watcher_t *)js_get_native(value, FS_WATCHER_NATIVE_TAG); 162 162 } 163 163 164 164 static void fs_add_active_watcher(fs_watcher_t *watcher) { ··· 922 922 923 923 static void fs_watcher_finalize(ant_t *js, ant_object_t *obj) { 924 924 fs_watcher_t *watcher = NULL; 925 - if (!obj) return; 925 + ant_value_t value = js_obj_from_ptr(obj); 926 926 927 - watcher = (fs_watcher_t *)obj->native.ptr; 928 - obj->native.ptr = NULL; 927 + watcher = (fs_watcher_t *)js_get_native(value, FS_WATCHER_NATIVE_TAG); 928 + js_clear_native(value, FS_WATCHER_NATIVE_TAG); 929 929 if (!watcher) return; 930 930 931 931 watcher->finalized = true; ··· 1083 1083 1084 1084 obj = js_mkobj(js); 1085 1085 js_set_proto_init(obj, g_fswatcher_proto); 1086 - js_set_native_ptr(obj, watcher); 1087 - js_set_native_tag(obj, FS_WATCHER_NATIVE_TAG); 1086 + js_set_native(obj, watcher, FS_WATCHER_NATIVE_TAG); 1088 1087 js_set_finalizer(obj, fs_watcher_finalize); 1089 1088 watcher->obj = obj; 1090 1089 ··· 1587 1586 static void fs_init_filehandle_proto(ant_t *js) { 1588 1587 if (is_object_type(g_filehandle_proto)) return; 1589 1588 g_filehandle_proto = js_mkobj(js); 1590 - js_set_native_tag(g_filehandle_proto, FS_FILEHANDLE_NATIVE_TAG); 1589 + js_set_native(g_filehandle_proto, NULL, FS_FILEHANDLE_NATIVE_TAG); 1591 1590 js_set(js, g_filehandle_proto, "close", js_mkfun(builtin_fs_filehandle_close)); 1592 1591 js_set(js, g_filehandle_proto, "stat", js_mkfun(builtin_fs_filehandle_stat)); 1593 1592 js_set(js, g_filehandle_proto, "sync", js_mkfun(builtin_fs_filehandle_sync)); ··· 1601 1600 fs_init_filehandle_proto(js); 1602 1601 ant_value_t handle = js_mkobj(js); 1603 1602 1604 - js_set_native_tag(handle, FS_FILEHANDLE_NATIVE_TAG); 1603 + js_set_native(handle, NULL, FS_FILEHANDLE_NATIVE_TAG); 1605 1604 js_set_proto_init(handle, g_filehandle_proto); 1606 1605 js_set_slot(handle, SLOT_DATA, js_mknum((double)fd)); 1607 1606 js_set(js, handle, "fd", js_mknum((double)fd)); ··· 4335 4334 4336 4335 rc = fs_watcher_start_event(watcher, path, opts.persistent, opts.recursive); 4337 4336 if (rc != 0) { 4338 - js_set_native_ptr(watcher_obj, NULL); 4337 + js_clear_native(watcher_obj, FS_WATCHER_NATIVE_TAG); 4339 4338 fs_watcher_free(watcher); 4340 4339 return fs_watch_error(js, rc, path); 4341 4340 }
+4 -6
src/modules/generator.c
··· 52 52 53 53 static generator_data_t *generator_data(ant_value_t gen) { 54 54 if (!js_check_native_tag(gen, GENERATOR_NATIVE_TAG)) return NULL; 55 - return (generator_data_t *)js_get_native_ptr(gen); 55 + return (generator_data_t *)js_get_native(gen, GENERATOR_NATIVE_TAG); 56 56 } 57 57 58 58 static generator_state_t generator_state(ant_value_t gen) { ··· 285 285 286 286 static void generator_finalize(ant_t *js, ant_object_t *obj) { 287 287 ant_value_t gen = js_obj_from_ptr(obj); 288 - generator_data_t *data = (generator_data_t *)js_get_native_ptr(gen); 288 + generator_data_t *data = (generator_data_t *)js_get_native(gen, GENERATOR_NATIVE_TAG); 289 289 290 290 if (!data) return; 291 291 if (data->coro) generator_clear_coro(gen, data->coro); 292 292 293 - js_set_native_ptr(gen, NULL); 294 - js_set_native_tag(gen, 0); 293 + js_set_native(gen, NULL, 0); 295 294 296 295 generator_free_queue(data); 297 296 free(data); ··· 600 599 coroutine_hold(coro, CORO_HOLD_GENERATOR); 601 600 coroutine_release(coro); 602 601 603 - js_set_native_ptr(gen, data); 604 - js_set_native_tag(gen, GENERATOR_NATIVE_TAG); 602 + js_set_native(gen, data, GENERATOR_NATIVE_TAG); 605 603 js_set_finalizer(gen, generator_finalize); 606 604 607 605 ant_value_t instance_proto = js_get(js, callee_func, "prototype");
+2 -2
src/modules/headers.c
··· 71 71 72 72 static hdr_list_t *get_list(ant_value_t obj) { 73 73 if (!js_check_native_tag(obj, HEADERS_NATIVE_TAG)) return NULL; 74 - return (hdr_list_t *)js_get_native_ptr(obj); 74 + return (hdr_list_t *)js_get_native(obj, HEADERS_NATIVE_TAG); 75 75 } 76 76 77 77 static headers_guard_t get_guard(ant_value_t obj) { ··· 480 480 481 481 bool advance_headers(ant_t *js, js_iter_t *it, ant_value_t *out) { 482 482 if (!js_check_native_tag(it->iterator, HEADERS_ITER_NATIVE_TAG)) return false; 483 - hdr_iter_t *st = (hdr_iter_t *)js_get_native_ptr(it->iterator); 483 + hdr_iter_t *st = (hdr_iter_t *)js_get_native(it->iterator, HEADERS_ITER_NATIVE_TAG); 484 484 485 485 size_t count = 0; 486 486 sorted_pair_t *view = build_sorted_view(st->list, &count);
+5 -5
src/modules/iterator.c
··· 884 884 static void async_terminal_close_and_reject(ant_t *js, ant_value_t state, ant_value_t reason); 885 885 886 886 static void async_terminal_state_finalize(ant_t *js, ant_object_t *obj) { 887 - free(obj->native.ptr); 888 - obj->native.ptr = NULL; 887 + ant_value_t value = js_obj_from_ptr(obj); 888 + free(js_get_native(value, ASYNC_TERMINAL_STATE_TAG)); 889 + js_clear_native(value, ASYNC_TERMINAL_STATE_TAG); 889 890 } 890 891 891 892 static inline async_terminal_state_t *async_terminal_state(ant_value_t state) { 892 893 if (!js_check_native_tag(state, ASYNC_TERMINAL_STATE_TAG)) return NULL; 893 - return (async_terminal_state_t *)js_get_native_ptr(state); 894 + return (async_terminal_state_t *)js_get_native(state, ASYNC_TERMINAL_STATE_TAG); 894 895 } 895 896 896 897 static inline int async_terminal_mode(ant_value_t state) { ··· 1194 1195 st->index = 0; 1195 1196 st->has_acc = (mode == ASYNC_TERM_REDUCE && nargs > 1); 1196 1197 1197 - js_set_native_tag(state, ASYNC_TERMINAL_STATE_TAG); 1198 - js_set_native_ptr(state, st); 1198 + js_set_native(state, st, ASYNC_TERMINAL_STATE_TAG); 1199 1199 js_set_finalizer(state, async_terminal_state_finalize); 1200 1200 1201 1201 js_set_slot_wb(js, state, SLOT_DATA, iter);
+1 -1
src/modules/napi.c
··· 483 483 ant_value_t current = js_getcurrentfunc(js); 484 484 if (!js_check_native_tag(current, NAPI_CALLBACK_NATIVE_TAG)) return js_mkundef(); 485 485 486 - napi_callback_binding_t *binding = (napi_callback_binding_t *)js_get_native_ptr(current); 486 + napi_callback_binding_t *binding = (napi_callback_binding_t *)js_get_native(current, NAPI_CALLBACK_NATIVE_TAG); 487 487 if (!binding || !binding->cb) return js_mkundef(); 488 488 489 489 ant_napi_env_t *nenv = binding->env ? binding->env : napi_get_or_create_env(js);
+5 -8
src/modules/net.c
··· 102 102 103 103 static net_server_t *net_server_data(ant_value_t value) { 104 104 if (!js_check_native_tag(value, NET_SERVER_NATIVE_TAG)) return NULL; 105 - return (net_server_t *)js_get_native_ptr(value); 105 + return (net_server_t *)js_get_native(value, NET_SERVER_NATIVE_TAG); 106 106 } 107 107 108 108 static net_socket_t *net_socket_data(ant_value_t value) { 109 109 if (!js_check_native_tag(value, NET_SOCKET_NATIVE_TAG)) return NULL; 110 - return (net_socket_t *)js_get_native_ptr(value); 110 + return (net_socket_t *)js_get_native(value, NET_SOCKET_NATIVE_TAG); 111 111 } 112 112 113 113 static void net_add_active_server(net_server_t *server) { ··· 357 357 358 358 net_remove_active_socket(socket); 359 359 if (is_object_type(socket->obj)) { 360 - js_set_native_ptr(socket->obj, NULL); 361 - js_set_native_tag(socket->obj, 0); 360 + js_set_native(socket->obj, NULL, 0); 362 361 } 363 362 net_server_maybe_finish_close(socket->server); 364 363 free(socket); ··· 383 382 socket->encoding = js_mkundef(); 384 383 socket->allow_half_open = allow_half_open; 385 384 386 - js_set_native_ptr(obj, socket); 387 - js_set_native_tag(obj, NET_SOCKET_NATIVE_TAG); 385 + js_set_native(obj, socket, NET_SOCKET_NATIVE_TAG); 388 386 js_set(js, obj, "remoteAddress", js_mkundef()); 389 387 js_set(js, obj, "remotePort", js_mkundef()); 390 388 js_set(js, obj, "remoteFamily", js_mkundef()); ··· 431 429 return NULL; 432 430 } 433 431 434 - js_set_native_ptr(obj, server); 435 - js_set_native_tag(obj, NET_SERVER_NATIVE_TAG); 432 + js_set_native(obj, server, NET_SERVER_NATIVE_TAG); 436 433 net_server_sync_state(server); 437 434 return server; 438 435 }
+1 -1
src/modules/request.c
··· 32 32 33 33 static request_data_t *get_data(ant_value_t obj) { 34 34 if (!js_check_native_tag(obj, REQUEST_NATIVE_TAG)) return NULL; 35 - return (request_data_t *)js_get_native_ptr(obj); 35 + return (request_data_t *)js_get_native(obj, REQUEST_NATIVE_TAG); 36 36 } 37 37 38 38 request_data_t *request_get_data(ant_value_t obj) {
+1 -1
src/modules/response.c
··· 32 32 33 33 static response_data_t *get_data(ant_value_t obj) { 34 34 if (!js_check_native_tag(obj, RESPONSE_NATIVE_TAG)) return NULL; 35 - return (response_data_t *)js_get_native_ptr(obj); 35 + return (response_data_t *)js_get_native(obj, RESPONSE_NATIVE_TAG); 36 36 } 37 37 38 38 response_data_t *response_get_data(ant_value_t obj) {
+9 -4
src/modules/server.c
··· 37 37 38 38 static server_runtime_t *g_server = NULL; 39 39 40 + enum { 41 + SERVER_REQUEST_NATIVE_TAG = 0x53524551u, // SREQ 42 + SERVER_RUNTIME_NATIVE_TAG = 0x5352544du // SRTM 43 + }; 44 + 40 45 typedef struct stop_waiter_s { 41 46 ant_value_t promise; 42 47 struct stop_waiter_s *next; ··· 119 124 } 120 125 121 126 static inline server_request_t *server_current_request(ant_t *js) { 122 - return (server_request_t *)js_get_native_ptr(js->current_func); 127 + return (server_request_t *)js_get_native(js->current_func, SERVER_REQUEST_NATIVE_TAG); 123 128 } 124 129 125 130 static inline server_runtime_t *server_current_runtime(ant_t *js) { 126 - return (server_runtime_t *)js_get_native_ptr(js->current_func); 131 + return (server_runtime_t *)js_get_native(js->current_func, SERVER_RUNTIME_NATIVE_TAG); 127 132 } 128 133 129 134 static ant_value_t server_mkreqfun( ··· 132 137 server_request_t *req 133 138 ) { 134 139 ant_value_t func = js_heavy_mkfun(js, fn, js_mkundef()); 135 - js_set_native_ptr(func, req); 140 + js_set_native(func, req, SERVER_REQUEST_NATIVE_TAG); 136 141 return func; 137 142 } 138 143 ··· 142 147 server_runtime_t *server 143 148 ) { 144 149 ant_value_t func = js_heavy_mkfun(js, fn, js_mkundef()); 145 - js_set_native_ptr(func, server); 150 + js_set_native(func, server, SERVER_RUNTIME_NATIVE_TAG); 146 151 return func; 147 152 } 148 153
+6 -8
src/modules/stream.c
··· 52 52 53 53 static stream_private_state_t *stream_private_state(ant_value_t stream_obj) { 54 54 if (!stream_is_instance(stream_obj)) return NULL; 55 - return (stream_private_state_t *)js_get_native_ptr(stream_obj); 55 + return (stream_private_state_t *)js_get_native(stream_obj, STREAM_NATIVE_TAG); 56 56 } 57 57 58 58 static ant_value_t stream_require_this(ant_t *js, ant_value_t value, const char *label) { ··· 118 118 ant_value_t stream_obj = js_obj_from_ptr(obj); 119 119 stream_private_state_t *priv = stream_private_state(stream_obj); 120 120 if (!priv) return; 121 - js_set_native_ptr(stream_obj, NULL); 121 + js_clear_native(stream_obj, STREAM_NATIVE_TAG); 122 122 if (priv->attached_state && priv->attached_state_finalize) 123 123 priv->attached_state_finalize(js, stream_obj, priv->attached_state); 124 124 free(priv); ··· 347 347 stream_private_state_t *priv = calloc(1, sizeof(*priv)); 348 348 349 349 if (is_object_type(proto)) js_set_proto_init(obj, proto); 350 - js_set_native_tag(obj, STREAM_NATIVE_TAG); 351 - 352 - if (priv) js_set_native_ptr(obj, priv); 350 + js_set_native(obj, priv, STREAM_NATIVE_TAG); 353 351 js_set_slot(obj, SLOT_AUX, js_mkundef()); 354 352 js_set_finalizer(obj, stream_finalize); 355 353 ··· 1801 1799 void stream_init_readable_object(ant_t *js, ant_value_t obj, ant_value_t options) { 1802 1800 stream_init_constructors(js); 1803 1801 if (!is_object_type(obj)) return; 1804 - js_set_native_tag(obj, STREAM_NATIVE_TAG); 1802 + js_set_native(obj, NULL, STREAM_NATIVE_TAG); 1805 1803 stream_init_readable(js, obj, options); 1806 1804 } 1807 1805 1808 1806 void stream_init_writable_object(ant_t *js, ant_value_t obj, ant_value_t options) { 1809 1807 stream_init_constructors(js); 1810 1808 if (!is_object_type(obj)) return; 1811 - js_set_native_tag(obj, STREAM_NATIVE_TAG); 1809 + js_set_native(obj, NULL, STREAM_NATIVE_TAG); 1812 1810 stream_init_writable(js, obj, options); 1813 1811 } 1814 1812 1815 1813 void stream_init_duplex_object(ant_t *js, ant_value_t obj, ant_value_t options) { 1816 1814 stream_init_constructors(js); 1817 1815 if (!is_object_type(obj)) return; 1818 - js_set_native_tag(obj, STREAM_NATIVE_TAG); 1816 + js_set_native(obj, NULL, STREAM_NATIVE_TAG); 1819 1817 stream_init_readable(js, obj, options); 1820 1818 stream_init_writable(js, obj, options); 1821 1819 }
+4 -5
src/modules/string_decoder.c
··· 35 35 36 36 static sd_state_t *sd_get_state(ant_value_t obj) { 37 37 if (!js_check_native_tag(obj, STRING_DECODER_NATIVE_TAG)) return NULL; 38 - return (sd_state_t *)js_get_native_ptr(obj); 38 + return (sd_state_t *)js_get_native(obj, STRING_DECODER_NATIVE_TAG); 39 39 } 40 40 41 41 static void sd_finalize(ant_t *js, ant_object_t *obj) { 42 - if (!obj || obj->native.tag != STRING_DECODER_NATIVE_TAG) return; 43 - sd_state_t *st = (sd_state_t *)obj->native.ptr; 42 + ant_value_t value = js_obj_from_ptr(obj); 43 + sd_state_t *st = (sd_state_t *)js_get_native(value, STRING_DECODER_NATIVE_TAG); 44 44 if (st) { free(st->td); free(st); } 45 - obj->native.ptr = NULL; 46 - obj->native.tag = 0; 45 + js_clear_native(value, STRING_DECODER_NATIVE_TAG); 47 46 } 48 47 49 48 static int sd_parse_encoding(const char *s, size_t len) {
+4 -5
src/modules/textcodec.c
··· 30 30 31 31 static td_state_t *td_get_state(ant_value_t obj) { 32 32 if (!js_check_native_tag(obj, TEXT_DECODER_NATIVE_TAG)) return NULL; 33 - return (td_state_t *)js_get_native_ptr(obj); 33 + return (td_state_t *)js_get_native(obj, TEXT_DECODER_NATIVE_TAG); 34 34 } 35 35 36 36 static void td_finalize(ant_t *js, ant_object_t *obj) { 37 - if (!obj || obj->native.tag != TEXT_DECODER_NATIVE_TAG) return; 38 - free(obj->native.ptr); 39 - obj->native.ptr = NULL; 40 - obj->native.tag = 0; 37 + ant_value_t value = js_obj_from_ptr(obj); 38 + free(js_get_native(value, TEXT_DECODER_NATIVE_TAG)); 39 + js_clear_native(value, TEXT_DECODER_NATIVE_TAG); 41 40 } 42 41 43 42 static int resolve_encoding(const char *s, size_t len) {
+3 -5
src/modules/tls.c
··· 41 41 42 42 static ant_tls_context_wrap_t *tls_context_data(ant_value_t value) { 43 43 if (!js_check_native_tag(value, TLS_CONTEXT_NATIVE_TAG)) return NULL; 44 - return (ant_tls_context_wrap_t *)js_get_native_ptr(value); 44 + return (ant_tls_context_wrap_t *)js_get_native(value, TLS_CONTEXT_NATIVE_TAG); 45 45 } 46 46 47 47 static bool tls_value_bytes( ··· 95 95 if (!wrap) return js_getthis(js); 96 96 97 97 tls_context_free(wrap); 98 - js_set_native_ptr(wrap->obj, NULL); 99 - js_set_native_tag(wrap->obj, 0); 98 + js_set_native(wrap->obj, NULL, 0); 100 99 return js_getthis(js); 101 100 } 102 101 ··· 214 213 js_set_proto_init(obj, g_tls_context_proto); 215 214 wrap->obj = obj; 216 215 217 - js_set_native_ptr(obj, wrap); 218 - js_set_native_tag(obj, TLS_CONTEXT_NATIVE_TAG); 216 + js_set_native(obj, wrap, TLS_CONTEXT_NATIVE_TAG); 219 217 220 218 return obj; 221 219 }
+4 -5
src/modules/url.c
··· 31 31 32 32 url_state_t *url_get_state(ant_value_t obj) { 33 33 if (!js_check_native_tag(obj, URL_NATIVE_TAG)) return NULL; 34 - return (url_state_t *)js_get_native_ptr(obj); 34 + return (url_state_t *)js_get_native(obj, URL_NATIVE_TAG); 35 35 } 36 36 37 37 bool usp_is_urlsearchparams(ant_t *js, ant_value_t obj) { ··· 51 51 } 52 52 53 53 static void url_finalize(ant_t *js, ant_object_t *obj) { 54 - if (!obj || obj->native.tag != URL_NATIVE_TAG) return; 55 - url_free_state((url_state_t *)obj->native.ptr); 56 - obj->native.ptr = NULL; 57 - obj->native.tag = 0; 54 + ant_value_t value = js_obj_from_ptr(obj); 55 + url_free_state((url_state_t *)js_get_native(value, URL_NATIVE_TAG)); 56 + js_clear_native(value, URL_NATIVE_TAG); 58 57 } 59 58 60 59 static int default_port_for(const char *proto) {
+9 -12
src/modules/wasi.c
··· 224 224 static ant_value_t wasi_exported_func_call(ant_t *js, ant_value_t *args, int nargs) { 225 225 if (!js_check_native_tag(js->current_func, WASI_FUNC_TAG)) 226 226 return js_mkerr(js, "Invalid WASI function"); 227 - wasi_func_env_t *env = (wasi_func_env_t *)js_get_native_ptr(js->current_func); 227 + wasi_func_env_t *env = (wasi_func_env_t *)js_get_native(js->current_func, WASI_FUNC_TAG); 228 228 229 229 uint32_t param_count = wasm_func_get_param_count(env->func, env->inst); 230 230 uint32_t result_count = wasm_func_get_result_count(env->func, env->inst); ··· 248 248 } 249 249 250 250 static void wasi_func_finalize(ant_t *js, ant_object_t *obj) { 251 - if (obj->native.tag != WASI_FUNC_TAG) return; 252 - 253 - free(obj->native.ptr); 254 - obj->native.ptr = NULL; 255 - obj->native.tag = 0; 251 + ant_value_t value = js_obj_from_ptr(obj); 252 + free(js_get_native(value, WASI_FUNC_TAG)); 253 + js_clear_native(value, WASI_FUNC_TAG); 256 254 } 257 255 258 256 static void wasi_instance_finalize(ant_t *js, ant_object_t *obj) { 259 - if (obj->native.tag != WASI_INSTANCE_TAG) return; 260 - wasi_instance_handle_t *handle = (wasi_instance_handle_t *)obj->native.ptr; 257 + ant_value_t value = js_obj_from_ptr(obj); 258 + wasi_instance_handle_t *handle = (wasi_instance_handle_t *)js_get_native(value, WASI_INSTANCE_TAG); 261 259 262 260 if (!handle) return; 263 261 if (handle->exec_env) wasm_runtime_destroy_exec_env(handle->exec_env); 264 262 if (handle->inst) wasm_runtime_deinstantiate(handle->inst); 263 + js_clear_native(value, WASI_INSTANCE_TAG); 265 264 if (handle->module) wasm_runtime_unload(handle->module); 266 265 267 266 free(handle->binary); ··· 340 339 GC_ROOT_PIN(js, obj); 341 340 342 341 js_set_slot(obj, SLOT_CFUNC, js_mkfun(wasi_exported_func_call)); 343 - js_set_native_ptr(obj, fenv); 344 - js_set_native_tag(obj, WASI_FUNC_TAG); 342 + js_set_native(obj, fenv, WASI_FUNC_TAG); 345 343 js_set_slot_wb(js, obj, SLOT_ENTRIES, instance_obj); 346 344 js_set_finalizer(obj, wasi_func_finalize); 347 345 js_set(js, exports_obj, name, js_obj_to_func(obj)); ··· 441 439 ant_value_t instance_obj = js_mkobj(js); 442 440 ant_value_t exports_obj = js_mkobj(js); 443 441 444 - js_set_native_ptr(instance_obj, handle); 445 - js_set_native_tag(instance_obj, WASI_INSTANCE_TAG); 442 + js_set_native(instance_obj, handle, WASI_INSTANCE_TAG); 446 443 js_set_slot_wb(js, instance_obj, SLOT_CTOR, module_obj); 447 444 js_set_finalizer(instance_obj, wasi_instance_finalize); 448 445
+19 -25
src/modules/wasm.c
··· 179 179 static wasm_module_handle_t *wasm_module_handle(ant_value_t value) { 180 180 if (!js_check_brand(value, BRAND_WASM_MODULE)) return NULL; 181 181 if (!js_check_native_tag(value, WASM_MODULE_NATIVE_TAG)) return NULL; 182 - return (wasm_module_handle_t *)js_get_native_ptr(value); 182 + return (wasm_module_handle_t *)js_get_native(value, WASM_MODULE_NATIVE_TAG); 183 183 } 184 184 185 185 static wasm_instance_handle_t *wasm_instance_handle(ant_value_t value) { 186 186 if (!js_check_brand(value, BRAND_WASM_INSTANCE)) return NULL; 187 187 if (!js_check_native_tag(value, WASM_INSTANCE_NATIVE_TAG)) return NULL; 188 - return (wasm_instance_handle_t *)js_get_native_ptr(value); 188 + return (wasm_instance_handle_t *)js_get_native(value, WASM_INSTANCE_NATIVE_TAG); 189 189 } 190 190 191 191 static wasm_extern_handle_t *wasm_extern_handle(ant_value_t value, wasm_extern_wrap_kind_t kind) { ··· 196 196 } 197 197 198 198 if (!js_check_native_tag(value, WASM_EXTERN_NATIVE_TAG)) return NULL; 199 - wasm_extern_handle_t *handle = (wasm_extern_handle_t *)js_get_native_ptr(value); 199 + wasm_extern_handle_t *handle = (wasm_extern_handle_t *)js_get_native(value, WASM_EXTERN_NATIVE_TAG); 200 200 return handle && handle->kind == kind ? handle : NULL; 201 201 } 202 202 ··· 325 325 state = js_get_slot(value, SLOT_DATA); 326 326 if (!is_object_type(state) || !js_check_native_tag(state, WASM_FUNC_STATE_TAG)) 327 327 return false; 328 - handle = (wasm_func_handle_t *)js_get_native_ptr(state); 328 + handle = (wasm_func_handle_t *)js_get_native(state, WASM_FUNC_STATE_TAG); 329 329 if (!handle || !handle->func) return false; 330 330 out->of.ref = wasm_func_as_ref(handle->func); 331 331 return out->of.ref != NULL; ··· 375 375 } 376 376 377 377 static void wasm_module_finalize(ant_t *js, ant_object_t *obj) { 378 - if (!obj || obj->native.tag != WASM_MODULE_NATIVE_TAG) return; 379 - wasm_module_handle_t *handle = (wasm_module_handle_t *)obj->native.ptr; 378 + ant_value_t value = js_obj_from_ptr(obj); 379 + wasm_module_handle_t *handle = (wasm_module_handle_t *)js_get_native(value, WASM_MODULE_NATIVE_TAG); 380 380 if (!handle) return; 381 381 if (handle->module) wasm_module_delete(handle->module); 382 382 if (handle->store) wasm_store_delete(handle->store); 383 383 384 384 free(handle); 385 - obj->native.ptr = NULL; 386 - obj->native.tag = 0; 385 + js_clear_native(value, WASM_MODULE_NATIVE_TAG); 387 386 } 388 387 389 388 static ant_value_t wasm_wrap_instance(ant_t *js, wasm_instance_handle_t *handle, ant_value_t module_ref) { ··· 396 395 } 397 396 398 397 static void wasm_instance_finalize(ant_t *js, ant_object_t *obj) { 399 - if (!obj || obj->native.tag != WASM_INSTANCE_NATIVE_TAG) return; 400 - wasm_instance_handle_t *handle = (wasm_instance_handle_t *)obj->native.ptr; 398 + ant_value_t value = js_obj_from_ptr(obj); 399 + wasm_instance_handle_t *handle = (wasm_instance_handle_t *)js_get_native(value, WASM_INSTANCE_NATIVE_TAG); 401 400 if (!handle) return; 402 401 for (size_t j = 0; j < handle->host_func_count; j++) 403 402 if (handle->host_funcs[j]) wasm_func_delete(handle->host_funcs[j]); ··· 405 404 free(handle->host_funcs); 406 405 wasm_extern_vec_delete(&handle->exports); 407 406 free(handle); 408 - obj->native.ptr = NULL; 409 - obj->native.tag = 0; 407 + js_clear_native(value, WASM_INSTANCE_NATIVE_TAG); 410 408 } 411 409 412 410 static ant_value_t wasm_wrap_extern_object(ant_t *js, wasm_extern_wrap_kind_t kind, ant_value_t proto, int brand, wasm_store_t *store, bool own_handle, void *ptr, ant_value_t owner) { ··· 433 431 } 434 432 435 433 static void wasm_extern_finalize(ant_t *js, ant_object_t *obj) { 436 - if (!obj || obj->native.tag != WASM_EXTERN_NATIVE_TAG) return; 437 - wasm_extern_handle_t *handle = (wasm_extern_handle_t *)obj->native.ptr; 434 + ant_value_t value = js_obj_from_ptr(obj); 435 + wasm_extern_handle_t *handle = (wasm_extern_handle_t *)js_get_native(value, WASM_EXTERN_NATIVE_TAG); 438 436 if (!handle) return; 439 437 440 438 if (handle->own_handle) { ··· 453 451 } 454 452 455 453 free(handle); 456 - obj->native.ptr = NULL; 457 - obj->native.tag = 0; 454 + js_clear_native(value, WASM_EXTERN_NATIVE_TAG); 458 455 } 459 456 460 457 static ant_value_t js_wasm_exported_func_call(ant_t *js, ant_value_t *args, int nargs) { ··· 465 462 if (!is_object_type(state) || !js_check_native_tag(state, WASM_FUNC_STATE_TAG)) 466 463 return js_mkerr(js, "Invalid WebAssembly function"); 467 464 468 - handle = (wasm_func_handle_t *)js_get_native_ptr(state); 465 + handle = (wasm_func_handle_t *)js_get_native(state, WASM_FUNC_STATE_TAG); 469 466 func = handle ? handle->func : NULL; 470 467 if (!func) return js_mkerr(js, "Invalid WebAssembly function"); 471 468 ··· 531 528 } 532 529 533 530 static void wasm_func_state_finalize(ant_t *js, ant_object_t *obj) { 534 - if (obj->native.tag != WASM_FUNC_STATE_TAG) return; 535 - 536 - wasm_func_handle_t *handle = (wasm_func_handle_t *)obj->native.ptr; 531 + ant_value_t value = js_obj_from_ptr(obj); 532 + wasm_func_handle_t *handle = (wasm_func_handle_t *)js_get_native(value, WASM_FUNC_STATE_TAG); 537 533 if (!handle) return; 538 534 539 535 if (handle->own_func && handle->func) wasm_func_delete(handle->func); 540 536 free(handle); 541 - obj->native.ptr = NULL; 542 - obj->native.tag = 0; 537 + js_clear_native(value, WASM_FUNC_STATE_TAG); 543 538 } 544 539 545 540 static ant_value_t wasm_wrap_func(ant_t *js, wasm_func_t *func, ant_value_t owner, bool own_func) { ··· 558 553 handle->own_func = own_func; 559 554 560 555 state = js_mkobj(js); 561 - js_set_native_ptr(state, handle); 562 - js_set_native_tag(state, WASM_FUNC_STATE_TAG); 556 + js_set_native(state, handle, WASM_FUNC_STATE_TAG); 563 557 564 558 if (is_object_type(owner)) js_set_slot_wb(js, state, SLOT_ENTRIES, owner); 565 559 js_set_finalizer(state, wasm_func_state_finalize); ··· 1221 1215 if (!is_object_type(state) || !js_check_native_tag(state, WASM_FUNC_STATE_TAG)) 1222 1216 return js_mkerr_typed(js, JS_ERR_TYPE, "WebAssembly.Table.set expects a WebAssembly function or null"); 1223 1217 1224 - func_handle = (wasm_func_handle_t *)js_get_native_ptr(state); 1218 + func_handle = (wasm_func_handle_t *)js_get_native(state, WASM_FUNC_STATE_TAG); 1225 1219 if (!func_handle || !func_handle->func) 1226 1220 return js_mkerr_typed(js, JS_ERR_TYPE, "WebAssembly.Table.set expects a WebAssembly function or null"); 1227 1221
+1 -1
src/modules/worker_threads.c
··· 94 94 static ant_worker_thread_t *wt_get_worker(ant_t *js, ant_value_t this_obj) { 95 95 if (!is_object_type(this_obj)) return NULL; 96 96 if (!js_check_native_tag(this_obj, WORKER_NATIVE_TAG)) return NULL; 97 - return (ant_worker_thread_t *)js_get_native_ptr(this_obj); 97 + return (ant_worker_thread_t *)js_get_native(this_obj, WORKER_NATIVE_TAG); 98 98 } 99 99 100 100 static bool wt_is_message_port(ant_t *js, ant_value_t obj) {
+2 -3
src/modules/zlib.c
··· 76 76 77 77 static zlib_stream_t *zlib_stream_ptr(ant_value_t obj) { 78 78 if (!js_check_native_tag(obj, ZLIB_STREAM_TAG)) return NULL; 79 - return (zlib_stream_t *)js_get_native_ptr(obj); 79 + return (zlib_stream_t *)js_get_native(obj, ZLIB_STREAM_TAG); 80 80 } 81 81 82 82 static void zlib_add_active(zlib_stream_t *st) { ··· 424 424 ant_value_t obj = js_mkobj(js); 425 425 if (is_object_type(g_transform_proto)) js_set_proto_init(obj, g_transform_proto); 426 426 427 - js_set_native_ptr(obj, st); 428 - js_set_native_tag(obj, ZLIB_STREAM_TAG); 427 + js_set_native(obj, st, ZLIB_STREAM_TAG); 429 428 430 429 js_set(js, obj, "readable", js_true); 431 430 js_set(js, obj, "writable", js_true);
+2 -1
src/silver/ops/upvalues.h
··· 11 11 ) { 12 12 ant_value_t proto_obj = mkobj(js, 0); 13 13 if (is_err(proto_obj)) return proto_obj; 14 - if (is_object_type(parent_proto)) js_set_proto_init(proto_obj, parent_proto); 15 14 16 15 ant_value_t ctor_key = js_mkstr(js, "constructor", 11); 17 16 if (is_err(ctor_key)) return ctor_key; ··· 20 19 if (is_err(set_ctor)) return set_ctor; 21 20 22 21 js_set_descriptor(js, proto_obj, "constructor", 11, JS_DESC_W | JS_DESC_C); 22 + if (is_object_type(parent_proto)) js_set_proto_init(proto_obj, parent_proto); 23 + 23 24 ant_value_t proto_key = js_mkstr(js, "prototype", 9); 24 25 if (is_err(proto_key)) return proto_key; 25 26
+17 -15
src/streams/codec.c
··· 64 64 } 65 65 66 66 static void tes_state_finalize(ant_t *js, ant_object_t *obj) { 67 - if (!obj || obj->native.tag != TES_NATIVE_TAG) return; 68 - free(obj->native.ptr); 69 - obj->native.ptr = NULL; 70 - obj->native.tag = 0; 67 + ant_value_t value = js_obj_from_ptr(obj); 68 + free(js_get_native(value, TES_NATIVE_TAG)); 69 + js_clear_native(value, TES_NATIVE_TAG); 71 70 } 72 71 73 72 static void tds_state_finalize(ant_t *js, ant_object_t *obj) { 74 - if (!obj || obj->native.tag != TDS_NATIVE_TAG) return; 75 - free(obj->native.ptr); 76 - obj->native.ptr = NULL; 77 - obj->native.tag = 0; 73 + ant_value_t value = js_obj_from_ptr(obj); 74 + free(js_get_native(value, TDS_NATIVE_TAG)); 75 + js_clear_native(value, TDS_NATIVE_TAG); 78 76 } 79 77 80 78 static ant_value_t codec_transform_controller(ant_value_t *args, int nargs) { ··· 87 85 88 86 static ant_value_t tes_transform(ant_t *js, ant_value_t *args, int nargs) { 89 87 tes_state_t *st = js_check_native_tag(js->current_func, TES_NATIVE_TAG) 90 - ? (tes_state_t *)js_get_native_ptr(js->current_func) 88 + ? (tes_state_t *)js_get_native(js->current_func, TES_NATIVE_TAG) 91 89 : NULL; 92 90 93 91 if (!st) return js_mkerr_typed(js, JS_ERR_TYPE, "Invalid TextEncoderStream"); ··· 174 172 175 173 static ant_value_t tes_flush(ant_t *js, ant_value_t *args, int nargs) { 176 174 tes_state_t *st = js_check_native_tag(js->current_func, TES_NATIVE_TAG) 177 - ? (tes_state_t *)js_get_native_ptr(js->current_func) 175 + ? (tes_state_t *)js_get_native(js->current_func, TES_NATIVE_TAG) 178 176 : NULL; 179 177 180 178 if (!st) return js_mkerr_typed(js, JS_ERR_TYPE, "Invalid TextEncoderStream"); ··· 242 240 243 241 if (is_err(ts_obj)) { free(st); return ts_obj; } 244 242 js_set_slot(obj, SLOT_ENTRIES, ts_obj); 243 + js_set_slot_wb(js, transform_fn, SLOT_ENTRIES, obj); 244 + js_set_slot_wb(js, flush_fn, SLOT_ENTRIES, obj); 245 245 246 246 return obj; 247 247 } 248 248 249 249 static ant_value_t tds_transform(ant_t *js, ant_value_t *args, int nargs) { 250 250 td_state_t *st = js_check_native_tag(js->current_func, TDS_NATIVE_TAG) 251 - ? (td_state_t *)js_get_native_ptr(js->current_func) 251 + ? (td_state_t *)js_get_native(js->current_func, TDS_NATIVE_TAG) 252 252 : NULL; 253 253 254 254 if (!st) return js_mkerr_typed(js, JS_ERR_TYPE, "Invalid TextDecoderStream"); ··· 277 277 278 278 static ant_value_t tds_flush(ant_t *js, ant_value_t *args, int nargs) { 279 279 td_state_t *st = js_check_native_tag(js->current_func, TDS_NATIVE_TAG) 280 - ? (td_state_t *)js_get_native_ptr(js->current_func) 280 + ? (td_state_t *)js_get_native(js->current_func, TDS_NATIVE_TAG) 281 281 : NULL; 282 282 283 283 if (!st) return js_mkerr_typed(js, JS_ERR_TYPE, "Invalid TextDecoderStream"); ··· 298 298 } 299 299 300 300 static ant_value_t js_tds_get_encoding(ant_t *js, ant_value_t *args, int nargs) { 301 - td_state_t *st = (td_state_t *)js_get_native_ptr(js->this_val); 301 + td_state_t *st = (td_state_t *)js_get_native(js->this_val, TDS_NATIVE_TAG); 302 302 if (!st) return js_mkstr(js, "utf-8", 5); 303 303 switch (st->encoding) { 304 304 case TD_ENC_UTF16LE: return js_mkstr(js, "utf-16le", 8); ··· 310 310 } 311 311 312 312 static ant_value_t js_tds_get_fatal(ant_t *js, ant_value_t *args, int nargs) { 313 - td_state_t *st = (td_state_t *)js_get_native_ptr(js->this_val); 313 + td_state_t *st = (td_state_t *)js_get_native(js->this_val, TDS_NATIVE_TAG); 314 314 return (st && st->fatal) ? js_true : js_false; 315 315 } 316 316 317 317 static ant_value_t js_tds_get_ignore_bom(ant_t *js, ant_value_t *args, int nargs) { 318 - td_state_t *st = (td_state_t *)js_get_native_ptr(js->this_val); 318 + td_state_t *st = (td_state_t *)js_get_native(js->this_val, TDS_NATIVE_TAG); 319 319 return (st && st->ignore_bom) ? js_true : js_false; 320 320 } 321 321 ··· 421 421 422 422 if (is_err(ts_obj)) { free(st); return ts_obj; } 423 423 js_set_slot(obj, SLOT_ENTRIES, ts_obj); 424 + js_set_slot_wb(js, transform_fn, SLOT_ENTRIES, obj); 425 + js_set_slot_wb(js, flush_fn, SLOT_ENTRIES, obj); 424 426 425 427 return obj; 426 428 }
+30 -35
src/streams/compression.c
··· 87 87 } 88 88 89 89 static void zstate_finalize(ant_t *js, ant_object_t *obj) { 90 - if (!obj || obj->native.tag != CS_Z_NATIVE_TAG) return; 91 - zstate_t *st = (zstate_t *)obj->native.ptr; 90 + ant_value_t value = js_obj_from_ptr(obj); 91 + zstate_t *st = (zstate_t *)js_get_native(value, CS_Z_NATIVE_TAG); 92 92 if (!st) return; 93 93 if (st->initialized) deflateEnd(&st->strm); 94 94 free(st); 95 - obj->native.ptr = NULL; 96 - obj->native.tag = 0; 95 + js_clear_native(value, CS_Z_NATIVE_TAG); 97 96 } 98 97 99 98 static void zstate_inflate_finalize(ant_t *js, ant_object_t *obj) { 100 - if (!obj || obj->native.tag != DS_Z_NATIVE_TAG) return; 101 - zstate_t *st = (zstate_t *)obj->native.ptr; 99 + ant_value_t value = js_obj_from_ptr(obj); 100 + zstate_t *st = (zstate_t *)js_get_native(value, DS_Z_NATIVE_TAG); 102 101 if (!st) return; 103 102 if (st->initialized) inflateEnd(&st->strm); 104 103 free(st); 105 - obj->native.ptr = NULL; 106 - obj->native.tag = 0; 104 + js_clear_native(value, DS_Z_NATIVE_TAG); 107 105 } 108 106 109 107 static void brotli_state_finalize(ant_t *js, ant_object_t *obj) { 110 - if (!obj || (obj->native.tag != CS_BROTLI_NATIVE_TAG && obj->native.tag != DS_BROTLI_NATIVE_TAG)) return; 111 - brotli_stream_state_t *st = (brotli_stream_state_t *)obj->native.ptr; 108 + ant_value_t value = js_obj_from_ptr(obj); 109 + uint32_t tag = js_check_native_tag(value, CS_BROTLI_NATIVE_TAG) 110 + ? CS_BROTLI_NATIVE_TAG 111 + : DS_BROTLI_NATIVE_TAG; 112 + brotli_stream_state_t *st = (brotli_stream_state_t *)js_get_native(value, tag); 112 113 brotli_stream_state_destroy(st); 113 - obj->native.ptr = NULL; 114 - obj->native.tag = 0; 114 + js_clear_native(value, tag); 115 115 } 116 116 117 117 static ant_value_t enqueue_buffer(ant_t *js, ant_value_t ctrl_obj, const uint8_t *data, size_t len) { ··· 127 127 #define ZCHUNK_SIZE 16384 128 128 129 129 static ant_value_t cs_transform(ant_t *js, ant_value_t *args, int nargs) { 130 - uint32_t tag = js_get_native_tag(js->current_func); 131 - zstate_t *st = (zstate_t *)js_get_native_ptr(js->current_func); 132 - 133 130 ant_value_t ctrl_obj = (nargs > 1) ? args[1] : js_mkundef(); 134 131 ant_value_t chunk = (nargs > 0) ? args[0] : js_mkundef(); 135 132 ··· 141 138 142 139 if (!input || input_len == 0) return js_mkundef(); 143 140 144 - if (tag == CS_BROTLI_NATIVE_TAG) { 145 - brotli_stream_state_t *brotli_st = (brotli_stream_state_t *)js_get_native_ptr(js->current_func); 141 + brotli_stream_state_t *brotli_st = (brotli_stream_state_t *)js_get_native(js->current_func, CS_BROTLI_NATIVE_TAG); 142 + if (brotli_st) 146 143 return brotli_stream_transform(js, brotli_st, ctrl_obj, input, input_len); 147 - } 148 144 149 - if (tag != CS_Z_NATIVE_TAG || !st) 145 + zstate_t *st = (zstate_t *)js_get_native(js->current_func, CS_Z_NATIVE_TAG); 146 + if (!st) 150 147 return js_mkerr_typed(js, JS_ERR_TYPE, "Invalid CompressionStream"); 151 148 152 149 st->strm.next_in = (Bytef *)input; ··· 170 167 } 171 168 172 169 static ant_value_t cs_flush(ant_t *js, ant_value_t *args, int nargs) { 173 - uint32_t tag = js_get_native_tag(js->current_func); 174 170 ant_value_t ctrl_obj = (nargs > 0) ? args[0] : js_mkundef(); 175 171 176 - if (tag == CS_BROTLI_NATIVE_TAG) { 177 - brotli_stream_state_t *brotli_st = (brotli_stream_state_t *)js_get_native_ptr(js->current_func); 172 + brotli_stream_state_t *brotli_st = (brotli_stream_state_t *)js_get_native(js->current_func, CS_BROTLI_NATIVE_TAG); 173 + if (brotli_st) 178 174 return brotli_stream_flush(js, brotli_st, ctrl_obj); 179 - } 180 175 181 - zstate_t *st = (zstate_t *)js_get_native_ptr(js->current_func); 182 - if (tag != CS_Z_NATIVE_TAG || !st) return js_mkerr_typed(js, JS_ERR_TYPE, "Invalid CompressionStream"); 176 + zstate_t *st = (zstate_t *)js_get_native(js->current_func, CS_Z_NATIVE_TAG); 177 + if (!st) return js_mkerr_typed(js, JS_ERR_TYPE, "Invalid CompressionStream"); 183 178 184 179 st->strm.next_in = NULL; 185 180 st->strm.avail_in = 0; ··· 274 269 return ts_obj; 275 270 } 276 271 js_set_slot(obj, SLOT_ENTRIES, ts_obj); 272 + js_set_slot_wb(js, transform_fn, SLOT_ENTRIES, obj); 273 + js_set_slot_wb(js, flush_fn, SLOT_ENTRIES, obj); 277 274 278 275 return obj; 279 276 } 280 277 281 278 static ant_value_t ds_transform(ant_t *js, ant_value_t *args, int nargs) { 282 - uint32_t tag = js_get_native_tag(js->current_func); 283 - zstate_t *st = (zstate_t *)js_get_native_ptr(js->current_func); 284 279 ant_value_t ctrl_obj = (nargs > 1) ? args[1] : js_mkundef(); 285 280 286 281 ant_value_t chunk = (nargs > 0) ? args[0] : js_mkundef(); ··· 291 286 return js_mkerr_typed(js, JS_ERR_TYPE, "The provided value is not of type '(ArrayBuffer or ArrayBufferView)'"); 292 287 293 288 if (!input || input_len == 0) return js_mkundef(); 294 - if (tag == DS_BROTLI_NATIVE_TAG) { 295 - brotli_stream_state_t *brotli_st = (brotli_stream_state_t *)js_get_native_ptr(js->current_func); 289 + brotli_stream_state_t *brotli_st = (brotli_stream_state_t *)js_get_native(js->current_func, DS_BROTLI_NATIVE_TAG); 290 + if (brotli_st) 296 291 return brotli_stream_transform(js, brotli_st, ctrl_obj, input, input_len); 297 - } 298 292 299 - if (tag != DS_Z_NATIVE_TAG || !st) 293 + zstate_t *st = (zstate_t *)js_get_native(js->current_func, DS_Z_NATIVE_TAG); 294 + if (!st) 300 295 return js_mkerr_typed(js, JS_ERR_TYPE, "Invalid DecompressionStream"); 301 296 302 297 st->strm.next_in = (Bytef *)input; ··· 321 316 } 322 317 323 318 static ant_value_t ds_flush(ant_t *js, ant_value_t *args, int nargs) { 324 - uint32_t tag = js_get_native_tag(js->current_func); 325 319 ant_value_t ctrl_obj = (nargs > 0) ? args[0] : js_mkundef(); 326 - if (tag == DS_BROTLI_NATIVE_TAG) { 327 - brotli_stream_state_t *st = (brotli_stream_state_t *)js_get_native_ptr(js->current_func); 320 + brotli_stream_state_t *st = (brotli_stream_state_t *)js_get_native(js->current_func, DS_BROTLI_NATIVE_TAG); 321 + if (st) 328 322 return brotli_stream_flush(js, st, ctrl_obj); 329 - } 330 323 return js_mkundef(); 331 324 } 332 325 ··· 404 397 } 405 398 406 399 js_set_slot(obj, SLOT_ENTRIES, ts_obj); 400 + js_set_slot_wb(js, transform_fn, SLOT_ENTRIES, obj); 401 + js_set_slot_wb(js, flush_fn, SLOT_ENTRIES, obj); 407 402 return obj; 408 403 } 409 404
+8 -10
src/streams/pipes.c
··· 52 52 } 53 53 54 54 static void pipe_state_finalize(ant_t *js, ant_object_t *obj) { 55 - if (!obj || obj->native.tag != PIPE_STATE_NATIVE_TAG) return; 56 - free(obj->native.ptr); 57 - obj->native.ptr = NULL; 58 - obj->native.tag = 0; 55 + ant_value_t value = js_obj_from_ptr(obj); 56 + free(js_get_native(value, PIPE_STATE_NATIVE_TAG)); 57 + js_clear_native(value, PIPE_STATE_NATIVE_TAG); 59 58 } 60 59 61 60 static pipe_state_t *pipe_get_state(ant_value_t state) { 62 61 if (!js_check_native_tag(state, PIPE_STATE_NATIVE_TAG)) return NULL; 63 - return (pipe_state_t *)js_get_native_ptr(state); 62 + return (pipe_state_t *)js_get_native(state, PIPE_STATE_NATIVE_TAG); 64 63 } 65 64 66 65 static ant_value_t pipe_state_source(ant_value_t state) { ··· 489 488 } tee_state_t; 490 489 491 490 static void tee_state_finalize(ant_t *js, ant_object_t *obj) { 492 - if (!obj || obj->native.tag != TEE_STATE_NATIVE_TAG) return; 493 - free(obj->native.ptr); 494 - obj->native.ptr = NULL; 495 - obj->native.tag = 0; 491 + ant_value_t value = js_obj_from_ptr(obj); 492 + free(js_get_native(value, TEE_STATE_NATIVE_TAG)); 493 + js_clear_native(value, TEE_STATE_NATIVE_TAG); 496 494 } 497 495 498 496 static tee_state_t *tee_get_state(ant_value_t state) { 499 497 if (!js_check_native_tag(state, TEE_STATE_NATIVE_TAG)) return NULL; 500 - return (tee_state_t *)js_get_native_ptr(state); 498 + return (tee_state_t *)js_get_native(state, TEE_STATE_NATIVE_TAG); 501 499 } 502 500 503 501 static ant_value_t tee_state_reader(ant_value_t state) {
+8 -10
src/streams/readable.c
··· 51 51 52 52 rs_stream_t *rs_get_stream(ant_value_t obj) { 53 53 if (!js_check_native_tag(obj, RS_STREAM_NATIVE_TAG)) return NULL; 54 - return (rs_stream_t *)js_get_native_ptr(obj); 54 + return (rs_stream_t *)js_get_native(obj, RS_STREAM_NATIVE_TAG); 55 55 } 56 56 57 57 rs_controller_t *rs_get_controller(ant_value_t obj) { 58 58 if (!js_check_native_tag(obj, RS_CONTROLLER_NATIVE_TAG)) return NULL; 59 - return (rs_controller_t *)js_get_native_ptr(obj); 59 + return (rs_controller_t *)js_get_native(obj, RS_CONTROLLER_NATIVE_TAG); 60 60 } 61 61 62 62 static void rs_stream_finalize(ant_t *js, ant_object_t *obj) { 63 - if (!obj || obj->native.tag != RS_STREAM_NATIVE_TAG) return; 64 - free(obj->native.ptr); 65 - obj->native.ptr = NULL; 66 - obj->native.tag = 0; 63 + ant_value_t value = js_obj_from_ptr(obj); 64 + free(js_get_native(value, RS_STREAM_NATIVE_TAG)); 65 + js_clear_native(value, RS_STREAM_NATIVE_TAG); 67 66 } 68 67 69 68 static void rs_controller_finalize(ant_t *js, ant_object_t *obj) { 70 - if (!obj || obj->native.tag != RS_CONTROLLER_NATIVE_TAG) return; 71 - rs_controller_t *ctrl = (rs_controller_t *)obj->native.ptr; 69 + ant_value_t value = js_obj_from_ptr(obj); 70 + rs_controller_t *ctrl = (rs_controller_t *)js_get_native(value, RS_CONTROLLER_NATIVE_TAG); 72 71 if (!ctrl) return; 73 72 free(ctrl->queue_sizes); 74 73 free(ctrl); 75 - obj->native.ptr = NULL; 76 - obj->native.tag = 0; 74 + js_clear_native(value, RS_CONTROLLER_NATIVE_TAG); 77 75 } 78 76 79 77 ant_value_t rs_stream_controller(ant_t *js, ant_value_t stream_obj) {
+12 -16
src/streams/transform.c
··· 55 55 } 56 56 57 57 static void ts_ws_finalize(ant_t *js, ant_object_t *obj) { 58 - if (!obj || obj->native.tag != WS_STREAM_NATIVE_TAG) return; 59 - free(obj->native.ptr); 60 - obj->native.ptr = NULL; 61 - obj->native.tag = 0; 58 + ant_value_t value = js_obj_from_ptr(obj); 59 + free(js_get_native(value, WS_STREAM_NATIVE_TAG)); 60 + js_clear_native(value, WS_STREAM_NATIVE_TAG); 62 61 } 63 62 64 63 static void ts_ws_ctrl_finalize(ant_t *js, ant_object_t *obj) { 65 - if (!obj || obj->native.tag != WS_CONTROLLER_NATIVE_TAG) return; 66 - ws_controller_t *ctrl = (ws_controller_t *)obj->native.ptr; 64 + ant_value_t value = js_obj_from_ptr(obj); 65 + ws_controller_t *ctrl = (ws_controller_t *)js_get_native(value, WS_CONTROLLER_NATIVE_TAG); 67 66 if (!ctrl) return; 68 67 free(ctrl->queue_sizes); 69 68 free(ctrl); 70 - obj->native.ptr = NULL; 71 - obj->native.tag = 0; 69 + js_clear_native(value, WS_CONTROLLER_NATIVE_TAG); 72 70 } 73 71 74 72 static void ts_rs_finalize(ant_t *js, ant_object_t *obj) { 75 - if (!obj || obj->native.tag != RS_STREAM_NATIVE_TAG) return; 76 - free(obj->native.ptr); 77 - obj->native.ptr = NULL; 78 - obj->native.tag = 0; 73 + ant_value_t value = js_obj_from_ptr(obj); 74 + free(js_get_native(value, RS_STREAM_NATIVE_TAG)); 75 + js_clear_native(value, RS_STREAM_NATIVE_TAG); 79 76 } 80 77 81 78 static void ts_rs_ctrl_finalize(ant_t *js, ant_object_t *obj) { 82 - if (!obj || obj->native.tag != RS_CONTROLLER_NATIVE_TAG) return; 83 - rs_controller_t *ctrl = (rs_controller_t *)obj->native.ptr; 79 + ant_value_t value = js_obj_from_ptr(obj); 80 + rs_controller_t *ctrl = (rs_controller_t *)js_get_native(value, RS_CONTROLLER_NATIVE_TAG); 84 81 if (!ctrl) return; 85 82 free(ctrl->queue_sizes); 86 83 free(ctrl); 87 - obj->native.ptr = NULL; 88 - obj->native.tag = 0; 84 + js_clear_native(value, RS_CONTROLLER_NATIVE_TAG); 89 85 } 90 86 91 87 static inline bool ts_get_backpressure(ant_value_t ts_obj) {
+8 -10
src/streams/writable.c
··· 39 39 40 40 ws_stream_t *ws_get_stream(ant_value_t obj) { 41 41 if (!js_check_native_tag(obj, WS_STREAM_NATIVE_TAG)) return NULL; 42 - return (ws_stream_t *)js_get_native_ptr(obj); 42 + return (ws_stream_t *)js_get_native(obj, WS_STREAM_NATIVE_TAG); 43 43 } 44 44 45 45 ws_controller_t *ws_get_controller(ant_value_t obj) { 46 46 if (!js_check_native_tag(obj, WS_CONTROLLER_NATIVE_TAG)) return NULL; 47 - return (ws_controller_t *)js_get_native_ptr(obj); 47 + return (ws_controller_t *)js_get_native(obj, WS_CONTROLLER_NATIVE_TAG); 48 48 } 49 49 50 50 static void ws_stream_finalize(ant_t *js, ant_object_t *obj) { 51 - if (!obj || obj->native.tag != WS_STREAM_NATIVE_TAG) return; 52 - free(obj->native.ptr); 53 - obj->native.ptr = NULL; 54 - obj->native.tag = 0; 51 + ant_value_t value = js_obj_from_ptr(obj); 52 + free(js_get_native(value, WS_STREAM_NATIVE_TAG)); 53 + js_clear_native(value, WS_STREAM_NATIVE_TAG); 55 54 } 56 55 57 56 static void ws_controller_finalize(ant_t *js, ant_object_t *obj) { 58 - if (!obj || obj->native.tag != WS_CONTROLLER_NATIVE_TAG) return; 59 - ws_controller_t *ctrl = (ws_controller_t *)obj->native.ptr; 57 + ant_value_t value = js_obj_from_ptr(obj); 58 + ws_controller_t *ctrl = (ws_controller_t *)js_get_native(value, WS_CONTROLLER_NATIVE_TAG); 60 59 if (!ctrl) return; 61 60 free(ctrl->queue_sizes); 62 61 free(ctrl); 63 - obj->native.ptr = NULL; 64 - obj->native.tag = 0; 62 + js_clear_native(value, WS_CONTROLLER_NATIVE_TAG); 65 63 } 66 64 67 65 ant_value_t ws_stream_controller(ant_value_t stream_obj) {