felix
/
slime
1
0
Rozštěpit 0
Zdrojový kód Úkoly 0 Požadavky na natažení 0 Vydání 0 Wiki Aktivita
Procházet zdrojové kódy

I think I did Lisp_Object SSO

master
FelixBrendel před 7 roky
rodič
9f2b25486c
revize
d6ecda99f6
10 změnil soubory, kde provedl 386 přidání a 501 odebrání
Rozdělené zobrazení
Diff Options
Zobrazit statistiky Stáhněte soubor opravy Stáhněte rozdílový soubor
  1. +1
    -1
      bin/tests/lexical_scope.slime.expanded
  2. +189
    -219
      src/built_ins.cpp
  3. +8
    -8
      src/env.cpp
  4. +53
    -53
      src/eval.cpp
  5. +22
    -93
      src/io.cpp
  6. +8
    -25
      src/memory.cpp
  7. +41
    -48
      src/parse.cpp
  8. +8
    -9
      src/structs.cpp
  9. +45
    -45
      src/testing.cpp
  10. +11
    -0
      todo.org

+ 1
- 1
bin/tests/lexical_scope.slime.expanded Zobrazit soubor

@@ -1,4 +1,4 @@
(define (make-counter) (let ((var 0.000000)) (lambda nil (mutate var (+ 1.000000 var)) var)))
(define (make-counter) (let ((var 0.000000)) (lambda () (mutate var (+ 1.000000 var)) var)))

(define counter1 (make-counter))



+ 189
- 219
src/built_ins.cpp Zobrazit soubor

@@ -16,24 +16,20 @@ proc lisp_object_equal(Lisp_Object* n1, Lisp_Object* n2) -> bool {
return false;
case Lisp_Object_Type::Keyword:
return string_equal(
n1->value.keyword->identifier,
n2->value.keyword->identifier);
n1->value.identifier,
n2->value.identifier);
case Lisp_Object_Type::T:
case Lisp_Object_Type::Nil:
return true;
case Lisp_Object_Type::Number:
return
n1->value.number->value ==
n2->value.number->value;
return n1->value.number == n2->value.number;
case Lisp_Object_Type::Pair:
create_error(Error_Type::Not_Yet_Implemented, n1->sourceCodeLocation);
return false;
case Lisp_Object_Type::String:
return string_equal(n1->value.string, n2->value.string);
case Lisp_Object_Type::Symbol:
return string_equal(
n1->value.symbol->identifier,
n2->value.symbol->identifier);
return string_equal(n1->value.identifier, n2->value.identifier);
}

// we should never reach here
@@ -80,43 +76,49 @@ proc load_built_ins_into_environment(Environment* env) -> void {
env);
};

proc parse_lambda_starting_from_args = [&](Lisp_Object* arguments, Environment* env) -> Lisp_Object* {
Function* function = new(Function);
function->parent_environment = env;
function->type = Function_Type::Lambda;
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();
ret->type = Lisp_Object_Type::Function;

ret->value.function.parent_environment = env;

if (is_special)
ret->value.function.type = Function_Type::Special_Lambda;
else
ret->value.function.type = Function_Type::Lambda;

// if parameters were specified
if (arguments->value.pair->first->type != Lisp_Object_Type::Nil) {
if (arguments->value.pair.first->type != Lisp_Object_Type::Nil) {
try {
assert_type(arguments->value.pair->first, Lisp_Object_Type::Pair);
assert_type(arguments->value.pair.first, Lisp_Object_Type::Pair);
}
try {
parse_argument_list(arguments->value.pair->first, function);
parse_argument_list(arguments->value.pair.first, &ret->value.function);
}
} else {
function->positional_arguments = create_positional_argument_list(1);
function->keyword_arguments = create_keyword_argument_list(1);
function->rest_argument = nullptr;
ret->value.function.positional_arguments = create_positional_argument_list(1);
ret->value.function.keyword_arguments = create_keyword_argument_list(1);
ret->value.function.rest_argument = nullptr;
}

arguments = arguments->value.pair->rest;
arguments = arguments->value.pair.rest;
// if there is a docstring, use it
if (arguments->value.pair->first->type == Lisp_Object_Type::String) {
function->docstring = arguments->value.pair->first->value.string;
arguments = arguments->value.pair->rest;
if (arguments->value.pair.first->type == Lisp_Object_Type::String) {
ret->value.function.docstring = arguments->value.pair.first->value.string;
arguments = arguments->value.pair.rest;
} else {
function->docstring = nullptr;
ret->value.function.docstring = nullptr;
}

// we are now in the function body, just wrap it in an
// implicit prog
function->body = Memory::create_lisp_object_pair(
ret->value.function.body = Memory::create_lisp_object_pair(
Memory::get_or_create_lisp_object_symbol("prog"),
arguments);

Lisp_Object* ret = Memory::create_lisp_object();
ret->type = Lisp_Object_Type::Function;
ret->value.function = function;

// ret->value.function = function;
return ret;
};

@@ -129,12 +131,12 @@ proc load_built_ins_into_environment(Environment* env) -> void {
if (arguments->type == Lisp_Object_Type::Nil)
return Memory::t;

Lisp_Object* first = arguments->value.pair->first;
Lisp_Object* first = arguments->value.pair.first;

while (arguments->type == Lisp_Object_Type::Pair) {
if (!lisp_object_equal(arguments->value.pair->first, first))
if (!lisp_object_equal(arguments->value.pair.first, first))
return Memory::nil;
arguments = arguments->value.pair->rest;
arguments = arguments->value.pair.rest;
}

return Memory::t;
@@ -149,14 +151,14 @@ proc load_built_ins_into_environment(Environment* env) -> void {

while (arguments->type == Lisp_Object_Type::Pair) {
try {
assert_type(arguments->value.pair->first, Lisp_Object_Type::Number);
assert_type(arguments->value.pair.first, Lisp_Object_Type::Number);
}

if (arguments->value.pair->first->value.number->value >= last_number)
if (arguments->value.pair.first->value.number >= last_number)
return Memory::nil;

last_number = arguments->value.pair->first->value.number->value;
arguments = arguments->value.pair->rest;
last_number = arguments->value.pair.first->value.number;
arguments = arguments->value.pair.rest;
}

return Memory::t;
@@ -171,14 +173,14 @@ proc load_built_ins_into_environment(Environment* env) -> void {

while (arguments->type == Lisp_Object_Type::Pair) {
try {
assert_type(arguments->value.pair->first, Lisp_Object_Type::Number);
assert_type(arguments->value.pair.first, Lisp_Object_Type::Number);
}

if (arguments->value.pair->first->value.number->value > last_number)
if (arguments->value.pair.first->value.number > last_number)
return Memory::nil;

last_number = arguments->value.pair->first->value.number->value;
arguments = arguments->value.pair->rest;
last_number = arguments->value.pair.first->value.number;
arguments = arguments->value.pair.rest;
}

return Memory::t;
@@ -193,14 +195,14 @@ proc load_built_ins_into_environment(Environment* env) -> void {

while (arguments->type == Lisp_Object_Type::Pair) {
try {
assert_type(arguments->value.pair->first, Lisp_Object_Type::Number);
assert_type(arguments->value.pair.first, Lisp_Object_Type::Number);
}

if (arguments->value.pair->first->value.number->value <= last_number)
if (arguments->value.pair.first->value.number <= last_number)
return Memory::nil;

last_number = arguments->value.pair->first->value.number->value;
arguments = arguments->value.pair->rest;
last_number = arguments->value.pair.first->value.number;
arguments = arguments->value.pair.rest;
}

return Memory::t;
@@ -215,14 +217,14 @@ proc load_built_ins_into_environment(Environment* env) -> void {

while (arguments->type == Lisp_Object_Type::Pair) {
try {
assert_type(arguments->value.pair->first, Lisp_Object_Type::Number);
assert_type(arguments->value.pair.first, Lisp_Object_Type::Number);
}

if (arguments->value.pair->first->value.number->value < last_number)
if (arguments->value.pair.first->value.number < last_number)
return Memory::nil;

last_number = arguments->value.pair->first->value.number->value;
arguments = arguments->value.pair->rest;
last_number = arguments->value.pair.first->value.number;
arguments = arguments->value.pair.rest;
}

return Memory::t;
@@ -236,10 +238,10 @@ proc load_built_ins_into_environment(Environment* env) -> void {
double sum = 0;
while (arguments->type == Lisp_Object_Type::Pair) {
try {
assert_type(arguments->value.pair->first, Lisp_Object_Type::Number);
assert_type(arguments->value.pair.first, Lisp_Object_Type::Number);
}
sum += arguments->value.pair->first->value.number->value;
arguments = arguments->value.pair->rest;
sum += arguments->value.pair.first->value.number;
arguments = arguments->value.pair.rest;
}

return Memory::create_lisp_object_number(sum);
@@ -251,18 +253,18 @@ proc load_built_ins_into_environment(Environment* env) -> void {
}

try {
assert_type(arguments->value.pair->first, Lisp_Object_Type::Number);
assert_type(arguments->value.pair.first, Lisp_Object_Type::Number);
}
double difference = arguments->value.pair->first->value.number->value;
double difference = arguments->value.pair.first->value.number;

arguments = arguments->value.pair->rest;
arguments = arguments->value.pair.rest;
while (arguments->type == Lisp_Object_Type::Pair) {
try {
assert_type(arguments->value.pair->first, Lisp_Object_Type::Number);
assert_type(arguments->value.pair.first, Lisp_Object_Type::Number);
}

difference -= arguments->value.pair->first->value.number->value;
arguments = arguments->value.pair->rest;
difference -= arguments->value.pair.first->value.number;
arguments = arguments->value.pair.rest;
}
return Memory::create_lisp_object_number(difference);
});
@@ -273,18 +275,18 @@ proc load_built_ins_into_environment(Environment* env) -> void {
}

try {
assert_type(arguments->value.pair->first, Lisp_Object_Type::Number);
assert_type(arguments->value.pair.first, Lisp_Object_Type::Number);
}
double product = arguments->value.pair->first->value.number->value;
double product = arguments->value.pair.first->value.number;

arguments = arguments->value.pair->rest;
arguments = arguments->value.pair.rest;
while (arguments->type == Lisp_Object_Type::Pair) {
try {
assert_type(arguments->value.pair->first, Lisp_Object_Type::Number);
assert_type(arguments->value.pair.first, Lisp_Object_Type::Number);
}

product *= arguments->value.pair->first->value.number->value;
arguments = arguments->value.pair->rest;
product *= arguments->value.pair.first->value.number;
arguments = arguments->value.pair.rest;
}
return Memory::create_lisp_object_number(product);
});
@@ -295,18 +297,18 @@ proc load_built_ins_into_environment(Environment* env) -> void {
}

try {
assert_type(arguments->value.pair->first, Lisp_Object_Type::Number);
assert_type(arguments->value.pair.first, Lisp_Object_Type::Number);
}
double quotient = arguments->value.pair->first->value.number->value;
double quotient = arguments->value.pair.first->value.number;

arguments = arguments->value.pair->rest;
arguments = arguments->value.pair.rest;
while (arguments->type == Lisp_Object_Type::Pair) {
try {
assert_type(arguments->value.pair->first, Lisp_Object_Type::Number);
assert_type(arguments->value.pair.first, Lisp_Object_Type::Number);
}

quotient /= arguments->value.pair->first->value.number->value;
arguments = arguments->value.pair->rest;
quotient /= arguments->value.pair.first->value.number;
arguments = arguments->value.pair.rest;
}
return Memory::create_lisp_object_number(quotient);
});
@@ -322,18 +324,18 @@ proc load_built_ins_into_environment(Environment* env) -> void {
}

try {
assert_type(arguments->value.pair->first, Lisp_Object_Type::Number);
assert_type(arguments->value.pair.first, Lisp_Object_Type::Number);
}

double base = arguments->value.pair->first->value.number->value;
double base = arguments->value.pair.first->value.number;

arguments = arguments->value.pair->rest;
arguments = arguments->value.pair.rest;

try {
assert_type(arguments->value.pair->first, Lisp_Object_Type::Number);
assert_type(arguments->value.pair.first, Lisp_Object_Type::Number);
}

double exponent = arguments->value.pair->first->value.number->value;
double exponent = arguments->value.pair.first->value.number;

return Memory::create_lisp_object_number(pow(base, exponent));
});
@@ -348,7 +350,7 @@ proc load_built_ins_into_environment(Environment* env) -> void {
report_error(Error_Type::Wrong_Number_Of_Arguments);
}

if (is_truthy(arguments->value.pair->first, env))
if (is_truthy(arguments->value.pair.first, env))
return Memory::t;

report_error(Error_Type::Assertion_Error);
@@ -363,7 +365,7 @@ proc load_built_ins_into_environment(Environment* env) -> void {
report_error(Error_Type::Wrong_Number_Of_Arguments);
}

Lisp_Object* symbol = arguments->value.pair->first;
Lisp_Object* symbol = arguments->value.pair.first;
Lisp_Object* value;

if (symbol->type == Lisp_Object_Type::Pair) {
@@ -386,15 +388,15 @@ proc load_built_ins_into_environment(Environment* env) -> void {
f(3) x
*/

Lisp_Object* real_symbol = symbol->value.pair->first;
Lisp_Object* real_symbol = symbol->value.pair.first;

try {
assert_type(real_symbol, Lisp_Object_Type::Symbol);
}

Lisp_Object* fake_lambda = Memory::create_lisp_object_pair(
symbol ->value.pair->rest,
arguments->value.pair->rest);
symbol ->value.pair.rest,
arguments->value.pair.rest);

value = parse_lambda_starting_from_args(fake_lambda, env);
symbol = real_symbol;
@@ -406,7 +408,7 @@ proc load_built_ins_into_environment(Environment* env) -> void {
report_error(Error_Type::Type_Missmatch);
}

value = arguments->value.pair->rest->value.pair->first;
value = arguments->value.pair.rest->value.pair.first;
try {
value = eval_expr(value, env);
}
@@ -425,7 +427,7 @@ proc load_built_ins_into_environment(Environment* env) -> void {
// report_error(Error_Type::Wrong_Number_Of_Arguments);
// }

// Lisp_Object* symbol = arguments->value.pair->first;
// Lisp_Object* symbol = arguments->value.pair.first;

// if (symbol->type == Lisp_Object_Type::Pair) {
// try {
@@ -442,7 +444,7 @@ proc load_built_ins_into_environment(Environment* env) -> void {
// }


// Lisp_Object* value = arguments->value.pair->rest->value.pair->first;
// Lisp_Object* value = arguments->value.pair.rest->value.pair.first;
// try {
// value = eval_expr(value, env);
// }
@@ -459,14 +461,14 @@ proc load_built_ins_into_environment(Environment* env) -> void {
if (arguments_length != 2)
report_error(Error_Type::Wrong_Number_Of_Arguments);

if (evaluated_arguments->value.pair->first->type == Lisp_Object_Type::Nil ||
evaluated_arguments->value.pair->first->type == Lisp_Object_Type::Keyword)
if (evaluated_arguments->value.pair.first->type == Lisp_Object_Type::Nil ||
evaluated_arguments->value.pair.first->type == Lisp_Object_Type::Keyword)
{
report_error(Error_Type::Type_Missmatch);
}

Lisp_Object* target = evaluated_arguments->value.pair->first;
Lisp_Object* source = evaluated_arguments->value.pair->rest->value.pair->first;
Lisp_Object* target = evaluated_arguments->value.pair.first;
Lisp_Object* source = evaluated_arguments->value.pair.rest->value.pair.first;

*target = *source;
return target;
@@ -480,9 +482,9 @@ proc load_built_ins_into_environment(Environment* env) -> void {
report_error(Error_Type::Wrong_Number_Of_Arguments);
}

Lisp_Object* condition = arguments->value.pair->first;
Lisp_Object* then_part = arguments->value.pair->rest;
Lisp_Object* else_part = then_part->value.pair->rest;
Lisp_Object* condition = arguments->value.pair.first;
Lisp_Object* then_part = arguments->value.pair.rest;
Lisp_Object* else_part = then_part->value.pair.rest;

bool truthy;
try {
@@ -493,11 +495,11 @@ proc load_built_ins_into_environment(Environment* env) -> void {

if (truthy)
try{
result = eval_expr(then_part->value.pair->first, env);
result = eval_expr(then_part->value.pair.first, env);
}
else if (arguments_length == 3)
try {
result = eval_expr(else_part->value.pair->first, env);
result = eval_expr(else_part->value.pair.first, env);
}
else return Memory::nil;
return result;
@@ -511,7 +513,7 @@ proc load_built_ins_into_environment(Environment* env) -> void {
report_error(Error_Type::Wrong_Number_Of_Arguments);
}

return arguments->value.pair->first;
return arguments->value.pair.first;
});
defun("quasiquote", cLambda {
try {
@@ -535,12 +537,12 @@ proc load_built_ins_into_environment(Environment* env) -> void {
return Memory::copy_lisp_object(expr);

// it is a pair!
Lisp_Object* originalPair = expr->value.pair->first;
Lisp_Object* originalPair = expr->value.pair.first;
if (originalPair->type == Lisp_Object_Type::Symbol &&
string_equal(originalPair->value.symbol->identifier, "unquote"))
string_equal(originalPair->value.identifier, "unquote"))
{
// eval replace the stuff
return eval_expr(expr->value.pair->rest->value.pair->first, env);
return eval_expr(expr->value.pair.rest->value.pair.first, env);
}

// it is a list but not starting with the symbol
@@ -556,22 +558,22 @@ proc load_built_ins_into_environment(Environment* env) -> void {
Lisp_Object* newPairHead = newPair;
Lisp_Object* head = expr;
while (head->type == Lisp_Object_Type::Pair) {
newPairHead->value.pair->first = unquoteSomeExpressions(head->value.pair->first);
newPairHead->value.pair.first = unquoteSomeExpressions(head->value.pair.first);

if (head->value.pair->rest->type != Lisp_Object_Type::Pair)
if (head->value.pair.rest->type != Lisp_Object_Type::Pair)
break;

newPairHead->value.pair->rest = Memory::create_lisp_object_pair(nullptr, nullptr);
newPairHead->value.pair.rest = Memory::create_lisp_object_pair(nullptr, nullptr);

newPairHead = newPairHead->value.pair->rest;
head = head->value.pair->rest;
newPairHead = newPairHead->value.pair.rest;
head = head->value.pair.rest;
}
newPairHead->value.pair->rest = Memory::nil;
newPairHead->value.pair.rest = Memory::nil;

return newPair;
};

Lisp_Object* ret = arguments->value.pair->first;
Lisp_Object* ret = arguments->value.pair.first;
Lisp_Object* head = ret;

ret = unquoteSomeExpressions(ret);
@@ -584,9 +586,9 @@ proc load_built_ins_into_environment(Environment* env) -> void {
report_error(Error_Type::Ill_Formed_List);
}
try {
result &= is_truthy(arguments->value.pair->first, env);
result &= is_truthy(arguments->value.pair.first, env);
}
arguments = arguments->value.pair->rest;
arguments = arguments->value.pair.rest;

if (!result) return Memory::nil;
}
@@ -600,9 +602,9 @@ proc load_built_ins_into_environment(Environment* env) -> void {
report_error(Error_Type::Ill_Formed_List);
}
try {
result |= is_truthy(arguments->value.pair->first, env);
result |= is_truthy(arguments->value.pair.first, env);
}
arguments = arguments->value.pair->rest;
arguments = arguments->value.pair.rest;

if (result) return Memory::t;
}
@@ -619,7 +621,7 @@ proc load_built_ins_into_environment(Environment* env) -> void {
}
bool truthy;
try {
truthy = is_truthy(arguments->value.pair->first, env);
truthy = is_truthy(arguments->value.pair.first, env);
}
if (truthy)
return Memory::nil;
@@ -633,9 +635,9 @@ proc load_built_ins_into_environment(Environment* env) -> void {
if (arguments_length < 2) {
report_error(Error_Type::Wrong_Number_Of_Arguments);
}
Lisp_Object* condition_part = arguments->value.pair->first;
Lisp_Object* condition_part = arguments->value.pair.first;
Lisp_Object* condition;
Lisp_Object* then_part = arguments->value.pair->rest;
Lisp_Object* then_part = arguments->value.pair.rest;
Lisp_Object* result = Memory::nil;

while (true) {
@@ -646,7 +648,7 @@ proc load_built_ins_into_environment(Environment* env) -> void {
break;
}
try {
result = eval_expr(then_part->value.pair->first, env);
result = eval_expr(then_part->value.pair.first, env);
}
}
return result;
@@ -662,7 +664,7 @@ proc load_built_ins_into_environment(Environment* env) -> void {
report_error(Error_Type::Wrong_Number_Of_Arguments);

Environment* let_env = Memory::create_child_environment(env);
Lisp_Object* bindings = arguments->value.pair->first;
Lisp_Object* bindings = arguments->value.pair.first;
while (true) {
if (bindings->type == Lisp_Object_Type::Nil) {
break;
@@ -670,29 +672,29 @@ proc load_built_ins_into_environment(Environment* env) -> void {
report_error(Error_Type::Ill_Formed_Arguments);
}

Lisp_Object* sym = bindings->value.pair->first->value.pair->first;
Lisp_Object* sym = bindings->value.pair.first->value.pair.first;
if(sym->type != Lisp_Object_Type::Symbol) {
report_error(Error_Type::Ill_Formed_Arguments);
}
Lisp_Object* rest_sym = bindings->value.pair->first->value.pair->rest;
Lisp_Object* rest_sym = bindings->value.pair.first->value.pair.rest;
if (rest_sym->type != Lisp_Object_Type::Pair) {
report_error(Error_Type::Ill_Formed_Arguments);
}
if (rest_sym->value.pair->rest->type != Lisp_Object_Type::Nil) {
if (rest_sym->value.pair.rest->type != Lisp_Object_Type::Nil) {
report_error(Error_Type::Ill_Formed_Arguments);
}

Lisp_Object* value = eval_expr(rest_sym->value.pair->first, env);
Lisp_Object* value = eval_expr(rest_sym->value.pair.first, env);

// NOTE(Felix): We have to copy the value here because
// if the let body modifies the value, it would bake
// in... bad bad...
define_symbol(sym, Memory::copy_lisp_object(value), let_env);

bindings = bindings->value.pair->rest;
bindings = bindings->value.pair.rest;
}

arguments = arguments->value.pair->rest;
arguments = arguments->value.pair.rest;

Lisp_Object* evaluated_arguments;
try {
@@ -707,10 +709,10 @@ proc load_built_ins_into_environment(Environment* env) -> void {
// 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 == Lisp_Object_Type::Pair) {
evaluated_arguments = evaluated_arguments->value.pair->rest;
while (evaluated_arguments->value.pair.rest->type == Lisp_Object_Type::Pair) {
evaluated_arguments = evaluated_arguments->value.pair.rest;
}
return evaluated_arguments->value.pair->first;
return evaluated_arguments->value.pair.first;
});
defun("lambda", cLambda {
/* TODO(Felix): first one crashes
@@ -742,43 +744,11 @@ proc load_built_ins_into_environment(Environment* env) -> void {
if (arguments_length == 0)
report_error(Error_Type::Wrong_Number_Of_Arguments);

Function* function = new(Function);
function->parent_environment = env;
function->type = Function_Type::Special_Lambda;

// if parameters were specified
if (arguments->value.pair->first->type != Lisp_Object_Type::Nil) {
try {
assert_type(arguments->value.pair->first, Lisp_Object_Type::Pair);
}
try {
parse_argument_list(arguments->value.pair->first, function);
}
} else {
function->positional_arguments = create_positional_argument_list(1);
function->keyword_arguments = create_keyword_argument_list(1);
function->rest_argument = nullptr;
}

arguments = arguments->value.pair->rest;
// if there is a docstring, use it
if (arguments->value.pair->first->type == Lisp_Object_Type::String) {
function->docstring = arguments->value.pair->first->value.string;
arguments = arguments->value.pair->rest;
} else {
function->docstring = nullptr;
}
Lisp_Object* function = parse_lambda_starting_from_args(arguments, env, true);
// parse lambda starting from arguments

// we are now in the function body, just wrap it in an
// implicit prog
function->body = Memory::create_lisp_object_pair(
Memory::get_or_create_lisp_object_symbol("prog"),
arguments);

Lisp_Object* ret = Memory::create_lisp_object();
ret->type = Lisp_Object_Type::Function;
ret->value.function = function;
return ret;
return function;
});
defun("eval", cLambda {
try {
@@ -789,7 +759,7 @@ proc load_built_ins_into_environment(Environment* env) -> void {
}
Lisp_Object* result;
try {
result = eval_expr(evaluated_arguments->value.pair->first, env);
result = eval_expr(evaluated_arguments->value.pair.first, env);
}
return result;
});
@@ -808,10 +778,10 @@ proc load_built_ins_into_environment(Environment* env) -> void {
// 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 == Lisp_Object_Type::Pair) {
evaluated_arguments = evaluated_arguments->value.pair->rest;
while (evaluated_arguments->value.pair.rest->type == Lisp_Object_Type::Pair) {
evaluated_arguments = evaluated_arguments->value.pair.rest;
}
return evaluated_arguments->value.pair->first;
return evaluated_arguments->value.pair.first;
});
defun("list", cLambda {
try {
@@ -827,7 +797,7 @@ proc load_built_ins_into_environment(Environment* env) -> void {
if (arguments_length != 2) {
report_error(Error_Type::Wrong_Number_Of_Arguments);
}
return Memory::create_lisp_object_pair(evaluated_arguments->value.pair->first, evaluated_arguments->value.pair->rest->value.pair->first);
return Memory::create_lisp_object_pair(evaluated_arguments->value.pair.first, evaluated_arguments->value.pair.rest->value.pair.first);
});
defun("first", cLambda {
try {
@@ -836,12 +806,12 @@ proc load_built_ins_into_environment(Environment* env) -> void {
if (arguments_length != 1) {
report_error(Error_Type::Wrong_Number_Of_Arguments);
}
if (evaluated_arguments->value.pair->first->type == Lisp_Object_Type::Nil)
if (evaluated_arguments->value.pair.first->type == Lisp_Object_Type::Nil)
return Memory::nil;
if (evaluated_arguments->value.pair->first->type != Lisp_Object_Type::Pair)
if (evaluated_arguments->value.pair.first->type != Lisp_Object_Type::Pair)
report_error(Error_Type::Type_Missmatch);

return evaluated_arguments->value.pair->first->value.pair->first;
return evaluated_arguments->value.pair.first->value.pair.first;
});
defun("rest", cLambda {
try {
@@ -850,12 +820,12 @@ proc load_built_ins_into_environment(Environment* env) -> void {
if (arguments_length != 1) {
report_error(Error_Type::Wrong_Number_Of_Arguments);
}
if (evaluated_arguments->value.pair->first->type == Lisp_Object_Type::Nil)
if (evaluated_arguments->value.pair.first->type == Lisp_Object_Type::Nil)
return Memory::nil;
if (evaluated_arguments->value.pair->first->type != Lisp_Object_Type::Pair)
if (evaluated_arguments->value.pair.first->type != Lisp_Object_Type::Pair)
report_error(Error_Type::Type_Missmatch);

return evaluated_arguments->value.pair->first->value.pair->rest;
return evaluated_arguments->value.pair.first->value.pair.rest;
});
defun("set-type", cLambda {
try {
@@ -865,14 +835,14 @@ proc load_built_ins_into_environment(Environment* env) -> void {
report_error(Error_Type::Wrong_Number_Of_Arguments);
}

Lisp_Object* object = evaluated_arguments->value.pair->first;
Lisp_Object* type = evaluated_arguments->value.pair->rest->value.pair->first;
Lisp_Object* object = evaluated_arguments->value.pair.first;
Lisp_Object* type = evaluated_arguments->value.pair.rest->value.pair.first;

try {
assert_type(type, Lisp_Object_Type::Keyword);
}

evaluated_arguments->value.pair->first->userType = type;
evaluated_arguments->value.pair.first->userType = type;
return type;
});
defun("delete-type", cLambda {
@@ -882,7 +852,7 @@ proc load_built_ins_into_environment(Environment* env) -> void {
if (arguments_length != 1) {
report_error(Error_Type::Wrong_Number_Of_Arguments);
}
evaluated_arguments->value.pair->first->userType = nullptr;
evaluated_arguments->value.pair.first->userType = nullptr;
return Memory::t;
});
defun("type", cLambda {
@@ -893,15 +863,15 @@ proc load_built_ins_into_environment(Environment* env) -> void {
report_error(Error_Type::Wrong_Number_Of_Arguments);
}

if (evaluated_arguments->value.pair->first->userType) {
return evaluated_arguments->value.pair->first->userType;
if (evaluated_arguments->value.pair.first->userType) {
return evaluated_arguments->value.pair.first->userType;
}

Lisp_Object_Type type = evaluated_arguments->value.pair->first->type;
Lisp_Object_Type type = evaluated_arguments->value.pair.first->type;
switch (type) {
case Lisp_Object_Type::CFunction: return Memory::get_or_create_lisp_object_keyword("cfunction");
case Lisp_Object_Type::Function: {
Function* fun = evaluated_arguments->value.pair->first->value.function;
Function* fun = &evaluated_arguments->value.pair.first->value.function;
if (fun->type == Function_Type::Lambda)
return Memory::get_or_create_lisp_object_keyword("lambda");
else if (fun->type == Function_Type::Special_Lambda)
@@ -929,12 +899,12 @@ proc load_built_ins_into_environment(Environment* env) -> void {
report_error(Error_Type::Wrong_Number_Of_Arguments);
}

print(arguments->value.pair->first);
print(arguments->value.pair.first);

Lisp_Object* 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)),
Memory::create_lisp_object_pair(arguments->value.pair.first, Memory::nil)),
env);

if (type) {
@@ -944,52 +914,52 @@ proc load_built_ins_into_environment(Environment* env) -> void {

// TODO(Felix): Maybe don't compare strings here?? Wtf
if (type->type == Lisp_Object_Type::Keyword &&
(string_equal(type->value.keyword->identifier, "lambda") ||
string_equal(type->value.keyword->identifier, "special-lambda") ||
string_equal(type->value.keyword->identifier, "macro")))
(string_equal(type->value.identifier, "lambda") ||
string_equal(type->value.identifier, "special-lambda") ||
string_equal(type->value.identifier, "macro")))
{
Lisp_Object* fun = eval_expr(arguments->value.pair->first, env);
Lisp_Object* fun = eval_expr(arguments->value.pair.first, env);

if (fun->value.function->docstring)
printf("Docstring:\n==========\n%s\n\n", Memory::get_c_str(fun->value.function->docstring));
if (fun->value.function.docstring)
printf("Docstring:\n==========\n%s\n\n", Memory::get_c_str(fun->value.function.docstring));
else
printf("No docstring avaliable\n");

printf("Arguments:\n==========\n");
printf("Postitional: {");
if (fun->value.function->positional_arguments->next_index != 0) {
if (fun->value.function.positional_arguments->next_index != 0) {
printf("%s",
Memory::get_c_str(fun->value.function->positional_arguments->identifiers[0]));
for (int i = 1; i < fun->value.function->positional_arguments->next_index; ++i) {
Memory::get_c_str(fun->value.function.positional_arguments->identifiers[0]));
for (int i = 1; i < fun->value.function.positional_arguments->next_index; ++i) {
printf(", %s",
Memory::get_c_str(fun->value.function->positional_arguments->identifiers[i]));
Memory::get_c_str(fun->value.function.positional_arguments->identifiers[i]));
}
}
printf("}\n");
printf("Keyword: {");
if (fun->value.function->keyword_arguments->next_index != 0) {
if (fun->value.function.keyword_arguments->next_index != 0) {
printf("%s",
Memory::get_c_str(fun->value.function->keyword_arguments->identifiers[0]));
if (fun->value.function->keyword_arguments->values->data[0]) {
Memory::get_c_str(fun->value.function.keyword_arguments->identifiers[0]));
if (fun->value.function.keyword_arguments->values->data[0]) {
printf(" (");
print(fun->value.function->keyword_arguments->values->data[0]);
print(fun->value.function.keyword_arguments->values->data[0]);
printf(")");
}
for (int i = 1; i < fun->value.function->keyword_arguments->next_index; ++i) {
for (int i = 1; i < fun->value.function.keyword_arguments->next_index; ++i) {
printf(", %s",
Memory::get_c_str(fun->value.function->keyword_arguments->identifiers[i]));
if (fun->value.function->keyword_arguments->values->data[i]) {
Memory::get_c_str(fun->value.function.keyword_arguments->identifiers[i]));
if (fun->value.function.keyword_arguments->values->data[i]) {
printf(" (");
print(fun->value.function->keyword_arguments->values->data[i]);
print(fun->value.function.keyword_arguments->values->data[i]);
printf(")");
}
}
}
printf("}\n");
printf("Rest: {");
if (fun->value.function->rest_argument)
if (fun->value.function.rest_argument)
printf("%s",
Memory::get_c_str(fun->value.function->rest_argument));
Memory::get_c_str(fun->value.function.rest_argument));
printf("}\n");

}
@@ -1007,12 +977,12 @@ proc load_built_ins_into_environment(Environment* env) -> void {
if (arguments_length != 1) {
report_error(Error_Type::Wrong_Number_Of_Arguments);
}
if (evaluated_arguments->value.pair->first->type != Lisp_Object_Type::Function) {
if (evaluated_arguments->value.pair.first->type != Lisp_Object_Type::Function) {
report_error(Error_Type::Type_Missmatch);
}

puts("body:\n");
print(evaluated_arguments->value.pair->first->value.function->body);
print(evaluated_arguments->value.pair.first->value.function.body);
puts("\n");

return Memory::nil;
@@ -1024,7 +994,7 @@ proc load_built_ins_into_environment(Environment* env) -> void {
if (arguments_length != 1) {
report_error(Error_Type::Wrong_Number_Of_Arguments);
}
print(evaluated_arguments->value.pair->first);
print(evaluated_arguments->value.pair.first);
// printf("\n");
return Memory::nil;
});
@@ -1038,11 +1008,11 @@ proc load_built_ins_into_environment(Environment* env) -> void {
}

if (arguments_length == 1) {
Lisp_Object* prompt = evaluated_arguments->value.pair->first;
Lisp_Object* prompt = evaluated_arguments->value.pair.first;
/* if (prompt->type == Lisp_Object_Type::String) */
/* printf("%s", prompt->value.string->value); */
/* else */
print(evaluated_arguments->value.pair->first);
print(evaluated_arguments->value.pair.first);
}
char* line = read_line();
String* strLine = Memory::create_string(line);
@@ -1059,11 +1029,11 @@ proc load_built_ins_into_environment(Environment* env) -> void {
}

if (arguments_length == 1) {
Lisp_Object* error_code = evaluated_arguments->value.pair->first;
Lisp_Object* error_code = evaluated_arguments->value.pair.first;
if (error_code->type != Lisp_Object_Type::Number)
report_error(Error_Type::Type_Missmatch);

exit((int)error_code->value.number->value);
exit((int)error_code->value.number);
}
exit(0);
});
@@ -1085,8 +1055,8 @@ proc load_built_ins_into_environment(Environment* env) -> void {
report_error(Error_Type::Wrong_Number_Of_Arguments);
}

Lisp_Object* try_part = arguments->value.pair->first;
Lisp_Object* catch_part = arguments->value.pair->rest->value.pair->first;
Lisp_Object* try_part = arguments->value.pair.first;
Lisp_Object* catch_part = arguments->value.pair.rest->value.pair.first;
Lisp_Object* result;

result = eval_expr(try_part, env);
@@ -1106,12 +1076,12 @@ proc load_built_ins_into_environment(Environment* env) -> void {
if (arguments_length != 1)
report_error(Error_Type::Wrong_Number_Of_Arguments);

if (evaluated_arguments->value.pair->first->type != Lisp_Object_Type::String)
if (evaluated_arguments->value.pair.first->type != Lisp_Object_Type::String)
report_error(Error_Type::Type_Missmatch);

Lisp_Object* result;
try {
result = built_in_load(evaluated_arguments->value.pair->first->value.string, env);
result = built_in_load(evaluated_arguments->value.pair.first->value.string, env);
}
return result;

@@ -1127,14 +1097,14 @@ proc load_built_ins_into_environment(Environment* env) -> void {
if (arguments_length != 1)
report_error(Error_Type::Wrong_Number_Of_Arguments);

if (evaluated_arguments->value.pair->first->type == Lisp_Object_Type::Nil ||
evaluated_arguments->value.pair->first->type == Lisp_Object_Type::Keyword)
if (evaluated_arguments->value.pair.first->type == Lisp_Object_Type::Nil ||
evaluated_arguments->value.pair.first->type == Lisp_Object_Type::Keyword)
{
report_error(Error_Type::Type_Missmatch);
}

Lisp_Object* target = Memory::create_lisp_object();
Lisp_Object* source = evaluated_arguments->value.pair->first;
Lisp_Object* source = evaluated_arguments->value.pair.first;

*target = *source;
return target;
@@ -1157,13 +1127,13 @@ proc load_built_ins_into_environment(Environment* env) -> void {
report_error(Error_Type::Wrong_Number_Of_Arguments);
}

Lisp_Object* source = evaluated_arguments->value.pair->first;
Lisp_Object* source = evaluated_arguments->value.pair.first;

if (source->type != Lisp_Object_Type::Symbol) {
report_error(Error_Type::Type_Missmatch);
}

return Memory::get_or_create_lisp_object_keyword(source->value.symbol->identifier);
return Memory::get_or_create_lisp_object_keyword(source->value.identifier);
});
defun("string->symbol", cLambda {

@@ -1178,7 +1148,7 @@ proc load_built_ins_into_environment(Environment* env) -> void {
report_error(Error_Type::Wrong_Number_Of_Arguments);
}

Lisp_Object* source = evaluated_arguments->value.pair->first;
Lisp_Object* source = evaluated_arguments->value.pair.first;

if (source->type != Lisp_Object_Type::String) {
report_error(Error_Type::Type_Missmatch);
@@ -1195,12 +1165,12 @@ proc load_built_ins_into_environment(Environment* env) -> void {
report_error(Error_Type::Wrong_Number_Of_Arguments);
}

Lisp_Object* source = evaluated_arguments->value.pair->first;
Lisp_Object* source = evaluated_arguments->value.pair.first;

if (source->type != Lisp_Object_Type::Symbol) {
report_error(Error_Type::Type_Missmatch);
}
return Memory::create_lisp_object_string(Memory::duplicate_string(source->value.symbol->identifier));
return Memory::create_lisp_object_string(Memory::duplicate_string(source->value.identifier));
});
defun("concat-strings", cLambda {
try {
@@ -1217,11 +1187,11 @@ proc load_built_ins_into_environment(Environment* env) -> void {

while (head->type == Lisp_Object_Type::Pair) {
try {
assert_type(head->value.pair->first, Lisp_Object_Type::String);
assert_type(head->value.pair.first, Lisp_Object_Type::String);
}
resulting_string_len += head->value.pair->first->value.string->length;
resulting_string_len += head->value.pair.first->value.string->length;

head = head->value.pair->rest;
head = head->value.pair.rest;
}

head = evaluated_arguments;
@@ -1231,9 +1201,9 @@ proc load_built_ins_into_environment(Environment* env) -> void {

while (head->type == Lisp_Object_Type::Pair) {
strcpy((&resulting_string->data)+index_in_string,
Memory::get_c_str(head->value.pair->first->value.string));
index_in_string += head->value.pair->first->value.string->length;
head = head->value.pair->rest;
Memory::get_c_str(head->value.pair.first->value.string));
index_in_string += head->value.pair.first->value.string->length;
head = head->value.pair.rest;
}

return Memory::create_lisp_object_string(resulting_string);


+ 8
- 8
src/env.cpp Zobrazit soubor

@@ -11,23 +11,23 @@ proc define_symbol(Lisp_Object* symbol, Lisp_Object* value, Environment* env) ->
env->values = (Lisp_Object**)realloc(env->values, env->capacity * sizeof(Lisp_Object*));
}

env->keys [env->next_index] = Memory::get_c_str(symbol->value.symbol->identifier);
env->keys [env->next_index] = Memory::get_c_str(symbol->value.identifier);
env->values[env->next_index] = value;
++env->next_index;
}

proc lookup_symbol_in_this_envt(Symbol* sym, Environment* env) -> Lisp_Object* {
proc lookup_symbol_in_this_envt(String* identifier, Environment* env) -> Lisp_Object* {
for (int i = env->next_index - 1; i >= 0; --i)
if (string_equal(env->keys[i], Memory::get_c_str(sym->identifier)))
if (string_equal(env->keys[i], Memory::get_c_str(identifier)))
return env->values[i];
return nullptr;
}

proc lookup_symbol(Lisp_Object* node, Environment* env) -> Lisp_Object* {
// first check current environment
Symbol* sym = node->value.symbol;
String* identifier = node->value.identifier;
Lisp_Object* result;
result = lookup_symbol_in_this_envt(sym, env);
result = lookup_symbol_in_this_envt(identifier, env);
if (result)
return result;

@@ -38,15 +38,15 @@ proc lookup_symbol(Lisp_Object* node, Environment* env) -> Lisp_Object* {
return result;
}

if (string_equal(Memory::get_c_str(sym->identifier), "nil")) {
if (string_equal(Memory::get_c_str(identifier), "nil")) {
return Memory::nil;
}
if (string_equal(Memory::get_c_str(sym->identifier), "t")) {
if (string_equal(Memory::get_c_str(identifier), "t")) {
return Memory::t;
}

printf("%s\n", Memory::get_c_str(identifier));
create_error(Error_Type::Symbol_Not_Defined, node->sourceCodeLocation);
printf("%s\n", Memory::get_c_str(sym->identifier));
return nullptr;
}



+ 53
- 53
src/eval.cpp Zobrazit soubor

@@ -11,13 +11,13 @@ proc apply_arguments_to_function(Lisp_Object* arguments, Function* function) ->
// 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);
arguments->value.pair.first, new_env);
} else {

create_error(Error_Type::Ill_Formed_Arguments, arguments->sourceCodeLocation);
return nullptr;
}
arguments = arguments->value.pair->rest;
arguments = arguments->value.pair.rest;
}

String_Array_List* read_in_keywords = create_String_array_list();
@@ -29,12 +29,12 @@ proc apply_arguments_to_function(Lisp_Object* arguments, Function* function) ->
// 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 == Lisp_Object_Type::Keyword) {
while (arguments->value.pair.first->type == Lisp_Object_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) {
if (string_equal(
arguments->value.pair->first->value.keyword->identifier,
arguments->value.pair.first->value.identifier,
function->keyword_arguments->identifiers[i]))
{
accepted = true;
@@ -54,7 +54,7 @@ proc apply_arguments_to_function(Lisp_Object* arguments, Function* function) ->
// check if it was already read in
for (int i = 0; i < read_in_keywords->next_index; ++i) {
if (string_equal(
arguments->value.pair->first->value.keyword->identifier,
arguments->value.pair.first->value.identifier,
read_in_keywords->data[i]))
{
// TODO(Felix): if we are actually done with all the
@@ -69,21 +69,21 @@ proc apply_arguments_to_function(Lisp_Object* arguments, Function* function) ->
// 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 != Lisp_Object_Type::Pair) {
if (arguments->value.pair.rest->type != Lisp_Object_Type::Pair) {
create_error(Error_Type::Ill_Formed_Arguments, arguments->sourceCodeLocation);
return nullptr;
}

// 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.keyword->identifier),
arguments->value.pair->rest->value.pair->first,
Memory::get_or_create_lisp_object_symbol(arguments->value.pair.first->value.identifier),
arguments->value.pair.rest->value.pair.first,
new_env);

append_to_array_list(read_in_keywords, arguments->value.pair->first->value.keyword->identifier);
append_to_array_list(read_in_keywords, arguments->value.pair.first->value.identifier);

// overstep both for next one
arguments = arguments->value.pair->rest->value.pair->rest;
arguments = arguments->value.pair.rest->value.pair.rest;

if (arguments->type == Lisp_Object_Type::Nil) {
break;
@@ -175,9 +175,9 @@ proc parse_argument_list(Lisp_Object* arguments, Function* function) -> void {

// okay let's try to read some positional arguments
while (arguments->type == Lisp_Object_Type::Pair) {
if (arguments->value.pair->first->type == Lisp_Object_Type::Keyword) {
if (string_equal(arguments->value.pair->first->value.keyword->identifier, "keys") ||
string_equal(arguments->value.pair->first->value.keyword->identifier, "rest"))
if (arguments->value.pair.first->type == Lisp_Object_Type::Keyword) {
if (string_equal(arguments->value.pair.first->value.identifier, "keys") ||
string_equal(arguments->value.pair.first->value.identifier, "rest"))
break;
else {
create_error(Error_Type::Ill_Formed_Lambda_List, arguments->sourceCodeLocation);
@@ -185,7 +185,7 @@ proc parse_argument_list(Lisp_Object* arguments, Function* function) -> void {
}
}

if (arguments->value.pair->first->type != Lisp_Object_Type::Symbol) {
if (arguments->value.pair.first->type != Lisp_Object_Type::Symbol) {
create_error(Error_Type::Ill_Formed_Lambda_List, arguments->sourceCodeLocation);
return;
}
@@ -193,9 +193,9 @@ proc parse_argument_list(Lisp_Object* arguments, Function* function) -> void {
// okay wow we found an actual symbol
append_to_positional_argument_list(
function->positional_arguments,
arguments->value.pair->first->value.symbol->identifier);
arguments->value.pair.first->value.identifier);

arguments = arguments->value.pair->rest;
arguments = arguments->value.pair.rest;
}

// okay we are done with positional arguments, lets check for
@@ -206,20 +206,20 @@ proc parse_argument_list(Lisp_Object* arguments, Function* function) -> void {
return;
}

if (arguments->value.pair->first->type == Lisp_Object_Type::Keyword &&
string_equal(arguments->value.pair->first->value.keyword->identifier, "keys"))
if (arguments->value.pair.first->type == Lisp_Object_Type::Keyword &&
string_equal(arguments->value.pair.first->value.identifier, "keys"))
{
arguments = arguments->value.pair->rest;
arguments = arguments->value.pair.rest;
if (arguments->type != Lisp_Object_Type::Pair ||
arguments->value.pair->first->type != Lisp_Object_Type::Symbol)
arguments->value.pair.first->type != Lisp_Object_Type::Symbol)
{
create_error(Error_Type::Ill_Formed_Lambda_List, arguments->sourceCodeLocation);
return;
}

while (arguments->type == Lisp_Object_Type::Pair) {
if (arguments->value.pair->first->type == Lisp_Object_Type::Keyword) {
if (string_equal(arguments->value.pair->first->value.keyword->identifier, "rest"))
if (arguments->value.pair.first->type == Lisp_Object_Type::Keyword) {
if (string_equal(arguments->value.pair.first->value.identifier, "rest"))
break;
else {
create_error(Error_Type::Ill_Formed_Lambda_List, arguments->sourceCodeLocation);
@@ -227,7 +227,7 @@ proc parse_argument_list(Lisp_Object* arguments, Function* function) -> void {
}
}

if (arguments->value.pair->first->type != Lisp_Object_Type::Symbol) {
if (arguments->value.pair.first->type != Lisp_Object_Type::Symbol) {
create_error(Error_Type::Ill_Formed_Lambda_List, arguments->sourceCodeLocation);
return;
}
@@ -235,20 +235,20 @@ proc parse_argument_list(Lisp_Object* arguments, Function* function) -> void {
// we found a symbol (arguments->value.pair->first) for
// the keyword args! Let's check if the next arguement is
// :defaults-to
Lisp_Object* next = arguments->value.pair->rest;
Lisp_Object* next = arguments->value.pair.rest;
if (next->type == Lisp_Object_Type::Pair &&
next->value.pair->first->type == Lisp_Object_Type::Keyword &&
string_equal(next->value.pair->first->value.keyword->identifier,
next->value.pair.first->type == Lisp_Object_Type::Keyword &&
string_equal(next->value.pair.first->value.identifier,
"defaults-to"))
{
// check if there is a next argument too, otherwise it
// would be an error
next = next->value.pair->rest;
next = next->value.pair.rest;
if (next->type == Lisp_Object_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;
arguments->value.pair.first->value.identifier,
next->value.pair.first);
arguments = next->value.pair.rest;
} else {
create_error(Error_Type::Ill_Formed_Lambda_List, arguments->sourceCodeLocation);
return;
@@ -256,7 +256,7 @@ proc parse_argument_list(Lisp_Object* arguments, Function* function) -> void {
} else {
// No :defaults-to, so just add it to the list
append_to_keyword_argument_list(function->keyword_arguments,
arguments->value.pair->first->value.symbol->identifier,
arguments->value.pair.first->value.identifier,
nullptr);
arguments = next;
}
@@ -272,18 +272,18 @@ proc parse_argument_list(Lisp_Object* arguments, Function* function) -> void {
return;
}

if (arguments->value.pair->first->type == Lisp_Object_Type::Keyword &&
string_equal(arguments->value.pair->first->value.keyword->identifier, "rest"))
if (arguments->value.pair.first->type == Lisp_Object_Type::Keyword &&
string_equal(arguments->value.pair.first->value.identifier, "rest"))
{
arguments = arguments->value.pair->rest;
arguments = arguments->value.pair.rest;
if (arguments->type != Lisp_Object_Type::Pair ||
arguments->value.pair->first->type != Lisp_Object_Type::Symbol)
arguments->value.pair.first->type != Lisp_Object_Type::Symbol)
{
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 != Lisp_Object_Type::Nil) {
function->rest_argument = arguments->value.pair.first->value.identifier;
if (arguments->value.pair.rest->type != Lisp_Object_Type::Nil) {
create_error(Error_Type::Ill_Formed_Lambda_List, arguments->sourceCodeLocation);
}
} else {
@@ -305,7 +305,7 @@ proc list_length(Lisp_Object* node) -> int {
int len = 0;
while (node->type == Lisp_Object_Type::Pair) {
++len;
node = node->value.pair->rest;
node = node->value.pair.rest;
if (node->type == Lisp_Object_Type::Nil)
return len;
}
@@ -317,7 +317,7 @@ proc list_length(Lisp_Object* node) -> int {
proc extract_keyword_value(char* keyword, Parsed_Arguments* args) -> Lisp_Object* {
// NOTE(Felix): This will be a hashmap lookup later
for (int i = 0; i < args->keyword_keys->next_index; ++i) {
if (string_equal(args->keyword_keys->data[i]->value.keyword->identifier, keyword))
if (string_equal(args->keyword_keys->data[i]->value.identifier, keyword))
return args->keyword_values->data[i];
}
return nullptr;
@@ -335,17 +335,17 @@ proc eval_arguments(Lisp_Object* arguments, Environment* env, int *out_arguments
Lisp_Object* current_head = arguments;
while (current_head->type == Lisp_Object_Type::Pair) {
try {
evaluated_arguments_head->value.pair->first =
eval_expr(current_head->value.pair->first, env);
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;
evaluated_arguments_head->value.pair.first->sourceCodeLocation = current_head->value.pair.first->sourceCodeLocation;
current_head = current_head->value.pair.rest;

if (current_head->type == Lisp_Object_Type::Pair) {
evaluated_arguments_head->value.pair->rest = Memory::create_lisp_object_pair(nullptr, nullptr);
evaluated_arguments_head = evaluated_arguments_head->value.pair->rest;
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->type == Lisp_Object_Type::Nil) {
evaluated_arguments_head->value.pair->rest = current_head;
evaluated_arguments_head->value.pair.rest = current_head;
} else {
create_error(Error_Type::Ill_Formed_Arguments, arguments->sourceCodeLocation);
return nullptr;
@@ -375,17 +375,17 @@ proc eval_expr(Lisp_Object* node, Environment* env) -> Lisp_Object* {
current_source_code_location = node->sourceCodeLocation;

Lisp_Object* lispOperator;
if (node->value.pair->first->type != Lisp_Object_Type::CFunction &&
node->value.pair->first->type != Lisp_Object_Type::Function)
if (node->value.pair.first->type != Lisp_Object_Type::CFunction &&
node->value.pair.first->type != Lisp_Object_Type::Function)
{
try {
lispOperator = eval_expr(node->value.pair->first, env);
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;
Lisp_Object* arguments = node->value.pair.rest;
int arguments_length;

// check for c function
@@ -398,7 +398,7 @@ proc eval_expr(Lisp_Object* node, Environment* env) -> Lisp_Object* {
if (lispOperator->type == Lisp_Object_Type::Function) {
// only for lambdas we evaluate the arguments before
// apllying
if (lispOperator->value.function->type == Function_Type::Lambda) {
if (lispOperator->value.function.type == Function_Type::Lambda) {
try {
arguments = eval_arguments(arguments, env, &arguments_length);
}
@@ -406,7 +406,7 @@ proc eval_expr(Lisp_Object* node, Environment* env) -> Lisp_Object* {

Lisp_Object* result;
try {
result = apply_arguments_to_function(arguments, lispOperator->value.function);
result = apply_arguments_to_function(arguments, &lispOperator->value.function);
}
return result;
}


+ 22
- 93
src/io.cpp Zobrazit soubor

@@ -227,129 +227,58 @@ proc panic(char* message) -> void {
exit(1);
}

proc print(Lisp_Object* node, bool print_quotes = false) -> void {
proc print(Lisp_Object* node, bool print_quotes = false, FILE* file = stdout) -> void {

switch (node->type) {
case (Lisp_Object_Type::Nil): {
printf("()");
} break;
case (Lisp_Object_Type::T): {
printf("t");
} break;
case (Lisp_Object_Type::Number): {
printf("%f", node->value.number->value);
} break;
case (Lisp_Object_Type::Nil): fprintf(file, "()"); break;
case (Lisp_Object_Type::T): fprintf(file, "t"); break;
case (Lisp_Object_Type::Number): fprintf(file, "%f", node->value.number); break;
case (Lisp_Object_Type::Symbol): fprintf(file, "%s", Memory::get_c_str(node->value.identifier)); break;
case (Lisp_Object_Type::Keyword): fprintf(file, ":%s", Memory::get_c_str(node->value.identifier)); break;
case (Lisp_Object_Type::CFunction): fprintf(file, "[C-function]"); break;
case (Lisp_Object_Type::String): {
if (print_quotes)
printf("\"%s\"", Memory::get_c_str(node->value.string));
fprintf(file, "\"%s\"", Memory::get_c_str(node->value.string));
else
printf("%s", Memory::get_c_str(node->value.string));
} break;
case (Lisp_Object_Type::Symbol): {
printf("%s", Memory::get_c_str(node->value.symbol->identifier));
} break;
case (Lisp_Object_Type::Keyword): {
printf(":%s", Memory::get_c_str(node->value.keyword->identifier));
fprintf(file, "%s", Memory::get_c_str(node->value.string));
} break;
case (Lisp_Object_Type::Function): {
if (node->value.function->type == Function_Type::Lambda)
printf("[lambda]");
else if (node->value.function->type == Function_Type::Special_Lambda)
printf("[special-lambda]");
else if (node->value.function->type == Function_Type::Macro)
printf("[macro]");
if (node->value.function.type == Function_Type::Lambda)
fprintf(file, "[lambda]");
else if (node->value.function.type == Function_Type::Special_Lambda)
fprintf(file, "[special-lambda]");
else if (node->value.function.type == Function_Type::Macro)
fprintf(file, "[macro]");
else
assert(false);
} break;
case (Lisp_Object_Type::CFunction): {
printf("[C-function]");
} break;
case (Lisp_Object_Type::Pair): {
Lisp_Object* head = node;
printf("(");
fprintf(file, "(");

// NOTE(Felix): We cold do a while true here, however in case
// we want to print a broken list (for logging the error) we
// should do mo checks.
while (head) {
print(head->value.pair->first);
head = head->value.pair->rest;
print(head->value.pair.first, print_quotes, file);
head = head->value.pair.rest;
if (!head)
return;
if (head->type != Lisp_Object_Type::Pair)
break;
printf(" ");
fprintf(file, " ");
}

if (head->type != Lisp_Object_Type::Nil) {
printf(" . ");
fprintf(file, " . ");
print(head);
}

printf(")");
fprintf(file, ")");
} break;
}
}

// XXX(Felix): obv code dublicate
proc fprint(FILE* f, Lisp_Object* node) -> void {
switch (node->type) {
case (Lisp_Object_Type::Nil): {
fprintf(f, "nil");
} break;
case (Lisp_Object_Type::T): {
fprintf(f, "t");
} break;
case (Lisp_Object_Type::Number): {
fprintf(f, "%f", node->value.number->value);
} break;
case (Lisp_Object_Type::String): {
fprintf(f, "\"%s\"", Memory::get_c_str(node->value.string));
} break;
case (Lisp_Object_Type::Symbol): {
fprintf(f, "%s", Memory::get_c_str(node->value.symbol->identifier));
} break;
case (Lisp_Object_Type::Keyword): {
fprintf(f, ":%s", Memory::get_c_str(node->value.keyword->identifier));
} break;
case (Lisp_Object_Type::Function): {
if (node->value.function->type == Function_Type::Lambda)
fprintf(f, "[lambda]");
else if (node->value.function->type == Function_Type::Special_Lambda)
fprintf(f, "[special-lambda]");
else if (node->value.function->type == Function_Type::Macro)
fprintf(f, "[macro]");
else
assert(false);
} break;
case (Lisp_Object_Type::CFunction): {
fprintf(f, "[C-function]");
} break;
case (Lisp_Object_Type::Pair): {
Lisp_Object* head = node;
fprintf(f, "(");

// NOTE(Felix): We cold do a while true here, however in case
// we want to print a broken list (for logging the error) we
// should do mo checks.
while (head) {
fprint(f, head->value.pair->first);
head = head->value.pair->rest;
if (!head)
return;
if (head->type != Lisp_Object_Type::Pair)
break;
fprintf(f, " ");
}

if (head->type != Lisp_Object_Type::Nil) {
fprintf(f, " . ");
print(head);
}

fprintf(f, ")");
} break;
}
}

proc print_error_location() -> void {
if (error->location) {


+ 8
- 25
src/memory.cpp Zobrazit soubor

@@ -114,33 +114,16 @@ namespace Memory {
// init nil
nil = create_lisp_object();
nil->type = Lisp_Object_Type::Nil;
nil->value.pair = nullptr;

// init t
t = create_lisp_object();
t->type = Lisp_Object_Type::T;
t->value.pair = nullptr;
}

// proc get_lisp_object_nil() -> Lisp_Object* {
// Lisp_Object* node = create_lisp_object();
// node->type = Lisp_Object_Type::Nil;
// node->value.pair = nullptr;
// return node;
// }

// proc get_lisp_object_t() -> Lisp_Object* {
// Lisp_Object* node = create_lisp_object();
// node->type = Lisp_Object_Type::T;
// node->value.pair = nullptr;
// return node;
// }

proc create_lisp_object_number(double number) -> Lisp_Object* {
Lisp_Object* node = create_lisp_object();
node->type = Lisp_Object_Type::Number;
node->value.number = new(Number);
node->value.number->value = number;
node->value.number = number;
return node;
}

@@ -163,8 +146,8 @@ namespace Memory {
// reuse it and dont create new one
Lisp_Object* node = create_lisp_object();
node->type = Lisp_Object_Type::Symbol;
node->value.symbol = new(Symbol);
node->value.symbol->identifier = identifier;
// node->value.symbol = new(Symbol);
node->value.identifier = identifier;
return node;
}

@@ -178,8 +161,8 @@ namespace Memory {
// reuse it and dont create new one
Lisp_Object* node = create_lisp_object();
node->type = Lisp_Object_Type::Keyword;
node->value.keyword = new(Keyword);
node->value.keyword->identifier = keyword;
// node->value.keyword = new(Keyword);
node->value.identifier = keyword;
return node;
}

@@ -200,9 +183,9 @@ namespace Memory {
proc create_lisp_object_pair(Lisp_Object* first, Lisp_Object* rest) -> Lisp_Object* {
Lisp_Object* node = create_lisp_object();
node->type = Lisp_Object_Type::Pair;
node->value.pair = new(Pair);
node->value.pair->first = first;
node->value.pair->rest = rest;
// node->value.pair = new(Pair);
node->value.pair.first = first;
node->value.pair.rest = rest;
return node;
}



+ 41
- 48
src/parse.cpp Zobrazit soubor

@@ -293,7 +293,7 @@ namespace Parser {
// okay there is something
Lisp_Object* head = Memory::create_lisp_object();
head->type = Lisp_Object_Type::Pair;
head->value.pair = new(Pair);
// head->value.pair = new(Pair);
Lisp_Object* expression = head;

while (true) {
@@ -304,11 +304,11 @@ namespace Parser {
text[*index_in_text] == ',')
{
try {
head->value.pair->first = parse_expression(text, index_in_text);
head->value.pair.first = parse_expression(text, index_in_text);
}
} else {
try {
head->value.pair->first = parse_atom(text, index_in_text);
head->value.pair.first = parse_atom(text, index_in_text);
}
}

@@ -320,7 +320,7 @@ namespace Parser {


if (text[(*index_in_text)] == ')') {
head->value.pair->rest = Memory::nil;
head->value.pair.rest = Memory::nil;
++parser_col;
++(*index_in_text);
break;
@@ -330,9 +330,9 @@ namespace Parser {
eat_until_code(text, index_in_text);

if (text[(*index_in_text)] == '(')
head->value.pair->rest = parse_expression(text, index_in_text);
head->value.pair.rest = parse_expression(text, index_in_text);
else
head->value.pair->rest = parse_atom(text, index_in_text);
head->value.pair.rest = parse_atom(text, index_in_text);

eat_until_code(text, index_in_text);

@@ -342,16 +342,16 @@ namespace Parser {
++(*index_in_text);
break;
} else {
head->value.pair->rest = Memory::create_lisp_object_pair(nullptr, nullptr);
head = head->value.pair->rest;
head->value.pair.rest = Memory::create_lisp_object_pair(nullptr, nullptr);
head = head->value.pair.rest;
}
}

// check if we have to create or delete or run macros
if (expression->value.pair->first->type == Lisp_Object_Type::Symbol) {
if (string_equal("define-syntax", expression->value.pair->first->value.symbol->identifier)) {
if (expression->value.pair.first->type == Lisp_Object_Type::Symbol) {
if (string_equal("define-syntax", expression->value.pair.first->value.identifier)) {
// create a new macro
Lisp_Object* arguments = expression->value.pair->rest;
Lisp_Object* arguments = expression->value.pair.rest;
int arguments_length;

// HACK(Felix): almost code duplicate from
@@ -366,57 +366,57 @@ namespace Parser {
return nullptr;
}

if (arguments->value.pair->first->type != Lisp_Object_Type::Symbol) {
if (arguments->value.pair.first->type != Lisp_Object_Type::Symbol) {
create_error(Error_Type::Type_Missmatch, expression->sourceCodeLocation);
return nullptr;
}

// extract the name
Lisp_Object* symbol_for_macro = arguments->value.pair->first;
arguments = arguments->value.pair->rest;
Lisp_Object* symbol_for_macro = arguments->value.pair.first;
arguments = arguments->value.pair.rest;

Function* function = new(Function);
function->parent_environment = environment_for_macros;
function->type = Function_Type::Macro;
// Function* function = new(Function);
Lisp_Object* macro = Memory::create_lisp_object();
macro->type = Lisp_Object_Type::Function;
macro->value.function.parent_environment = environment_for_macros;
macro->value.function.type = Function_Type::Macro;

// if parameters were specified
if (arguments->value.pair->first->type != Lisp_Object_Type::Nil) {
if (arguments->value.pair.first->type != Lisp_Object_Type::Nil) {
try {
assert_type(arguments->value.pair->first, Lisp_Object_Type::Pair);
assert_type(arguments->value.pair.first, Lisp_Object_Type::Pair);
}
try {
parse_argument_list(arguments->value.pair->first, function);
parse_argument_list(arguments->value.pair.first, &macro->value.function);
}
} else {
function->positional_arguments = create_positional_argument_list(1);
function->keyword_arguments = create_keyword_argument_list(1);
function->rest_argument = nullptr;
macro->value.function.positional_arguments = create_positional_argument_list(1);
macro->value.function.keyword_arguments = create_keyword_argument_list(1);
macro->value.function.rest_argument = nullptr;
}

arguments = arguments->value.pair->rest;
arguments = arguments->value.pair.rest;
// if there is a docstring, use it
if (arguments->value.pair->first->type == Lisp_Object_Type::String) {
function->docstring = arguments->value.pair->first->value.string;
arguments = arguments->value.pair->rest;
if (arguments->value.pair.first->type == Lisp_Object_Type::String) {
macro->value.function.docstring = arguments->value.pair.first->value.string;
arguments = arguments->value.pair.rest;
} else {
function->docstring = nullptr;
macro->value.function.docstring = nullptr;
}

// we are now in the function body, just wrap it in an
// implicit prog
function->body = Memory::create_lisp_object_pair(
macro->value.function.body = Memory::create_lisp_object_pair(
Memory::get_or_create_lisp_object_symbol("prog"),
arguments);

Lisp_Object* macro = Memory::create_lisp_object();
macro->type = Lisp_Object_Type::Function;
macro->value.function = function;
// macro->value.function = function;
define_symbol(symbol_for_macro, macro, environment_for_macros);

// print_environment(environment_for_macros);
return Memory::nil;

} else if (string_equal("delete-syntax", expression->value.pair->first->value.symbol->identifier)) {
} else if (string_equal("delete-syntax", expression->value.pair.first->value.identifier)) {
/* --- deleting an existing macro --- */
// TODO(Felix): this is a hard one because when
// environments will be made from hashmaps, how can we
@@ -436,21 +436,12 @@ namespace Parser {
// if not it is regular code, dont touch.

for (int i = 0; i < environment_for_macros->next_index; ++i) {
if (string_equal(expression->value.pair->first->value.symbol->identifier, environment_for_macros->keys[i]) &&
if (string_equal(expression->value.pair.first->value.identifier, environment_for_macros->keys[i]) &&
environment_for_macros->values[i]->type == Lisp_Object_Type::Function &&
environment_for_macros->values[i]->value.function->type == Function_Type::Macro)
environment_for_macros->values[i]->value.function.type == Function_Type::Macro)
{
try {
// if (string_equal(environment_for_macros->keys[i], "when")) {
// printf("invoking macro for %s in %s:%d to:\n\t", environment_for_macros->keys[i], parser_file, parser_line);
// print(environment_for_macros->values[i]->value.function->body);
// }
expression = eval_expr(expression, environment_for_macros);
// if (string_equal(environment_for_macros->keys[i], "when")) {
// printf("\nresult: \n\t");
// print(expression);
// printf("\n\n");
// }
}
}
}
@@ -536,6 +527,11 @@ namespace Parser {
strcat(newName, ext);

FILE *f = fopen(newName, "w");
defer {
fclose(f);
free(newName);
};

if (f == NULL) {
printf("Error opening file!\n");
exit(1);
@@ -545,12 +541,9 @@ namespace Parser {
// a macro will parse as nil for now, so we skip those
if (program->data[i]->type == Lisp_Object_Type::Nil)
continue;
fprint(f, program->data[i]);
print(program->data[i], true, f);
fprintf(f, "\n\n");
}

fclose(f);
free(newName);
}

proc parse_program(String* file_name, char* text) -> Lisp_Object_Array_List* {


+ 8
- 9
src/structs.cpp Zobrazit soubor

@@ -73,9 +73,9 @@ struct Keyword {
String* identifier;
};

struct Number {
double value;
};
// struct Number {
// double value;
// };

struct Pair {
Lisp_Object* first;
@@ -119,12 +119,11 @@ struct Lisp_Object {
Lisp_Object_Type type;
Lisp_Object* userType;
union {
Symbol* symbol;
Keyword* keyword;
Number* number;
String* string;
Pair* pair;
Function* function;
String* identifier; // used for symbols and keywords
double number;
String* string;
Pair pair;
Function function;
cFunction* cFunction;
} value;
};


+ 45
- 45
src/testing.cpp Zobrazit soubor

@@ -105,26 +105,26 @@ proc test_eval_operands() -> testresult {
assert_equal_int(list_length(operands), 4);

assert_equal_type(operands, Lisp_Object_Type::Pair);
assert_equal_type(operands->value.pair->first, Lisp_Object_Type::Number);
assert_equal_double(operands->value.pair->first->value.number->value, 1);
assert_equal_type(operands->value.pair.first, Lisp_Object_Type::Number);
assert_equal_double(operands->value.pair.first->value.number, 1);

operands = operands->value.pair->rest;
operands = operands->value.pair.rest;

assert_equal_type(operands, Lisp_Object_Type::Pair);
assert_equal_type(operands->value.pair->first, Lisp_Object_Type::Number);
assert_equal_double(operands->value.pair->first->value.number->value, 3);
assert_equal_type(operands->value.pair.first, Lisp_Object_Type::Number);
assert_equal_double(operands->value.pair.first->value.number, 3);

operands = operands->value.pair->rest;
operands = operands->value.pair.rest;

assert_equal_type(operands, Lisp_Object_Type::Pair);
assert_equal_type(operands->value.pair->first, Lisp_Object_Type::String);
assert_equal_string(operands->value.pair->first->value.string, "okay");
assert_equal_type(operands->value.pair.first, Lisp_Object_Type::String);
assert_equal_string(operands->value.pair.first->value.string, "okay");

operands = operands->value.pair->rest;
operands = operands->value.pair.rest;

assert_equal_type(operands, Lisp_Object_Type::Pair);
assert_equal_type(operands->value.pair->first, Lisp_Object_Type::Keyword);
assert_equal_string(operands->value.pair->first->value.keyword->identifier, "haha");
assert_equal_type(operands->value.pair.first, Lisp_Object_Type::Keyword);
assert_equal_string(operands->value.pair.first->value.identifier, "haha");

return pass;
}
@@ -141,13 +141,13 @@ proc test_parse_atom() -> testresult {
Lisp_Object* result = Parser::parse_atom(string, &index_in_text);

assert_equal_type(result, Lisp_Object_Type::Number);
assert_equal_double(result->value.number->value, 123);
assert_equal_double(result->value.number, 123);

++index_in_text;

result = Parser::parse_atom(string, &index_in_text);
assert_equal_type(result, Lisp_Object_Type::Number);
assert_equal_double(result->value.number->value, -1.23e-2);
assert_equal_double(result->value.number, -1.23e-2);

// test strings
++index_in_text;
@@ -161,26 +161,26 @@ proc test_parse_atom() -> testresult {

result = Parser::parse_atom(string, &index_in_text);
assert_equal_type(result, Lisp_Object_Type::Keyword);
assert_equal_string(result->value.keyword->identifier, "key1");
assert_equal_string(result->value.identifier, "key1");

++index_in_text;

result = Parser::parse_atom(string, &index_in_text);
assert_equal_type(result, Lisp_Object_Type::Keyword);
assert_equal_string(result->value.keyword->identifier, "key:2");
assert_equal_string(result->value.identifier, "key:2");

// test symbols
++index_in_text;

result = Parser::parse_atom(string, &index_in_text);
assert_equal_type(result, Lisp_Object_Type::Symbol);
assert_equal_string(result->value.symbol->identifier, "sym");
assert_equal_string(result->value.identifier, "sym");

++index_in_text;

result = Parser::parse_atom(string, &index_in_text);
assert_equal_type(result, Lisp_Object_Type::Symbol);
assert_equal_string(result->value.symbol->identifier, "+");
assert_equal_string(result->value.identifier, "+");

return pass;
}
@@ -193,22 +193,22 @@ proc test_parse_expression() -> testresult {
assert_no_error();

assert_equal_type(result, Lisp_Object_Type::Pair);
assert_equal_type(result->value.pair->first, Lisp_Object_Type::Symbol);
assert_equal_string(result->value.pair->first->value.symbol->identifier, "fun");
assert_equal_type(result->value.pair.first, Lisp_Object_Type::Symbol);
assert_equal_string(result->value.pair.first->value.identifier, "fun");

result = result->value.pair->rest;
result = result->value.pair.rest;

assert_equal_type(result, Lisp_Object_Type::Pair);
assert_equal_type(result->value.pair->first, Lisp_Object_Type::Symbol);
assert_equal_string(result->value.pair->first->value.symbol->identifier, "+");
assert_equal_type(result->value.pair.first, Lisp_Object_Type::Symbol);
assert_equal_string(result->value.pair.first->value.identifier, "+");

result = result->value.pair->rest;
result = result->value.pair.rest;

assert_equal_type(result, Lisp_Object_Type::Pair);
assert_equal_type(result->value.pair->first, Lisp_Object_Type::Number);
assert_equal_double(result->value.pair->first->value.number->value, 12);
assert_equal_type(result->value.pair.first, Lisp_Object_Type::Number);
assert_equal_double(result->value.pair.first->value.number, 12);

result = result->value.pair->rest;
result = result->value.pair.rest;

assert_equal_type(result, Lisp_Object_Type::Nil);

@@ -219,23 +219,23 @@ proc test_parse_expression() -> testresult {
assert_no_error();

assert_equal_type(result, Lisp_Object_Type::Pair);
assert_equal_type(result->value.pair->first, Lisp_Object_Type::Symbol);
assert_equal_string(result->value.pair->first->value.symbol->identifier, "define");
assert_equal_type(result->value.pair.first, Lisp_Object_Type::Symbol);
assert_equal_string(result->value.pair.first->value.identifier, "define");

result = result->value.pair->rest;
result = result->value.pair.rest;

assert_equal_type(result, Lisp_Object_Type::Pair);
assert_equal_type(result->value.pair->first, Lisp_Object_Type::Symbol);
assert_equal_string(result->value.pair->first->value.symbol->identifier, "fun");
assert_equal_type(result->value.pair.first, Lisp_Object_Type::Symbol);
assert_equal_string(result->value.pair.first->value.identifier, "fun");

result = result->value.pair->rest;
result = result->value.pair.rest;

assert_equal_type(result, Lisp_Object_Type::Pair);
assert_equal_type(result->value.pair->first, Lisp_Object_Type::Pair);
assert_equal_type(result->value.pair->first->value.pair->first, Lisp_Object_Type::Symbol);
assert_equal_string(result->value.pair->first->value.pair->first->value.symbol->identifier, "lambda");
assert_equal_type(result->value.pair.first, Lisp_Object_Type::Pair);
assert_equal_type(result->value.pair.first->value.pair.first, Lisp_Object_Type::Symbol);
assert_equal_string(result->value.pair.first->value.pair.first->value.identifier, "lambda");

result = result->value.pair->rest;
result = result->value.pair.rest;

return pass;
}
@@ -248,7 +248,7 @@ proc test_built_in_add() -> testresult {
assert_no_error();
assert_not_null(result);
assert_equal_type(result, Lisp_Object_Type::Number);
assert_equal_double(result->value.number->value, 14);
assert_equal_double(result->value.number, 14);

return pass;
}
@@ -261,7 +261,7 @@ proc test_built_in_substract() -> testresult {
assert_no_error();
assert_not_null(result);
assert_equal_type(result, Lisp_Object_Type::Number);
assert_equal_double(result->value.number->value, 6);
assert_equal_double(result->value.number, 6);

return pass;
}
@@ -275,7 +275,7 @@ proc test_built_in_multiply() -> testresult {
assert_no_error();
assert_not_null(result);
assert_equal_type(result, Lisp_Object_Type::Number);
assert_equal_double(result->value.number->value, 40);
assert_equal_double(result->value.number, 40);

return pass;
}
@@ -289,7 +289,7 @@ proc test_built_in_divide() -> testresult {
assert_no_error();
assert_not_null(result);
assert_equal_type(result, Lisp_Object_Type::Number);
assert_equal_double(result->value.number->value, 5);
assert_equal_double(result->value.number, 5);

return pass;
}
@@ -303,7 +303,7 @@ proc test_built_in_if() -> testresult {
assert_no_error();
assert_not_null(result);
assert_equal_type(result, Lisp_Object_Type::Number);
assert_equal_double(result->value.number->value, 4);
assert_equal_double(result->value.number, 4);

char exp_string2[] = "(if () 4 5)";
expression = Parser::parse_single_expression(exp_string2);
@@ -312,7 +312,7 @@ proc test_built_in_if() -> testresult {
assert_no_error();
assert_not_null(result);
assert_equal_type(result, Lisp_Object_Type::Number);
assert_equal_double(result->value.number->value, 5);
assert_equal_double(result->value.number, 5);

return pass;
}
@@ -393,7 +393,7 @@ proc test_built_in_type() -> testresult {
assert_no_error();
assert_not_null(result);
assert_equal_type(result, Lisp_Object_Type::Keyword);
assert_equal_string(result->value.keyword->identifier, "number");
assert_equal_string(result->value.identifier, "number");

// setting user type
char exp_string2[] = "(prog (set-type a :my-type)(type a))";
@@ -403,7 +403,7 @@ proc test_built_in_type() -> testresult {
assert_no_error();
assert_not_null(result);
assert_equal_type(result, Lisp_Object_Type::Keyword);
assert_equal_string(result->value.keyword->identifier, "my-type");
assert_equal_string(result->value.identifier, "my-type");

// trying to set invalid user type
char exp_string3[] = "(prog (set-type a \"wrong tpye\")(type a))";
@@ -421,7 +421,7 @@ proc test_built_in_type() -> testresult {
assert_no_error();
assert_not_null(result);
assert_equal_type(result, Lisp_Object_Type::Keyword);
assert_equal_string(result->value.keyword->identifier, "number");
assert_equal_string(result->value.identifier, "number");

return pass;
}


+ 11
- 0
todo.org Zobrazit soubor

@@ -13,3 +13,14 @@
;; should output 6
;; outputs 0
#+END_SRC
* SSO

#+begin_src c
Symbol* symbol; // { String* identifier }
Keyword* keyword; // { String* identifier }
Number* number; // { double value }
String* string; // has to stay a pointer
Pair* pair; // { Lisp_Object* first; Lisp_Object* rest }
Function* function; //
cFunction* cFunction; // has to stay a pointer
#+end_src

Zapsat Náhled
Načítá se…
Zrušit
Uložit