From 9b5692da9d44813bdee03f80854d6d687841bf19 Mon Sep 17 00:00:00 2001 From: FelixBrendel Date: Thu, 27 Dec 2018 16:29:20 +0100 Subject: [PATCH] Lexical scoping is working, but `defun` broke because of that. Need macros next --- bin/pre.slime | 383 +++++++++++++++++++++++----------------------- bin/test.slime | 29 +++- src/ast.cpp | 5 +- src/built_ins.cpp | 45 +++++- src/env.cpp | 144 ++++++++--------- src/eval.cpp | 5 +- src/main.cpp | 4 +- 7 files changed, 325 insertions(+), 290 deletions(-) diff --git a/bin/pre.slime b/bin/pre.slime index e04e0f2..8a1c7f7 100644 --- a/bin/pre.slime +++ b/bin/pre.slime @@ -1,196 +1,197 @@ (define defmacro (macro (@name @params :rest @body) "Macro for creating macros with a more concise syntax." - (eval (pair 'define (pair @name (pair (pair 'macro (pair @params @body)) nil)))))) + (eval (pair 'define-upwards (pair @name (pair (pair 'macro (pair @params @body)) nil)))))) -(defmacro defun (@name @params :rest @body) +(define defun + (macro (@name @params :rest @body) "Macro for creating functions with a more concise syntax." - (eval (pair 'define (pair @name (pair (pair 'lambda (pair @params @body)) nil))))) - -(defun nil? (x) - "Checks if the argument is nil." - (= x nil)) - -(defun number? (x) - "Checks if the argument is a number." - (= (type x) :number)) - -(defun symbol? (x) - "Checks if the argument is a symbol." - (= (type x) :symbol)) - -(defun keyword? (x) - "Checks if the argument is a keyword." - (= (type x) :keyword)) - -(defun pair? (x) - "Checks if the argument is a pair." - (= (type x) :pair)) - -(defun string? (x) - "Checks if the argument is a string." - (= (type x) :string)) - -(defun dynamic-function? (x) - "Checks if the argument is a function." - (= (type x) :dynamic-function)) - -(defun dynamic-macro? (x) - "Checks if the argument is a macro." - (= (type x) :dynamic-macro)) - -(defun built-in-function? (x) - "Checks if the argument is a built-in function." - (= (type x) :built-in-function)) - -(defun apply (fun seq) - "Applies the funciton to the sequence, as in calls the funciton with -ithe sequence as arguemens." - (eval (pair fun seq))) - -(defmacro when (@test :rest @body) - "Executes the code in :rest if test is true." - (if (eval @test) - (eval (pair prog @body)) - nil)) - -(defmacro unless (@test :rest @body) - "Executes the code in :rest if test is false." - (if (eval @test) - nil - (eval (pair prog @body)))) - -(defun end (seq) - "Returns the last pair in the sqeuence." - (if (or (nil? seq) (not (pair? (rest seq)))) - seq - (end (rest seq)))) - -(defun last (seq) - "Returns the (first) of the last (pair) of the given sequence." - (first (end seq))) - -(defun extend (seq elem) - "Extends a list with the given element, by putting it in -the (rest) of the last element of the sequence." - (when (pair? seq) - (define e (end seq)) - (mutate e (pair (first e) elem))) - seq) - -(defun incr (val) - "Adds one to the argument." - (+ val 1)) - -(defun decr (val) - "Subtracts one from the argument." - (- val 1)) - -(defun append (seq elem) - "Appends an element to a sequence, by extendeing the list -with (pair elem nil)." - (extend seq (pair elem nil))) - -(defun length (seq) - "Returns the length of the given sequence." - (if (nil? seq) - 0 - (incr (length (rest seq))))) - -(defmacro n-times (@times @action) - "Executes @action @times times." - (unless (<= (eval @times) 0) - (eval @action) - (apply n-times (list (list - @times 1) @action)))) - -(defmacro for (@symbol @from @to :rest @for-body) - "Designed to resemble a C style for loop. It takes a symbol as -well as its starting number and end number and executes the -@for-body with the defined symbol for all numbers between @from -to @to, where @to is exclusive." - (if (< (eval @from) (eval @to)) - (macro-define @op incr) - (if (> (eval @from) (eval @to)) - (macro-define @op decr) - (macro-define @op nil))) - (when @op - (macro-define (eval @symbol) (eval @from)) - (eval (pair prog @for-body)) - (eval (extend (list for @symbol (@op @from) @to) @for-body)))) - -(defun range (:keys from :defaults-to 0 to) - "Returns a sequence of numbers starting with the number defined -by the key 'from' and ends with the number defined in 'to'." - (when (< from to) - (pair from (range :from (+ 1 from) :to to)))) - -(defun range-while (:keys from :defaults-to 0 to) - "Returns a sequence of numbers starting with the number defined -by the key 'from' and ends with the number defined in 'to'." - (define result (list (copy from))) - (define head result) - (mutate from (incr from)) - (while (< from to) - (prog - (mutate head (pair (first head) (pair (copy from) nil))) - (define head (rest head)) - (mutate from (incr from)))) - result) - -(defun map (fun seq) - "Takes a function and a sequence as arguments and returns a new -sequence which contains the results of using the first sequences -elemens as argument to that function." - (if (nil? seq) - seq - (pair (fun (first seq)) - (map fun (rest seq))))) - -(defun reduce (fun seq) - "Takes a function and a sequence as arguments and applies the -function to the argument sequence. This only works correctly if -the given function accepts a variable amount of parameters. If -your funciton is limited to two arguments, use `reduce-binary' -instead." - (apply fun seq)) - -(defun reduce-binary (fun seq) - "Takes a function and a sequence as arguments and applies the -function to the argument sequence. reduce-binary applies the -arguments `pair-wise' which means it works with binary functions -as compared to `reduce'." - (if (nil? (rest seq)) - (first seq) - (fun (first seq) - (reduce-binary fun (rest seq))))) - -(defun filter (fun seq) - "Takes a function and a sequence as arguments and applies the -function to every value in the sequence. If the result of that -funciton application returns a truthy value, the original value is -added to a list, which in the end is returned." - (when seq - (if (fun (first seq)) - (pair (first seq) - (filter fun (rest seq))) - (filter fun (rest seq))))) - -(defun printf (:keys sep :defaults-to " " end :defaults-to "\n" :rest args) - "A wrapper for the built-in (print) that accepts a variable number -of arguments and also provides keywords for specifying the printed -separators between the arguments and what should be printed after the -las argument." - (defmacro printf-quoted (:keys @sep @end :rest @args) - (if (nil? @args) - (prog (print (eval @end)) nil) - (prog - (print (first @args)) - (unless (nil? (rest @args)) - (print (eval @sep))) - (eval (pair printf-quoted - (extend (list :@sep (eval @sep) :@end (eval @end)) (rest @args))))))) - - (eval (pair printf-quoted (extend (list :@sep (eval sep) :@end (eval end)) args)))) - -(defmacro pe (@expr) - (printf @expr "evaluates to" (eval @expr))) + (eval (pair 'define-upwards (pair @name (pair (pair 'lambda (pair @params @body)) nil)))))) + +;; (defun nil? (x) +;; "Checks if the argument is nil." +;; (= x nil)) + +;; (defun number? (x) +;; "Checks if the argument is a number." +;; (= (type x) :number)) + +;; (defun symbol? (x) +;; "Checks if the argument is a symbol." +;; (= (type x) :symbol)) + +;; (defun keyword? (x) +;; "Checks if the argument is a keyword." +;; (= (type x) :keyword)) + +;; (defun pair? (x) +;; "Checks if the argument is a pair." +;; (= (type x) :pair)) + +;; (defun string? (x) +;; "Checks if the argument is a string." +;; (= (type x) :string)) + +;; (defun dynamic-function? (x) +;; "Checks if the argument is a function." +;; (= (type x) :dynamic-function)) + +;; (defun dynamic-macro? (x) +;; "Checks if the argument is a macro." +;; (= (type x) :dynamic-macro)) + +;; (defun built-in-function? (x) +;; "Checks if the argument is a built-in function." +;; (= (type x) :built-in-function)) + +;; (defun apply (fun seq) +;; "Applies the funciton to the sequence, as in calls the function +;; with ithe sequence as arguemens." +;; (eval (pair fun seq))) + +;; (defmacro when (@test :rest @body) +;; "Executes the code in :rest if test is true." +;; (if (eval @test) +;; (eval (pair prog @body)) +;; nil)) + +;; (defmacro unless (@test :rest @body) +;; "Executes the code in :rest if test is false." +;; (if (eval @test) +;; nil +;; (eval (pair prog @body)))) + +;; (defun end (seq) +;; "Returns the last pair in the sqeuence." +;; (if (or (nil? seq) (not (pair? (rest seq)))) +;; seq +;; (end (rest seq)))) + +;; (defun last (seq) +;; "Returns the (first) of the last (pair) of the given sequence." +;; (first (end seq))) + +;; (defun extend (seq elem) +;; "Extends a list with the given element, by putting it in +;; the (rest) of the last element of the sequence." +;; (when (pair? seq) +;; (define e (end seq)) +;; (mutate e (pair (first e) elem))) +;; seq) + +;; (defun incr (val) +;; "Adds one to the argument." +;; (+ val 1)) + +;; (defun decr (val) +;; "Subtracts one from the argument." +;; (- val 1)) + +;; (defun append (seq elem) +;; "Appends an element to a sequence, by extendeing the list +;; with (pair elem nil)." +;; (extend seq (pair elem nil))) + +;; (defun length (seq) +;; "Returns the length of the given sequence." +;; (if (nil? seq) +;; 0 +;; (incr (length (rest seq))))) + +;; (defmacro n-times (@times @action) +;; "Executes @action @times times." +;; (unless (<= (eval @times) 0) +;; (eval @action) +;; (apply n-times (list (list - @times 1) @action)))) + +;; (defmacro for (@symbol @from @to :rest @for-body) +;; "Designed to resemble a C style for loop. It takes a symbol as +;; well as its starting number and end number and executes the +;; @for-body with the defined symbol for all numbers between @from +;; to @to, where @to is exclusive." +;; (if (< (eval @from) (eval @to)) +;; (macro-define @op incr) +;; (if (> (eval @from) (eval @to)) +;; (macro-define @op decr) +;; (macro-define @op nil))) +;; (when @op +;; (macro-define (eval @symbol) (eval @from)) +;; (eval (pair prog @for-body)) +;; (eval (extend (list for @symbol (@op @from) @to) @for-body)))) + +;; (defun range (:keys from :defaults-to 0 to) +;; "Returns a sequence of numbers starting with the number defined +;; by the key 'from' and ends with the number defined in 'to'." +;; (when (< from to) +;; (pair from (range :from (+ 1 from) :to to)))) + +;; (defun range-while (:keys from :defaults-to 0 to) +;; "Returns a sequence of numbers starting with the number defined +;; by the key 'from' and ends with the number defined in 'to'." +;; (define result (list (copy from))) +;; (define head result) +;; (mutate from (incr from)) +;; (while (< from to) +;; (prog +;; (mutate head (pair (first head) (pair (copy from) nil))) +;; (define head (rest head)) +;; (mutate from (incr from)))) +;; result) + +;; (defun map (fun seq) +;; "Takes a function and a sequence as arguments and returns a new +;; sequence which contains the results of using the first sequences +;; elemens as argument to that function." +;; (if (nil? seq) +;; seq +;; (pair (fun (first seq)) +;; (map fun (rest seq))))) + +;; (defun reduce (fun seq) +;; "Takes a function and a sequence as arguments and applies the +;; function to the argument sequence. This only works correctly if +;; the given function accepts a variable amount of parameters. If +;; your funciton is limited to two arguments, use `reduce-binary' +;; instead." +;; (apply fun seq)) + +;; (defun reduce-binary (fun seq) +;; "Takes a function and a sequence as arguments and applies the +;; function to the argument sequence. reduce-binary applies the +;; arguments `pair-wise' which means it works with binary functions +;; as compared to `reduce'." +;; (if (nil? (rest seq)) +;; (first seq) +;; (fun (first seq) +;; (reduce-binary fun (rest seq))))) + +;; (defun filter (fun seq) +;; "Takes a function and a sequence as arguments and applies the +;; function to every value in the sequence. If the result of that +;; funciton application returns a truthy value, the original value is +;; added to a list, which in the end is returned." +;; (when seq +;; (if (fun (first seq)) +;; (pair (first seq) +;; (filter fun (rest seq))) +;; (filter fun (rest seq))))) + +;; (defun printf (:keys sep :defaults-to " " end :defaults-to "\n" :rest args) +;; "A wrapper for the built-in (print) that accepts a variable number +;; of arguments and also provides keywords for specifying the printed +;; separators between the arguments and what should be printed after the +;; las argument." +;; (defmacro printf-quoted (:keys @sep @end :rest @args) +;; (if (nil? @args) +;; (prog (print (eval @end)) nil) +;; (prog +;; (print (first @args)) +;; (unless (nil? (rest @args)) +;; (print (eval @sep))) +;; (eval (pair printf-quoted +;; (extend (list :@sep (eval @sep) :@end (eval @end)) (rest @args))))))) + +;; (eval (pair printf-quoted (extend (list :@sep (eval sep) :@end (eval end)) args)))) + +;; (defmacro pe (@expr) +;; (printf @expr "evaluates to" (eval @expr))) diff --git a/bin/test.slime b/bin/test.slime index 63b72ba..e06d6bc 100644 --- a/bin/test.slime +++ b/bin/test.slime @@ -1,12 +1,29 @@ (defun make-vector (x y z) - (let ((local-x x) - (local-y y) - (local-z z)) - (lambda () - local-x))) + (let ((local-x x) + (local-y y) + (local-z z) + (defun (macro (@name @params :rest @body) + (eval (pair 'define-upwards (pair @name (pair (pair 'lambda (pair @params @body)) nil))))))) + + (defun set-x (new-x) (mutate local-x new-x)) + (defun set-y (new-y) (mutate local-y new-y)) + (defun set-z (new-z) (mutate local-z new-z)) + + (defun dispatch (message) + (if (= message ::get-x) + local-x + (if (= message ::set-x) + set-x + nil))) + + (break) + dispatch)) (define v (make-vector 1 2 3)) -(print (v)) + +(print (v ::get-x)) +((v ::set-x) 19) +(print (v ::get-x)) (read " ") diff --git a/src/ast.cpp b/src/ast.cpp index 14193cc..0b5b71e 100644 --- a/src/ast.cpp +++ b/src/ast.cpp @@ -109,6 +109,7 @@ void append_to_keyword_argument_list(Keyword_Arguments* args, append_to_Ast_Node_array_list(args->values, default_value); } +struct Environment; struct Function { bool is_macro; @@ -117,10 +118,10 @@ struct Function { Keyword_Arguments* keyword_arguments; // rest_argument will be nullptr if no rest argument is declared char* rest_argument; - struct Ast_Node* body; // implicit prog + Ast_Node* body; // implicit prog + Environment* parent_environment; // we are doing closures now!! }; -struct Environment; struct CFunction { std::function function; diff --git a/src/built_ins.cpp b/src/built_ins.cpp index eaf26f1..9055631 100644 --- a/src/built_ins.cpp +++ b/src/built_ins.cpp @@ -324,7 +324,7 @@ void load_built_ins_into_environment(Environment* env) { return value; }); - defun("macro-define", cLambda { + defun("define-upwards", cLambda { try { arguments_length = list_length(arguments); } @@ -345,15 +345,50 @@ void load_built_ins_into_environment(Environment* env) { report_error(Error_Type::Type_Missmatch); } + if (!env->parent) { + report_error(Error_Type::Unknown_Error); + } + + Ast_Node* value = arguments->value.pair->rest->value.pair->first; try { value = eval_expr(value, env); } - define_macro_symbol(symbol, value, env); + define_symbol(symbol, value, env->parent); return value; }); + // defun("macro-define", cLambda { + // try { + // arguments_length = list_length(arguments); + // } + + // if (arguments_length != 2) { + // report_error(Error_Type::Wrong_Number_Of_Arguments); + // } + + // Ast_Node* symbol = arguments->value.pair->first; + + // if (symbol->type == Ast_Node_Type::Pair) { + // try { + // symbol = eval_expr(symbol, env); + // } + // } + + // if (symbol->type != Ast_Node_Type::Symbol) { + // report_error(Error_Type::Type_Missmatch); + // } + + // Ast_Node* value = arguments->value.pair->rest->value.pair->first; + // try { + // value = eval_expr(value, env); + // } + + // define_macro_symbol(symbol, value, env); + + // return value; + // }); defun("mutate", cLambda { try { evaluated_arguments = eval_arguments(arguments, env, &arguments_length); @@ -500,7 +535,7 @@ void load_built_ins_into_environment(Environment* env) { if (arguments_length < 1) report_error(Error_Type::Wrong_Number_Of_Arguments); - Environment* let_env = create_child_environment(env, Environment_Type::Let); + Environment* let_env = create_child_environment(env); Ast_Node* bindings = arguments->value.pair->first; while (true) { if (bindings->type == Ast_Node_Type::Nil) { @@ -564,6 +599,7 @@ void load_built_ins_into_environment(Environment* env) { /* if (lispOperator->value.built_in_function->type == Built_In_Macro) { */ /* function->is_macro = true; */ /* } else { */ + function->parent_environment = env; function->is_macro = false; /* } */ @@ -614,6 +650,7 @@ void load_built_ins_into_environment(Environment* env) { report_error(Error_Type::Wrong_Number_Of_Arguments); Function* function = new(Function); + function->parent_environment = env; function->is_macro = true; // if parameters were specified @@ -962,7 +999,7 @@ void load_built_ins_into_environment(Environment* env) { } Environment* create_built_ins_environment() { - Environment* ret = create_child_environment(nullptr, Environment_Type::Let); + Environment* ret = create_child_environment(nullptr); load_built_ins_into_environment(ret); return ret; } diff --git a/src/env.cpp b/src/env.cpp index 21d1229..4988eed 100644 --- a/src/env.cpp +++ b/src/env.cpp @@ -1,12 +1,5 @@ -enum struct Environment_Type { - Let, - Lambda, - Macro, -}; - struct Environment { struct Environment* parent; - Environment_Type type; int capacity; int next_index; @@ -15,12 +8,11 @@ struct Environment { Ast_Node** values; }; -Environment* create_child_environment(Environment* parent, Environment_Type type) { +Environment* create_child_environment(Environment* parent) { Environment* env = new(Environment); int start_capacity = 16; - env->type = type; env->parent = parent; env->capacity = start_capacity; env->next_index = 0; @@ -30,19 +22,19 @@ Environment* create_child_environment(Environment* parent, Environment_Type type return env; } -Environment* create_empty_environment(Environment_Type type) { - return create_child_environment(nullptr, type); +Environment* create_empty_environment() { + return create_child_environment(nullptr); } void define_symbol(Ast_Node* symbol, Ast_Node* value, Environment* env) { - if (env->type == Environment_Type::Macro) { - // NOTE(Felix): we know we have a parent because every - // environment has a parent except the top level environment. - // However the top level environment is not a let-environment, - // so we would not land here - define_symbol(symbol, value, env->parent); - return; - } + // if (env->type == Environment_Type::Macro) { + // // NOTE(Felix): we know we have a parent because every + // // environment has a parent except the top level environment. + // // However the top level environment is not a let-environment, + // // so we would not land here + // define_symbol(symbol, value, env->parent); + // return; + // } // NOTE(Felix): right now we are simply adding the symol at the // back of the list without checking if it already exists but are @@ -60,16 +52,16 @@ void define_symbol(Ast_Node* symbol, Ast_Node* value, Environment* env) { ++env->next_index; } -void define_macro_symbol(Ast_Node* symbol, Ast_Node* value, Environment* env) { - if (env->type != Environment_Type::Macro) { - create_error(Error_Type::Unknown_Error, symbol->sourceCodeLocation); - return; - } +// void define_macro_symbol(Ast_Node* symbol, Ast_Node* value, Environment* env) { +// if (env->type != Environment_Type::Macro) { +// create_error(Error_Type::Unknown_Error, symbol->sourceCodeLocation); +// return; +// } - env->type = Environment_Type::Lambda; - define_symbol(symbol, value, env); - env->type = Environment_Type::Macro; -} +// env->type = Environment_Type::Lambda; +// define_symbol(symbol, value, env); +// env->type = Environment_Type::Macro; +// } void print_environment(Environment* env); @@ -80,41 +72,41 @@ Ast_Node* lookup_symbol_in_this_envt(Symbol* sym, Environment* env) { return nullptr; } -Ast_Node* lookup_symbol_from_lambda_env(Symbol* sym, Environment* env) { - Ast_Node* result; - do { - if (env->type != Environment_Type::Lambda) { - result = lookup_symbol_in_this_envt(sym, env); - if (result) return result; - } - env = env->parent; - } while (env); - return nullptr; -} - -Ast_Node* lookup_symbol_from_let_or_macro_env(Symbol* sym, Environment* env) { - Ast_Node* result; - do { - result = lookup_symbol_in_this_envt(sym, env); - if (result) return result; - if (env->type == Environment_Type::Lambda) - break; - - env = env->parent; - } while (env); - - if (env) { - do { - if (env->type != Environment_Type::Lambda) { - result = lookup_symbol_in_this_envt(sym, env); - if (result) return result; - } - env = env->parent; - } while (env); - } - - return nullptr; -} +// Ast_Node* lookup_symbol_from_lambda_env(Symbol* sym, Environment* env) { +// Ast_Node* result; +// do { +// if (env->type != Environment_Type::Lambda) { +// result = lookup_symbol_in_this_envt(sym, env); +// if (result) return result; +// } +// env = env->parent; +// } while (env); +// return nullptr; +// } + +// Ast_Node* lookup_symbol_from_let_or_macro_env(Symbol* sym, Environment* env) { +// Ast_Node* result; +// do { +// result = lookup_symbol_in_this_envt(sym, env); +// if (result) return result; +// if (env->type == Environment_Type::Lambda) +// break; + +// env = env->parent; +// } while (env); + +// if (env) { +// do { +// if (env->type != Environment_Type::Lambda) { +// result = lookup_symbol_in_this_envt(sym, env); +// if (result) return result; +// } +// env = env->parent; +// } while (env); +// } + +// return nullptr; +// } Ast_Node* lookup_symbol(Ast_Node* node, Environment* env) { // first check current environment @@ -125,11 +117,7 @@ Ast_Node* lookup_symbol(Ast_Node* node, Environment* env) { return result; if (env->parent) { - if (env->type == Environment_Type::Lambda) { - result = lookup_symbol_from_lambda_env(sym, env->parent); - } else { - result = lookup_symbol_from_let_or_macro_env(sym, env->parent); - } + result = lookup_symbol(node, env->parent); if (result) return result; @@ -142,14 +130,6 @@ Ast_Node* lookup_symbol(Ast_Node* node, Environment* env) { return create_ast_node_t(); } - // we should not need this anymore when we have c lambdas as built - // in functions - - /* result = create_ast_node_built_in_function(sym->identifier); */ - /* result->sourceCodeLocation = node->sourceCodeLocation; */ - /* if (result) */ - /* return result; */ - create_error(Error_Type::Symbol_Not_Defined, node->sourceCodeLocation); /* printf("%s\n", sym->identifier); */ return nullptr; @@ -170,12 +150,12 @@ void print_environment_indent(Environment* env, int indent) { if (env->parent) { print_indent(indent); printf("parent"); - if (env->parent->type == Environment_Type::Lambda) - printf(" (lambda)"); - else if (env->parent->type == Environment_Type::Macro) - printf(" (macro)"); - else if (env->parent->type == Environment_Type::Let) - printf(" (let)"); + // if (env->parent->type == Environment_Type::Lambda) + // printf(" (lambda)"); + // else if (env->parent->type == Environment_Type::Macro) + // printf(" (macro)"); + // else if (env->parent->type == Environment_Type::Let) + // printf(" (let)"); printf(":\n"); print_environment_indent(env->parent, indent+4); } diff --git a/src/eval.cpp b/src/eval.cpp index b5b153c..5767981 100644 --- a/src/eval.cpp +++ b/src/eval.cpp @@ -6,7 +6,8 @@ Ast_Node* apply_arguments_to_function(Ast_Node* arguments, Function* function, E // switching between "define_symbol" and "define_macro_symbol" all // the time - Environment* new_env = create_child_environment(parent, Environment_Type::Lambda); + // Environment* new_env = create_child_environment(parent, Environment_Type::Lambda); + Environment* new_env = create_child_environment(function->parent_environment); // positional arguments for (int i = 0; i < function->positional_arguments->next_index; ++i) { @@ -145,8 +146,6 @@ Ast_Node* apply_arguments_to_function(Ast_Node* arguments, Function* function, E // don't have to check every time if it is macro environment or // not - if (function->is_macro) - new_env->type = Environment_Type::Macro; try { result = eval_expr(function->body, new_env); diff --git a/src/main.cpp b/src/main.cpp index 5ca17b5..f8d387e 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -30,7 +30,7 @@ Ast_Node* interprete_file (char* file_name) { program = parse_program(file_name, file_content); } - Environment* env = create_empty_environment(Environment_Type::Let); + Environment* env = create_empty_environment(); load_built_ins_into_environment(env); try { @@ -50,7 +50,7 @@ Ast_Node* interprete_file (char* file_name) { int interprete_stdin () { printf("Welcome to the lispy interpreter.\n"); char* line; - Environment* env = create_empty_environment(Environment_Type::Let); + Environment* env = create_empty_environment(); load_built_ins_into_environment(env); built_in_load("pre.slime", env);