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

cleanup and sicp file, but crashes

Browse Source
This commit is contained in:
FelixBrendel
2019-04-23 21:20:46 +02:00
parent b978f8b2b2
commit c8807a04b2
11 changed files with 498 additions and 130 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/built_ins.cpp
+33 -10
View File
@@ -61,7 +61,8 @@ proc load_built_ins_into_environment(Environment* env) -> void {
proc parse_lambda_starting_from_args = [&](Lisp_Object* arguments, Environment* env, bool is_special = false) -> Lisp_Object* {
// Function* function = new(Function);
Lisp_Object* ret = Memory::create_lisp_object();
Lisp_Object* ret;
try ret = Memory::create_lisp_object();
Memory::set_type(ret, Lisp_Object_Type::Function);
ret->value.function.parent_environment = env;
@@ -96,7 +97,7 @@ proc load_built_ins_into_environment(Environment* env) -> void {
// we are now in the function body, just wrap it in an
// implicit prog
ret->value.function.body = Memory::create_lisp_object_pair(
try ret->value.function.body = Memory::create_lisp_object_pair(
Memory::get_or_create_lisp_object_symbol("prog"),
arguments);
@@ -207,7 +208,6 @@ proc load_built_ins_into_environment(Environment* env) -> void {
sum += arguments->value.pair.first->value.number;
arguments = arguments->value.pair.rest;
}
return Memory::create_lisp_object_number(sum);
});
defun("-", cLambda {
@@ -217,8 +217,9 @@ proc load_built_ins_into_environment(Environment* env) -> void {
double difference = arguments->value.pair.first->value.number;
if (arguments_length == 1)
if (arguments_length == 1) {
return Memory::create_lisp_object_number(-difference);
}
arguments = arguments->value.pair.rest;
while (Memory::get_type(arguments) == Lisp_Object_Type::Pair) {
@@ -277,6 +278,22 @@ proc load_built_ins_into_environment(Environment* env) -> void {
return Memory::create_lisp_object_number(pow(base, exponent));
});
defun("%", cLambda {
int arguments_length;
try arguments = eval_arguments(arguments, env, &arguments_length);
try assert_arguments_length(2, arguments_length);
try assert_type(arguments->value.pair.first, Lisp_Object_Type::Number);
double a = arguments->value.pair.first->value.number;
arguments = arguments->value.pair.rest;
try assert_type(arguments->value.pair.first, Lisp_Object_Type::Number);
double b = arguments->value.pair.first->value.number;
return Memory::create_lisp_object_number((int)a % (int)b);
});
defun("assert", cLambda {
int arguments_length;
@@ -321,7 +338,8 @@ proc load_built_ins_into_environment(Environment* env) -> void {
try assert_type(real_symbol, Lisp_Object_Type::Symbol);
Lisp_Object* fake_lambda = Memory::create_lisp_object_pair(
Lisp_Object* fake_lambda;
try fake_lambda = Memory::create_lisp_object_pair(
symbol ->value.pair.rest,
arguments->value.pair.rest);
@@ -417,10 +435,11 @@ proc load_built_ins_into_environment(Environment* env) -> void {
//NOTE(Felix): Of fucking course we have to copy the
// list. The quasiquote will be part of the body of a
// funciton, we can't jsut modify it because otherwise
// funciton, we can't just modify it because otherwise
// we modify the body of the function and would bake
// in the result...
Lisp_Object* newPair = Memory::create_lisp_object_pair(nullptr, nullptr);
Lisp_Object* newPair;
try newPair = Memory::create_lisp_object_pair(nullptr, nullptr);
Lisp_Object* newPairHead = newPair;
Lisp_Object* head = expr;
while (Memory::get_type(head) == Lisp_Object_Type::Pair) {
@@ -429,7 +448,7 @@ proc load_built_ins_into_environment(Environment* env) -> void {
if (Memory::get_type(head->value.pair.rest) != Lisp_Object_Type::Pair)
break;
newPairHead->value.pair.rest = Memory::create_lisp_object_pair(nullptr, nullptr);
try newPairHead->value.pair.rest = Memory::create_lisp_object_pair(nullptr, nullptr);
newPairHead = newPairHead->value.pair.rest;
head = head->value.pair.rest;
@@ -604,9 +623,11 @@ proc load_built_ins_into_environment(Environment* env) -> void {
try evaluated_arguments = eval_arguments(arguments, env, &arguments_length);
try assert_arguments_length(2, arguments_length);
return Memory::create_lisp_object_pair(
Lisp_Object* ret;
try ret = Memory::create_lisp_object_pair(
evaluated_arguments->value.pair.first,
evaluated_arguments->value.pair.rest->value.pair.first);
return ret;
});
defun("first", cLambda {
try evaluated_arguments = eval_arguments(arguments, env, &arguments_length);
@@ -658,6 +679,7 @@ proc load_built_ins_into_environment(Environment* env) -> void {
}
Lisp_Object_Type type = Memory::get_type(evaluated_arguments->value.pair.first);
switch (type) {
case Lisp_Object_Type::CFunction: return Memory::get_or_create_lisp_object_keyword("cfunction");
case Lisp_Object_Type::Function: {
@@ -686,7 +708,8 @@ proc load_built_ins_into_environment(Environment* env) -> void {
print(arguments->value.pair.first);
Lisp_Object* type = eval_expr(
Lisp_Object* type;
try type = eval_expr(
Memory::create_lisp_object_pair(
Memory::get_or_create_lisp_object_symbol("type"),
Memory::create_lisp_object_pair(arguments->value.pair.first, Memory::nil)),
src/defines.cpp
+5 -7
View File
@@ -29,7 +29,7 @@ constexpr bool is_debug_build = false;
while (1) \
if (1) { \
if(Globals::error) { \
if (log_level == Log_Level::Debug) { \
if (Globals::log_level == Log_Level::Debug) { \
printf("in %s:%d\n", __FILE__, __LINE__); \
} \
return 0; \
@@ -45,7 +45,7 @@ constexpr bool is_debug_build = false;
while (1) \
if (1) { \
if(Globals::error) { \
if (log_level == Log_Level::Debug) { \
if (Globals::log_level == Log_Level::Debug) { \
printf("in %s:%d\n", __FILE__, __LINE__); \
} \
return; \
@@ -59,15 +59,15 @@ constexpr bool is_debug_build = false;
if (0) \
label(finished,__LINE__): ; \
else \
for (Log_Level log_level_before = log_level;;) \
for(log_level = Log_Level::None;;) \
for (Log_Level log_level_before = Globals::log_level;;) \
for(Globals::log_level = Log_Level::None;;) \
if (1) { \
goto label(body,__LINE__); \
} \
else \
while (1) \
if (1) { \
log_level = log_level_before; \
Globals::log_level = log_level_before; \
goto label(finished,__LINE__); \
} \
else label(body,__LINE__):
@@ -184,7 +184,6 @@ struct {
} \
} while(0)
// TODO(Felix): Shouldn't it be expected > actual here
#define assert_arguments_length_less_equal(expected, actual) \
do { \
if (expected < actual) { \
@@ -192,7 +191,6 @@ struct {
} \
} while(0)
// TODO(Felix): Shouldn't it be expected < actual here
#define assert_arguments_length_greater_equal(expected, actual) \
do { \
if (expected > actual) { \
src/error.cpp
+2 -3
View File
@@ -8,9 +8,8 @@ proc delete_error() -> void {
}
proc create_error(const char* c_file_name, int c_file_line, Lisp_Object* type, String* message) -> void {
if_debug {
printf("Error created in:\n%s:%d\n", c_file_name, c_file_line);
}
printf("Error created in:\n%s:%d\n", c_file_name, c_file_line);
delete_error();
debug_break();
src/eval.cpp
+41 -62
View File
@@ -1,5 +1,6 @@
proc apply_arguments_to_function(Lisp_Object* arguments, Function* function) -> Lisp_Object* {
Environment* new_env = Memory::create_child_environment(function->parent_environment);
Lisp_Object* sym, *val; // used as temp storage to use `try`
// positional arguments
for (int i = 0; i < function->positional_arguments->next_index; ++i) {
@@ -10,9 +11,9 @@ proc apply_arguments_to_function(Lisp_Object* arguments, Function* function) ->
// TODO(Felix): here we create new lisp_object_symbols from
// their identifiers but before we converted them to
// strings from symbols... Wo maybe just use the symbols?
define_symbol(
Memory::get_or_create_lisp_object_symbol(function->positional_arguments->identifiers[i]),
arguments->value.pair.first, new_env);
try sym = Memory::get_or_create_lisp_object_symbol(function->positional_arguments->identifiers[i]);
define_symbol(sym, arguments->value.pair.first, new_env);
arguments = arguments->value.pair.rest;
}
@@ -77,10 +78,8 @@ proc apply_arguments_to_function(Lisp_Object* arguments, Function* function) ->
}
// if not set it and then add it to the array list
define_symbol(
Memory::get_or_create_lisp_object_symbol(arguments->value.pair.first->value.identifier),
arguments->value.pair.rest->value.pair.first,
new_env);
try sym = Memory::get_or_create_lisp_object_symbol(arguments->value.pair.first->value.identifier),
define_symbol(sym, arguments->value.pair.rest->value.pair.first, new_env);
append_to_array_list(read_in_keywords, arguments->value.pair.first->value.identifier);
@@ -119,9 +118,9 @@ proc apply_arguments_to_function(Lisp_Object* arguments, Function* function) ->
// this one does have a default value, lets see if we have
// to use it or if the user supplied his own
if (!was_set) {
define_symbol(
Memory::get_or_create_lisp_object_symbol(defined_keyword),
Memory::copy_lisp_object(function->keyword_arguments->values->data[i]), new_env);
try sym = Memory::get_or_create_lisp_object_symbol(defined_keyword);
try val = Memory::copy_lisp_object(function->keyword_arguments->values->data[i]);
define_symbol(sym, val, new_env);
}
}
}
@@ -129,15 +128,13 @@ proc apply_arguments_to_function(Lisp_Object* arguments, Function* function) ->
if (arguments == Memory::nil) {
if (function->rest_argument) {
define_symbol(
Memory::get_or_create_lisp_object_symbol(function->rest_argument),
Memory::nil, new_env);
try sym = Memory::get_or_create_lisp_object_symbol(function->rest_argument);
define_symbol(sym, Memory::nil, new_env);
}
} else {
if (function->rest_argument) {
define_symbol(
Memory::get_or_create_lisp_object_symbol(function->rest_argument),
arguments, new_env);
try sym = Memory::get_or_create_lisp_object_symbol(function->rest_argument);
define_symbol(sym, arguments, new_env);
} else {
// rest was not declared but additional arguments were found
create_generic_error(
@@ -147,14 +144,9 @@ proc apply_arguments_to_function(Lisp_Object* arguments, Function* function) ->
}
}
Lisp_Object* result;
try {
result = eval_expr(function->body, new_env);
}
try result = eval_expr(function->body, new_env);
return result;
}
/*
@@ -345,19 +337,20 @@ proc eval_arguments(Lisp_Object* arguments, Environment* env, int *out_arguments
return arguments;
}
Lisp_Object* evaluated_arguments = Memory::create_lisp_object_pair(nullptr, nullptr);
Lisp_Object* evaluated_arguments;
try evaluated_arguments = Memory::create_lisp_object_pair(nullptr, nullptr);
Lisp_Object* evaluated_arguments_head = evaluated_arguments;
Lisp_Object* current_head = arguments;
while (Memory::get_type(current_head) == Lisp_Object_Type::Pair) {
try {
evaluated_arguments_head->value.pair.first =
eval_expr(current_head->value.pair.first, env);
}
try evaluated_arguments_head->value.pair.first = eval_expr(current_head->value.pair.first, env);
evaluated_arguments_head->value.pair.first->sourceCodeLocation = current_head->value.pair.first->sourceCodeLocation;
current_head = current_head->value.pair.rest;
if (Memory::get_type(current_head) == Lisp_Object_Type::Pair) {
evaluated_arguments_head->value.pair.rest = Memory::create_lisp_object_pair(nullptr, nullptr);
try evaluated_arguments_head->value.pair.rest = Memory::create_lisp_object_pair(nullptr, nullptr);
evaluated_arguments_head = evaluated_arguments_head->value.pair.rest;
} else if (current_head == Memory::nil) {
evaluated_arguments_head->value.pair.rest = current_head;
@@ -383,9 +376,8 @@ proc eval_expr(Lisp_Object* node, Environment* env) -> Lisp_Object* {
return node;
case Lisp_Object_Type::Symbol: {
Lisp_Object* symbol;
try {
symbol = lookup_symbol(node, env);
}
try symbol = lookup_symbol(node, env);
return symbol;
}
case Lisp_Object_Type::Pair: {
@@ -394,11 +386,9 @@ proc eval_expr(Lisp_Object* node, Environment* env) -> Lisp_Object* {
if (Memory::get_type(node->value.pair.first) != Lisp_Object_Type::CFunction &&
Memory::get_type(node->value.pair.first) != Lisp_Object_Type::Function)
{
try {
lispOperator = eval_expr(node->value.pair.first, env);
}
try lispOperator = eval_expr(node->value.pair.first, env);
} else {
lispOperator = node->value.pair.first;
lispOperator = node->value.pair.first;
}
Lisp_Object* arguments = node->value.pair.rest;
@@ -415,15 +405,11 @@ proc eval_expr(Lisp_Object* node, Environment* env) -> Lisp_Object* {
// only for lambdas we evaluate the arguments before
// apllying
if (lispOperator->value.function.type == Function_Type::Lambda) {
try {
arguments = eval_arguments(arguments, env, &arguments_length);
}
try arguments = eval_arguments(arguments, env, &arguments_length);
}
Lisp_Object* result;
try {
result = apply_arguments_to_function(arguments, &lispOperator->value.function);
}
try result = apply_arguments_to_function(arguments, &lispOperator->value.function);
return result;
}
}
@@ -434,14 +420,10 @@ proc eval_expr(Lisp_Object* node, Environment* env) -> Lisp_Object* {
}
}
proc is_truthy (Lisp_Object* expression, Environment* env) -> bool {
proc is_truthy(Lisp_Object* expression, Environment* env) -> bool {
Lisp_Object* result;
try {
result = eval_expr(expression, env);
}
if (result == Memory::nil)
return false;
return true;
try result = eval_expr(expression, env);
return result != Memory::nil;
}
proc interprete_file (char* file_name) -> Lisp_Object* {
@@ -449,28 +431,25 @@ proc interprete_file (char* file_name) -> Lisp_Object* {
Environment* env = Memory::create_empty_environment();
Parser::init(env);
char* file_content = read_entire_file(file_name);
if (!file_content) {
create_generic_error("The file '%s' could not be read.", file_name);
}
char* file_content;
try file_content = read_entire_file(file_name);
load_built_ins_into_environment(env);
try {
built_in_load(Memory::create_string("pre.slime"), env);
}
built_in_load(Memory::create_string("pre.slime"), env);
Lisp_Object_Array_List* program;
try {
program = Parser::parse_program(
Memory::create_string(file_name), file_content);
}
program = Parser::parse_program(Memory::create_string(file_name), file_content);
Lisp_Object* result = Memory::nil;
for (int i = 0; i < program->next_index; ++i) {
try {
result = eval_expr(program->data[i], env);
}
result = eval_expr(program->data[i], env);
if (Globals::error) {
log_error();
delete_error();
return nullptr;
}
}
return result;
src/forward_decls.cpp
+2 -1
View File
@@ -19,6 +19,7 @@ namespace Memory {
}
namespace Globals {
Log_Level log_level = Log_Level::Debug;
Lisp_Object* current_source_code = nullptr;
Error* error;
Error* error = nullptr;
}
src/io.cpp
+3 -4
View File
@@ -111,6 +111,8 @@ proc read_entire_file(char* filename) -> char* {
}
closeFile:
fclose(fp);
} else {
create_generic_error("The file '%s' could not be read.", filename);
}
return fileContent;
@@ -205,11 +207,8 @@ proc read_line() -> char* {
return linep;
}
Log_Level log_level = Log_Level::Debug;
proc log_message(Log_Level type, char* message) -> void {
if (type > log_level)
if (type > Globals::log_level)
return;
const char* prefix;
src/memory.cpp
+36 -17
View File
@@ -151,11 +151,11 @@ namespace Memory {
next_free_spot_in_string_memory = string_memory;
// init nil
nil = create_lisp_object();
try nil = create_lisp_object();
set_type(nil, Lisp_Object_Type::Nil);
// init t
t = create_lisp_object();
try t = create_lisp_object();
set_type(t, Lisp_Object_Type::T);
}
@@ -167,21 +167,24 @@ namespace Memory {
}
proc create_lisp_object_number(double number) -> Lisp_Object* {
Lisp_Object* node = create_lisp_object();
Lisp_Object* node;
try node = create_lisp_object();
set_type(node, Lisp_Object_Type::Number);
node->value.number = number;
return node;
}
proc create_lisp_object_string(String* str) -> Lisp_Object* {
Lisp_Object* node = create_lisp_object();
Lisp_Object* node;
try node = create_lisp_object();
set_type(node, Lisp_Object_Type::String);
node->value.string = str;
return node;
}
proc create_lisp_object_string(const char* str) -> Lisp_Object* {
Lisp_Object* node = create_lisp_object();
Lisp_Object* node;
try node = create_lisp_object();
set_type(node, Lisp_Object_Type::String);
node->value.string = create_string(str);
return node;
@@ -190,7 +193,8 @@ namespace Memory {
proc get_or_create_lisp_object_symbol(String* identifier) -> Lisp_Object* {
// TODO(Felix): if we already have it stored somewhere then
// reuse it and dont create new one
Lisp_Object* node = create_lisp_object();
Lisp_Object* node;
try node = create_lisp_object();
set_type(node, Lisp_Object_Type::Symbol);
// node->value.symbol = new(Symbol);
node->value.identifier = identifier;
@@ -208,7 +212,8 @@ namespace Memory {
proc get_or_create_lisp_object_keyword(String* keyword) -> Lisp_Object* {
// TODO(Felix): if we already have it stored somewhere then
// reuse it and dont create new one
Lisp_Object* node = create_lisp_object();
Lisp_Object* node;
try node = create_lisp_object();
set_type(node, Lisp_Object_Type::Keyword);
// node->value.keyword = new(Keyword);
node->value.identifier = keyword;
@@ -224,7 +229,8 @@ namespace Memory {
}
proc create_lisp_object_cfunction(std::function<Lisp_Object* (Lisp_Object*, Environment*)> function) -> Lisp_Object* {
Lisp_Object* node = create_lisp_object();
Lisp_Object* node;
try node = create_lisp_object();
set_type(node, Lisp_Object_Type::CFunction);
// node->value.lambdaWrapper = new Lambda_Wrapper(function);
node->value.cFunction = new(cFunction);
@@ -233,7 +239,8 @@ namespace Memory {
}
proc create_lisp_object_pair(Lisp_Object* first, Lisp_Object* rest) -> Lisp_Object* {
Lisp_Object* node = create_lisp_object();
Lisp_Object* node;
try node = create_lisp_object();
set_type(node, Lisp_Object_Type::Pair);
// node->value.pair = new(Pair);
node->value.pair.first = first;
@@ -242,7 +249,8 @@ namespace Memory {
}
proc copy_lisp_object(Lisp_Object* n) -> Lisp_Object* {
Lisp_Object* target = create_lisp_object();
Lisp_Object* target;
try target = create_lisp_object();
*target = *n;
return target;
}
@@ -272,27 +280,38 @@ namespace Memory {
}
inline proc create_list(Lisp_Object* o1) -> Lisp_Object* {
return create_lisp_object_pair(o1, nil);
Lisp_Object* ret;
try ret = create_lisp_object_pair(o1, nil);
return ret;
}
inline proc create_list(Lisp_Object* o1, Lisp_Object* o2) -> Lisp_Object* {
return create_lisp_object_pair(o1, create_list(o2));
Lisp_Object* ret;
try ret = create_lisp_object_pair(o1, create_list(o2));
return ret;
}
inline proc create_list(Lisp_Object* o1, Lisp_Object* o2, Lisp_Object* o3) -> Lisp_Object* {
return create_lisp_object_pair(o1, create_list(o2, o3));
Lisp_Object* ret;
try ret = create_lisp_object_pair(o1, create_list(o2, o3));
return ret;
}
inline proc create_list(Lisp_Object* o1, Lisp_Object* o2, Lisp_Object* o3, Lisp_Object* o4) -> Lisp_Object* {
return create_lisp_object_pair(o1, create_list(o2, o3, o4));
Lisp_Object* ret;
try ret = create_lisp_object_pair(o1, create_list(o2, o3, o4));
return ret;
}
inline proc create_list(Lisp_Object* o1, Lisp_Object* o2, Lisp_Object* o3, Lisp_Object* o4, Lisp_Object* o5) -> Lisp_Object* {
return create_lisp_object_pair(o1, create_list(o2, o3, o4, o5));
Lisp_Object* ret;
try ret = create_lisp_object_pair(o1, create_list(o2, o3, o4, o5));
return ret;
}
inline proc create_list(Lisp_Object* o1, Lisp_Object* o2, Lisp_Object* o3, Lisp_Object* o4, Lisp_Object* o5, Lisp_Object* o6) -> Lisp_Object* {
return create_lisp_object_pair(o1, create_list(o2, o3, o4, o5, o6));
Lisp_Object* ret;
try ret = create_lisp_object_pair(o1, create_list(o2, o3, o4, o5, o6));
return ret;
}
}
src/parse.cpp
+25 -15
View File
@@ -111,7 +111,8 @@ namespace Parser {
// dont create a String first
String* str_number = read_atom(text, index_in_text);
sscanf(Memory::get_c_str(str_number), "%lf", &number);
Lisp_Object* ret = Memory::create_lisp_object_number(number);
Lisp_Object* ret;
try ret = Memory::create_lisp_object_number(number);
inject_scl(ret);
return ret;
@@ -122,7 +123,8 @@ namespace Parser {
++(*index_in_text);
++parser_col;
String* str_keyword = read_atom(text, index_in_text);
Lisp_Object* ret = Memory::get_or_create_lisp_object_keyword(str_keyword);
Lisp_Object* ret;
try ret = Memory::get_or_create_lisp_object_keyword(str_keyword);
inject_scl(ret);
return ret;
@@ -131,7 +133,9 @@ namespace Parser {
proc parse_symbol(char* text, int* index_in_text) -> Lisp_Object* {
// we are now at the first char of the symbol
String* str_symbol = read_atom(text, index_in_text);
Lisp_Object* ret = Memory::get_or_create_lisp_object_symbol(str_symbol);
Lisp_Object* ret;
try ret = Memory::get_or_create_lisp_object_symbol(str_symbol);
inject_scl(ret);
return ret;
}
@@ -144,7 +148,8 @@ namespace Parser {
// now we are at the first letter, if this is the closing '"' then
// it's easy
if (text[*index_in_text] == '"') {
Lisp_Object* ret = Memory::create_lisp_object_string(
Lisp_Object* ret;
try ret = Memory::create_lisp_object_string(
Memory::create_string("", 0));
inject_scl(ret);
@@ -200,7 +205,9 @@ namespace Parser {
}
}
Lisp_Object* ret = Memory::create_lisp_object_string(string);
Lisp_Object* ret;
try ret = Memory::create_lisp_object_string(string);
inject_scl(ret);
return ret;
}
@@ -259,16 +266,17 @@ namespace Parser {
}
Lisp_Object* ret = nullptr;
// TODO(Felix): use Memory::create_list() here
if (quoteType == '\'')
ret = Memory::create_lisp_object_pair(
try ret = Memory::create_lisp_object_pair(
Memory::get_or_create_lisp_object_symbol("quote"),
Memory::create_lisp_object_pair(result, Memory::nil));
else if (quoteType == '`')
ret = Memory::create_lisp_object_pair(
try ret = Memory::create_lisp_object_pair(
Memory::get_or_create_lisp_object_symbol("quasiquote"),
Memory::create_lisp_object_pair(result, Memory::nil));
else if (quoteType == ',')
ret = Memory::create_lisp_object_pair(
try ret = Memory::create_lisp_object_pair(
Memory::get_or_create_lisp_object_symbol("unquote"),
Memory::create_lisp_object_pair(result, Memory::nil));
inject_scl(ret);
@@ -291,7 +299,8 @@ namespace Parser {
}
// okay there is something
Lisp_Object* head = Memory::create_lisp_object();
Lisp_Object* head;
try head = Memory::create_lisp_object();
Memory::set_type(head, Lisp_Object_Type::Pair);
// head->value.pair = new(Pair);
Lisp_Object* expression = head;
@@ -346,7 +355,7 @@ namespace Parser {
++(*index_in_text);
break;
} else {
head->value.pair.rest = Memory::create_lisp_object_pair(nullptr, nullptr);
try head->value.pair.rest = Memory::create_lisp_object_pair(nullptr, nullptr);
head = head->value.pair.rest;
}
}
@@ -377,7 +386,8 @@ namespace Parser {
arguments = arguments->value.pair.first->value.pair.rest;
// Function* function = new(Function);
Lisp_Object* macro = Memory::create_lisp_object();
Lisp_Object* macro;
try macro = Memory::create_lisp_object();
Memory::set_type(macro, Lisp_Object_Type::Function);
macro->value.function.parent_environment = environment_for_macros;
macro->value.function.type = Function_Type::Macro;
@@ -403,7 +413,7 @@ namespace Parser {
// we are now in the function body, just wrap it in an
// implicit prog
macro->value.function.body = Memory::create_lisp_object_pair(
try macro->value.function.body = Memory::create_lisp_object_pair(
Memory::get_or_create_lisp_object_symbol("prog"),
body);
@@ -510,12 +520,12 @@ namespace Parser {
++end_pos;
text[end_pos] = '\0';
Lisp_Object* str = Memory::create_lisp_object_string(
Lisp_Object* str;
try str = Memory::create_lisp_object_string(
Memory::create_string(text+index_in_text));
text[end_pos] = '\n';
return Memory::create_list(
Memory::get_or_create_lisp_object_symbol(bare), str);
return Memory::create_list(Memory::get_or_create_lisp_object_symbol(bare), str);
}
}
src/testing.cpp
+2 -3
View File
@@ -501,7 +501,7 @@ proc test_file(const char* file) -> testresult {
}
proc run_all_tests() -> bool {
Memory::init(4096 * 2, 4096 * 16);
Memory::init(4096 * 2000, 4096 * 16);
Parser::init(Memory::create_built_ins_environment());
bool result = true;
@@ -527,12 +527,11 @@ proc run_all_tests() -> bool {
printf("\n-- Memory management --\n");
invoke_test(test_singular_t_and_nil);
printf("\n-- Macros --\n");
printf("\n-- Test Files --\n");
invoke_test_script("lexical_scope");
invoke_test_script("class_macro");
invoke_test_script("sicp");
return result;
}