From 88f0059c7e8e7680e39611e865b0356bc510adc8 Mon Sep 17 00:00:00 2001 From: LLLL Colonq Date: Tue, 21 Jul 2026 19:40:45 -0400 Subject: pit: Hash table annotations, better dumper --- pit/src/runtime/dump.c | 69 ++++++++++++++++++++++++++++--------------- pit/src/runtime/eval.c | 8 ++--- pit/src/runtime/gc.c | 16 +++++----- pit/src/runtime/macroexpand.c | 4 +-- 4 files changed, 59 insertions(+), 38 deletions(-) (limited to 'pit/src/runtime') diff --git a/pit/src/runtime/dump.c b/pit/src/runtime/dump.c index 3c1cf13..e8ba4b0 100644 --- a/pit/src/runtime/dump.c +++ b/pit/src/runtime/dump.c @@ -1,25 +1,26 @@ +#include #include -typedef bool (*pit_dump_callback)(char *buf, i64 len, void *data); -i64 pit_dump_with_callback( - pit_runtime *rt, char *start, i64 buf_len, pit_value top, bool readable, - pit_dump_callback cb, void *data +void pit_dump_with_callback( + pit_runtime *rt, pit_value top, bool readable, + pit_dump_callback write, void *data ) { + char buf[1024]; + i64 len = (i64) sizeof(buf); + i64 slen = 0; i64 traversal_reset = rt->traversal->next; - char *buf = start; - char *end = start + buf_len; pit_value_heavy *h = NULL; pit_traversal_push_value(rt, rt->traversal, top); while (rt->traversal->next > traversal_reset) { pit_traversal_entry ent; - i64 len = (i64) (end - buf); if (rt->error != PIT_NIL) goto end; if (pit_vec_pop(pit_traversal_entry)(rt->traversal, &ent) < 0) pit_error(rt, "dump stack underflow"); if (rt->error != PIT_NIL) goto end; switch (ent.sort) { case PIT_TRAVERSAL_ENTRY_DUMP_STRING: { - for (char *s = ent.in.dump_string; *s != 0 && buf < end; ++s) *(buf++) = *s; + if (write((u8 *) ent.in.dump_string, (i64) pit_libc_string_strlen(ent.in.dump_string), data) < 0) + goto end; break; } case PIT_TRAVERSAL_ENTRY_VALUE: { @@ -27,13 +28,15 @@ i64 pit_dump_with_callback( switch (pit_value_sort(v)) { case PIT_VALUE_SORT_DOUBLE: #ifndef PIT_NO_DOUBLE - buf += pit_libc_string_snprintf(buf, (size_t) len, "%lf", pit_value_as_double(rt, v)); + slen = pit_libc_string_snprintf(buf, (size_t) len, "%lf", pit_value_as_double(rt, v)); #else - buf += pit_string_snprintf(buf, (size_t) len, ""); + slen = pit_libc_string_snprintf(buf, (size_t) len, ""); #endif + if (write((u8 *) buf, slen, data) < 0) goto end; break; case PIT_VALUE_SORT_INTEGER: - buf += pit_libc_string_snprintf(buf, (size_t) len, "%ld", pit_value_as_integer(rt, v)); + slen = pit_libc_string_snprintf(buf, (size_t) len, "%ld", pit_value_as_integer(rt, v)); + if (write((u8 *) buf, slen, data) < 0) goto end; break; case PIT_VALUE_SORT_SYMBOL: { pit_symtab_entry *se = pit_symtab_lookup(rt, v); @@ -41,21 +44,20 @@ i64 pit_dump_with_callback( && pit_value_sort(se->name) == PIT_VALUE_SORT_REF && (h = pit_value_ref_deref(rt, pit_value_as_ref(rt, se->name))) ) { - i64 i = 0; - for (; i < h->in.bytes.len && i < len - 1; ++i) { - buf[i] = (char) h->in.bytes.data[i]; - } - buf += i; + if (write(h->in.bytes.data, h->in.bytes.len, data) < 0) goto end; } else { - buf += pit_libc_string_snprintf(buf, (size_t) len, "", pit_value_as_symbol(rt, v)); + slen = pit_libc_string_snprintf(buf, (size_t) len, "", pit_value_as_symbol(rt, v)); + if (write((u8 *) buf, slen, data) < 0) goto end; } break; } case PIT_VALUE_SORT_REF: { pit_ref r = pit_value_as_ref(rt, v); h = pit_value_ref_deref(rt, r); - if (!h) pit_libc_string_snprintf(buf, (size_t) len, "", r); - else { + if (!h) { + pit_libc_string_snprintf(buf, (size_t) len, "", r); + if (write((u8 *) buf, slen, data) < 0) goto end; + } else { switch (h->hsort) { case PIT_VALUE_HEAVY_SORT_CELL: { pit_traversal_push_dump_string(rt, rt->traversal, "}"); @@ -117,11 +119,12 @@ i64 pit_dump_with_callback( } } if (readable && i < len - 1) buf[i++] = '"'; - buf += i; + if (write((u8 *) buf, i, data) < 0) goto end; break; } default: - buf += pit_libc_string_snprintf(buf, (size_t) len, "", r); + slen = pit_libc_string_snprintf(buf, (size_t) len, "", r); + if (write((u8 *) buf, slen, data) < 0) goto end; } } break; @@ -135,9 +138,29 @@ i64 pit_dump_with_callback( } end: rt->traversal->next = traversal_reset; - return (i64) (buf - start); +} + +struct pit_dump_to_buf_closure { + char *buf; + i64 len; + i64 off; +}; +static i64 pit_dump_to_buf_callback(u8 *buf, i64 len, void *data) { + struct pit_dump_to_buf_closure *cl = (struct pit_dump_to_buf_closure *) data; + i64 i = 0; + for (; i < len && cl->off + i < cl->len; ++i) { + cl->buf[cl->off + i] = (char) buf[i]; + } + cl->off += i; + if (cl->len - cl->off < len) return -1; + return 0; } i64 pit_dump(pit_runtime *rt, char *buf, i64 len, pit_value v, bool readable) { - return pit_dump_with_callback(rt, buf, len, v, readable, NULL, NULL); + struct pit_dump_to_buf_closure cl; + cl.buf = buf; + cl.len = len; + cl.off = 0; + pit_dump_with_callback(rt, v, readable, pit_dump_to_buf_callback, &cl); + return cl.off; } diff --git a/pit/src/runtime/eval.c b/pit/src/runtime/eval.c index 301d8d0..f923760 100644 --- a/pit/src/runtime/eval.c +++ b/pit/src/runtime/eval.c @@ -16,7 +16,7 @@ pit_value pit_eval(pit_runtime *rt, pit_value top) { if (pit_value_is_cons(rt, cur)) { /* compound expressions: function/macro application special forms */ pit_value fsym = pit_value_cons_car(rt, cur); bool is_symbol = pit_value_is_symbol(rt, fsym); - pit_annotated_ref *ann = pit_annotation_get(rt, pit_value_as_ref(rt, cur)); + pit_annotation *ann = pit_annotation_get(rt, pit_value_as_ref(rt, cur)); if (is_symbol && pit_symtab_is_symbol_special_form(rt, fsym)) { /* special forms */ pit_value f = pit_symtab_fget(rt, fsym); pit_value args = pit_value_cons_cdr(rt, cur); @@ -82,9 +82,9 @@ pit_value pit_eval(pit_runtime *rt, pit_value top) { args = pit_value_cons(rt, a, args); } if (ent->in.application.annotation != NULL) { - rt->source_line = ent->in.application.annotation->annotation.line; - rt->source_column = ent->in.application.annotation->annotation.column; - pit_vec_push(pit_annotated_ref)(rt->backtrace, *ent->in.application.annotation); + rt->source_line = ent->in.application.annotation->line; + rt->source_column = ent->in.application.annotation->column; + // pit_vec_push(pit_annotated_ref)(rt->backtrace, *ent->in.application.annotation); } if (pit_vec_push(pit_value)(rt->result_stack, pit_value_apply(rt, f, args)) < 0) pit_error(rt, "evaluation result stack underflow"); diff --git a/pit/src/runtime/gc.c b/pit/src/runtime/gc.c index fcb5f89..671202d 100644 --- a/pit/src/runtime/gc.c +++ b/pit/src/runtime/gc.c @@ -17,11 +17,9 @@ static pit_value gc_copy_value(pit_runtime *rt, pit_value v) { pit_ref r = pit_value_as_ref(rt, v); pit_value_heavy *h = pit_value_ref_deref(rt, r); i64 new = gc_copy(rt, h); - pit_annotated_ref *ann = pit_annotation_get(rt, r); + pit_annotation *ann = pit_annotation_get(rt, r); if (ann != NULL) { - pit_annotated_ref newann = *ann; - newann.ref = new; - if (pit_vec_push(pit_annotated_ref)(rt->backtrace, newann) < 0) + if (pit_hashtable_insert(pit_ref, pit_annotation)(rt->annotations_backbuffer, new, *ann) < 0) pit_error(rt, "annotation overflow"); } return pit_value_ref_new(rt, new); @@ -34,10 +32,10 @@ void pit_gc(pit_runtime *rt) { rt->frozen_symtab = 0; pit_arena *fromspace = rt->heap; pit_arena *tospace = rt->backbuffer; - pit_vec(pit_annotated_ref) *fromspace_ann = rt->annotations; - pit_vec(pit_annotated_ref) *tospace_ann = rt->backtrace; + pit_hashtable(pit_ref, pit_annotation) *fromspace_ann = rt->annotations; + pit_hashtable(pit_ref, pit_annotation) *tospace_ann = rt->annotations_backbuffer; pit_arena_reset(tospace); - pit_vec_reset(pit_annotated_ref)(tospace_ann); + pit_hashtable_reset(pit_ref, pit_annotation)(tospace_ann); /* populate tospace with immediately reachable values */ for (i64 i = 0; i < rt->symtab->next; ++i) { pit_symtab_entry *ent = pit_vec_get(pit_symtab_entry)(rt->symtab, i); @@ -95,6 +93,6 @@ void pit_gc(pit_runtime *rt) { rt->heap = tospace; rt->backbuffer = fromspace; rt->annotations = tospace_ann; - rt->backtrace = fromspace_ann; - pit_vec_reset(pit_annotated_ref)(rt->backtrace); + rt->annotations_backbuffer = fromspace_ann; + pit_hashtable_reset(pit_ref, pit_annotation)(rt->annotations_backbuffer); } diff --git a/pit/src/runtime/macroexpand.c b/pit/src/runtime/macroexpand.c index 6252ae1..7ff1a6a 100644 --- a/pit/src/runtime/macroexpand.c +++ b/pit/src/runtime/macroexpand.c @@ -14,7 +14,7 @@ pit_value pit_macroexpand(pit_runtime *rt, pit_value top) { if (pit_value_is_cons(rt, cur)) { pit_value fsym = pit_value_cons_car(rt, cur); bool is_symbol = pit_value_is_symbol(rt, fsym); - pit_annotated_ref *ann = pit_annotation_get(rt, pit_value_as_ref(rt, cur)); + pit_annotation *ann = pit_annotation_get(rt, pit_value_as_ref(rt, cur)); if (is_symbol && pit_symtab_is_symbol_macro(rt, fsym)) { pit_value f = pit_symtab_fget(rt, fsym); pit_value args = pit_value_cons_cdr(rt, cur); @@ -88,7 +88,7 @@ pit_value pit_macroexpand(pit_runtime *rt, pit_value top) { } app = pit_value_cons(rt, f, args); if (ent->in.application.annotation != NULL) { - pit_annotation_set(rt, pit_value_as_ref(rt, app), ent->in.application.annotation->annotation); + pit_annotation_set(rt, pit_value_as_ref(rt, app), *ent->in.application.annotation); } if (pit_vec_push(pit_value)(rt->result_stack, app) < 0) pit_error(rt, "macro expansion stack overflow"); -- cgit v1.3.1