From 92f5c63c9a05306071285b6543ecc0a8d32446c0 Mon Sep 17 00:00:00 2001 From: Nathan Braswell Date: Mon, 6 Jul 2015 13:48:19 -0400 Subject: [PATCH] Grammer loading works and test file can lex itself. Got rid of regex memory saftey for speed, will reintroduce next --- stdlib/grammer.krak | 16 +++++++++++----- stdlib/lexer.krak | 6 ++++++ stdlib/regex.krak | 8 ++++---- stdlib/vector.krak | 9 +++++++++ tests/test_grammer.krak | 10 +++++++++- tests/test_vectorTest.expected_results | 8 ++++++++ tests/test_vectorTest.krak | 14 ++++++++++++++ 7 files changed, 61 insertions(+), 10 deletions(-) diff --git a/stdlib/grammer.krak b/stdlib/grammer.krak index c32db10..a00e6ff 100644 --- a/stdlib/grammer.krak +++ b/stdlib/grammer.krak @@ -46,7 +46,7 @@ fun split_into_words(gram_str: string::string): vector::vector { 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 - var regexs: set::set + var regexs: vector::vector 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 } } diff --git a/stdlib/lexer.krak b/stdlib/lexer.krak index 36253d3..fc9503a 100644 --- a/stdlib/lexer.krak +++ b/stdlib/lexer.krak @@ -4,6 +4,12 @@ import string import vector import util +fun lexer(regs: vector::vector): 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 var input: string::string diff --git a/stdlib/regex.krak b/stdlib/regex.krak index ba4fcae..b4de205 100644 --- a/stdlib/regex.krak +++ b/stdlib/regex.krak @@ -56,14 +56,14 @@ obj regex (Object) { } fun copy_construct(old:*regex):void { - //begin = old->begin - //regexString.copy_construct(&old->regexString) - construct(old->regexString) + begin = old->begin + regexString.copy_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 { diff --git a/stdlib/vector.krak b/stdlib/vector.krak index dad5763..6feffdb 100644 --- a/stdlib/vector.krak +++ b/stdlib/vector.krak @@ -127,6 +127,10 @@ obj vector (Object) { return i; return -1; } + // ditto + fun contains(item: U): bool { + return find(item) != -1 + } fun operator[]=(index: int, dataIn: T) { set(index, dataIn) @@ -140,6 +144,11 @@ obj vector (Object) { for (var i = 0; i < dataIn.size; i++;) addEnd(dataIn[i]); } + // same darn trick + fun add_unique(dataIn: U): void { + if (!contains(dataIn)) + addEnd(dataIn) + } fun add(dataIn: T): void { addEnd(dataIn); } fun addEnd(dataIn: T): void { if (size+1 >= available) diff --git a/tests/test_grammer.krak b/tests/test_grammer.krak index 4917b62..f477920 100644 --- a/tests/test_grammer.krak +++ b/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 } diff --git a/tests/test_vectorTest.expected_results b/tests/test_vectorTest.expected_results index 7c1ac58..d531c56 100644 --- a/tests/test_vectorTest.expected_results +++ b/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 diff --git a/tests/test_vectorTest.krak b/tests/test_vectorTest.krak index f872b4e..7bc1934 100644 --- a/tests/test_vectorTest.krak +++ b/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)