From: Elijah Cohen <eli@eli173.com>
Date: Mon, 12 Aug 2024 05:52:02 +0000 (-0500)
Subject: made dubious changes to eval structure
X-Git-Url: https://git.eli173.com/?a=commitdiff_plain;h=3bb0ec5e0017c3c24bd70234a1e55e98568a0ff2;p=klapaucius

made dubious changes to eval structure
---

diff --git a/ideas.org b/ideas.org
index c8b9514..9690f46 100644
--- a/ideas.org
+++ b/ideas.org
@@ -1,3 +1,9 @@
+
+so i'm redoing the basic eval to not pass an arg, but pass the rest of the list... yeah?
+then the builtins just harvest the rest one at a time to get all their args,
+and when executed can modify the rest? cool sounds good and worthwhile
+
+
 GARBAGE COLLECTION
 my grand design is that I will allocate and deallocate all the time, that is, if I 'def' something I keep it, but dereferencing something clones the thing, and then any call using it frees it again.
 is that too slow? yeah probably
diff --git a/src/builtins.c b/src/builtins.c
index f7a5761..90cf1c1 100644
--- a/src/builtins.c
+++ b/src/builtins.c
@@ -14,13 +14,13 @@
 #include <stdio.h>
 
 
-Sexpr* dispatch(Sexpr* b, Sexpr* env) {
+Sexpr* dispatch(Sexpr* b, Sexpr* rest, Sexpr* env) {
 	uint64_t prefix = (b->value.b.opcode) >> 8;
 	switch(prefix) {
 	case CORE_PREFIX:
-		return x_core_dispatch(b, env);
+		return x_core_dispatch(b, rest, env);
 	case ARITH_PREFIX:
-		return x_arith_dispatch(b, env);
+		return x_arith_dispatch(b, rest, env);
 	default:
 		return from_nil();
 	}
diff --git a/src/builtins.h b/src/builtins.h
index 51b1aab..c20e829 100644
--- a/src/builtins.h
+++ b/src/builtins.h
@@ -5,7 +5,7 @@
 
 #include "builtins/core.h"
 
-Sexpr* dispatch(Sexpr* b, Sexpr* env);
+Sexpr* dispatch(Sexpr* b, Sexpr* rest, Sexpr* env);
 uint64_t u64_get_num_args(Sexpr* b);
 Sexpr* load_env(Sexpr* env);
 
diff --git a/src/builtins/arithmetic.c b/src/builtins/arithmetic.c
index c612272..8a04be5 100644
--- a/src/builtins/arithmetic.c
+++ b/src/builtins/arithmetic.c
@@ -10,22 +10,22 @@
 #include <stdlib.h>
 
 
-Sexpr* a_plus(Sexpr* b, Sexpr* env) {
+Sexpr* a_plus(Sexpr* b, Sexpr* rest, Sexpr* env) {
 	if(ARITH_PLUS_ARGS != u64_get_num_args(b)) {
-		return b;
+		return cons(b, rest);
 	}
 	Sexpr* args = b->value.b.args;
 	uint64_t m = eval(car(args), env)->value.u;
 	uint64_t n = eval(car(cdr(args)), env)->value.u;
-	return from_uint(m + n);
+	return cons(from_uint(m + n), rest);
 }
 
-Sexpr* x_arith_dispatch(Sexpr* b, Sexpr* env) {
+Sexpr* x_arith_dispatch(Sexpr* b, Sexpr* rest, Sexpr* env) {
 	uint64_t code = b->value.b.opcode & 0xff;
 
 	switch(code) {
 	case ARITH_PLUS:
-		return a_plus(b, env);
+		return a_plus(b, rest, env);
 	default:
 		return from_nil();
 	}
diff --git a/src/builtins/arithmetic.h b/src/builtins/arithmetic.h
index 6c3fa8f..bbfa4f0 100644
--- a/src/builtins/arithmetic.h
+++ b/src/builtins/arithmetic.h
@@ -9,7 +9,7 @@
 #define ARITH_PLUS 0x00
 #define ARITH_PLUS_ARGS 2
 
-Sexpr* x_arith_dispatch(Sexpr* s, Sexpr* env);
+Sexpr* x_arith_dispatch(Sexpr* s, Sexpr* rest, Sexpr* env);
 Sexpr* load_arith_env(Sexpr* env);
 
 #endif
diff --git a/src/builtins/core.c b/src/builtins/core.c
index 244ba49..99eb17c 100644
--- a/src/builtins/core.c
+++ b/src/builtins/core.c
@@ -12,126 +12,126 @@
 
 #include <stdio.h>
 
-Sexpr* c_quote(Sexpr* b, Sexpr* env) {
+Sexpr* c_quote(Sexpr* b, Sexpr* rest, Sexpr* env) {
 	if(CORE_QUOTE_ARGS != u64_get_num_args(b))
-		return b;
+		return cons(b, rest);
 	//return car(b->value.b.args);
-	return from_quote(car(b->value.b.args));
+	return cons(from_quote(car(b->value.b.args)), rest);
 }
 
 // redo the rest of these...
-Sexpr* c_cons(Sexpr* b, Sexpr* env) {
+Sexpr* c_cons(Sexpr* b, Sexpr* rest, Sexpr* env) {
 	if(CORE_CONS_ARGS != u64_get_num_args(b))
-		return b;
+		return cons(b, rest);
 	Sexpr* args = b->value.b.args;
 	Sexpr* _cdr = eval(car(args), env);
 	Sexpr* _car = eval(car(cdr(args)), env);
-	return cons(_car, _cdr);
+	return cons(cons(_car, _cdr), rest);
 }
-Sexpr* c_car(Sexpr* b, Sexpr* env) {
+Sexpr* c_car(Sexpr* b, Sexpr* rest, Sexpr* env) {
 	if(CORE_CAR_ARGS != u64_get_num_args(b))
-		return b;
+		return cons(b, rest);
 	Sexpr* args = b->value.b.args;
-	return car(eval(car(args), env));
+	// huh okay, can i ditch the eval now that i'm doing the 'rest' thing?
+	return cons(car(eval(car(args), env)), rest);
 }
-Sexpr* c_cdr(Sexpr* b, Sexpr* env) {
+Sexpr* c_cdr(Sexpr* b, Sexpr* rest, Sexpr* env) {
 	if(CORE_CDR_ARGS != u64_get_num_args(b))
-		return b;
+		return cons(b, rest);
 	Sexpr* args = b->value.b.args;
-	return cdr(eval(car(args), env));
+	// see above
+	return cons(cdr(eval(car(args), env)), rest);
 }
-Sexpr* c_if(Sexpr* b, Sexpr* env) {
+Sexpr* c_if(Sexpr* b, Sexpr* rest, Sexpr* env) {
 	if(CORE_IF_ARGS != u64_get_num_args(b))
-		return b;
+		return cons(b, rest);
 	Sexpr* args = b->value.b.args;
 	
 	Sexpr* falsy = car(args);
 	Sexpr* truthy = car(cdr(args));
 	Sexpr* cond = car(cdr(cdr(args)));
 	if(eval(cond, env)->type != NIL)
-		return truthy;
+		return cons(truthy, rest);
 	else
-		return falsy;
-	// uhhh am I sure about this one?
-	// the lack of evals is perhaps a little suspect...
+		return cons(falsy, rest);
 }
-Sexpr* c_eq(Sexpr* b, Sexpr* env) {
+Sexpr* c_eq(Sexpr* b, Sexpr* rest, Sexpr* env) {
 	if(CORE_EQ_ARGS != u64_get_num_args(b))
-		return b;
+		return cons(b, rest);
 	Sexpr* args = b->value.b.args;
 	// yeah eval is kinda necessary for this one I'd say
 	Sexpr* lh = eval(car(args), env);
 	Sexpr* rh = eval(car(cdr(args)), env);
 	if(equal(lh, rh)->type == T)
-		return from_t();
-	return from_nil();
+		return cons(from_t(), rest);
+	return cons(from_nil(), rest);
 }
-Sexpr* c_not(Sexpr* b, Sexpr* env) {
-		if(CORE_NOT_ARGS != u64_get_num_args(b))
-		return b;
+Sexpr* c_not(Sexpr* b, Sexpr* rest, Sexpr* env) {
+	if(CORE_NOT_ARGS != u64_get_num_args(b))
+		return cons(b, rest);
 	Sexpr* args = b->value.b.args;
 	// I guess I would need the eval to check if eventually is nil
 	if(eval(car(args), env)->type == NIL)
-		return from_t();
-	return from_nil();
+		return cons(from_t(), rest);
+	return cons(from_nil(), rest);
 }
-Sexpr* c_atom(Sexpr* b, Sexpr* env) {
+Sexpr* c_atom(Sexpr* b, Sexpr* rest, Sexpr* env) {
 	if(CORE_ATOM_ARGS != u64_get_num_args(b))
-		return b;
+		return cons(b, rest);
 	Sexpr* args = b->value.b.args;
 	Sexpr* argeval = eval(car(args), env);
 	while(argeval->type == QUOTE) {
 		argeval = argeval->value.q;
 	}
 	if(argeval->type != CONS) {
-		return from_t();
+		return cons(from_t(), rest);
 	}
-	return from_nil();
+	return cons(from_nil(), rest);
 }
 
 
-Sexpr* c_def(Sexpr* b, Sexpr* env) {
+Sexpr* c_def(Sexpr* b, Sexpr* rest, Sexpr* env) {
 	if(CORE_DEF_ARGS != u64_get_num_args(b))
-		return b;
+		return cons(b, rest);
 	Sexpr* args = b->value.b.args;
 	Sexpr* val = eval(car(args), env);
 	Sexpr* key = car(cdr(args));
 	append_to_dict(env, key, val);
-	return val;
+	return cons(val, rest);
 }
-Sexpr* c_exit(Sexpr* b, Sexpr* env) {
+Sexpr* c_exit(Sexpr* b, Sexpr* rest, Sexpr* env) {
 	if(CORE_EXIT_ARGS != u64_get_num_args(b))
-		return b;
+		return cons(b, rest);
 	Sexpr* args = b->value.b.args;
 	uint64_t value = car(args)->value.u;
 	exit(value);
 	return NULL;
 }
 
-Sexpr* x_core_dispatch(Sexpr* b, Sexpr* env) {
+Sexpr* x_core_dispatch(Sexpr* b, Sexpr* rest, Sexpr* env) {
 	uint64_t code = b->value.b.opcode & 0xff;
 
 	switch(code) {
 	case CORE_QUOTE:
-		return c_quote(b, env);
+		return c_quote(b, rest, env);
 	case CORE_CONS:
-		return c_cons(b, env);
+		return c_cons(b, rest, env);
 	case CORE_CAR:
-		return c_car(b, env);
+		return c_car(b, rest, env);
 	case CORE_CDR:
-		return c_cdr(b, env);
+		return c_cdr(b, rest, env);
 	case CORE_IF:
-		return c_if(b, env);
+		return c_if(b, rest, env);
 	case CORE_EQ:
-		return c_eq(b, env);
+		return c_eq(b, rest, env);
 	case CORE_NOT:
-		return c_not(b, env);
+		return c_not(b, rest, env);
 	case CORE_ATOM:
-		return c_atom(b, env);
+		return c_atom(b, rest, env);
 	case CORE_DEF:
-		return c_def(b, env);
+		return c_def(b, rest, env);
 	case CORE_EXIT:
-		return c_exit(b, env);
+		return c_exit(b, rest, env);
 	default:
 		return from_nil();
 	}
diff --git a/src/builtins/core.h b/src/builtins/core.h
index c85342e..72cb421 100644
--- a/src/builtins/core.h
+++ b/src/builtins/core.h
@@ -30,7 +30,7 @@
 #define CORE_EXIT 0xff
 #define CORE_EXIT_ARGS 1
 
-Sexpr* x_core_dispatch(Sexpr* s, Sexpr* env);
+Sexpr* x_core_dispatch(Sexpr* s, Sexpr* rest, Sexpr* env);
 Sexpr* load_core_env(Sexpr* env);
 
 #endif
diff --git a/src/dict.c b/src/dict.c
index 92c088d..c28498e 100644
--- a/src/dict.c
+++ b/src/dict.c
@@ -23,7 +23,8 @@ Sexpr* init_dict() {
 Sexpr* append_to_dict(Sexpr* dict, Sexpr* key, Sexpr* value) {
 	// assumes dict well-formed, returns new dict
 	// puts new things on the front of the dict, makes it so looking up gets the newest stuff first
-	Sexpr* new = cons(key, value);
+	Sexpr* new = cons(key, clone(value));
+	// not yet sure if the above 'clone' is needed, or where the call should take place
 	Sexpr* head = cons(new, car(dict));
 	dict->value.c->car = head;
 	//return cons(new, dict);
@@ -36,7 +37,8 @@ Sexpr* lookup(Sexpr* dict, Sexpr* key) {
 	Sexpr* node = car(dict);
 		while(node->type != NIL) {
 			if(equal(key, car(car(node)))->type == T) {
-				return cons(cdr(car(node)), from_nil());
+				Sexpr* value = clone(cdr(car(node)));
+				return cons(value, from_nil());
 			}
 			node = cdr(node);
 	}
diff --git a/src/eval.c b/src/eval.c
index 031fb25..cb99014 100644
--- a/src/eval.c
+++ b/src/eval.c
@@ -10,7 +10,7 @@
 Sexpr* apply_builtin(Sexpr* func, Sexpr* arg, Sexpr* env);
 
 Sexpr* eval(Sexpr* s, Sexpr* dict) {
-	//printf("s: %s\n", sprint_sexpr(s));
+	printf("s: %s\n", sprint_sexpr(s));
 	// non-null s
 	// generally assumes that a sexpr passed to this is well-formed (ie no inapt NULLS)
 	// question: does a completed builtin get evaluated here?
@@ -29,23 +29,25 @@ Sexpr* eval(Sexpr* s, Sexpr* dict) {
 	} // from now on: type is cons
 	Sexpr* curr = s;
 	while(curr->type == CONS) {
-		if(cdr(curr)->type == NIL)
+		if(cdr(curr)->type == NIL) // this is okay to keep, yeah
 			return eval(car(curr), dict);
 		if(cdr(curr)->type != CONS)
 			// need to redo, how do i eval "(f . x)" ?
 			// ^ easy, just return (f . x)
 			return curr;
 		// now i need to apply actually
-		Sexpr* arg = car(cdr(curr));
+		//Sexpr* arg = car(cdr(curr));
+		Sexpr* rest = cdr(curr);
 		Sexpr* func = eval(car(curr), dict);
-		Sexpr* newcar = apply_builtin(func, arg, dict);
-		Sexpr* newcdr = cdr(cdr(curr));
-		curr = cons(newcar, newcdr);
+		//Sexpr* newcar = apply_builtin(func, arg, dict);
+		//Sexpr* newcdr = cdr(cdr(curr));
+		curr = apply_builtin(func, rest, dict); // is this ok?
+		//curr = cons(newcar, newcdr);
 	}
 	return curr;
 }
 
-Sexpr* apply_builtin(Sexpr* func, Sexpr* arg, Sexpr* env) {
+Sexpr* apply_builtin(Sexpr* func, Sexpr* rest, Sexpr* env) {
 	if(func->type != BUILTIN) {
 		printf("uh oh\n");
 		return from_nil(); // uhh this /should/ actually be impossible...
@@ -53,8 +55,8 @@ Sexpr* apply_builtin(Sexpr* func, Sexpr* arg, Sexpr* env) {
 	Sexpr* ret = malloc(sizeof(Sexpr));
 	ret->type = BUILTIN;
 	ret->value.b.opcode = func->value.b.opcode;
-	ret->value.b.args = cons(arg, func->value.b.args);
+	ret->value.b.args = cons(car(rest), func->value.b.args);
 	
-	return dispatch(ret, env);
+	return dispatch(ret, cdr(rest), env);
 	// applies if correct no of args, just returns self otherwise
 }
diff --git a/src/eval.h b/src/eval.h
index db625cc..358df08 100644
--- a/src/eval.h
+++ b/src/eval.h
@@ -10,7 +10,7 @@
 // key type is string, value type is sexpr, hash range is uint64_t
 
 Sexpr* eval(Sexpr* s, Sexpr* env);
-Sexpr* apply_builtin(Sexpr* func, Sexpr* arg, Sexpr* env);
+Sexpr* apply_builtin(Sexpr* func, Sexpr* rest, Sexpr* env);