Implement a hash_map and swap gss over to use it, making self-compilation 10 seconds faster on my laptop. captain.sh has been extended with the ability to bootstrap over any number of git commits.

captain.sh

@@ -1,25 +1,33 @@
 #!/bin/bash
 
 kraken="kraken"
-bootstrap_commits=(cf46fb13afe66ba475db9725e9269c9c1cd3bbc3)
+bootstrap_commits=(cf46fb13afe66ba475db9725e9269c9c1cd3bbc3 2cd43e5a217318c70097334b3598d2924f64b362)
 
 if [[ $1 == "clean" ]]
 then
     rm ${kraken}
     rm ${kraken}_bac
     rm ${kraken}_deprecated
+    rm ${kraken}_bootstrap
     rm -rf bootstrap_kalypso
 else
     if [[ $1 == "backup" ]]
     then
         rm ${kraken}
     fi
+    if [[ $1 == "from_old" ]]
+    then
+        rm ${kraken}
+        rm ${kraken}_bac
+        rm ${kraken}_deprecated
+    fi
     if [[ $1 == "rebuild" ]]
     then
         rm ${kraken}
         rm ${kraken}_bac
         rm ${kraken}_deprecated
         rm ${kraken}_bootstrap
+        rm -rf bootstrap_kalypso
     fi
 
     if [ -s "$kraken" ]
@@ -32,7 +40,10 @@ else
         then
             if ! [ -s "${kraken}_deprecated" ]
             then
-                echo "no ${kraken}_deprecated, bootstrapping using Cephelpod and a chain of old Kalypsos"
+                echo "no ${kraken}_deprecated, bootstrapping using kraken_bootstrap"
+                if ! [ -s "${kraken}_bootstrap" ]
+                then
+                    echo "no ${kraken}_bootstrap, bootstrapping using Cephelpod and a chain of old Kalypsos"
                     git clone . bootstrap_kalypso
                     pushd bootstrap_kalypso
                     git checkout ${bootstrap_commits[0]}
@@ -54,20 +65,41 @@ else
                     pushd deprecated_compiler/build_kraken/kraken
                     sh kraken.sh
                     popd
-                cp deprecated_compiler/build_kraken/kraken/kraken ../${kraken}_bootstrap
+                    cp deprecated_compiler/build_kraken/kraken/kraken ./${kraken}_bootstrap
-                popd
+                    # loop through the chain
-                # Now make 
+                    for ((i=1; i < ${#bootstrap_commits[@]}; i++))
+                    do
+                        echo "building kalypso bootstrap part $i"
+                        echo "commit hash: ${bootstrap_commits[$i]}"
+                        mv ./krakenGrammer.kgm krakenGrammer.kgm_old
+                        git checkout ${bootstrap_commits[$i]}
                         mv ./krakenGrammer.kgm krakenGrammer.kgm_new
+                        mv ./krakenGrammer.kgm_old krakenGrammer.kgm
+                        ./${kraken}_bootstrap kraken.krak ${kraken}_bootstrap
+                        mv ./krakenGrammer.kgm_new krakenGrammer.kgm
+                    done
+                    popd # out of bootstrap
+                fi
+                echo "making kraken_deprecated - the first current Kraken version, but built with an old compiler"
+            
+                # Now make real
+                mv ./krakenGrammer.kgm krakenGrammer.kgm_new
+                mv ./krakenGrammer.kgm.comp_new krakenGrammer.kgm.comp_new_new
                 cp bootstrap_kalypso/krakenGrammer.kgm ./
+                cp bootstrap_kalypso/krakenGrammer.kgm.comp_new ./
+                cp bootstrap_kalypso/${kraken}_bootstrap ./${kraken}_bootstrap
                 ./${kraken}_bootstrap kraken.krak ${kraken}_deprecated
                 mv ./krakenGrammer.kgm_new krakenGrammer.kgm
+                mv ./krakenGrammer.kgm.comp_new_new krakenGrammer.kgm.comp_new
             else
                 echo "${kraken}_deprecated exists, calling"
             fi
+            echo "making kraken_bac, a current compiler built with kraken_deprecated"
             ./${kraken}_deprecated kraken.krak ${kraken}_bac
         else
             echo "${kraken}_bac exists, calling"
         fi
+        echo "making kraken, the real current compiler built with kraken_bac"
         ./${kraken}_bac kraken.krak ${kraken}
     fi
 fi

stdlib/hash_map.krak

@@ -22,17 +22,29 @@ obj hash_map<T,U> (Object, Serializable) {
         data.construct()
         data.add(map::map<T,U>())
         size = 0
+        /*io::print("Constructed hash_map, this: ")*/
+        /*io::println((this) cast int)*/
+        /*io::print("size of data:")*/
+        /*io::println(data.size)*/
         return this
     }
     fun copy_construct(old: *hash_map<T,U>) {
         data.copy_construct(&old->data)
         size = old->size
+        /*io::print("Copy constructed hash_map, this: ")*/
+        /*io::println((this) cast int)*/
+        /*io::print("new size of data:")*/
+        /*io::println(data.size)*/
+        /*io::print("old size of data:")*/
+        /*io::println(old->data.size)*/
     }
     fun operator=(rhs: hash_map<T,U>) {
         destruct()
         copy_construct(&rhs)
     }
     fun destruct() {
+        /*io::print("destructed hash_map, this: ")*/
+        /*io::println((this) cast int)*/
         data.destruct()
     }
     fun serialize(): vector::vector<char> {
@@ -49,11 +61,16 @@ obj hash_map<T,U> (Object, Serializable) {
         return data == other.data
     }
     fun set(key: T, value: U) {
+        /*io::print("doing set! this:")*/
+        /*io::println((this) cast int)*/
+        /*io::print("size of data:")*/
+        /*io::println(data.size)*/
         var key_hash = util::hash(key)
-        if (!data[key_hash%data.size].contains_key(key))
+        if (!data[key_hash%data.size].contains_key(key)) {
             size++
-        data[key_hash%data.size].set(key, value)
             if (size > data.size) {
+                /*io::print("rehashing to: ")*/
+                /*io::println(size*2)*/
                 var new_data = vector::vector<map::map<T,U>>()
                 for (var i = 0; i < size*2; i++;)
                     new_data.addEnd(map::map<T,U>())
@@ -63,6 +80,8 @@ obj hash_map<T,U> (Object, Serializable) {
                 data = new_data
             }
         }
+        data[key_hash%data.size].set(key, value)
+    }
     fun get(key: T): ref U {
         return data[util::hash(key)%data.size].get(key)
     }
@@ -103,6 +122,8 @@ obj hash_map<T,U> (Object, Serializable) {
     }
     fun clear() {
         data.clear()
+        size = 0
+        data.add(map::map<T,U>())
     }
 }
 

stdlib/parser.krak

@@ -405,8 +405,8 @@ obj parser (Object) {
 
 obj gss (Object) {
     var data: vector<vector<*tree<int>>>
-    var edges: map< pair<*tree<int>, *tree<int>>, *tree<symbol> >
+    /*var edges: map< pair<*tree<int>, *tree<int>>, *tree<symbol> >*/
-    /*var edges: hash_map< pair<*tree<int>, *tree<int>>, *tree<symbol> >*/
+    var edges: hash_map< pair<*tree<int>, *tree<int>>, *tree<symbol> >
 
     fun construct(): *gss {
         data.construct()

stdlib/util.krak

@@ -95,8 +95,8 @@ obj pair<T,U> (Object, Serializable, Hashable) {
         return second_pair.second
     }
 
-    /*fun hash():int return hash(first) ^ hash(second)*/
+    fun hash():int return hash(first) ^ hash(second)
-    fun hash():int return 0
+    /*fun hash():int return 0*/
 
     // the old unnecessary template to prevent generation
     // if not used trick (in this case, changing out U with V)