slime version 0.2

src/globals.cpp

@@ -1,6 +1,6 @@
 namespace Slime {
 #define v_major 0
-#define v_minor 1
+#define v_minor 2
 #define STRINGIZE2(s) #s
 #define STRINGIZE(s) STRINGIZE2(s)
 #define VERSION_STRING "v" STRINGIZE(v_major) "." STRINGIZE(v_minor) " - built on " __DATE__ " " __TIME__

src/io.cpp

@@ -324,6 +324,8 @@ namespace Slime {
             string_builder.dealloc();
         };
 
+        if (!node) return _strdup("<nullptr>");
+
         switch (node->type) {
         case (Lisp_Object_Type::Nil):          return _strdup("()");
         case (Lisp_Object_Type::T):            return _strdup("t");

src/testing.cpp

@@ -317,7 +317,16 @@ namespace Slime {
         return pass;
     }
 
-    proc test_built_in_add() -> testresult {
+    proc test_string_copy() -> testresult {
+        Lisp_Object* str = Memory::create_lisp_object("Hello World");
+        Lisp_Object* cpy = Memory::copy_lisp_object(str);
+        assert_not_equal_int(str,  cpy);
+        assert_not_equal_int(str->value.string.data,  cpy->value.string.data);
+        return pass;
+    }
+
+    proc test_simple_stuff() -> testresult {
+        {   // built in add
             char exp_string[] = "(+ 10 4)";
             Lisp_Object* expression = Parser::parse_single_expression(exp_string);
             Lisp_Object* result;
@@ -327,11 +336,8 @@ namespace Slime {
             assert_not_null(result);
             assert_equal_type(result, Lisp_Object_Type::Number);
             assert_equal_f64(result->value.number, 14);
-
-        return pass;
         }
-
+        {   // built in subtract
-    proc test_built_in_substract() -> testresult {
             char exp_string[] = "(- 10 4)";
             Lisp_Object* expression = Parser::parse_single_expression(exp_string);
             Lisp_Object* result;
@@ -342,12 +348,8 @@ namespace Slime {
             assert_not_null(result);
             assert_equal_type(result, Lisp_Object_Type::Number);
             assert_equal_f64(result->value.number, 6);
-
-        return pass;
         }
-
+        {   // built in multiply
-
-    proc test_built_in_multiply() -> testresult {
             char exp_string[] = "(* 10 4)";
             Lisp_Object* expression = Parser::parse_single_expression(exp_string);
             Lisp_Object* result;
@@ -357,12 +359,8 @@ namespace Slime {
             assert_not_null(result);
             assert_equal_type(result, Lisp_Object_Type::Number);
             assert_equal_f64(result->value.number, 40);
-
-        return pass;
         }
-
+        {   // built in divide
-
-    proc test_built_in_divide() -> testresult {
             char exp_string[] = "(/ 20 4)";
             Lisp_Object* expression = Parser::parse_single_expression(exp_string);
             Lisp_Object* result;
@@ -372,12 +370,8 @@ namespace Slime {
             assert_not_null(result);
             assert_equal_type(result, Lisp_Object_Type::Number);
             assert_equal_f64(result->value.number, 5);
-
-        return pass;
         }
-
+        {   // built in if
-
-    proc test_built_in_if() -> testresult {
             char exp_string1[] = "(if 1 4 5)";
             Lisp_Object* expression = Parser::parse_single_expression(exp_string1);
             Lisp_Object* result;
@@ -396,11 +390,8 @@ namespace Slime {
             assert_not_null(result);
             assert_equal_type(result, Lisp_Object_Type::Number);
             assert_equal_f64(result->value.number, 5);
-
-        return pass;
         }
-
+        {   // built in and
-    proc test_built_in_and() -> testresult {
             char exp_string1[] = "(and 1 \"asd\" 4)";
             Lisp_Object* expression = Parser::parse_single_expression(exp_string1);
             Lisp_Object* result;
@@ -418,11 +409,8 @@ namespace Slime {
             assert_no_error();
             assert_not_null(result);
             assert_equal_type(result, Lisp_Object_Type::Nil);
-
-        return pass;
         }
-
+        {   // built in or
-    proc test_built_in_or() -> testresult {
             char exp_string1[] = "(or \"asd\" nil)";
             Lisp_Object* expression = Parser::parse_single_expression(exp_string1);
             Lisp_Object* result;
@@ -440,12 +428,8 @@ namespace Slime {
             assert_no_error();
             assert_not_null(result);
             assert_equal_type(result, Lisp_Object_Type::Nil);
-
-        return pass;
         }
-
+        {   // buit in not
-
-    proc test_built_in_not() -> testresult {
             char exp_string1[] = "(not ())";
             Lisp_Object* expression = Parser::parse_single_expression(exp_string1);
             Lisp_Object* result;
@@ -464,14 +448,8 @@ namespace Slime {
             assert_no_error();
             assert_not_null(result);
             assert_equal_type(result, Lisp_Object_Type::Nil);
-
-        return pass;
         }
-
+        {   // built in type
-    proc test_built_in_type() -> testresult {
-        // Environment* env;
-        // try env = get_root_environment();
-
             // normal type testing
             char exp_string1[] = "(begin (define a 10)(type a))";
             Lisp_Object* expression = Parser::parse_single_expression(exp_string1);
@@ -492,20 +470,6 @@ namespace Slime {
             assert_equal_type(result, Lisp_Object_Type::Keyword);
             assert_equal_string(result->value.symbol, "my-type");
 
-        // // trying to set invalid user type
-        // char exp_string3[] = "(begin (set-type! a \"wrong tpye\")(type a))";
-        // expression = Parser::parse_single_expression(exp_string3);
-        // assert_no_error();
-
-        // ignore_logging {
-        //     dont_break_on_errors {
-        //         result = eval_expr(expression);
-        //     }
-        // }
-
-        // assert_error();
-        // delete_error();
-
             // deleting user type
             char exp_string4[] = "(begin (delete-type! a)(type a))";
             expression = Parser::parse_single_expression(exp_string4);
@@ -515,7 +479,7 @@ namespace Slime {
             assert_not_null(result);
             assert_equal_type(result, Lisp_Object_Type::Keyword);
             assert_equal_string(result->value.symbol, "number");
-
+        }
         return pass;
     }
 
@@ -604,15 +568,8 @@ namespace Slime {
         invoke_test(test_parse_expression);
 
         printf("\n-- Built ins --\n");
-        invoke_test(test_built_in_add);
+        invoke_test(test_simple_stuff);
-        invoke_test(test_built_in_substract);
+        invoke_test(test_string_copy);
-        invoke_test(test_built_in_multiply);
-        invoke_test(test_built_in_divide);
-        invoke_test(test_built_in_if);
-        invoke_test(test_built_in_and);
-        invoke_test(test_built_in_or);
-        invoke_test(test_built_in_not);
-        // invoke_test(test_built_in_type);
 
         printf("\n-- Memory management --\n");
         invoke_test(test_singular_t_and_nil);

todo.org

@@ -20,14 +20,16 @@
   CLOSED: [2020-03-29 So 21:27]
 * DONE use better type names: u32, ..
   CLOSED: [2020-03-31 Di 11:36]
-* TODO when copying LO<string>, check if string itself is being copied
+* DONE when copying LO<string>, check if string itself is being copied
+  CLOSED: [2020-03-31 Di 11:58]
+* DONE update header files
+  CLOSED: [2020-03-31 Di 11:58]
 * TODO define-syntax-shorthand
 (define-syntax-shorthand [ vector ] )
 (define-syntax-shorthand { hash-map } )
 * TODO doc generation
-* TODO assert list_length for arguemns of macros
+* TODO assert list length for arguemns of macros
  ???
-* TODO update header files
 * TODO source code locations
 * TODO function let
 (let fac ([n 10])