pit: Backtraces

3 files changed, 27 insertions, 21 deletions

diff --git a/pit/src/runtime/dump.c b/pit/src/runtime/dump.c
index e8ba4b0..0bd605e 100644
--- a/pit/src/runtime/dump.c
+++ b/pit/src/runtime/dump.c
@@ -1,7 +1,7 @@
 #include <lcq/pit/utils.h>
 #include <lcq/pit/runtime/dump.h>
 
-void pit_dump_with_callback(
+pit_dump_condition pit_dump_with_callback(
     pit_runtime *rt, pit_value top, bool readable,
     pit_dump_callback write, void *data
 ) {
@@ -10,17 +10,17 @@ void pit_dump_with_callback(
     i64 slen = 0;
     i64 traversal_reset = rt->traversal->next;
     pit_value_heavy *h = NULL;
+    pit_dump_condition ret = PIT_DUMP_CONDITION_NORMAL;
     pit_traversal_push_value(rt, rt->traversal, top);
     while (rt->traversal->next > traversal_reset) {
         pit_traversal_entry ent;
-        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;
+        if (pit_vec_pop(pit_traversal_entry)(rt->traversal, &ent) < 0) {
+            ret = PIT_DUMP_CONDITION_STACK_UNDERFLOW;
+            goto end;
+        }
         switch (ent.sort) {
         case PIT_TRAVERSAL_ENTRY_DUMP_STRING: {
-            if (write((u8 *) ent.in.dump_string, (i64) pit_libc_string_strlen(ent.in.dump_string), data) < 0)
-                goto end;
+            if ((ret = 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: {
@@ -32,11 +32,11 @@ void pit_dump_with_callback(
 #else
                 slen = pit_libc_string_snprintf(buf, (size_t) len, "<unsupported double>");
 #endif
-                if (write((u8 *) buf, slen, data) < 0) goto end;
+                if ((ret = write((u8 *) buf, slen, data)) < 0) goto end;
                 break;
             case PIT_VALUE_SORT_INTEGER:
                 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;
+                if ((ret = write((u8 *) buf, slen, data)) < 0) goto end;
                 break;
             case PIT_VALUE_SORT_SYMBOL: {
                 pit_symtab_entry *se = pit_symtab_lookup(rt, v);
@@ -44,10 +44,10 @@ void 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)))
                 ) {
-                    if (write(h->in.bytes.data, h->in.bytes.len, data) < 0) goto end;
+                    if ((ret = write(h->in.bytes.data, h->in.bytes.len, data)) < 0) goto end;
                 } else {
                     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;
+                    if ((ret = write((u8 *) buf, slen, data)) < 0) goto end;
                 }
                 break;
             }
@@ -56,7 +56,7 @@ void pit_dump_with_callback(
                 h = pit_value_ref_deref(rt, r);
                 if (!h) {
                     pit_libc_string_snprintf(buf, (size_t) len, "<ref %ld>", r);
-                    if (write((u8 *) buf, slen, data) < 0) goto end;
+                    if ((ret = write((u8 *) buf, slen, data)) < 0) goto end;
                 } else {
                     switch (h->hsort) {
                     case PIT_VALUE_HEAVY_SORT_CELL: {
@@ -71,7 +71,7 @@ void pit_dump_with_callback(
                         bool first = true;
                         while (xs != PIT_NIL && pit_value_is_cons(rt, xs)) {
                             if (pit_vec_push(pit_value)(rt->expr_stack, pit_value_cons_car(rt, xs)) < 0) {
-                                pit_error(rt, "dump expr stack overflow");
+                                ret = PIT_DUMP_CONDITION_STACK_OVERFLOW;
                                 goto end;
                             }
                             xs = pit_value_cons_cdr(rt, xs);
@@ -86,7 +86,7 @@ void pit_dump_with_callback(
                             else pit_traversal_push_dump_string(rt, rt->traversal, " ");
                             pit_value x = PIT_NIL;
                             if (pit_vec_pop(pit_value)(rt->expr_stack, &x) < 0) {
-                                pit_error(rt, "dump expr stack underflow");
+                                ret = PIT_DUMP_CONDITION_STACK_UNDERFLOW;
                                 goto end;
                             }
                             pit_traversal_push_value(rt, rt->traversal, x);
@@ -119,12 +119,12 @@ void pit_dump_with_callback(
                             }
                         }
                         if (readable && i < len - 1) buf[i++] = '"';
-                        if (write((u8 *) buf, i, data) < 0) goto end;
+                        if ((ret = write((u8 *) buf, i, data)) < 0) goto end;
                         break;
                     }
                     default:
                         slen = pit_libc_string_snprintf(buf, (size_t) len, "<ref %ld>", r);
-                        if (write((u8 *) buf, slen, data) < 0) goto end;
+                        if ((ret = write((u8 *) buf, slen, data)) < 0) goto end;
                     }
                 }
                 break;
@@ -133,11 +133,13 @@ void pit_dump_with_callback(
             break;
         }
         default:
-            pit_error(rt, "unexpected traversal entry"); goto end;
+            ret = PIT_DUMP_CONDITION_MALFORMED_TRAVERSAL;
+            goto end;
         }
     }
 end:
     rt->traversal->next = traversal_reset;
+    return ret;
 }
 
 struct pit_dump_to_buf_closure {
@@ -145,15 +147,15 @@ struct pit_dump_to_buf_closure {
     i64 len;
     i64 off;
 };
-static i64 pit_dump_to_buf_callback(u8 *buf, i64 len, void *data) {
+static pit_dump_condition 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;
+    if (cl->len - cl->off < len) return PIT_DUMP_CONDITION_FULL;
+    return PIT_DUMP_CONDITION_NORMAL;
 }
 
 i64 pit_dump(pit_runtime *rt, char *buf, i64 len, pit_value v, bool readable) {
diff --git a/pit/src/runtime/eval.c b/pit/src/runtime/eval.c
index f923760..44c9a57 100644
--- a/pit/src/runtime/eval.c
+++ b/pit/src/runtime/eval.c
@@ -82,9 +82,12 @@ pit_value pit_eval(pit_runtime *rt, pit_value top) {
                 args = pit_value_cons(rt, a, args);
             }
             if (ent->in.application.annotation != NULL) {
+                pit_backtrace_entry be;
+                be.val = f;
+                be.ann = *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);
+                pit_vec_push(pit_backtrace_entry)(rt->backtrace, be);
             }
             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/value/cell.c b/pit/src/runtime/value/cell.c
index 34b9226..a9cbe72 100644
--- a/pit/src/runtime/value/cell.c
+++ b/pit/src/runtime/value/cell.c
@@ -11,6 +11,7 @@ pit_value pit_value_cell_new(pit_runtime *rt, pit_value v) {
     h->in.cell = v;
     return ret;
 }
+#include <stdio.h>
 pit_value pit_value_cell_get(pit_runtime *rt, pit_value cell, pit_value sym) {
     if (pit_value_sort(cell) != PIT_VALUE_SORT_REF) {
         char buf[256];