move test_compiler up to main kraken.krak and fix linker string, make paths work correctly

.gitignore

@@ -18,3 +18,5 @@ callgrind*
 bintest.bin
 *.dot
 .stfolder
+kraken
+*.c

kraken.krak

@@ -15,8 +15,10 @@ fun main(argc: int, argv: **char):int {
     /*var gram.construct(): grammer*/
     // delay construction until we either load it or copy construct it
     var gram: grammer
-
+    var base_dir = string("/").join(string(argv[0]).split('/').slice(0,-2))
-    var file_name = string("../krakenGrammer.kgm")
+    println(base_dir)
+    var file_name = base_dir + "/krakenGrammer.kgm"
+    println(file_name)
 
     var compiled_name = file_name + string(".comp_new")
     var file_contents = read_file(file_name)
@@ -37,12 +39,12 @@ fun main(argc: int, argv: **char):int {
             pos = gram.unserialize(binary, pos)
             println("finished unserializeing!!")
         } else {
-            println("file contents do not match:")
+            /*println("file contents do not match:")*/
-            println("CACHED:")
+            /*println("CACHED:")*/
-            println(cached_contents)
+            /*println(cached_contents)*/
-            println("REAL:")
+            /*println("REAL:")*/
-            println(file_contents)
+            /*println(file_contents)*/
-            println("END")
+            /*println("END")*/
         }
     } else {
         println("cached file does not exist")
@@ -61,12 +63,13 @@ fun main(argc: int, argv: **char):int {
         println("done writing")
     }
 
-    var kraken_file_name = string("to_parse.krak")
+    if (argc <= 1) {
-    if (argc > 1)
+        error("No input file!\n Call with one argument (the input file), or two arguments (input file and output name)")
-        kraken_file_name = string(argv[1])
+    }
+    var kraken_file_name = string(argv[1])
     var parse.construct(gram): parser
     var ast_pass.construct(): ast_transformation
-    var importer.construct(parse, ast_pass, vector(string(), string("../stdlib/"))): importer
+    var importer.construct(parse, ast_pass, vector(string(), base_dir + "/stdlib/")): importer
     importer.import(kraken_file_name)
     println("NOW DOING C_GENERATOR")
     var c_generator.construct(): c_generator
@@ -74,7 +77,13 @@ fun main(argc: int, argv: **char):int {
     var kraken_c_output_name = kraken_file_name + ".c"
     write_file(kraken_c_output_name, c_output_pair.first)
     println(string("linker string: ") + c_output_pair.second)
-    system(string("cc -g -O3 -std=c99 ") + kraken_c_output_name + " -o " + kraken_file_name + ".exe")
+
+    var executable_name = string(".").join(kraken_file_name.split('.').slice(0,-2))
+    if (argc == 3)
+        executable_name = string(argv[2])
+    var compile_string = "cc -g -O3 -std=c99 " + c_output_pair.second + " " + kraken_c_output_name + " -o " + executable_name
+    println(compile_string)
+    system(compile_string)
 
     return 0
 }

stdlib/ast_transformation.krak

@@ -554,6 +554,7 @@ obj ast_transformation (Object) {
             return new_passthrough
         var in_passthrough_params = get_node("in_passthrough_params", passthrough_params)
         var out_passthrough_params = get_node("out_passthrough_params", passthrough_params)
+        var linker_str = get_node("opt_string", passthrough_params)
         if (in_passthrough_params)
             get_nodes("param_assign", in_passthrough_params).for_each(fun(p: *tree<symbol>) {
                 var idents = get_nodes("identifier", p)
@@ -570,6 +571,8 @@ obj ast_transformation (Object) {
                 else
                     new_passthrough->simple_passthrough.out_params.add(make_pair(transform_identifier(idents[0], scope, search_type::none()), concat_symbol_tree(idents[0])))
             })
+        if (linker_str)
+            new_passthrough->simple_passthrough.linker_str = concat_symbol_tree(linker_str).slice(1,-2)
         return new_passthrough
     }
     fun transform_statement(node: *tree<symbol>, scope: *ast_node, template_replacements: map<string, *type>): *ast_node return ast_statement_ptr(transform(node->children[0], scope, template_replacements));

stdlib/c_generator.krak

@@ -82,6 +82,7 @@ obj c_generator (Object) {
     var closure_struct_definitions: string
     var replacement_map: map<string, string>
     var longest_replacement: int
+    var linker_string: string
     fun construct(): *c_generator {
         id_counter = 0
         ast_name_map.construct()
@@ -89,6 +90,7 @@ obj c_generator (Object) {
         function_type_map.construct()
         function_typedef_string.construct()
         closure_struct_definitions.construct()
+        linker_string.construct()
         replacement_map.construct()
         // IMPORTANT
         longest_replacement = 3
@@ -146,6 +148,7 @@ obj c_generator (Object) {
         closure_struct_definitions.copy_construct(&old->closure_struct_definitions)
         replacement_map.copy_construct(&old->replacement_map)
         longest_replacement = old->longest_replacement
+        linker_string.copy_construct(&old->linker_string)
     }
     fun operator=(other: ref c_generator) {
         destruct()
@@ -158,6 +161,7 @@ obj c_generator (Object) {
         function_typedef_string.destruct()
         closure_struct_definitions.destruct()
         replacement_map.destruct()
+        linker_string.destruct()
     }
     fun get_id(): string return to_string(id_counter++);
     fun generate_function_prototype_and_header(child: *ast_node, enclosing_object: *ast_node, is_lambda: bool, defer_stack: *stack<pair<bool,stack<*ast_node>>>):pair<string,string> {
@@ -193,7 +197,6 @@ obj c_generator (Object) {
                          type_to_c(backing.type->return_type) + " " + decorated_name + "(" + parameters + ")")
     }
     fun generate_c(name_ast_map: map<string, pair<*tree<symbol>,*ast_node>>): pair<string,string> {
-        var linker_string:string = ""
         var prequal: string = "#include <stdbool.h>\n#include <stdlib.h>\n#include <stdio.h>\n"
         var plain_typedefs: string = "\n/**Plain Typedefs**/\n"
         var top_level_c_passthrough: string = ""
@@ -455,6 +458,8 @@ obj c_generator (Object) {
         var result = string()
         var pre = string()
         var post = string()
+        if (node->simple_passthrough.linker_str != "")
+            linker_string += node->simple_passthrough.linker_str + " "
         node->simple_passthrough.in_params.for_each(fun(i: pair<*ast_node, string>) {
             var wanted_name = i.second
             var current_name = generate_identifier(i.first, null<ast_node>(), null<ast_node>()).one_string()
@@ -701,7 +706,7 @@ obj c_generator (Object) {
             closed_vars.for_each(fun(i: *ast_node) {
                 // note that we get/have gotten rid of refs here, or maybe more accurately, everything is a ref
                 // should be a variable anyway?
-                to_ret.pre += string(".") + get_name(i) + "=&" + generate(i, enclosing_object, enclosing_func, null<stack<pair<bool,stack<*ast_node>>>>(), true).one_string() + ","
+                to_ret.pre += string(".") + get_name(i) + "=(void*)&" + generate(i, enclosing_object, enclosing_func, null<stack<pair<bool,stack<*ast_node>>>>(), true).one_string() + ","
             })
             to_ret.pre += "};\n"
             return to_ret + string("((") + type_to_c(node->function.type) + "){(void*)&" + temp_closure_struct + ",(void*)" + get_name(node) + "})"

stdlib/string.krak

@@ -189,6 +189,12 @@ obj string (Object, Serializable) {
         out.add(current)
         return out
     }
+    fun join(to_join: vector::vector<string>): string {
+        var to_ret = to_join.first()
+        for (var i = 1; i < to_join.size; i++;)
+            to_ret += *this + to_join[i]
+        return to_ret
+    }
     fun for_each(func: fun(char):void) {
         data.for_each(func)
     }

tests/grammer.kgm

@@ -1,16 +0,0 @@
-# comment
-a = b ;
-b = "c":named_c ;
-b = c "d":dname ;
-c = "a" | d ;
-d = "has space" ;
-d = "has
-return" ;
-d = "has \"" ;
-d = "has 
-ll\"
-\\\"y8\" \\\\" ;
-d   =    "has space"      ;
-d = e ;
-e = f | ;
-f = ;

tests/grammer2.kgm

@@ -1,16 +0,0 @@
-# comment
-Goal = a ;
-a = b | rec "end" ;
-b = "c":named_c ;
-b = c "d":dname ;
-c = "a" | d ;
-d = e post_null post_non_null inherit_null ;
-inherit_null = e | post_non_null ;
-e = ;
-e = g ;
-#e = e | g ;
-f = ;
-g = f ;
-post_null = "hi" ;
-post_non_null = "bye" ;
-rec = "hmm" rec | ;

tests/grammer3.kgm

@@ -1,3 +0,0 @@
-# comment
-Goal = a ;
-a = "hi" "d":dname ;

tests/grammer4.kgm

@@ -1,5 +0,0 @@
-# comment
-Goal = a ;
-a = "a" d ;
-d = g ;
-g = ;

tests/new_runner.sh

@@ -1,6 +1,6 @@
 #!/bin/bash
 
-runner_path="./tester/tester"
+runner_path="./tester"
 #testDir=${1:-"../tests"}
 testDir="."
 ext=${2:-"krak"}

tests/tester.krak

@@ -8,7 +8,7 @@ fun error(message: *char) {
 }
 
 fun main(argc: int, argv: **char): int {
-    var kraken_path = string("./test_compiler/test_compiler")
+    var kraken_path = string("../kraken")
     var all_results = string()
     var num_passed = 0
     var name_length = 0
@@ -28,7 +28,7 @@ fun main(argc: int, argv: **char): int {
         if (system(kraken_path + " " + test_name + ".krak")) error("could not compile")
         var results_file_name = test_name + ".results"
         var expected_results_file_name = test_name + ".expected_results"
-        if (system(string("./") + test_name + ".krak.exe > " + results_file_name)) error("could not run")
+        if (system(string("./") + test_name + " > " + results_file_name)) error("could not run")
         if (file_exists(results_file_name) && file_exists(expected_results_file_name) && read_file(results_file_name) == read_file(expected_results_file_name)) {
             println(test_name + "\tPASSED!")
             all_results += pad_with_spaces(test_name) + "\tPASSED!\n"
@@ -39,6 +39,7 @@ fun main(argc: int, argv: **char): int {
             all_results += pad_with_spaces(test_name) + "\tFAILED!!!\n"
         }
         system(string("rm ./") + test_name + ".krak.*")
+        system(string("rm ./") + test_name)
     }
     println(string("\n\nTEST RESULTS: ") + num_passed + "/" + (argc-1))
     println(all_results)

tests/to_parse.krak

@@ -1,13 +0,0 @@
-import simple_print: *
-fun main(): int {
-    var data = 7
-    var v: fun():int
-    v = fun(): int {
-        println(data)
-        return data
-    }
-    println(v())
-      // println(print_and_return(7))
-    return 0
-}
-