Optimization of string and vector with references and less functional code, bugfix of closing over references

src/CGenerator.cpp

@@ -289,6 +289,7 @@ CCodeTriple CGenerator::generate(NodeTree<ASTData>* from, NodeTree<ASTData>* enc
 		{
             std::string preName = "";
             std::string postName = "";
+            bool closed = false;
             // check for this being a closed over variable
             // first, get declaring function, if it exists
             if (enclosingFunction) {
@@ -297,6 +298,7 @@ CCodeTriple CGenerator::generate(NodeTree<ASTData>* from, NodeTree<ASTData>* enc
                     if (enclosingFunction->getDataRef()->closedVariables.find(from) != enclosingFunction->getDataRef()->closedVariables.end()) {
                         preName += "(*closed_variables->";
                         postName += ")";
+                        closed = true;
                     }
                 }
             }
@@ -311,8 +313,8 @@ CCodeTriple CGenerator::generate(NodeTree<ASTData>* from, NodeTree<ASTData>* enc
 			//If we're in an object method, and our enclosing scope is that object, we're a member of the object and should use the this reference.
 			if (enclosingObject && enclosingObject->getDataRef()->scope.find(data.symbol.getName()) != enclosingObject->getDataRef()->scope.end())
 				preName += "this->";
-            // dereference references, but only if inside a function
-			if (enclosingFunction && data.valueType->is_reference) {
+            // dereference references, but only if inside a function and not if this is a closed over variable
+			if (enclosingFunction && data.valueType->is_reference && !closed) {
 				preName += "(*";
                 postName += ")";
             }
@@ -924,7 +926,7 @@ std::string CGenerator::closureStructType(std::set<NodeTree<ASTData>*> closedVar
         //auto tmp = var->getDataRef()->valueType->withIncreasedIndirection();
         std::string varName = var->getDataRef()->symbol.getName();
         varName = (varName == "this") ? varName : scopePrefix(var) + varName;
-        typedefString += ValueTypeToCType(var->getDataRef()->valueType, "*"+varName) + ";";
+        typedefString += ValueTypeToCType(var->getDataRef()->valueType->withoutReference(), "*"+varName) + ";";
     }
     std::string structName = "closureStructType" + getID();
     typedefString += " } " + structName + ";\n";

stdlib/string.krak

@@ -3,7 +3,7 @@ import util
 import mem
 
 fun string(in:*char):string {
-    var out:string = in
+    var out.construct(in):string
     return out
 }
 
@@ -22,11 +22,11 @@ obj string (Object) {
         // no null terminator
         return this;
     }
-    fun construct(vec: vector::vector<char>): *string {
+    fun construct(vec: ref vector::vector<char>): *string {
         data.copy_construct(&vec);
         return this;
     }
-    fun construct(str: string): *string {
+    fun construct(str: ref string): *string {
         return construct(str.data);
     }
 
@@ -43,7 +43,7 @@ obj string (Object) {
         construct(str)
     }
 
-    fun operator=(str: string): void {
+    fun operator=(str: ref string): void {
         destruct();
         data.copy_construct(&str.data)
     }
@@ -62,8 +62,15 @@ obj string (Object) {
     }
     fun length():int { return data.size; }
 
-    fun operator==(other: string): bool {
-        return length() == other.length() && !util::range(length()).any_true(fun(i: int):bool { return data[i] != other[i]; } )
+    fun operator==(other: ref string): bool {
+        // you were too good for this world
+        //return length() == other.length() && !util::range(length()).any_true(fun(i: int):bool { return data[i] != other[i]; } )
+        if (data.size != other.data.size)
+            return false
+        for (var i = 0; i < data.size; i++;)
+            if (data.data[i] != other.data.data[i])
+                return false
+        return true
     }
     fun operator==(other: *char): bool {
         var str.construct(other) : string
@@ -76,7 +83,7 @@ obj string (Object) {
         return ret
     }
 
-    fun operator+(str: string): string {
+    fun operator+(str: ref string): string {
         var newStr.construct(str):string
         var ret.construct(data + newStr.data):string
         return ret
@@ -91,9 +98,10 @@ obj string (Object) {
         data += newStr.data
     }
 
-    fun operator+=(str: string): void {
-        var newStr.construct(str):string
-        data += newStr.data
+    fun operator+=(str: ref string): void {
+        //var newStr.construct(str):string
+        //data += newStr.data
+        data += str.data
     }
 
     fun toCharArray(): *char {

stdlib/symbol.krak

@@ -54,14 +54,14 @@ obj symbol (Object) {
         name.copy_construct(&old->name)
         terminal = old->terminal
     }
-    fun operator=(old: symbol) {
+    fun operator=(old: ref symbol) {
         destruct()
         copy_construct(&old)
     }
-    fun operator==(other: symbol): bool {
+    fun operator==(other: ref symbol): bool {
         return data == other.data && name == other.name && terminal == other.terminal;
     }
-    fun operator!=(other: symbol): bool {
+    fun operator!=(other: ref symbol): bool {
         return !(*this == other);
     }
     fun to_string(): string::string {

stdlib/vector.krak

@@ -24,11 +24,19 @@ obj vector<T> (Object) {
         data = new<T>(8);
         return this;
     }
+    fun construct(ammt: int): *vector<T> {
+        size = 0;
+        available = ammt;
+        data = new<T>(ammt);
+        return this;
+    }
 
     fun copy_construct(old: *vector<T>): void {
-        construct()
+        construct(old->size)
+        size = old->size
         for (var i = 0; i < old->size; i++;)
-            addEnd(old->get(i))
+            maybe_copy_construct(&data[i], &old->data[i]);
+            //addEnd(old->get(i))
     }
 
     fun destruct(): void {

tests/test_close_over_references.expected_results

@@ -0,0 +1,2 @@
+9
+9

tests/test_close_over_references.krak

@@ -0,0 +1,17 @@
+import io:*
+
+fun func(it: ref int) {
+    it++
+    fun() {
+        it++
+        println(it)
+    }()
+}
+
+fun main(): int {
+    var it = 7
+    func(it)
+    println(it)
+
+    return 0
+}

tests/test_grammer.krak

@@ -7,7 +7,7 @@ import symbol:*
 
 fun main():int {
 
-    /*var a = load_grammer(read_file(string("../krakenGrammer.kgm")))*/
+    //var a = load_grammer(read_file(string("../krakenGrammer.kgm")))
     /*var a = load_grammer(read_file(string("grammer.kgm")))*/
     var a = load_grammer(read_file(string("grammer2.kgm")))
     println(a.to_string())
@@ -42,9 +42,9 @@ fun main():int {
    /*lex.set_input(read_file(string("test_grammer.krak")))*/
     /*lex.set_input(string("ccdahas spacedhas*/
 /*returndaaaaaaaaaaaaaa"))*/
-    lex.set_input(string("hibyed"))
+    //lex.set_input(string("hibyed"))
     println("woo lexing:")
-    range(8).for_each(fun(i: int) { println(lex.next().to_string()); } )
+    //range(8).for_each(fun(i: int) { println(lex.next().to_string()); } )
     /*range(80).for_each(fun(i: int) { println(lex.next().to_string()); } )*/
     println(a.to_string())
     a.calculate_state_automaton()

tests/test_vectorTest.expected_results

@@ -66,38 +66,26 @@ Copied: 303 to 304
 Destroyed: 303
 Destroyed: 302
 Copied: 104 to 105
-Copied: 105 to 106
-Destroyed: 105
 Copied: 204 to 205
-Copied: 205 to 206
-Destroyed: 205
 Copied: 304 to 305
-Copied: 305 to 306
-Destroyed: 305
 Destroyed: 104
 Destroyed: 204
 Destroyed: 304
 Destroyed: 301
 Destroyed: 201
 Destroyed: 101
-Copied: 106 to 107
-Copied: 107 to 108
-Destroyed: 107
-Copied: 206 to 207
-Copied: 207 to 208
-Destroyed: 207
-Copied: 306 to 307
-Copied: 307 to 308
-Destroyed: 307
-Destroyed: 106
+Copied: 105 to 106
+Copied: 205 to 206
+Copied: 305 to 306
+Destroyed: 105
+Destroyed: 205
+Destroyed: 305
 Destroyed: 206
+Copied: 306 to 307
 Destroyed: 306
-Destroyed: 208
-Copied: 308 to 309
-Destroyed: 308
 done
-Destroyed: 108
-Destroyed: 309
+Destroyed: 106
+Destroyed: 307
 Destroyed: 300
 Destroyed: 200
 Destroyed: 100