felix/slime
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

converted all typedefs to c++ types and enums to enum structs

Browse Source
This commit is contained in:
FelixBrendel
2018-12-27 15:01:29 +01:00
parent 9bc30d1569
commit 34b7390ba9
11 changed files with 373 additions and 385 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/assert.cpp
+2 -2
View File
@@ -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);
}
src/ast.cpp
+49 -52
View File
@@ -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<Ast_Node*(Ast_Node*, Environment*)> 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<Ast_Node*(Ast_Node*, Environment*)> 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::function<Ast_Node*(Ast_Node*, Environme
Ast_Node* create_ast_node_pair(Ast_Node* first, Ast_Node* rest) {
Ast_Node* node = create_ast_node();
node->type = 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;
src/built_ins.cpp
+119 -119
View File
@@ -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;
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;
}
src/env.cpp
+18 -20
View File
@@ -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);
src/error.cpp
+31 -31
View File
@@ -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";
}
}
src/eval.cpp
+69 -69
View File
@@ -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;
src/helpers.cpp
+4 -9
View File
@@ -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)
src/io.cpp
+28 -30
View File
@@ -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;
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);
}
src/main.cpp
+3 -3
View File
@@ -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);
src/parse.cpp
+6 -6
View File
@@ -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;
}
}
src/testing.cpp
+42 -42
View File
@@ -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);