renamed builtins to procedures

7 files changed, 67 insertions, 67 deletions

diff --git a/lisp.c b/lisp.c
index 1c80a74..8b9f3ad 100644
--- a/lisp.c
+++ b/lisp.c
@@ -55,10 +55,10 @@ value *make_lambda(env *e, value *params, value *body) {
 	return l;
 }
 
-value *make_builtin(value *(*fn) (env *, value *)){
+value *make_procedure(value *(*fn) (env *, value *)){
 	value *val = malloc(sizeof(value));
-	val->type = VT_BUILTIN;
-	val->as.builtin.fn = fn;
+	val->type = VT_PROCEDURE;
+	val->as.procedure.fn = fn;
 	return val;
 }
 
@@ -155,8 +155,8 @@ void print_value(value *val){
 			printf(")");
 			break;
 
-		case VT_BUILTIN:
-			printf("<builtin>\n");
+		case VT_PROCEDURE:
+			printf("<procedure>\n");
 			break;
 		default:
 			printf("<unknown>\n");
@@ -280,8 +280,8 @@ value *eval_pair(env *e, value *v) {
 	}
 
 	value *head_eval = eval(e, head);
-	if (head_eval->type == VT_BUILTIN) {
-		return head_eval->as.builtin.fn(e, tail);
+	if (head_eval->type == VT_PROCEDURE) {
+		return head_eval->as.procedure.fn(e, tail);
 	}
 
 	if (head_eval->type == VT_LAMBDA) {
@@ -334,24 +334,24 @@ value *apply(value *lval, value *args) {
 	return make_lambda(sub_env, params, lval->as.lambda.body);
 }
 
-value *builtin_cons(env *e, value *args) {
+value *procedure_cons(env *e, value *args) {
 	value *v = eval(e, car(args));
 	return cons(v, eval(e, car(cdr(args))));
 }
 
-value *builtin_car(env *e, value *args) {
+value *procedure_car(env *e, value *args) {
 	return car(eval(e, car(args)));
 }
 
-value *builtin_cdr(env *e, value *args) {
+value *procedure_cdr(env *e, value *args) {
 	return cdr(eval(e, car(args)));
 }
 
-value *builtin_reverse(env *e, value *args) {
+value *procedure_reverse(env *e, value *args) {
 	return reverse(eval(e, car(args)));
 }
 
-value *builtin_isnull(env *e, value *args) {
+value *procedure_isnull(env *e, value *args) {
 	value *v = eval(e, car(args));
 	if(v->type == VT_NIL) {
 		return make_int(1);
@@ -376,14 +376,14 @@ int value_eq(value *a, value *b) {
 			return value_eq(car(a), car(b)) &&
 				value_eq(cdr(a), cdr(b));
 		case VT_LAMBDA:
-		case VT_BUILTIN:
+		case VT_PROCEDURE:
 		default:
 			return 0;
 	}
 	return 1;
 }
 
-value *builtin_equal(env *e, value *args) {
+value *procedure_equal(env *e, value *args) {
 	value *v_prev = eval(e, car(args));
 
 	args = cdr(args);
@@ -434,26 +434,26 @@ value *apply_to_nums(env *e, value *args, double (*fn)(double, double)) {
 }
 
 double add_fn(double x, double y) { return x+y; }
-value *builtin_add(env *e, value *args) {
+value *procedure_add(env *e, value *args) {
 	return apply_to_nums(e, args, add_fn);
 }
 
 double sub_fn(double x, double y) { return x-y; }
-value *builtin_sub(env *e, value *args) {
+value *procedure_sub(env *e, value *args) {
 	return apply_to_nums(e, args, sub_fn);
 }
 
 double mul_fn(double x, double y) { return x*y; }
-value *builtin_mul(env *e, value *args) {
+value *procedure_mul(env *e, value *args) {
 	return apply_to_nums(e, args, mul_fn);
 }
 
 double div_fn(double x, double y) { return x/y; }
-value *builtin_div(env *e, value *args) {
+value *procedure_div(env *e, value *args) {
 	return apply_to_nums(e, args, div_fn);
 }
 
-value *builtin_lt(env *e, value *args) {
+value *procedure_lt(env *e, value *args) {
 	double prev_num;
 	value *v = eval(e, car(args));
 
@@ -489,7 +489,7 @@ value *builtin_lt(env *e, value *args) {
 	return make_int(1);
 }
 
-value *builtin_load_module(env *e, value *args) {
+value *procedure_load_module(env *e, value *args) {
 	value *fst_arg = eval(e, car(args));
 
 	if (fst_arg->type != VT_STRING) {
diff --git a/lisp.h b/lisp.h
index df5835e..7d435ff 100644
--- a/lisp.h
+++ b/lisp.h
@@ -26,18 +26,18 @@ value *eval_pair(env *e, value *val);
 
 value *apply(value *lambda, value *args);
 
-value *builtin_cons(env *e, value *args);
-value *builtin_car(env *e, value *args);
-value *builtin_cdr(env *e, value *args);
-value *builtin_reverse(env *e, value *args);
-value *builtin_isnull(env *e, value *args);
-value *builtin_equal(env *e, value *args);
-value *builtin_add(env *e, value *args);
-value *builtin_sub(env *e, value *args);
-value *builtin_mul(env *e, value *args);
-value *builtin_div(env *e, value *args);
-value *builtin_lt(env *e, value *args);
-value *builtin_load_module(env *e, value *args);
+value *procedure_cons(env *e, value *args);
+value *procedure_car(env *e, value *args);
+value *procedure_cdr(env *e, value *args);
+value *procedure_reverse(env *e, value *args);
+value *procedure_isnull(env *e, value *args);
+value *procedure_equal(env *e, value *args);
+value *procedure_add(env *e, value *args);
+value *procedure_sub(env *e, value *args);
+value *procedure_mul(env *e, value *args);
+value *procedure_div(env *e, value *args);
+value *procedure_lt(env *e, value *args);
+value *procedure_load_module(env *e, value *args);
 
 int is_integer(double x);
 
diff --git a/lisp/meta_cirular_eval.lisp b/lisp/meta_cirular_eval.lisp
index 60b7bf8..d58bcdd 100644
--- a/lisp/meta_cirular_eval.lisp
+++ b/lisp/meta_cirular_eval.lisp
@@ -54,7 +54,7 @@
 ; apply
 (define (apply proc args)
   (cond
-    ((procedure? proc) (apply proc args)) ; builtin
+    ((procedure? proc) (apply proc args)) ; procedure
     ((and (pair? proc) (eq? (car proc) 'closure))
      (let ((params (cadr proc))
            (body (caddr proc))
diff --git a/lisp_api.h b/lisp_api.h
index 6361031..bb4bf6f 100644
--- a/lisp_api.h
+++ b/lisp_api.h
@@ -12,7 +12,7 @@ typedef enum {
 	VT_NIL,
 	VT_PAIR,
 	VT_LAMBDA,
-	VT_BUILTIN
+	VT_PROCEDURE
 } val_type;
 
 struct value {
@@ -33,7 +33,7 @@ struct value {
 		} lambda;
 		struct {
 			value *(*fn) (env *, value *);
-		} builtin;
+		} procedure;
 	} as;
 };
 
@@ -43,7 +43,7 @@ value *make_symbol(const char *sym);
 value *make_string(const char *str);
 value *make_nil();
 value *make_lambda(env *e, value *params, value *body);
-value *make_builtin(value *(*fn) (env *, value *));
+value *make_procedure(value *(*fn) (env *, value *));
 value *cons(value *car, value *cdr);
 value *car(value *cons);
 value *cdr(value *cons);
diff --git a/main.c b/main.c
index 5a8043b..86aa69d 100644
--- a/main.c
+++ b/main.c
@@ -94,19 +94,19 @@ void init_readline() {
 int main(int argc, char **argv) {
 	// init global env
 	global_env = env_create(NULL);
-	env_define(global_env, "cons", make_builtin(builtin_cons));
-	env_define(global_env, "car", make_builtin(builtin_car));
-	env_define(global_env, "cdr", make_builtin(builtin_cdr));
-	env_define(global_env, "reverse", make_builtin(builtin_reverse));
-	env_define(global_env, "null?", make_builtin(builtin_isnull));
-	env_define(global_env, "equal?", make_builtin(builtin_equal));
-	env_define(global_env, "+", make_builtin(builtin_add));
-	env_define(global_env, "-", make_builtin(builtin_sub));
-	env_define(global_env, "*", make_builtin(builtin_mul));
-	env_define(global_env, "/", make_builtin(builtin_div));
-	env_define(global_env, "<", make_builtin(builtin_lt));
-
-	env_define(global_env, "load_module", make_builtin(builtin_load_module));
+	env_define(global_env, "cons", make_procedure(procedure_cons));
+	env_define(global_env, "car", make_procedure(procedure_car));
+	env_define(global_env, "cdr", make_procedure(procedure_cdr));
+	env_define(global_env, "reverse", make_procedure(procedure_reverse));
+	env_define(global_env, "null?", make_procedure(procedure_isnull));
+	env_define(global_env, "equal?", make_procedure(procedure_equal));
+	env_define(global_env, "+", make_procedure(procedure_add));
+	env_define(global_env, "-", make_procedure(procedure_sub));
+	env_define(global_env, "*", make_procedure(procedure_mul));
+	env_define(global_env, "/", make_procedure(procedure_div));
+	env_define(global_env, "<", make_procedure(procedure_lt));
+
+	env_define(global_env, "load_module", make_procedure(procedure_load_module));
 
 	// evaluate files
 	for(int i = 1; i < argc; i++) {
diff --git a/modules/test_module.c b/modules/test_module.c
index ead7b91..f43a6d1 100644
--- a/modules/test_module.c
+++ b/modules/test_module.c
@@ -10,7 +10,7 @@ module_export *module_init() {
 	static module_export exports[2];
 
 	exports[0].name = "hello";
-	exports[0].v    = make_builtin(&hello_fun);
+	exports[0].v    = make_procedure(&hello_fun);
 
 	exports[1].name = NULL;
 	exports[1].v    = NULL;
diff --git a/test.c b/test.c
index 5bc1ff4..4360bef 100644
--- a/test.c
+++ b/test.c
@@ -120,7 +120,7 @@ void test_lambda_add() {
 	env *e = env_create(NULL);
 
 	// install +
-	env_define(e, "+", make_builtin(builtin_add));
+	env_define(e, "+", make_procedure(procedure_add));
 
 	value *expr =
 		cons(
@@ -148,7 +148,7 @@ void test_lambda_add() {
 
 void test_lambda_multiple_args() {
 	env *e = env_create(NULL);
-	env_define(e, "+", make_builtin(builtin_add));
+	env_define(e, "+", make_procedure(procedure_add));
 
 	value *expr =
 		cons(
@@ -184,7 +184,7 @@ void test_lambda_closure() {
 	//((lambda (y) (+ x y)) 5)
 
 	env *e = env_create(NULL);
-	env_define(e, "+", make_builtin(builtin_add));
+	env_define(e, "+", make_procedure(procedure_add));
 	env_define(e, "x", make_int(10));
 
 	value *expr =
@@ -213,7 +213,7 @@ void test_lambda_closure() {
 void test_nested_lambdas() {
 	// (((lambda (x) (lambda (y) (+ x y))) 3) 4)
 	env *e = env_create(NULL);
-	env_define(e, "+", make_builtin(builtin_add));
+	env_define(e, "+", make_procedure(procedure_add));
 
 	value *expr =
 		cons(
@@ -274,10 +274,10 @@ void test_lambda_does_not_modify_outer_env() {
 void test_recursive_factorial() {
 	env *e = env_create(NULL);
 
-	env_define(e, "+", make_builtin(builtin_add));
-	env_define(e, "-", make_builtin(builtin_sub));
-	env_define(e, "*", make_builtin(builtin_mul));
-	env_define(e, "<", make_builtin(builtin_lt));
+	env_define(e, "+", make_procedure(procedure_add));
+	env_define(e, "-", make_procedure(procedure_sub));
+	env_define(e, "*", make_procedure(procedure_mul));
+	env_define(e, "<", make_procedure(procedure_lt));
 
 	/*
 	(define fact
@@ -349,7 +349,7 @@ void test_recursive_factorial() {
 
 void test_eq_ints() {
 	env *e = env_create(NULL);
-	env_define(e, "eq", make_builtin(builtin_equal));
+	env_define(e, "eq", make_procedure(procedure_equal));
 
 	value *expr =
 		cons(make_symbol("eq"),
@@ -366,7 +366,7 @@ void test_eq_ints() {
 
 void test_eq_ints_false() {
 	env *e = env_create(NULL);
-	env_define(e, "eq", make_builtin(builtin_equal));
+	env_define(e, "eq", make_procedure(procedure_equal));
 
 	value *expr =
 		cons(make_symbol("eq"),
@@ -381,7 +381,7 @@ void test_eq_ints_false() {
 
 void test_eq_symbols() {
 	env *e = env_create(NULL);
-	env_define(e, "eq", make_builtin(builtin_equal));
+	env_define(e, "eq", make_procedure(procedure_equal));
 
 	value *expr =
 		cons(make_symbol("eq"),
@@ -396,7 +396,7 @@ void test_eq_symbols() {
 
 void test_eq_lists() {
 	env *e = env_create(NULL);
-	env_define(e, "eq", make_builtin(builtin_equal));
+	env_define(e, "eq", make_procedure(procedure_equal));
 
 	value *list1 =
 		cons(make_int(1),
@@ -421,7 +421,7 @@ void test_eq_lists() {
 
 void test_null_true() {
 	env *e = env_create(NULL);
-	env_define(e, "null?", make_builtin(builtin_isnull));
+	env_define(e, "null?", make_procedure(procedure_isnull));
 
 	value *expr =
 		cons(make_symbol("null?"),
@@ -434,7 +434,7 @@ void test_null_true() {
 
 void test_null_false() {
 	env *e = env_create(NULL);
-	env_define(e, "null?", make_builtin(builtin_isnull));
+	env_define(e, "null?", make_procedure(procedure_isnull));
 
 	value *expr =
 		cons(make_symbol("null?"),
@@ -450,7 +450,7 @@ void test_null_false() {
 
 void test_if_true() {
 	env *e = env_create(NULL);
-	env_define(e, "<", make_builtin(builtin_lt));
+	env_define(e, "<", make_procedure(procedure_lt));
 
 	value *expr =
 		cons(make_symbol("if"),
@@ -503,7 +503,7 @@ void test_if_short_circuit() {
 
 void test_add_multiple_args() {
 	env *e = env_create(NULL);
-	env_define(e, "+", make_builtin(builtin_add));
+	env_define(e, "+", make_procedure(procedure_add));
 
 	value *expr =
 		cons(make_symbol("+"),
@@ -520,7 +520,7 @@ void test_add_multiple_args() {
 
 void test_lt_chain() {
 	env *e = env_create(NULL);
-	env_define(e, "<", make_builtin(builtin_lt));
+	env_define(e, "<", make_procedure(procedure_lt));
 
 	value *expr =
 		cons(make_symbol("<"),