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

tests/broken_tests/test_future.expected_results

@@ -0,0 +1,4 @@
+Thread 0 Started!
+0
+FINISHED THREAD 0
+Threads have finished

tests/broken_tests/test_future.krak

@@ -0,0 +1,29 @@
+import future:*
+import io:*
+
+
+fun main() : int {
+    var a = 0
+    var c = fun() : int { 
+    var b = a
+    print("Thread ")
+    print(b)
+    println(" Started!")
+    var x : int = 0
+    for(var i = 1; i < 100; i++;) {
+        x++
+    }
+    return b
+    }
+    
+    var gadget1.construct(c) : future<int>
+    gadget1.run()
+    gadget1.finish()
+
+    println("Threads have finished")
+
+    pthread_exit()
+    println("All Done!")
+
+    return 0
+} 

tests/broken_tests/test_grammer.krak

@@ -0,0 +1,121 @@
+import io:*
+import grammer:*
+import parser:*
+import lexer:*
+import string:*
+import util:*
+import symbol:*
+import tree:*
+import serialize:*
+
+fun main():int {
+
+    /*var a.construct(): grammer*/
+    // delay construction until unserialization or copy_construction now
+    var a: grammer
+
+    var file_name = string("../krakenGrammer.kgm")
+    /*var file_name = string("../simplifiedKrakenGrammer.kgm")*/
+    /*var file_name = string("grammer.kgm")*/
+
+    var compiled_name = file_name + string(".comp_new")
+    var file_contents = read_file(file_name)
+    var loaded_and_valid = false
+
+    if (file_exists(compiled_name)) {
+        println("cached file exists")
+        var pos = 0
+        var binary = read_file_binary(compiled_name)
+        println("read file!")
+        var cached_contents = string()
+        println("made tmp string!")
+        unpack(cached_contents, pos) = unserialize<string>(binary, pos)
+        println("unserialized the string!")
+        if (cached_contents == file_contents) {
+            println("loaded_and_valid, using cached version!")
+            loaded_and_valid = true
+            /*unpack(a, pos) = unserialize<grammer>(binary, pos)*/
+            // avoid extra copies
+            pos = a.unserialize(binary, pos)
+            println("finished unserializeing!!")
+        } else {
+            println("file contents do not match:")
+            println("CACHED:")
+            println(cached_contents)
+            println("REAL:")
+            println(file_contents)
+            println("END")
+        }
+    } else {
+        println("cached file does not exist")
+    }
+    if (!loaded_and_valid) {
+        println("Not loaded_and_valid, re-generating and writing out")
+        /*a = load_grammer(file_contents)*/
+        // copy construct now
+        a.copy_construct(&load_grammer(file_contents))
+        println("grammer loaded, calculate_first_set")
+        a.calculate_first_set()
+        println("grammer loaded, calculate_state_automaton")
+        a.calculate_state_automaton()
+        println("calculated, writing out")
+        write_file_binary(compiled_name, serialize(file_contents) + serialize(a))
+        println("done writing")
+    }
+    /*println(a.to_string())*/
+    var doFirstSet = fun() {
+        println("///////////////////START FIRST SET/////////////")
+        println("//TERMINALS//")
+        a.terminals.for_each( fun(terminal: util::pair<symbol::symbol, regex::regex>) {
+            var set_str = string::string("{ ")
+            a.first_set_map[terminal.first].for_each( fun(sym: symbol::symbol) {
+                set_str += sym.to_string() + ", "
+            })
+            set_str += "}"
+            print(terminal.first.to_string() + " first: " + set_str + "\n")
+        })
+        println("//NON TERMINALS//")
+        a.non_terminals.for_each( fun(non_terminal: symbol::symbol) {
+            var set_str = string::string("{ ")
+            a.first_set_map[non_terminal].for_each( fun(sym: symbol::symbol) {
+                set_str += sym.to_string() + ", "
+            })
+            set_str += "}"
+            print(non_terminal.to_string() + " first: " + set_str + "\n")
+            println()
+        })
+        println("///////////////////END FIRST SET/////////////")
+    }
+    /*doFirstSet()*/
+
+    println(a.to_string())
+    a.parse_table.print_string()
+    var lex = lexer(a.terminals)
+
+   lex.set_input(read_file(string("to_parse.krak")))
+    /*lex.set_input(string("ccdahas spacedhas*/
+/*returndaaaaaaaaaaaaaa"))*/
+    //lex.set_input(string("hibyed"))
+    println("woo lexing:")
+    range(8).for_each(fun(i: int) { println(lex.next().to_string()); } )
+    /*range(80).for_each(fun(i: int) { println(lex.next().to_string()); } )*/
+
+
+    var parse.construct(a): parser
+    /*var result = parse.parse_input(string("a"), string("fun name"))*/
+    /*var result = parse.parse_input(read_file(string("test_adt.krak")), string("fun name"))*/
+    var result = parse.parse_input(read_file(string("to_parse.krak")), string("fun name"))
+    /*var result = parse.parse_input(string("inport a;"), string("fun name"))*/
+    /*var result = parse.parse_input(string("fun main():int { return 0; }"), string("fun name"))*/
+    /*var result = parse.parse_input(string("ad"), string("fun name"))*/
+    /*var result = parse.parse_input(string("hibyed"), string("fun name"))*/
+    /*var result = parse.parse_input(string("hmmhmmend"), string("fun name"))*/
+    /*var result = parse.parse_input(string("hid"), string("fun name"))*/
+    println("the tree")
+    println(syntax_tree_to_dot(result))
+    write_file(string("syntax_tree.dot"), syntax_tree_to_dot(result))
+    /*var parse.construct(): parser*/
+    return 0
+}
+
+

tests/broken_tests/test_trigTest.expected_results

@@ -0,0 +1 @@
+3.141593

tests/broken_tests/test_trigTest.krak

@@ -0,0 +1,40 @@
+import simple_print:*;
+import math:*;
+
+fun main(): int
+{
+  var ans: double;
+  var STD_PI: double = 4.0*atan(1.0);
+  println(STD_PI);
+
+  /*
+  ans = 4.0*atan(1.0);
+  print("atan = ");
+  println(ans);
+
+  ans = atan2(0.0,1.0);
+  print("atan2 = ");
+  println(ans);
+
+  ans = acos(1.0);
+  print("acos = ");
+  println(ans);
+
+  ans = 2.0 * asin(1.0);
+  print("asin = ");
+  println(ans);
+
+  ans = tan(STD_PI / 4.0);
+  print("tan = ");
+  println(ans);
+
+  ans = cos(0.0);
+  print("cos = ");
+  println(ans);
+
+  ans = sin(0.0);
+  print("sin = ");
+  println(ans);
+  */
+  return 0;
+}