Grammer loading works and test file can lex itself. Got rid of regex memory saftey for speed, will reintroduce next

stdlib/grammer.krak

@@ -46,7 +46,7 @@ fun split_into_words(gram_str: string::string): vector::vector<string::string> {
     return out
 }
 
-fun load_grammer(path: string::string): grammer {
+fun load_grammer(gram_str: string::string): grammer {
     var gram.construct(): grammer
     var leftSide = symbol::symbol("", false)
     var doLeftSide = true
@@ -55,7 +55,7 @@ fun load_grammer(path: string::string): grammer {
         /*io::print("word: "); io::println(word);*/
     /*})*/
     /*return gram*/
-    split_into_words(io::read_file(path)).for_each(fun(word: string::string) {
+    split_into_words(gram_str).for_each(fun(word: string::string) {
         if (word == "=") {
             // do nothing
         } else if (word == "|") {
@@ -69,7 +69,13 @@ fun load_grammer(path: string::string): grammer {
             if (doLeftSide)
                 leftSide = symbol::symbol(word, true)
             else
-                rightSide.add(symbol::symbol(word, word[0] == '"'))
+                if (word[0] == '"') {
+                    rightSide.add(symbol::symbol(word.slice(1,-2), true))
+                    /*gram.regexs.add_unique(regex::regex(word.slice(1,-2)))*/
+                    gram.regexs.add(regex::regex(word.slice(1,-2)))
+                } else {
+                    rightSide.add(symbol::symbol(word, false))
+                }
             doLeftSide = false
         }
     })
@@ -78,7 +84,7 @@ fun load_grammer(path: string::string): grammer {
 
 obj grammer (Object) {
     var rules: vector::vector<rule>
-    var regexs: set::set<regex::regex>
+    var regexs: vector::vector<regex::regex>
 
     fun construct(): *grammer {
         rules.construct()
@@ -143,7 +149,7 @@ obj rule (Object) {
 
     fun to_string(): string::string {
         var result = lhs.name + " -> "
-        rhs.for_each( fun(i : symbol::symbol) { result += i.name + ", "; } )
+        rhs.for_each( fun(i : symbol::symbol) { result += i.to_string() + ", "; } )
         return result
     }
 }

stdlib/lexer.krak

@@ -4,6 +4,12 @@ import string
 import vector
 import util
 
+fun lexer(regs: vector::vector<regex::regex>): lexer {
+    var toRet.construct() :lexer
+    regs.for_each( fun(reg: regex::regex) toRet.add_regex(reg); )
+    return toRet
+}
+
 obj lexer (Object) {
     var regs: vector::vector<regex::regex>
     var input: string::string

stdlib/regex.krak

@@ -56,14 +56,14 @@ obj regex (Object) {
     }
 
     fun copy_construct(old:*regex):void {
-        //begin = old->begin
+        begin = old->begin
-        //regexString.copy_construct(&old->regexString)
+        regexString.copy_construct(&old->regexString)
-        construct(old->regexString)
+        /*construct(old->regexString)*/
     }
 
     fun destruct():void {
         regexString.destruct()
-        mem::safe_recursive_delete(begin, fun(it: *regexState): set::set<*regexState> { return set::from_vector(it->next_states); } )
+        /*mem::safe_recursive_delete(begin, fun(it: *regexState): set::set<*regexState> { return set::from_vector(it->next_states); } )*/
     }
 
     fun operator==(other: regex):bool {

stdlib/vector.krak

@@ -127,6 +127,10 @@ obj vector<T> (Object) {
                 return i;
         return -1;
     }
+    // ditto
+    fun contains<U>(item: U): bool {
+        return find(item) != -1
+    }
 
     fun operator[]=(index: int, dataIn: T) {
         set(index, dataIn)
@@ -140,6 +144,11 @@ obj vector<T> (Object) {
         for (var i = 0; i < dataIn.size; i++;)
             addEnd(dataIn[i]);
     }
+    // same darn trick
+    fun add_unique<U>(dataIn: U): void {
+        if (!contains(dataIn))
+            addEnd(dataIn)
+    }
     fun add(dataIn: T): void { addEnd(dataIn); }
     fun addEnd(dataIn: T): void {
         if (size+1 >= available)

tests/test_grammer.krak

@@ -1,11 +1,19 @@
 import io:*
 import grammer:*
+import lexer:*
 import string:*
+import util:*
 
 fun main():int {
-    var a = load_grammer(string("../krakenGrammer.kgm"))
+    var a = load_grammer(read_file(string("../krakenGrammer.kgm")))
     /*var a = load_grammer(string("grammer.kgm"))*/
     println(a.to_string())
+    var lex = lexer(a.regexs)
+    lex.set_input(read_file(string("test_grammer.krak")))
+    /*lex.set_input(string("ccdahas spacedhas*/
+/*returndaaaaaaaaaaaaaa"))*/
+    println("woo lexing:")
+    range(80).for_each(fun(i: int) { println(lex.next().to_string()); } )
     return 0
 }
 

tests/test_vectorTest.expected_results

@@ -26,6 +26,14 @@ find test
 0
 1
 2
+contains test
+false
+true
+true
+true
+false
+add_unique test
+ 1 2 3 4
 set, []=, and delete test
 4
 8

tests/test_vectorTest.krak

@@ -115,6 +115,20 @@ fun main(): int {
     println(multipleFindTest.find(2))
     println(multipleFindTest.find(3))
 
+    println("contains test")
+    println(multipleFindTest.contains(0))
+    println(multipleFindTest.contains(1))
+    println(multipleFindTest.contains(2))
+    println(multipleFindTest.contains(3))
+    println(multipleFindTest.contains(4))
+
+    println("add_unique test")
+    multipleFindTest.add_unique(1)
+    multipleFindTest.add_unique(4)
+    multipleFindTest.add_unique(4)
+    multipleFindTest.for_each( fun(i:int) { print(" "); print(i); } )
+    println()
+
     println("set, []=, and delete test")
     var setTest = vector(4,5,6)
     setTest.add(7)