+1 -1

include/common.h

reviewed

··· 22 22 SLOT_PROTO, 23 23 SLOT_FUNC_PROTO, 24 24 SLOT_ASYNC_PROTO, 25 25 - SLOT_BUFFER, 25 25 + SLOT_AUX, 26 26 SLOT_TARGET_FUNC, 27 27 SLOT_NAME, 28 28 SLOT_MODULE_CTX,

+7 -2

include/modules/buffer.h

reviewed

··· 49 49 void cleanup_buffer_module(void); 50 50 void free_array_buffer_data(ArrayBufferData *data); 51 51 52 52 - ArrayBufferData *create_array_buffer_data(size_t length); 52 52 + size_t buffer_get_external_memory(void); 53 53 + 53 54 ant_value_t create_arraybuffer_obj(ant_t *js, ArrayBufferData *buffer); 54 55 const char *buffer_typedarray_type_name(TypedArrayType type); 56 56 + 57 57 + ArrayBufferData *create_array_buffer_data(size_t length); 58 58 + ArrayBufferData *buffer_get_arraybuffer_data(ant_value_t value); 59 59 + TypedArrayData *buffer_get_typedarray_data(ant_value_t value); 60 60 + DataViewData *buffer_get_dataview_data(ant_value_t value); 55 61 56 62 ant_value_t create_typed_array( 57 63 ant_t *js, TypedArrayType type, ArrayBufferData *buffer, ··· 70 76 ant_value_t arraybuffer_obj 71 77 ); 72 78 73 73 - size_t buffer_get_external_memory(void); 74 79 bool buffer_is_dataview(ant_value_t obj); 75 80 bool buffer_is_binary_source(ant_value_t value); 76 81 bool buffer_source_get_bytes(ant_t *js, ant_value_t value, const uint8_t **out, size_t *len);

+106 -110

src/ant.c

reviewed

··· 1166 1166 is_set = (tlen == 3 && memcmp(tag_str, "Set", 3) == 0); 1167 1167 is_arraybuffer = (tlen >= 11 && memcmp(tag_str + tlen - 11, "ArrayBuffer", 11) == 0); 1168 1168 1169 1169 - ant_value_t ta_slot = js_get_slot(obj, SLOT_BUFFER); 1170 1170 - if (vtype(ta_slot) == T_TYPEDARRAY) { 1171 1171 - TypedArrayData *ta = (TypedArrayData *)vdata(ta_slot); 1172 1172 - if (ta && ta->buffer) { 1173 1173 - const char *type_name = NULL; 1174 1174 - size_t type_len = 0; 1169 1169 + TypedArrayData *ta = buffer_get_typedarray_data(obj); 1170 1170 + if (ta && ta->buffer) { 1171 1171 + const char *type_name = NULL; 1172 1172 + size_t type_len = 0; 1173 1173 + 1174 1174 + ant_value_t proto = js_get_proto(js, obj); 1175 1175 + ant_value_t buffer_proto = get_ctor_proto(js, "Buffer", 6); 1176 1176 + if (vtype(proto) == T_OBJ && vtype(buffer_proto) == T_OBJ && vdata(proto) == vdata(buffer_proto)) { 1177 1177 + type_name = "Buffer"; 1178 1178 + type_len = 6; 1179 1179 + } else if (ta->type <= TYPED_ARRAY_BIGUINT64) { 1180 1180 + type_name = buffer_typedarray_type_name(ta->type); 1181 1181 + type_len = strlen(type_name); 1182 1182 + } else { 1183 1183 + type_name = "TypedArray"; 1184 1184 + type_len = 10; 1185 1185 + } 1186 1186 + 1187 1187 + n += cpy(buf + n, REMAIN(n, len), type_name, type_len); 1188 1188 + n += (size_t) snprintf(buf + n, REMAIN(n, len), "(%zu) ", ta->length); 1189 1189 + n += cpy(buf + n, REMAIN(n, len), "[ ", 2); 1190 1190 + 1191 1191 + uint8_t *data = ta->buffer->data + ta->byte_offset; 1192 1192 + 1193 1193 + for (size_t i = 0; i < ta->length && i < 100; i++) { 1194 1194 + if (i > 0) n += cpy(buf + n, REMAIN(n, len), ", ", 2); 1175 1195 1176 1176 - ant_value_t proto = js_get_proto(js, obj); 1177 1177 - ant_value_t buffer_proto = get_ctor_proto(js, "Buffer", 6); 1178 1178 - if (vtype(proto) == T_OBJ && vtype(buffer_proto) == T_OBJ && vdata(proto) == vdata(buffer_proto)) { 1179 1179 - type_name = "Buffer"; 1180 1180 - type_len = 6; 1181 1181 - } else if (ta->type <= TYPED_ARRAY_BIGUINT64) { 1182 1182 - type_name = buffer_typedarray_type_name(ta->type); 1183 1183 - type_len = strlen(type_name); 1184 1184 - } else { 1185 1185 - type_name = "TypedArray"; 1186 1186 - type_len = 10; 1196 1196 + switch (ta->type) { 1197 1197 + case TYPED_ARRAY_INT8: 1198 1198 + n += (size_t) snprintf(buf + n, REMAIN(n, len), "%d", (int)((int8_t*)data)[i]); 1199 1199 + break; 1200 1200 + case TYPED_ARRAY_UINT8: 1201 1201 + case TYPED_ARRAY_UINT8_CLAMPED: 1202 1202 + n += (size_t) snprintf(buf + n, REMAIN(n, len), "%u", (unsigned)data[i]); 1203 1203 + break; 1204 1204 + case TYPED_ARRAY_INT16: 1205 1205 + n += (size_t) snprintf(buf + n, REMAIN(n, len), "%d", (int)((int16_t*)data)[i]); 1206 1206 + break; 1207 1207 + case TYPED_ARRAY_UINT16: 1208 1208 + n += (size_t) snprintf(buf + n, REMAIN(n, len), "%u", (unsigned)((uint16_t*)data)[i]); 1209 1209 + break; 1210 1210 + case TYPED_ARRAY_INT32: 1211 1211 + n += (size_t) snprintf(buf + n, REMAIN(n, len), "%d", ((int32_t*)data)[i]); 1212 1212 + break; 1213 1213 + case TYPED_ARRAY_UINT32: 1214 1214 + n += (size_t) snprintf(buf + n, REMAIN(n, len), "%u", ((uint32_t*)data)[i]); 1215 1215 + break; 1216 1216 + case TYPED_ARRAY_FLOAT16: 1217 1217 + n += (size_t) snprintf( 1218 1218 + buf + n, REMAIN(n, len), "%g", half_to_double(((uint16_t*)data)[i]) 1219 1219 + ); 1220 1220 + break; 1221 1221 + case TYPED_ARRAY_FLOAT32: 1222 1222 + n += (size_t) snprintf(buf + n, REMAIN(n, len), "%g", (double)((float*)data)[i]); 1223 1223 + break; 1224 1224 + case TYPED_ARRAY_FLOAT64: 1225 1225 + n += (size_t) snprintf(buf + n, REMAIN(n, len), "%g", ((double*)data)[i]); 1226 1226 + break; 1227 1227 + case TYPED_ARRAY_BIGINT64: 1228 1228 + n += (size_t) snprintf(buf + n, REMAIN(n, len), "%lldn", (long long)((int64_t*)data)[i]); 1229 1229 + break; 1230 1230 + case TYPED_ARRAY_BIGUINT64: 1231 1231 + n += (size_t) snprintf(buf + n, REMAIN(n, len), "%llun", (unsigned long long)((uint64_t*)data)[i]); 1232 1232 + break; 1233 1233 + default: 1234 1234 + n += (size_t) snprintf(buf + n, REMAIN(n, len), "%u", (unsigned)data[i]); 1235 1235 + break; 1187 1236 } 1188 1188 - 1189 1189 - n += cpy(buf + n, REMAIN(n, len), type_name, type_len); 1190 1190 - n += (size_t) snprintf(buf + n, REMAIN(n, len), "(%zu) ", ta->length); 1191 1191 - n += cpy(buf + n, REMAIN(n, len), "[ ", 2); 1192 1192 - 1193 1193 - uint8_t *data = ta->buffer->data + ta->byte_offset; 1194 1194 - 1195 1195 - for (size_t i = 0; i < ta->length && i < 100; i++) { 1196 1196 - if (i > 0) n += cpy(buf + n, REMAIN(n, len), ", ", 2); 1197 1197 - 1198 1198 - switch (ta->type) { 1199 1199 - case TYPED_ARRAY_INT8: 1200 1200 - n += (size_t) snprintf(buf + n, REMAIN(n, len), "%d", (int)((int8_t*)data)[i]); 1201 1201 - break; 1202 1202 - case TYPED_ARRAY_UINT8: 1203 1203 - case TYPED_ARRAY_UINT8_CLAMPED: 1204 1204 - n += (size_t) snprintf(buf + n, REMAIN(n, len), "%u", (unsigned)data[i]); 1205 1205 - break; 1206 1206 - case TYPED_ARRAY_INT16: 1207 1207 - n += (size_t) snprintf(buf + n, REMAIN(n, len), "%d", (int)((int16_t*)data)[i]); 1208 1208 - break; 1209 1209 - case TYPED_ARRAY_UINT16: 1210 1210 - n += (size_t) snprintf(buf + n, REMAIN(n, len), "%u", (unsigned)((uint16_t*)data)[i]); 1211 1211 - break; 1212 1212 - case TYPED_ARRAY_INT32: 1213 1213 - n += (size_t) snprintf(buf + n, REMAIN(n, len), "%d", ((int32_t*)data)[i]); 1214 1214 - break; 1215 1215 - case TYPED_ARRAY_UINT32: 1216 1216 - n += (size_t) snprintf(buf + n, REMAIN(n, len), "%u", ((uint32_t*)data)[i]); 1217 1217 - break; 1218 1218 - case TYPED_ARRAY_FLOAT16: 1219 1219 - n += (size_t) snprintf( 1220 1220 - buf + n, REMAIN(n, len), "%g", half_to_double(((uint16_t*)data)[i]) 1221 1221 - ); 1222 1222 - break; 1223 1223 - case TYPED_ARRAY_FLOAT32: 1224 1224 - n += (size_t) snprintf(buf + n, REMAIN(n, len), "%g", (double)((float*)data)[i]); 1225 1225 - break; 1226 1226 - case TYPED_ARRAY_FLOAT64: 1227 1227 - n += (size_t) snprintf(buf + n, REMAIN(n, len), "%g", ((double*)data)[i]); 1228 1228 - break; 1229 1229 - case TYPED_ARRAY_BIGINT64: 1230 1230 - n += (size_t) snprintf(buf + n, REMAIN(n, len), "%lldn", (long long)((int64_t*)data)[i]); 1231 1231 - break; 1232 1232 - case TYPED_ARRAY_BIGUINT64: 1233 1233 - n += (size_t) snprintf(buf + n, REMAIN(n, len), "%llun", (unsigned long long)((uint64_t*)data)[i]); 1234 1234 - break; 1235 1235 - default: 1236 1236 - n += (size_t) snprintf(buf + n, REMAIN(n, len), "%u", (unsigned)data[i]); 1237 1237 - break; 1238 1238 - } 1239 1239 - } 1240 1240 - 1241 1241 - if (ta->length > 100) n += cpy(buf + n, REMAIN(n, len), ", ...", 5); 1242 1242 - n += cpy(buf + n, REMAIN(n, len), " ]", 2); 1243 1243 - pop_stringify(); 1244 1244 - return n; 1245 1237 } 1238 1238 + 1239 1239 + if (ta->length > 100) n += cpy(buf + n, REMAIN(n, len), ", ...", 5); 1240 1240 + n += cpy(buf + n, REMAIN(n, len), " ]", 2); 1241 1241 + pop_stringify(); 1242 1242 + return n; 1246 1243 } 1247 1244 1248 1245 if (is_arraybuffer) { 1249 1249 - ant_value_t buf_val = js_get_slot(obj, SLOT_BUFFER); 1250 1250 - if (vtype(buf_val) == T_NUM) { 1251 1251 - ArrayBufferData *ab_data = (ArrayBufferData *)(uintptr_t)tod(buf_val); 1246 1246 + ArrayBufferData *ab_data = buffer_get_arraybuffer_data(obj); 1247 1247 + if (ab_data) { 1252 1248 size_t bytelen = ab_data ? ab_data->length : 0; 1253 1249 1254 1250 n += cpy(buf + n, REMAIN(n, len), tag_str, tlen); ··· 1273 1269 1274 1270 bool is_dataview = (tlen == 8 && memcmp(tag_str, "DataView", 8) == 0); 1275 1271 if (is_dataview) { 1276 1276 - ant_value_t dv_data_val = js_get_slot(obj, SLOT_DATA); 1277 1277 - if (vtype(dv_data_val) == T_NUM) { 1278 1278 - DataViewData *dv = (DataViewData *)(uintptr_t)tod(dv_data_val); 1279 1279 - if (dv && dv->buffer) { 1280 1280 - n += cpy(buf + n, REMAIN(n, len), "DataView {\n", 11); 1281 1281 - n += cpy(buf + n, REMAIN(n, len), " [byteLength]: ", 16); 1282 1282 - n += (size_t) snprintf(buf + n, REMAIN(n, len), "%zu", dv->byte_length); 1283 1283 - n += cpy(buf + n, REMAIN(n, len), ",\n", 2); 1284 1284 - n += cpy(buf + n, REMAIN(n, len), " [byteOffset]: ", 16); 1285 1285 - n += (size_t) snprintf(buf + n, REMAIN(n, len), "%zu", dv->byte_offset); 1286 1286 - n += cpy(buf + n, REMAIN(n, len), ",\n", 2); 1287 1287 - n += cpy(buf + n, REMAIN(n, len), " [buffer]: ArrayBuffer {\n", 26); 1288 1288 - n += cpy(buf + n, REMAIN(n, len), " [Uint8Contents]: <", 22); 1289 1289 - 1290 1290 - if (dv->buffer->data && dv->buffer->length > 0) { 1291 1291 - for (size_t i = 0; i < dv->buffer->length; i++) { 1292 1292 - if (i > 0) n += cpy(buf + n, REMAIN(n, len), " ", 1); 1293 1293 - n += (size_t) snprintf(buf + n, REMAIN(n, len), "%02x", dv->buffer->data[i]); 1294 1294 - } 1272 1272 + DataViewData *dv = buffer_get_dataview_data(obj); 1273 1273 + if (dv && dv->buffer) { 1274 1274 + n += cpy(buf + n, REMAIN(n, len), "DataView {\n", 11); 1275 1275 + n += cpy(buf + n, REMAIN(n, len), " [byteLength]: ", 16); 1276 1276 + n += (size_t) snprintf(buf + n, REMAIN(n, len), "%zu", dv->byte_length); 1277 1277 + n += cpy(buf + n, REMAIN(n, len), ",\n", 2); 1278 1278 + n += cpy(buf + n, REMAIN(n, len), " [byteOffset]: ", 16); 1279 1279 + n += (size_t) snprintf(buf + n, REMAIN(n, len), "%zu", dv->byte_offset); 1280 1280 + n += cpy(buf + n, REMAIN(n, len), ",\n", 2); 1281 1281 + n += cpy(buf + n, REMAIN(n, len), " [buffer]: ArrayBuffer {\n", 26); 1282 1282 + n += cpy(buf + n, REMAIN(n, len), " [Uint8Contents]: <", 22); 1283 1283 + 1284 1284 + if (dv->buffer->data && dv->buffer->length > 0) { 1285 1285 + for (size_t i = 0; i < dv->buffer->length; i++) { 1286 1286 + if (i > 0) n += cpy(buf + n, REMAIN(n, len), " ", 1); 1287 1287 + n += (size_t) snprintf(buf + n, REMAIN(n, len), "%02x", dv->buffer->data[i]); 1295 1288 } 1296 1296 - 1297 1297 - n += cpy(buf + n, REMAIN(n, len), ">,\n", 3); 1298 1298 - n += cpy(buf + n, REMAIN(n, len), " [byteLength]: ", 18); 1299 1299 - n += (size_t) snprintf(buf + n, REMAIN(n, len), "%zu", dv->buffer->length); 1300 1300 - n += cpy(buf + n, REMAIN(n, len), "\n }\n}", 6); 1301 1301 - pop_stringify(); 1302 1302 - return n; 1303 1289 } 1290 1290 + 1291 1291 + n += cpy(buf + n, REMAIN(n, len), ">,\n", 3); 1292 1292 + n += cpy(buf + n, REMAIN(n, len), " [byteLength]: ", 18); 1293 1293 + n += (size_t) snprintf(buf + n, REMAIN(n, len), "%zu", dv->buffer->length); 1294 1294 + n += cpy(buf + n, REMAIN(n, len), "\n }\n}", 6); 1295 1295 + pop_stringify(); 1296 1296 + return n; 1304 1297 } 1305 1298 } 1306 1299 ··· 12865 12858 12866 12859 js_esm_cleanup_module_cache(); 12867 12860 code_arena_reset(); 12868 12868 - cleanup_buffer_module(); 12869 12861 cleanup_lmdb_module(); 12870 12862 12871 12863 ant_object_t *lists[] = { js->objects, js->objects_old, js->permanent_objects }; 12872 12872 - for (int i = 0; i < 3; i++) 12873 12873 - for (ant_object_t *obj = lists[i]; obj;) { 12874 12874 - ant_object_t *next = obj->next; 12875 12875 - gc_object_free(js, obj); 12876 12876 - obj = next; 12877 12877 - } 12864 12864 + for (int i = 0; i < 3; i++) for (ant_object_t *obj = lists[i]; obj;) { 12865 12865 + ant_object_t *next = obj->next; 12866 12866 + gc_object_free(js, obj); 12867 12867 + obj = next; 12868 12868 + } 12878 12869 12879 12870 js->objects = NULL; 12880 12871 js->objects_old = NULL; 12881 12872 js->permanent_objects = NULL; 12873 12873 + 12874 12874 + cleanup_buffer_module(); 12882 12875 fixed_arena_destroy(&js->obj_arena); 12883 12876 fixed_arena_destroy(&js->closure_arena); 12884 12877 fixed_arena_destroy(&js->upvalue_arena); ··· 12886 12879 free(js->prop_refs); 12887 12880 js->prop_refs = NULL; 12888 12881 js->prop_refs_len = js->prop_refs_cap = 0; 12882 12882 + 12889 12883 free(js->c_roots); 12890 12884 js->c_roots = NULL; 12891 12885 js->c_root_count = js->c_root_cap = 0; 12886 12886 + 12892 12887 free(js->pending_rejections.items); 12893 12888 js->pending_rejections.items = NULL; 12894 12889 js->pending_rejections.len = js->pending_rejections.cap = 0; ··· 12896 12891 js_pool_destroy(&js->pool.rope); 12897 12892 js_pool_destroy(&js->pool.symbol); 12898 12893 js_pool_destroy(&js->pool.permanent); 12894 12894 + 12899 12895 js_class_pool_destroy(&js->pool.bigint); 12900 12896 js_class_pool_destroy(&js->pool.string); 12901 12897

+2 -2

src/modules/atomics.c

reviewed

··· 83 83 } 84 84 85 85 static bool get_atomic_array_data(ant_t *js, ant_value_t this_val, TypedArrayData **out_data, uint8_t **out_ptr) { 86 86 - ant_value_t ta_data_val = js_get_slot(this_val, SLOT_BUFFER); 87 87 - TypedArrayData *ta_data = (TypedArrayData *)js_gettypedarray(ta_data_val); 86 86 + TypedArrayData *ta_data = buffer_get_typedarray_data(this_val); 88 87 if (!ta_data || !ta_data->buffer) return false; 89 88 90 89 *out_data = ta_data; 91 90 *out_ptr = ta_data->buffer->data + ta_data->byte_offset; 91 91 + 92 92 return true; 93 93 } 94 94

+8 -16

src/modules/blob.c

reviewed

··· 99 99 } 100 100 101 101 if (t == T_OBJ) { 102 102 - ant_value_t buf_slot = js_get_slot(part, SLOT_BUFFER); 103 103 - if (vtype(buf_slot) == T_TYPEDARRAY) { 104 104 - TypedArrayData *ta = (TypedArrayData *)js_gettypedarray(buf_slot); 105 105 - if (ta && ta->buffer && !ta->buffer->is_detached) { 106 106 - if (!byte_buf_append(buf, ta->buffer->data + ta->byte_offset, ta->byte_length)) 107 107 - return js_mkerr(js, "out of memory"); 108 108 - } 102 102 + TypedArrayData *ta = buffer_get_typedarray_data(part); 103 103 + if (ta && ta->buffer && !ta->buffer->is_detached) { 104 104 + if (!byte_buf_append(buf, ta->buffer->data + ta->byte_offset, ta->byte_length)) return js_mkerr(js, "out of memory"); 109 105 return js_mkundef(); 110 106 } 111 111 - if (vtype(buf_slot) == T_NUM) { 112 112 - ArrayBufferData *abd = (ArrayBufferData *)(uintptr_t)(size_t)js_getnum(buf_slot); 113 113 - if (abd && !abd->is_detached) { 114 114 - if (!byte_buf_append(buf, abd->data, abd->length)) 115 115 - return js_mkerr(js, "out of memory"); 116 116 - return js_mkundef(); 117 117 - } 107 107 + ArrayBufferData *abd = buffer_get_arraybuffer_data(part); 108 108 + if (abd && !abd->is_detached) { 109 109 + if (!byte_buf_append(buf, abd->data, abd->length)) return js_mkerr(js, "out of memory"); 110 110 + return js_mkundef(); 118 111 } 119 112 blob_data_t *bd = blob_get_data(part); 120 113 if (bd && bd->size > 0) { 121 121 - if (!byte_buf_append(buf, bd->data, bd->size)) 122 122 - return js_mkerr(js, "out of memory"); 114 114 + if (!byte_buf_append(buf, bd->data, bd->size)) return js_mkerr(js, "out of memory"); 123 115 return js_mkundef(); 124 116 } 125 117 }

+179 -263

src/modules/buffer.c

reviewed

··· 3 3 #include <string.h> 4 4 #include <ctype.h> 5 5 6 6 - #ifdef _WIN32 7 7 - #define WIN32_LEAN_AND_MEAN 8 8 - #include <windows.h> 9 9 - #else 10 10 - #include <sys/mman.h> 11 11 - #endif 12 12 - 13 6 #include "ant.h" 14 7 #include "utf8.h" 15 8 #include "utils.h" ··· 18 11 #include "internal.h" 19 12 #include "runtime.h" 20 13 #include "descriptors.h" 14 14 + #include "ptr.h" 21 15 22 16 #include "silver/engine.h" 23 17 #include "modules/buffer.h" 24 18 #include "modules/symbol.h" 25 19 26 26 - #define TA_ARENA_SIZE (16 * 1024 * 1024) 27 20 #define BUFFER_REGISTRY_INITIAL_CAP 64 28 21 29 29 - static uint8_t *ta_arena = NULL; 30 30 - static size_t ta_arena_offset = 0; 31 31 - 22 22 + static size_t ta_metadata_bytes = 0; 32 23 static size_t buffer_registry_count = 0; 33 24 static size_t buffer_registry_cap = 0; 34 25 35 26 static ArrayBufferData **buffer_registry = NULL; 36 27 static ant_value_t g_typedarray_iter_proto = 0; 37 28 29 29 + enum { 30 30 + BUFFER_ARRAYBUFFER_NATIVE_TAG = 0x41425546u, // ABUF 31 31 + BUFFER_TYPEDARRAY_NATIVE_TAG = 0x54594152u, // TYAR 32 32 + BUFFER_DATAVIEW_NATIVE_TAG = 0x44564957u, // DVIW 33 33 + }; 34 34 + 35 35 + static void *ta_meta_alloc(size_t size) { 36 36 + void *ptr = ant_calloc(size); 37 37 + if (!ptr) return NULL; 38 38 + ta_metadata_bytes += size; 39 39 + return ptr; 40 40 + } 41 41 + 42 42 + static void ta_meta_free(void *ptr, size_t size) { 43 43 + if (!ptr) return; 44 44 + if (ta_metadata_bytes >= size) ta_metadata_bytes -= size; 45 45 + else ta_metadata_bytes = 0; 46 46 + free(ptr); 47 47 + } 48 48 + 49 49 + ArrayBufferData *buffer_get_arraybuffer_data(ant_value_t value) { 50 50 + if (!is_object_type(value) || buffer_is_dataview(value)) return NULL; 51 51 + if (js_check_native_tag(value, BUFFER_ARRAYBUFFER_NATIVE_TAG)) 52 52 + return (ArrayBufferData *)js_get_native_ptr(value); 53 53 + return NULL; 54 54 + } 55 55 + 56 56 + TypedArrayData *buffer_get_typedarray_data(ant_value_t value) { 57 57 + if (vtype(value) == T_TYPEDARRAY) 58 58 + return (TypedArrayData *)js_gettypedarray(value); 59 59 + if (!is_object_type(value)) return NULL; 60 60 + if (js_check_native_tag(value, BUFFER_TYPEDARRAY_NATIVE_TAG)) 61 61 + return (TypedArrayData *)js_get_native_ptr(value); 62 62 + return NULL; 63 63 + } 64 64 + 65 65 + DataViewData *buffer_get_dataview_data(ant_value_t value) { 66 66 + if (!is_object_type(value)) return NULL; 67 67 + if (js_check_native_tag(value, BUFFER_DATAVIEW_NATIVE_TAG)) 68 68 + return (DataViewData *)js_get_native_ptr(value); 69 69 + return NULL; 70 70 + } 71 71 + 72 72 + static void arraybuffer_finalize(ant_t *js, ant_object_t *obj) { 73 73 + ant_value_t value = js_obj_from_ptr(obj); 74 74 + if (!js_check_native_tag(value, BUFFER_ARRAYBUFFER_NATIVE_TAG)) return; 75 75 + ArrayBufferData *data = (ArrayBufferData *)js_get_native_ptr(value); 76 76 + js_set_native_ptr(value, NULL); 77 77 + js_set_native_tag(value, 0); 78 78 + if (data) free_array_buffer_data(data); 79 79 + } 80 80 + 81 81 + static void typedarray_finalize(ant_t *js, ant_object_t *obj) { 82 82 + ant_value_t value = js_obj_from_ptr(obj); 83 83 + if (!js_check_native_tag(value, BUFFER_TYPEDARRAY_NATIVE_TAG)) return; 84 84 + TypedArrayData *ta_data = (TypedArrayData *)js_get_native_ptr(value); 85 85 + js_set_native_ptr(value, NULL); 86 86 + js_set_native_tag(value, 0); 87 87 + if (!ta_data) return; 88 88 + 89 89 + if (ta_data->buffer) free_array_buffer_data(ta_data->buffer); 90 90 + ta_meta_free(ta_data, sizeof(*ta_data)); 91 91 + } 92 92 + 93 93 + static void dataview_finalize(ant_t *js, ant_object_t *obj) { 94 94 + ant_value_t value = js_obj_from_ptr(obj); 95 95 + if (!js_check_native_tag(value, BUFFER_DATAVIEW_NATIVE_TAG)) return; 96 96 + DataViewData *dv_data = (DataViewData *)js_get_native_ptr(value); 97 97 + js_set_native_ptr(value, NULL); 98 98 + js_set_native_tag(value, 0); 99 99 + if (!dv_data) return; 100 100 + 101 101 + if (dv_data->buffer) free_array_buffer_data(dv_data->buffer); 102 102 + ta_meta_free(dv_data, sizeof(*dv_data)); 103 103 + } 104 104 + 38 105 bool buffer_is_dataview(ant_value_t obj) { 39 106 return js_check_brand(obj, BRAND_DATAVIEW); 40 107 } 41 108 42 109 bool buffer_is_binary_source(ant_value_t value) { 43 43 - ant_value_t slot = 0; 44 44 - 45 110 if (vtype(value) == T_TYPEDARRAY) return true; 46 111 if (!is_object_type(value)) return false; 47 112 if (buffer_is_dataview(value)) return true; 48 48 - 49 49 - slot = js_get_slot(value, SLOT_BUFFER); 50 50 - return vtype(slot) == T_TYPEDARRAY || vtype(slot) == T_NUM; 113 113 + return buffer_get_typedarray_data(value) != NULL || buffer_get_arraybuffer_data(value) != NULL; 51 114 } 52 115 53 116 bool buffer_source_get_bytes(ant_t *js, ant_value_t value, const uint8_t **out, size_t *len) { ··· 55 118 if (len) *len = 0; 56 119 if (!buffer_is_binary_source(value)) return false; 57 120 58 58 - ant_value_t slot = js_get_slot(value, SLOT_BUFFER); 59 59 - TypedArrayData *ta = (TypedArrayData *)js_gettypedarray(slot); 121 121 + TypedArrayData *ta = buffer_get_typedarray_data(value); 60 122 61 123 if (ta) { 62 124 if (!ta->buffer || ta->buffer->is_detached) { *out = NULL; *len = 0; return true; } ··· 65 127 return true; 66 128 } 67 129 68 68 - if (vtype(slot) == T_NUM) { 69 69 - ArrayBufferData *ab = (ArrayBufferData *)(uintptr_t)(size_t)js_getnum(slot); 70 70 - if (!ab || ab->is_detached) { *out = NULL; *len = 0; return true; } 130 130 + ArrayBufferData *ab = buffer_get_arraybuffer_data(value); 131 131 + if (ab) { 132 132 + if (ab->is_detached) { *out = NULL; *len = 0; return true; } 71 133 *out = ab->data; 72 134 *len = ab->length; 73 135 return true; 74 136 } 75 137 76 138 if (buffer_is_dataview(value)) { 77 77 - ant_value_t dv_data_val = js_get_slot(value, SLOT_DATA); 78 78 - if (vtype(dv_data_val) != T_NUM) return false; 79 79 - DataViewData *dv = (DataViewData *)(uintptr_t)js_getnum(dv_data_val); 139 139 + DataViewData *dv = buffer_get_dataview_data(value); 80 140 if (!dv || !dv->buffer || dv->buffer->is_detached) { *out = NULL; *len = 0; return true; } 81 141 *out = dv->buffer->data + dv->byte_offset; 82 142 *len = dv->byte_length; ··· 95 155 uint32_t kind = ITER_STATE_KIND(state); 96 156 uint32_t idx = ITER_STATE_INDEX(state); 97 157 98 98 - ant_value_t ta_val = js_get_slot(ta_obj, SLOT_BUFFER); 99 99 - TypedArrayData *ta = (TypedArrayData *)js_gettypedarray(ta_val); 158 158 + TypedArrayData *ta = buffer_get_typedarray_data(ta_obj); 100 159 if (!ta || !ta->buffer || ta->buffer->is_detached || idx >= (uint32_t)ta->length) 101 160 return false; 102 161 ··· 190 249 if (!data || !buffer_registry) return; 191 250 192 251 for (size_t i = 0; i < buffer_registry_count; i++) { 193 193 - if (buffer_registry[i] == data) { 194 194 - buffer_registry[i] = buffer_registry[--buffer_registry_count]; 195 195 - return; 196 196 - } 197 197 - } 252 252 + if (buffer_registry[i] == data) { 253 253 + buffer_registry[i] = buffer_registry[--buffer_registry_count]; 254 254 + return; 255 255 + }} 198 256 } 199 257 200 258 static inline ssize_t normalize_index(ssize_t idx, ssize_t len) { ··· 202 260 if (idx < 0) return 0; 203 261 if (idx > len) return len; 204 262 return idx; 205 205 - } 206 206 - 207 207 - static void *ta_arena_alloc(size_t size) { 208 208 - size = (size + 7) & ~7; 209 209 - 210 210 - if (!ta_arena) { 211 211 - #ifdef _WIN32 212 212 - ta_arena = VirtualAlloc(NULL, TA_ARENA_SIZE, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE); 213 213 - if (!ta_arena) return NULL; 214 214 - #else 215 215 - void *hint = (void *)0x100000; 216 216 - ta_arena = mmap( 217 217 - hint, TA_ARENA_SIZE, PROT_READ | PROT_WRITE, 218 218 - MAP_PRIVATE | MAP_ANONYMOUS, -1, 0); 219 219 - 220 220 - if (ta_arena == MAP_FAILED) { 221 221 - ta_arena = mmap( 222 222 - NULL, TA_ARENA_SIZE, PROT_READ | PROT_WRITE, 223 223 - MAP_PRIVATE | MAP_ANONYMOUS, -1, 0); 224 224 - } 225 225 - if (ta_arena == MAP_FAILED) return NULL; 226 226 - #endif 227 227 - } 228 228 - 229 229 - if (ta_arena_offset + size > TA_ARENA_SIZE) return NULL; 230 230 - void *ptr = ta_arena + ta_arena_offset; 231 231 - ta_arena_offset += size; 232 232 - 233 233 - return ptr; 234 263 } 235 264 236 265 ArrayBufferData *create_array_buffer_data(size_t length) { ··· 340 369 ant_value_t proto = js_get_ctor_proto(js, "ArrayBuffer", 11); 341 370 342 371 if (is_special_object(proto)) js_set_proto_init(obj, proto); 343 343 - js_set_slot(obj, SLOT_BUFFER, ANT_PTR(data)); 372 372 + js_set_native_ptr(obj, data); 373 373 + js_set_native_tag(obj, BUFFER_ARRAYBUFFER_NATIVE_TAG); 344 374 js_set(js, obj, "byteLength", js_mknum((double)length)); 375 375 + js_set_finalizer(obj, arraybuffer_finalize); 345 376 346 377 return obj; 347 378 } ··· 349 380 // ArrayBuffer.prototype.slice(begin, end) 350 381 static ant_value_t js_arraybuffer_slice(ant_t *js, ant_value_t *args, int nargs) { 351 382 ant_value_t this_val = js_getthis(js); 352 352 - ant_value_t data_val = js_get_slot(this_val, SLOT_BUFFER); 353 353 - 354 354 - if (vtype(data_val) != T_NUM) { 355 355 - return js_mkerr(js, "Not an ArrayBuffer"); 356 356 - } 357 357 - 358 358 - ArrayBufferData *data = (ArrayBufferData *)(uintptr_t)js_getnum(data_val); 383 383 + ArrayBufferData *data = buffer_get_arraybuffer_data(this_val); 359 384 if (!data) return js_mkerr(js, "Invalid ArrayBuffer"); 360 385 if (data->is_detached) return js_mkerr(js, "Cannot slice a detached ArrayBuffer"); 361 386 ··· 378 403 ant_value_t proto = js_get_ctor_proto(js, "ArrayBuffer", 11); 379 404 380 405 if (is_special_object(proto)) js_set_proto_init(new_obj, proto); 381 381 - js_set_slot(new_obj, SLOT_BUFFER, ANT_PTR(new_data)); 406 406 + js_set_native_ptr(new_obj, new_data); 407 407 + js_set_native_tag(new_obj, BUFFER_ARRAYBUFFER_NATIVE_TAG); 382 408 js_set(js, new_obj, "byteLength", js_mknum((double)new_length)); 409 409 + js_set_finalizer(new_obj, arraybuffer_finalize); 383 410 384 411 return new_obj; 385 412 } ··· 387 414 // ArrayBuffer.prototype.transfer(newLength) 388 415 static ant_value_t js_arraybuffer_transfer(ant_t *js, ant_value_t *args, int nargs) { 389 416 ant_value_t this_val = js_getthis(js); 390 390 - ant_value_t data_val = js_get_slot(this_val, SLOT_BUFFER); 391 391 - 392 392 - if (vtype(data_val) != T_NUM) { 393 393 - return js_mkerr(js, "Not an ArrayBuffer"); 394 394 - } 395 395 - 396 396 - ArrayBufferData *data = (ArrayBufferData *)(uintptr_t)js_getnum(data_val); 417 417 + ArrayBufferData *data = buffer_get_arraybuffer_data(this_val); 397 418 if (!data) return js_mkerr(js, "Invalid ArrayBuffer"); 398 419 399 420 if (data->is_detached) { ··· 423 444 ant_value_t proto = js_get_ctor_proto(js, "ArrayBuffer", 11); 424 445 425 446 if (is_special_object(proto)) js_set_proto_init(new_obj, proto); 426 426 - js_set_slot(new_obj, SLOT_BUFFER, ANT_PTR(new_data)); 447 447 + js_set_native_ptr(new_obj, new_data); 448 448 + js_set_native_tag(new_obj, BUFFER_ARRAYBUFFER_NATIVE_TAG); 427 449 js_set(js, new_obj, "byteLength", js_mknum((double)new_length)); 450 450 + js_set_finalizer(new_obj, arraybuffer_finalize); 428 451 429 452 return new_obj; 430 453 } ··· 437 460 // ArrayBuffer.prototype.detached getter 438 461 static ant_value_t js_arraybuffer_detached_getter(ant_t *js, ant_value_t *args, int nargs) { 439 462 ant_value_t this_val = js_getthis(js); 440 440 - ant_value_t data_val = js_get_slot(this_val, SLOT_BUFFER); 441 441 - if (vtype(data_val) != T_NUM) return js_false; 442 442 - 443 443 - ArrayBufferData *data = (ArrayBufferData *)(uintptr_t)js_getnum(data_val); 444 444 - if (!data) return js_true; 463 463 + ArrayBufferData *data = buffer_get_arraybuffer_data(this_val); 464 464 + if (!data) return js_false; 445 465 446 466 return js_bool(data->is_detached); 447 467 } ··· 456 476 index = index * 10 + (c - '0'); 457 477 } 458 478 459 459 - ant_value_t ta_val = js_get_slot(obj, SLOT_BUFFER); 460 460 - TypedArrayData *ta_data = (TypedArrayData *)js_gettypedarray(ta_val); 479 479 + TypedArrayData *ta_data = buffer_get_typedarray_data(obj); 461 480 if (!ta_data || index >= ta_data->length) return js_mkundef(); 462 481 if (!ta_data->buffer || ta_data->buffer->is_detached) return js_mkundef(); 463 482 ··· 495 514 index = index * 10 + (c - '0'); 496 515 } 497 516 498 498 - ant_value_t ta_val = js_get_slot(obj, SLOT_BUFFER); 499 499 - TypedArrayData *ta_data = (TypedArrayData *)js_gettypedarray(ta_val); 517 517 + TypedArrayData *ta_data = buffer_get_typedarray_data(obj); 500 518 if (!ta_data || index >= ta_data->length) return true; 501 519 if (!ta_data->buffer || ta_data->buffer->is_detached) return true; 502 520 ··· 577 595 ant_value_t ab_proto = js_get_ctor_proto(js, "ArrayBuffer", 11); 578 596 if (is_special_object(ab_proto)) js_set_proto_init(ab_obj, ab_proto); 579 597 580 580 - js_set_slot(ab_obj, SLOT_BUFFER, js_mknum((double)(uintptr_t)buffer)); 598 598 + js_set_native_ptr(ab_obj, buffer); 599 599 + js_set_native_tag(ab_obj, BUFFER_ARRAYBUFFER_NATIVE_TAG); 581 600 js_set(js, ab_obj, "byteLength", js_mknum((double)buffer->length)); 601 601 + js_set_finalizer(ab_obj, arraybuffer_finalize); 582 602 buffer->ref_count++; 583 603 584 604 return ab_obj; ··· 588 608 ant_t *js, TypedArrayType type, ArrayBufferData *buffer, 589 609 size_t byte_offset, size_t length, const char *type_name, ant_value_t arraybuffer_obj 590 610 ) { 591 591 - TypedArrayData *ta_data = ta_arena_alloc(sizeof(TypedArrayData)); 611 611 + TypedArrayData *ta_data = ta_meta_alloc(sizeof(TypedArrayData)); 592 612 if (!ta_data) return js_mkerr(js, "Failed to allocate TypedArray"); 593 613 594 614 size_t element_size = get_element_size(type); ··· 603 623 ant_value_t proto = js_get_ctor_proto(js, type_name, strlen(type_name)); 604 624 if (is_special_object(proto)) js_set_proto_init(obj, proto); 605 625 606 606 - js_set_slot(obj, SLOT_BUFFER, js_mktypedarray(ta_data)); 626 626 + js_set_native_ptr(obj, ta_data); 627 627 + js_set_native_tag(obj, BUFFER_TYPEDARRAY_NATIVE_TAG); 607 628 js_set(js, obj, "length", js_mknum((double)length)); 608 629 js_set(js, obj, "byteLength", js_mknum((double)(length * element_size))); 609 630 js_set(js, obj, "byteOffset", js_mknum((double)byte_offset)); ··· 612 633 613 634 js_set_getter(obj, typedarray_index_getter); 614 635 js_set_setter(obj, typedarray_index_setter); 636 636 + js_set_finalizer(obj, typedarray_finalize); 615 637 616 638 return obj; 617 639 } ··· 630 652 size_t byte_offset, size_t byte_length, 631 653 ant_value_t arraybuffer_obj 632 654 ) { 633 633 - DataViewData *dv_data = ta_arena_alloc(sizeof(DataViewData)); 655 655 + DataViewData *dv_data = ta_meta_alloc(sizeof(DataViewData)); 634 656 if (!dv_data) return js_mkerr(js, "Failed to allocate DataView"); 635 657 636 658 dv_data->buffer = buffer; ··· 642 664 ant_value_t proto = js_get_ctor_proto(js, "DataView", 8); 643 665 if (is_special_object(proto)) js_set_proto_init(obj, proto); 644 666 667 667 + js_set_native_ptr(obj, dv_data); 668 668 + js_set_native_tag(obj, BUFFER_DATAVIEW_NATIVE_TAG); 645 669 js_set_slot(obj, SLOT_BRAND, js_mknum(BRAND_DATAVIEW)); 646 646 - js_set_slot(obj, SLOT_DATA, ANT_PTR(dv_data)); 647 670 js_mkprop_fast(js, obj, "buffer", 6, arraybuffer_obj); 648 671 js_set_descriptor(js, obj, "buffer", 6, 0); 649 672 js_set(js, obj, "byteLength", js_mknum((double)byte_length)); 650 673 js_set(js, obj, "byteOffset", js_mknum((double)byte_offset)); 674 674 + js_set_finalizer(obj, dataview_finalize); 651 675 652 676 return obj; 653 677 } ··· 685 709 return create_typed_array(js, type, buffer, 0, length, type_name); 686 710 } 687 711 688 688 - ant_value_t buffer_data_val = js_get_slot(args[0], SLOT_BUFFER); 689 689 - if (vtype(buffer_data_val) == T_NUM) { 690 690 - ArrayBufferData *buffer = (ArrayBufferData *)(uintptr_t)js_getnum(buffer_data_val); 712 712 + ArrayBufferData *arraybuffer = buffer_get_arraybuffer_data(args[0]); 713 713 + if (arraybuffer) { 714 714 + ArrayBufferData *buffer = arraybuffer; 691 715 size_t byte_offset = 0; 692 716 size_t length = buffer->length; 693 717 ··· 781 805 // TypedArray.prototype.at(index) 782 806 static ant_value_t js_typedarray_at(ant_t *js, ant_value_t *args, int nargs) { 783 807 ant_value_t this_val = js_getthis(js); 784 784 - ant_value_t ta_data_val = js_get_slot(this_val, SLOT_BUFFER); 785 785 - 786 786 - TypedArrayData *ta_data = (TypedArrayData *)js_gettypedarray(ta_data_val); 808 808 + TypedArrayData *ta_data = buffer_get_typedarray_data(this_val); 787 809 if (!ta_data) return js_mkerr(js, "Invalid TypedArray"); 788 810 789 811 if (nargs == 0 || vtype(args[0]) != T_NUM) return js_mkundef(); ··· 816 838 817 839 static ant_value_t js_typedarray_slice(ant_t *js, ant_value_t *args, int nargs) { 818 840 ant_value_t this_val = js_getthis(js); 819 819 - ant_value_t ta_data_val = js_get_slot(this_val, SLOT_BUFFER); 820 820 - 821 821 - TypedArrayData *ta_data = (TypedArrayData *)js_gettypedarray(ta_data_val); 841 841 + TypedArrayData *ta_data = buffer_get_typedarray_data(this_val); 822 842 if (!ta_data) return js_mkerr(js, "Invalid TypedArray"); 823 843 824 844 ssize_t len = (ssize_t)ta_data->length; ··· 853 873 // TypedArray.prototype.subarray(begin, end) 854 874 static ant_value_t js_typedarray_subarray(ant_t *js, ant_value_t *args, int nargs) { 855 875 ant_value_t this_val = js_getthis(js); 856 856 - ant_value_t ta_data_val = js_get_slot(this_val, SLOT_BUFFER); 857 857 - 858 858 - TypedArrayData *ta_data = (TypedArrayData *)js_gettypedarray(ta_data_val); 876 876 + TypedArrayData *ta_data = buffer_get_typedarray_data(this_val); 859 877 if (!ta_data) return js_mkerr(js, "Invalid TypedArray"); 860 878 861 879 ssize_t len = (ssize_t)ta_data->length; ··· 881 899 // TypedArray.prototype.fill(value, start, end) 882 900 static ant_value_t js_typedarray_fill(ant_t *js, ant_value_t *args, int nargs) { 883 901 ant_value_t this_val = js_getthis(js); 884 884 - ant_value_t ta_data_val = js_get_slot(this_val, SLOT_BUFFER); 885 885 - 886 886 - TypedArrayData *ta_data = (TypedArrayData *)js_gettypedarray(ta_data_val); 902 902 + TypedArrayData *ta_data = buffer_get_typedarray_data(this_val); 887 903 if (!ta_data) return js_mkerr(js, "Invalid TypedArray"); 888 904 889 905 double value = 0; ··· 945 961 if (nargs < 1) return js_mkerr(js, "set requires source argument"); 946 962 947 963 ant_value_t this_val = js_getthis(js); 948 948 - ant_value_t dst_ta_val = js_get_slot(this_val, SLOT_BUFFER); 949 949 - TypedArrayData *dst = (TypedArrayData *)js_gettypedarray(dst_ta_val); 964 964 + TypedArrayData *dst = buffer_get_typedarray_data(this_val); 950 965 if (!dst) return js_mkerr(js, "Invalid TypedArray"); 951 966 if (!dst->buffer || dst->buffer->is_detached) return js_mkerr(js, "Cannot operate on a detached TypedArray"); 952 967 ··· 957 972 if (offset > dst->length) return js_mkerr(js, "Offset out of bounds"); 958 973 959 974 ant_value_t src_val = args[0]; 960 960 - ant_value_t src_ta_val = js_get_slot(src_val, SLOT_BUFFER); 961 961 - TypedArrayData *src_ta = (TypedArrayData *)js_gettypedarray(src_ta_val); 975 975 + TypedArrayData *src_ta = buffer_get_typedarray_data(src_val); 962 976 963 977 if (src_ta && src_ta->buffer && !src_ta->buffer->is_detached) { 964 978 size_t src_len = src_ta->length; ··· 1017 1031 // TypedArray.prototype.copyWithin(target, start, end) 1018 1032 static ant_value_t js_typedarray_copyWithin(ant_t *js, ant_value_t *args, int nargs) { 1019 1033 ant_value_t this_val = js_getthis(js); 1020 1020 - ant_value_t ta_data_val = js_get_slot(this_val, SLOT_BUFFER); 1021 1021 - TypedArrayData *ta = (TypedArrayData *)js_gettypedarray(ta_data_val); 1034 1034 + TypedArrayData *ta = buffer_get_typedarray_data(this_val); 1022 1035 if (!ta) return js_mkerr(js, "Invalid TypedArray"); 1023 1036 if (!ta->buffer || ta->buffer->is_detached) return js_mkerr(js, "Cannot operate on a detached TypedArray"); 1024 1037 ··· 1051 1064 static ant_value_t js_typedarray_toReversed(ant_t *js, ant_value_t *args, int nargs) { 1052 1065 (void)args; (void)nargs; 1053 1066 ant_value_t this_val = js_getthis(js); 1054 1054 - ant_value_t ta_data_val = js_get_slot(this_val, SLOT_BUFFER); 1055 1055 - 1056 1056 - TypedArrayData *ta_data = (TypedArrayData *)js_gettypedarray(ta_data_val); 1067 1067 + TypedArrayData *ta_data = buffer_get_typedarray_data(this_val); 1057 1068 if (!ta_data) return js_mkerr(js, "Invalid TypedArray"); 1058 1069 1059 1070 size_t length = ta_data->length; ··· 1079 1090 // TypedArray.prototype.toSorted(comparefn) 1080 1091 static ant_value_t js_typedarray_toSorted(ant_t *js, ant_value_t *args, int nargs) { 1081 1092 ant_value_t this_val = js_getthis(js); 1082 1082 - ant_value_t ta_data_val = js_get_slot(this_val, SLOT_BUFFER); 1083 1083 - 1084 1084 - TypedArrayData *ta_data = (TypedArrayData *)js_gettypedarray(ta_data_val); 1093 1093 + TypedArrayData *ta_data = buffer_get_typedarray_data(this_val); 1085 1094 if (!ta_data) return js_mkerr(js, "Invalid TypedArray"); 1086 1095 1087 1096 size_t length = ta_data->length; ··· 1095 1104 free_array_buffer_data(new_buffer); 1096 1105 if (is_err(result)) return result; 1097 1106 1098 1098 - ant_value_t result_ta_val = js_get_slot(result, SLOT_BUFFER); 1099 1099 - TypedArrayData *result_ta = (TypedArrayData *)js_gettypedarray(result_ta_val); 1107 1107 + TypedArrayData *result_ta = buffer_get_typedarray_data(result); 1100 1108 uint8_t *data = result_ta->buffer->data; 1101 1109 1102 1110 ant_value_t comparefn = (nargs > 0 && vtype(args[0]) == T_FUNC) ? args[0] : js_mkundef(); ··· 1167 1175 if (nargs < 2) return js_mkerr(js, "with requires index and value"); 1168 1176 1169 1177 ant_value_t this_val = js_getthis(js); 1170 1170 - ant_value_t ta_data_val = js_get_slot(this_val, SLOT_BUFFER); 1171 1171 - 1172 1172 - TypedArrayData *ta_data = (TypedArrayData *)js_gettypedarray(ta_data_val); 1178 1178 + TypedArrayData *ta_data = buffer_get_typedarray_data(this_val); 1173 1179 if (!ta_data) return js_mkerr(js, "Invalid TypedArray"); 1174 1180 1175 1181 ssize_t index = (ssize_t)js_getnum(args[0]); ··· 1347 1353 return js_mkerr(js, "DataView requires an ArrayBuffer"); 1348 1354 } 1349 1355 1350 1350 - ant_value_t buffer_data_val = js_get_slot(args[0], SLOT_BUFFER); 1351 1351 - if (vtype(buffer_data_val) != T_NUM) { 1356 1356 + ArrayBufferData *buffer = buffer_get_arraybuffer_data(args[0]); 1357 1357 + if (!buffer) { 1352 1358 return js_mkerr(js, "First argument must be an ArrayBuffer"); 1353 1359 } 1354 1354 - 1355 1355 - ArrayBufferData *buffer = (ArrayBufferData *)(uintptr_t)js_getnum(buffer_data_val); 1356 1360 size_t byte_offset = 0; 1357 1361 size_t byte_length = buffer->length; 1358 1362 ··· 1371 1375 } 1372 1376 } else byte_length = buffer->length - byte_offset; 1373 1377 1374 1374 - DataViewData *dv_data = ta_arena_alloc(sizeof(DataViewData)); 1378 1378 + DataViewData *dv_data = ta_meta_alloc(sizeof(DataViewData)); 1375 1379 if (!dv_data) return js_mkerr(js, "Failed to allocate DataView"); 1376 1380 1377 1381 dv_data->buffer = buffer; ··· 1383 1387 ant_value_t proto = js_get_ctor_proto(js, "DataView", 8); 1384 1388 if (is_special_object(proto)) js_set_proto_init(obj, proto); 1385 1389 1390 1390 + js_set_native_ptr(obj, dv_data); 1391 1391 + js_set_native_tag(obj, BUFFER_DATAVIEW_NATIVE_TAG); 1386 1392 js_set_slot(obj, SLOT_BRAND, js_mknum(BRAND_DATAVIEW)); 1387 1387 - js_set_slot(obj, SLOT_DATA, ANT_PTR(dv_data)); 1388 1393 js_mkprop_fast(js, obj, "buffer", 6, args[0]); 1389 1394 js_set_descriptor(js, obj, "buffer", 6, 0); 1390 1395 1391 1396 js_set(js, obj, "byteLength", js_mknum((double)byte_length)); 1392 1397 js_set(js, obj, "byteOffset", js_mknum((double)byte_offset)); 1398 1398 + js_set_finalizer(obj, dataview_finalize); 1393 1399 1394 1400 return obj; 1395 1401 } ··· 1399 1405 if (nargs < 1) return js_mkerr(js, "getInt8 requires byteOffset"); 1400 1406 1401 1407 ant_value_t this_val = js_getthis(js); 1402 1402 - ant_value_t dv_data_val = js_get_slot(this_val, SLOT_DATA); 1403 1403 - 1404 1404 - if (vtype(dv_data_val) != T_NUM) { 1405 1405 - return js_mkerr(js, "Not a DataView"); 1406 1406 - } 1407 1407 - 1408 1408 - DataViewData *dv = (DataViewData *)(uintptr_t)js_getnum(dv_data_val); 1408 1408 + DataViewData *dv = buffer_get_dataview_data(this_val); 1409 1409 + if (!dv) return js_mkerr(js, "Not a DataView"); 1409 1410 size_t offset = (size_t)js_getnum(args[0]); 1410 1411 1411 1412 if (offset >= dv->byte_length) { ··· 1421 1422 if (nargs < 2) return js_mkerr(js, "setInt8 requires byteOffset and value"); 1422 1423 1423 1424 ant_value_t this_val = js_getthis(js); 1424 1424 - ant_value_t dv_data_val = js_get_slot(this_val, SLOT_DATA); 1425 1425 - 1426 1426 - if (vtype(dv_data_val) != T_NUM) { 1427 1427 - return js_mkerr(js, "Not a DataView"); 1428 1428 - } 1429 1429 - 1430 1430 - DataViewData *dv = (DataViewData *)(uintptr_t)js_getnum(dv_data_val); 1425 1425 + DataViewData *dv = buffer_get_dataview_data(this_val); 1426 1426 + if (!dv) return js_mkerr(js, "Not a DataView"); 1431 1427 size_t offset = (size_t)js_getnum(args[0]); 1432 1428 int8_t value = (int8_t)js_to_int32(js_getnum(args[1])); 1433 1429 ··· 1444 1440 if (nargs < 1) return js_mkerr(js, "getUint8 requires byteOffset"); 1445 1441 1446 1442 ant_value_t this_val = js_getthis(js); 1447 1447 - ant_value_t dv_data_val = js_get_slot(this_val, SLOT_DATA); 1448 1448 - 1449 1449 - if (vtype(dv_data_val) != T_NUM) { 1450 1450 - return js_mkerr(js, "Not a DataView"); 1451 1451 - } 1452 1452 - 1453 1453 - DataViewData *dv = (DataViewData *)(uintptr_t)js_getnum(dv_data_val); 1443 1443 + DataViewData *dv = buffer_get_dataview_data(this_val); 1444 1444 + if (!dv) return js_mkerr(js, "Not a DataView"); 1454 1445 size_t offset = (size_t)js_getnum(args[0]); 1455 1446 1456 1447 if (offset >= dv->byte_length) { ··· 1466 1457 if (nargs < 2) return js_mkerr(js, "setUint8 requires byteOffset and value"); 1467 1458 1468 1459 ant_value_t this_val = js_getthis(js); 1469 1469 - ant_value_t dv_data_val = js_get_slot(this_val, SLOT_DATA); 1470 1470 - 1471 1471 - if (vtype(dv_data_val) != T_NUM) { 1472 1472 - return js_mkerr(js, "Not a DataView"); 1473 1473 - } 1474 1474 - 1475 1475 - DataViewData *dv = (DataViewData *)(uintptr_t)js_getnum(dv_data_val); 1460 1460 + DataViewData *dv = buffer_get_dataview_data(this_val); 1461 1461 + if (!dv) return js_mkerr(js, "Not a DataView"); 1476 1462 size_t offset = (size_t)js_getnum(args[0]); 1477 1463 uint8_t value = (uint8_t)js_to_uint32(js_getnum(args[1])); 1478 1464 ··· 1489 1475 if (nargs < 1) return js_mkerr(js, "getInt16 requires byteOffset"); 1490 1476 1491 1477 ant_value_t this_val = js_getthis(js); 1492 1492 - ant_value_t dv_data_val = js_get_slot(this_val, SLOT_DATA); 1493 1493 - 1494 1494 - if (vtype(dv_data_val) != T_NUM) { 1495 1495 - return js_mkerr(js, "Not a DataView"); 1496 1496 - } 1497 1497 - 1498 1498 - DataViewData *dv = (DataViewData *)(uintptr_t)js_getnum(dv_data_val); 1478 1478 + DataViewData *dv = buffer_get_dataview_data(this_val); 1479 1479 + if (!dv) return js_mkerr(js, "Not a DataView"); 1499 1480 size_t offset = (size_t)js_getnum(args[0]); 1500 1481 bool little_endian = (nargs > 1 && js_truthy(js, args[1])); 1501 1482 ··· 1520 1501 if (nargs < 1) return js_mkerr(js, "getUint16 requires byteOffset"); 1521 1502 1522 1503 ant_value_t this_val = js_getthis(js); 1523 1523 - ant_value_t dv_data_val = js_get_slot(this_val, SLOT_DATA); 1524 1524 - 1525 1525 - if (vtype(dv_data_val) != T_NUM) { 1526 1526 - return js_mkerr(js, "Not a DataView"); 1527 1527 - } 1528 1528 - 1529 1529 - DataViewData *dv = (DataViewData *)(uintptr_t)js_getnum(dv_data_val); 1504 1504 + DataViewData *dv = buffer_get_dataview_data(this_val); 1505 1505 + if (!dv) return js_mkerr(js, "Not a DataView"); 1530 1506 size_t offset = (size_t)js_getnum(args[0]); 1531 1507 bool little_endian = (nargs > 1 && js_truthy(js, args[1])); 1532 1508 ··· 1548 1524 if (nargs < 2) return js_mkerr(js, "setUint16 requires byteOffset and value"); 1549 1525 1550 1526 ant_value_t this_val = js_getthis(js); 1551 1551 - ant_value_t dv_data_val = js_get_slot(this_val, SLOT_DATA); 1552 1552 - 1553 1553 - if (vtype(dv_data_val) != T_NUM) { 1554 1554 - return js_mkerr(js, "Not a DataView"); 1555 1555 - } 1556 1556 - 1557 1557 - DataViewData *dv = (DataViewData *)(uintptr_t)js_getnum(dv_data_val); 1527 1527 + DataViewData *dv = buffer_get_dataview_data(this_val); 1528 1528 + if (!dv) return js_mkerr(js, "Not a DataView"); 1558 1529 size_t offset = (size_t)js_getnum(args[0]); 1559 1530 uint16_t value = (uint16_t)js_to_uint32(js_getnum(args[1])); 1560 1531 bool little_endian = (nargs > 2 && js_truthy(js, args[2])); ··· 1581 1552 if (nargs < 1) return js_mkerr(js, "getInt32 requires byteOffset"); 1582 1553 1583 1554 ant_value_t this_val = js_getthis(js); 1584 1584 - ant_value_t dv_data_val = js_get_slot(this_val, SLOT_DATA); 1585 1585 - 1586 1586 - if (vtype(dv_data_val) != T_NUM) { 1587 1587 - return js_mkerr(js, "Not a DataView"); 1588 1588 - } 1589 1589 - 1590 1590 - DataViewData *dv = (DataViewData *)(uintptr_t)js_getnum(dv_data_val); 1555 1555 + DataViewData *dv = buffer_get_dataview_data(this_val); 1556 1556 + if (!dv) return js_mkerr(js, "Not a DataView"); 1591 1557 size_t offset = (size_t)js_getnum(args[0]); 1592 1558 bool little_endian = (nargs > 1 && js_truthy(js, args[1])); 1593 1559 ··· 1612 1578 if (nargs < 1) return js_mkerr(js, "getFloat32 requires byteOffset"); 1613 1579 1614 1580 ant_value_t this_val = js_getthis(js); 1615 1615 - ant_value_t dv_data_val = js_get_slot(this_val, SLOT_DATA); 1616 1616 - 1617 1617 - if (vtype(dv_data_val) != T_NUM) { 1618 1618 - return js_mkerr(js, "Not a DataView"); 1619 1619 - } 1620 1620 - 1621 1621 - DataViewData *dv = (DataViewData *)(uintptr_t)js_getnum(dv_data_val); 1581 1581 + DataViewData *dv = buffer_get_dataview_data(this_val); 1582 1582 + if (!dv) return js_mkerr(js, "Not a DataView"); 1622 1583 size_t offset = (size_t)js_getnum(args[0]); 1623 1584 bool little_endian = (nargs > 1 && js_truthy(js, args[1])); 1624 1585 ··· 1645 1606 if (nargs < 2) return js_mkerr(js, "setInt16 requires byteOffset and value"); 1646 1607 1647 1608 ant_value_t this_val = js_getthis(js); 1648 1648 - ant_value_t dv_data_val = js_get_slot(this_val, SLOT_DATA); 1649 1649 - 1650 1650 - if (vtype(dv_data_val) != T_NUM) { 1651 1651 - return js_mkerr(js, "Not a DataView"); 1652 1652 - } 1653 1653 - 1654 1654 - DataViewData *dv = (DataViewData *)(uintptr_t)js_getnum(dv_data_val); 1609 1609 + DataViewData *dv = buffer_get_dataview_data(this_val); 1610 1610 + if (!dv) return js_mkerr(js, "Not a DataView"); 1655 1611 size_t offset = (size_t)js_getnum(args[0]); 1656 1612 int16_t value = (int16_t)js_to_int32(js_getnum(args[1])); 1657 1613 bool little_endian = (nargs > 2 && js_truthy(js, args[2])); ··· 1678 1634 if (nargs < 2) return js_mkerr(js, "setInt32 requires byteOffset and value"); 1679 1635 1680 1636 ant_value_t this_val = js_getthis(js); 1681 1681 - ant_value_t dv_data_val = js_get_slot(this_val, SLOT_DATA); 1682 1682 - 1683 1683 - if (vtype(dv_data_val) != T_NUM) { 1684 1684 - return js_mkerr(js, "Not a DataView"); 1685 1685 - } 1686 1686 - 1687 1687 - DataViewData *dv = (DataViewData *)(uintptr_t)js_getnum(dv_data_val); 1637 1637 + DataViewData *dv = buffer_get_dataview_data(this_val); 1638 1638 + if (!dv) return js_mkerr(js, "Not a DataView"); 1688 1639 size_t offset = (size_t)js_getnum(args[0]); 1689 1640 int32_t value = js_to_int32(js_getnum(args[1])); 1690 1641 bool little_endian = (nargs > 2 && js_truthy(js, args[2])); ··· 1715 1666 if (nargs < 1) return js_mkerr(js, "getUint32 requires byteOffset"); 1716 1667 1717 1668 ant_value_t this_val = js_getthis(js); 1718 1718 - ant_value_t dv_data_val = js_get_slot(this_val, SLOT_DATA); 1719 1719 - 1720 1720 - if (vtype(dv_data_val) != T_NUM) { 1721 1721 - return js_mkerr(js, "Not a DataView"); 1722 1722 - } 1723 1723 - 1724 1724 - DataViewData *dv = (DataViewData *)(uintptr_t)js_getnum(dv_data_val); 1669 1669 + DataViewData *dv = buffer_get_dataview_data(this_val); 1670 1670 + if (!dv) return js_mkerr(js, "Not a DataView"); 1725 1671 size_t offset = (size_t)js_getnum(args[0]); 1726 1672 bool little_endian = (nargs > 1 && js_truthy(js, args[1])); 1727 1673 ··· 1743 1689 if (nargs < 2) return js_mkerr(js, "setUint32 requires byteOffset and value"); 1744 1690 1745 1691 ant_value_t this_val = js_getthis(js); 1746 1746 - ant_value_t dv_data_val = js_get_slot(this_val, SLOT_DATA); 1747 1747 - 1748 1748 - if (vtype(dv_data_val) != T_NUM) { 1749 1749 - return js_mkerr(js, "Not a DataView"); 1750 1750 - } 1751 1751 - 1752 1752 - DataViewData *dv = (DataViewData *)(uintptr_t)js_getnum(dv_data_val); 1692 1692 + DataViewData *dv = buffer_get_dataview_data(this_val); 1693 1693 + if (!dv) return js_mkerr(js, "Not a DataView"); 1753 1694 size_t offset = (size_t)js_getnum(args[0]); 1754 1695 1755 1696 uint32_t value = js_to_uint32(js_getnum(args[1])); ··· 1778 1719 if (nargs < 2) return js_mkerr(js, "setFloat32 requires byteOffset and value"); 1779 1720 1780 1721 ant_value_t this_val = js_getthis(js); 1781 1781 - ant_value_t dv_data_val = js_get_slot(this_val, SLOT_DATA); 1782 1782 - 1783 1783 - if (vtype(dv_data_val) != T_NUM) { 1784 1784 - return js_mkerr(js, "Not a DataView"); 1785 1785 - } 1786 1786 - 1787 1787 - DataViewData *dv = (DataViewData *)(uintptr_t)js_getnum(dv_data_val); 1722 1722 + DataViewData *dv = buffer_get_dataview_data(this_val); 1723 1723 + if (!dv) return js_mkerr(js, "Not a DataView"); 1788 1724 size_t offset = (size_t)js_getnum(args[0]); 1789 1725 float value = (float)js_getnum(args[1]); 1790 1726 bool little_endian = (nargs > 2 && js_truthy(js, args[2])); ··· 1817 1753 if (nargs < 1) return js_mkerr(js, "getFloat64 requires byteOffset"); 1818 1754 1819 1755 ant_value_t this_val = js_getthis(js); 1820 1820 - ant_value_t dv_data_val = js_get_slot(this_val, SLOT_DATA); 1821 1821 - 1822 1822 - if (vtype(dv_data_val) != T_NUM) { 1823 1823 - return js_mkerr(js, "Not a DataView"); 1824 1824 - } 1825 1825 - 1826 1826 - DataViewData *dv = (DataViewData *)(uintptr_t)js_getnum(dv_data_val); 1756 1756 + DataViewData *dv = buffer_get_dataview_data(this_val); 1757 1757 + if (!dv) return js_mkerr(js, "Not a DataView"); 1827 1758 size_t offset = (size_t)js_getnum(args[0]); 1828 1759 bool little_endian = (nargs > 1 && js_truthy(js, args[1])); 1829 1760 ··· 1852 1783 if (nargs < 2) return js_mkerr(js, "setFloat64 requires byteOffset and value"); 1853 1784 1854 1785 ant_value_t this_val = js_getthis(js); 1855 1855 - ant_value_t dv_data_val = js_get_slot(this_val, SLOT_DATA); 1856 1856 - 1857 1857 - if (vtype(dv_data_val) != T_NUM) { 1858 1858 - return js_mkerr(js, "Not a DataView"); 1859 1859 - } 1860 1860 - 1861 1861 - DataViewData *dv = (DataViewData *)(uintptr_t)js_getnum(dv_data_val); 1786 1786 + DataViewData *dv = buffer_get_dataview_data(this_val); 1787 1787 + if (!dv) return js_mkerr(js, "Not a DataView"); 1862 1788 size_t offset = (size_t)js_getnum(args[0]); 1863 1789 double value = js_getnum(args[1]); 1864 1790 bool little_endian = (nargs > 2 && js_truthy(js, args[2])); ··· 2045 1971 } 2046 1972 2047 1973 static ant_value_t typedarray_join_with(ant_t *js, ant_value_t this_val, const char *sep, size_t sep_len) { 2048 2048 - ant_value_t ta_data_val = js_get_slot(this_val, SLOT_BUFFER); 2049 2049 - 2050 2050 - TypedArrayData *ta_data = (TypedArrayData *)js_gettypedarray(ta_data_val); 1974 1974 + TypedArrayData *ta_data = buffer_get_typedarray_data(this_val); 2051 1975 if (!ta_data) return js_mkstr(js, "", 0); 2052 1976 if (!ta_data->buffer || ta_data->buffer->is_detached || ta_data->length == 0) 2053 1977 return js_mkstr(js, "", 0); ··· 2119 2043 2120 2044 static ant_value_t js_typedarray_indexOf(ant_t *js, ant_value_t *args, int nargs) { 2121 2045 ant_value_t this_val = js_getthis(js); 2122 2122 - ant_value_t ta_data_val = js_get_slot(this_val, SLOT_BUFFER); 2123 2123 - 2124 2124 - TypedArrayData *ta_data = (TypedArrayData *)js_gettypedarray(ta_data_val); 2046 2046 + TypedArrayData *ta_data = buffer_get_typedarray_data(this_val); 2125 2047 if (!ta_data || !ta_data->buffer || ta_data->buffer->is_detached) return js_mknum(-1); 2126 2048 2127 2049 size_t len = ta_data->length; ··· 2170 2092 // Buffer.prototype.toString(encoding) 2171 2093 static ant_value_t js_buffer_toString(ant_t *js, ant_value_t *args, int nargs) { 2172 2094 ant_value_t this_val = js_getthis(js); 2173 2173 - ant_value_t ta_data_val = js_get_slot(this_val, SLOT_BUFFER); 2174 2174 - 2175 2175 - TypedArrayData *ta_data = (TypedArrayData *)js_gettypedarray(ta_data_val); 2095 2095 + TypedArrayData *ta_data = buffer_get_typedarray_data(this_val); 2176 2096 if (!ta_data) return js_mkerr(js, "Invalid Buffer"); 2177 2097 2178 2098 BufferEncoding encoding = ENC_UTF8; ··· 2253 2173 if (nargs < 1) return js_mkerr(js, "write requires a string"); 2254 2174 2255 2175 ant_value_t this_val = js_getthis(js); 2256 2256 - ant_value_t ta_data_val = js_get_slot(this_val, SLOT_BUFFER); 2257 2257 - 2258 2258 - TypedArrayData *ta_data = (TypedArrayData *)js_gettypedarray(ta_data_val); 2176 2176 + TypedArrayData *ta_data = buffer_get_typedarray_data(this_val); 2259 2177 if (!ta_data) return js_mkerr(js, "Invalid Buffer"); 2260 2178 2261 2179 size_t str_len; ··· 2377 2295 snprintf(idx, sizeof(idx), "%zu", i); 2378 2296 ant_value_t buf = js_get(js, list, idx); 2379 2297 2380 2380 - ant_value_t ta_data_val = js_get_slot(buf, SLOT_BUFFER); 2381 2381 - TypedArrayData *ta = js_gettypedarray(ta_data_val); 2298 2298 + TypedArrayData *ta = buffer_get_typedarray_data(buf); 2382 2299 if (!ta || !ta->buffer) continue; 2383 2300 2384 2301 size_t copy_len = ta->byte_length; ··· 2397 2314 static ant_value_t js_buffer_compare(ant_t *js, ant_value_t *args, int nargs) { 2398 2315 if (nargs < 2) return js_mkerr(js, "Buffer.compare requires two arguments"); 2399 2316 2400 2400 - ant_value_t ta1_val = js_get_slot(args[0], SLOT_BUFFER); 2401 2401 - ant_value_t ta2_val = js_get_slot(args[1], SLOT_BUFFER); 2402 2402 - 2403 2403 - TypedArrayData *ta1 = js_gettypedarray(ta1_val); 2404 2404 - TypedArrayData *ta2 = js_gettypedarray(ta2_val); 2317 2317 + TypedArrayData *ta1 = buffer_get_typedarray_data(args[0]); 2318 2318 + TypedArrayData *ta2 = buffer_get_typedarray_data(args[1]); 2405 2319 2406 2320 if (!ta1 || !ta2) { 2407 2321 return js_mkerr(js, "Arguments must be Buffers"); ··· 2440 2354 ant_value_t proto = js_get_ctor_proto(js, "SharedArrayBuffer", 17); 2441 2355 2442 2356 if (is_special_object(proto)) js_set_proto_init(obj, proto); 2443 2443 - js_set_slot(obj, SLOT_BUFFER, ANT_PTR(data)); 2357 2357 + js_set_native_ptr(obj, data); 2358 2358 + js_set_native_tag(obj, BUFFER_ARRAYBUFFER_NATIVE_TAG); 2444 2359 js_set(js, obj, "byteLength", js_mknum((double)length)); 2360 2360 + js_set_finalizer(obj, arraybuffer_finalize); 2445 2361 2446 2362 return obj; 2447 2363 } ··· 2642 2558 buffer_registry_cap = 0; 2643 2559 } 2644 2560 2645 2645 - ta_arena_offset = 0; 2561 2561 + ta_metadata_bytes = 0; 2646 2562 } 2647 2563 2648 2564 size_t buffer_get_external_memory(void) { 2649 2649 - size_t total = ta_arena ? ta_arena_offset : 0; 2565 2565 + size_t total = ta_metadata_bytes; 2650 2566 2651 2567 for (size_t i = 0; i < buffer_registry_count; i++) { 2652 2568 if (buffer_registry[i])

+1 -2

src/modules/child_process.c

reviewed

··· 585 585 data = js_getstr(js, data_arg, &data_len); 586 586 if (!data) return js_mkerr(js, "Data must be a string or Buffer"); 587 587 } else { 588 588 - ant_value_t ta_data_val = js_get_slot(data_arg, SLOT_BUFFER); 589 589 - TypedArrayData *ta_data = (TypedArrayData *)js_gettypedarray(ta_data_val); 588 588 + TypedArrayData *ta_data = buffer_get_typedarray_data(data_arg); 590 589 if (!ta_data || !ta_data->buffer || !ta_data->buffer->data) { 591 590 return js_mkerr(js, "Data must be a string or Buffer"); 592 591 }

+7 -9

src/modules/crypto.c

reviewed

··· 45 45 } 46 46 47 47 static bool crypto_get_mutable_bytes(ant_value_t value, uint8_t **out, size_t *len) { 48 48 - ant_value_t slot = js_get_slot(value, SLOT_BUFFER); 49 49 - if (vtype(slot) == T_TYPEDARRAY) { 50 50 - TypedArrayData *ta = (TypedArrayData *)js_gettypedarray(slot); 51 51 - if (!ta || !ta->buffer || ta->buffer->is_detached) return false; 48 48 + TypedArrayData *ta = buffer_get_typedarray_data(value); 49 49 + if (ta) { 50 50 + if (!ta->buffer || ta->buffer->is_detached) return false; 52 51 *out = ta->buffer->data + ta->byte_offset; 53 52 *len = ta->byte_length; 54 53 return true; 55 54 } 56 55 57 57 - if (vtype(slot) == T_NUM) { 58 58 - ArrayBufferData *ab = (ArrayBufferData *)(uintptr_t)(size_t)js_getnum(slot); 59 59 - if (!ab || ab->is_detached) return false; 56 56 + ArrayBufferData *ab = buffer_get_arraybuffer_data(value); 57 57 + if (ab) { 58 58 + if (ab->is_detached) return false; 60 59 *out = ab->data; 61 60 *len = ab->length; 62 61 return true; ··· 354 353 return js_mkerr(js, "libsodium initialization failed"); 355 354 } 356 355 357 357 - ant_value_t ta_data_val = js_get_slot(args[0], SLOT_BUFFER); 358 358 - TypedArrayData *ta_data = (TypedArrayData *)js_gettypedarray(ta_data_val); 356 356 + TypedArrayData *ta_data = buffer_get_typedarray_data(args[0]); 359 357 if (!ta_data || !ta_data->buffer) { 360 358 return js_mkerr(js, "argument must be a TypedArray"); 361 359 }

+1 -2

src/modules/fetch.c

reviewed

··· 265 265 } 266 266 267 267 static bool fetch_get_upload_chunk(ant_value_t value, const uint8_t **out, size_t *len) { 268 268 - ant_value_t slot = js_get_slot(value, SLOT_BUFFER); 269 269 - TypedArrayData *ta = (TypedArrayData *)js_gettypedarray(slot); 268 268 + TypedArrayData *ta = buffer_get_typedarray_data(value); 270 269 271 270 if (!ta || ta->type != TYPED_ARRAY_UINT8) return false; 272 271 if (!ta->buffer || ta->buffer->is_detached) {

+8 -16

src/modules/fs.c

reviewed

··· 2868 2868 ssize_t bytes_read = uv_req->result; 2869 2869 2870 2870 if (req->data && bytes_read > 0) { 2871 2871 - ant_value_t ta_val = js_get_slot(req->target_buffer, SLOT_BUFFER); 2872 2872 - TypedArrayData *ta = (TypedArrayData *)js_gettypedarray(ta_val); 2871 2871 + TypedArrayData *ta = buffer_get_typedarray_data(req->target_buffer); 2873 2872 if (ta && ta->buffer && ta->buffer->data) { 2874 2873 uint8_t *dest = ta->buffer->data + ta->byte_offset + req->buf_offset; 2875 2874 memcpy(dest, req->data, (size_t)bytes_read); ··· 2897 2896 int fd = (int)js_getnum(args[0]); 2898 2897 2899 2898 ant_value_t buf_arg = args[1]; 2900 2900 - ant_value_t ta_data_val = js_get_slot(buf_arg, SLOT_BUFFER); 2901 2901 - TypedArrayData *ta_data = (TypedArrayData *)js_gettypedarray(ta_data_val); 2899 2899 + TypedArrayData *ta_data = buffer_get_typedarray_data(buf_arg); 2902 2900 if (!ta_data || !ta_data->buffer || !ta_data->buffer->data) 2903 2901 return js_mkerr(js, "read() buffer argument must be a Buffer or TypedArray"); 2904 2902 ··· 2959 2957 2960 2958 int fd = (int)js_getnum(args[0]); 2961 2959 2962 2962 - ant_value_t ta_data_val = js_get_slot(args[1], SLOT_BUFFER); 2963 2963 - TypedArrayData *ta_data = (TypedArrayData *)js_gettypedarray(ta_data_val); 2960 2960 + TypedArrayData *ta_data = buffer_get_typedarray_data(args[1]); 2964 2961 if (!ta_data || !ta_data->buffer || !ta_data->buffer->data) 2965 2962 return js_mkerr(js, "readSync() second argument must be a Buffer, TypedArray, or DataView"); 2966 2963 ··· 3022 3019 return js_mknum((double)result); 3023 3020 } 3024 3021 3025 3025 - ant_value_t ta_data_val = js_get_slot(args[1], SLOT_BUFFER); 3026 3026 - TypedArrayData *ta_data = (TypedArrayData *)js_gettypedarray(ta_data_val); 3022 3022 + TypedArrayData *ta_data = buffer_get_typedarray_data(args[1]); 3027 3023 if (!ta_data || !ta_data->buffer || !ta_data->buffer->data) 3028 3024 return js_mkerr(js, "writeSync() second argument must be a Buffer, TypedArray, DataView, or string"); 3029 3025 ··· 3082 3078 write_data = str; 3083 3079 write_len = str_len; 3084 3080 } else { 3085 3085 - ant_value_t ta_data_val = js_get_slot(args[1], SLOT_BUFFER); 3086 3086 - TypedArrayData *ta_data = (TypedArrayData *)js_gettypedarray(ta_data_val); 3081 3081 + TypedArrayData *ta_data = buffer_get_typedarray_data(args[1]); 3087 3082 if (!ta_data || !ta_data->buffer || !ta_data->buffer->data) 3088 3083 return js_mkerr(js, "write() second argument must be a Buffer, TypedArray, DataView, or string"); 3089 3084 ··· 3162 3157 3163 3158 for (ant_offset_t i = 0; i < arr_len; i++) { 3164 3159 ant_value_t item = js_arr_get(js, args[1], i); 3165 3165 - ant_value_t ta_val = js_get_slot(item, SLOT_BUFFER); 3166 3166 - TypedArrayData *ta = (TypedArrayData *)js_gettypedarray(ta_val); 3160 3160 + TypedArrayData *ta = buffer_get_typedarray_data(item); 3167 3161 if (!ta || !ta->buffer || !ta->buffer->data) { 3168 3162 free(bufs); 3169 3163 return js_mkerr(js, "writevSync() buffers must contain ArrayBufferViews"); ··· 3200 3194 size_t total_len = 0; 3201 3195 for (ant_offset_t i = 0; i < arr_len; i++) { 3202 3196 ant_value_t item = js_arr_get(js, args[1], i); 3203 3203 - ant_value_t ta_val = js_get_slot(item, SLOT_BUFFER); 3204 3204 - TypedArrayData *ta = (TypedArrayData *)js_gettypedarray(ta_val); 3197 3197 + TypedArrayData *ta = buffer_get_typedarray_data(item); 3205 3198 if (!ta || !ta->buffer || !ta->buffer->data) 3206 3199 return js_mkerr(js, "writev() buffers must contain ArrayBufferViews"); 3207 3200 total_len += ta->byte_length; ··· 3219 3212 size_t off = 0; 3220 3213 for (ant_offset_t i = 0; i < arr_len; i++) { 3221 3214 ant_value_t item = js_arr_get(js, args[1], i); 3222 3222 - ant_value_t ta_val = js_get_slot(item, SLOT_BUFFER); 3223 3223 - TypedArrayData *ta = (TypedArrayData *)js_gettypedarray(ta_val); 3215 3215 + TypedArrayData *ta = buffer_get_typedarray_data(item); 3224 3216 memcpy(req->data + off, ta->buffer->data + ta->byte_offset, ta->byte_length); 3225 3217 off += ta->byte_length; 3226 3218 }

+1 -1

src/modules/io.c

reviewed

··· 587 587 [SLOT_PROTO] = "PROTO", 588 588 [SLOT_FUNC_PROTO] = "FUNC_PROTO", 589 589 [SLOT_ASYNC_PROTO] = "ASYNC_PROTO", 590 590 - [SLOT_BUFFER] = "BUFFER", 590 590 + [SLOT_AUX] = "AUX", 591 591 [SLOT_TARGET_FUNC] = "TARGET_FUNC", 592 592 [SLOT_NAME] = "NAME", 593 593 [SLOT_MODULE_CTX] = "MODULE_CTX",

+7 -9

src/modules/lmdb.c

reviewed

··· 298 298 } 299 299 300 300 if (vtype(input) == T_OBJ) { 301 301 - ant_value_t slot = js_get_slot(input, SLOT_BUFFER); 302 302 - 303 303 - if (vtype(slot) == T_TYPEDARRAY) { 304 304 - TypedArrayData *ta = (TypedArrayData *)js_gettypedarray(slot); 305 305 - if (!ta || !ta->buffer || !ta->buffer->data) return false; 301 301 + TypedArrayData *ta = buffer_get_typedarray_data(input); 302 302 + if (ta) { 303 303 + if (!ta->buffer || !ta->buffer->data) return false; 306 304 out->mv_data = (void *)(ta->buffer->data + ta->byte_offset); 307 305 out->mv_size = ta->byte_length; 308 306 return true; 309 307 } 310 310 - 311 311 - if (vtype(slot) == T_NUM) { 312 312 - ArrayBufferData *ab = (ArrayBufferData *)(uintptr_t)js_getnum(slot); 313 313 - if (!ab || !ab->data) return false; 308 308 + 309 309 + ArrayBufferData *ab = buffer_get_arraybuffer_data(input); 310 310 + if (ab) { 311 311 + if (!ab->data) return false; 314 312 out->mv_data = (void *)ab->data; 315 313 out->mv_size = ab->length; 316 314 return true;

+5 -21

src/modules/napi.c

reviewed

··· 345 345 napi_value value, 346 346 TypedArrayData **out 347 347 ) { 348 348 - ant_value_t slot = js_get_slot((ant_value_t)value, SLOT_BUFFER); 349 349 - if (vtype(slot) != T_TYPEDARRAY) return false; 350 350 - TypedArrayData *ta = (TypedArrayData *)js_gettypedarray(slot); 348 348 + TypedArrayData *ta = buffer_get_typedarray_data((ant_value_t)value); 351 349 if (!ta || !ta->buffer || ta->buffer->is_detached) return false; 352 350 *out = ta; 353 351 return true; ··· 1081 1079 return napi_set_last(env, napi_invalid_arg, "invalid argument"); 1082 1080 } 1083 1081 1084 1084 - ant_value_t slot = js_get_slot((ant_value_t)arraybuffer, SLOT_BUFFER); 1085 1085 - if (vtype(slot) != T_NUM) return napi_set_last(env, napi_arraybuffer_expected, "arraybuffer expected"); 1086 1086 - 1087 1087 - ArrayBufferData *ab = (ArrayBufferData *)(uintptr_t)js_getnum(slot); 1082 1082 + ArrayBufferData *ab = buffer_get_arraybuffer_data((ant_value_t)arraybuffer); 1088 1083 if (!ab || ab->is_detached) return napi_set_last(env, napi_arraybuffer_expected, "invalid arraybuffer"); 1089 1084 1090 1085 TypedArrayType ta_type; ··· 1416 1411 if (!nenv || !nenv->js) return napi_set_last(env, napi_invalid_arg, "invalid env"); 1417 1412 if (!is_object_type((ant_value_t)arraybuffer)) return napi_set_last(env, napi_arraybuffer_expected, "arraybuffer expected"); 1418 1413 1419 1419 - ant_value_t slot = js_get_slot((ant_value_t)arraybuffer, SLOT_BUFFER); 1420 1420 - if (vtype(slot) != T_NUM) return napi_set_last(env, napi_arraybuffer_expected, "arraybuffer expected"); 1421 1421 - 1422 1422 - ArrayBufferData *ab = (ArrayBufferData *)(uintptr_t)js_getnum(slot); 1414 1414 + ArrayBufferData *ab = buffer_get_arraybuffer_data((ant_value_t)arraybuffer); 1423 1415 if (!ab || ab->is_detached) return napi_set_last(env, napi_arraybuffer_expected, "arraybuffer expected"); 1424 1416 1425 1417 if (data) *data = ab->data; ··· 1926 1918 if (!nenv || !nenv->js || !result) return napi_set_last(env, napi_invalid_arg, "invalid argument"); 1927 1919 if (!is_object_type((ant_value_t)value)) { *result = false; return napi_set_last(env, napi_ok, NULL); } 1928 1920 1929 1929 - ant_value_t slot = js_get_slot((ant_value_t)value, SLOT_BUFFER); 1930 1930 - if (vtype(slot) != T_NUM) { 1931 1931 - *result = false; 1932 1932 - } else { 1933 1933 - ant_value_t buf_prop = js_get(nenv->js, (ant_value_t)value, "buffer"); 1934 1934 - *result = vtype(buf_prop) == T_UNDEF; 1935 1935 - } 1921 1921 + *result = buffer_get_arraybuffer_data((ant_value_t)value) != NULL; 1936 1922 return napi_set_last(env, napi_ok, NULL); 1937 1923 } 1938 1924 ··· 1978 1964 if (!is_object_type((ant_value_t)value)) { 1979 1965 *result = false; 1980 1966 } else { 1981 1981 - ant_value_t slot = js_get_slot((ant_value_t)value, SLOT_DATA); 1982 1982 - ant_value_t byte_len = js_get(nenv->js, (ant_value_t)value, "byteLength"); 1983 1983 - *result = vtype(slot) == T_NUM && vtype(byte_len) == T_NUM; 1967 1967 + *result = buffer_get_dataview_data((ant_value_t)value) != NULL; 1984 1968 } 1985 1969 return napi_set_last(env, napi_ok, NULL); 1986 1970 }

+2 -5

src/modules/net.c

reviewed

··· 705 705 706 706 copy = malloc(parsed.len); 707 707 if (!copy) return js_mkerr_typed(js, JS_ERR_TYPE, "Out of memory"); 708 708 + 708 709 memcpy(copy, parsed.bytes, parsed.len); 709 709 - 710 710 - if (ant_conn_write(socket->conn, copy, parsed.len, NULL, NULL) != 0) { 711 711 - free(copy); 712 712 - return js_false; 713 713 - } 710 710 + if (ant_conn_write(socket->conn, copy, parsed.len, NULL, NULL) != 0) return js_false; 714 711 715 712 GC_ROOT_SAVE(root_mark, js); 716 713 GC_ROOT_PIN(js, parsed.callback);

+1 -2

src/modules/response.c

reviewed

··· 395 395 396 396 static bool response_chunk_is_uint8_array(ant_value_t chunk, TypedArrayData **out_ta) { 397 397 if (!is_object_type(chunk)) return false; 398 398 - ant_value_t slot = js_get_slot(chunk, SLOT_BUFFER); 399 399 - TypedArrayData *ta = (TypedArrayData *)js_gettypedarray(slot); 398 398 + TypedArrayData *ta = buffer_get_typedarray_data(chunk); 400 399 if (!ta || !ta->buffer || ta->buffer->is_detached) return false; 401 400 if (ta->type != TYPED_ARRAY_UINT8) return false; 402 401 *out_ta = ta;

+1 -2

src/modules/server.c

reviewed

··· 343 343 } 344 344 345 345 static bool server_response_chunk(server_request_t *req, ant_value_t value, const uint8_t **out, size_t *len) { 346 346 - ant_value_t slot = js_get_slot(value, SLOT_BUFFER); 347 347 - TypedArrayData *ta = (TypedArrayData *)js_gettypedarray(slot); 346 346 + TypedArrayData *ta = buffer_get_typedarray_data(value); 348 347 349 348 if (!ta || ta->type != TYPED_ARRAY_UINT8) return false; 350 349 if (!ta->buffer || ta->buffer->is_detached) {

+4 -11

src/modules/structured-clone.c

reviewed

··· 77 77 78 78 static ant_value_t sc_clone_rec(ant_t *js, ant_value_t val, sc_entry_t **seen, sc_entry_t **transfer) { 79 79 uint8_t t = vtype(val); 80 80 - ant_value_t slot = js_mkundef(); 81 80 TypedArrayData *ta_data = NULL; 82 81 83 82 if (t == T_UNDEF || t == T_NULL || t == T_BOOL || t == T_NUM || t == T_BIGINT || t == T_STR) return val; 84 83 if (t == T_SYMBOL) return js_throw(js, make_dom_exception(js, "Symbol cannot be serialized", "DataCloneError")); 85 84 86 85 if (is_object_type(val)) { 87 87 - slot = js_get_slot(val, SLOT_BUFFER); 88 88 - ta_data = (TypedArrayData *)js_gettypedarray(slot); 86 86 + ta_data = buffer_get_typedarray_data(val); 89 87 } 90 88 91 89 if (ta_data) { ··· 106 104 ant_value_t existing = sc_lookup(seen, val); 107 105 if (vtype(existing) != T_UNDEF) return existing; 108 106 109 109 - ant_value_t buf_slot_v = js_get_slot(val, SLOT_BUFFER); 110 110 - if (vtype(buf_slot_v) == T_NUM) { 111 111 - ArrayBufferData *abd = (ArrayBufferData *)(uintptr_t)(size_t)js_getnum(buf_slot_v); 107 107 + ArrayBufferData *abd = buffer_get_arraybuffer_data(val); 108 108 + if (abd) { 112 109 if (abd && !abd->is_detached) { 113 110 if (transfer && sc_has(transfer, val)) { 114 111 ArrayBufferData *new_abd = calloc(1, sizeof(ArrayBufferData)); ··· 135 132 }} 136 133 137 134 if (buffer_is_dataview(val)) { 138 138 - ant_value_t dv_data_val = js_get_slot(val, SLOT_DATA); 139 139 - if (vtype(dv_data_val) != T_NUM) 140 140 - return js_throw(js, make_dom_exception(js, "DataView could not be cloned", "DataCloneError")); 141 141 - 142 142 - DataViewData *dv = (DataViewData *)(uintptr_t)js_getnum(dv_data_val); 135 135 + DataViewData *dv = buffer_get_dataview_data(val); 143 136 if (!dv || !dv->buffer) 144 137 return js_throw(js, make_dom_exception(js, "DataView could not be cloned", "DataCloneError")); 145 138

+1 -1

src/modules/textcodec.c

reviewed

··· 132 132 if (!str) { str = ""; str_len = 0; } 133 133 } 134 134 135 135 - TypedArrayData *ta = (TypedArrayData *)js_gettypedarray(js_get_slot(args[1], SLOT_BUFFER)); 135 135 + TypedArrayData *ta = buffer_get_typedarray_data(args[1]); 136 136 if (!ta) return js_mkerr_typed(js, JS_ERR_TYPE, "Second argument must be a Uint8Array"); 137 137 138 138 uint8_t *dest = (ta->buffer && !ta->buffer->is_detached)

+13 -39

src/modules/util.c

reviewed

··· 228 228 return false; 229 229 } 230 230 231 231 - static bool util_is_typed_array_value(ant_value_t value, TypedArrayData **out) { 232 232 - ant_value_t slot; 233 233 - 234 234 - if (vtype(value) == T_TYPEDARRAY) { 235 235 - if (out) *out = (TypedArrayData *)js_gettypedarray(value); 236 236 - return true; 237 237 - } 238 238 - 239 239 - if (!is_object_type(value)) return false; 240 240 - slot = js_get_slot(value, SLOT_BUFFER); 241 241 - if (vtype(slot) != T_TYPEDARRAY) return false; 242 242 - 243 243 - if (out) *out = (TypedArrayData *)js_gettypedarray(slot); 244 244 - return true; 245 245 - } 246 246 - 247 247 - static ArrayBufferData *util_get_arraybuffer_data(ant_value_t value) { 248 248 - ant_value_t slot; 249 249 - 250 250 - if (!is_object_type(value) || buffer_is_dataview(value)) return NULL; 251 251 - slot = js_get_slot(value, SLOT_BUFFER); 252 252 - if (vtype(slot) != T_NUM) return NULL; 253 253 - 254 254 - return (ArrayBufferData *)(uintptr_t)(size_t)js_getnum(slot); 255 255 - } 256 256 - 257 231 static bool util_is_boxed_primitive(ant_value_t value, uint8_t *type_out) { 258 232 ant_value_t primitive; 259 233 ··· 290 264 } 291 265 292 266 static ant_value_t util_types_is_any_array_buffer(ant_t *js, ant_value_t *args, int nargs) { 293 293 - ArrayBufferData *buffer = (nargs > 0) ? util_get_arraybuffer_data(args[0]) : NULL; 267 267 + ArrayBufferData *buffer = (nargs > 0) ? buffer_get_arraybuffer_data(args[0]) : NULL; 294 268 return js_bool(buffer != NULL); 295 269 } 296 270 297 271 static ant_value_t util_types_is_array_buffer(ant_t *js, ant_value_t *args, int nargs) { 298 298 - ArrayBufferData *buffer = (nargs > 0) ? util_get_arraybuffer_data(args[0]) : NULL; 272 272 + ArrayBufferData *buffer = (nargs > 0) ? buffer_get_arraybuffer_data(args[0]) : NULL; 299 273 return js_bool(buffer != NULL && !buffer->is_shared); 300 274 } 301 275 302 276 static ant_value_t util_types_is_shared_array_buffer(ant_t *js, ant_value_t *args, int nargs) { 303 303 - ArrayBufferData *buffer = (nargs > 0) ? util_get_arraybuffer_data(args[0]) : NULL; 277 277 + ArrayBufferData *buffer = (nargs > 0) ? buffer_get_arraybuffer_data(args[0]) : NULL; 304 278 return js_bool(buffer != NULL && buffer->is_shared); 305 279 } 306 280 307 281 static ant_value_t util_types_is_array_buffer_view(ant_t *js, ant_value_t *args, int nargs) { 308 282 if (nargs < 1) return js_false; 309 309 - return js_bool(buffer_is_dataview(args[0]) || util_is_typed_array_value(args[0], NULL)); 283 283 + return js_bool(buffer_is_dataview(args[0]) || buffer_get_typedarray_data(args[0]) != NULL); 310 284 } 311 285 312 286 static ant_value_t util_types_is_data_view(ant_t *js, ant_value_t *args, int nargs) { ··· 316 290 317 291 static ant_value_t util_types_is_typed_array(ant_t *js, ant_value_t *args, int nargs) { 318 292 if (nargs < 1) return js_false; 319 319 - return js_bool(util_is_typed_array_value(args[0], NULL)); 293 293 + return js_bool(buffer_get_typedarray_data(args[0]) != NULL); 320 294 } 321 295 322 296 static ant_value_t util_types_is_float16_array(ant_t *js, ant_value_t *args, int nargs) { 323 323 - TypedArrayData *typed_array = NULL; 324 324 - if (nargs < 1 || !util_is_typed_array_value(args[0], &typed_array)) return js_false; 297 297 + TypedArrayData *typed_array = (nargs > 0) ? buffer_get_typedarray_data(args[0]) : NULL; 298 298 + if (!typed_array) return js_false; 325 299 return js_bool(typed_array != NULL && typed_array->type == TYPED_ARRAY_FLOAT16); 326 300 } 327 301 328 328 - #define DEFINE_TYPED_ARRAY_CHECK(fn_name, typed_array_kind) \ 329 329 - static ant_value_t fn_name(ant_t *js, ant_value_t *args, int nargs) { \ 330 330 - TypedArrayData *typed_array = NULL; \ 331 331 - if (nargs < 1 || !util_is_typed_array_value(args[0], &typed_array)) return js_false; \ 332 332 - return js_bool(typed_array != NULL && typed_array->type == typed_array_kind); \ 302 302 + #define DEFINE_TYPED_ARRAY_CHECK(fn_name, typed_array_kind) \ 303 303 + static ant_value_t fn_name(ant_t *js, ant_value_t *args, int nargs) { \ 304 304 + TypedArrayData *typed_array = (nargs > 0) ? buffer_get_typedarray_data(args[0]) : NULL; \ 305 305 + if (!typed_array) return js_false; \ 306 306 + return js_bool(typed_array != NULL && typed_array->type == typed_array_kind); \ 333 307 } 334 308 335 309 DEFINE_TYPED_ARRAY_CHECK(util_types_is_int8_array, TYPED_ARRAY_INT8) 336 310 DEFINE_TYPED_ARRAY_CHECK(util_types_is_uint8_array, TYPED_ARRAY_UINT8) 337 337 - DEFINE_TYPED_ARRAY_CHECK(util_types_is_uint8_clamped_array, TYPED_ARRAY_UINT8_CLAMPED) 338 311 DEFINE_TYPED_ARRAY_CHECK(util_types_is_int16_array, TYPED_ARRAY_INT16) 339 312 DEFINE_TYPED_ARRAY_CHECK(util_types_is_uint16_array, TYPED_ARRAY_UINT16) 340 313 DEFINE_TYPED_ARRAY_CHECK(util_types_is_int32_array, TYPED_ARRAY_INT32) ··· 343 316 DEFINE_TYPED_ARRAY_CHECK(util_types_is_float64_array, TYPED_ARRAY_FLOAT64) 344 317 DEFINE_TYPED_ARRAY_CHECK(util_types_is_bigint64_array, TYPED_ARRAY_BIGINT64) 345 318 DEFINE_TYPED_ARRAY_CHECK(util_types_is_biguint64_array, TYPED_ARRAY_BIGUINT64) 319 319 + DEFINE_TYPED_ARRAY_CHECK(util_types_is_uint8_clamped_array, TYPED_ARRAY_UINT8_CLAMPED) 346 320 347 321 static ant_value_t util_types_is_promise(ant_t *js, ant_value_t *args, int nargs) { 348 322 if (nargs < 1) return js_false;

+1 -2

src/modules/v8.c

reviewed

··· 233 233 static ant_value_t v8_deserialize(ant_t *js, ant_value_t *args, int nargs) { 234 234 if (nargs < 1) return js_mkerr(js, "deserialize: Buffer required"); 235 235 236 236 - ant_value_t buf_slot = js_get_slot(args[0], SLOT_BUFFER); 237 237 - TypedArrayData *ta = (TypedArrayData *)js_gettypedarray(buf_slot); 236 236 + TypedArrayData *ta = buffer_get_typedarray_data(args[0]); 238 237 if (!ta || !ta->buffer) return js_mkerr(js, "deserialize: expected a Buffer"); 239 238 240 239 const uint8_t *data = ta->buffer->data + ta->byte_offset;

+6 -6

src/streams/pipes.c

reviewed

··· 60 60 } 61 61 62 62 static ant_value_t pipe_state_reader(ant_value_t state) { 63 63 - return js_get_slot(state, SLOT_BUFFER); 63 63 + return js_get_slot(state, SLOT_AUX); 64 64 } 65 65 66 66 static ant_value_t pipe_state_writer(ant_value_t state) { ··· 121 121 ant_value_t reader = pipe_state_reader(state); 122 122 if (rs_is_reader(reader)) { 123 123 pipes_release_reader(js, reader); 124 124 - js_set_slot(state, SLOT_BUFFER, js_mkundef()); 124 124 + js_set_slot(state, SLOT_AUX, js_mkundef()); 125 125 } 126 126 127 127 ant_value_t writer = pipe_state_writer(state); ··· 387 387 js_set_slot(state, SLOT_DATA, ANT_PTR(pst)); 388 388 js_set_slot(state, SLOT_ENTRIES, source); 389 389 js_set_slot(state, SLOT_CTOR, dest); 390 390 - js_set_slot(state, SLOT_BUFFER, reader); 390 390 + js_set_slot(state, SLOT_AUX, reader); 391 391 js_set_slot(state, SLOT_DEFAULT, writer); 392 392 js_set_slot(state, SLOT_RS_PULL, promise); 393 393 js_set_finalizer(state, pipe_state_finalize); ··· 493 493 } 494 494 495 495 static ant_value_t tee_state_reader(ant_value_t state) { 496 496 - return js_get_slot(state, SLOT_BUFFER); 496 496 + return js_get_slot(state, SLOT_AUX); 497 497 } 498 498 499 499 static void tee_release_reader(ant_t *js, ant_value_t state) { 500 500 ant_value_t reader = tee_state_reader(state); 501 501 if (!rs_is_reader(reader)) return; 502 502 pipes_release_reader(js, reader); 503 503 - js_set_slot(state, SLOT_BUFFER, js_mkundef()); 503 503 + js_set_slot(state, SLOT_AUX, js_mkundef()); 504 504 } 505 505 506 506 static void tee_resolve_cancel_promises(ant_t *js, ant_value_t state) { ··· 750 750 ant_value_t state = js_mkobj(js); 751 751 js_set_slot(state, SLOT_DATA, ANT_PTR(st)); 752 752 js_set_slot(state, SLOT_ENTRIES, js->this_val); 753 753 - js_set_slot(state, SLOT_BUFFER, reader); 753 753 + js_set_slot(state, SLOT_AUX, reader); 754 754 js_set_slot(state, SLOT_RS_PULL, js_mkundef()); 755 755 js_set_slot(state, SLOT_RS_CANCEL, js_mkundef()); 756 756 js_set_slot(state, SLOT_RS_CLOSED, js_mkundef());

+7 -7

src/streams/readable.c

reviewed

··· 26 26 bool rs_is_reader(ant_value_t obj) { 27 27 return js_check_brand(obj, BRAND_READABLE_STREAM_READER) 28 28 && vtype(js_get_slot(obj, SLOT_RS_CLOSED)) == T_PROMISE 29 29 - && vtype(js_get_slot(obj, SLOT_BUFFER)) == T_ARR; 29 29 + && vtype(js_get_slot(obj, SLOT_AUX)) == T_ARR; 30 30 } 31 31 32 32 bool rs_is_controller(ant_value_t obj) { ··· 91 91 } 92 92 93 93 ant_value_t rs_stream_error(ant_value_t stream_obj) { 94 94 - return js_get_slot(stream_obj, SLOT_BUFFER); 94 94 + return js_get_slot(stream_obj, SLOT_AUX); 95 95 } 96 96 97 97 static inline ant_value_t rs_ctrl_stream(ant_value_t ctrl_obj) { ··· 111 111 } 112 112 113 113 static inline ant_value_t rs_ctrl_queue(ant_t *js, ant_value_t ctrl_obj) { 114 114 - return js_get_slot(ctrl_obj, SLOT_BUFFER); 114 114 + return js_get_slot(ctrl_obj, SLOT_AUX); 115 115 } 116 116 117 117 ant_value_t rs_reader_stream(ant_value_t reader_obj) { ··· 123 123 } 124 124 125 125 ant_value_t rs_reader_reqs(ant_value_t reader_obj) { 126 126 - return js_get_slot(reader_obj, SLOT_BUFFER); 126 126 + return js_get_slot(reader_obj, SLOT_AUX); 127 127 } 128 128 129 129 bool rs_reader_has_reqs(ant_t *js, ant_value_t reader_obj) { ··· 252 252 rs_stream_t *stream = rs_get_stream(stream_obj); 253 253 if (!stream || stream->state != RS_STATE_READABLE) return; 254 254 stream->state = RS_STATE_ERRORED; 255 255 - js_set_slot(stream_obj, SLOT_BUFFER, e); 255 255 + js_set_slot(stream_obj, SLOT_AUX, e); 256 256 257 257 ant_value_t reader_obj = rs_stream_reader(stream_obj); 258 258 if (rs_is_reader(reader_obj)) { ··· 673 673 js_set_slot(obj, SLOT_BRAND, js_mknum(BRAND_READABLE_STREAM_READER)); 674 674 js_set_slot(obj, SLOT_ENTRIES, stream_obj); 675 675 js_set_slot(obj, SLOT_RS_CLOSED, closed); 676 676 - js_set_slot(obj, SLOT_BUFFER, js_mkarr(js)); 676 676 + js_set_slot(obj, SLOT_AUX, js_mkarr(js)); 677 677 js_set_slot(stream_obj, SLOT_CTOR, obj); 678 678 679 679 if (stream->state == RS_STATE_CLOSED) ··· 817 817 js_set_slot(ctrl_obj, SLOT_RS_PULL, pull_fn); 818 818 js_set_slot(ctrl_obj, SLOT_RS_CANCEL, cancel_fn); 819 819 js_set_slot(ctrl_obj, SLOT_RS_SIZE, size_fn); 820 820 - js_set_slot(ctrl_obj, SLOT_BUFFER, js_mkarr(js)); 820 820 + js_set_slot(ctrl_obj, SLOT_AUX, js_mkarr(js)); 821 821 js_set_finalizer(ctrl_obj, rs_controller_finalize); 822 822 823 823 js_set_slot(stream_obj, SLOT_ENTRIES, ctrl_obj);

+13 -13

src/streams/transform.c

reviewed

··· 113 113 } 114 114 115 115 static inline ant_value_t ts_bp_promise(ant_value_t ts_obj) { 116 116 - return js_get_slot(ts_obj, SLOT_BUFFER); 116 116 + return js_get_slot(ts_obj, SLOT_AUX); 117 117 } 118 118 119 119 ant_value_t ts_stream_controller(ant_value_t ts_obj) { ··· 133 133 } 134 134 135 135 static inline ant_value_t ts_ctrl_cancel_fn(ant_value_t ctrl_obj) { 136 136 - return js_get_slot(ctrl_obj, SLOT_BUFFER); 136 136 + return js_get_slot(ctrl_obj, SLOT_AUX); 137 137 } 138 138 139 139 static inline ant_value_t ts_ctrl_transformer(ant_value_t ctrl_obj) { ··· 149 149 } 150 150 151 151 static inline ant_value_t ts_writable_stored_error(ant_value_t ts_obj) { 152 152 - return js_get_slot(ts_writable(ts_obj), SLOT_BUFFER); 152 152 + return js_get_slot(ts_writable(ts_obj), SLOT_AUX); 153 153 } 154 154 155 155 static inline ant_value_t ts_cancel_promise(ant_value_t ts_obj) { ··· 198 198 static void ts_ctrl_clear_algorithms(ant_value_t ctrl_obj) { 199 199 js_set_slot(ctrl_obj, SLOT_ENTRIES, js_mkundef()); 200 200 js_set_slot(ctrl_obj, SLOT_CTOR, js_mkundef()); 201 201 - js_set_slot(ctrl_obj, SLOT_BUFFER, js_mkundef()); 201 201 + js_set_slot(ctrl_obj, SLOT_AUX, js_mkundef()); 202 202 } 203 203 204 204 static ant_value_t ts_take_thrown_or(ant_t *js, ant_value_t fallback) { ··· 261 261 if (vtype(bp) == T_PROMISE) js_resolve_promise(js, bp, js_mkundef()); 262 262 } 263 263 ant_value_t new_bp = js_mkpromise(js); 264 264 - js_set_slot(ts_obj, SLOT_BUFFER, new_bp); 264 264 + js_set_slot(ts_obj, SLOT_AUX, new_bp); 265 265 ts_set_bp_flag(ts_obj, backpressure); 266 266 } 267 267 ··· 420 420 ant_value_t wrapper = js_get_slot(js->current_func, SLOT_DATA); 421 421 ant_value_t p = js_get_slot(wrapper, SLOT_DATA); 422 422 ant_value_t ts_obj = js_get_slot(wrapper, SLOT_ENTRIES); 423 423 - ant_value_t reason = js_get_slot(wrapper, SLOT_BUFFER); 423 423 + ant_value_t reason = js_get_slot(wrapper, SLOT_AUX); 424 424 425 425 ant_value_t readable = ts_readable(ts_obj); 426 426 rs_stream_t *rs = rs_get_stream(readable); ··· 457 457 ant_value_t wrapper = js_get_slot(js->current_func, SLOT_DATA); 458 458 ant_value_t p = js_get_slot(wrapper, SLOT_DATA); 459 459 ant_value_t ts_obj = js_get_slot(wrapper, SLOT_ENTRIES); 460 460 - ant_value_t reason = js_get_slot(wrapper, SLOT_BUFFER); 460 460 + ant_value_t reason = js_get_slot(wrapper, SLOT_AUX); 461 461 462 462 ant_value_t readable = ts_readable(ts_obj); 463 463 rs_stream_t *rs = rs_get_stream(readable); ··· 591 591 ant_value_t wrapper = js_mkobj(js); 592 592 js_set_slot(wrapper, SLOT_DATA, p); 593 593 js_set_slot(wrapper, SLOT_ENTRIES, ts_obj); 594 594 - js_set_slot(wrapper, SLOT_BUFFER, reason); 594 594 + js_set_slot(wrapper, SLOT_AUX, reason); 595 595 js_set_slot(wrapper, SLOT_CTOR, ts_cancel_started_by_abort(ts_obj) ? js_true : js_false); 596 596 597 597 ant_value_t res_fn = js_heavy_mkfun(js, ts_abort_cancel_resolve, wrapper); ··· 732 732 ant_value_t wrapper = js_mkobj(js); 733 733 js_set_slot(wrapper, SLOT_DATA, p); 734 734 js_set_slot(wrapper, SLOT_ENTRIES, ts_obj); 735 735 - js_set_slot(wrapper, SLOT_BUFFER, reason); 735 735 + js_set_slot(wrapper, SLOT_AUX, reason); 736 736 js_set_slot(wrapper, SLOT_CTOR, ts_cancel_started_by_abort(ts_obj) ? js_true : js_false); 737 737 ant_value_t res_fn = js_heavy_mkfun(js, ts_source_cancel_resolve, wrapper); 738 738 ant_value_t rej_fn = js_heavy_mkfun(js, ts_source_cancel_reject, wrapper); ··· 935 935 js_set_slot(ctrl_obj, SLOT_DATA, ts_obj); 936 936 js_set_slot(ctrl_obj, SLOT_ENTRIES, transform_fn); 937 937 js_set_slot(ctrl_obj, SLOT_CTOR, flush_fn); 938 938 - js_set_slot(ctrl_obj, SLOT_BUFFER, cancel_fn); 938 938 + js_set_slot(ctrl_obj, SLOT_AUX, cancel_fn); 939 939 js_set_slot(ctrl_obj, SLOT_SETTLED, transformer); 940 940 js_set_slot(ctrl_obj, SLOT_RS_PULL, js_mkundef()); 941 941 js_set_slot(ts_obj, SLOT_DEFAULT, ctrl_obj); ··· 975 975 js_set_slot(rs_ctrl_obj, SLOT_RS_PULL, source_pull); 976 976 js_set_slot(rs_ctrl_obj, SLOT_RS_CANCEL, source_cancel); 977 977 js_set_slot(rs_ctrl_obj, SLOT_RS_SIZE, readable_size_fn); 978 978 - js_set_slot(rs_ctrl_obj, SLOT_BUFFER, js_mkarr(js)); 978 978 + js_set_slot(rs_ctrl_obj, SLOT_AUX, js_mkarr(js)); 979 979 js_set_finalizer(rs_ctrl_obj, ts_rs_ctrl_finalize); 980 980 js_set_slot(rs_obj, SLOT_ENTRIES, rs_ctrl_obj); 981 981 ··· 995 995 js_set_slot(ts_obj, SLOT_CTOR, ws_obj); 996 996 997 997 ant_value_t bp_promise = js_mkpromise(js); 998 998 - js_set_slot(ts_obj, SLOT_BUFFER, bp_promise); 998 998 + js_set_slot(ts_obj, SLOT_AUX, bp_promise); 999 999 1000 1000 ts_set_backpressure(js, ts_obj, true); 1001 1001 ··· 1013 1013 js_set_slot(ws_ctrl_obj, SLOT_WS_ABORT, sink_abort); 1014 1014 js_set_slot(ws_ctrl_obj, SLOT_RS_SIZE, writable_size_fn); 1015 1015 js_set_slot(ws_ctrl_obj, SLOT_CTOR, js_mkundef()); 1016 1016 - js_set_slot(ws_ctrl_obj, SLOT_BUFFER, js_mkarr(js)); 1016 1016 + js_set_slot(ws_ctrl_obj, SLOT_AUX, js_mkarr(js)); 1017 1017 js_set_finalizer(ws_ctrl_obj, ts_ws_ctrl_finalize); 1018 1018 1019 1019 js_set_slot(ws_obj, SLOT_ENTRIES, ws_ctrl_obj);

+5 -5

src/streams/writable.c

reviewed

··· 78 78 } 79 79 80 80 static inline ant_value_t ws_stream_stored_error(ant_value_t stream_obj) { 81 81 - return js_get_slot(stream_obj, SLOT_BUFFER); 81 81 + return js_get_slot(stream_obj, SLOT_AUX); 82 82 } 83 83 84 84 static inline ant_value_t ws_stream_write_requests(ant_t *js, ant_value_t stream_obj) { ··· 126 126 } 127 127 128 128 static inline ant_value_t ws_ctrl_queue(ant_value_t ctrl_obj) { 129 129 - return js_get_slot(ctrl_obj, SLOT_BUFFER); 129 129 + return js_get_slot(ctrl_obj, SLOT_AUX); 130 130 } 131 131 132 132 static inline ant_value_t ws_ctrl_signal(ant_value_t ctrl_obj) { ··· 266 266 ws_controller_t *ctrl = ws_get_controller(ctrl_obj); 267 267 268 268 stream->state = WS_STATE_ERRORING; 269 269 - js_set_slot(stream_obj, SLOT_BUFFER, reason); 269 269 + js_set_slot(stream_obj, SLOT_AUX, reason); 270 270 271 271 ant_value_t signal_ac = ws_ctrl_signal(ctrl_obj); 272 272 if (is_object_type(signal_ac)) { ··· 427 427 if (!stream) return; 428 428 429 429 if (stream->state == WS_STATE_ERRORING) { 430 430 - js_set_slot(stream_obj, SLOT_BUFFER, js_mkundef()); 430 430 + js_set_slot(stream_obj, SLOT_AUX, js_mkundef()); 431 431 if (stream->has_pending_abort) { 432 432 ant_value_t ap = ws_stream_pending_abort_promise(stream_obj); 433 433 js_resolve_promise(js, ap, js_mkundef()); ··· 1079 1079 js_set_slot(ctrl_obj, SLOT_WS_ABORT, abort_fn); 1080 1080 js_set_slot(ctrl_obj, SLOT_RS_SIZE, size_fn); 1081 1081 js_set_slot(ctrl_obj, SLOT_CTOR, underlying_sink); 1082 1082 - js_set_slot(ctrl_obj, SLOT_BUFFER, js_mkarr(js)); 1082 1082 + js_set_slot(ctrl_obj, SLOT_AUX, js_mkarr(js)); 1083 1083 js_set_finalizer(ctrl_obj, ws_controller_finalize); 1084 1084 1085 1085 ant_value_t ac_ctor = js_get(js, js_glob(js), "AbortController");

+17

tests/repro_typedarray_metadata_leak.cjs

reviewed

··· 1 1 + 'use strict'; 2 2 + 3 3 + const total = 600000; 4 4 + const step = 100000; 5 5 + let checksum = 0; 6 6 + 7 7 + for (let i = 0; i < total; i++) { 8 8 + const buf = Buffer.alloc(32); 9 9 + buf[0] = i & 255; 10 10 + checksum ^= buf[0]; 11 11 + 12 12 + if ((i + 1) % step === 0) { 13 13 + console.log(`allocated ${i + 1}`); 14 14 + } 15 15 + } 16 16 + 17 17 + console.log(`OK: allocated ${total} buffers checksum=${checksum}`);