From 34b7390ba95ebaceea6dddca5b76f8bd59699a89 Mon Sep 17 00:00:00 2001 From: FelixBrendel Date: Thu, 27 Dec 2018 15:01:29 +0100 Subject: [PATCH] converted all typedefs to c++ types and enums to enum structs --- src/assert.cpp | 4 +- src/ast.cpp | 101 ++++++++++--------- src/built_ins.cpp | 240 +++++++++++++++++++++++----------------------- src/env.cpp | 38 ++++---- src/error.cpp | 62 ++++++------ src/eval.cpp | 138 +++++++++++++------------- src/helpers.cpp | 13 +-- src/io.cpp | 60 ++++++------ src/main.cpp | 6 +- src/parse.cpp | 12 +-- src/testing.cpp | 84 ++++++++-------- 11 files changed, 373 insertions(+), 385 deletions(-) diff --git a/src/assert.cpp b/src/assert.cpp index 0eac73c..085ea3a 100644 --- a/src/assert.cpp +++ b/src/assert.cpp @@ -1,6 +1,6 @@ void assert_type (Ast_Node* node, Ast_Node_Type type) { if (!node) - create_error(Error_Type_Unknown_Error, nullptr); + create_error(Error_Type::Unknown_Error, nullptr); if (node->type == type) return; - create_error(Error_Type_Type_Missmatch, node->sourceCodeLocation); + create_error(Error_Type::Type_Missmatch, node->sourceCodeLocation); } diff --git a/src/ast.cpp b/src/ast.cpp index 1a8999e..14193cc 100644 --- a/src/ast.cpp +++ b/src/ast.cpp @@ -1,73 +1,71 @@ struct Ast_Node; define_array_list(struct Ast_Node*, Ast_Node); -typedef enum { - Ast_Node_Type_Nil, - Ast_Node_Type_T, - - Ast_Node_Type_Symbol, - Ast_Node_Type_Keyword, - Ast_Node_Type_Number, - Ast_Node_Type_String, - - Ast_Node_Type_Pair, - Ast_Node_Type_Function, - Ast_Node_Type_CFunction, -} Ast_Node_Type; +enum struct Ast_Node_Type { + Nil, + T, + Symbol, + Keyword, + Number, + String, + Pair, + Function, + CFunction, +}; char* Ast_Node_Type_to_string(Ast_Node_Type type) { switch (type) { - case(Ast_Node_Type_Nil): return "nil"; - case(Ast_Node_Type_T): return "t"; - case(Ast_Node_Type_Number): return "number"; - case(Ast_Node_Type_String): return "string"; - case(Ast_Node_Type_Symbol): return "symbol"; - case(Ast_Node_Type_Keyword): return "keyword"; - case(Ast_Node_Type_Function): return "function"; - case(Ast_Node_Type_CFunction): return "C-function"; - case(Ast_Node_Type_Pair): return "pair"; + case(Ast_Node_Type::Nil): return "nil"; + case(Ast_Node_Type::T): return "t"; + case(Ast_Node_Type::Number): return "number"; + case(Ast_Node_Type::String): return "string"; + case(Ast_Node_Type::Symbol): return "symbol"; + case(Ast_Node_Type::Keyword): return "keyword"; + case(Ast_Node_Type::Function): return "function"; + case(Ast_Node_Type::CFunction): return "C-function"; + case(Ast_Node_Type::Pair): return "pair"; } return "unknown"; } -typedef struct { +struct Symbol { char* identifier; -} Symbol; +}; -typedef struct { +struct Keyword { char* identifier; -} Keyword; +}; -typedef struct { +struct Number { double value; -} Number; +}; -typedef struct { +struct String { char* value; int length; -} String; +}; -typedef struct { +struct Pair { struct Ast_Node* first; struct Ast_Node* rest; -} Pair; +}; -typedef struct { +struct Positional_Arguments { // TODO(Felix) use Ast_Node_symbols here instead, so we don't have // to convert them to strings and back to symbols char** identifiers; int next_index; int length; -} Positional_Arguments; +}; -typedef struct { +struct Keyword_Arguments { char** identifiers; // values[i] will be nullptr if no defalut value was declared for // key identifiers[i] Ast_Node_Array_List* values; int next_index; int length; -} Keyword_Arguments; +}; /* Ast_Node_Array_List* create_Ast_Node_Array_List(int initial_length); */ @@ -112,7 +110,7 @@ void append_to_keyword_argument_list(Keyword_Arguments* args, } -typedef struct { +struct Function { bool is_macro; char* docstring; Positional_Arguments* positional_arguments; @@ -120,12 +118,13 @@ typedef struct { // rest_argument will be nullptr if no rest argument is declared char* rest_argument; struct Ast_Node* body; // implicit prog -} Function; +}; struct Environment; -typedef struct { + +struct CFunction { std::function function; -} CFunction; +}; struct Ast_Node { Source_Code_Location* sourceCodeLocation; @@ -140,16 +139,14 @@ struct Ast_Node { CFunction* cfunction; } value; }; -// was forward declarated -typedef struct Ast_Node Ast_Node; -typedef struct { +struct Parsed_Arguments { Ast_Node_Array_List* positional_arguments; // TODO(Felix): Really use hashmap (keyword[sting] -> // value[Ast_Node*]) here Ast_Node_Array_List* keyword_keys; Ast_Node_Array_List* keyword_values; -} Parsed_Arguments; +}; Ast_Node* create_ast_node() { Ast_Node* node = new(Ast_Node); @@ -159,21 +156,21 @@ Ast_Node* create_ast_node() { Ast_Node* create_ast_node_nil() { Ast_Node* node = create_ast_node(); - node->type = Ast_Node_Type_Nil; + node->type = Ast_Node_Type::Nil; node->value.pair = nullptr; return node; } Ast_Node* create_ast_node_t() { Ast_Node* node = create_ast_node(); - node->type = Ast_Node_Type_T; + node->type = Ast_Node_Type::T; node->value.pair = nullptr; return node; } Ast_Node* create_ast_node_number(double number) { Ast_Node* node = create_ast_node(); - node->type = Ast_Node_Type_Number; + node->type = Ast_Node_Type::Number; node->value.number = new(Number); node->value.number->value = number; return node; @@ -181,7 +178,7 @@ Ast_Node* create_ast_node_number(double number) { Ast_Node* create_ast_node_string(char* str, int length) { Ast_Node* node = create_ast_node(); - node->type = Ast_Node_Type_String; + node->type = Ast_Node_Type::String; node->value.string = new(String); node->value.string->value = str; node->value.string->length = length; @@ -190,7 +187,7 @@ Ast_Node* create_ast_node_string(char* str, int length) { Ast_Node* create_ast_node_symbol(char* identifier) { Ast_Node* node = create_ast_node(); - node->type = Ast_Node_Type_Symbol; + node->type = Ast_Node_Type::Symbol; node->value.symbol = new(Symbol); node->value.symbol->identifier = identifier; return node; @@ -198,7 +195,7 @@ Ast_Node* create_ast_node_symbol(char* identifier) { Ast_Node* create_ast_node_keyword(char* keyword) { Ast_Node* node = create_ast_node(); - node->type = Ast_Node_Type_Keyword; + node->type = Ast_Node_Type::Keyword; node->value.keyword = new(Keyword); node->value.keyword->identifier = keyword; return node; @@ -206,7 +203,7 @@ Ast_Node* create_ast_node_keyword(char* keyword) { Ast_Node* create_ast_node_cfunction(std::function function) { Ast_Node* node = create_ast_node(); - node->type = Ast_Node_Type_CFunction; + node->type = Ast_Node_Type::CFunction; node->value.cfunction = new(CFunction); node->value.cfunction->function = function; return node; @@ -214,7 +211,7 @@ Ast_Node* create_ast_node_cfunction(std::functiontype = Ast_Node_Type_Pair; + node->type = Ast_Node_Type::Pair; node->value.pair = new(Pair); node->value.pair->first = first; node->value.pair->rest = rest; diff --git a/src/built_ins.cpp b/src/built_ins.cpp index 7ce0289..eaf26f1 100644 --- a/src/built_ins.cpp +++ b/src/built_ins.cpp @@ -11,34 +11,34 @@ bool ast_node_equal(Ast_Node* n1, Ast_Node* n2) { return false; switch (n1->type) { - case Ast_Node_Type_CFunction: + case Ast_Node_Type::CFunction: // TODO(Felix): make comparing work again. return false; /* return n1->value.built_in_function->type */ /* == n2->value.built_in_function->type; */ - case Ast_Node_Type_Function: + case Ast_Node_Type::Function: // if they have the same pointer, true is // returned a few lines above return false; - case Ast_Node_Type_Keyword: + case Ast_Node_Type::Keyword: return string_equal( n1->value.keyword->identifier, n2->value.keyword->identifier); - case Ast_Node_Type_T: - case Ast_Node_Type_Nil: + case Ast_Node_Type::T: + case Ast_Node_Type::Nil: return true; - case Ast_Node_Type_Number: + case Ast_Node_Type::Number: return n1->value.number->value == n2->value.number->value; - case Ast_Node_Type_Pair: - create_error(Error_Type_Not_Yet_Implemented, n1->sourceCodeLocation); + case Ast_Node_Type::Pair: + create_error(Error_Type::Not_Yet_Implemented, n1->sourceCodeLocation); return false; - case Ast_Node_Type_String: + case Ast_Node_Type::String: return string_equal( n1->value.string->value, n2->value.string->value); - case Ast_Node_Type_Symbol: + case Ast_Node_Type::Symbol: return string_equal( n1->value.symbol->identifier, n2->value.symbol->identifier); @@ -54,12 +54,12 @@ Ast_Node* built_in_equals(Ast_Node* arguments, Environment* env) { arguments = eval_arguments(arguments, env, &arguments_length); } - if (arguments->type == Ast_Node_Type_Nil) + if (arguments->type == Ast_Node_Type::Nil) return create_ast_node_t(); Ast_Node* first = arguments->value.pair->first; - while (arguments->type == Ast_Node_Type_Pair) { + while (arguments->type == Ast_Node_Type::Pair) { if (!ast_node_equal(arguments->value.pair->first, first)) return create_ast_node_nil(); arguments = arguments->value.pair->rest; @@ -76,9 +76,9 @@ Ast_Node* built_in_greater(Ast_Node* arguments, Environment* env) { double last_number = strtod("Inf", NULL); - while (arguments->type == Ast_Node_Type_Pair) { + while (arguments->type == Ast_Node_Type::Pair) { try { - assert_type(arguments->value.pair->first, Ast_Node_Type_Number); + assert_type(arguments->value.pair->first, Ast_Node_Type::Number); } if (arguments->value.pair->first->value.number->value >= last_number) @@ -99,9 +99,9 @@ Ast_Node* built_in_greater_equal(Ast_Node* arguments, Environment* env) { double last_number = strtod("Inf", NULL); - while (arguments->type == Ast_Node_Type_Pair) { + while (arguments->type == Ast_Node_Type::Pair) { try { - assert_type(arguments->value.pair->first, Ast_Node_Type_Number); + assert_type(arguments->value.pair->first, Ast_Node_Type::Number); } if (arguments->value.pair->first->value.number->value > last_number) @@ -122,9 +122,9 @@ Ast_Node* built_in_less(Ast_Node* arguments, Environment* env) { double last_number = strtod("-Inf", NULL); - while (arguments->type == Ast_Node_Type_Pair) { + while (arguments->type == Ast_Node_Type::Pair) { try { - assert_type(arguments->value.pair->first, Ast_Node_Type_Number); + assert_type(arguments->value.pair->first, Ast_Node_Type::Number); } if (arguments->value.pair->first->value.number->value <= last_number) @@ -145,9 +145,9 @@ Ast_Node* built_in_less_equal(Ast_Node* arguments, Environment* env) { double last_number = strtod("-Inf", NULL); - while (arguments->type == Ast_Node_Type_Pair) { + while (arguments->type == Ast_Node_Type::Pair) { try { - assert_type(arguments->value.pair->first, Ast_Node_Type_Number); + assert_type(arguments->value.pair->first, Ast_Node_Type::Number); } if (arguments->value.pair->first->value.number->value < last_number) @@ -167,9 +167,9 @@ Ast_Node* built_in_add(Ast_Node* arguments, Environment* env) { } double sum = 0; - while (arguments->type == Ast_Node_Type_Pair) { + while (arguments->type == Ast_Node_Type::Pair) { try { - assert_type(arguments->value.pair->first, Ast_Node_Type_Number); + assert_type(arguments->value.pair->first, Ast_Node_Type::Number); } sum += arguments->value.pair->first->value.number->value; arguments = arguments->value.pair->rest; @@ -185,14 +185,14 @@ Ast_Node* built_in_substract(Ast_Node* arguments, Environment* env) { } try { - assert_type(arguments->value.pair->first, Ast_Node_Type_Number); + assert_type(arguments->value.pair->first, Ast_Node_Type::Number); } double difference = arguments->value.pair->first->value.number->value; arguments = arguments->value.pair->rest; - while (arguments->type == Ast_Node_Type_Pair) { + while (arguments->type == Ast_Node_Type::Pair) { try { - assert_type(arguments->value.pair->first, Ast_Node_Type_Number); + assert_type(arguments->value.pair->first, Ast_Node_Type::Number); } difference -= arguments->value.pair->first->value.number->value; @@ -208,14 +208,14 @@ Ast_Node* built_in_multiply(Ast_Node* arguments, Environment* env) { } try { - assert_type(arguments->value.pair->first, Ast_Node_Type_Number); + assert_type(arguments->value.pair->first, Ast_Node_Type::Number); } double product = arguments->value.pair->first->value.number->value; arguments = arguments->value.pair->rest; - while (arguments->type == Ast_Node_Type_Pair) { + while (arguments->type == Ast_Node_Type::Pair) { try { - assert_type(arguments->value.pair->first, Ast_Node_Type_Number); + assert_type(arguments->value.pair->first, Ast_Node_Type::Number); } product *= arguments->value.pair->first->value.number->value; @@ -231,14 +231,14 @@ Ast_Node* built_in_divide(Ast_Node* arguments, Environment* env) { } try { - assert_type(arguments->value.pair->first, Ast_Node_Type_Number); + assert_type(arguments->value.pair->first, Ast_Node_Type::Number); } double quotient = arguments->value.pair->first->value.number->value; arguments = arguments->value.pair->rest; - while (arguments->type == Ast_Node_Type_Pair) { + while (arguments->type == Ast_Node_Type::Pair) { try { - assert_type(arguments->value.pair->first, Ast_Node_Type_Number); + assert_type(arguments->value.pair->first, Ast_Node_Type::Number); } quotient /= arguments->value.pair->first->value.number->value; @@ -263,7 +263,7 @@ Ast_Node* built_in_load(char* file_name, Environment* env) { } return result; } else { - create_error(Error_Type_Unknown_Error, nullptr); + create_error(Error_Type::Unknown_Error, nullptr); return nullptr; } } @@ -300,19 +300,19 @@ void load_built_ins_into_environment(Environment* env) { } if (arguments_length != 2) { - report_error(Error_Type_Wrong_Number_Of_Arguments); + report_error(Error_Type::Wrong_Number_Of_Arguments); } Ast_Node* symbol = arguments->value.pair->first; - if (symbol->type == Ast_Node_Type_Pair) { + 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); + if (symbol->type != Ast_Node_Type::Symbol) { + report_error(Error_Type::Type_Missmatch); } Ast_Node* value = arguments->value.pair->rest->value.pair->first; @@ -330,19 +330,19 @@ void load_built_ins_into_environment(Environment* env) { } if (arguments_length != 2) { - report_error(Error_Type_Wrong_Number_Of_Arguments); + report_error(Error_Type::Wrong_Number_Of_Arguments); } Ast_Node* symbol = arguments->value.pair->first; - if (symbol->type == Ast_Node_Type_Pair) { + 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); + if (symbol->type != Ast_Node_Type::Symbol) { + report_error(Error_Type::Type_Missmatch); } Ast_Node* value = arguments->value.pair->rest->value.pair->first; @@ -360,12 +360,12 @@ void load_built_ins_into_environment(Environment* env) { } if (arguments_length != 2) - report_error(Error_Type_Wrong_Number_Of_Arguments); + report_error(Error_Type::Wrong_Number_Of_Arguments); - if (evaluated_arguments->value.pair->first->type == Ast_Node_Type_Nil || - evaluated_arguments->value.pair->first->type == Ast_Node_Type_Keyword) + if (evaluated_arguments->value.pair->first->type == Ast_Node_Type::Nil || + evaluated_arguments->value.pair->first->type == Ast_Node_Type::Keyword) { - report_error(Error_Type_Type_Missmatch); + report_error(Error_Type::Type_Missmatch); } Ast_Node* target = evaluated_arguments->value.pair->first; @@ -380,7 +380,7 @@ void load_built_ins_into_environment(Environment* env) { } if (arguments_length != 2 && arguments_length != 3) { - report_error(Error_Type_Wrong_Number_Of_Arguments); + report_error(Error_Type::Wrong_Number_Of_Arguments); } Ast_Node* condition = arguments->value.pair->first; @@ -411,16 +411,16 @@ void load_built_ins_into_environment(Environment* env) { } if (arguments_length != 1) { - report_error(Error_Type_Wrong_Number_Of_Arguments); + report_error(Error_Type::Wrong_Number_Of_Arguments); } return arguments->value.pair->first; }); defun("and", cLambda { bool result = true; - while (arguments->type != Ast_Node_Type_Nil) { - if (arguments->type != Ast_Node_Type_Pair) { - report_error(Error_Type_Ill_Formed_List); + while (arguments->type != Ast_Node_Type::Nil) { + if (arguments->type != Ast_Node_Type::Pair) { + report_error(Error_Type::Ill_Formed_List); } try { result &= is_truthy(arguments->value.pair->first, env); @@ -434,9 +434,9 @@ void load_built_ins_into_environment(Environment* env) { }); defun("or", cLambda { bool result = false; - while (arguments->type != Ast_Node_Type_Nil) { - if (arguments->type != Ast_Node_Type_Pair) { - report_error(Error_Type_Ill_Formed_List); + while (arguments->type != Ast_Node_Type::Nil) { + if (arguments->type != Ast_Node_Type::Pair) { + report_error(Error_Type::Ill_Formed_List); } try { result |= is_truthy(arguments->value.pair->first, env); @@ -454,7 +454,7 @@ void load_built_ins_into_environment(Environment* env) { } if (arguments_length != 1) { - report_error(Error_Type_Wrong_Number_Of_Arguments); + report_error(Error_Type::Wrong_Number_Of_Arguments); } bool truthy; try { @@ -470,7 +470,7 @@ void load_built_ins_into_environment(Environment* env) { } if (arguments_length < 2) { - report_error(Error_Type_Wrong_Number_Of_Arguments); + report_error(Error_Type::Wrong_Number_Of_Arguments); } Ast_Node* condition_part = arguments->value.pair->first; Ast_Node* condition; @@ -481,7 +481,7 @@ void load_built_ins_into_environment(Environment* env) { try { condition = eval_expr(condition_part, env); } - if (condition->type == Ast_Node_Type_Nil) { + if (condition->type == Ast_Node_Type::Nil) { break; } try { @@ -498,27 +498,27 @@ void load_built_ins_into_environment(Environment* env) { } if (arguments_length < 1) - report_error(Error_Type_Wrong_Number_Of_Arguments); + 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, Environment_Type::Let); Ast_Node* bindings = arguments->value.pair->first; while (true) { - if (bindings->type == Ast_Node_Type_Nil) { + if (bindings->type == Ast_Node_Type::Nil) { break; - } else if (bindings->type != Ast_Node_Type_Pair) { - report_error(Error_Type_Ill_Formed_Arguments); + } else if (bindings->type != Ast_Node_Type::Pair) { + report_error(Error_Type::Ill_Formed_Arguments); } Ast_Node* sym = bindings->value.pair->first->value.pair->first; - if(sym->type != Ast_Node_Type_Symbol) { - report_error(Error_Type_Ill_Formed_Arguments); + if(sym->type != Ast_Node_Type::Symbol) { + report_error(Error_Type::Ill_Formed_Arguments); } Ast_Node* rest_sym = bindings->value.pair->first->value.pair->rest; - if (rest_sym->type != Ast_Node_Type_Pair) { - report_error(Error_Type_Ill_Formed_Arguments); + if (rest_sym->type != Ast_Node_Type::Pair) { + report_error(Error_Type::Ill_Formed_Arguments); } - if (rest_sym->value.pair->rest->type != Ast_Node_Type_Nil) { - report_error(Error_Type_Ill_Formed_Arguments); + if (rest_sym->value.pair->rest->type != Ast_Node_Type::Nil) { + report_error(Error_Type::Ill_Formed_Arguments); } Ast_Node* value = eval_expr(rest_sym->value.pair->first, env); @@ -535,7 +535,7 @@ void load_built_ins_into_environment(Environment* env) { evaluated_arguments = eval_arguments(arguments, let_env, &arguments_length); } - if (evaluated_arguments->type == Ast_Node_Type_Nil) + if (evaluated_arguments->type == Ast_Node_Type::Nil) return evaluated_arguments; // skip to the last evaluated operand and return it, @@ -543,7 +543,7 @@ void load_built_ins_into_environment(Environment* env) { // manually, because we want to increase code reuse, // but at the cost that we have to find the end of the // list again - while (evaluated_arguments->value.pair->rest->type == Ast_Node_Type_Pair) { + while (evaluated_arguments->value.pair->rest->type == Ast_Node_Type::Pair) { evaluated_arguments = evaluated_arguments->value.pair->rest; } return evaluated_arguments->value.pair->first; @@ -558,7 +558,7 @@ void load_built_ins_into_environment(Environment* env) { } if (arguments_length == 0) - report_error(Error_Type_Wrong_Number_Of_Arguments); + report_error(Error_Type::Wrong_Number_Of_Arguments); Function* function = new(Function); /* if (lispOperator->value.built_in_function->type == Built_In_Macro) { */ @@ -568,9 +568,9 @@ void load_built_ins_into_environment(Environment* env) { /* } */ // if parameters were specified - if (arguments->value.pair->first->type != Ast_Node_Type_Nil) { + if (arguments->value.pair->first->type != Ast_Node_Type::Nil) { try { - assert_type(arguments->value.pair->first, Ast_Node_Type_Pair); + assert_type(arguments->value.pair->first, Ast_Node_Type::Pair); } try { parse_argument_list(arguments->value.pair->first, function); @@ -583,7 +583,7 @@ void load_built_ins_into_environment(Environment* env) { arguments = arguments->value.pair->rest; // if there is a docstring, use it - if (arguments->value.pair->first->type == Ast_Node_Type_String) { + if (arguments->value.pair->first->type == Ast_Node_Type::String) { function->docstring = arguments->value.pair->first->value.string->value; arguments = arguments->value.pair->rest; } else { @@ -597,7 +597,7 @@ void load_built_ins_into_environment(Environment* env) { arguments); Ast_Node* ret = new(Ast_Node); - ret->type = Ast_Node_Type_Function; + ret->type = Ast_Node_Type::Function; ret->value.function = function; return ret; }); @@ -611,15 +611,15 @@ void load_built_ins_into_environment(Environment* env) { } if (arguments_length == 0) - report_error(Error_Type_Wrong_Number_Of_Arguments); + report_error(Error_Type::Wrong_Number_Of_Arguments); Function* function = new(Function); function->is_macro = true; // if parameters were specified - if (arguments->value.pair->first->type != Ast_Node_Type_Nil) { + if (arguments->value.pair->first->type != Ast_Node_Type::Nil) { try { - assert_type(arguments->value.pair->first, Ast_Node_Type_Pair); + assert_type(arguments->value.pair->first, Ast_Node_Type::Pair); } try { parse_argument_list(arguments->value.pair->first, function); @@ -632,7 +632,7 @@ void load_built_ins_into_environment(Environment* env) { arguments = arguments->value.pair->rest; // if there is a docstring, use it - if (arguments->value.pair->first->type == Ast_Node_Type_String) { + if (arguments->value.pair->first->type == Ast_Node_Type::String) { function->docstring = arguments->value.pair->first->value.string->value; arguments = arguments->value.pair->rest; } else { @@ -646,7 +646,7 @@ void load_built_ins_into_environment(Environment* env) { arguments); Ast_Node* ret = new(Ast_Node); - ret->type = Ast_Node_Type_Function; + ret->type = Ast_Node_Type::Function; ret->value.function = function; return ret; }); @@ -655,7 +655,7 @@ void load_built_ins_into_environment(Environment* env) { evaluated_arguments = eval_arguments(arguments, env, &arguments_length); } if (arguments_length != 1) { - report_error(Error_Type_Wrong_Number_Of_Arguments); + report_error(Error_Type::Wrong_Number_Of_Arguments); } Ast_Node* result; try { @@ -670,7 +670,7 @@ void load_built_ins_into_environment(Environment* env) { evaluated_arguments = eval_arguments(arguments, env, &arguments_length); } - if (evaluated_arguments->type == Ast_Node_Type_Nil) + if (evaluated_arguments->type == Ast_Node_Type::Nil) return evaluated_arguments; // skip to the last evaluated operand and return it, @@ -678,7 +678,7 @@ void load_built_ins_into_environment(Environment* env) { // manually, because we want to increase code reuse, // but at the cost that we have to find the end of the // list again - while (evaluated_arguments->value.pair->rest->type == Ast_Node_Type_Pair) { + while (evaluated_arguments->value.pair->rest->type == Ast_Node_Type::Pair) { evaluated_arguments = evaluated_arguments->value.pair->rest; } return evaluated_arguments->value.pair->first; @@ -699,7 +699,7 @@ void load_built_ins_into_environment(Environment* env) { // BUG(Felix): Why is arguments_length for '(1 (2)) == 3 and not 2?? /* if (arguments_length != 2) { */ if (list_length(evaluated_arguments) != 2) { - report_error(Error_Type_Wrong_Number_Of_Arguments); + report_error(Error_Type::Wrong_Number_Of_Arguments); } return create_ast_node_pair(evaluated_arguments->value.pair->first, evaluated_arguments->value.pair->rest->value.pair->first); }); @@ -708,12 +708,12 @@ void load_built_ins_into_environment(Environment* env) { evaluated_arguments = eval_arguments(arguments, env, &arguments_length); } if (arguments_length != 1) { - report_error(Error_Type_Wrong_Number_Of_Arguments); + report_error(Error_Type::Wrong_Number_Of_Arguments); } - if (evaluated_arguments->value.pair->first->type == Ast_Node_Type_Nil) + if (evaluated_arguments->value.pair->first->type == Ast_Node_Type::Nil) return create_ast_node_nil(); - if (evaluated_arguments->value.pair->first->type != Ast_Node_Type_Pair) - report_error(Error_Type_Type_Missmatch); + if (evaluated_arguments->value.pair->first->type != Ast_Node_Type::Pair) + report_error(Error_Type::Type_Missmatch); return evaluated_arguments->value.pair->first->value.pair->first; }); @@ -722,12 +722,12 @@ void load_built_ins_into_environment(Environment* env) { evaluated_arguments = eval_arguments(arguments, env, &arguments_length); } if (arguments_length != 1) { - report_error(Error_Type_Wrong_Number_Of_Arguments); + report_error(Error_Type::Wrong_Number_Of_Arguments); } - if (evaluated_arguments->value.pair->first->type == Ast_Node_Type_Nil) + if (evaluated_arguments->value.pair->first->type == Ast_Node_Type::Nil) return create_ast_node_nil(); - if (evaluated_arguments->value.pair->first->type != Ast_Node_Type_Pair) - report_error(Error_Type_Type_Missmatch); + if (evaluated_arguments->value.pair->first->type != Ast_Node_Type::Pair) + report_error(Error_Type::Type_Missmatch); return evaluated_arguments->value.pair->first->value.pair->rest; }); @@ -736,24 +736,24 @@ void load_built_ins_into_environment(Environment* env) { evaluated_arguments = eval_arguments(arguments, env, &arguments_length); } if (arguments_length != 1) { - report_error(Error_Type_Wrong_Number_Of_Arguments); + report_error(Error_Type::Wrong_Number_Of_Arguments); } - Ast_Node_Type type = evaluated_arguments->value.pair->first->type; + Ast_Node_Type type = evaluated_arguments->value.pair->first->type; switch (type) { - case Ast_Node_Type_CFunction: return create_ast_node_keyword("cfunction"); - case Ast_Node_Type_Function: { + case Ast_Node_Type::CFunction: return create_ast_node_keyword("cfunction"); + case Ast_Node_Type::Function: { if (evaluated_arguments->value.pair->first->value.function->is_macro) return create_ast_node_keyword("dynamic-macro"); return create_ast_node_keyword("dynamic-function"); } - case Ast_Node_Type_Keyword: return create_ast_node_keyword("keyword"); - case Ast_Node_Type_Nil: return create_ast_node_keyword("nil"); - case Ast_Node_Type_T: return create_ast_node_keyword("t"); - case Ast_Node_Type_Number: return create_ast_node_keyword("number"); - case Ast_Node_Type_Pair: return create_ast_node_keyword("pair"); - case Ast_Node_Type_String: return create_ast_node_keyword("string"); - case Ast_Node_Type_Symbol: return create_ast_node_keyword("symbol"); + case Ast_Node_Type::Keyword: return create_ast_node_keyword("keyword"); + case Ast_Node_Type::Nil: return create_ast_node_keyword("nil"); + case Ast_Node_Type::T: return create_ast_node_keyword("t"); + case Ast_Node_Type::Number: return create_ast_node_keyword("number"); + case Ast_Node_Type::Pair: return create_ast_node_keyword("pair"); + case Ast_Node_Type::String: return create_ast_node_keyword("string"); + case Ast_Node_Type::Symbol: return create_ast_node_keyword("symbol"); } return create_ast_node_keyword("unknown"); }); @@ -763,7 +763,7 @@ void load_built_ins_into_environment(Environment* env) { } if (arguments_length != 1) { - report_error(Error_Type_Wrong_Number_Of_Arguments); + report_error(Error_Type::Wrong_Number_Of_Arguments); } print(arguments->value.pair->first); @@ -780,7 +780,7 @@ void load_built_ins_into_environment(Environment* env) { printf("\n"); // just make sure type was not redefined and // returns something that is not a keyword - if (type->type == Ast_Node_Type_Keyword && + if (type->type == Ast_Node_Type::Keyword && (string_equal(type->value.keyword->identifier, "dynamic-function") || string_equal(type->value.keyword->identifier, "dynamic-macro"))) { @@ -836,7 +836,7 @@ void load_built_ins_into_environment(Environment* env) { evaluated_arguments = eval_arguments(arguments, env, &arguments_length); } if (arguments_length != 1) { - report_error(Error_Type_Wrong_Number_Of_Arguments); + report_error(Error_Type::Wrong_Number_Of_Arguments); } print(evaluated_arguments->value.pair->first); printf("\n"); @@ -848,12 +848,12 @@ void load_built_ins_into_environment(Environment* env) { } if (arguments_length > 1) { - report_error(Error_Type_Wrong_Number_Of_Arguments); + report_error(Error_Type::Wrong_Number_Of_Arguments); } if (arguments_length == 1) { Ast_Node* prompt = evaluated_arguments->value.pair->first; - /* if (prompt->type == Ast_Node_Type_String) */ + /* if (prompt->type == Ast_Node_Type::String) */ /* printf("%s", prompt->value.string->value); */ /* else */ print(evaluated_arguments->value.pair->first); @@ -867,13 +867,13 @@ void load_built_ins_into_environment(Environment* env) { } if (arguments_length > 1) { - report_error(Error_Type_Wrong_Number_Of_Arguments); + report_error(Error_Type::Wrong_Number_Of_Arguments); } if (arguments_length == 1) { Ast_Node* error_code = evaluated_arguments->value.pair->first; - if (error_code->type != Ast_Node_Type_Number) - report_error(Error_Type_Type_Missmatch); + if (error_code->type != Ast_Node_Type::Number) + report_error(Error_Type::Type_Missmatch); exit((int)error_code->value.number->value); } @@ -892,7 +892,7 @@ void load_built_ins_into_environment(Environment* env) { } if (arguments_length != 2) { - report_error(Error_Type_Wrong_Number_Of_Arguments); + report_error(Error_Type::Wrong_Number_Of_Arguments); } Ast_Node* try_part = arguments->value.pair->first; @@ -914,10 +914,10 @@ void load_built_ins_into_environment(Environment* env) { } if (arguments_length != 1) - report_error(Error_Type_Wrong_Number_Of_Arguments); + report_error(Error_Type::Wrong_Number_Of_Arguments); - if (evaluated_arguments->value.pair->first->type != Ast_Node_Type_String) - report_error(Error_Type_Type_Missmatch); + if (evaluated_arguments->value.pair->first->type != Ast_Node_Type::String) + report_error(Error_Type::Type_Missmatch); Ast_Node* result; try { @@ -933,12 +933,12 @@ void load_built_ins_into_environment(Environment* env) { } if (arguments_length != 1) - report_error(Error_Type_Wrong_Number_Of_Arguments); + report_error(Error_Type::Wrong_Number_Of_Arguments); - if (evaluated_arguments->value.pair->first->type == Ast_Node_Type_Nil || - evaluated_arguments->value.pair->first->type == Ast_Node_Type_Keyword) + if (evaluated_arguments->value.pair->first->type == Ast_Node_Type::Nil || + evaluated_arguments->value.pair->first->type == Ast_Node_Type::Keyword) { - report_error(Error_Type_Type_Missmatch); + report_error(Error_Type::Type_Missmatch); } Ast_Node* target = new(Ast_Node); @@ -952,9 +952,9 @@ void load_built_ins_into_environment(Environment* env) { evaluated_arguments = eval_arguments(arguments, env, &arguments_length); } if (arguments_length != 0) { - report_error(Error_Type_Wrong_Number_Of_Arguments); + report_error(Error_Type::Wrong_Number_Of_Arguments); } - report_error(Error_Type_Unknown_Error); + report_error(Error_Type::Unknown_Error); }); #undef report_error @@ -962,7 +962,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, Environment_Type::Let); load_built_ins_into_environment(ret); return ret; } diff --git a/src/env.cpp b/src/env.cpp index 6fa9962..21d1229 100644 --- a/src/env.cpp +++ b/src/env.cpp @@ -1,8 +1,8 @@ -typedef enum { - Environment_Type_Let, - Environment_Type_Lambda, - Environment_Type_Macro, -} Environment_Type; +enum struct Environment_Type { + Let, + Lambda, + Macro, +}; struct Environment { struct Environment* parent; @@ -15,8 +15,6 @@ struct Environment { Ast_Node** values; }; -typedef struct Environment Environment; - Environment* create_child_environment(Environment* parent, Environment_Type type) { Environment* env = new(Environment); @@ -37,7 +35,7 @@ Environment* create_empty_environment(Environment_Type type) { } void define_symbol(Ast_Node* symbol, Ast_Node* value, Environment* env) { - if (env->type == Environment_Type_Macro) { + 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, @@ -63,14 +61,14 @@ void define_symbol(Ast_Node* symbol, Ast_Node* value, Environment* env) { } 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); + if (env->type != Environment_Type::Macro) { + create_error(Error_Type::Unknown_Error, symbol->sourceCodeLocation); return; } - env->type = Environment_Type_Lambda; + env->type = Environment_Type::Lambda; define_symbol(symbol, value, env); - env->type = Environment_Type_Macro; + env->type = Environment_Type::Macro; } void print_environment(Environment* env); @@ -85,7 +83,7 @@ Ast_Node* lookup_symbol_in_this_envt(Symbol* sym, Environment* env) { Ast_Node* lookup_symbol_from_lambda_env(Symbol* sym, Environment* env) { Ast_Node* result; do { - if (env->type != Environment_Type_Lambda) { + if (env->type != Environment_Type::Lambda) { result = lookup_symbol_in_this_envt(sym, env); if (result) return result; } @@ -99,7 +97,7 @@ Ast_Node* lookup_symbol_from_let_or_macro_env(Symbol* sym, Environment* env) { do { result = lookup_symbol_in_this_envt(sym, env); if (result) return result; - if (env->type == Environment_Type_Lambda) + if (env->type == Environment_Type::Lambda) break; env = env->parent; @@ -107,7 +105,7 @@ Ast_Node* lookup_symbol_from_let_or_macro_env(Symbol* sym, Environment* env) { if (env) { do { - if (env->type != Environment_Type_Lambda) { + if (env->type != Environment_Type::Lambda) { result = lookup_symbol_in_this_envt(sym, env); if (result) return result; } @@ -127,7 +125,7 @@ Ast_Node* lookup_symbol(Ast_Node* node, Environment* env) { return result; if (env->parent) { - if (env->type == Environment_Type_Lambda) { + 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); @@ -152,7 +150,7 @@ Ast_Node* lookup_symbol(Ast_Node* node, Environment* env) { /* if (result) */ /* return result; */ - create_error(Error_Type_Symbol_Not_Defined, node->sourceCodeLocation); + create_error(Error_Type::Symbol_Not_Defined, node->sourceCodeLocation); /* printf("%s\n", sym->identifier); */ return nullptr; } @@ -172,11 +170,11 @@ void print_environment_indent(Environment* env, int indent) { if (env->parent) { print_indent(indent); printf("parent"); - if (env->parent->type == Environment_Type_Lambda) + if (env->parent->type == Environment_Type::Lambda) printf(" (lambda)"); - else if (env->parent->type == Environment_Type_Macro) + else if (env->parent->type == Environment_Type::Macro) printf(" (macro)"); - else if (env->parent->type == Environment_Type_Let) + else if (env->parent->type == Environment_Type::Let) printf(" (let)"); printf(":\n"); print_environment_indent(env->parent, indent+4); diff --git a/src/error.cpp b/src/error.cpp index e4249b1..e692587 100644 --- a/src/error.cpp +++ b/src/error.cpp @@ -1,24 +1,24 @@ -typedef enum { - Error_Type_Ill_Formed_Arguments, - Error_Type_Ill_Formed_Lambda_List, - Error_Type_Ill_Formed_List, - Error_Type_Not_A_Function, - Error_Type_Not_Yet_Implemented, - Error_Type_Symbol_Not_Defined, - Error_Type_Syntax_Error, - Error_Type_Trailing_Garbage, - Error_Type_Type_Missmatch, - Error_Type_Unbalanced_Parenthesis, - Error_Type_Unexpected_Eof, - Error_Type_Unknown_Error, - Error_Type_Unknown_Keyword_Argument, - Error_Type_Wrong_Number_Of_Arguments, -} Error_Type; +enum struct Error_Type { + Ill_Formed_Arguments, + Ill_Formed_Lambda_List, + Ill_Formed_List, + Not_A_Function, + Not_Yet_Implemented, + Symbol_Not_Defined, + Syntax_Error, + Trailing_Garbage, + Type_Missmatch, + Unbalanced_Parenthesis, + Unexpected_Eof, + Unknown_Error, + Unknown_Keyword_Argument, + Wrong_Number_Of_Arguments, +}; -typedef struct Error_t { +struct Error { Error_Type type; Source_Code_Location* location; -} Error; +}; Error* error; @@ -39,19 +39,19 @@ void create_error(Error_Type type, Source_Code_Location* location) { char* Error_Type_to_string(Error_Type type) { switch (type) { - case Error_Type_Ill_Formed_Arguments: return "Evaluation-error: Ill formed arguments"; - case Error_Type_Ill_Formed_Lambda_List: return "Evaluation-error: Ill formed lambda list"; - case Error_Type_Ill_Formed_List: return "Evaluation-error: Ill formed list"; - case Error_Type_Not_A_Function: return "Evaluation-error: Not a function"; - case Error_Type_Not_Yet_Implemented: return "Evaluation-error: Not yet implemented"; - case Error_Type_Symbol_Not_Defined: return "Evaluation-error: Symbol not defined"; - case Error_Type_Syntax_Error: return "Syntax Error"; - case Error_Type_Trailing_Garbage: return "Evaluation-error: Trailing garbage following expression"; - case Error_Type_Type_Missmatch: return "Evaluation-error: Type Missmatch"; - case Error_Type_Unbalanced_Parenthesis: return "Parsing-error: Unbalanced parenthesis"; - case Error_Type_Unexpected_Eof: return "Parsing-error: Unexpected EOF"; - case Error_Type_Unknown_Keyword_Argument: return "Evaluation-error: Unknown keyword argument"; - case Error_Type_Wrong_Number_Of_Arguments: return "Evaluation-error: Wrong number of arguments"; + case Error_Type::Ill_Formed_Arguments: return "Evaluation-error: Ill formed arguments"; + case Error_Type::Ill_Formed_Lambda_List: return "Evaluation-error: Ill formed lambda list"; + case Error_Type::Ill_Formed_List: return "Evaluation-error: Ill formed list"; + case Error_Type::Not_A_Function: return "Evaluation-error: Not a function"; + case Error_Type::Not_Yet_Implemented: return "Evaluation-error: Not yet implemented"; + case Error_Type::Symbol_Not_Defined: return "Evaluation-error: Symbol not defined"; + case Error_Type::Syntax_Error: return "Syntax Error"; + case Error_Type::Trailing_Garbage: return "Evaluation-error: Trailing garbage following expression"; + case Error_Type::Type_Missmatch: return "Evaluation-error: Type Missmatch"; + case Error_Type::Unbalanced_Parenthesis: return "Parsing-error: Unbalanced parenthesis"; + case Error_Type::Unexpected_Eof: return "Parsing-error: Unexpected EOF"; + case Error_Type::Unknown_Keyword_Argument: return "Evaluation-error: Unknown keyword argument"; + case Error_Type::Wrong_Number_Of_Arguments: return "Evaluation-error: Wrong number of arguments"; default: return "Unknown Error"; } } diff --git a/src/eval.cpp b/src/eval.cpp index bbfa142..b5b153c 100644 --- a/src/eval.cpp +++ b/src/eval.cpp @@ -6,11 +6,11 @@ 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); // positional arguments for (int i = 0; i < function->positional_arguments->next_index; ++i) { - if (arguments->type == Ast_Node_Type_Pair) { + if (arguments->type == Ast_Node_Type::Pair) { // TODO(Felix): here we create new ast_node_symbols from // their identifiers but before we converted them to // strings from symbols... Wo maybe just use the symbols? @@ -19,13 +19,13 @@ Ast_Node* apply_arguments_to_function(Ast_Node* arguments, Function* function, E arguments->value.pair->first, new_env); } else { // not enough arguments given - create_error(Error_Type_Ill_Formed_Arguments, arguments->sourceCodeLocation); + create_error(Error_Type::Ill_Formed_Arguments, arguments->sourceCodeLocation); return nullptr; } arguments = arguments->value.pair->rest; } - if (arguments->type == Ast_Node_Type_Nil) + if (arguments->type == Ast_Node_Type::Nil) goto eval_time; String_Array_List* read_in_keywords = create_String_array_list(16); @@ -34,7 +34,7 @@ Ast_Node* apply_arguments_to_function(Ast_Node* arguments, Function* function, E // something that is not a keyword is encountered or a keyword // that is not recognized is encoutered, jump out of the loop. - while (arguments->value.pair->first->type == Ast_Node_Type_Keyword) { + while (arguments->value.pair->first->type == Ast_Node_Type::Keyword) { // check if this one is even an accepted keyword bool accepted = false; for (int i = 0; i < function->keyword_arguments->next_index; ++i) { @@ -47,7 +47,7 @@ Ast_Node* apply_arguments_to_function(Ast_Node* arguments, Function* function, E } } if (!accepted) { - create_error(Error_Type_Ill_Formed_Arguments, arguments->sourceCodeLocation); + create_error(Error_Type::Ill_Formed_Arguments, arguments->sourceCodeLocation); return nullptr; } @@ -61,7 +61,7 @@ Ast_Node* apply_arguments_to_function(Ast_Node* arguments, Function* function, E // necessary keywords then we have to count the rest // as :rest here, instead od always creating an error // (special case with default variables) - create_error(Error_Type_Ill_Formed_Arguments, arguments->sourceCodeLocation); + create_error(Error_Type::Ill_Formed_Arguments, arguments->sourceCodeLocation); return nullptr; } } @@ -69,8 +69,8 @@ Ast_Node* apply_arguments_to_function(Ast_Node* arguments, Function* function, E // okay so we found a keyword that has to be read in and was // not already read in, is there a next element to actually // set it to? - if (arguments->value.pair->rest->type != Ast_Node_Type_Pair) { - create_error(Error_Type_Ill_Formed_Arguments, arguments->sourceCodeLocation); + if (arguments->value.pair->rest->type != Ast_Node_Type::Pair) { + create_error(Error_Type::Ill_Formed_Arguments, arguments->sourceCodeLocation); return nullptr; } @@ -85,7 +85,7 @@ Ast_Node* apply_arguments_to_function(Ast_Node* arguments, Function* function, E // overstep both for next one arguments = arguments->value.pair->rest->value.pair->rest; - if (arguments->type == Ast_Node_Type_Nil) { + if (arguments->type == Ast_Node_Type::Nil) { break; } } @@ -107,7 +107,7 @@ Ast_Node* apply_arguments_to_function(Ast_Node* arguments, Function* function, E if (function->keyword_arguments->values->data[i] == nullptr) { // if this one does not have a default value if (!was_set) { - create_error(Error_Type_Ill_Formed_Arguments, arguments->sourceCodeLocation); + create_error(Error_Type::Ill_Formed_Arguments, arguments->sourceCodeLocation); return nullptr; } } else { @@ -122,7 +122,7 @@ Ast_Node* apply_arguments_to_function(Ast_Node* arguments, Function* function, E } - if (arguments->type == Ast_Node_Type_Nil) { + if (arguments->type == Ast_Node_Type::Nil) { if (function->rest_argument) { define_symbol( create_ast_node_symbol(function->rest_argument), @@ -135,7 +135,7 @@ Ast_Node* apply_arguments_to_function(Ast_Node* arguments, Function* function, E arguments, new_env); } else { // rest was not declared but additional arguments were found - create_error(Error_Type_Ill_Formed_Arguments, arguments->sourceCodeLocation); + create_error(Error_Type::Ill_Formed_Arguments, arguments->sourceCodeLocation); return nullptr; } } @@ -146,7 +146,7 @@ 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; + new_env->type = Environment_Type::Macro; try { result = eval_expr(function->body, new_env); @@ -180,19 +180,19 @@ void parse_argument_list(Ast_Node* arguments, Function* function) { function->rest_argument = nullptr; // okay let's try to read some positional arguments - while (arguments->type == Ast_Node_Type_Pair) { - if (arguments->value.pair->first->type == Ast_Node_Type_Keyword) { + while (arguments->type == Ast_Node_Type::Pair) { + if (arguments->value.pair->first->type == Ast_Node_Type::Keyword) { if (string_equal(arguments->value.pair->first->value.keyword->identifier, "keys") || string_equal(arguments->value.pair->first->value.keyword->identifier, "rest")) break; else { - create_error(Error_Type_Ill_Formed_Lambda_List, arguments->sourceCodeLocation); + create_error(Error_Type::Ill_Formed_Lambda_List, arguments->sourceCodeLocation); return; } } - if (arguments->value.pair->first->type != Ast_Node_Type_Symbol) { - create_error(Error_Type_Ill_Formed_Lambda_List, arguments->sourceCodeLocation); + if (arguments->value.pair->first->type != Ast_Node_Type::Symbol) { + create_error(Error_Type::Ill_Formed_Lambda_List, arguments->sourceCodeLocation); return; } @@ -206,35 +206,35 @@ void parse_argument_list(Ast_Node* arguments, Function* function) { // okay we are done with positional arguments, lets check for // keywords, - if (arguments->type != Ast_Node_Type_Pair) { - if (arguments->type != Ast_Node_Type_Nil) - create_error(Error_Type_Ill_Formed_Lambda_List, arguments->sourceCodeLocation); + if (arguments->type != Ast_Node_Type::Pair) { + if (arguments->type != Ast_Node_Type::Nil) + create_error(Error_Type::Ill_Formed_Lambda_List, arguments->sourceCodeLocation); return; } - if (arguments->value.pair->first->type == Ast_Node_Type_Keyword && + if (arguments->value.pair->first->type == Ast_Node_Type::Keyword && string_equal(arguments->value.pair->first->value.keyword->identifier, "keys")) { arguments = arguments->value.pair->rest; - if (arguments->type != Ast_Node_Type_Pair || - arguments->value.pair->first->type != Ast_Node_Type_Symbol) + if (arguments->type != Ast_Node_Type::Pair || + arguments->value.pair->first->type != Ast_Node_Type::Symbol) { - create_error(Error_Type_Ill_Formed_Lambda_List, arguments->sourceCodeLocation); + create_error(Error_Type::Ill_Formed_Lambda_List, arguments->sourceCodeLocation); return; } - while (arguments->type == Ast_Node_Type_Pair) { - if (arguments->value.pair->first->type == Ast_Node_Type_Keyword) { + while (arguments->type == Ast_Node_Type::Pair) { + if (arguments->value.pair->first->type == Ast_Node_Type::Keyword) { if (string_equal(arguments->value.pair->first->value.keyword->identifier, "rest")) break; else { - create_error(Error_Type_Ill_Formed_Lambda_List, arguments->sourceCodeLocation); + create_error(Error_Type::Ill_Formed_Lambda_List, arguments->sourceCodeLocation); return; } } - if (arguments->value.pair->first->type != Ast_Node_Type_Symbol) { - create_error(Error_Type_Ill_Formed_Lambda_List, arguments->sourceCodeLocation); + if (arguments->value.pair->first->type != Ast_Node_Type::Symbol) { + create_error(Error_Type::Ill_Formed_Lambda_List, arguments->sourceCodeLocation); return; } @@ -242,21 +242,21 @@ void parse_argument_list(Ast_Node* arguments, Function* function) { // the keyword args! Let's check if the next arguement is // :defaults-to Ast_Node* next = arguments->value.pair->rest; - if (next->type == Ast_Node_Type_Pair && - next->value.pair->first->type == Ast_Node_Type_Keyword && + if (next->type == Ast_Node_Type::Pair && + next->value.pair->first->type == Ast_Node_Type::Keyword && string_equal(next->value.pair->first->value.keyword->identifier, "defaults-to")) { // check if there is a next argument too, otherwise it // would be an error next = next->value.pair->rest; - if (next->type == Ast_Node_Type_Pair) { + if (next->type == Ast_Node_Type::Pair) { append_to_keyword_argument_list(function->keyword_arguments, arguments->value.pair->first->value.symbol->identifier, next->value.pair->first); arguments = next->value.pair->rest; } else { - create_error(Error_Type_Ill_Formed_Lambda_List, arguments->sourceCodeLocation); + create_error(Error_Type::Ill_Formed_Lambda_List, arguments->sourceCodeLocation); return; } } else { @@ -272,51 +272,51 @@ void parse_argument_list(Ast_Node* arguments, Function* function) { // Now we are also done with keyword arguments, lets check for // if there is a rest argument - if (arguments->type != Ast_Node_Type_Pair) { - if (arguments->type != Ast_Node_Type_Nil) - create_error(Error_Type_Ill_Formed_Lambda_List, arguments->sourceCodeLocation); + if (arguments->type != Ast_Node_Type::Pair) { + if (arguments->type != Ast_Node_Type::Nil) + create_error(Error_Type::Ill_Formed_Lambda_List, arguments->sourceCodeLocation); return; } - if (arguments->value.pair->first->type == Ast_Node_Type_Keyword && + if (arguments->value.pair->first->type == Ast_Node_Type::Keyword && string_equal(arguments->value.pair->first->value.keyword->identifier, "rest")) { arguments = arguments->value.pair->rest; - if (arguments->type != Ast_Node_Type_Pair || - arguments->value.pair->first->type != Ast_Node_Type_Symbol) + if (arguments->type != Ast_Node_Type::Pair || + arguments->value.pair->first->type != Ast_Node_Type::Symbol) { - create_error(Error_Type_Ill_Formed_Lambda_List, arguments->sourceCodeLocation); + create_error(Error_Type::Ill_Formed_Lambda_List, arguments->sourceCodeLocation); return; } function->rest_argument = arguments->value.pair->first->value.symbol->identifier; - if (arguments->value.pair->rest->type != Ast_Node_Type_Nil) { - create_error(Error_Type_Ill_Formed_Lambda_List, arguments->sourceCodeLocation); + if (arguments->value.pair->rest->type != Ast_Node_Type::Nil) { + create_error(Error_Type::Ill_Formed_Lambda_List, arguments->sourceCodeLocation); } } else { printf("this should not happen?"); - create_error(Error_Type_Unknown_Error, arguments->sourceCodeLocation); + create_error(Error_Type::Unknown_Error, arguments->sourceCodeLocation); } } int list_length(Ast_Node* node) { - if (node->type == Ast_Node_Type_Nil) + if (node->type == Ast_Node_Type::Nil) return 0; - if (node->type != Ast_Node_Type_Pair) { - create_error(Error_Type_Type_Missmatch, node->sourceCodeLocation); + if (node->type != Ast_Node_Type::Pair) { + create_error(Error_Type::Type_Missmatch, node->sourceCodeLocation); return 0; } int len = 0; - while (node->type == Ast_Node_Type_Pair) { + while (node->type == Ast_Node_Type::Pair) { ++len; node = node->value.pair->rest; - if (node->type == Ast_Node_Type_Nil) + if (node->type == Ast_Node_Type::Nil) return len; } - create_error(Error_Type_Ill_Formed_List, node->sourceCodeLocation); + create_error(Error_Type::Ill_Formed_List, node->sourceCodeLocation); return 0; } @@ -333,27 +333,27 @@ Ast_Node* extract_keyword_value(char* keyword, Parsed_Arguments* args) { Ast_Node* eval_arguments(Ast_Node* arguments, Environment* env, int *out_arguments_length) { *out_arguments_length = 0; - if (arguments->type == Ast_Node_Type_Nil) { + if (arguments->type == Ast_Node_Type::Nil) { return arguments; } Ast_Node* evaluated_arguments = create_ast_node_pair(nullptr, nullptr); Ast_Node* evaluated_arguments_head = evaluated_arguments; Ast_Node* current_head = arguments; - while (current_head->type == Ast_Node_Type_Pair) { + while (current_head->type == Ast_Node_Type::Pair) { try { evaluated_arguments_head->value.pair->first = eval_expr(current_head->value.pair->first, env); } current_head = current_head->value.pair->rest; - if (current_head->type == Ast_Node_Type_Pair) { + if (current_head->type == Ast_Node_Type::Pair) { evaluated_arguments_head->value.pair->rest = create_ast_node_pair(nullptr, nullptr); evaluated_arguments_head = evaluated_arguments_head->value.pair->rest; - } else if (current_head->type == Ast_Node_Type_Nil) { + } else if (current_head->type == Ast_Node_Type::Nil) { evaluated_arguments_head->value.pair->rest = current_head; } else { - create_error(Error_Type_Ill_Formed_Arguments, arguments->sourceCodeLocation); + create_error(Error_Type::Ill_Formed_Arguments, arguments->sourceCodeLocation); return nullptr; } ++(*out_arguments_length); @@ -372,24 +372,24 @@ Ast_Node* eval_expr(Ast_Node* node, Environment* env) { Ast_Node* ret = new(Ast_Node); switch (node->type) { - case Ast_Node_Type_T: - case Ast_Node_Type_Nil: + case Ast_Node_Type::T: + case Ast_Node_Type::Nil: return node; - case Ast_Node_Type_Symbol: { + case Ast_Node_Type::Symbol: { Ast_Node* symbol; try { symbol = lookup_symbol(node, env); } return symbol; } - case Ast_Node_Type_Number: - case Ast_Node_Type_Keyword: - case Ast_Node_Type_String: + case Ast_Node_Type::Number: + case Ast_Node_Type::Keyword: + case Ast_Node_Type::String: return node; - case Ast_Node_Type_Pair: { + case Ast_Node_Type::Pair: { Ast_Node* lispOperator; - if (node->value.pair->first->type != Ast_Node_Type_CFunction && - node->value.pair->first->type != Ast_Node_Type_Function) + if (node->value.pair->first->type != Ast_Node_Type::CFunction && + node->value.pair->first->type != Ast_Node_Type::Function) { try { lispOperator = eval_expr(node->value.pair->first, env); @@ -402,13 +402,13 @@ Ast_Node* eval_expr(Ast_Node* node, Environment* env) { int arguments_length; // check for c function - if (lispOperator->type == Ast_Node_Type_CFunction) { + if (lispOperator->type == Ast_Node_Type::CFunction) { Ast_Node* result = lispOperator->value.cfunction->function(arguments, env); return result; } // check for list function - if (lispOperator->type == Ast_Node_Type_Function) { + if (lispOperator->type == Ast_Node_Type::Function) { if (!lispOperator->value.function->is_macro) { try { arguments = eval_arguments(arguments, env, &arguments_length); @@ -426,7 +426,7 @@ Ast_Node* eval_expr(Ast_Node* node, Environment* env) { #ifdef _DEBUG __debugbreak(); #endif - report_error(Error_Type_Not_A_Function); + report_error(Error_Type::Not_A_Function); } } #undef report_error @@ -437,7 +437,7 @@ bool is_truthy (Ast_Node* expression, Environment* env) { try { result = eval_expr(expression, env); } - if (result->type == Ast_Node_Type_Nil) + if (result->type == Ast_Node_Type::Nil) return false; return true; diff --git a/src/helpers.cpp b/src/helpers.cpp index 34e4ce7..b51a4b9 100644 --- a/src/helpers.cpp +++ b/src/helpers.cpp @@ -27,11 +27,11 @@ #define define_array_list(type, name) \ - typedef struct { \ + struct name##_Array_List { \ type* data; \ int length; \ int next_index; \ - } name##_Array_List; \ + }; \ \ \ void append_to_##name##_array_list(name##_Array_List* arraylist, type element) { \ @@ -55,8 +55,6 @@ define_array_list(char*, String); -//typedef enum { false, true } bool; - int string_equal(char* a, char* b) { return !strcmp(a, b); } @@ -99,9 +97,6 @@ static char get_nibble(char c) { return (c - '0'); } -#define true 1 -#define false 0 -#define bool char bool unescape_string(char* in) { if (!in) return true; @@ -278,11 +273,11 @@ char* read_line() { } -typedef struct { +struct Source_Code_Location { char* file; int line; int column; -} Source_Code_Location; +}; Source_Code_Location* create_source_code_location(char* file, int line, int col) { if (!file) diff --git a/src/io.cpp b/src/io.cpp index ca7fe8c..eaa156d 100644 --- a/src/io.cpp +++ b/src/io.cpp @@ -1,24 +1,22 @@ -/* #define console_normal "\x1B[0m" */ -/* #define console_red "\x1B[31m" */ -/* #define console_green "\x1B[32m" */ -/* #define console_cyan "\x1B[36m" */ +// #define console_normal "\x1B[0m" +// #define console_red "\x1B[31m" +// #define console_green "\x1B[32m" +// #define console_cyan "\x1B[36m" #define console_normal "" #define console_red "" #define console_green "" #define console_cyan "" +enum struct Log_Level { + None, + Critical, + Warning, + Info, + Debug, +}; -typedef enum { - Log_Level_None, - - Log_Level_Critical, - Log_Level_Warning, - Log_Level_Info, - Log_Level_Debug, -} Log_Level; - -Log_Level log_level = Log_Level_Debug; +Log_Level log_level = Log_Level::Debug; void log_message(Log_Level type, char* message) { if (type > log_level) @@ -26,50 +24,50 @@ void log_message(Log_Level type, char* message) { char* prefix; switch (type) { - case Log_Level_Critical: prefix = "CRITICAL"; break; - case Log_Level_Warning: prefix = "WARNING"; break; - case Log_Level_Info: prefix = "INFO"; break; - case Log_Level_Debug: prefix = "DEBUG"; break; - default: return; + case Log_Level::Critical: prefix = "CRITICAL"; break; + case Log_Level::Warning: prefix = "WARNING"; break; + case Log_Level::Info: prefix = "INFO"; break; + case Log_Level::Debug: prefix = "DEBUG"; break; + default: return; } printf("%s: %s\n",prefix, message); } void panic(char* message) { - log_message(Log_Level_Critical, message); + log_message(Log_Level::Critical, message); exit(1); } void print(Ast_Node* node) { switch (node->type) { - case (Ast_Node_Type_Nil): { + case (Ast_Node_Type::Nil): { printf("nil"); } break; - case (Ast_Node_Type_T): { + case (Ast_Node_Type::T): { printf("t"); } break; - case (Ast_Node_Type_Number): { + case (Ast_Node_Type::Number): { printf("%f", node->value.number->value); } break; - case (Ast_Node_Type_String): { + case (Ast_Node_Type::String): { printf("%s", node->value.string->value); } break; - case (Ast_Node_Type_Symbol): { + case (Ast_Node_Type::Symbol): { printf("%s", node->value.symbol->identifier); } break; - case (Ast_Node_Type_Keyword): { + case (Ast_Node_Type::Keyword): { printf(":%s", node->value.keyword->identifier); } break; - case (Ast_Node_Type_Function): { + case (Ast_Node_Type::Function): { if (node->value.function->is_macro) printf("[macro]"); else printf("[lambda]"); } break; - case (Ast_Node_Type_CFunction): { + case (Ast_Node_Type::CFunction): { printf("[C-function]"); } break; - case (Ast_Node_Type_Pair): { + case (Ast_Node_Type::Pair): { Ast_Node* head = node; printf("("); @@ -81,12 +79,12 @@ void print(Ast_Node* node) { head = head->value.pair->rest; if (!head) return; - if (head->type != Ast_Node_Type_Pair) + if (head->type != Ast_Node_Type::Pair) break; printf(" "); } - if (head->type != Ast_Node_Type_Nil) { + if (head->type != Ast_Node_Type::Nil) { printf(" . "); print(head); } diff --git a/src/main.cpp b/src/main.cpp index cbcfe6c..5ca17b5 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -22,7 +22,7 @@ Ast_Node* interprete_file (char* file_name) { char* file_content = read_entire_file(file_name); if (!file_content) { - create_error(Error_Type_Unknown_Error, nullptr); + create_error(Error_Type::Unknown_Error, nullptr); } Ast_Node_Array_List* program; @@ -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(Environment_Type::Let); 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(Environment_Type::Let); load_built_ins_into_environment(env); built_in_load("pre.slime", env); diff --git a/src/parse.cpp b/src/parse.cpp index 8fc01d5..d753d94 100644 --- a/src/parse.cpp +++ b/src/parse.cpp @@ -161,7 +161,7 @@ Ast_Node* parse_string(char* text, int* index_in_text) { if (!unescape_string(text+(*index_in_text))) { create_error( - Error_Type_Unknown_Error, + Error_Type::Unknown_Error, create_source_code_location(parser_file, parser_line, parser_col)); return nullptr; } @@ -243,7 +243,7 @@ Ast_Node* parse_expression(char* text, int* index_in_text) { // okay there is something Ast_Node* head = new(Ast_Node); - head->type = Ast_Node_Type_Pair; + head->type = Ast_Node_Type::Pair; head->value.pair = new(Pair); Ast_Node* expression = head; @@ -260,7 +260,7 @@ Ast_Node* parse_expression(char* text, int* index_in_text) { eat_until_code(text, index_in_text); if (text[(*index_in_text)] == '\0') { - create_error(Error_Type_Unexpected_Eof, create_source_code_location(parser_file, parser_line, parser_col)); + create_error(Error_Type::Unexpected_Eof, create_source_code_location(parser_file, parser_line, parser_col)); return nullptr; } @@ -283,7 +283,7 @@ Ast_Node* parse_expression(char* text, int* index_in_text) { eat_until_code(text, index_in_text); if (text[(*index_in_text)] != ')') - create_error(Error_Type_Syntax_Error, create_source_code_location(parser_file, parser_line, parser_col)); + create_error(Error_Type::Syntax_Error, create_source_code_location(parser_file, parser_line, parser_col)); ++parser_col; ++(*index_in_text); break; @@ -316,7 +316,7 @@ Ast_Node* parse_single_expression(char* text) { eat_until_code(text, &index_in_text); if (text[(index_in_text)] == '\0') return result; - create_error(Error_Type_Trailing_Garbage, create_source_code_location(parser_file, parser_line, parser_col)); + create_error(Error_Type::Trailing_Garbage, create_source_code_location(parser_file, parser_line, parser_col)); return nullptr; } @@ -348,7 +348,7 @@ Ast_Node_Array_List* parse_program(char* file_name, char* text) { } break; default: /* syntax error */ - create_error(Error_Type_Syntax_Error, create_source_code_location(parser_file, parser_line, parser_col)); + create_error(Error_Type::Syntax_Error, create_source_code_location(parser_file, parser_line, parser_col)); return nullptr; } } diff --git a/src/testing.cpp b/src/testing.cpp index e751766..7eb2d69 100644 --- a/src/testing.cpp +++ b/src/testing.cpp @@ -94,26 +94,26 @@ testresult test_eval_operands() { assert_no_error(error); assert_equal_int(list_length(operands), 4); - assert_equal_type(operands, Ast_Node_Type_Pair); - assert_equal_type(operands->value.pair->first, Ast_Node_Type_Number); + assert_equal_type(operands, Ast_Node_Type::Pair); + assert_equal_type(operands->value.pair->first, Ast_Node_Type::Number); assert_equal_double(operands->value.pair->first->value.number->value, 1); operands = operands->value.pair->rest; - assert_equal_type(operands, Ast_Node_Type_Pair); - assert_equal_type(operands->value.pair->first, Ast_Node_Type_Number); + assert_equal_type(operands, Ast_Node_Type::Pair); + assert_equal_type(operands->value.pair->first, Ast_Node_Type::Number); assert_equal_double(operands->value.pair->first->value.number->value, 3); operands = operands->value.pair->rest; - assert_equal_type(operands, Ast_Node_Type_Pair); - assert_equal_type(operands->value.pair->first, Ast_Node_Type_String); + assert_equal_type(operands, Ast_Node_Type::Pair); + assert_equal_type(operands->value.pair->first, Ast_Node_Type::String); assert_equal_string(operands->value.pair->first->value.string->value, "okay"); operands = operands->value.pair->rest; - assert_equal_type(operands, Ast_Node_Type_Pair); - assert_equal_type(operands->value.pair->first, Ast_Node_Type_Keyword); + assert_equal_type(operands, Ast_Node_Type::Pair); + assert_equal_type(operands->value.pair->first, Ast_Node_Type::Keyword); assert_equal_string(operands->value.pair->first->value.keyword->identifier, "haha"); return pass; @@ -130,46 +130,46 @@ testresult test_parse_atom() { // test numbers Ast_Node* result = parse_atom(string, &index_in_text); - assert_equal_type(result, Ast_Node_Type_Number); + assert_equal_type(result, Ast_Node_Type::Number); assert_equal_double(result->value.number->value, 123); ++index_in_text; result = parse_atom(string, &index_in_text); - assert_equal_type(result, Ast_Node_Type_Number); + assert_equal_type(result, Ast_Node_Type::Number); assert_equal_double(result->value.number->value, -1.23e-2); // test strings ++index_in_text; result = parse_atom(string, &index_in_text); - assert_equal_type(result, Ast_Node_Type_String); + assert_equal_type(result, Ast_Node_Type::String); assert_equal_string(result->value.string->value, "asd"); // test keywords ++index_in_text; result = parse_atom(string, &index_in_text); - assert_equal_type(result, Ast_Node_Type_Keyword); + assert_equal_type(result, Ast_Node_Type::Keyword); assert_equal_string(result->value.keyword->identifier, "key1"); ++index_in_text; result = parse_atom(string, &index_in_text); - assert_equal_type(result, Ast_Node_Type_Keyword); + assert_equal_type(result, Ast_Node_Type::Keyword); assert_equal_string(result->value.keyword->identifier, "key:2"); // test symbols ++index_in_text; result = parse_atom(string, &index_in_text); - assert_equal_type(result, Ast_Node_Type_Symbol); + assert_equal_type(result, Ast_Node_Type::Symbol); assert_equal_string(result->value.symbol->identifier, "sym"); ++index_in_text; result = parse_atom(string, &index_in_text); - assert_equal_type(result, Ast_Node_Type_Symbol); + assert_equal_type(result, Ast_Node_Type::Symbol); assert_equal_string(result->value.symbol->identifier, "+"); return pass; @@ -182,25 +182,25 @@ testresult test_parse_expression() { Ast_Node* result = parse_expression(string, &index_in_text); assert_no_error(error); - assert_equal_type(result, Ast_Node_Type_Pair); - assert_equal_type(result->value.pair->first, Ast_Node_Type_Symbol); + assert_equal_type(result, Ast_Node_Type::Pair); + assert_equal_type(result->value.pair->first, Ast_Node_Type::Symbol); assert_equal_string(result->value.pair->first->value.symbol->identifier, "fun"); result = result->value.pair->rest; - assert_equal_type(result, Ast_Node_Type_Pair); - assert_equal_type(result->value.pair->first, Ast_Node_Type_Symbol); + assert_equal_type(result, Ast_Node_Type::Pair); + assert_equal_type(result->value.pair->first, Ast_Node_Type::Symbol); assert_equal_string(result->value.pair->first->value.symbol->identifier, "+"); result = result->value.pair->rest; - assert_equal_type(result, Ast_Node_Type_Pair); - assert_equal_type(result->value.pair->first, Ast_Node_Type_Number); + assert_equal_type(result, Ast_Node_Type::Pair); + assert_equal_type(result->value.pair->first, Ast_Node_Type::Number); assert_equal_double(result->value.pair->first->value.number->value, 12); result = result->value.pair->rest; - assert_equal_type(result, Ast_Node_Type_Nil); + assert_equal_type(result, Ast_Node_Type::Nil); char string2[] = "(define fun (lambda (x) (+ 5 (* x x ))))"; index_in_text = 0; @@ -208,21 +208,21 @@ testresult test_parse_expression() { result = parse_expression(string2, &index_in_text); assert_no_error(error); - assert_equal_type(result, Ast_Node_Type_Pair); - assert_equal_type(result->value.pair->first, Ast_Node_Type_Symbol); + assert_equal_type(result, Ast_Node_Type::Pair); + assert_equal_type(result->value.pair->first, Ast_Node_Type::Symbol); assert_equal_string(result->value.pair->first->value.symbol->identifier, "define"); result = result->value.pair->rest; - assert_equal_type(result, Ast_Node_Type_Pair); - assert_equal_type(result->value.pair->first, Ast_Node_Type_Symbol); + assert_equal_type(result, Ast_Node_Type::Pair); + assert_equal_type(result->value.pair->first, Ast_Node_Type::Symbol); assert_equal_string(result->value.pair->first->value.symbol->identifier, "fun"); result = result->value.pair->rest; - assert_equal_type(result, Ast_Node_Type_Pair); - assert_equal_type(result->value.pair->first, Ast_Node_Type_Pair); - assert_equal_type(result->value.pair->first->value.pair->first, Ast_Node_Type_Symbol); + assert_equal_type(result, Ast_Node_Type::Pair); + assert_equal_type(result->value.pair->first, Ast_Node_Type::Pair); + assert_equal_type(result->value.pair->first->value.pair->first, Ast_Node_Type::Symbol); assert_equal_string(result->value.pair->first->value.pair->first->value.symbol->identifier, "lambda"); result = result->value.pair->rest; @@ -237,7 +237,7 @@ testresult test_built_in_add() { assert_no_error(error); assert_not_null(result); - assert_equal_type(result, Ast_Node_Type_Number); + assert_equal_type(result, Ast_Node_Type::Number); assert_equal_double(result->value.number->value, 14); return pass; @@ -250,7 +250,7 @@ testresult test_built_in_substract() { assert_no_error(error); assert_not_null(result); - assert_equal_type(result, Ast_Node_Type_Number); + assert_equal_type(result, Ast_Node_Type::Number); assert_equal_double(result->value.number->value, 6); return pass; @@ -264,7 +264,7 @@ testresult test_built_in_multiply() { assert_no_error(error); assert_not_null(result); - assert_equal_type(result, Ast_Node_Type_Number); + assert_equal_type(result, Ast_Node_Type::Number); assert_equal_double(result->value.number->value, 40); return pass; @@ -278,7 +278,7 @@ testresult test_built_in_divide() { assert_null(error); assert_not_null(result); - assert_equal_type(result, Ast_Node_Type_Number); + assert_equal_type(result, Ast_Node_Type::Number); assert_equal_double(result->value.number->value, 5); return pass; @@ -292,7 +292,7 @@ testresult test_built_in_if() { assert_no_error(error); assert_not_null(result); - assert_equal_type(result, Ast_Node_Type_Number); + assert_equal_type(result, Ast_Node_Type::Number); assert_equal_double(result->value.number->value, 4); char exp_string2[] = "(if () 4 5)"; @@ -301,7 +301,7 @@ testresult test_built_in_if() { assert_no_error(error); assert_not_null(result); - assert_equal_type(result, Ast_Node_Type_Number); + assert_equal_type(result, Ast_Node_Type::Number); assert_equal_double(result->value.number->value, 5); return pass; @@ -314,7 +314,7 @@ testresult test_built_in_and() { assert_no_error(error); assert_not_null(result); - assert_equal_type(result, Ast_Node_Type_T); + assert_equal_type(result, Ast_Node_Type::T); // a false case char exp_string2[] = "(and () \"asd\" 4)"; @@ -323,7 +323,7 @@ testresult test_built_in_and() { assert_no_error(error); assert_not_null(result); - assert_equal_type(result, Ast_Node_Type_Nil); + assert_equal_type(result, Ast_Node_Type::Nil); return pass; } @@ -335,7 +335,7 @@ testresult test_built_in_or() { assert_no_error(error); assert_not_null(result); - assert_equal_type(result, Ast_Node_Type_T); + assert_equal_type(result, Ast_Node_Type::T); // a false case char exp_string2[] = "(or () ())"; @@ -344,7 +344,7 @@ testresult test_built_in_or() { assert_no_error(error); assert_not_null(result); - assert_equal_type(result, Ast_Node_Type_Nil); + assert_equal_type(result, Ast_Node_Type::Nil); return pass; } @@ -358,7 +358,7 @@ testresult test_built_in_not() { // a true case assert_no_error(error); assert_not_null(result); - assert_equal_type(result, Ast_Node_Type_T); + assert_equal_type(result, Ast_Node_Type::T); // a false case char exp_string2[] = "(not \"asd xD\")"; @@ -367,13 +367,13 @@ testresult test_built_in_not() { assert_no_error(error); assert_not_null(result); - assert_equal_type(result, Ast_Node_Type_Nil); + assert_equal_type(result, Ast_Node_Type::Nil); return pass; } void run_all_tests() { - log_level = Log_Level_None; + log_level = Log_Level::None; printf("-- Parsing --\n"); invoke_test(test_parse_atom);