Refactor into monorepo

1 files changed, 116 insertions, 0 deletions

diff --git a/pit/src/runtime.c b/pit/src/runtime.c
new file mode 100644
index 0000000..a8428c7
--- /dev/null
+++ b/pit/src/runtime.c
@@ -0,0 +1,116 @@
+#include <lcq/pit/utils.h>
+#include <lcq/pit/lexer.h>
+#include <lcq/pit/parser.h>
+#include <lcq/pit/runtime.h>
+#include <lcq/pit/library.h>
+
+enum pit_value_sort pit_value_sort(pit_value v) {
+    /* if this isn't a NaN, or it's a quiet NaN, this is a real double */
+    /* if (((v >> 52) & 0b011111111111) != 0b011111111111 || ((v >> 51) & 0b1) == 1) return PIT_VALUE_SORT_DOUBLE; */
+    if (((v >> 52) & 0x7ff) != 0x7ff || ((v >> 51) & 1) == 1) return PIT_VALUE_SORT_DOUBLE;
+    /* otherwise, we've packed something else in the significand
+         0 for signaling NaN -+
+           sign --+ +- 1 (NaN)| +- our sort tag       + our data
+                  | |         | |                     |
+                  s111111111110ttddddddddddddddddddddddddddddddddddddddddddddddddd */
+    /* return (v & 0b0000000000000110000000000000000000000000000000000000000000000000) >> 49; */
+    return (v & 0x6000000000000) >> 49; /* equivalent hex literal */
+}
+
+u64 pit_value_data(pit_value v) {
+    /* return  v & 0b0000000000000001111111111111111111111111111111111111111111111111; */
+    return v & 0x1ffffffffffff;
+}
+
+pit_runtime *pit_runtime_new(u8 *buf, i64 len) {
+    pit_arena *a = pit_arena_new(buf, len, sizeof(u8));
+    pit_runtime *ret = pit_arena_alloc_back(a, sizeof(*ret));
+    i64 heap_size = len / 4;
+    i64 annotations_size = len / 32;
+    i64 symtab_size = len / 16;
+    i64 stack_size = len / 32;
+    ret->heap = pit_arena_new(pit_arena_alloc_back(a, heap_size), heap_size, sizeof(pit_value_heavy));
+    ret->backbuffer = pit_arena_new(pit_arena_alloc_back(a, heap_size), heap_size, sizeof(pit_value_heavy));
+    ret->annotations = pit_vec_new(pit_annotated_ref)(pit_arena_alloc_back(a, annotations_size), annotations_size);
+    ret->backtrace = pit_vec_new(pit_annotated_ref)(pit_arena_alloc_back(a, annotations_size), annotations_size);
+    ret->symtab = pit_vec_new(pit_symtab_entry)(pit_arena_alloc_back(a, symtab_size), symtab_size);
+    ret->expr_stack = pit_vec_new(pit_value)(pit_arena_alloc_back(a, stack_size), stack_size);
+    ret->result_stack = pit_vec_new(pit_value)(pit_arena_alloc_back(a, stack_size), stack_size);
+    ret->program = pit_vec_new(pit_runtime_eval_ins)(pit_arena_alloc_back(a, stack_size), stack_size);
+    ret->saved_bindings = pit_vec_new(pit_value)(pit_arena_alloc_back(a, stack_size), stack_size);
+    ret->frozen_values = 0;
+    ret->frozen_symtab = 0;
+    ret->error = PIT_NIL;
+    ret->source_line = ret->source_column = -1;
+    ret->error_line = ret->error_column = -1;
+    pit_value nil = pit_symtab_intern_cstr(ret, "nil"); /* nil must be the 0th symbol for PIT_NIL to work */
+    pit_symtab_set(ret, nil, PIT_NIL);
+    pit_value truth = pit_symtab_intern_cstr(ret, "t");
+    pit_symtab_set(ret, truth, truth);
+    pit_runtime_freeze(ret);
+    return ret;
+}
+
+void pit_runtime_freeze(pit_runtime *rt) {
+    rt->frozen_values = rt->heap->next;
+    rt->frozen_symtab = rt->symtab->next;
+}
+void pit_runtime_reset(pit_runtime *rt) {
+    rt->heap->next = rt->frozen_values;
+    rt->symtab->next = rt->frozen_symtab;
+}
+
+pit_value pit_error_get(pit_runtime *rt) {
+    pit_value ret = rt->error;
+    rt->error = PIT_NIL;
+    return ret;
+}
+
+void pit_error(pit_runtime *rt, char *format, ...) {
+    if (rt->error == PIT_NIL) { /* only record the first error encountered */
+        char buf[1024] = {0};
+        va_list vargs;
+        va_start(vargs, format);
+        pit_libc_string_snprintf(buf, sizeof(buf), format, vargs);
+        va_end(vargs);
+        rt->error = PIT_T; /* we set the error now to prevent infinite recursion */
+        rt->error = pit_value_bytes_new_cstr(rt, buf); /* in case this errs also */
+        if (rt->error == PIT_NIL) rt->error = PIT_T;
+        rt->error_line = rt->source_line;
+        rt->error_column = rt->source_column;
+    }
+}
+
+void pit_annotation_set(struct pit_runtime *rt, pit_ref ref, pit_annotation annotation) {
+    pit_annotated_ref a;
+    a.ref = ref;
+    a.annotation = annotation;
+    if (pit_vec_push(pit_annotated_ref)(rt->annotations, a) < 0)
+        pit_error(rt, "annotation overflow");
+}
+pit_annotated_ref *pit_annotation_get(struct pit_runtime *rt, pit_ref ref) {
+    for (i64 i = 0; i < rt->annotations->next; ++i) {
+        pit_annotated_ref *a = pit_vec_get(pit_annotated_ref)(rt->annotations, i);
+        if (a == NULL) pit_error(rt, "failed to get annotation");
+        else if (a->ref == ref) {
+            return a;
+        }
+    }
+    return NULL;
+}
+
+void pit_runtime_eval_program_push_literal(pit_runtime *rt, pit_vec(pit_runtime_eval_ins) *s, pit_value x) {
+    pit_runtime_eval_ins ent;
+    ent.sort = PIT_RUNTIME_EVAL_INS_LITERAL;
+    ent.in.literal = x;
+    if (pit_vec_push(pit_runtime_eval_ins)(s, ent) < 0)
+        pit_error(rt, "evaluation program overflow");
+}
+void pit_runtime_eval_program_push_apply(pit_runtime *rt, pit_vec(pit_runtime_eval_ins) *s, i64 arity, pit_annotated_ref *annotation) {
+    pit_runtime_eval_ins ent;
+    ent.sort = PIT_RUNTIME_EVAL_INS_APPLY;
+    ent.in.apply.arity = arity;
+    ent.in.apply.annotation = annotation;
+    if (pit_vec_push(pit_runtime_eval_ins)(s, ent) < 0)
+        pit_error(rt, "evaluation program overflow");
+}