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

fixed into for cFunction args

Browse Source
This commit is contained in:
Felix Brendel
2019-09-19 13:47:34 +02:00
parent d32c9596ba
commit 5f90f2877f
3 changed files with 75 additions and 72 deletions
Download Patch File Download Diff File Expand all files Collapse all files
build.sh
Regular → Executable
View File
src/built_ins.cpp
+75 -71
View File
@@ -106,7 +106,8 @@ proc load_built_ins_into_environment() -> void {
#define fetch1(var) \ #define fetch1(var) \
static Lisp_Object* var##_symbol = Memory::get_or_create_lisp_object_symbol(#var); \ static Lisp_Object* var##_symbol = Memory::get_or_create_lisp_object_symbol(#var); \
Lisp_Object* var = lookup_symbol(var##_symbol, get_current_environment()) Lisp_Object* var = lookup_symbol(var##_symbol, get_current_environment()); \
if (Globals::error) printf("in %s:%d\n", __FILE__, __LINE__)
#define fetch2(var1, var2) fetch1(var1); fetch1(var2) #define fetch2(var1, var2) fetch1(var1); fetch1(var2)
#define fetch3(var1, var2, var3) fetch2(var1, var2); fetch1(var3) #define fetch3(var1, var2, var3) fetch2(var1, var2); fetch1(var3)
@@ -320,19 +321,19 @@ proc load_built_ins_into_environment() -> void {
return nullptr; return nullptr;
}; };
define_special((define-syntax form (:doc "") . body), "TODO") { define_special((define-syntax form (:doc "") . body), "TODO") {
// fetch(form, doc, body); fetch(form, doc, body);
static Lisp_Object *form_symbol = Memory::get_or_create_lisp_object_symbol("form"); // static Lisp_Object *form_symbol = Memory::get_or_create_lisp_object_symbol("form");
static Lisp_Object *doc_symbol = Memory::get_or_create_lisp_object_symbol("doc"); // static Lisp_Object *doc_symbol = Memory::get_or_create_lisp_object_symbol("doc");
static Lisp_Object *body_symbol = Memory::get_or_create_lisp_object_symbol("body"); // static Lisp_Object *body_symbol = Memory::get_or_create_lisp_object_symbol("body");
printf("\n\nin define-syntax:: envi stack depth: %d\n", // printf("\n\nin define-syntax:: envi stack depth: %d\n",
Globals::Current_Execution::envi_stack.next_index); // Globals::Current_Execution::envi_stack.next_index);
print_environment(get_current_environment()); // print_environment(get_current_environment());
Lisp_Object *form = lookup_symbol(form_symbol, get_current_environment()); // Lisp_Object *form = lookup_symbol(form_symbol, get_current_environment());
Lisp_Object *doc = lookup_symbol(doc_symbol, get_current_environment()); // Lisp_Object *doc = lookup_symbol(doc_symbol, get_current_environment());
Lisp_Object *body = lookup_symbol(body_symbol, get_current_environment()); // Lisp_Object *body = lookup_symbol(body_symbol, get_current_environment());
assert_type(doc, Lisp_Object_Type::String); assert_type(doc, Lisp_Object_Type::String);
// if no doc string, we dont have to store it // if no doc string, we dont have to store it
@@ -823,79 +824,82 @@ proc load_built_ins_into_environment() -> void {
print(n); print(n);
Lisp_Object* type; Lisp_Object* type;
Lisp_Object* val;
in_caller_env { in_caller_env {
try type = eval_expr(Memory::create_list(Memory::get_or_create_lisp_object_symbol("type"), n)); try type = eval_expr(Memory::create_list(Memory::get_or_create_lisp_object_symbol("type"), n));
try val = eval_expr(n);
} }
if (type) { printf(" is of type ");
Lisp_Object* val; print(type);
in_caller_env { printf(" (internal: %s)", Lisp_Object_Type_to_string(Memory::get_type(val)));
try Lisp_Object* val = eval_expr(n); printf("\nand is printed as: ");
} print(val);
printf(" is of type "); printf("\n\ndocs: \n %s\n",
print(type); (val->docstring)
printf("\nand is printed as: "); ? Memory::get_c_str(val->docstring)
print(val); : "No docs avaliable");
printf("\n\ndocs: \n %s\n",
(val->docstring)
? Memory::get_c_str(val->docstring)
: "No docs avaliable");
// TODO(Felix): Maybe don't compare strings here?? Wtf if (Memory::get_type(val) == Lisp_Object_Type::Function ||
if (Memory::get_type(type) == Lisp_Object_Type::Keyword && Memory::get_type(val) == Lisp_Object_Type::CFunction)
(string_equal(type->value.symbol.identifier, "lambda") || {
string_equal(type->value.symbol.identifier, "special-lambda") || Arguments* args;
string_equal(type->value.symbol.identifier, "macro"))) if (Memory::get_type(val) == Lisp_Object_Type::Function)
{ args = &val->value.function.args;
Lisp_Object* fun = eval_expr(n); else
args = &val->value.cFunction->args;
if (fun->docstring) printf("Arguments:\n==========\n");
printf("Docstring:\n==========\n%s\n\n", Memory::get_c_str(fun->docstring)); printf("Postitional: {");
else if (args->positional.symbols.next_index != 0) {
printf("No docstring avaliable\n"); printf("%s",
Memory::get_c_str(args->positional.symbols.data[0]->value.symbol.identifier));
printf("Arguments:\n==========\n"); for (int i = 1; i < args->positional.symbols.next_index; ++i) {
printf("Postitional: {"); printf(", %s",
if (fun->value.function.args.positional.symbols.next_index != 0) { Memory::get_c_str(args->positional.symbols.data[i]->value.symbol.identifier));
printf("%s",
Memory::get_c_str(fun->value.function.args.positional.symbols.data[0]->value.symbol.identifier));
for (int i = 1; i < fun->value.function.args.positional.symbols.next_index; ++i) {
printf(", %s",
Memory::get_c_str(fun->value.function.args.positional.symbols.data[i]->value.symbol.identifier));
}
} }
printf("}\n"); }
printf("Keyword: {"); printf("}\n");
if (fun->value.function.args.keyword.values.next_index != 0) { printf("Keyword: {");
printf("%s", if (args->keyword.values.next_index != 0) {
Memory::get_c_str(fun->value.function.args.keyword.keywords.data[0]->value.symbol.identifier)); printf("%s",
if (fun->value.function.args.keyword.values.data[0]) { Memory::get_c_str(args->keyword.keywords.data[0]->value.symbol.identifier));
if (args->keyword.values.data[0]) {
printf(" (");
print(args->keyword.values.data[0], true);
printf(")");
}
for (int i = 1; i < args->keyword.values.next_index; ++i) {
printf(", %s",
Memory::get_c_str(args->keyword.keywords.data[i]->value.symbol.identifier));
if (args->keyword.values.data[i]) {
printf(" ("); printf(" (");
print(fun->value.function.args.keyword.values.data[0]); print(args->keyword.values.data[i], true);
printf(")"); printf(")");
} }
for (int i = 1; i < fun->value.function.args.keyword.values.next_index; ++i) {
printf(", %s",
Memory::get_c_str(fun->value.function.args.keyword.keywords.data[i]->value.symbol.identifier));
if (fun->value.function.args.keyword.values.data[i]) {
printf(" (");
print(fun->value.function.args.keyword.values.data[i]);
printf(")");
}
}
} }
printf("}\n");
printf("Rest: {");
if (fun->value.function.args.rest)
printf("%s",
Memory::get_c_str(fun->value.function.args.rest));
printf("}\n");
} }
} else { printf("}\n");
printf(" is not defined\n"); printf("Rest: {");
delete_error(); if (args->rest)
printf("%s",
Memory::get_c_str(args->rest->value.symbol.identifier));
printf("}\n");
} }
// }
// // TODO(Felix): Maybe don't compare strings here?? Wtf
// if (Memory::get_type(type) == Lisp_Object_Type::Keyword &&
// (string_equal(type->value.symbol.identifier, "lambda") ||
// string_equal(type->value.symbol.identifier, "special-lambda") ||
// string_equal(type->value.symbol.identifier, "macro")))
// {
// Lisp_Object* fun = eval_expr(n);
// if (fun->docstring)
// printf("Docstring:\n==========\n%s\n\n", Memory::get_c_str(fun->docstring));
// else
// printf("No docstring avaliable\n");
return Memory::nil; return Memory::nil;
}; };
src/main.cpp
-1
View File
@@ -1,7 +1,6 @@
#include "slime.h" #include "slime.h"
int main(int argc, char* argv[]) { int main(int argc, char* argv[]) {
if (argc > 1) { if (argc > 1) {
if (Slime::string_equal(argv[1], "--run-tests")) { if (Slime::string_equal(argv[1], "--run-tests")) {
int res = Slime::run_all_tests(); int res = Slime::run_all_tests();