├── benchmark
    ├── gensort.msgpack
    └── benchmark.html
├── README
├── test
    ├── server.rb
    ├── test_pack.html
    ├── test_unpack.html
    └── test_xhr.html
└── lib
    └── msgpack.js


/benchmark/gensort.msgpack:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/cuzic/MessagePack-JS/HEAD/benchmark/gensort.msgpack


--------------------------------------------------------------------------------
/README:
--------------------------------------------------------------------------------
 1 | * MessagePack-JS
 2 |   JavaScript implimentation for MessagePack serialization format.
 3 | 
 4 | ** usage
 5 | 
 6 |   var $true  = MessagePack.unpack("\xc3");
 7 |   alert($true); // true
 8 | 
 9 |   var int8   = MessagePack.unpack("\xd0\xc0"));
10 |   alert(int8); // -64
11 | 
12 |   var fixraw = MessagePack.unpack("\xa1\x61");
13 |   alert(fixraw); // 'a'
14 | 
15 |   var int32  = MessagePack.unpack("\xd2\xff\xf0\x00\x00");
16 |   alert(int32); // -1048576
17 | 
18 | ** environment
19 |   tested for IE 8.0.6 , Firefox 3.6.3 , Google Chrome 4.1
20 | 
21 | ** see other
22 |   http://msgpack.sourceforge.net/
23 | 
24 | ** LISENCE
25 |   MIT Lisence
26 | 
27 | ** Test
28 |   Test code (tests.html) requires JsUnit
29 |   Benchmark code needs prototype.js
30 |   If you want to test and benchmark msgpack.js,
31 |     please deploy as follows:
32 |         ./lib/msgpack.js
33 |         ./test/test_unpack.html
34 |         ./test/test_pack.html
35 |         ./test/test_xhr.html
36 | 
37 |         # see jsunit < http://github.com/pivotal/jsunit >
38 |         ./test/jsunit/testRunner.html 
39 |         ./test/jsunit/app/jsUnitCore.js
40 |         ./test/jsunit/testRunner.html
41 |         ./test/jsunit/app/jsUnitCore.js
42 | 
43 |         ./benchmark/benchmark.html
44 |         # see prototype.js < http://www.prototypejs.org/ >
45 |         ./benchmark/prototype/prototype.js
46 | 
47 |   Before you test test_xhr.html, you must start server.rb.
48 |     > ruby server.rb
49 |   server.rb require Ruby MessagePack Library.
50 |   Please install Ruby MessagePack Library:
51 |     > gem install msgpack
52 | 


--------------------------------------------------------------------------------
/test/server.rb:
--------------------------------------------------------------------------------
 1 | #!/usr/local/bin/ruby
 2 | require 'webrick'
 3 | require 'rubygems'
 4 | require 'msgpack'
 5 | 
 6 | def webrick(config = {})
 7 |     WEBrick::HTTPServer.new(config).instance_eval do |server|
 8 |         [:INT, :TERM].each do |signal|
 9 |             Signal.trap(signal) { shutdown }
10 |         end
11 |         server.mount_proc("/unpack") do |req, res|
12 |             if req.path =~ %r(/unpack/([a-z0-9]+)) then
13 |                 path = $1
14 |                 res.content_type = "text/plain; charset=x-user-defined"
15 |                 case path
16 |                 when "null"
17 |                     res.body = nil.to_msgpack
18 |                 when "true"
19 |                     res.body = true.to_msgpack
20 |                 when "false"
21 |                     res.body = false.to_msgpack
22 |                 when "fixnum"
23 |                     res.body = 100.to_msgpack
24 |                 when "fixraw"
25 |                     res.body = "0123456789abc".to_msgpack
26 |                 when "fixarray"
27 |                     res.body = [0, true, false].to_msgpack
28 |                 when "fixmap"
29 |                     res.body = {0 => "0", 1 => "1"}.to_msgpack
30 |                 when "float"
31 |                     res.body = (10.5).to_msgpack
32 |                 when "uint8"
33 |                     res.body = 200.to_msgpack
34 |                 when "uint16"
35 |                     res.body = 40000.to_msgpack
36 |                 when "uint32"
37 |                     res.body = (3*(2**30)).to_msgpack
38 |                 when "uint64"
39 |                     res.body = (3*(2**62)).to_msgpack
40 |                 when "int8"
41 |                     res.body = (-100).to_msgpack
42 |                 when "int16"
43 |                     res.body = (-1000).to_msgpack
44 |                 when "int32"
45 |                     res.body = (-1000_000).to_msgpack
46 |                 when "int64"
47 |                     res.body = (-1000_000_000_000_000).to_msgpack
48 |                 when "raw16"
49 |                     res.body = ("a"*1000).to_msgpack
50 |                 when "raw32"
51 |                     res.body = ("a"*100_000).to_msgpack
52 |                 when "array16"
53 |                     res.body = ([1]*1000).to_msgpack
54 |                 when "array32"
55 |                     res.body = ([1]*100_000).to_msgpack
56 |                 when "map16"
57 |                     hash = (0..1000).inject({}) do |h, key|
58 |                         h[key] = key.to_s
59 |                         h
60 |                     end
61 |                     res.body = hash.to_msgpack
62 |                 when "map32"
63 |                     hash = (0..1000_000).inject({}) do |h, key|
64 |                         h[key] = key.to_s
65 |                         h
66 |                     end
67 |                     res.body = hash.to_msgpack
68 |                 end
69 |             end
70 |         end
71 |         start
72 |     end
73 | end
74 | 
75 | webrick :DocumentRoot => File.expand_path(File.join(File.dirname(__FILE__), "..")),
76 |     :Port => 5001
77 | 


--------------------------------------------------------------------------------
/benchmark/benchmark.html:
--------------------------------------------------------------------------------
  1 | <html>
  2 |  <head>
  3 |   <title> MessagePack Benchmark Test </title>
  4 |   <script type="text/javascript" src="./prototype/prototype.js"> </script>
  5 |   <script type="text/javascript" src="../msgpack.js"> </script>
  6 |   <script type="text/javascript">
  7 |   // global variables
  8 |   var $msgpack, $json;
  9 | 
 10 |   function load_msgpack(){
 11 |       var url = "./gensort.msgpack";
 12 |       new Ajax.Request(url, {
 13 |           method: 'get',
 14 |           onCreate: function(request, response){
 15 |           var transport = request.transport;
 16 |               if(transport.overrideMimeType){
 17 |                   transport.overrideMimeType("text/plain; charset=x-user-defined");
 18 |               }
 19 |           },
 20 |           onSuccess: function(response) {
 21 |               if(MessagePack.hasVBS){
 22 |                   var binary = response.transport.responseBody;
 23 |                   $msgpack = binary;
 24 |               }else{
 25 |                   $msgpack = response.responseText;
 26 |               }
 27 |               C("msgpack is loaded." );
 28 |           }
 29 |      })
 30 |   }
 31 | 
 32 |   function load_json(){
 33 |       url = "./gensort.json";
 34 | 
 35 |       new Ajax.Request(url, {
 36 |           method: 'get',
 37 |           onSuccess: function(transport) {
 38 |               $json = transport.responseText;
 39 |               C("json is loaded.");
 40 |           }
 41 |       });
 42 | };
 43 | 
 44 |   function getTimeMeasurementJavaScript(name, func){
 45 |       timeStart=new Date();
 46 | 
 47 |       func();
 48 | 
 49 |       totalTime = (new Date - timeStart);
 50 |       C(name + ":" + totalTime + " milli sec");
 51 |   }
 52 | 
 53 |   function msgpack_benchmark(msgpack){
 54 |       getTimeMeasurementJavaScript("msgpack", function(){
 55 |           var data;
 56 |           for(var i = 0; i < 10; i++){
 57 |               data = MessagePack.unpack(msgpack);
 58 |           }
 59 |       });
 60 |   }
 61 | 
 62 |   function json_benchmark(json){
 63 |       getTimeMeasurementJavaScript("json", function(){
 64 |           var data;
 65 |           for(var i = 0; i < 10; i++){
 66 |               data = eval(json);
 67 |           }
 68 |       });
 69 |   }
 70 | 
 71 |    function test_benchmark(){
 72 |       getTimeMeasurementJavaScript(function(){
 73 |           for(var i = 0; i < 1000; i++){
 74 |           }
 75 |       });
 76 |    }
 77 | 
 78 |   </script>
 79 | </head>
 80 | <body>
 81 |     <div>
 82 |     <input type="button" onclick="msgpack_benchmark($msgpack);" value="msgpack benchmark">
 83 |     <input type="button" onclick="json_benchmark($json);" value="json benchmark">
 84 |     </div>
 85 |     <div>
 86 |     <textarea id="console" style="width:70%;height:20em;"></textarea>
 87 |     </div>
 88 |     <script type="text/javascript">
 89 | var C = function(){
 90 | 	var c = document.getElementById('console');
 91 | 	return function(msg){
 92 | 		c.value = msg+'\n'+c.value;
 93 | 	}
 94 | }();
 95 | C('data loading...');
 96 | load_msgpack();
 97 | load_json();
 98 |     </script>
 99 | </body>
100 | </html>
101 | 


--------------------------------------------------------------------------------
/test/test_pack.html:
--------------------------------------------------------------------------------
 1 | <html>
 2 |  <head>
 3 |   <title> test pack </title>
 4 |   <script type="text/javascript" src="./jsunit/app/jsUnitCore.js">
 5 |   </script>
 6 |   <script type="text/javascript" src="../lib/msgpack.js">
 7 |   </script>
 8 |   <script type="text/javascript">
 9 |       if(MessagePack.hasVBS){
10 |           // quick hack for Internet Explorer unescape();
11 |           execScript(
12 |                   'Function msgpack_getByte(data, pos)\r\n' +
13 |                   '  msgpack_getByte = AscB(MidB(data, 2*pos + 1, 1))\r\n'+
14 |                   'End Function\r\n' , "VBScript"
15 |                   );
16 |       }
17 | 
18 |       function _test_pack(value, hex){
19 |           var data = MessagePack.pack(value);
20 |           var pp   = "\"" + hex.replace(/../g, "\\x$&") + "\""
21 |           var str  = eval(pp);
22 |           if(value == 0.1){
23 |                var s = "";
24 |                for(var i = 0; i < data.length; ++i){
25 |                    s += data.charCodeAt(i).toString(16);
26 |                }
27 |           }
28 |           assertEquals(str, data);
29 |       }
30 | 
31 |       function test_pack_positive_fixnum() {
32 |           _test_pack(0, "00");
33 |       }
34 |       function test_pack_negative_fixnum() {
35 |           _test_pack(-1, "ff");
36 |       }
37 |       function test_pack_uint8() {
38 |           _test_pack(255, "ccff");
39 |       }
40 |       function test_pack_FixRaw() {
41 |           _test_pack("a", "a161");
42 |       }
43 |       function test_pack_FixArray() {
44 |           _test_pack([0], "9100");
45 |       }
46 |       function test_pack_FixMap() {
47 |           _test_pack({"a": 64}, "81a16140");
48 |       }
49 |       function test_pack_Nil() {
50 |           _test_pack(null, "c0");
51 |       }
52 |       function test_pack_True() {
53 |           _test_pack(true, "c3");
54 |       }
55 |       function test_pack_False() {
56 |           _test_pack(false, "c2");
57 |       }
58 |       function test_pack_double() {
59 |           _test_pack(0.1, "cb3fb999999999999a");
60 |       }
61 |       function test_pack_uint16() {
62 |           _test_pack(32768, "cd8000");
63 |       }
64 |       function test_pack_uint32() {
65 |           _test_pack(1048576, "ce00100000");
66 |       }
67 |       function test_pack_int8() {
68 |           _test_pack(-64, "d0c0");
69 |       }
70 |       function test_pack_int16() {
71 |           _test_pack(-1024, "d1fc00");
72 |       }
73 |       function test_pack_int32() {
74 |           _test_pack(-1048576, "d2fff00000");
75 |       }
76 |       function test_pack_int64() {
77 |           _test_pack(-1099511627776, "d3ffffff0000000000");
78 |       }
79 |       function test_pack_raw16() {
80 |           var spaces = "                                        ";
81 |           _test_pack(spaces, "da002820202020202020202020202020202020202020202020202020202020202020202020202020202020");
82 |       }
83 |       function test_pack_array16() {
84 |           var ary = [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0];
85 |           _test_pack(ary, "dc001000000000000000000000000000000000");
86 |       }
87 | 
88 |       function test_pack_hiragana() {
89 |           //var data = MessagePack.pack("あい");
90 |           //assertEquals("hiragana ai", data, "\x");
91 |       }
92 |   </script>
93 | </head>
94 | <body>
95 | 
96 | </body>
97 | </html>
98 | 


--------------------------------------------------------------------------------
/test/test_unpack.html:
--------------------------------------------------------------------------------
  1 | <html>
  2 |  <head>
  3 |   <title> test </title>
  4 |   <script type="text/javascript" src="./jsunit/app/jsUnitCore.js">
  5 |   </script>
  6 |   <script type="text/javascript" src="../lib/msgpack.js">
  7 |   </script>
  8 |   <script type="text/javascript">
  9 |       if(MessagePack.hasVBS){
 10 |           // quick hack for Internet Explorer unescape();
 11 |           execScript(
 12 |                   'Function msgpack_getByte(data, pos)\r\n' +
 13 |                   '  msgpack_getByte = AscB(MidB(data, 2*pos + 1, 1))\r\n'+
 14 |                   'End Function\r\n' , "VBScript"
 15 |                   );
 16 |       }
 17 | 
 18 |       function testAssert_positive_fixnum() {
 19 |           var data = decodeURI("%00");
 20 |           var output = MessagePack.unpack(data);
 21 |           assertEquals("0x00 == 0", 0, output);
 22 |       }
 23 |       function testAssert_negative_fixnum() {
 24 |           var data = unescape("%FF");
 25 |           var output = MessagePack.unpack(data);
 26 |           assertEquals("0xFF == -1", -1, output);
 27 |       }
 28 |       function testAssert_uint8() {
 29 |           var data = unescape("%CC%FF");
 30 |           var output = MessagePack.unpack(data);
 31 |           assertEquals("0xCCFF == 255", 255, output);
 32 |       }
 33 |       function testAssert_FixRaw() {
 34 |           var data = unescape("%A1%61");
 35 |           var output = MessagePack.unpack(data);
 36 |           assertEquals("0xA161 == 'a'", 'a', output);
 37 |       }
 38 |       function testAssert_FixArray() {
 39 |           var data = unescape("%91%00");
 40 |           var output = MessagePack.unpack(data);
 41 |           assertArrayEquals("0x9100 == [0]", [0], output);
 42 |       }
 43 |       function testAssert_FixMap() {
 44 |           var data = unescape("%81%00%c0");
 45 |           var output = MessagePack.unpack(data);
 46 |           assertHashEquals("0x8100c0 == {0 => null}", {0: null}, output);
 47 |       }
 48 |       function testAssert_FixMap() {
 49 |           var data = unescape("%81%00%c0");
 50 |           var output = MessagePack.unpack(data);
 51 |           assertHashEquals("0x8100c0 == {0 => null}", {0: null}, output);
 52 |       }
 53 |       function testAssert_Nil() {
 54 |           var data = unescape("%c0");
 55 |           var output = MessagePack.unpack(data);
 56 |           assertNull("0xc0 == null", output);
 57 |       }
 58 |       function testAssert_Nil() {
 59 |           var data = unescape("%c0");
 60 |           var output = MessagePack.unpack(data);
 61 |           assertNull("0xc0 == null", output);
 62 |       }
 63 |       function testAssert_True() {
 64 |           var data = unescape("%c3");
 65 |           var output = MessagePack.unpack(data);
 66 |           assertTrue("0xc3 == true", output);
 67 |       }
 68 |       function testAssert_False() {
 69 |           var data = unescape("%c2");
 70 |           var output = MessagePack.unpack(data);
 71 |           assertFalse("0xc2 == false", output);
 72 |       }
 73 |       function testAssert_double() {
 74 |           var data = unescape("%cb%3f%b9%99%99%99%99%99%9a");
 75 |           var output = MessagePack.unpack(data);
 76 |           assertEquals("0xcb3fb999999999999a == 0.1", 0.1, output);
 77 |       }
 78 |       function testAssert_uint16() {
 79 |           var data = unescape("%cd%80%00");
 80 |           var output = MessagePack.unpack(data);
 81 |           assertEquals("0xcd8000 == 32768", 32768, output);
 82 |       }
 83 |       function testAssert_uint32() {
 84 |           var data = unescape("%ce%00%10%00%00");
 85 |           var output = MessagePack.unpack(data);
 86 |           assertEquals("0xce00100000 == 1048576", 1048576, output);
 87 |       }
 88 |       function testAssert_uint64() {
 89 |           var data = unescape("%cf%00%00%01%00%00%00%00%00");
 90 |           var output = MessagePack.unpack(data);
 91 |           assertEquals("0xcf0000010000000000 == 1099511627776", 1099511627776, output);
 92 |       }
 93 | 
 94 |       function testAssert_int8() {
 95 |           var data = unescape("%d0%c0");
 96 |           var output = MessagePack.unpack(data);
 97 |           assertEquals("0xd0c0 == -64", -64, output);
 98 |       }
 99 |       function testAssert_int16() {
100 |           var data = unescape("%d1%fc%00");
101 |           var output = MessagePack.unpack(data);
102 |           assertEquals("0xd1fc00 == -1024", -1024, output);
103 |       }
104 |       function testAssert_int32() {
105 |           var data = unescape("%d2%ff%f0%00%00");
106 |           var output = MessagePack.unpack(data);
107 |           assertEquals("0xd2fff00000 == -1048576", -1048576, output);
108 |       }
109 |       function testAssert_int64() {
110 |           var data = unescape("%d3%ff%ff%ff%00%00%00%00%00");
111 |           var output = MessagePack.unpack(data);
112 |           assertEquals("d3ffffff0000000000", -1099511627776, output);
113 |       }
114 |       function testAssert_raw16() {
115 |           var data = unescape("%da%00%28%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20");
116 |           var output = MessagePack.unpack(data);
117 |           assertEquals("40 spaces", "                                        ", output);
118 |       }
119 |       function testAssert_array16() {
120 |           var data = unescape("%dc%00%10%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00");
121 |           var output = MessagePack.unpack(data);
122 |           assertArrayEquals("[0]*16", [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], output);
123 |       }
124 | 
125 |       function testAssert_hiragana() {
126 |           var data = unescape("%a6%e3%81%82%e3%81%84");
127 |           var output = MessagePack.unpack(data);
128 |           assertEquals("hiragana ai", "あい", output);
129 |       }
130 |   </script>
131 | </head>
132 | <body>
133 | </body>
134 | </html>
135 | 
136 | 


--------------------------------------------------------------------------------
/test/test_xhr.html:
--------------------------------------------------------------------------------
  1 | <html>
  2 |  <head>
  3 |   <title> test xml http request</title>
  4 |   <script type="text/javascript" src="./jsunit/app/jsUnitCore.js">
  5 |   </script>
  6 |   <script type="text/javascript" src="../lib/msgpack.js">
  7 |   </script>
  8 |   <script type="text/javascript">
  9 |       function async_request(url, fn){
 10 |           var xhr; 
 11 |           if(window.ActiveXObject) {
 12 |               try {
 13 |                   xhr = new ActiveXObject('Msxml2.XMLHTTP');
 14 |               }
 15 |               catch(e) {
 16 |                   xhr = new ActiveXObject('Microsoft.XMLHTTP');
 17 |               }
 18 |           }
 19 |           else if(window.XMLHttpRequest) {
 20 |                xhr = new XMLHttpRequest();
 21 |           } else {
 22 |               throw "no xml http request";
 23 |           }
 24 | 
 25 |           var callback = function(){
 26 |               if(xhr.readyState  == 4) {
 27 |                   if(window.ActiveXObject){
 28 |                       fn(xhr.responseBody);
 29 |                   }
 30 |                   else{
 31 |                       fn(xhr.responseText);
 32 |                   }
 33 |               }
 34 |           };
 35 | 
 36 |           xhr.onreadystatechange  = callback;
 37 |           if(xhr.overrideMimeType){
 38 |               xhr.overrideMimeType('text/plain; charset=x-user-defined');
 39 |           }
 40 | 
 41 |           xhr.open("GET", url,  false); 
 42 |           xhr.send(null); 
 43 |       }
 44 | 
 45 |       function _test_unpack(path, value_or_func){
 46 |           var url = "http://localhost:5001/unpack/";
 47 |           var callback = function(msg){
 48 |               var data = MessagePack.unpack(msg);
 49 |               if(typeof(value_or_func) == "function"){
 50 |                   var func = value_or_func;
 51 |                   func(data);
 52 |               }
 53 |               else{
 54 |                   var value = value_or_func;
 55 |                   assertEquals(path + ": \"" + escape(data) +
 56 |                           "\" == " + value, value, data);
 57 |               }
 58 |               if(value != data){
 59 |                   C(value + "!=" + data);
 60 |               }
 61 |               else{
 62 |                   C(value + "==" + data);
 63 |               }
 64 |           };
 65 |           async_request(url + path, callback);
 66 |       }
 67 | 
 68 |       function testAssert_fixnum() {
 69 |           _test_unpack("fixnum", 100);
 70 |       }
 71 |       function testAssert_null() {
 72 |           _test_unpack("null", function(data){
 73 |                   assertNull(data);
 74 |                   });
 75 |       }
 76 |       function testAssert_true() {
 77 |           _test_unpack("true", function(data){
 78 |                   assertTrue(data);
 79 |                   });
 80 |       }
 81 |       function testAssert_fixraw() {
 82 |           _test_unpack("fixraw", "0123456789abc");
 83 |       }
 84 | 
 85 |       function testAssert_fixarray(){
 86 |           _test_unpack("fixarray", function(data){
 87 |                   assertArrayEquals(data, [0, true, false]);
 88 |           });
 89 |       }
 90 |       function testAssert_fixmap() {
 91 |           _test_unpack("fixmap", function(data){
 92 |               assertObjectEquals(data, {0: "0", 1: "1"});
 93 |           });
 94 |       }
 95 |       function testAssert_float() {
 96 |           _test_unpack("float", 10.5);
 97 |       }
 98 |       function testAssert_uint8() {
 99 |           _test_unpack("uint8", 200);
100 |       }
101 |       function testAssert_uint16() {
102 |           _test_unpack("uint16", 40000);
103 |       }
104 |       function testAssert_uint32() {
105 |           _test_unpack("uint32", 3*Math.pow(2, 30));
106 |       }
107 |       function testAssert_uint64() {
108 |           _test_unpack("uint64", 3*Math.pow(2, 62));
109 |       }
110 |       function testAssert_int8() {
111 |           _test_unpack("int8", -100);
112 |       }
113 |       function testAssert_int16() {
114 |           _test_unpack("int16", -1000);
115 |       }
116 |       function testAssert_int32() {
117 |           _test_unpack("int32", -1000000);
118 |       }
119 |       function testAssert_int64() {
120 |           _test_unpack("int64", -Math.pow(10, 15));
121 |       }
122 |       function testAssert_raw16() {
123 |           var a = "";
124 |           for(var i = 0; i < 1000; i++){
125 |               a.concat("a");
126 |           }
127 |           _test_unpack("raw16", a);
128 |       }
129 |       function testAssert_raw32() {
130 |           var a = "";
131 |           for(var i = 0; i < 100000; i++){
132 |               a.concat("a");
133 |           }
134 |           _test_unpack("raw32", a);
135 |       }
136 |       function testAssert_array16() {
137 |           var a = [];
138 |           for(var i = 0; i < 1000; i++){
139 |               a[i] = 1;
140 |           }
141 |           _test_unpack("array16", function(data){
142 |                   assertArrayEquals(data, a);
143 |           });
144 |       }
145 | 
146 |       function testAssert_array32() {
147 |           var a = [];
148 |           for(var i = 0; i < 100000; i++){
149 |               a[i] = 1;
150 |           }
151 |           _test_unpack("array32", function(data){
152 |                   assertArrayEquals(data, a);
153 |                   });
154 |       }
155 |       function testAssert_map16() {
156 |           var a = {};
157 |           for(var i = 0; i < 1000; i++){
158 |               a[i] = "" + i;
159 |           }
160 |           _test_unpack("map16", function(data){
161 |                   assertObjectEquals(data, a);
162 |                   });
163 |       }
164 | 
165 |       function testAssert_map32() {
166 |           var a = {};
167 |           for(var i = 0; i < 100000; i++){
168 |               a[i] = "" + i;
169 |           }
170 |           _test_unpack("map32", function(data){
171 |                   assertObjectEquals(data, a);
172 |                   });
173 |       }
174 |   </script>
175 | </head>
176 | <body>
177 |     <input type=button onclick="testAssert_fixarray();" value="fixarray">
178 |     <input type=button onclick="testAssert_uint8();" value="uint8">
179 |     <input type=button onclick="testAssert_fixnum();" value="fixnum">
180 |     <input type=button onclick="testAssert_uint16();" value="uint16">
181 |     <input type=button onclick="testAssert_uint32();" value="uint32">
182 |     <input type=button onclick="testAssert_float();" value="float">
183 |     <br/>
184 |     <textarea id="console" cols=50 rows=10>
185 |     </textarea>
186 |     <script type="text/javascript">
187 |         function C(msg){
188 |             var ta = document.getElementById("console");
189 |             ta.value = msg + "\n" + ta.value;
190 |         }
191 |     </script>
192 | </body>
193 | </html>
194 | 


--------------------------------------------------------------------------------
/lib/msgpack.js:
--------------------------------------------------------------------------------
  1 | MessagePack = {};
  2 | MessagePack.unpack = function(data){
  3 |         var unpacker = new MessagePack.Decoder(data);
  4 |         return unpacker.unpack();
  5 | };
  6 | 
  7 | MessagePack.UTF8      = 0;
  8 | MessagePack.ASCII8bit = 1;
  9 | MessagePack.UTF16     = 2; // not yet implemented
 10 | MessagePack.ByteArray = -1;
 11 | MessagePack.CharSet   = MessagePack.UTF8;
 12 | 
 13 | // data : responseText for FireFox, Chrome, Safari ...
 14 | //      : responseBody for Internet Explorer
 15 | // charSet : specifies how to handle with raw data
 16 | //      'utf-8': assume raw data is UTF-8 String
 17 | //      'ascii': assume raw data is ASCII-8bit String
 18 | //      'utf16': assume raw data is UTF-16 String
 19 | //      'byte-array': not convert to string. just return array of numbers
 20 | MessagePack.Decoder = function(data, charSet){
 21 |     this.index = 0;
 22 |     if(MessagePack.hasVBS){
 23 |         if(typeof(data) == "unknown"){
 24 |             // assume data is byte array
 25 |             this.length = msgpack_getLength(data);
 26 |             this.byte_array_to_string(data);
 27 |         }else{
 28 |             this.length = msgpack_getLength(data);
 29 |             this.data = data;
 30 |         }
 31 |     }else{
 32 |         this.length = data.length;
 33 |         this.data   = data;
 34 |     }
 35 |     charSet = charSet || MessagePack.CharSet || 0;
 36 |     if(charSet == 'utf-8'){
 37 |         charSet = MessagePack.UTF8;
 38 |     }
 39 |     else if(charSet == 'ascii'){
 40 |         charSet = MessagePack.ASCII8bit;
 41 |     }
 42 |     else if(charSet == 'utf16'){
 43 |         charSet = MessagePack.UTF16;
 44 |     }
 45 |     else if(charSet == 'byte-array'){
 46 |         charSet = MessagePack.ByteArray;
 47 |     }
 48 |     else{
 49 |         charSet = MessagePack.UTF8;
 50 |     }
 51 | }
 52 | 
 53 | 
 54 | if(typeof execScript != 'undefined'){
 55 |     execScript(
 56 |             'Dim g_msgpack_binary_data\n' +
 57 |             'Sub msgpack_set_binary_data(binary)\n' +
 58 |             '    g_msgpack_binary_data = binary\n' +
 59 |             'End Sub\n' +
 60 |             'Function msgpack_getByte(pos)\n' +
 61 |             '  msgpack_getByte = AscB(MidB(g_msgpack_binary_data, pos + 1, 1))\n'+
 62 |             'End Function\n',"VBScript");
 63 |     execScript(
 64 |             'Function msgpack_substr(pos, len)\n' +
 65 |             '  Dim array()\n'+
 66 |             '  ReDim array(len)\n'+
 67 |             '  For i = 1 To len\n'+
 68 |             '    array(i-1) = AscB(MidB(g_msgpack_binary_data, pos + i, 1))\n'+
 69 |             '  Next\n'+
 70 |             '  msgpack_substr = array\n'+
 71 |             'End Function\n' +
 72 |             'Function msgpack_getLength(data)\n' +
 73 |             '  msgpack_getLength = LenB(data)\n' +
 74 |             'End Function\n' +
 75 |             '\n', 'VBScript');
 76 | }
 77 | 
 78 | MessagePack.hasVBS = 'msgpack_getByte' in this;
 79 | 
 80 | with({p: MessagePack.Decoder.prototype}){
 81 |     p.unpack = function(){
 82 |         var type = this.unpack_uint8();
 83 |         if(type < 0x80){
 84 |             var positive_fixnum = type;
 85 |             return positive_fixnum;
 86 |         }else if((type ^ 0xe0) < 0x20){
 87 |             var negative_fixnum = (type ^ 0xe0) - 0x20;
 88 |             return negative_fixnum;
 89 |         }
 90 |         var size;
 91 |         if((size = type ^ 0xa0) <= 0x1f){
 92 |             return this.unpack_raw(size);
 93 |         }else if((size = type ^ 0x90) <= 0x0f){
 94 |             return this.unpack_array(size);
 95 |         }else if((size = type ^ 0x80) <= 0x0f){
 96 |             return this.unpack_map(size);
 97 |         }
 98 | 
 99 |         switch(type){
100 |             case 0xc0:
101 |                 return null;
102 |             case 0xc1:
103 |                 return undefined;
104 |             case 0xc2:
105 |                 return false;
106 |             case 0xc3:
107 |                 return true;
108 |             case 0xca:
109 |                 return this.unpack_float();
110 |             case 0xcb:
111 |                 return this.unpack_double();
112 |             case 0xcc:
113 |                 return this.unpack_uint8();
114 |             case 0xcd:
115 |                 return this.unpack_uint16();
116 |             case 0xce:
117 |                 return this.unpack_uint32();
118 |             case 0xcf:
119 |                 return this.unpack_uint64();
120 |             case 0xd0:
121 |                 return this.unpack_int8();
122 |             case 0xd1:
123 |                 return this.unpack_int16();
124 |             case 0xd2:
125 |                 return this.unpack_int32();
126 |             case 0xd3:
127 |                 return this.unpack_int64();
128 |             case 0xd4:
129 |                 return undefined;
130 |             case 0xd5:
131 |                 return undefined;
132 |             case 0xd6:
133 |                 return undefined;
134 |             case 0xd7:
135 |                 return undefined;
136 |             case 0xd8:
137 |                 return undefined;
138 |             case 0xd9:
139 |                 return undefined;
140 |             case 0xda:
141 |                 size = this.unpack_uint16();
142 |                 return this.unpack_raw(size);
143 |             case 0xdb:
144 |                 size = this.unpack_uint32;
145 |                 return this.unpack_raw(size);
146 |             case 0xdc:
147 |                 size = this.unpack_uint16();
148 |                 return this.unpack_array(size);
149 |             case 0xdd:
150 |                 size = this.unpack_uint32();
151 |                 return this.unpack_array(size);
152 |             case 0xde:
153 |                 size = this.unpack_uint16();
154 |                 return this.unpack_map(size);
155 |             case 0xdf:
156 |                 size = this.unpack_uint32();
157 |                 return this.unpack_map(size);
158 |         }
159 |     }
160 | 
161 |     p.unpack_uint8 = function(){
162 |         var byte = this.getc() & 0xff;
163 |         this.index++;
164 |         return byte;
165 |     };
166 | 
167 |     p.unpack_uint16 = function(){
168 |         var bytes = this.read(2);
169 |         var uint16 =
170 |             ((bytes[0] & 0xff) * 256) + (bytes[1] & 0xff);
171 |         this.index += 2;
172 |         return uint16;
173 |     }
174 | 
175 |     p.unpack_uint32 = function(){
176 |         var bytes = this.read(4);
177 |         var uint32 =
178 |              ((bytes[0]  * 256 +
179 |                bytes[1]) * 256 +
180 |                bytes[2]) * 256 +
181 |                bytes[3];
182 |         this.index += 4;
183 |         return uint32;
184 |     }
185 | 
186 |     p.unpack_uint64 = function(){
187 |         var bytes = this.read(8);
188 |         var uint64 =
189 |          ((((((bytes[0]  * 256 +
190 |                bytes[1]) * 256 +
191 |                bytes[2]) * 256 +
192 |                bytes[3]) * 256 +
193 |                bytes[4]) * 256 +
194 |                bytes[5]) * 256 +
195 |                bytes[6]) * 256 +
196 |                bytes[7];
197 |         this.index += 8;
198 |         return uint64;
199 |     }
200 | 
201 | 
202 |     p.unpack_int8 = function(){
203 |         var uint8 = this.unpack_uint8();
204 |         return (uint8 < 0x80 ) ? uint8 : uint8 - (1 << 8);
205 |     };
206 | 
207 |     p.unpack_int16 = function(){
208 |         var uint16 = this.unpack_uint16();
209 |         return (uint16 < 0x8000 ) ? uint16 : uint16 - (1 << 16);
210 |     }
211 | 
212 |     p.unpack_int32 = function(){
213 |         var uint32 = this.unpack_uint32();
214 |         return (uint32 < Math.pow(2, 31) ) ? uint32 :
215 |             uint32 - Math.pow(2, 32);
216 |     }
217 | 
218 |     p.unpack_int64 = function(){
219 |         var uint64 = this.unpack_uint64();
220 |         return (uint64 < Math.pow(2, 63) ) ? uint64 :
221 |             uint64 - Math.pow(2, 64);
222 |     }
223 | 
224 |     p.unpack_raw = function(size){
225 |         if( this.length < this.index + size){
226 |             throw new Error("MessagePackFailure: index is out of range"
227 |                 + " " + this.index + " " + size + " " + this.length);
228 |         }
229 |         var bytes = this.read(size);
230 |         this.index += size;
231 |         if(this.charSet == MessagePack.ASCII8bit){
232 |             // For 8bit encoding
233 |             return String.fromCharCode.apply(String, bytes);
234 |         }else if(this.charSet == MessagePack.ByteArray){
235 |             // Array of numbers
236 |             return bytes;
237 |         }
238 |         else{
239 |         // assume UTF-8 string
240 |             var i = 0, str = "", c, code;
241 |             while(i < size){
242 |                 c = bytes[i];
243 |                 if( c < 128){
244 |                     str += String.fromCharCode(c);
245 |                     i++;
246 |                 }
247 |                 else if((c ^ 0xc0) < 32){
248 |                     code = ((c ^ 0xc0) << 6) | (bytes[i+1] & 63);
249 |                     str += String.fromCharCode(code);
250 |                     i += 2;
251 |                 }
252 |                 else {
253 |                     code = ((c & 15) << 12) | ((bytes[i+1] & 63) << 6) |
254 |                         (bytes[i+2] & 63);
255 |                     str += String.fromCharCode(code);
256 |                     i += 3;
257 |                 }
258 |             }
259 |             return str;
260 |         }
261 |     }
262 | 
263 |     p.unpack_array = function(size){
264 |         var objects = new Array(size);
265 |         for(var i = 0; i < size ; i++){
266 |             objects[i] = this.unpack();
267 |         }
268 |         return objects;
269 |     }
270 | 
271 |     p.unpack_map = function(size){
272 |         var map = {};
273 |         for(var i = 0; i < size ; i++){
274 |             var key  = this.unpack();
275 |             var value = this.unpack();
276 |             map[key] = value;
277 |         }
278 |         return map;
279 |     }
280 | 
281 |     p.unpack_float = function(){
282 |         var uint32 = this.unpack_uint32();
283 |         var sign = uint32 >> 31;
284 |         var exp  = ((uint32 >> 23) & 0xff) - 127;
285 |         var fraction = ( uint32 & 0x7fffff ) | 0x800000;
286 |         return (sign == 0 ? 1 : -1) *
287 |             fraction * Math.pow(2, exp - 23);
288 |     }
289 | 
290 |     p.unpack_double = function(){
291 |         var h32 = this.unpack_uint32();
292 |         var l32 = this.unpack_uint32();
293 |         var sign = h32 >> 31;
294 |         var exp  = ((h32 >> 20) & 0x7ff) - 1023;
295 |         var hfrac = ( h32 & 0xfffff ) | 0x100000;
296 |         var frac = hfrac * Math.pow(2, exp - 20) +
297 |             l32   * Math.pow(2, exp - 52);
298 |         return (sign == 0 ? 1 : -1) * frac;
299 |     }
300 | 
301 |     p.byte_array_to_string = function(data){
302 |         var binary_to_js_array_hex = function(binary){
303 |             var xmldom = new ActiveXObject("Microsoft.XMLDOM");
304 |             var bin = xmldom.createElement("bin");
305 |             bin.nodeTypedValue = data;
306 |             bin.dataType = "bin.hex";
307 | 
308 |             var text = bin.text;
309 |             var size = text.length;
310 |             return function (start, length){
311 |                 var i = 0, chunk = 4, bytes = []
312 |                     chunk2 = chunk*2, hex, int32;
313 |                 for(; i + 3 < length; i+=4){
314 |                     hex = text.substr(2*(i + start), chunk2);
315 |                     int32 = parseInt(hex, 16);
316 | 
317 |                     bytes[i    ] = (int32 > 24) & 0xff;
318 |                     bytes[i + 1] = (int32 > 16) & 0xff;
319 |                     bytes[i + 2] = (int32 >  8) & 0xff;
320 |                     bytes[i + 3] =  int32       & 0xff;
321 |                 }
322 |                 for(i -= 3; i < length; i++){
323 |                     hex = this.data.substr(2*(i+start), 2);
324 |                     bytes[i] = parseInt(hex, 16);
325 |                 }
326 |                 return bytes;
327 |             }
328 |         }
329 | 
330 |         var binary_to_js_array_base64 = function(binary){
331 |             var chr2index = {};
332 |             var text;
333 |             (function(){
334 |                var xmldom = new ActiveXObject("Microsoft.XMLDOM");
335 |                var bin = xmldom.createElement("bin");
336 |                bin.dataType = "bin.base64";
337 |                bin.nodeTypedValue = binary;
338 | 
339 |                text = bin.text.replace(/[^A-Za-z0-9\+\/\=]/g, "");
340 | 
341 |                var b64map =
342 |                "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
343 |                for(var i = 0, length = b64map.length;  i < length ; i++){
344 |                    chr2index[b64map.charAt(i)] = i;
345 |                }
346 |             })();
347 |             var chr2, chr3, prev_i = 0;
348 |             return function(start, length){
349 |                 var bytes, last_pos = Math.floor(3 * prev_i / 4);
350 |                 switch(last_pos - start){
351 |                     case 2:
352 |                         bytes = [chr2, chr3];
353 |                         break;
354 |                     case 1:
355 |                         bytes = [chr3];
356 |                         break;
357 |                     default:
358 |                         bytes = [];
359 |                 }
360 |                 var j = bytes.length;
361 |                 if(length <= j){
362 |                     bytes.length = length;
363 |                     return bytes;
364 |                 }
365 |                 var i = prev_i, enc1, enc2, enc3, enc4,
366 |                     last = 4*Math.ceil((start + length) / 3);
367 |                 while(i < last){
368 |                     enc1 = chr2index[text.charAt(i++)];
369 |                     enc2 = chr2index[text.charAt(i++)];
370 |                     enc3 = chr2index[text.charAt(i++)];
371 |                     enc4 = chr2index[text.charAt(i++)];
372 | 
373 |                     bytes[j++] = (enc1 << 2) | (enc2 >> 4);
374 |                     bytes[j++] = ((enc2 & 0x0f) << 4) | (enc3 >> 2);
375 |                     bytes[j++] = ((enc3 & 0x03) << 6) | enc4;
376 |                 }
377 |                 prev_i = i;
378 |                 chr2 = bytes[j-2];
379 |                 chr3 = bytes[j-1];
380 |                 bytes.length = length;
381 |                 return bytes;
382 |             }
383 |         }
384 | 
385 |         var binary_to_js_array_vbs = function(data){
386 |             msgpack_set_binary_data(data);
387 |             return function(position, length){
388 |                 return msgpack_substr(position, length).toArray();
389 |             }
390 |         };
391 | 
392 |         //var bytes_substr = binary_to_js_array_hex(data);
393 |         var bytes_substr = binary_to_js_array_base64(data);
394 |         //var bytes_substr = binary_to_js_array_vbs(data);
395 | 
396 |         this.read = function(length){
397 |             var j = this.index, i = 0;
398 |             if( j + length <= this.length){
399 |                 return bytes_substr( j, length);
400 |             }else{
401 |                 throw new Error("MessagePackFailure: index is out of range");
402 |             }
403 |         }
404 | 
405 |         this.getc = function(){
406 |             var j = this.index;
407 |             if(j < this.length){
408 |                 return bytes_substr( j, 1)[0];
409 |             }else{
410 |                 throw new Error("MessagePackFailure: index is out of range");
411 |             }
412 |         }
413 |     }
414 | 
415 |     p.read = function(length){
416 |         var j = this.index;
417 |         if(j + length <= this.length){
418 |             var bytes = new Array(length);
419 |             for(var i = length - 1; i >= 0; --i){
420 |                 bytes[i] = this.data.charCodeAt(j+i) & 0xff;
421 |             }
422 |             return bytes;
423 |         }else{
424 |             throw new Error("MessagePackFailure: index is out of range");
425 |         }
426 |     }
427 | 
428 |     p.getc = function(){
429 |         var j = this.index;
430 |         if(j < this.length){
431 |             return this.data.charCodeAt(j);
432 |         }
433 |         else{
434 |             throw new Error("MessagePackFailure: index is out of range");
435 |         }
436 |     }
437 | }
438 | 
439 | MessagePack.pack = function(data){
440 |     var enc = new MessagePack.Encoder(data);
441 |     return enc.pack(data);
442 | }
443 | 
444 | // Encoder object has no member and constructor does nothing
445 | // TODO:  implement something
446 | MessagePack.Encoder = function(data, charSet){
447 | }
448 | 
449 | with ({p: MessagePack.Encoder.prototype}){
450 |     p.pack = function(value){
451 |         var type = typeof(value);
452 |         if(type == "string"){
453 |             return this.pack_string(value);
454 |         }
455 |         else if(type == "number"){
456 |             if(Math.floor(value) === value){
457 |                 return this.pack_integer(value);
458 |             }
459 |             else{
460 |                 return this.pack_double(value);
461 |             }
462 |         }
463 |         else if(type == "boolean"){
464 |             if(value === true){
465 |                 return "\xc3";
466 |             }
467 |             else if(value === false){
468 |                 return "\xc2";
469 |             }
470 |         }
471 |         else if(type == "object"){
472 |             if(value === null){
473 |                 return "\xc0";
474 |             }
475 |             var constructor = value.constructor;
476 |             if(constructor == Array){
477 |                 return this.pack_array(value);
478 |             }
479 |             else if(constructor == Object){
480 |                 return this.pack_object(value);
481 |             }
482 |             else{
483 |                 throw new Error("not yet supported")
484 |             }
485 |         }
486 |     }
487 | 
488 |     p.pack_string = function(str){
489 |         var length = str.length;
490 |         if(length <= 0x1f){
491 |             return this.pack_uint8(0xa0 + length) + str;
492 |         }
493 |         else if(length <= 0xffff){
494 |             return "\xda" + this.pack_uint16(length) + str;
495 |         }
496 |         else if(length <= 0xffffffff){
497 |             return "\xdb" + this.pack_uint32(length) + str;
498 |         }
499 |         else{
500 |             throw new Error("invalid length");
501 |         }
502 |     }
503 | 
504 |     p.pack_array = function(ary){
505 |         var length = ary.length;
506 |         var str;
507 | 
508 |         if(length <= 0x0f){
509 |             str = this.pack_uint8(0x90 + length);
510 |         }
511 |         else if(length <= 0xffff){
512 |             str = "\xdc" + this.pack_uint16(length);
513 |         }
514 |         else if(length <= 0xffffffff){
515 |             str = "\xdd" + this.pack_uint32(length);
516 |         }
517 |         else{
518 |             throw new Error("invalid length");
519 |         }
520 |         var elems = [];
521 |         for(var i = 0; i < length ; i++){
522 |             elems.push(this.pack(ary[i]));
523 |         }
524 |         return str + elems.join("");
525 |     }
526 | 
527 |     p.pack_integer = function(num){
528 |         if( -0x20 <= num && num <= 0x7f){
529 |             return String.fromCharCode(num & 0xff);
530 |         }
531 |         else if(0x00 <= num && num <= 0xff){
532 |             return "\xcc" + this.pack_uint8(num);
533 |         }
534 |         else if(-0x80 <= num && num <= 0x7f){
535 |             return "\xd0" + this.pack_int8(num);
536 |         }
537 |         else if( 0x0000 <= num && num <= 0xffff){
538 |             return "\xcd" + this.pack_uint16(num);
539 |         }
540 |         else if(-0x8000 <= num && num <= 0x7fff){
541 |             return "\xd1" + this.pack_int16(num);
542 |         }
543 |         else if( 0x00000000 <= num && num <= 0xffffffff){
544 |             return "\xce" + this.pack_uint32(num);
545 |         }
546 |         else if(-0x80000000 <= num && num <= 0x7fffffff){
547 |             return "\xd2" + this.pack_int32(num);
548 |         }
549 |         else if(-0x8000000000000000 <= num && num <= 0x7FFFFFFFFFFFFFFF){
550 |             return "\xd3" + this.pack_int64(num);
551 |         }
552 |         else if(0x0000000000000000 <= num && num <= 0xFFFFFFFFFFFFFFFF){
553 |             return "\xcf" + this.pack_uint64(num);
554 |         }
555 |         else{
556 |             throw new Error("invalid integer");
557 |         }
558 |     }
559 | 
560 |     p.pack_double = function(num){
561 |         var sign = 0;
562 |         if(num < 0){
563 |             sign = 1;
564 |             num = -num;
565 |         }
566 |         var exp  = Math.floor(Math.log(num) / Math.LN2);
567 |         var frac0 = num / Math.pow(2, exp) - 1;
568 |         var frac1 = Math.floor(frac0 * Math.pow(2, 52));
569 |         var b32   = Math.pow(2, 32);
570 |         var h32 = (sign << 31) | ((exp+1023) << 20) |
571 | 	          (frac1 / b32) & 0x0fffff;
572 |         var l32 = frac1 % b32;
573 |         return "\xcb" + this.pack_int32(h32) + this.pack_int32(l32);
574 |     }
575 | 
576 |     p.pack_object = function(obj){
577 |         var str = "";
578 |         var length = 0;
579 |         var ary = [];
580 |         for(var prop in obj){
581 |             if(obj.hasOwnProperty(prop)){
582 |                 length++;
583 |                 ary.push(this.pack(prop));
584 |                 ary.push(this.pack(obj[prop]));
585 |             }
586 |         }
587 |         if(length <= 0x0f){
588 |             return this.pack_uint8(0x80 + length) + ary.join("");
589 |         }
590 |         else if(length <= 0xffff){
591 |             return "\xde" + this.pack_uint16(length) + ary.join("");
592 |         }
593 |         else if(length <= 0xffffffff){
594 |             return "\xdf" + this.pack_uint32(length) + ary.join("");
595 |         }
596 |         else{
597 |             throw new Error("invalid length");
598 |         }
599 |     }
600 | 
601 |     p.pack_uint8 = function(num){
602 |         return String.fromCharCode(num);
603 |     }
604 | 
605 |     p.pack_uint16 = function(num){
606 |         return String.fromCharCode(num >> 8, num & 0xff);
607 |     }
608 | 
609 |     p.pack_uint32 = function(num){
610 |         var n = num & 0xffffffff;
611 |         return String.fromCharCode(
612 |                 (n & 0xff000000) >>> 24,
613 |                 (n & 0x00ff0000) >>> 16,
614 |                 (n & 0x0000ff00) >>>  8,
615 |                 (n & 0x000000ff));
616 |     }
617 | 
618 |     p.pack_uint64 = function(num){
619 |         var high = num / Math.pow(2, 32);
620 |         var low  = num % Math.pow(2, 32);
621 | 
622 |         return String.fromCharCode(
623 |                 (high & 0xff000000) >>> 24,
624 |                 (high & 0x00ff0000) >>> 16,
625 |                 (high & 0x0000ff00) >>>  8,
626 |                 (high & 0x000000ff),
627 |                 (low  & 0xff000000) >>> 24,
628 |                 (low  & 0x00ff0000) >>> 16,
629 |                 (low  & 0x0000ff00) >>>  8,
630 |                 (low  & 0x000000ff));
631 |     }
632 | 
633 |     p.pack_int8 = function(num){
634 |         return String.fromCharCode(num & 0xff);
635 |     }
636 | 
637 |     p.pack_int16 = function(num){
638 |         return String.fromCharCode((num & 0xff00) >> 8, num & 0xff);
639 |     }
640 | 
641 |     p.pack_int32 = function(num){
642 |         return String.fromCharCode((num >>> 24) & 0xff,
643 |                 (num & 0x00ff0000) >>> 16,
644 |                 (num & 0x0000ff00) >>> 8,
645 |                 (num & 0x000000ff));
646 |     }
647 | 
648 |     p.pack_int64 = function(num){
649 |         var high = Math.floor(num / Math.pow(2, 32));
650 |         var low  = num % Math.pow(2, 32);
651 | 
652 |         return String.fromCharCode(
653 |             (high & 0xff000000) >>> 24,
654 |             (high & 0x00ff0000) >>> 16,
655 |             (high & 0x0000ff00) >>>  8,
656 |             (high & 0x000000ff),
657 |             (low  & 0xff000000) >>> 24,
658 |             (low  & 0x00ff0000) >>> 16,
659 |             (low  & 0x0000ff00) >>>  8,
660 |             (low  & 0x000000ff));
661 |     }
662 | }
663 | 


--------------------------------------------------------------------------------