summaryrefslogtreecommitdiff
path: root/pit/src/runtime
diff options
context:
space:
mode:
Diffstat (limited to 'pit/src/runtime')
-rw-r--r--pit/src/runtime/compile.c222
-rw-r--r--pit/src/runtime/eval.c238
-rw-r--r--pit/src/runtime/macroexpand.c31
-rw-r--r--pit/src/runtime/value/func.c133
4 files changed, 296 insertions, 328 deletions
diff --git a/pit/src/runtime/compile.c b/pit/src/runtime/compile.c
new file mode 100644
index 0000000..a676a61
--- /dev/null
+++ b/pit/src/runtime/compile.c
@@ -0,0 +1,222 @@
+#include <lcq/pit/runtime/compile.h>
+
+#include <stdio.h>
+
+static void call_special_form(pit_runtime *rt, pit_value f, pit_value args) {
+ char buf[256] = {0};
+ switch (pit_value_sort(f)) {
+ case PIT_VALUE_SORT_REF: {
+ pit_value_heavy *h = pit_value_ref_deref(rt, pit_value_as_ref(rt, f));
+ if (!h) { pit_error(rt, "bad ref for special form"); return; }
+ switch (h->hsort) {
+ case PIT_VALUE_HEAVY_SORT_NATIVEFUNC:
+ h->in.nativefunc.f(rt, args, h->in.nativefunc.data);
+ break;
+ default: {
+ i64 end = pit_dump(rt, buf, sizeof(buf) - 1, f, true);
+ buf[end] = 0;
+ pit_error(rt, "attempted to apply non-nativefunc special form: %s", buf);
+ return;
+ }
+ }
+ break;
+ }
+ default: {
+ i64 end = pit_dump(rt, buf, sizeof(buf) - 1, f, true);
+ buf[end] = 0;
+ pit_error(rt, "attempted to apply non-function special form: %s", buf);
+ return;
+ }
+ }
+}
+
+static pit_value free_vars(pit_runtime *rt, pit_value initial_bound, pit_value body) {
+ i64 expr_stack_reset = rt->expr_stack->next;
+ pit_value ret = PIT_NIL;
+ if (pit_vec_push(pit_value)(rt->expr_stack, pit_value_cons(rt, initial_bound, body)) < 0) {
+ pit_error(rt, "free variable search stack overflow");
+ return PIT_NIL;
+ }
+ while (rt->expr_stack->next > expr_stack_reset) {
+ pit_value boundscur, bound, cur;
+ if (pit_vec_pop(pit_value)(rt->expr_stack, &boundscur) < 0) {
+ pit_error(rt, "free variable search stack underflow");
+ return PIT_NIL;
+ }
+ bound = pit_value_cons_car(rt, boundscur);
+ cur = pit_value_cons_cdr(rt, boundscur);
+ 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_value fargs = pit_value_cons_cdr(rt, cur);
+ if (is_symbol && pit_symtab_symbol_name_match_cstr(rt, fsym, "lambda")) {
+ pit_value new_bound = pit_value_list_append(rt, pit_value_cons_car(rt, fargs), bound);
+ fargs = pit_value_cons_cdr(rt, fargs);
+ while (fargs != PIT_NIL) {
+ if (pit_vec_push(pit_value)(rt->expr_stack, pit_value_cons(rt, new_bound, pit_value_cons_car(rt, fargs))) < 0) {
+ pit_error(rt, "free variable search stack overflow");
+ return PIT_NIL;
+ }
+ fargs = pit_value_cons_cdr(rt, fargs);
+ }
+ } else if (is_symbol && pit_symtab_symbol_name_match_cstr(rt, fsym, "quote")) {
+ /* don't look inside quote!
+ if we add other special forms, make sure to consider them here if necessary! */
+ } else {
+ while (fargs != PIT_NIL) {
+ if (pit_vec_push(pit_value)(rt->expr_stack, pit_value_cons(rt, bound, pit_value_cons_car(rt, fargs))) < 0) {
+ pit_error(rt, "free variable search stack overflow");
+ return PIT_NIL;
+ }
+ fargs = pit_value_cons_cdr(rt, fargs);
+ }
+ if (!is_symbol) {
+ if (pit_vec_push(pit_value)(rt->expr_stack, pit_value_cons(rt, bound, fsym)) < 0) {
+ pit_error(rt, "free variable search stack overflow");
+ return PIT_NIL;
+ }
+ }
+ }
+ } else if (pit_value_is_symbol(rt, cur)) {
+ if (pit_value_list_contains_eq(rt, cur, bound) == PIT_NIL) {
+ ret = pit_value_cons(rt, cur, ret);
+ }
+ }
+ }
+ rt->expr_stack->next = expr_stack_reset;
+ return ret;
+}
+
+static pit_value lambda(pit_runtime *rt, pit_value args, pit_value body) {
+ pit_value expanded = pit_macroexpand(rt, pit_value_cons(rt, pit_symtab_intern_cstr(rt, "progn"), body));
+ fprintf(stderr, "lambda: "); pit_dump_to_file(rt, stderr, expanded, false); fprintf(stderr, "\n");
+ return pit_value_list(rt, 4,
+ pit_symtab_intern_cstr(rt, "lambda"),
+ args,
+ free_vars(rt, args, expanded),
+ pit_compile(rt, expanded)
+ );
+}
+
+static void c_now(pit_runtime *rt, pit_value v) {
+ pit_traversal_push_value(rt, rt->traversal, v);
+}
+
+static void c_eval(pit_runtime *rt, pit_value e) {
+ if (pit_vec_push(pit_value)(rt->expr_stack, e) < 0)
+ pit_error(rt, "evaluation stack overflow");
+}
+
+pit_value pit_compile(pit_runtime *rt, pit_value top) {
+ char buf[256] = {0};
+ pit_value ret = PIT_NIL;
+ i64 expr_stack_reset = rt->expr_stack->next;
+ i64 traversal_reset = rt->traversal->next;
+ fprintf(stderr, "compile: "); pit_dump_to_file(rt, stderr, top, false); fprintf(stderr, "\n");
+ c_eval(rt, top);
+ /* convert the expression tree into "polish notation" in traversal */
+ while (rt->expr_stack->next > expr_stack_reset) {
+ pit_value cur = PIT_NIL;
+ if (rt->error != PIT_NIL) goto end;
+ if (pit_vec_pop(pit_value)(rt->expr_stack, &cur) < 0)
+ pit_error(rt, "evaluation stack underflow");
+ fprintf(stderr, "cur: "); pit_dump_to_file(rt, stderr, cur, false); fprintf(stderr, "\n");
+ 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_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);
+ call_special_form(rt, f, args);
+ } else if (is_symbol && pit_symtab_is_symbol_macro(rt, fsym)) { /* macros */
+ i64 end = pit_dump(rt, buf, sizeof(buf) - 1, fsym, true);
+ buf[end] = 0;
+ pit_error(rt, "encountered an unexpanded macro while compiling: %s", buf);
+ } else { /* normal functions */
+ pit_value args = pit_value_cons_cdr(rt, cur);
+ i64 argcount = 0;
+ while (args != PIT_NIL) {
+ // fprintf(stderr, "push1: "); pit_dump_to_file(rt, stderr, pit_value_cons_car(rt, args), false); fprintf(stderr, "\n");
+ c_eval(rt, pit_value_cons_car(rt, args));
+ args = pit_value_cons_cdr(rt, args);
+ argcount += 1;
+ }
+ if (!is_symbol) {
+ // fprintf(stderr, "push2: "); pit_dump_to_file(rt, stderr, fsym, false); fprintf(stderr, "\n");
+ c_eval(rt, fsym);
+ }
+ c_now(rt, pit_value_list(rt, 2, pit_symtab_intern_cstr(rt, "apply"), pit_value_integer_new(rt, argcount)));
+ if (is_symbol) {
+ c_now(rt, pit_value_list(rt, 1, pit_symtab_intern_cstr(rt, "fget")));
+ c_now(rt, pit_value_list(rt, 2, pit_symtab_intern_cstr(rt, "literal"), fsym));
+ }
+ }
+ } else if (pit_value_is_symbol(rt, cur)) { /* unquoted symbols: variable lookup */
+ pit_symtab_entry *ent = pit_symtab_lookup(rt, cur);
+ if (ent->is_keyword) {
+ c_now(rt, pit_value_list(rt, 2, pit_symtab_intern_cstr(rt, "literal"), cur));
+ } else {
+ c_now(rt, pit_value_list(rt, 1, pit_symtab_intern_cstr(rt, "get")));
+ c_now(rt, pit_value_list(rt, 2, pit_symtab_intern_cstr(rt, "literal"), cur));
+ }
+ } else { /* other expressions evaluate to themselves! */
+ c_now(rt, pit_value_list(rt, 2, pit_symtab_intern_cstr(rt, "literal"), cur));
+ }
+ }
+ for (i64 idx = traversal_reset; idx < rt->traversal->next; idx++) {
+ pit_traversal_entry *ent = pit_vec_get(pit_traversal_entry)(rt->traversal, idx);
+ if (ent == NULL) pit_error(rt, "evaluation traversal invalid");
+ if (rt->error != PIT_NIL) goto end;
+ switch (ent->sort) {
+ case PIT_TRAVERSAL_ENTRY_VALUE: {
+ ret = pit_value_cons(rt, ent->in.value, ret);
+ break;
+ }
+ default:
+ pit_error(rt, "unknown traversal entry");
+ ret = PIT_NIL;
+ goto end;
+ }
+ }
+end: {
+ rt->expr_stack->next = expr_stack_reset;
+ rt->traversal->next = traversal_reset;
+ fprintf(stderr, "compiled: "); pit_dump_to_file(rt, stderr, ret, false); fprintf(stderr, "\n");
+ return ret;
+ }
+}
+
+static pit_value impl_sf_quote(pit_runtime *rt, pit_value args, void *data) {
+ (void) data;
+ pit_traversal_push_value(rt, rt->traversal,
+ pit_value_list(rt, 2, pit_symtab_intern_cstr(rt, "literal"), pit_value_cons_car(rt, args))
+ );
+ return PIT_NIL;
+}
+static pit_value impl_sf_if(pit_runtime *rt, pit_value args, void *data) {
+ (void) data;
+ pit_value c = pit_value_cons_car(rt, args);
+ args = pit_value_cons_cdr(rt, args);
+ pit_value t = pit_value_cons_car(rt, args);
+ args = pit_value_cons_cdr(rt, args);
+ pit_value e = pit_value_cons_car(rt, args);
+ c_now(rt, pit_value_list(rt, 1, pit_symtab_intern_cstr(rt, "if")));
+ c_now(rt, lambda(rt, PIT_NIL, pit_value_list(rt, 1, t)));
+ c_now(rt, lambda(rt, PIT_NIL, pit_value_list(rt, 1, e)));
+ c_eval(rt, c);
+ return PIT_NIL;
+}
+static pit_value impl_sf_lambda(pit_runtime *rt, pit_value args, void *data) {
+ (void) data;
+ pit_value as = pit_value_cons_car(rt, args);
+ pit_value body = pit_value_cons_cdr(rt, args);
+ c_now(rt, lambda(rt, as, body));
+ return PIT_NIL;
+}
+
+void pit_compile_install_special_forms(pit_runtime *rt) {
+ pit_symtab_sfset(rt, pit_symtab_intern_cstr(rt, "quote"), pit_value_nativefunc_new(rt, impl_sf_quote));
+ pit_symtab_sfset(rt, pit_symtab_intern_cstr(rt, "if"), pit_value_nativefunc_new(rt, impl_sf_if));
+ pit_symtab_sfset(rt, pit_symtab_intern_cstr(rt, "lambda"), pit_value_nativefunc_new(rt, impl_sf_lambda));
+}
diff --git a/pit/src/runtime/eval.c b/pit/src/runtime/eval.c
index 1822bc5..3903a64 100644
--- a/pit/src/runtime/eval.c
+++ b/pit/src/runtime/eval.c
@@ -2,127 +2,8 @@
#include <stdio.h>
-void pit_vm_call_special_form(pit_runtime *rt, pit_value f, pit_value args) {
- char buf[256] = {0};
- switch (pit_value_sort(f)) {
- case PIT_VALUE_SORT_REF: {
- pit_value_heavy *h = pit_value_ref_deref(rt, pit_value_as_ref(rt, f));
- if (!h) { pit_error(rt, "bad ref for special form"); return; }
- switch (h->hsort) {
- case PIT_VALUE_HEAVY_SORT_NATIVEFUNC:
- h->in.nativefunc.f(rt, args, h->in.nativefunc.data);
- break;
- default: {
- i64 end = pit_dump(rt, buf, sizeof(buf) - 1, f, true);
- buf[end] = 0;
- pit_error(rt, "attempted to apply non-nativefunc special form: %s", buf);
- return;
- }
- }
- break;
- }
- default: {
- i64 end = pit_dump(rt, buf, sizeof(buf) - 1, f, true);
- buf[end] = 0;
- pit_error(rt, "attempted to apply non-function special form: %s", buf);
- return;
- }
- }
-}
-
-pit_value pit_vm_compile(pit_runtime *rt, pit_value top) {
- pit_value ret = PIT_NIL;
- i64 expr_stack_reset = rt->expr_stack->next;
- i64 traversal_reset = rt->traversal->next;
- if (pit_vec_push(pit_value)(rt->expr_stack, top) < 0)
- pit_error(rt, "evaluation stack overflow");
- /* first, convert the expression tree into "polish notation" in traversal */
- while (rt->expr_stack->next > expr_stack_reset) {
- pit_value cur = PIT_NIL;
- if (rt->error != PIT_NIL) goto end;
- if (pit_vec_pop(pit_value)(rt->expr_stack, &cur) < 0)
- pit_error(rt, "evaluation stack underflow");
- fprintf(stderr, "cur: "); pit_dump_to_file(rt, stderr, cur, false); fprintf(stderr, "\n");
- 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_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);
- pit_vm_call_special_form(rt, f, args);
- } else if (is_symbol && pit_symtab_is_symbol_macro(rt, fsym)) { /* macros */
- pit_error(rt, "encountered a macro while evaluating");
- } else { /* normal functions */
- pit_value args = pit_value_cons_cdr(rt, cur);
- i64 argcount = 0;
- while (args != PIT_NIL) {
- if (pit_vec_push(pit_value)(rt->expr_stack, pit_value_cons_car(rt, args)) < 0)
- pit_error(rt, "evaluation stack overflow");
- args = pit_value_cons_cdr(rt, args);
- argcount += 1;
- }
- if (!is_symbol) {
- if (pit_vec_push(pit_value)(rt->expr_stack, fsym) < 0)
- pit_error(rt, "evaluation stack overflow");
- }
- pit_traversal_push_value(rt, rt->traversal,
- pit_value_list(rt, 2, pit_symtab_intern_cstr(rt, "apply"), pit_value_integer_new(rt, argcount))
- );
- if (is_symbol) {
- pit_traversal_push_value(rt, rt->traversal,
- pit_value_list(rt, 1, pit_symtab_intern_cstr(rt, "fget"))
- );
- pit_traversal_push_value(rt, rt->traversal,
- pit_value_list(rt, 2, pit_symtab_intern_cstr(rt, "literal"), fsym)
- );
- }
- }
- } else if (pit_value_is_symbol(rt, cur)) { /* unquoted symbols: variable lookup */
- pit_symtab_entry *ent = pit_symtab_lookup(rt, cur);
- if (ent->is_keyword) {
- pit_traversal_push_value(rt, rt->traversal,
- pit_value_list(rt, 2, pit_symtab_intern_cstr(rt, "literal"), cur)
- );
- } else {
- pit_traversal_push_value(rt, rt->traversal,
- pit_value_list(rt, 1, pit_symtab_intern_cstr(rt, "get"))
- );
- pit_traversal_push_value(rt, rt->traversal,
- pit_value_list(rt, 2, pit_symtab_intern_cstr(rt, "literal"), cur)
- );
- }
- } else { /* other expressions evaluate to themselves! */
- pit_traversal_push_value(rt, rt->traversal,
- pit_value_list(rt, 2, pit_symtab_intern_cstr(rt, "literal"), cur)
- );
- }
- }
- for (i64 idx = traversal_reset; idx < rt->traversal->next; idx++) {
- pit_traversal_entry *ent = pit_vec_get(pit_traversal_entry)(rt->traversal, idx);
- if (ent == NULL) pit_error(rt, "evaluation traversal invalid");
- if (rt->error != PIT_NIL) goto end;
- switch (ent->sort) {
- case PIT_TRAVERSAL_ENTRY_VALUE: {
- ret = pit_value_cons(rt, ent->in.value, ret);
- break;
- }
- default:
- pit_error(rt, "unknown traversal entry");
- ret = PIT_NIL;
- goto end;
- }
- }
-end: {
- rt->expr_stack->next = expr_stack_reset;
- rt->traversal->next = traversal_reset;
- fprintf(stderr, "compiled: "); pit_dump_to_file(rt, stderr, ret, false); fprintf(stderr, "\n");
- return ret;
- }
-}
-
/* add a new stack frame to the vm (with a tag and callsite annotation) */
-void pit_vm_push_code_func(pit_runtime *rt, pit_value code, pit_value tag, pit_annotation ann, pit_value bound) {
+static void vm_push_code_func(pit_runtime *rt, pit_value code, pit_value tag, pit_annotation ann, pit_value bound) {
pit_callstack_entry ent;
ent.tag = tag;
ent.ann = ann;
@@ -135,36 +16,38 @@ void pit_vm_push_code_func(pit_runtime *rt, pit_value code, pit_value tag, pit_a
}
/* add a new stack frame to the vm (with no annotation) */
-void pit_vm_push_code(pit_runtime *rt, pit_value code) {
+static void vm_push_code(pit_runtime *rt, pit_value code) {
pit_annotation ann;
ann.line = -1;
ann.column = -1;
- pit_vm_push_code_func(rt, code, PIT_NIL, ann, PIT_NIL);
+ vm_push_code_func(rt, code, PIT_NIL, ann, PIT_NIL);
}
-void pit_vm_push(pit_runtime *rt, pit_value v) {
- fprintf(stderr, "push: "); pit_dump_to_file(rt, stderr, v, false); fprintf(stderr, "\n");
+static void vm_push(pit_runtime *rt, pit_value v) {
+ // fprintf(stderr, "push: "); pit_dump_to_file(rt, stderr, v, false); fprintf(stderr, "\n");
if (pit_vec_push(pit_value)(rt->result_stack, v) < 0) {
pit_error(rt, "vm stack overflow");
}
}
-pit_value pit_vm_pop(pit_runtime *rt) {
+static pit_value vm_pop(pit_runtime *rt) {
pit_value ret = PIT_NIL;
if (pit_vec_pop(pit_value)(rt->result_stack, &ret) < 0) {
pit_error(rt, "vm stack underflow");
}
- fprintf(stderr, "pop: "); pit_dump_to_file(rt, stderr, ret, false); fprintf(stderr, "\n");
+ // fprintf(stderr, "pop: "); pit_dump_to_file(rt, stderr, ret, false); fprintf(stderr, "\n");
return ret;
}
-void pit_vm_call_lisp(pit_runtime *rt, pit_value tag, pit_value closure, pit_value args) {
+static void vm_call_lisp(pit_runtime *rt, pit_value tag, pit_value closure, pit_value args) {
pit_value bound = PIT_NIL;
pit_value env = pit_value_array_get(rt, closure, 0);
pit_value anames = pit_value_array_get(rt, closure, 1);
pit_value arg_rest_nm = pit_value_array_get(rt, closure, 2);
pit_value body = pit_value_array_get(rt, closure, 3);
if (rt->error != PIT_NIL) return;
+ // fprintf(stderr, "call lisp: "); pit_dump_to_file(rt, stderr, closure, false); fprintf(stderr, "\n");
+ // fprintf(stderr, "binding: "); pit_dump_to_file(rt, stderr, env, false); fprintf(stderr, "\n");
while (env != PIT_NIL) { /* first, bind all entries in the closure */
pit_value b = pit_value_cons_car(rt, env);
pit_value nm = pit_value_cons_car(rt, b);
@@ -190,28 +73,28 @@ void pit_vm_call_lisp(pit_runtime *rt, pit_value tag, pit_value closure, pit_val
pit_annotation ann;
ann.line = -1;
ann.column = -1;
- pit_vm_push_code_func(rt, body, tag, ann, bound);
+ vm_push_code_func(rt, body, tag, ann, bound);
}
-void pit_vm_call(pit_runtime *rt, pit_value f, pit_value args) {
+static bool vm_call(pit_runtime *rt, pit_value f, pit_value args) {
char buf[256] = {0};
if (pit_value_is_symbol(rt, f)) f = pit_symtab_fget(rt, f);
switch (pit_value_sort(f)) {
case PIT_VALUE_SORT_REF: {
pit_value_heavy *h = pit_value_ref_deref(rt, pit_value_as_ref(rt, f));
- if (!h) { pit_error(rt, "bad ref for function"); return; }
+ if (!h) { pit_error(rt, "bad ref for function"); return false; }
switch (h->hsort) {
case PIT_VALUE_HEAVY_SORT_NATIVEFUNC:
- pit_vm_push(rt, h->in.nativefunc.f(rt, args, h->in.nativefunc.data));
+ vm_push(rt, h->in.nativefunc.f(rt, args, h->in.nativefunc.data));
break;
case PIT_VALUE_HEAVY_SORT_FUNC:
- pit_vm_call_lisp(rt, h->in.func.nm, h->in.func.closure, args);
+ vm_call_lisp(rt, h->in.func.nm, h->in.func.closure, args);
break;
default: {
i64 end = pit_dump(rt, buf, sizeof(buf) - 1, f, true);
buf[end] = 0;
pit_error(rt, "attempted to apply non-function ref: %s", buf);
- return;
+ return false;
}
}
break;
@@ -220,20 +103,21 @@ void pit_vm_call(pit_runtime *rt, pit_value f, pit_value args) {
i64 end = pit_dump(rt, buf, sizeof(buf) - 1, f, true);
buf[end] = 0;
pit_error(rt, "attempted to apply non-function value: %s", buf);
- return;
+ return false;
}
}
+ return true;
}
/* run one instruction of the VM */
bool pit_vm_run_one(pit_runtime *rt) {
- char buf[256] = {0};
if (rt->callstack->next < 1) return false;
pit_callstack_entry *ent = pit_vec_get(pit_callstack_entry)(rt->callstack, rt->callstack->next - 1);
if (ent == NULL) {
pit_error(rt, "malformed call stack");
return false;
}
+ // fprintf(stderr, "code: "); pit_dump_to_file(rt, stderr, ent->code, false); fprintf(stderr, "\n");
pit_value ins = pit_value_cons_car(rt, ent->code);
if (ins == PIT_NIL) {
pit_error(rt, "malformed vm instruction");
@@ -246,53 +130,50 @@ bool pit_vm_run_one(pit_runtime *rt) {
final = true;
pit_vec_pop(pit_callstack_entry)(rt->callstack, NULL);
} else ent->code = rest;
- fprintf(stderr, "ins: "); pit_dump_to_file(rt, stderr, ins, false); fprintf(stderr, "\n");
+ // fprintf(stderr, "ins: "); pit_dump_to_file(rt, stderr, ins, false); fprintf(stderr, "\n");
pit_value op = pit_value_cons_car(rt, ins);
if (pit_symtab_symbol_name_match_cstr(rt, op, "literal")) {
- pit_vm_push(rt, pit_value_cons_car(rt, pit_value_cons_cdr(rt, ins)));
+ /* push a lisp value to the vm stack */
+ vm_push(rt, pit_value_cons_car(rt, pit_value_cons_cdr(rt, ins)));
+ } else if (pit_symtab_symbol_name_match_cstr(rt, op, "lambda")) {
+ /* create and push a function with the given arguments, free variables, and (compiled) body */
+ /* notably, this builds the closure by recording the currently-bound cells for each free variable! */
+ pit_value args = pit_value_cons_cdr(rt, ins);
+ pit_value as = pit_value_cons_car(rt, args);
+ args = pit_value_cons_cdr(rt, args);
+ pit_value freevars = pit_value_cons_car(rt, args);
+ args = pit_value_cons_cdr(rt, args);
+ pit_value body = pit_value_cons_car(rt, args);
+ vm_push(rt, pit_value_func_lambda(rt, as, freevars, body));
} else if (pit_symtab_symbol_name_match_cstr(rt, op, "get")) {
- pit_vm_push(rt, pit_symtab_get(rt, pit_vm_pop(rt)));
+ pit_value nm = vm_pop(rt);
+ // fprintf(stderr, "get: "); pit_dump_to_file(rt, stderr, nm, false); fprintf(stderr, "\n");
+ vm_push(rt, pit_symtab_get(rt, nm));
+ /* pop a symbol and look up its value */
+ // vm_push(rt, pit_symtab_get(rt, vm_pop(rt)));
} else if (pit_symtab_symbol_name_match_cstr(rt, op, "fget")) {
- pit_vm_push(rt, pit_symtab_fget(rt, pit_vm_pop(rt)));
+ /* pop a symbol and look up its function value */
+ vm_push(rt, pit_symtab_fget(rt, vm_pop(rt)));
+ } else if (pit_symtab_symbol_name_match_cstr(rt, op, "if")) {
+ /* pop a then-function, an else-function, and a condition */
+ /* call (no args) the then-function if the condition is true, otherwise call the else-function */
+ pit_value t = vm_pop(rt);
+ pit_value e = vm_pop(rt);
+ pit_value c = vm_pop(rt);
+ if (!vm_call(rt, c != PIT_NIL ? t : e, PIT_NIL)) return false;
} else if (pit_symtab_symbol_name_match_cstr(rt, op, "apply")) {
+ /* pop an arity n and a function, and then n arguments, and apply the function */
i64 arity = pit_value_as_integer(rt, pit_value_cons_car(rt, pit_value_cons_cdr(rt, ins)));
- pit_value f = pit_vm_pop(rt);
+ pit_value f = vm_pop(rt);
pit_value args = PIT_NIL;
- while (arity-- > 0) args = pit_value_cons(rt, pit_vm_pop(rt), args);
- if (pit_value_is_symbol(rt, f)) f = pit_symtab_fget(rt, f);
- switch (pit_value_sort(f)) {
- case PIT_VALUE_SORT_REF: {
- pit_value_heavy *h = pit_value_ref_deref(rt, pit_value_as_ref(rt, f));
- if (!h) { pit_error(rt, "bad ref for function"); return PIT_NIL; }
- switch (h->hsort) {
- case PIT_VALUE_HEAVY_SORT_NATIVEFUNC:
- pit_vm_push(rt, h->in.nativefunc.f(rt, args, h->in.nativefunc.data));
- break;
- case PIT_VALUE_HEAVY_SORT_FUNC:
- pit_vm_call_lisp(rt, h->in.func.nm, h->in.func.closure, args);
- break;
- default: {
- i64 end = pit_dump(rt, buf, sizeof(buf) - 1, f, true);
- buf[end] = 0;
- pit_error(rt, "attempted to apply non-function ref: %s", buf);
- return false;
- }
- }
- break;
- }
- default: {
- i64 end = pit_dump(rt, buf, sizeof(buf) - 1, f, true);
- buf[end] = 0;
- pit_error(rt, "attempted to apply non-function value: %s", buf);
- return false;
- }
- }
+ while (arity-- > 0) args = pit_value_cons(rt, vm_pop(rt), args);
+ if (!vm_call(rt, f, args)) return false;
} else {
pit_error(rt, "unknown vm operation");
return false;
}
if (final) { /* if we have finished this stack frame */
- fprintf(stderr, "unbinding: "); pit_dump_to_file(rt, stderr, bound, false); fprintf(stderr, "\n");
+ // fprintf(stderr, "unbinding: "); pit_dump_to_file(rt, stderr, bound, false); fprintf(stderr, "\n");
while (bound != PIT_NIL) { /* unbind everything we bound for the frame, in reverse */
pit_symtab_unbind(rt, pit_value_cons_car(rt, bound));
bound = pit_value_cons_cdr(rt, bound);
@@ -301,15 +182,18 @@ bool pit_vm_run_one(pit_runtime *rt) {
return true;
}
-/* run the VM until evaluation finishes, returning the result */
+/* run the VM until evaluation of this code finishes, returning the result */
pit_value pit_vm_eval(pit_runtime *rt, pit_value v) {
- pit_vm_push_code(rt, v);
- while (pit_vm_run_one(rt));
- pit_vm_pop(rt);
+ i64 start = rt->callstack->next;
+ vm_push_code(rt, v);
+ while (pit_vm_run_one(rt) && rt->callstack->next > start);
+ return vm_pop(rt);
}
+/* run the VM until this function call finishes, returning the result */
pit_value pit_vm_apply(pit_runtime *rt, pit_value f, pit_value args) {
- pit_vm_call(rt, f, args);
- while (pit_vm_run_one(rt));
- pit_vm_pop(rt);
+ i64 start = rt->callstack->next;
+ vm_call(rt, f, args);
+ while (pit_vm_run_one(rt) && rt->callstack->next > start);
+ return vm_pop(rt);
}
diff --git a/pit/src/runtime/macroexpand.c b/pit/src/runtime/macroexpand.c
index 7ff1a6a..ffa796d 100644
--- a/pit/src/runtime/macroexpand.c
+++ b/pit/src/runtime/macroexpand.c
@@ -1,6 +1,9 @@
#include <lcq/pit/runtime/macroexpand.h>
+#include <stdio.h>
+
pit_value pit_macroexpand(pit_runtime *rt, pit_value top) {
+ fprintf(stderr, "macroexpand: "); pit_dump_to_file(rt, stderr, top, false); fprintf(stderr, "\n");
i64 expr_stack_reset = rt->expr_stack->next;
i64 result_stack_reset = rt->result_stack->next;
i64 traversal_reset = rt->traversal->next;
@@ -15,33 +18,14 @@ pit_value pit_macroexpand(pit_runtime *rt, pit_value top) {
pit_value fsym = pit_value_cons_car(rt, cur);
bool is_symbol = pit_value_is_symbol(rt, fsym);
pit_annotation *ann = pit_annotation_get(rt, pit_value_as_ref(rt, cur));
- if (is_symbol && pit_symtab_is_symbol_macro(rt, fsym)) {
+ if (is_symbol && pit_symtab_is_symbol_special_form(rt, fsym)) {
+ pit_traversal_push_value(rt, rt->traversal, cur);
+ } else 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);
- pit_value res = pit_value_apply(rt, f, args);
+ pit_value res = pit_vm_apply(rt, f, args);
if (pit_vec_push(pit_value)(rt->expr_stack, res) < 0)
pit_error(rt, "macro expansion stack overflow");
- } else if (is_symbol && pit_symtab_symbol_name_match_cstr(rt, fsym, "defer")) {
- pit_value args = pit_value_cons_cdr(rt, cur);
- pit_traversal_push_value(rt, rt->traversal, pit_value_cons_car(rt, args));
- } else if (is_symbol && pit_symtab_symbol_name_match_cstr(rt, fsym, "quote")) {
- pit_traversal_push_value(rt, rt->traversal, cur);
- } else if (is_symbol && pit_symtab_symbol_name_match_cstr(rt, fsym, "lambda")) {
- pit_value args = pit_value_cons_cdr(rt, cur);
- pit_value bindings = pit_value_cons_car(rt, args);
- pit_value body = pit_value_cons_cdr(rt, args);
- i64 argcount = 0;
- if (pit_vec_push(pit_value)(rt->expr_stack, pit_value_list(rt, 2, pit_symtab_intern_cstr(rt, "defer"), bindings)) < 0)
- pit_error(rt, "macro expansion stack overflow");
- while (body != PIT_NIL) {
- pit_value a = pit_value_cons_car(rt, body);
- if (pit_vec_push(pit_value)(rt->expr_stack, a) < 0)
- pit_error(rt, "macro expansion stack overflow");
- body = pit_value_cons_cdr(rt, body);
- argcount += 1;
- }
- pit_traversal_push_application(rt, rt->traversal, argcount + 1, ann);
- pit_traversal_push_value(rt, rt->traversal, fsym);
} else {
pit_value args = pit_value_cons_cdr(rt, cur);
i64 argcount = 0;
@@ -106,6 +90,7 @@ end: {
rt->expr_stack->next = expr_stack_reset;
rt->result_stack->next = result_stack_reset;
rt->traversal->next = traversal_reset;
+ fprintf(stderr, "macroexpand result: "); pit_dump_to_file(rt, stderr, ret, false); fprintf(stderr, "\n");
return ret;
}
}
diff --git a/pit/src/runtime/value/func.c b/pit/src/runtime/value/func.c
index 5f88cb0..ad5ce4c 100644
--- a/pit/src/runtime/value/func.c
+++ b/pit/src/runtime/value/func.c
@@ -1,61 +1,6 @@
#include <lcq/pit/runtime/value/func.h>
-static pit_value free_vars(pit_runtime *rt, pit_value initial_bound, pit_value body) {
- i64 expr_stack_reset = rt->expr_stack->next;
- pit_value ret = PIT_NIL;
- if (pit_vec_push(pit_value)(rt->expr_stack, pit_value_cons(rt, initial_bound, body)) < 0) {
- pit_error(rt, "free variable search stack overflow");
- return PIT_NIL;
- }
- while (rt->expr_stack->next > expr_stack_reset) {
- pit_value boundscur, bound, cur;
- if (pit_vec_pop(pit_value)(rt->expr_stack, &boundscur) < 0) {
- pit_error(rt, "free variable search stack underflow");
- return PIT_NIL;
- }
- bound = pit_value_cons_car(rt, boundscur);
- cur = pit_value_cons_cdr(rt, boundscur);
- 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_value fargs = pit_value_cons_cdr(rt, cur);
- if (is_symbol && pit_symtab_symbol_name_match_cstr(rt, fsym, "lambda")) {
- pit_value new_bound = pit_value_list_append(rt, pit_value_cons_car(rt, fargs), bound);
- fargs = pit_value_cons_cdr(rt, fargs);
- while (fargs != PIT_NIL) {
- if (pit_vec_push(pit_value)(rt->expr_stack, pit_value_cons(rt, new_bound, pit_value_cons_car(rt, fargs))) < 0) {
- pit_error(rt, "free variable search stack overflow");
- return PIT_NIL;
- }
- fargs = pit_value_cons_cdr(rt, fargs);
- }
- } else if (is_symbol && pit_symtab_symbol_name_match_cstr(rt, fsym, "quote")) {
- /* don't look inside quote!
- if we add other special forms, make sure to consider them here if necessary! */
- } else {
- while (fargs != PIT_NIL) {
- if (pit_vec_push(pit_value)(rt->expr_stack, pit_value_cons(rt, bound, pit_value_cons_car(rt, fargs))) < 0) {
- pit_error(rt, "free variable search stack overflow");
- return PIT_NIL;
- }
- fargs = pit_value_cons_cdr(rt, fargs);
- }
- if (!is_symbol) {
- if (pit_vec_push(pit_value)(rt->expr_stack, pit_value_cons(rt, bound, fsym)) < 0) {
- pit_error(rt, "free variable search stack overflow");
- return PIT_NIL;
- }
- }
- }
- } else if (pit_value_is_symbol(rt, cur)) {
- if (pit_value_list_contains_eq(rt, cur, bound) == PIT_NIL) {
- ret = pit_value_cons(rt, cur, ret);
- }
- }
- }
- rt->expr_stack->next = expr_stack_reset;
- return ret;
-}
+#include <stdio.h>
bool pit_value_is_func(pit_runtime *rt, pit_value a) {
return pit_value_is_ref_heavy_sort(rt, a, PIT_VALUE_HEAVY_SORT_FUNC);
@@ -63,12 +8,13 @@ bool pit_value_is_func(pit_runtime *rt, pit_value a) {
bool pit_value_is_nativefunc(pit_runtime *rt, pit_value a) {
return pit_value_is_ref_heavy_sort(rt, a, PIT_VALUE_HEAVY_SORT_NATIVEFUNC);
}
-pit_value pit_value_func_lambda(pit_runtime *rt, pit_value args, pit_value body) {
+pit_value pit_value_func_lambda(pit_runtime *rt, pit_value args, pit_value freevars, pit_value compiled) {
+ // fprintf(stderr, "lambda args: "); pit_dump_to_file(rt, stderr, args, false); fprintf(stderr, "\n");
+ // fprintf(stderr, "lambda freevars: "); pit_dump_to_file(rt, stderr, freevars, false); fprintf(stderr, "\n");
+ // fprintf(stderr, "lambda compiled: "); pit_dump_to_file(rt, stderr, compiled, false); fprintf(stderr, "\n");
pit_value ret = pit_value_ref_heavy_new(rt);
pit_value_heavy *h = pit_value_ref_deref(rt, pit_value_as_ref(rt, ret));
if (!h) { pit_error(rt, "failed to create new heavy value for lambda"); return PIT_NIL; }
- pit_value expanded = pit_macroexpand(rt, pit_value_cons(rt, pit_symtab_intern_cstr(rt, "progn"), body));
- pit_value freevars = free_vars(rt, args, expanded);
pit_value env = PIT_NIL;
while (freevars != PIT_NIL) {
pit_value sym = pit_value_cons_car(rt, freevars);
@@ -94,7 +40,6 @@ pit_value pit_value_func_lambda(pit_runtime *rt, pit_value args, pit_value body)
}
}
arg_cells = pit_value_list_reverse(rt, arg_cells);
- pit_value compiled = pit_vm_compile(rt, expanded);
pit_value closure[4] = {env, arg_cells, arg_rest_nm, compiled};
h->in.func.nm = PIT_NIL;
h->in.func.closure = pit_value_array_from_buf(rt, closure, 4);
@@ -112,71 +57,3 @@ pit_value pit_value_nativefunc_new_with_data(pit_runtime *rt, pit_nativefunc f,
pit_value pit_value_nativefunc_new(pit_runtime *rt, pit_nativefunc f) {
return pit_value_nativefunc_new_with_data(rt, f, NULL);
}
-pit_value pit_value_apply(pit_runtime *rt, pit_value f, pit_value args) {
- char buf[256] = {0};
- if (pit_value_is_symbol(rt, f)) {
- f = pit_symtab_fget(rt, f);
- }
- /* if f is not a symbol, assume it is a func or nativefunc
- most commonly, this happens when you funcall a variable
- with a function in the value cell, e.g. passing a lambda to a function */
- switch (pit_value_sort(f)) {
- case PIT_VALUE_SORT_REF: {
- pit_value_heavy *h = pit_value_ref_deref(rt, pit_value_as_ref(rt, f));
- if (!h) { pit_error(rt, "bad ref"); return PIT_NIL; }
- if (h->hsort == PIT_VALUE_HEAVY_SORT_FUNC) {
- /* calling a Lisp function is simple! */
- pit_value bound = PIT_NIL;
- pit_value env = pit_value_array_get(rt, h->in.func.closure, 0);
- pit_value anames = pit_value_array_get(rt, h->in.func.closure, 1);
- pit_value arg_rest_nm = pit_value_array_get(rt, h->in.func.closure, 2);
- pit_value body = pit_value_array_get(rt, h->in.func.closure, 3);
- if (rt->error != PIT_NIL) return PIT_NIL;
- while (env != PIT_NIL) { /* first, bind all entries in the closure */
- pit_value b = pit_value_cons_car(rt, env);
- pit_value nm = pit_value_cons_car(rt, b);
- pit_symtab_bind(rt, nm, pit_value_cons_cdr(rt, b));
- bound = pit_value_cons(rt, nm, bound);
- env = pit_value_cons_cdr(rt, env);
- }
- while (anames != PIT_NIL) { /* bind all argument names to their values */
- pit_value nm = pit_value_cons_car(rt, anames);
- pit_value cell = pit_value_cell_new(rt, PIT_NIL);
- if (arg_rest_nm != PIT_NIL && pit_value_eq(nm, arg_rest_nm)) {
- pit_value_cell_set(rt, cell, args, nm);
- pit_symtab_bind(rt, nm, cell);
- break;
- } else {
- pit_value_cell_set(rt, cell, pit_value_cons_car(rt, args), nm);
- pit_symtab_bind(rt, nm, cell);
- }
- bound = pit_value_cons(rt, nm, bound);
- args = pit_value_cons_cdr(rt, args);
- anames = pit_value_cons_cdr(rt, anames);
- }
- /* TODO */
- pit_value ret = body;
- // pit_value ret = pit_eval(rt, body); /* evaluate the body */
- while (bound != PIT_NIL) { /* unbind everything we bound earlier, in reverse */
- pit_symtab_unbind(rt, pit_value_cons_car(rt, bound));
- bound = pit_value_cons_cdr(rt, bound);
- }
- return ret;
- } else if (h->hsort == PIT_VALUE_HEAVY_SORT_NATIVEFUNC) {
- /* calling native functions is even simpler */
- return h->in.nativefunc.f(rt, args, h->in.nativefunc.data);
- } else {
- i64 end = pit_dump(rt, buf, sizeof(buf) - 1, f, true);
- buf[end] = 0;
- pit_error(rt, "attempted to apply non-function ref: %s", buf);
- return PIT_NIL;
- }
- }
- default: {
- i64 end = pit_dump(rt, buf, sizeof(buf) - 1, f, true);
- buf[end] = 0;
- pit_error(rt, "attempted to apply non-function value: %s", buf);
- return PIT_NIL;
- }
- }
-}
generated by cgit v1.3.1 (git 2.54.0) at 2026-09-02 00:56:27 +0000