divine 0.0.1 → 0.0.2

data/lib/divine/code_generators/ruby.rb

@@ -46,19 +46,47 @@ module Divine
     end
 
     def read_ip_number(data)
-      read_short_binary(data).bytes.to_a.join('.')
+      ips = read_short_binary(data)
+      if ips.size == 4
+        read_ipv4_number(ips)
+      else
+        read_ipv6_number(ips)
+      end
     end
 
+    def read_ipv4_number(ips)
+      ips.bytes.to_a.join('.')
+    end
+
+    def read_ipv6_number(ips)
+      ipv6 = []
+      ips.bytes.each_slice(2) do |t|
+        fst = t[0]
+        lst = t[1]
+        tmp = ""
+        tmp = fst.to_s 16 if fst != 0
+        if fst != 0 and lst < 10
+          tmp << "0#{lst.to_s 16}"
+        elsif fst != 0 and lst > 10 or fst == 0 and lst > 0
+          tmp << lst.to_s(16)
+        end
+        ipv6.push(tmp)
+      end
+      ipv6.join(':').gsub(/:{2,}/, "::")
+    end
+    
     ### Write methods ###
     def write_int8(v, out)
       v = v.to_i
       raise_error "Too large int8 number: #{v}" if v > 0xFF  # Max 255
+      raise_error "a negative number passed  to int8 number: #{v}" if v < 0
       out << v
     end
 
     def write_int16(v, out)
       v = v.to_i
       raise_error "Too large int16 number: #{v}" if v > 0xFFFF # Max 65.535 
+      raise_error "a negative number passed  to int16 number: #{v}" if v < 0
       write_int8( v >> 8 & 0xFF, out)
       write_int8( v & 0xFF, out)
     end
@@ -66,6 +94,7 @@ module Divine
     def write_int24(v, out)
       v = v.to_i
       raise_error "Too large int24 number: #{v}" if v > 0xFFFFFF # Max 16.777.215
+      raise_error "a negative number passed  to int24 number: #{v}" if v < 0 # In Case added to ruby declaration
       write_int8( v >> 16 & 0xFF, out)
       write_int16( v & 0xFFFF, out)
     end
@@ -73,6 +102,7 @@ module Divine
     def write_int32(v, out)
       v = v.to_i
       raise_error "Too large int32 number: #{v}" if v > 0xFFFFFFFF # Max 4.294.967.295
+      raise_error "a negative number passed  to int32 number: #{v}" if v < 0
       write_int8( v >> 24 & 0xFF, out)
       write_int24( v & 0xFFFFFF, out)
     end
@@ -105,6 +135,19 @@ module Divine
       end
     end
 
+    def write_16_binary(v, out)
+      if v.is_a?(Array)
+        raise_error "Too large 16 binary: #{v.size} (#{v.class.name})" unless v.size*2 < 0xFF
+        write_int8(v.size * 2, out) # IPv6 consists of 8 parts each of them has zise of 2 bytes
+        v.each do |x|
+          write_int16(x, out)
+        end
+      else 
+        raise_error "Unsupported binary 'nil'" if v == nil
+        raise_error "Unsupported binary of type '#{v.class.name}'"
+      end
+    end
+
     def write_short_binary(v, out)
       if v.is_a?(Array)
         raise_error "Too large short_binary: #{v.size} (#{v.class.name})" unless v.size < 0xFF
@@ -123,6 +166,24 @@ module Divine
     end
 
     def write_ip_number(v, out)
+      if v.is_a?(Array)
+        if v.size == 4
+          write_ipv4_number(v, out);
+        else
+          write_ipv6_number(v, out);
+        end
+      elsif v.is_a?(String)
+        if v.include?":"
+          write_ipv6_number(v, out);
+        else
+          write_ipv4_number(v, out);
+        end
+      else
+        raise_error "Unknown IP number '#{v}'"
+      end
+    end
+
+    def write_ipv4_number(v,out)
       if v.is_a?(Array)
         raise_error "Unknown IP v4 number #{v}" unless v.size == 0 || v.size == 4 # Only IPv4 for now 
         write_short_binary(v, out)
@@ -130,12 +191,36 @@ module Divine
         ss = v.split(/\./).map do |s|
           s.to_i
         end
-        write_ip_number(ss, out)
+        write_ipv4_number(ss, out)
       else
         raise_error "Unknown IP number '#{v}'"
       end
     end
 
+    def write_ipv6_number(v, out)
+      if v.is_a?(Array)
+        write_16_binary(v, out)
+      elsif v.is_a?(String)
+        v = v.gsub(" ","") + " " # Temporary: To avoid the split problem when we have : at the end of "v" 
+        raise_error "Unknown IPv6 number #{v}" unless v.strip.empty? ||
+                                                       v.strip.match(/[^:0-9a-f]+/i) == nil &&  #Should not contains numbers or letters 0-9a-f
+                                                       v.strip.match(/[0-9a-f]+/i) != nil &&   #Should contains numbers or letters 0-9a-f
+                                                       v.match(":{3,}") == nil && 
+                                                       v.split("::").size <= 2
+        ss = v.split(/:/).map do |s|
+          s = s.strip
+	  raise_error "Unknown IPv6 Group #{s}" unless s.size <= 4
+          s.to_i 16
+        end
+        ss = [] if v.strip.empty?
+        raise_error "Unknown IPv6 number #{v}" unless (!v.include?("::") && ss.size == 0 || ss.size == 8) || 
+						       (v.include?("::") && ss.size > 2 && ss.size < 8)
+	write_ipv6_number(ss, out)
+      else
+        raise_error "Unknown IPv6 number '#{v}'"
+      end
+    end
+
     private
     def raise_error(msg)
       raise "[#{self.class.name}] #{msg}" 
@@ -335,7 +420,7 @@ module Divine
       # User defined super class?
       toplevel = opts[:parent_class] || nil
       toplevel = " < #{toplevel}" if toplevel 
-      return "#{ruby_get_begin_module(opts)}#{base_template.result({ toplevel_class: toplevel })}\n\n#{src.join("\n\n")}#{ruby_get_end_module(opts)}"
+      return [{file: opts[:file], src: "#{ruby_get_begin_module(opts)}#{base_template.result({ toplevel_class: toplevel })}\n\n#{src.join("\n\n")}#{ruby_get_end_module(opts)}"}]
     end
   
     def ruby_get_begin_module(opts)
@@ -357,4 +442,4 @@ module Divine
 
 
   $language_generators[:ruby] = RubyGenerator.new
-end
+end

data/lib/divine/version.rb

@@ -1,3 +1,3 @@
 module Divine
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/test/basic_complex_test/basic_complex_test.rb

@@ -0,0 +1,34 @@
+
+require 'divine'
+
+struct 'TestBasic' do
+  int8 :i8
+  int16 :i16
+  int32 :i32
+  string :str
+  ip_number :ip
+  binary :guid
+end
+
+struct 'Entry' do
+
+end
+
+
+struct(:TestComplex) {
+  list :list1, :int32
+  list :list2, :int8
+  map :map1, :int8, :int32
+  map(:map2, :string) { 
+    list 'Entry'
+  }
+}
+
+if ARGV[0] == "ruby"
+  Divine::CodeGenerator.new.generate(:ruby, file: 'test_babel.rb', module: 'BabelTest', parent_class: "Object", target_dir: 'test/basic_complex_test/ruby_test')
+elsif ARGV[0] == "js"
+  Divine::CodeGenerator.new.generate(:javascript, file: 'test_babel.js', target_dir: 'test/basic_complex_test/js_test')
+elsif ARGV[0] == "java"
+  Divine::CodeGenerator.new.generate(:java, file: 'test_babel.java', target_dir: 'test/basic_complex_test/java_test')
+end
+

data/test/basic_complex_test/java_test/JavaTest.java

@@ -0,0 +1,96 @@
+
+import java.io.ByteArrayInputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import org.junit.*;
+
+public class JavaTest {
+	
+    @Test
+    public void testBasicTest() throws IOException {
+		System.out.println("Test Basic Test");
+		TestBasic testbasic_ser   = new TestBasic();
+		TestBasic testbasic_deser = new TestBasic();
+
+		testbasic_ser.i8   = 16;
+		testbasic_ser.i16  = 458;
+		testbasic_ser.i32  = 365248;
+		testbasic_ser.str  = "Testing String";
+		testbasic_ser.ip   = "";
+		
+		serialize(testbasic_ser);
+		byte[] read = deserialize();
+		testbasic_deser.deserialize(new ByteArrayInputStream(read));    
+
+		org.junit.Assert.assertEquals(testbasic_ser.i8, testbasic_deser.i8);
+		org.junit.Assert.assertEquals(testbasic_ser.i16, testbasic_deser.i16);
+		org.junit.Assert.assertEquals(testbasic_ser.i32, testbasic_deser.i32);
+		org.junit.Assert.assertEquals(testbasic_ser.str, testbasic_deser.str);
+		org.junit.Assert.assertEquals(testbasic_ser.ip, testbasic_deser.ip);
+    }
+	
+    @Test
+    public void testComplexTest() throws IOException {
+		TestComplex testcomplex_ser = new TestComplex();
+		TestComplex testcomplex_deser = new TestComplex();
+		testcomplex_ser.list1 = new ArrayList<Long>();
+		testcomplex_ser.list1.add(123456L);
+		testcomplex_ser.list1.add(654321L);
+		
+		testcomplex_ser.list2 = new ArrayList<Integer>();
+		testcomplex_ser.list2.add(123);
+		testcomplex_ser.list2.add(221);
+		
+		testcomplex_ser.map1 = new HashMap<Integer, Long>();
+		testcomplex_ser.map1.put(12, 123456L);
+		testcomplex_ser.map1.put(13, 6543231L);
+		
+		testcomplex_ser.map2 = new HashMap<String, ArrayList<Entry>>();
+		ArrayList<Entry> tmp = new ArrayList<Entry>();
+		tmp.add(new Entry());
+		tmp.add(new Entry());
+		testcomplex_ser.map2.put("Key_1", tmp);
+		testcomplex_ser.map2.put("Key_2", tmp);
+		
+		serialize(testcomplex_ser);
+		byte[] read = deserialize();
+		testcomplex_deser.deserialize(new ByteArrayInputStream(read)); 
+
+		org.junit.Assert.assertTrue (testcomplex_ser.list1.containsAll(testcomplex_deser.list1));
+		org.junit.Assert.assertTrue (testcomplex_ser.list2.containsAll(testcomplex_deser.list2));
+		for (Integer k : testcomplex_ser.map1.keySet()){
+			org.junit.Assert.assertEquals(testcomplex_ser.map1.get(k), testcomplex_deser.map1.get(k)); 
+		}
+		for (String k : testcomplex_ser.map2.keySet()){
+			org.junit.Assert.assertEquals(testcomplex_ser.map2.get(k).size(), testcomplex_deser.map2.get(k).size() ); 
+		}
+		
+    }
+    
+    	public void serialize(BabelBase obj) throws IOException {
+		byte[] data = obj.serialize();
+		File file = new File("test/basic_complex_test/java_test/bin.babel");
+		try {
+		    new FileOutputStream(file).write(data);
+		} catch (Exception e) {
+		    e.printStackTrace();
+		}
+	}
+
+	public byte[] deserialize() throws IOException{
+		File file = new File("test/basic_complex_test/java_test/bin.babel");
+		byte[] data = new byte[(int) file.length()];
+		try {
+		    new FileInputStream(file).read(data);
+		} catch (Exception e) {
+		    e.printStackTrace();
+		}
+		return data;
+	}
+    
+}

data/test/basic_complex_test/java_test/test_babel.java

@@ -0,0 +1,368 @@
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.regex.Pattern;
+import java.nio.charset.Charset;
+
+abstract class BabelBase  {
+	private static final Charset UTF8 = Charset.forName("UTF-8");
+
+	public byte[] serialize() throws IOException {
+		ByteArrayOutputStream baos = new ByteArrayOutputStream();
+		serializeInternal(baos);
+		baos.close();
+		return baos.toByteArray();
+	}
+
+	abstract void serializeInternal(ByteArrayOutputStream baos) throws IOException;
+
+	abstract void deserialize(ByteArrayInputStream baos) throws IOException;
+
+	protected int readInt8(ByteArrayInputStream data) {
+		return data.read() & 0xff;
+	}
+
+	protected int readInt16(ByteArrayInputStream data) {
+		return (data.read() << 8) | readInt8(data);
+	}
+
+	protected int readInt24(ByteArrayInputStream data) {
+		return (data.read() << 16) | readInt16(data);
+	}
+
+	protected long readInt32(ByteArrayInputStream data) {
+		return (data.read() << 24) | readInt24(data);
+	}
+
+	protected boolean readBool(ByteArrayInputStream data) {
+		return readInt8(data) == 1;
+	}
+
+	protected String readString(ByteArrayInputStream data) throws IOException {
+		// Force utf8
+		return new String(readBytes(readInt16(data), data), UTF8);
+	}
+
+	private byte[] readBytes(int size, ByteArrayInputStream data) throws IOException {
+		byte[] bs = new byte[size];
+		data.read(bs);
+		return bs;
+	}
+
+	protected byte[] readBinary(ByteArrayInputStream data) throws IOException {
+		long c = readInt32(data);
+		if (c > Integer.MAX_VALUE) {
+			throw new IndexOutOfBoundsException("Binary data to big for java");
+		}
+		return readBytes((int) c, data);
+	}
+
+	protected byte[] readShortBinary(ByteArrayInputStream data) throws IOException {
+		return readBytes(readInt8(data), data);
+	}
+
+	protected String readIpNumber(ByteArrayInputStream data) throws IOException {
+		byte[] ips = readShortBinary(data);		
+		if(ips.length == 4){
+			return readIpv4Number(ips);
+		} else{
+			return readIpv6Number(ips);
+		}
+	}
+
+	protected String readIpv4Number(byte[] ips){
+		String ip = "";
+		for (byte b : ips) {
+			if (ip.length() > 0) {
+				ip += ".";
+			}
+			ip += (b & 0xFF);
+		}
+		return ip;
+	}
+
+	protected String readIpv6Number(byte[] ips) throws IOException {
+		String ip = "";
+                int part1, part2;
+		for (int i = 0; i < ips.length; i+=2) {
+			part1   = ips[i] & 0xFF;
+			part2   = ips[i+1] & 0xFF;
+			ip += part1 == 0? "" : Integer.toHexString(part1);
+			ip += (part1 == 0 && part2 == 0)? "" : (part2 < 10 && part1 != 0? "0" + Integer.toHexString(part2): Integer.toHexString(part2));
+			if (i < ips.length-2) {
+				ip += ":";
+			}
+		}
+		ip = ip.replaceAll(":{3,}", "::");
+		return ip;
+	}
+
+	protected void writeInt8(int v, ByteArrayOutputStream out) {
+		if (v > 0xFF) { // Max 255
+			raiseError("Too large int8 number: " + v);
+		}else if(v < 0){
+			raiseError("a negative number passed  to int8 number: " + v);
+		}
+		out.write(v);
+	}
+
+	protected void writeInt16(int v, ByteArrayOutputStream out) {
+		if (v > 0xFFFF) { // Max 65.535 
+			raiseError("Too large int16 number: " + v);
+		}else if(v < 0){
+			raiseError("a negative number passed  to int16 number: " + v);
+		}
+		writeInt8(v >> 8 & 0xFF, out);
+		writeInt8(v & 0xFF, out);
+	}
+
+	protected void writeInt24(int v, ByteArrayOutputStream out) {
+		if (v > 0xFFFFFF) { 	// Max 16.777.215
+			raiseError("Too large int24 number: " + v);
+		}else if(v < 0){	// In Case added to Java declaration
+			raiseError("a negative number passed  to int24 number: " + v);
+		}
+		writeInt8(v >> 16 & 0xFF, out);
+		writeInt16(v & 0xFFFF, out);
+	}
+
+	protected void writeInt32(long v, ByteArrayOutputStream out) {
+		if (v > 0xFFFFFFFFL) { // Max 4.294.967.295
+			raiseError("Too large int32 number: " + v);
+		}else if(v < 0){
+			raiseError("a negative number passed  to int32 number: " + v);
+		}
+		writeInt8((int) ((v >> 24) & 0xFF), out);
+		writeInt24((int) (v & 0xFFFFFF), out);
+	}
+
+	protected void writeBool(boolean v, ByteArrayOutputStream out) {
+		writeInt8(v ? 1 : 0, out);
+	}
+
+	protected void writeString(String v, ByteArrayOutputStream out) throws IOException {
+		byte[] bs = v.getBytes(UTF8);
+		if (bs.length > 0xFFFF) {
+			raiseError("Too large string: " + bs.length + " bytes");
+		}
+		writeInt16(bs.length, out);
+		out.write(bs);
+	}
+
+	protected void writeBinary(byte[] v, ByteArrayOutputStream out) throws IOException {
+		if (v.length > 0xFFFFFFFFL) {
+			raiseError("Too large binary: " + v.length + " bytes");
+		}
+		writeInt32(v.length, out);
+		out.write(v);
+	}
+
+
+	protected void write16Binary(int[] v, ByteArrayOutputStream out) throws IOException {
+		if (v.length > 0xFF) {
+			raiseError("Too large 16_binary: " + (v.length*2) + " bytes");
+		}
+		writeInt8(v.length*2, out);
+		for(int i = 0; i < v.length; i++){
+			this.writeInt16(v[i], out);
+		}
+	}
+
+	protected void writeShortBinary(byte[] v, ByteArrayOutputStream out) throws IOException {
+		if (v.length > 0xFF) {
+			raiseError("Too large short_binary: " + v.length + " bytes");
+		}
+		writeInt8(v.length, out);
+		out.write(v);
+	}
+
+	protected void writeIpNumber(String v, ByteArrayOutputStream out) throws IOException {
+		if(v.contains(":")){
+			writeIpv6Number( v, out);
+		}else{
+			writeIpv4Number( v, out);
+    		}
+	}
+        
+        protected void writeIpv4Number(String v, ByteArrayOutputStream out) throws IOException {
+		byte[] ss = new byte[0];
+		if(!v.isEmpty()){
+			String[] bs = v.split("\\.");
+			ss = new byte[bs.length];
+			for (int i = 0; i < bs.length; i++) {
+				ss[i] = (byte) (Integer.parseInt(bs[i]) & 0xFF);
+			}
+		}
+		if (ss.length == 0 || ss.length == 4) {
+			writeShortBinary(ss, out);
+		} else {
+			raiseError("Unknown IP v4 number " + v); // Only IPv4 for now 
+		}
+	}
+
+        protected void writeIpv6Number(String v, ByteArrayOutputStream out)
+			throws IOException {
+		v = v.replaceAll(" ", "") + " "; // Temporary: To avoid the split problem when we have : at the
+					// end of "v"
+		int[] ss = new int[0];
+		boolean contains_ipv6_letters = Pattern.compile("[0-9a-f]+").matcher(
+				v.trim().toLowerCase()).find();
+		boolean contains_other_letters = Pattern.compile("[^:0-9a-f]+")
+				.matcher(v.trim().toLowerCase()).find();
+		// make sure of v must have only one "::" and no more than two of ":".
+		// e.g. 1::1::1 & 1:::1:205
+		if (!v.trim().isEmpty() && v.split(":{3,}").length == 1
+				&& v.split(":{2}").length <= 2 && !contains_other_letters
+				&& contains_ipv6_letters) {
+			String[] bs = v.split(":");
+			ss = new int[bs.length];
+			for (int i = 0; i < bs.length; i++) {
+				String s = bs[i].trim();
+				if (s.length() <= 4) // to avoid such number 0125f
+					ss[i] = Integer.parseInt(
+							(s.isEmpty() ? "0" : bs[i].trim()), 16);
+				else
+					raiseError("Unknown IPv6 Group " + i + " which is " + s);
+			}
+		}
+		// Check for make sure of the size of the IP groups in case "::" is used
+		// [> 2 & < 8]or not [must == 8]
+		if (!contains_other_letters
+				&& (!v.contains("::") && ss.length == 0 || ss.length == 8)
+				|| (v.contains("::") && ss.length > 2 && ss.length < 8)) {
+			write16Binary(ss, out);
+		} else {
+			raiseError("Unknown IP v6 number " + v);
+		}
+	}
+
+	protected void raiseError(String msg) {
+		throw new IllegalArgumentException("[" + this.getClass().getCanonicalName() + "] " + msg);
+	}
+}
+
+
+class Entry extends BabelBase {
+
+	@Override
+	void serializeInternal(ByteArrayOutputStream baos) throws IOException {
+	}
+
+	@Override
+	public void deserialize(ByteArrayInputStream bais) throws IOException {
+	}
+}
+
+
+class TestBasic extends BabelBase {
+	public int i8 = 0;
+	public int i16 = 0;
+	public long i32 = 0L;
+	public String str = "";
+	public String ip = "";
+	public byte[] guid = new byte[0];
+
+	@Override
+	void serializeInternal(ByteArrayOutputStream baos) throws IOException {
+		writeInt8(this.i8, baos);
+		writeInt16(this.i16, baos);
+		writeInt32(this.i32, baos);
+		writeString(this.str, baos);
+		writeIpNumber(this.ip, baos);
+		writeBinary(this.guid, baos);
+	}
+
+	@Override
+	public void deserialize(ByteArrayInputStream bais) throws IOException {
+		this.i8 = readInt8(bais);
+		this.i16 = readInt16(bais);
+		this.i32 = readInt32(bais);
+		this.str = readString(bais);
+		this.ip = readIpNumber(bais);
+		this.guid = readBinary(bais);
+	}
+}
+
+
+class TestComplex extends BabelBase {
+	public ArrayList<Long> list1 = new ArrayList<Long>();
+	public ArrayList<Integer> list2 = new ArrayList<Integer>();
+	public HashMap<Integer, Long> map1 = new HashMap<Integer, Long>();
+	public HashMap<String, ArrayList<Entry>> map2 = new HashMap<String, ArrayList<Entry>>();
+
+	@Override
+	void serializeInternal(ByteArrayOutputStream baos) throws IOException {
+		// Serialize list 'list1'
+		writeInt32(list1.size(), baos);
+		for(int var_101=0; var_101<list1.size(); var_101++) {
+			long var_100 = list1.get(var_101);
+			writeInt32(var_100, baos);
+		}
+		// Serialize list 'list2'
+		writeInt32(list2.size(), baos);
+		for(int var_103=0; var_103<list2.size(); var_103++) {
+			int var_102 = list2.get(var_103);
+			writeInt8(var_102, baos);
+		}
+		// Serialize map 'map1'
+		writeInt32(map1.size(), baos);
+		for(int var_104 : map1.keySet()) {
+			long var_105 = map1.get(var_104);
+			writeInt8(var_104, baos);
+			writeInt32(var_105, baos);
+		}
+		// Serialize map 'map2'
+		writeInt32(map2.size(), baos);
+		for(String var_106 : map2.keySet()) {
+			ArrayList<Entry> var_107 = map2.get(var_106);
+			writeString(var_106, baos);
+			writeInt32(var_107.size(), baos);
+			for(int var_109=0; var_109<var_107.size(); var_109++) {
+				Entry var_108 = var_107.get(var_109);
+				var_108.serializeInternal(baos);
+			}
+		}
+	}
+
+	@Override
+	public void deserialize(ByteArrayInputStream bais) throws IOException {
+		// Deserialize list 'list1'
+		this.list1 = new ArrayList<Long>();
+		int var_10a = (int)this.readInt32(bais);
+		for(int var_10c=0; var_10c<var_10a; var_10c++) {
+			long var_10b = readInt32(bais);
+			this.list1.add(var_10b);
+		}
+		// Deserialize list 'list2'
+		this.list2 = new ArrayList<Integer>();
+		int var_10d = (int)this.readInt32(bais);
+		for(int var_10f=0; var_10f<var_10d; var_10f++) {
+			int var_10e = readInt8(bais);
+			this.list2.add(var_10e);
+		}
+		// Deserialize map 'map1'
+		this.map1 = new HashMap<Integer, Long>();
+		int var_110 = (int)readInt32(bais);
+		for(int var_113=0; var_113<var_110; var_113++) {
+			int var_111 = readInt8(bais);
+			long var_112 = readInt32(bais);
+			this.map1.put(var_111, var_112);
+		}
+		// Deserialize map 'map2'
+		this.map2 = new HashMap<String, ArrayList<Entry>>();
+		int var_114 = (int)readInt32(bais);
+		for(int var_117=0; var_117<var_114; var_117++) {
+			String var_115 = readString(bais);
+			ArrayList<Entry> var_116 = new ArrayList<Entry>();
+			int var_118 = (int)this.readInt32(bais);
+			for(int var_11a=0; var_11a<var_118; var_11a++) {
+				Entry var_119 = new Entry();
+				var_119.deserialize(bais);
+				var_116.add(var_119);
+			}
+			this.map2.put(var_115, var_116);
+		}
+	}
+}