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

linux fixes

Browse Source
This commit is contained in:
Felix Brendel
2018-10-29 12:54:23 +01:00
parent f91a69c69e
commit 716b72ff0f
4 changed files with 174 additions and 169 deletions
Download Patch File Download Diff File Expand all files Collapse all files
build.sh
+3 -1
View File
@@ -2,5 +2,7 @@ clang src/main.c -g -o ./bin/slime --std=c99 || exit 1
echo ""
echo "--- Output Start ---"
./bin/slime
pushd bin
./slime
popd
echo "--- Output End ---"
src/built_ins.c
+92 -91
View File
@@ -2,39 +2,40 @@ Ast_Node* eval_expr(Ast_Node* node, Environment* env);
bool ast_node_equal(Ast_Node* n1, Ast_Node* n2) {
if (n1 == n2)
return true;
return true;
if (n1->type != n2->type)
return false;
return false;
switch (n1->type) {
case Ast_Node_Type_Built_In_Function:
return n1->value.built_in_function->type
== n2->value.built_in_function->type;
return n1->value.built_in_function->type
== n2->value.built_in_function->type;
case Ast_Node_Type_Function:
// if they have the same pointer, true is
// returned a few lines above
return false;
// if they have the same pointer, true is
// returned a few lines above
return false;
case Ast_Node_Type_Keyword:
return string_equal(
n1->value.keyword->identifier,
n2->value.keyword->identifier);
return string_equal(
n1->value.keyword->identifier,
n2->value.keyword->identifier);
case Ast_Node_Type_T:
case Ast_Node_Type_Nil:
return true;
return true;
case Ast_Node_Type_Number:
return
n1->value.number->value ==
n2->value.number->value;
return
n1->value.number->value ==
n2->value.number->value;
case Ast_Node_Type_Pair:
create_error(Error_Type_Not_Yet_Implemented, n1);
return false;
create_error(Error_Type_Not_Yet_Implemented, n1);
return false;
case Ast_Node_Type_String:
return string_equal(
n1->value.string->value,
n2->value.string->value);
return string_equal(
n1->value.string->value,
n2->value.string->value);
case Ast_Node_Type_Symbol:
return string_equal(
n1->value.symbol->identifier,
n2->value.symbol->identifier);
return string_equal(
n1->value.symbol->identifier,
n2->value.symbol->identifier);
}
// we should never reach here
@@ -43,32 +44,32 @@ bool ast_node_equal(Ast_Node* n1, Ast_Node* n2) {
Ast_Node* built_in_equals(Ast_Node* operands) {
if (operands->type == Ast_Node_Type_Nil)
return create_ast_node_t();
return create_ast_node_t();
Ast_Node* first = operands->value.pair->first;
while (operands->type == Ast_Node_Type_Pair) {
if (!ast_node_equal(operands->value.pair->first, first))
return create_ast_node_nil();
operands = operands->value.pair->rest;
if (!ast_node_equal(operands->value.pair->first, first))
return create_ast_node_nil();
operands = operands->value.pair->rest;
}
return create_ast_node_t();
return create_ast_node_t();
}
Ast_Node* built_in_greater(Ast_Node* operands) {
double last_number = strtod("Inf", NULL);
while (operands->type == Ast_Node_Type_Pair) {
try {
assert_type(operands->value.pair->first, Ast_Node_Type_Number);
}
try {
assert_type(operands->value.pair->first, Ast_Node_Type_Number);
}
if (operands->value.pair->first->value.number->value >= last_number)
return create_ast_node_nil();
if (operands->value.pair->first->value.number->value >= last_number)
return create_ast_node_nil();
last_number = operands->value.pair->first->value.number->value;
operands = operands->value.pair->rest;
last_number = operands->value.pair->first->value.number->value;
operands = operands->value.pair->rest;
}
return create_ast_node_t();
@@ -78,15 +79,15 @@ Ast_Node* built_in_greater_equal(Ast_Node* operands) {
double last_number = strtod("Inf", NULL);
while (operands->type == Ast_Node_Type_Pair) {
try {
assert_type(operands->value.pair->first, Ast_Node_Type_Number);
}
try {
assert_type(operands->value.pair->first, Ast_Node_Type_Number);
}
if (operands->value.pair->first->value.number->value > last_number)
return create_ast_node_nil();
if (operands->value.pair->first->value.number->value > last_number)
return create_ast_node_nil();
last_number = operands->value.pair->first->value.number->value;
operands = operands->value.pair->rest;
last_number = operands->value.pair->first->value.number->value;
operands = operands->value.pair->rest;
}
return create_ast_node_t();
@@ -96,15 +97,15 @@ Ast_Node* built_in_less(Ast_Node* operands) {
double last_number = strtod("-Inf", NULL);
while (operands->type == Ast_Node_Type_Pair) {
try {
assert_type(operands->value.pair->first, Ast_Node_Type_Number);
}
try {
assert_type(operands->value.pair->first, Ast_Node_Type_Number);
}
if (operands->value.pair->first->value.number->value <= last_number)
return create_ast_node_nil();
if (operands->value.pair->first->value.number->value <= last_number)
return create_ast_node_nil();
last_number = operands->value.pair->first->value.number->value;
operands = operands->value.pair->rest;
last_number = operands->value.pair->first->value.number->value;
operands = operands->value.pair->rest;
}
return create_ast_node_t();
@@ -114,15 +115,15 @@ Ast_Node* built_in_less_equal(Ast_Node* operands) {
double last_number = strtod("-Inf", NULL);
while (operands->type == Ast_Node_Type_Pair) {
try {
assert_type(operands->value.pair->first, Ast_Node_Type_Number);
}
try {
assert_type(operands->value.pair->first, Ast_Node_Type_Number);
}
if (operands->value.pair->first->value.number->value < last_number)
return create_ast_node_nil();
if (operands->value.pair->first->value.number->value < last_number)
return create_ast_node_nil();
last_number = operands->value.pair->first->value.number->value;
operands = operands->value.pair->rest;
last_number = operands->value.pair->first->value.number->value;
operands = operands->value.pair->rest;
}
return create_ast_node_t();
@@ -131,11 +132,11 @@ Ast_Node* built_in_less_equal(Ast_Node* operands) {
Ast_Node* built_in_add(Ast_Node* operands) {
double sum = 0;
while (operands->type == Ast_Node_Type_Pair) {
try {
assert_type(operands->value.pair->first, Ast_Node_Type_Number);
}
sum += operands->value.pair->first->value.number->value;
operands = operands->value.pair->rest;
try {
assert_type(operands->value.pair->first, Ast_Node_Type_Number);
}
sum += operands->value.pair->first->value.number->value;
operands = operands->value.pair->rest;
}
return create_ast_node_number(sum);
@@ -143,54 +144,54 @@ Ast_Node* built_in_add(Ast_Node* operands) {
Ast_Node* built_in_substract(Ast_Node* operands) {
try {
assert_type(operands->value.pair->first, Ast_Node_Type_Number);
assert_type(operands->value.pair->first, Ast_Node_Type_Number);
}
double difference = operands->value.pair->first->value.number->value;
operands = operands->value.pair->rest;
while (operands->type == Ast_Node_Type_Pair) {
try {
assert_type(operands->value.pair->first, Ast_Node_Type_Number);
}
try {
assert_type(operands->value.pair->first, Ast_Node_Type_Number);
}
difference -= operands->value.pair->first->value.number->value;
operands = operands->value.pair->rest;
difference -= operands->value.pair->first->value.number->value;
operands = operands->value.pair->rest;
}
return create_ast_node_number(difference);
}
Ast_Node* built_in_multiply(Ast_Node* operands) {
try {
assert_type(operands->value.pair->first, Ast_Node_Type_Number);
assert_type(operands->value.pair->first, Ast_Node_Type_Number);
}
double product = operands->value.pair->first->value.number->value;
operands = operands->value.pair->rest;
while (operands->type == Ast_Node_Type_Pair) {
try {
assert_type(operands->value.pair->first, Ast_Node_Type_Number);
}
try {
assert_type(operands->value.pair->first, Ast_Node_Type_Number);
}
product *= operands->value.pair->first->value.number->value;
operands = operands->value.pair->rest;
product *= operands->value.pair->first->value.number->value;
operands = operands->value.pair->rest;
}
return create_ast_node_number(product);
}
Ast_Node* built_in_divide(Ast_Node* operands) {
try {
assert_type(operands->value.pair->first, Ast_Node_Type_Number);
assert_type(operands->value.pair->first, Ast_Node_Type_Number);
}
double quotient = operands->value.pair->first->value.number->value;
operands = operands->value.pair->rest;
while (operands->type == Ast_Node_Type_Pair) {
try {
assert_type(operands->value.pair->first, Ast_Node_Type_Number);
}
try {
assert_type(operands->value.pair->first, Ast_Node_Type_Number);
}
quotient /= operands->value.pair->first->value.number->value;
operands = operands->value.pair->rest;
quotient /= operands->value.pair->first->value.number->value;
operands = operands->value.pair->rest;
}
return create_ast_node_number(quotient);
}
@@ -199,19 +200,19 @@ Ast_Node* built_in_divide(Ast_Node* operands) {
Ast_Node* built_in_load(char* file_name, Environment* env) {
char* file_content = read_entire_file(file_name);
if (file_content) {
Ast_Node* result = create_ast_node_nil();
Ast_Node_Array_List* program;
try {
program = parse_program(file_content);
}
for (int i = 0; i < program->next_index; ++i) {
try {
result = eval_expr(program->data[i], env);
}
}
return result;
Ast_Node* result = create_ast_node_nil();
Ast_Node_Array_List* program;
try {
program = parse_program(file_content);
}
for (int i = 0; i < program->next_index; ++i) {
try {
result = eval_expr(program->data[i], env);
}
}
return result;
} else {
create_error(Error_Type_Unknown_Error, create_ast_node_nil());
return nullptr;
create_error(Error_Type_Unknown_Error, create_ast_node_nil());
return nullptr;
}
}
src/env.c
+64 -64
View File
@@ -6,10 +6,10 @@ typedef enum {
struct Environment {
struct Environment* parent;
Environment_Type type;
Environment_Type type;
int capacity;
int next_index;
int capacity;
int next_index;
// TODO(Felix): Use a hashmap here.
char** keys;
Ast_Node** values;
@@ -22,12 +22,12 @@ Environment* create_child_environment(Environment* parent, Environment_Type type
int start_capacity = 16;
env->type = type;
env->parent = parent;
env->type = type;
env->parent = parent;
env->capacity = start_capacity;
env->next_index = 0;
env->keys = (char**)malloc(start_capacity * sizeof(char*));
env->values = (Ast_Node**)malloc(start_capacity * sizeof(Ast_Node*));
env->keys = (char**)malloc(start_capacity * sizeof(char*));
env->values = (Ast_Node**)malloc(start_capacity * sizeof(Ast_Node*));
return env;
}
@@ -38,12 +38,12 @@ Environment* create_empty_environment(Environment_Type type) {
void define_symbol(Ast_Node* symbol, Ast_Node* value, Environment* env) {
if (env->type == Environment_Type_Macro) {
// NOTE(Felix): we know we have a parent because every
// environment has a parent except the top level environment.
// However the top level environment is not a let-environment,
// so we would not land here
define_symbol(symbol, value, env->parent);
return;
// NOTE(Felix): we know we have a parent because every
// environment has a parent except the top level environment.
// However the top level environment is not a let-environment,
// so we would not land here
define_symbol(symbol, value, env->parent);
return;
}
// NOTE(Felix): right now we are simply adding the symol at the
@@ -52,9 +52,9 @@ void define_symbol(Ast_Node* symbol, Ast_Node* value, Environment* env) {
// latest defined one first, but a bit messy. Later we should use
// a hashmap here. @refactor
if (env->next_index == env->capacity) {
env->capacity *= 2;
env->keys = (char**)realloc(env->keys, env->capacity * sizeof(char*));
env->values = (Ast_Node**)realloc(env->values, env->capacity * sizeof(Ast_Node*));
env->capacity *= 2;
env->keys = (char**)realloc(env->keys, env->capacity * sizeof(char*));
env->values = (Ast_Node**)realloc(env->values, env->capacity * sizeof(Ast_Node*));
}
env->keys [env->next_index] = symbol->value.symbol->identifier;
@@ -63,9 +63,9 @@ 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);
return;
if (env->type != Environment_Type_Macro) {
create_error(Error_Type_Unknown_Error, symbol);
return;
}
env->type = Environment_Type_Lambda;
@@ -77,19 +77,19 @@ void print_environment(Environment* env);
Ast_Node* lookup_symbol_in_this_envt(Symbol* sym, Environment* env) {
for (int i = env->next_index - 1; i >= 0; --i)
if (string_equal(env->keys[i], sym->identifier))
return env->values[i];
if (string_equal(env->keys[i], sym->identifier))
return env->values[i];
return nullptr;
}
Ast_Node* lookup_symbol_from_lambda_env(Symbol* sym, Environment* env) {
Ast_Node* result;
do {
if (env->type != Environment_Type_Lambda) {
result = lookup_symbol_in_this_envt(sym, env);
if (result) return result;
}
env = env->parent;
if (env->type != Environment_Type_Lambda) {
result = lookup_symbol_in_this_envt(sym, env);
if (result) return result;
}
env = env->parent;
} while (env);
return nullptr;
}
@@ -97,22 +97,22 @@ Ast_Node* lookup_symbol_from_lambda_env(Symbol* sym, Environment* env) {
Ast_Node* lookup_symbol_from_let_or_macro_env(Symbol* sym, Environment* env) {
Ast_Node* result;
do {
result = lookup_symbol_in_this_envt(sym, env);
if (result) return result;
if (env->type == Environment_Type_Lambda)
break;
result = lookup_symbol_in_this_envt(sym, env);
if (result) return result;
if (env->type == Environment_Type_Lambda)
break;
env = env->parent;
env = env->parent;
} while (env);
if (env) {
do {
if (env->type != Environment_Type_Lambda) {
result = lookup_symbol_in_this_envt(sym, env);
if (result) return result;
}
env = env->parent;
} while (env);
do {
if (env->type != Environment_Type_Lambda) {
result = lookup_symbol_in_this_envt(sym, env);
if (result) return result;
}
env = env->parent;
} while (env);
}
return nullptr;
@@ -123,29 +123,29 @@ Ast_Node* lookup_symbol(Symbol* sym, Environment* env) {
Ast_Node* result;
result = lookup_symbol_in_this_envt(sym, env);
if (result)
return result;
return result;
if (env->parent) {
if (env->type == Environment_Type_Lambda) {
result = lookup_symbol_from_lambda_env(sym, env->parent);
} else {
result = lookup_symbol_from_let_or_macro_env(sym, env->parent);
}
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);
}
if (result)
return result;
if (result)
return result;
}
if (string_equal(sym->identifier, "nil")) {
return create_ast_node_nil();
return create_ast_node_nil();
}
if (string_equal(sym->identifier, "t")) {
return create_ast_node_t();
return create_ast_node_t();
}
result = create_ast_node_built_in_function(sym->identifier);
if (result)
return result;
return result;
create_error(Error_Type_Symbol_Not_Defined, create_ast_node_nil());
/* printf("%s\n", sym->identifier); */
@@ -153,28 +153,28 @@ Ast_Node* lookup_symbol(Symbol* sym, Environment* env) {
}
void print_indent(int indent) {
for (int i = 0; i < indent; ++i) {
printf(" ");
printf(" ");
}
}
void print_environment_indent(Environment* env, int indent) {
for (int i = 0; i < env->next_index; ++i) {
print_indent(indent);
printf("%s -> ", env->keys[i]);
print(env->values[i]);
printf("\n");
print_indent(indent);
printf("%s -> ", env->keys[i]);
print(env->values[i]);
printf("\n");
}
if (env->parent) {
print_indent(indent);
printf("parent");
if (env->parent->type == Environment_Type_Lambda)
printf(" (lambda)");
else if (env->parent->type == Environment_Type_Macro)
printf(" (macro)");
else if (env->parent->type == Environment_Type_Let)
printf(" (let)");
printf(":\n");
print_environment_indent(env->parent, indent+4);
print_indent(indent);
printf("parent");
if (env->parent->type == Environment_Type_Lambda)
printf(" (lambda)");
else if (env->parent->type == Environment_Type_Macro)
printf(" (macro)");
else if (env->parent->type == Environment_Type_Let)
printf(" (let)");
printf(":\n");
print_environment_indent(env->parent, indent+4);
}
}
src/eval.c
+15 -13
View File
@@ -139,20 +139,21 @@ Ast_Node* apply_arguments_to_function(Ast_Node* arguments, Function* function, E
}
}
eval_time:
Ast_Node* result;
eval_time: {
Ast_Node* result;
// don't have to check every time if it is macro environment or
// not
if (function->is_macro)
new_env->type = Environment_Type_Macro;
// don't have to check every time if it is macro environment or
// not
if (function->is_macro)
new_env->type = Environment_Type_Macro;
try {
result = eval_expr(function->body, new_env);
try {
result = eval_expr(function->body, new_env);
}
free(new_env);
return result;
}
free(new_env);
return result;
}
/*
@@ -433,8 +434,8 @@ Ast_Node* eval_expr(Ast_Node* node, Environment* env) {
// just make sure type was not redefined and
// returns something that is not a keyword
if (type->type == Ast_Node_Type_Keyword &&
string_equal(type->value.keyword->identifier, "dynamic-function") ||
string_equal(type->value.keyword->identifier, "dynamic-macro"))
(string_equal(type->value.keyword->identifier, "dynamic-function") ||
string_equal(type->value.keyword->identifier, "dynamic-macro")))
{
Ast_Node* fun = eval_expr(arguments->value.pair->first, env);
printf("\nMacro? %s\n", (fun->value.function->is_macro) ? "yes" : "no");
@@ -866,6 +867,7 @@ Ast_Node* eval_expr(Ast_Node* node, Environment* env) {
}
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");