MIRROR: javascript for 🐜's, a tiny runtime with big ambitions
update event system to properly clean up memory
+44
-21
+44
-21
src/modules/process.c
+44
-21
src/modules/process.c
···
232
232
return true;
233
233
}
234
234
235
+
static void free_event_type(ProcessEventType **events, ProcessEventType *evt) {
236
+
if (!evt) return;
237
+
HASH_DEL(*events, evt);
238
+
239
+
free(evt->listeners);
240
+
free(evt->event_type); free(evt);
241
+
}
242
+
235
243
static void check_listener_warning(const char *event) {
236
244
ProcessEventType *evt = NULL;
237
245
HASH_FIND_STR(process_events, event, evt);
···
261
269
} evt->listener_count--;
262
270
} else i++;
263
271
}
272
+
273
+
if (evt->listener_count == 0) {
274
+
int signum = get_signal_number(event_type);
275
+
if (signum > 0) signal(signum, SIG_DFL);
276
+
free_event_type(&process_events, evt);
277
+
}
264
278
}
265
279
266
280
static void process_signal_handler(int signum) {
···
299
313
return evt;
300
314
}
301
315
302
-
static void emit_stdio_event(ProcessEventType *events, const char *event_type, jsval_t *args, int nargs) {
316
+
static void emit_stdio_event(ProcessEventType **events, const char *event_type, jsval_t *args, int nargs) {
303
317
if (!rt->js) return;
304
318
ProcessEventType *evt = NULL;
305
-
HASH_FIND_STR(events, event_type, evt);
319
+
320
+
HASH_FIND_STR(*events, event_type, evt);
306
321
if (evt == NULL || evt->listener_count == 0) return;
307
322
308
323
int i = 0;
···
316
331
evt->listener_count--;
317
332
} else i++;
318
333
}
334
+
335
+
if (evt->listener_count == 0) free_event_type(events, evt);
319
336
}
320
337
321
338
static const char *stdin_escape_name(const char *seq, int len) {
···
435
452
}
436
453
437
454
jsval_t args[2] = { str_val, key_obj };
438
-
emit_stdio_event(stdin_events, "keypress", args, 2);
455
+
emit_stdio_event(&stdin_events, "keypress", args, 2);
439
456
}
440
457
441
458
static void process_keypress_data(struct js *js, const char *data, size_t len) {
···
513
530
}
514
531
}
515
532
516
-
static bool remove_listener_from_events(ProcessEventType *events, const char *event, jsval_t listener) {
533
+
static bool remove_listener_from_events(ProcessEventType **events, const char *event, jsval_t listener) {
517
534
ProcessEventType *evt = NULL;
518
-
HASH_FIND_STR(events, event, evt);
535
+
HASH_FIND_STR(*events, event, evt);
519
536
if (!evt) return false;
520
537
521
538
for (int i = 0; i < evt->listener_count; i++) {
522
539
if (evt->listeners[i].listener != listener) continue;
523
540
memmove(
524
-
&evt->listeners[i], &evt->listeners[i + 1],
541
+
&evt->listeners[i], &evt->listeners[i + 1],
525
542
(size_t)(evt->listener_count - i - 1) * sizeof(ProcessEventListener)
526
543
);
527
-
return --evt->listener_count == 0;
544
+
545
+
if (--evt->listener_count == 0) {
546
+
free_event_type(events, evt);
547
+
return true;
548
+
}
549
+
550
+
return false;
528
551
}
529
-
552
+
530
553
return false;
531
554
}
532
555
···
599
622
(void)stream;
600
623
if (nread > 0 && rt->js) {
601
624
jsval_t data_val = js_mkstr(rt->js, buf->base, (size_t)nread);
602
-
emit_stdio_event(stdin_events, "data", &data_val, 1);
625
+
emit_stdio_event(&stdin_events, "data", &data_val, 1);
603
626
if (stdin_state.keypress_enabled) process_keypress_data(rt->js, buf->base, (size_t)nread);
604
627
}
605
628
if (buf->base) free(buf->base);
···
646
669
js_set(rt->js, stdout_obj, "rows", js_mknum(rows));
647
670
js_set(rt->js, stdout_obj, "columns", js_mknum(cols));
648
671
649
-
emit_stdio_event(stdout_events, "resize", NULL, 0);
672
+
emit_stdio_event(&stdout_events, "resize", NULL, 0);
650
673
}
651
674
#endif
652
675
···
706
729
if (nargs < 1) {
707
730
ProcessEventType *evt, *tmp;
708
731
HASH_ITER(hh, stdin_events, evt, tmp) {
709
-
evt->listener_count = 0;
732
+
free_event_type(&stdin_events, evt);
710
733
}
711
734
stdin_stop_reading();
712
735
return this_obj;
···
717
740
718
741
ProcessEventType *evt = NULL;
719
742
HASH_FIND_STR(stdin_events, event, evt);
720
-
if (evt) evt->listener_count = 0;
743
+
if (evt) free_event_type(&stdin_events, evt);
721
744
if (strcmp(event, "data") == 0) stdin_stop_reading();
722
745
723
746
return this_obj;
···
730
753
char *event = js_getstr(js, args[0], NULL);
731
754
if (!event) return this_obj;
732
755
733
-
bool now_empty = remove_listener_from_events(stdin_events, event, args[1]);
756
+
bool now_empty = remove_listener_from_events(&stdin_events, event, args[1]);
734
757
if (now_empty && strcmp(event, "data") == 0) stdin_stop_reading();
735
758
736
759
return this_obj;
···
790
813
if (nargs < 1) {
791
814
ProcessEventType *evt, *tmp;
792
815
HASH_ITER(hh, stdout_events, evt, tmp) {
793
-
evt->listener_count = 0;
816
+
free_event_type(&stdout_events, evt);
794
817
}
795
818
return this_obj;
796
819
}
···
800
823
801
824
ProcessEventType *evt = NULL;
802
825
HASH_FIND_STR(stdout_events, event, evt);
803
-
if (evt) evt->listener_count = 0;
826
+
if (evt) free_event_type(&stdout_events, evt);
804
827
805
828
return this_obj;
806
829
}
···
812
835
char *event = js_getstr(js, args[0], NULL);
813
836
if (!event) return this_obj;
814
837
815
-
remove_listener_from_events(stdout_events, event, args[1]);
838
+
remove_listener_from_events(&stdout_events, event, args[1]);
816
839
return this_obj;
817
840
}
818
841
···
904
927
if (nargs < 1) {
905
928
ProcessEventType *evt, *tmp;
906
929
HASH_ITER(hh, stderr_events, evt, tmp) {
907
-
evt->listener_count = 0;
930
+
free_event_type(&stderr_events, evt);
908
931
}
909
932
return this_obj;
910
933
}
···
914
937
915
938
ProcessEventType *evt = NULL;
916
939
HASH_FIND_STR(stderr_events, event, evt);
917
-
if (evt) evt->listener_count = 0;
940
+
if (evt) free_event_type(&stderr_events, evt);
918
941
919
942
return this_obj;
920
943
}
···
926
949
char *event = js_getstr(js, args[0], NULL);
927
950
if (!event) return this_obj;
928
951
929
-
remove_listener_from_events(stderr_events, event, args[1]);
952
+
remove_listener_from_events(&stderr_events, event, args[1]);
930
953
return this_obj;
931
954
}
932
955
···
1568
1591
ProcessEventType *evt = NULL;
1569
1592
HASH_FIND_STR(process_events, event, evt);
1570
1593
if (evt) {
1571
-
evt->listener_count = 0;
1572
1594
int signum = get_signal_number(event);
1573
1595
if (signum > 0) signal(signum, SIG_DFL);
1596
+
free_event_type(&process_events, evt);
1574
1597
}
1575
1598
}
1576
1599
} else {
···
1578
1601
HASH_ITER(hh, process_events, evt, tmp) {
1579
1602
int signum = get_signal_number(evt->event_type);
1580
1603
if (signum > 0) signal(signum, SIG_DFL);
1581
-
evt->listener_count = 0;
1604
+
free_event_type(&process_events, evt);
1582
1605
}
1583
1606
}
1584
1607