divine 0.0.2 → 0.0.3

data/lib/divine/code_generators/javascript.rb

@@ -4,96 +4,125 @@
 # . They are 64-bit floating point values, the largest exact integral value is 2^53, or 9007199254740992 (-9007199254740992 to 9007199254740992)
 
 
-require 'pp'
-
 module Divine
   $debug_javascript = false
   
   class JavascriptHelperMethods < BabelHelperMethods
+    def get_header_comment
+      get_header_comment_text.map do |s|
+        "// #{s}"
+      end.join("\n")
+    end
+    
     def javascript_base_class_template_str
       <<EOS
-// ------------------------------------------------------------ BabelDataReader
-function BabelDataReader(data) {
+// ------------------------------------------------------------ DivineDataReader
+function DivineDataReader(data) {
     this.data = data;
     this.index = 0;
 }
 
-BabelDataReader.prototype.getbyte = function () {
+DivineDataReader.prototype.getbyte = function () {
     return this.data[this.index++];
 };
 
-BabelDataReader.prototype.read = function (items) {
+DivineDataReader.prototype.read = function (items) {
     var from = this.index;
     this.index += items
     return this.data.subarray(from, this.index)
 };
 
 
-// ------------------------------------------------------------ BabelDataWriter
-function BabelDataWriter(data) {
+// ------------------------------------------------------------ DivineDataWriter
+function DivineDataWriter(data) {
     this.data = data;
     this.index = 0;
     this.data = new Uint8Array(4096);
 }
 
-BabelDataWriter.prototype._realloc = function (size) {
+DivineDataWriter.prototype._realloc = function (size) {
     size = size || 4096;
     var old_data = this.data;
     this.data = new Uint8Array(Math.max(size, 4096) + this.data.length);
     this.data.set(old_data, 0);
 };
 
-BabelDataWriter.prototype.writeByte = function (a_byte) {
+DivineDataWriter.prototype.writeByte = function (a_byte) {
     if (this.index + 1 >= this.data.length) this._realloc();
     this.data[this.index++] = a_byte;
 };
 
-BabelDataWriter.prototype.write = function (bytes) {
+DivineDataWriter.prototype.write = function (bytes) {
     if (this.index + bytes.length >= this.data.length) this._realloc(bytes.length);
     this.data.set(bytes, this.index);
     this.index += bytes.length;
 };
 
-BabelDataWriter.prototype.get_data = function () {
+DivineDataWriter.prototype.get_data = function () {
     return this.data.subarray(0, this.index);
 };
 
 
-// ------------------------------------------------------------ BabelHelper
-function BabelHelper() {}
+// ------------------------------------------------------------ DivineHelper
+function DivineHelper() {}
 
-BabelHelper.prototype.serialize = function () {
-    var out = new BabelDataWriter();
+DivineHelper.prototype.serialize = function () {
+    var out = new DivineDataWriter();
     this.serialize_internal(out);
     return out.get_data();
 }
 
-BabelHelper.prototype.read_int8 = function (data) {
+DivineHelper.prototype.read_int8 = function (data) {
     return data.getbyte();
 };
 
-BabelHelper.prototype.read_int16 = function (data) {
+DivineHelper.prototype.read_int16 = function (data) {
     return (data.getbyte() << 8) | this.read_int8(data);
 };
 
-BabelHelper.prototype.read_int24 = function (data) {
+DivineHelper.prototype.read_int24 = function (data) {
     return (data.getbyte() << 16) | this.read_int16(data);
 };
 
-BabelHelper.prototype.read_int32 = function (data) {
+DivineHelper.prototype.read_int32 = function (data) {
     // return (data.getbyte() << 24) | this.read_int24(data); // See notes about numbers above
     return (data.getbyte() * (256*256*256)) + this.read_int24(data);
 };
 
-BabelHelper.prototype.read_binary = function (data) {
+DivineHelper.prototype.read_sint32 = function (data) {
+    // return (data.getbyte() << 24) | this.read_int24(data); // See notes about numbers above
+    var num = (data.getbyte() * (256*256*256)) + this.read_int24(data);
+    if (num > (Math.pow(2, 32 - 1) -1) ){
+      return num - Math.pow(2, 32);
+    }
+    return num;
+};
+
+DivineHelper.prototype.read_sint64 = function (data) {
+    var part1 = this.read_int32(data).toString(2);	// read first part of 32 bit number
+    var part2 = this.read_int32(data).toString(2);  	// read second part of 32 bit.
+    if (part1.length < 32){ 				// deal with positive number
+      part2 = Array(32 - part2.length + 1).join("0") + part2;
+      return parseInt((part1 + part2), 2);
+    }else{						// deal with negative number
+      part1 = part1.substr(11,part1.length);
+      part2 = Array(32 - part2.length + 1).join("0") + part2;
+      var binStr = part1 + part2;
+      binStr = binStr.replace(/1/g,'f').replace(/0/g,'1').replace(/f/g,'0');
+      val    = parseInt(binStr, 2) + 1;
+      return val * -1;
+    }
+}
+
+DivineHelper.prototype.read_binary = function (data) {
     return data.read(this.read_int32(data));
 };
 
-BabelHelper.prototype.read_short_binary = function (data) {
+DivineHelper.prototype.read_short_binary = function (data) {
     return data.read(this.read_int8(data));
 };
 
-BabelHelper.prototype.read_ip_number = function (data) {
+DivineHelper.prototype.read_ip_number = function (data) {
     var ip_array = this.read_short_binary(data);
     if(ip_array.length == 4){
        return this.read_ipv4_number(ip_array);
@@ -102,7 +131,7 @@ BabelHelper.prototype.read_ip_number = function (data) {
     }
 };
 
-BabelHelper.prototype.read_ipv4_number = function (ip_array) {
+DivineHelper.prototype.read_ipv4_number = function (ip_array) {
     ip = "";
     for (i = 0, len = ip_array.length; i < len; i++) {
         b = ip_array[i];
@@ -113,7 +142,7 @@ BabelHelper.prototype.read_ipv4_number = function (ip_array) {
     }
     return ip;
 };
-BabelHelper.prototype.read_ipv6_number = function (ip_array) {
+DivineHelper.prototype.read_ipv6_number = function (ip_array) {
     var ip = "";
     var part1, part2;
     for (i = 0, len = ip_array.length; i < len; i+=2) {
@@ -128,11 +157,11 @@ BabelHelper.prototype.read_ipv6_number = function (ip_array) {
     return ip;
 };
 
-BabelHelper.prototype.read_string = function (data) {
+DivineHelper.prototype.read_string = function (data) {
     return this.decode_utf8(data.read(this.read_int16(data)))
 };
 
-BabelHelper.prototype.write_int8 = function (v, out) {
+DivineHelper.prototype.write_int8 = function (v, out) {
     if (v > 0xFF) // Max 255
       this.raise_error("Too large int8 number: " + v);
     if(v < 0)
@@ -140,7 +169,7 @@ BabelHelper.prototype.write_int8 = function (v, out) {
     out.writeByte(v);
 }
 
-BabelHelper.prototype.write_int16 = function (v, out) {
+DivineHelper.prototype.write_int16 = function (v, out) {
     if (v > 0xFFFF) // Max 65.535
       this.raise_error("Too large int16 number: " + v);
     if(v < 0)
@@ -149,7 +178,7 @@ BabelHelper.prototype.write_int16 = function (v, out) {
     this.write_int8(v & 0xFF, out);
 }
 
-BabelHelper.prototype.write_int24 = function (v, out) {
+DivineHelper.prototype.write_int24 = function (v, out) {
     if (v > 0xFFFFFF) 	// Max 16.777.215
       this.raise_error("Too large int24 number: " + v);
     if (v < 0)		// In Case added to JavaScript declaration
@@ -158,7 +187,7 @@ BabelHelper.prototype.write_int24 = function (v, out) {
     this.write_int16(v & 0xFFFF, out);
 }
 
-BabelHelper.prototype.write_int32 = function (v, out) {
+DivineHelper.prototype.write_int32 = function (v, out) {
     if (v > 0xFFFFFFFF) // Max 4.294.967.295
       this.raise_error("Too large int32 number: " + v);
     if(v < 0)
@@ -167,18 +196,52 @@ BabelHelper.prototype.write_int32 = function (v, out) {
     this.write_int24(v & 0xFFFFFF, out);
 }
 
-BabelHelper.prototype.write_bool = function (v, out) {
+DivineHelper.prototype.write_sint32 = function (v, out) {
+    var max = Math.pow(2, 32 - 1) - 1;
+    var min = Math.pow(2, 32 - 1) - Math.pow(2, 32);
+    if (v > max) 			// Max  2.147.483.647
+      this.raise_error("Too large sInt32 number: " + v + ", Max = " + max);
+    if(v < min)				// Min -2.147.483.648
+      this.raise_error("Too small sInt32 number: " + v + ", Min = " + min);
+    this.write_int8(v >> 24 & 0xFF, out);
+    this.write_int24(v & 0xFFFFFF, out);
+}
+
+DivineHelper.prototype.write_sint64 = function (v, out) {
+    var max =  Math.pow(2, 53) - 1;
+    var min = -Math.pow(2, 53);
+    if (v > max)			// Max  9,007,199,254,740,991
+      this.raise_error("Too large sInt64 number: " + v + ", Max = " + max);
+    if (v < min)	 		// Min -9,007,199,254,740,992
+      this.raise_error("Too small sInt64 number: " + v + ", Min = " + min);
+    
+    binStr = v.toString(2);
+    if (v < 0){
+      invBinStr = binStr.replace('-','').replace(/1/g,'f').replace(/0/g,'1').replace(/f/g,'0');
+      invBinStr = (parseInt(invBinStr, 2) + 1).toString(2);
+      binStr    = Array(binStr.length - invBinStr.length).join("0") + invBinStr;
+      binStr    = Array(64 - binStr.length + 1).join("1") + binStr;
+    }else{
+      binStr    = Array(64 - binStr.length + 1).join("0") + binStr;
+    }
+    part1  = binStr.substr(0, binStr.length - 32);
+    part2  = binStr.substr(binStr.length - 32, binStr.length);
+    this.write_int32(parseInt(part1, 2), out);
+    this.write_int32(parseInt(part2, 2), out);
+}
+
+DivineHelper.prototype.write_bool = function (v, out) {
     this.write_int8(v ? 1 : 0, out)
 }
 
-BabelHelper.prototype.write_string = function (v, out) {
+DivineHelper.prototype.write_string = function (v, out) {
     var s = this.encode_utf8(v);
     if (s.length > 0xFFFF) this.raise_error("Too large string: " + s.length + " bytes");
     this.write_int16(s.length, out);
     out.write(s);
 }
 
-BabelHelper.prototype.write_binary = function (v, out) {
+DivineHelper.prototype.write_binary = function (v, out) {
     if ((v instanceof Array) || (v instanceof Uint8Array)) {
         if (v.length > 0xFFFFFFFF) this.raise_error("Too large binary: " + v.length + " (" + v.constructor.name + ")");
         this.write_int32(v.length, out)
@@ -194,7 +257,7 @@ BabelHelper.prototype.write_binary = function (v, out) {
     }
 }
 
-BabelHelper.prototype.write_16_binary = function (v, out) {
+DivineHelper.prototype.write_16_binary = function (v, out) {
     if ((v instanceof Array) || (v instanceof Uint8Array)) {
         if (v.length > 0xFF) this.raise_error("Too large 16 binary: " + v.length*2 + " (" + v.constructor.name + ")");
         this.write_int8(v.length * 2, out)
@@ -209,7 +272,7 @@ BabelHelper.prototype.write_16_binary = function (v, out) {
     }
 }
 
-BabelHelper.prototype.write_short_binary = function (v, out) {
+DivineHelper.prototype.write_short_binary = function (v, out) {
     if ((v instanceof Array) || (v instanceof Uint8Array)) {
         if (v.length > 0xFF) this.raise_error("Too large binary: " + v.length + " (" + v.constructor.name + ")");
         this.write_int8(v.length, out)
@@ -225,7 +288,7 @@ BabelHelper.prototype.write_short_binary = function (v, out) {
     }
 }
 
-BabelHelper.prototype.write_ip_number = function (v, out) {
+DivineHelper.prototype.write_ip_number = function (v, out) {
     if ((v instanceof Array) || (v instanceof Uint8Array)){
       if(v.length == 4){
          this.write_ipv4_number(v, out);
@@ -243,7 +306,7 @@ BabelHelper.prototype.write_ip_number = function (v, out) {
     }
 }
 
-BabelHelper.prototype.write_ipv4_number = function (v, out) {
+DivineHelper.prototype.write_ipv4_number = function (v, out) {
     if ((v instanceof Array) || (v instanceof Uint8Array)) {
         if (v.length != 4 && v.length != 0) this.raise_error("Unknown IP v4 number " + v);
         this.write_short_binary(v, out)
@@ -258,7 +321,7 @@ BabelHelper.prototype.write_ipv4_number = function (v, out) {
     }
 };
 
-BabelHelper.prototype.write_ipv6_number = function (v, out) {
+DivineHelper.prototype.write_ipv6_number = function (v, out) {
     if ((v instanceof Array) || (v instanceof Uint8Array)) {
         this.write_16_binary(v, out)
     } else if (v.constructor == String) {
@@ -270,7 +333,7 @@ BabelHelper.prototype.write_ipv6_number = function (v, out) {
             v = v.replace(/ /g, "");
             ss = v.split(":").map(function (t){
                if (t.length > 4)
-		 new BabelHelper().raise_error("Unknown IP Group number '" + t + "'");
+		 new DivineHelper().raise_error("Unknown IP Group number '" + t + "'");
                if (t.length == 0)
                  t = "0";
                return parseInt(t, 16);
@@ -288,7 +351,7 @@ BabelHelper.prototype.write_ipv6_number = function (v, out) {
     }
 }
 
-BabelHelper.prototype.encode_utf8 = function (str) {
+DivineHelper.prototype.encode_utf8 = function (str) {
     var utf8 = [];
     var chr, next_chr;
     var x, y, z;
@@ -331,7 +394,7 @@ BabelHelper.prototype.encode_utf8 = function (str) {
     return utf8;
 }
 
-BabelHelper.prototype.decode_utf8 = function (utf8_data) {
+DivineHelper.prototype.decode_utf8 = function (utf8_data) {
     var str = "";
     var chr, b2, b3, b4;
     for (var i = 0; i < utf8_data.length; i++) {
@@ -385,56 +448,103 @@ BabelHelper.prototype.decode_utf8 = function (utf8_data) {
     return str;
 }
 
-BabelHelper.prototype.raise_error = function (msg) {
+DivineHelper.prototype.raise_error = function (msg) {
     throw "[" + this.constructor.name + "] " + msg;
 }
 EOS
     end
 
-    def javascript_class_template_str
-      <<EOS2
-// ------------------------------------------------------------ <%= c.name %>
-function <%= c.name %>() {
-   BabelHelper.call(this);  
-<% c.fields.each do |f| %>
-   this.<%= f.name %> = <%= this.javascript_get_empty_declaration(f) %>;
-<% end %>
-}
-
-// Inherit BabelHelper
-<%= c.name %>.prototype = new BabelHelper();
- 
-// Correct the constructor pointer because it points to BabelHelper
-<%= c.name %>.prototype.constructor = <%= c.name %>;
-
-// Define the methods of <%= c.name %>
-<%= c.name %>.prototype.deserialize = function (data) {
-<% c.simple_fields.each do |f| %>
-   this.<%= f.name %> = this.read_<%= f.type %>(data);
-<% end %>
-<% c.complex_fields.each do |f| %>
-<%= this.javascript_deserialize_complex f %>
-<% end %>
-}
-
-<%= c.name %>.prototype.serialize_internal = function(out) {
-<% c.simple_fields.each do |f| %>
-   this.write_<%= f.type %>(this.<%= f.name %>, out);
-<% end %>
-<% c.complex_fields.each do |f| %>
-<%= this.javascript_serialize_complex f %>
-<% end %>
-}
-EOS2
+    def javascript_class_template(sh)
+      code = [
+        "",
+        "// ------------------------------------------------------------ #{sh.name}",
+        "function #{sh.name}() {",
+        :indent,
+        "DivineHelper.call(this);",
+        "",
+        # PROPERTIES
+      	"this.struct_version = #{sh.latest_version};",
+        sh.field_names.map do |fn|
+          f = sh.field(fn).last
+          "this.#{f.name} = #{javascript_get_empty_declaration(f)};"
+        end,
+        :deindent,
+        "}", "",
+        
+        "// Inherit DivineHelper",
+        "#{sh.name}.prototype = new DivineHelper();", "",
+
+        "// Correct the constructor pointer because it points to DivineHelper",
+        "#{sh.name}.prototype.constructor = #{sh.name};", "",
+
+        # SERiALIZE INTERNAL
+        "// Serialize",
+        "#{sh.name}.prototype.serialize_internal = function(out) {",
+        :indent,
+        "this.write_int8(this.struct_version, out);",
+        sh.structs.map do |s|
+          [
+            "if(this.struct_version == #{s.version}) {",
+            :indent,
+            s.simple_fields.map do |f|
+              "this.write_#{f.type}(this.#{f.name}, out);"
+            end,
+            s.complex_fields.map do |f|
+              [
+                "", "// Serialize #{f.type} '#{f.name}'",
+                $debug_javascript ? "console.log(\"Serialize '#{field.name}'\");" : nil,
+                javascript_serialize_internal("this.#{f.name}",  f.referenced_types)
+              ]
+            end,
+            "return;",
+            :deindent,
+            "}", ""
+          ]
+        end, "",
+        "throw \"Unsupported version \" + this.struct_version + \" for type '#{sh.name}'\";",
+        :deindent,
+        "}", "",
+
+        # DESERIALIZE
+        "// Deserialize",
+        "#{sh.name}.prototype.deserialize = function (data) {",
+        :indent,
+        "this.struct_version = this.read_int8(data);",
+        sh.structs.map do |s|
+          [
+            "if(this.struct_version == #{s.version}) {",
+            :indent,
+            s.simple_fields.map do |f|
+              "this.#{f.name} = this.read_#{f.type}(data);"
+            end,
+            s.complex_fields.map do |f|
+              [
+                "", "// Read #{f.type} '#{f.name}'",
+                $debug_javascript ? "console.log(\"Deserialize '#{field.name}'\");" : nil,
+                javascript_deserialize_internal("this.#{f.name}",  f.referenced_types)
+              ]
+            end,
+            "return;",
+            :deindent,
+            "}"
+          ]
+        end, "",
+        "throw \"Unsupported version \" + this.struct_version + \" for type '#{sh.name}'\";",
+        :deindent,
+        "}"
+      ]
+        
+      format_src(0, 3, code)
     end
 
+
     def javascript_get_empty_declaration(field)
       case field.type
       when :list, :binary, :short_binary
         "[]"
       when :map
         "{}"
-      when :int8, :int16, :int32
+      when :int8, :int16, :int32, :sint32, :sint64
         "0"
       when :string, :ip_number
         "\"\""
@@ -443,16 +553,6 @@ EOS2
       end
     end
 
-    def javascript_serialize_complex(field)
-      types = field.referenced_types
-      as = [
-            "// Serialize #{field.type} '#{field.name}'",
-            $debug_javascript ? "console.log(\"Serialize '#{field.name}'\");" : nil,
-            javascript_serialize_internal("this.#{field.name}", types)
-           ]
-      format_src(4, 4, as)
-    end
-
     def javascript_serialize_internal(var, types)
       if types.respond_to? :first
         case types.first
@@ -500,16 +600,6 @@ EOS2
       end
     end
 
-    def javascript_deserialize_complex(field)
-      types = field.referenced_types
-      as = [
-            "// Deserialize #{field.type} '#{field.name}'",
-            $debug_javascript ? "console.log(\"Deserialize '#{field.name}'\");" : nil,
-            javascript_deserialize_internal("this.#{field.name}", types)
-           ]
-      format_src(4, 4, as)
-    end
-
     def javascript_deserialize_internal(var, types)
       if types.respond_to? :first
         case types.first
@@ -569,16 +659,14 @@ EOS2
 
   class JavascriptGenerator < JavascriptHelperMethods
     def generate_code(structs, opts)
-      pp opts
       $debug_javascript = true if opts[:debug]
       base_template = Erubis::Eruby.new(javascript_base_class_template_str)
-      class_template = Erubis::Eruby.new(javascript_class_template_str)
       keys = structs.keys.sort
       src = keys.map do |k|
         ss = structs[k]
-        # TODO: Should we merge different versions and deduce deprecated methods, warn for incompatible changes, etc?
-        raise "Duplicate definitions of struct #{k}" if ss.size > 1
-        class_template.result( c: ss.first, this: self )
+        # Check different aspects the the structs
+        vss = sanity_check(ss)
+        javascript_class_template(StructHandler.new(vss))
       end
     
       # User defined super class?
@@ -588,7 +676,7 @@ EOS2
     end
   
     def javascript_get_begin_module(opts)
-      nil
+       "#{get_header_comment}\n\n"
     end
 
     def javascript_get_end_module(opts)