MIRROR: javascript for 🐜's, a tiny runtime with big ambitions
add garbage collector to crypto/events
+59
-21
+2
include/gc/modules.h
+2
include/gc/modules.h
···
16
16
void gc_mark_net(ant_t *js, gc_mark_fn mark);
17
17
void gc_mark_server(ant_t *js, gc_mark_fn mark);
18
18
void gc_mark_events(ant_t *js, gc_mark_fn mark);
19
+
void gc_mark_eventemitter_object(ant_t *js, ant_value_t obj, gc_mark_fn mark);
20
+
void gc_finalize_events_object(ant_t *js, ant_value_t obj);
19
21
void gc_mark_lmdb(ant_t *js, gc_mark_fn mark);
20
22
void gc_mark_symbols(ant_t *js, gc_mark_fn mark);
21
23
void gc_mark_esm(ant_t *js, gc_mark_fn mark);
+4
-3
src/gc/objects.c
+4
-3
src/gc/objects.c
···
323
323
gc_mark_value(js, entry->setter);
324
324
}
325
325
326
-
gc_mark_abort_signal_object(
327
-
js, js_obj_from_ptr(obj), gc_mark_value
328
-
);
326
+
gc_mark_abort_signal_object(js, js_obj_from_ptr(obj), gc_mark_value);
327
+
gc_mark_eventemitter_object(js, js_obj_from_ptr(obj), gc_mark_value);
329
328
}
330
329
331
330
static void gc_drain_mark_stack(ant_t *js) {
···
564
563
void gc_object_free(ant_t *js, ant_object_t *obj) {
565
564
if (!obj) return;
566
565
if (obj->finalizer) obj->finalizer(js, obj);
566
+
567
+
gc_finalize_events_object(js, js_obj_from_ptr(obj));
567
568
obj->mark_epoch = ANT_GC_DEAD;
568
569
569
570
if (obj->shape) {
+18
-2
src/modules/crypto.c
+18
-2
src/modules/crypto.c
···
37
37
38
38
enum { CRYPTO_HASH_NATIVE_TAG = 0x48415348u }; // HASH
39
39
40
+
static void crypto_hash_state_free(ant_hash_state_t *state) {
41
+
if (!state) return;
42
+
if (state->ctx) EVP_MD_CTX_free(state->ctx);
43
+
free(state);
44
+
}
45
+
46
+
static void crypto_hash_finalize(ant_t *js, ant_object_t *obj) {
47
+
ant_value_t value = js_obj_from_ptr(obj);
48
+
ant_hash_state_t *state = (ant_hash_state_t *)js_get_native(value, CRYPTO_HASH_NATIVE_TAG);
49
+
50
+
if (!state) return;
51
+
js_clear_native(value, CRYPTO_HASH_NATIVE_TAG);
52
+
crypto_hash_state_free(state);
53
+
}
54
+
40
55
int crypto_fill_random(void *buf, size_t len) {
41
56
if (len == 0) return 0;
42
57
if (len > (size_t)INT_MAX) return -1;
···
558
573
559
574
state->ctx = EVP_MD_CTX_new();
560
575
state->md = md;
576
+
561
577
if (!state->ctx || EVP_DigestInit_ex(state->ctx, md, NULL) != 1) {
562
-
if (state->ctx) EVP_MD_CTX_free(state->ctx);
563
-
free(state);
578
+
crypto_hash_state_free(state);
564
579
return js_mkerr(js, "Failed to initialize hash");
565
580
}
566
581
···
569
584
js_set(js, obj, "digest", js_mkfun(js_hash_digest));
570
585
571
586
js_set_native(obj, state, CRYPTO_HASH_NATIVE_TAG);
587
+
js_set_finalizer(obj, crypto_hash_finalize);
572
588
js_set_sym(js, obj, get_toStringTag_sym(), js_mkstr(js, "Hash", 4));
573
589
574
590
return obj;
+35
-16
src/modules/events.c
+35
-16
src/modules/events.c
···
78
78
UT_hash_handle hh;
79
79
} EventType;
80
80
81
-
typedef struct emitter_reg {
82
-
EventType **events;
83
-
struct emitter_reg *next;
84
-
} emitter_reg_t;
81
+
static EventType *global_events = NULL;
85
82
86
-
static EventType *global_events = NULL;
87
-
static emitter_reg_t *emitter_registry = NULL;
83
+
static void free_event_type_table(EventType **events) {
84
+
if (!events) return;
85
+
86
+
if (*events) {
87
+
EventType *evt, *tmp;
88
+
HASH_ITER(hh, *events, evt, tmp) {
89
+
HASH_DEL(*events, evt);
90
+
if (evt->listeners) utarray_free(evt->listeners);
91
+
free(evt);
92
+
}}
93
+
94
+
free(events);
95
+
}
88
96
89
97
static EventType *make_event_type(ant_value_t js_key, const evt_key_t *ek) {
90
98
EventType *evt = ant_calloc(sizeof(EventType) + ek->len);
···
159
167
events = ant_calloc(sizeof(EventType *));
160
168
if (!events) return NULL;
161
169
*events = NULL;
162
-
163
-
emitter_reg_t *reg = ant_calloc(sizeof(emitter_reg_t));
164
-
if (!reg) { free(events); return NULL; }
165
-
reg->events = events;
166
-
reg->next = emitter_registry;
167
-
emitter_registry = reg;
168
-
169
170
js_set_native(this_obj, events, EVENT_EMITTER_NATIVE_TAG);
170
171
}
171
172
return events;
···
1372
1373
1373
1374
void gc_mark_events(ant_t *js, gc_mark_fn mark) {
1374
1375
mark_event_type_listeners(js, mark, global_events);
1375
-
for (emitter_reg_t *reg = emitter_registry; reg; reg = reg->next) {
1376
-
if (*reg->events) mark_event_type_listeners(js, mark, *reg->events);
1377
-
}
1376
+
1378
1377
if (g_isTrusted_getter) mark(js, g_isTrusted_getter);
1379
1378
if (g_eventemitter_ctor) mark(js, g_eventemitter_ctor);
1380
1379
if (g_eventemitter_proto) mark(js, g_eventemitter_proto);
···
1384
1383
if (g_errorevent_proto) mark(js, g_errorevent_proto);
1385
1384
if (g_promiserejectionevent_proto) mark(js, g_promiserejectionevent_proto);
1386
1385
}
1386
+
1387
+
void gc_mark_eventemitter_object(ant_t *js, ant_value_t obj, gc_mark_fn mark) {
1388
+
EventType **events = (EventType **)js_get_native(obj, EVENT_EMITTER_NATIVE_TAG);
1389
+
if (events && *events) mark_event_type_listeners(js, mark, *events);
1390
+
}
1391
+
1392
+
void gc_finalize_events_object(ant_t *js, ant_value_t obj) {
1393
+
event_data_t *data = (event_data_t *)js_get_native(obj, EVENT_NATIVE_TAG);
1394
+
EventType **events = (EventType **)js_get_native(obj, EVENT_EMITTER_NATIVE_TAG);
1395
+
1396
+
if (data) {
1397
+
js_clear_native(obj, EVENT_NATIVE_TAG);
1398
+
free(data);
1399
+
}
1400
+
1401
+
if (events) {
1402
+
js_clear_native(obj, EVENT_EMITTER_NATIVE_TAG);
1403
+
free_event_type_table(events);
1404
+
}
1405
+
}