1 files changed, 46 insertions, 23 deletions

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 <lcq/pit/utils.h>
 #include <lcq/pit/runtime/dump.h>
 
-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, "<unsupported double>");
+                slen = pit_libc_string_snprintf(buf, (size_t) len, "<unsupported double>");
 #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, "<broken symbol %ld>", pit_value_as_symbol(rt, v));
+                    slen = pit_libc_string_snprintf(buf, (size_t) len, "<broken symbol %ld>", 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, "<ref %ld>", r);
-                else {
+                if (!h) {
+                    pit_libc_string_snprintf(buf, (size_t) len, "<ref %ld>", 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, "<ref %ld>", r);
+                        slen = pit_libc_string_snprintf(buf, (size_t) len, "<ref %ld>", 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;
 }