diff --git a/.gitignore b/.gitignore index 305f896a..11a458e1 100644 --- a/.gitignore +++ b/.gitignore @@ -1,15 +1,5 @@ *.o *.so -ruby/Makefile *.5 *.8 *.6 -_obj -_test -/csharp/MsgPack.suo -/csharp/MsgPack/bin -/csharp/MsgPack/obj -/csharp/MsgPack/MsgPack.csproj.user -/csharp/MsgPack.Test/obj -/csharp/MsgPack.Test/bin -/csharp/MsgPack.Test/MsgPack.Test.csproj.user diff --git a/csharp/README.md b/csharp/README.md deleted file mode 100644 index a94d096e..00000000 --- a/csharp/README.md +++ /dev/null @@ -1 +0,0 @@ -MessagePack for C# was moved to https://github.com/msgpack/msgpack-cli. diff --git a/erlang/.gitignore b/erlang/.gitignore deleted file mode 100644 index 0f7faad4..00000000 --- a/erlang/.gitignore +++ /dev/null @@ -1,5 +0,0 @@ -MANIFEST -*.beam -.omakedb* -*.omc -*~ \ No newline at end of file diff --git a/erlang/README.md b/erlang/README.md deleted file mode 100644 index f78602e7..00000000 --- a/erlang/README.md +++ /dev/null @@ -1,5 +0,0 @@ -MessagePack for Erlang -====================== - -This project has moved to its own repository for good usage in rebar. -New repository is http://github.com/msgpack/msgpack-erlang . diff --git a/example/simple.rb b/example/simple.rb deleted file mode 100644 index 90b46968..00000000 --- a/example/simple.rb +++ /dev/null @@ -1,5 +0,0 @@ -require 'msgpack' - -serialized = [1, -1, true, false, nil, {"key" => "value"}].to_msgpack -p MessagePack.unpack(serialized) - diff --git a/example/stream.rb b/example/stream.rb deleted file mode 100644 index a72f5b98..00000000 --- a/example/stream.rb +++ /dev/null @@ -1,72 +0,0 @@ -require 'msgpack' - -class Server - def initialize(sock) - @sock = sock - @pk = MessagePack::Unpacker.new - @buffer = '' - @nread = 0 - end - - def run - while true - begin - data = @sock.sysread(1024) - rescue - puts "connection closed (#{$!})" - return - end - receive_data(data) - end - end - - private - def receive_data(data) - @buffer << data - - while true - @nread = @pk.execute(@buffer, @nread) - - if @pk.finished? - msg = @pk.data - process_message(msg) - - @pk.reset - @buffer.slice!(0, @nread) - @nread = 0 - - next unless @buffer.empty? - end - - break - end - - if @buffer.length > 10*1024*1024 - raise "message is too large" - end - - rescue - puts "error while processing client packet: #{$!}" - end - - def process_message(msg) - puts "message reached: #{msg.inspect}" - end -end - - -rpipe, wpipe = IO.pipe - -# run server thread -thread = Thread.new(Server.new(rpipe)) {|srv| - srv.run -} - -# client thread: -wpipe.write ["put", "apple", "red"].to_msgpack -wpipe.write ["put", "lemon", "yellow"].to_msgpack -wpipe.write ["get", "apple"].to_msgpack -wpipe.close - -thread.join - diff --git a/go/README b/go/README deleted file mode 100644 index 2999c41a..00000000 --- a/go/README +++ /dev/null @@ -1,3 +0,0 @@ -THIS directory is moved to separeted repository. - -Please go http://github.com/msgpack/msgpack-go/ diff --git a/go/msgpack_test.go b/go/msgpack_test.go deleted file mode 100644 index 635c4da2..00000000 --- a/go/msgpack_test.go +++ /dev/null @@ -1,353 +0,0 @@ -package msgpack - -import ( - "testing" - "bytes" - "reflect" - "math" -) - -func equal(lhs reflect.Value, rhs reflect.Value) bool { - { - _rhs := rhs - if _rhs.Kind() == reflect.Interface { - return equal(lhs, _rhs.Elem()) - } - } - switch _lhs := lhs; _lhs.Kind() { - case reflect.Interface: - return equal(_lhs.Elem(), rhs) - case reflect.Bool: - _rhs := rhs - return _rhs.Kind() == reflect.Bool && - _lhs.Bool() == _rhs.Bool() - case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: - _rhs := rhs - return (_rhs.Kind() == reflect.Uint || _rhs.Kind() == reflect.Uint8 || _rhs.Kind() == reflect.Uint16 || _rhs.Kind() == reflect.Uint32 || _rhs.Kind() == reflect.Uint64 || _rhs.Kind() == reflect.Uintptr) && - _lhs.Uint() == _rhs.Uint() - case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: - _rhs := rhs - return (_rhs.Kind() == reflect.Int || _rhs.Kind() == reflect.Int8 || _rhs.Kind() == reflect.Int16 || _rhs.Kind() == reflect.Int32 || _rhs.Kind() == reflect.Int64) && - _lhs.Int() == _rhs.Int() - case reflect.Float32, reflect.Float64: - _rhs := rhs - return (_rhs.Kind() == reflect.Float32 || _rhs.Kind() == reflect.Float64) && - _lhs.Float() == _rhs.Float() - case reflect.Array, reflect.Slice: - _rhs := rhs - if _lhs.Len() != _rhs.Len() { - return false - } - for i := 0; i < _lhs.Len(); i++ { - if !equal(_lhs.Index(i), _rhs.Index(i)) { - return false - } - } - return true - case reflect.Map: - _rhs := rhs - if _lhs.Len() != _rhs.Len() { - return false - } - for _, k := range _lhs.MapKeys() { - lv, rv := _lhs.MapIndex(k), _rhs.MapIndex(k) - if !lv.IsValid() || !rv.IsValid() || !equal(lv, rv) { - return false - } - } - return true - } - return false -} - -func TestPackUint8(t *testing.T) { - b := &bytes.Buffer{} - for _, i := range []uint8{0, 1, 2, 125, 126, 127, 128, 253, 254, 255} { - _, err := PackUint8(b, i) - if err != nil { - t.Error("err != nil") - } - } - if bytes.Compare(b.Bytes(), []byte{0x00, 0x01, 0x02, 0x7d, 0x7e, 0x7f, 0xcc, 0x80, 0xcc, 0xfd, 0xcc, 0xfe, 0xcc, 0xff}) != 0 { - t.Error("wrong output", b.Bytes()) - } -} - -func TestPackBytes(t *testing.T) { - for _, i := range []struct { - s string - b []byte - }{ - {"a", []byte("\xa1a")}, - {"hello", []byte("\xa5hello")}, - {"world world world", []byte("\xb1world world world")}, - {"world world world world world world", []byte("\xda\x00#world world world world world world")}, - } { - - b := &bytes.Buffer{} - - _, err := PackBytes(b, []byte(i.s)) - if err != nil { - t.Error("err != nil") - } - - v, _, e := Unpack(b) - if e != nil { - t.Error("err != nil") - } - - if !equal(v, reflect.ValueOf([]byte(i.s))) { - t.Error("unpack(pack(%s)) != %s", i.s) - } - } -} - -func TestPackUint16(t *testing.T) { - b := &bytes.Buffer{} - for _, i := range []uint16{0, 1, 2, 125, 126, 127, 128, 253, 254, 255, 256, 65533, 65534, 65535} { - _, err := PackUint16(b, i) - if err != nil { - t.Error("err != nil") - } - } - if bytes.Compare(b.Bytes(), []byte{0x00, 0x01, 0x02, 0x7d, 0x7e, 0x7f, 0xcc, 0x80, 0xcc, 0xfd, 0xcc, 0xfe, 0xcc, 0xff, 0xcd, 0x01, 0x00, 0xcd, 0xff, 0xfd, 0xcd, 0xff, 0xfe, 0xcd, 0xff, 0xff}) != 0 { - t.Error("wrong output", b.Bytes()) - } -} - -func TestPackUint32(t *testing.T) { - b := &bytes.Buffer{} - for _, i := range []uint32{0, 1, 2, 125, 126, 127, 128, 253, 254, 255, 256, 65533, 65534, 65535, 65536, 4294967293, 4294967294, 4294967295} { - _, err := PackUint32(b, i) - if err != nil { - t.Error("err != nil") - } - } - if bytes.Compare(b.Bytes(), []byte{0x00, 0x01, 0x02, 0x7d, 0x7e, 0x7f, 0xcc, 0x80, 0xcc, 0xfd, 0xcc, 0xfe, 0xcc, 0xff, 0xcd, 0x01, 0x00, 0xcd, 0xff, 0xfd, 0xcd, 0xff, 0xfe, 0xcd, 0xff, 0xff, 0xce, 0x00, 0x01, 0x00, 0x00, 0xce, 0xff, 0xff, 0xff, 0xfd, 0xce, 0xff, 0xff, 0xff, 0xfe, 0xce, 0xff, 0xff, 0xff, 0xff}) != 0 { - t.Error("wrong output", b.Bytes()) - } -} - -func TestPackUint64(t *testing.T) { - b := &bytes.Buffer{} - for _, i := range []uint64{0, 1, 2, 125, 126, 127, 128, 253, 254, 255, 256, 65533, 65534, 65535, 65536, 4294967293, 4294967294, 4294967295, 4294967296, 18446744073709551613, 18446744073709551614, 18446744073709551615} { - _, err := PackUint64(b, i) - if err != nil { - t.Error("err != nil") - } - } - if bytes.Compare(b.Bytes(), []byte{0x00, 0x01, 0x02, 0x7d, 0x7e, 0x7f, 0xcc, 0x80, 0xcc, 0xfd, 0xcc, 0xfe, 0xcc, 0xff, 0xcd, 0x01, 0x00, 0xcd, 0xff, 0xfd, 0xcd, 0xff, 0xfe, 0xcd, 0xff, 0xff, 0xce, 0x00, 0x01, 0x00, 0x00, 0xce, 0xff, 0xff, 0xff, 0xfd, 0xce, 0xff, 0xff, 0xff, 0xfe, 0xce, 0xff, 0xff, 0xff, 0xff, 0xcf, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}) != 0 { - t.Error("wrong output", b.Bytes()) - } -} - -func TestPackInt8(t *testing.T) { - b := &bytes.Buffer{} - for _, i := range []int8{-128, -127, -34, -33, -32, -31, 0, 1, 126, 127} { - _, err := PackInt8(b, i) - if err != nil { - t.Error("err != nil") - } - } - if bytes.Compare(b.Bytes(), []byte{0xd0, 0x80, 0xd0, 0x81, 0xd0, 0xde, 0xd0, 0xdf, 0xe0, 0xe1, 0x00, 0x01, 0x7e, 0x7f}) != 0 { - t.Error("wrong output", b.Bytes()) - } -} - -func TestPackInt16(t *testing.T) { - b := &bytes.Buffer{} - for _, i := range []int16{-32768, -32767, -131, -130, -129, -128, -127, -34, -33, -32, -31, 0, 1, 126, 127, 128, 129, 130, 32765, 32766, 32767} { - _, err := PackInt16(b, i) - if err != nil { - t.Error("err != nil") - } - } - if bytes.Compare(b.Bytes(), []byte{0xd1, 0x80, 0x00, 0xd1, 0x80, 0x01, 0xd1, 0xff, 0x7d, 0xd1, 0xff, 0x7e, 0xd1, 0xff, 0x7f, 0xd0, 0x80, 0xd0, 0x81, 0xd0, 0xde, 0xd0, 0xdf, 0xe0, 0xe1, 0x00, 0x01, 0x7e, 0x7f, 0xd1, 0x00, 0x80, 0xd1, 0x00, 0x81, 0xd1, 0x00, 0x82, 0xd1, 0x7f, 0xfd, 0xd1, 0x7f, 0xfe, 0xd1, 0x7f, 0xff}) != 0 { - t.Error("wrong output", b.Bytes()) - } -} - -func TestPackInt32(t *testing.T) { - b := &bytes.Buffer{} - for _, i := range []int32{-2147483648, -2147483647, -2147483646, -32771, -32770, -32769, -32768, -32767, -131, -130, -129, -128, -127, -34, -33, -32, -31, 0, 1, 126, 127, 128, 129, 130, 32765, 32766, 32767, 32768, 32769, 32770, 2147483645, 2147483646, 2147483647} { - _, err := PackInt32(b, i) - if err != nil { - t.Error("err != nil") - } - } - if bytes.Compare(b.Bytes(), []byte{0xd2, 0x80, 0x00, 0x00, 0x00, 0xd2, 0x80, 0x00, 0x00, 0x01, 0xd2, 0x80, 0x00, 0x00, 0x02, 0xd2, 0xff, 0xff, 0x7f, 0xfd, 0xd2, 0xff, 0xff, 0x7f, 0xfe, 0xd2, 0xff, 0xff, 0x7f, 0xff, 0xd1, 0x80, 0x00, 0xd1, 0x80, 0x01, 0xd1, 0xff, 0x7d, 0xd1, 0xff, 0x7e, 0xd1, 0xff, 0x7f, 0xd0, 0x80, 0xd0, 0x81, 0xd0, 0xde, 0xd0, 0xdf, 0xe0, 0xe1, 0x00, 0x01, 0x7e, 0x7f, 0xd1, 0x00, 0x80, 0xd1, 0x00, 0x81, 0xd1, 0x00, 0x82, 0xd1, 0x7f, 0xfd, 0xd1, 0x7f, 0xfe, 0xd1, 0x7f, 0xff, 0xd2, 0x00, 0x00, 0x80, 0x00, 0xd2, 0x00, 0x00, 0x80, 0x01, 0xd2, 0x00, 0x00, 0x80, 0x02, 0xd2, 0x7f, 0xff, 0xff, 0xfd, 0xd2, 0x7f, 0xff, 0xff, 0xfe, 0xd2, 0x7f, 0xff, 0xff, 0xff}) != 0 { - t.Error("wrong output", b.Bytes()) - } -} - -func TestPackInt64(t *testing.T) { - b := &bytes.Buffer{} - for _, i := range []int64{-9223372036854775808, -9223372036854775807, -9223372036854775806, -2147483651, -2147483650, -2147483649, -2147483648, -2147483647, -2147483646, -32771, -32770, -32769, -32768, -32767, -131, -130, -129, -128, -127, -34, -33, -32, -31, 0, 1, 126, 127, 128, 129, 130, 32765, 32766, 32767, 32768, 32769, 32770, 2147483645, 2147483646, 2147483647, 2147483648, 2147483649, 2147483650, 4294967296, 4294967297, 4294967298} { - _, err := PackInt64(b, i) - if err != nil { - t.Error("err != nil") - } - } - if bytes.Compare(b.Bytes(), []byte{0xd3, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xd3, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xd3, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xd3, 0xff, 0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xfd, 0xd3, 0xff, 0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xfe, 0xd3, 0xff, 0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff, 0xd2, 0x80, 0x00, 0x00, 0x00, 0xd2, 0x80, 0x00, 0x00, 0x01, 0xd2, 0x80, 0x00, 0x00, 0x02, 0xd2, 0xff, 0xff, 0x7f, 0xfd, 0xd2, 0xff, 0xff, 0x7f, 0xfe, 0xd2, 0xff, 0xff, 0x7f, 0xff, 0xd1, 0x80, 0x00, 0xd1, 0x80, 0x01, 0xd1, 0xff, 0x7d, 0xd1, 0xff, 0x7e, 0xd1, 0xff, 0x7f, 0xd0, 0x80, 0xd0, 0x81, 0xd0, 0xde, 0xd0, 0xdf, 0xe0, 0xe1, 0x00, 0x01, 0x7e, 0x7f, 0xd1, 0x00, 0x80, 0xd1, 0x00, 0x81, 0xd1, 0x00, 0x82, 0xd1, 0x7f, 0xfd, 0xd1, 0x7f, 0xfe, 0xd1, 0x7f, 0xff, 0xd2, 0x00, 0x00, 0x80, 0x00, 0xd2, 0x00, 0x00, 0x80, 0x01, 0xd2, 0x00, 0x00, 0x80, 0x02, 0xd2, 0x7f, 0xff, 0xff, 0xfd, 0xd2, 0x7f, 0xff, 0xff, 0xfe, 0xd2, 0x7f, 0xff, 0xff, 0xff, 0xd3, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0xd3, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x01, 0xd3, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x02, 0xd3, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0xd3, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0xd3, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02}) != 0 { - t.Error("wrong output", b.Bytes()) - } -} - -func TestPackNil(t *testing.T) { - b := &bytes.Buffer{} - nbyteswrite, err := PackNil(b) - if nbyteswrite != 1 { - t.Error("nbyteswrite != 1") - } - if err != nil { - t.Error("err != nil") - } - if bytes.Compare(b.Bytes(), []byte{0xc0}) != 0 { - t.Error("wrong output", b.Bytes()) - } -} - -func TestPackBool(t *testing.T) { - b := &bytes.Buffer{} - for _, i := range []bool{false, true} { - nbyteswrite, err := PackBool(b, i) - if nbyteswrite != 1 { - t.Error("nbyteswrite != 1") - } - if err != nil { - t.Error("err != nil") - } - } - if bytes.Compare(b.Bytes(), []byte{0xc2, 0xc3}) != 0 { - t.Error("wrong output", b.Bytes()) - } -} - -func TestPackInt32Array(t *testing.T) { - b := &bytes.Buffer{} - _, err := PackInt32Array(b, []int32{}) - if err != nil { - t.Error("err != nil") - } - _, err = PackInt32Array(b, []int32{0}) - if err != nil { - t.Error("err != nil") - } - _, err = PackInt32Array(b, []int32{0, 1}) - if err != nil { - t.Error("err != nil") - } - _, err = PackInt32Array(b, []int32{0, 1, 2}) - if err != nil { - t.Error("err != nil") - } - if bytes.Compare(b.Bytes(), []byte{0x90, 0x91, 0x00, 0x92, 0x00, 0x01, 0x93, 0x00, 0x01, 0x02}) != 0 { - t.Error("wrong output", b.Bytes()) - } -} - -func TestPackArray(t *testing.T) { - b := &bytes.Buffer{} - _, err := PackArray(b, reflect.ValueOf([]int32{})) - if err != nil { - t.Error("err != nil") - } - _, err = PackArray(b, reflect.ValueOf([]int32{0})) - if err != nil { - t.Error("err != nil") - } - _, err = PackArray(b, reflect.ValueOf([]int32{0, 1})) - if err != nil { - t.Error("err != nil") - } - _, err = PackArray(b, reflect.ValueOf([]int32{0, 1, 2})) - if err != nil { - t.Error("err != nil") - } - if bytes.Compare(b.Bytes(), []byte{0x90, 0x91, 0x00, 0x92, 0x00, 0x01, 0x93, 0x00, 0x01, 0x02}) != 0 { - t.Error("wrong output", b.Bytes()) - } -} - -func TestPackMap(t *testing.T) { - b := &bytes.Buffer{} - _, err := PackMap(b, reflect.ValueOf(map[int]int{0: 1, 2: 3, 4: 5})) - if err != nil { - t.Error("err != nil") - } - - // map ordering is no longer deterministic -- check all possible orderings :( - if bytes.Compare(b.Bytes(), []byte{0x83, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05}) != 0 && - bytes.Compare(b.Bytes(), []byte{0x83, 0x00, 0x01, 0x04, 0x05, 0x02, 0x03}) != 0 && - bytes.Compare(b.Bytes(), []byte{0x83, 0x02, 0x03, 0x00, 0x01, 0x04, 0x05}) != 0 && - bytes.Compare(b.Bytes(), []byte{0x83, 0x02, 0x03, 0x04, 0x05, 0x00, 0x01}) != 0 && - bytes.Compare(b.Bytes(), []byte{0x83, 0x04, 0x05, 0x00, 0x01, 0x02, 0x03}) != 0 && - bytes.Compare(b.Bytes(), []byte{0x83, 0x04, 0x05, 0x02, 0x03, 0x00, 0x01}) != 0 { - t.Error("wrong output", b.Bytes()) - } -} - -func TestPack(t *testing.T) { - b := &bytes.Buffer{} - for _, i := range [](interface{}){nil, false, true, 0, 1, 2, 3, 127, -32, -1, -33, 128, "astring"} { - _, err := Pack(b, i) - if err != nil { - t.Error("err != nil") - } - } - if bytes.Compare(b.Bytes(), []byte{0xc0, 0xc2, 0xc3, 0x00, 0x01, 0x02, 0x03, 0x7f, 0xe0, 0xff, 0xd0, 0xdf, 0xd1, 0x00, 0x80, 0xA7, 'a', 's', 't', 'r', 'i', 'n', 'g'}) != 0 { - t.Error("wrong output") - } -} - -func TestUnpackArray(t *testing.T) { - b := bytes.NewBuffer([]byte{0x90, 0x91, 0x00, 0x92, 0x00, 0x01, 0x93, 0xd1, 0x00, 0x00, 0xd2, 0x00, 0x00, 0x00, 0x01, 0xd3, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xdc, 0x00, 0x02, 0x00, 0x01, 0xdd, 0x00, 0x00, 0x00, 0x04, 0x00, 0x01, 0x02, 0x03}) - for _, v := range [](interface{}){[](interface{}){}, [](interface{}){int8(0)}, [](interface{}){int8(0), int8(1)}, [](interface{}){int16(0), int32(1), int64(2)}, [](interface{}){int8(0), int8(1)}, [](interface{}){int8(0), int8(1), int8(2), int8(3)}} { - retval, _, e := Unpack(b) - if e != nil { - t.Error("err != nil") - } - if !equal(reflect.ValueOf(retval.Interface()), reflect.ValueOf(v)) { - t.Errorf("%s != %s", retval.Interface(), v) - } - } -} - -func TestUnpackInt(t *testing.T) { - b := bytes.NewBuffer([]byte{0xff, 0xe0, 0x00, 0x01, 0x02, 0x7d, 0x7e, 0x7f, 0xd0, 0x01, 0xd0, 0x80, 0xd0, 0xff, 0xcc, 0x80, 0xcc, 0xfd, 0xcc, 0xfe, 0xcc, 0xff, 0xd1, 0x00, 0x00, 0xd1, 0x7f, 0xff, 0xd1, 0xff, 0xff, 0xcd, 0x80, 0x00, 0xcd, 0xff, 0xff, 0xd2, 0x7f, 0xff, 0xff, 0xff, 0xce, 0x7f, 0xff, 0xff, 0xff, 0xd3, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}) - for _, v := range [](interface{}){ - int8(-1), int8(-32), int8(0), int8(1), int8(2), int8(125), int8(126), int8(127), int8(1), int8(-128), int8(-1), uint8(128), uint8(253), uint8(254), uint8(255), int16(0), int16(32767), int16(-1), uint16(32768), uint16(65535), int32(2147483647), uint32(2147483647), int64(9223372036854775807), uint64(18446744073709551615)} { - retval, _, e := Unpack(b) - if e != nil { - t.Error("err != nil") - } - if retval.Interface() != v { - t.Errorf("%u != %u", retval.Interface(), v) - } - } -} - -func TestUnpackFloat(t *testing.T) { - b := bytes.NewBuffer([]byte{0xca, 0x3d, 0xcc, 0xcc, 0xcd, 0xca, 0x3e, 0x4c, 0xcc, 0xcd, 0xca, 0xbd, 0xcc, 0xcc, 0xcd, 0xca, 0xbe, 0x4c, 0xcc, 0xcd, 0xca, 0x7f, 0x80, 0x00, 0x00, 0xca, 0xff, 0x80, 0x00, 0x00, 0xca, 0xff, 0xc0, 0x00, 0x0, 0xcb, 0x3f, 0xb9, 0x99, 0x99, 0x99, 0x99, 0x99, 0x9a, 0xcb, 0x3f, 0xc9, 0x99, 0x99, 0x99, 0x99, 0x99, 0x9a, 0xcb, 0xbf, 0xb9, 0x99, 0x99, 0x99, 0x99, 0x99, 0x9a, 0xcb, 0xbf, 0xc9, 0x99, 0x99, 0x99, 0x99, 0x99, 0x9a, 0xcb, 0x7f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xcb, 0xcb, 0xff, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xcb, 0x7f, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}) - for _, v := range [](interface{}){float32(.1), float32(.2), float32(-.1), float32(-.2), float32(math.Inf(1)), float32(math.Inf(-1)), float32(math.NaN()), float64(.1), float64(.2), float64(-.1), float64(-.2)} { - retval, _, e := Unpack(b) - if e != nil { - t.Error("err != nil") - } - isnan := false - if _v, ok := v.(float64); ok { - isnan = math.IsNaN(_v) - } else if _v, ok := v.(float32); ok { - isnan = math.IsNaN(float64(_v)) - } - if isnan { - if retval.Interface() == v { - t.Errorf("[NaN] %u == %u", retval.Interface(), v) - } - } else { - if retval.Interface() != v { - t.Errorf("%u != %u", retval.Interface(), v) - } - } - } -} diff --git a/go/pack.go b/go/pack.go deleted file mode 100644 index 21e2e20c..00000000 --- a/go/pack.go +++ /dev/null @@ -1,776 +0,0 @@ -package msgpack - -import ( - "io" - "os" - "reflect" - "unsafe" -) - -// Packs a given value and writes it into the specified writer. -func PackUint8(writer io.Writer, value uint8) (n int, err error) { - if value < 128 { - return writer.Write([]byte{byte(value)}) - } - return writer.Write([]byte{0xcc, byte(value)}) -} - -// Packs a given value and writes it into the specified writer. -func PackUint16(writer io.Writer, value uint16) (n int, err error) { - if value < 128 { - return writer.Write([]byte{byte(value)}) - } else if value < 256 { - return writer.Write([]byte{0xcc, byte(value)}) - } - return writer.Write([]byte{0xcd, byte(value >> 8), byte(value)}) -} - -// Packs a given value and writes it into the specified writer. -func PackUint32(writer io.Writer, value uint32) (n int, err error) { - if value < 128 { - return writer.Write([]byte{byte(value)}) - } else if value < 256 { - return writer.Write([]byte{0xcc, byte(value)}) - } else if value < 65536 { - return writer.Write([]byte{0xcd, byte(value >> 8), byte(value)}) - } - return writer.Write([]byte{0xce, byte(value >> 24), byte(value >> 16), byte(value >> 8), byte(value)}) -} - -// Packs a given value and writes it into the specified writer. -func PackUint64(writer io.Writer, value uint64) (n int, err error) { - if value < 128 { - return writer.Write([]byte{byte(value)}) - } else if value < 256 { - return writer.Write([]byte{0xcc, byte(value)}) - } else if value < 65536 { - return writer.Write([]byte{0xcd, byte(value >> 8), byte(value)}) - } else if value < 4294967296 { - return writer.Write([]byte{0xce, byte(value >> 24), byte(value >> 16), byte(value >> 8), byte(value)}) - } - return writer.Write([]byte{0xcf, byte(value >> 56), byte(value >> 48), byte(value >> 40), byte(value >> 32), byte(value >> 24), byte(value >> 16), byte(value >> 8), byte(value)}) -} - -func PackUint(writer io.Writer, value uint) (n int, err error) { - // Packs a given value and writes it into the specified writer. - switch unsafe.Sizeof(value) { - case 4: - return PackUint32(writer, *(*uint32)(unsafe.Pointer(&value))) - case 8: - return PackUint64(writer, *(*uint64)(unsafe.Pointer(&value))) - } - return 0, os.ErrNotExist // never get here -} - -// Packs a given value and writes it into the specified writer. -func PackInt8(writer io.Writer, value int8) (n int, err error) { - if value < -32 { - return writer.Write([]byte{0xd0, byte(value)}) - } - return writer.Write([]byte{byte(value)}) -} - -// Packs a given value and writes it into the specified writer. -func PackInt16(writer io.Writer, value int16) (n int, err error) { - if value < -128 || value >= 128 { - return writer.Write([]byte{0xd1, byte(uint16(value) >> 8), byte(value)}) - } else if value < -32 { - return writer.Write([]byte{0xd0, byte(value)}) - } - return writer.Write([]byte{byte(value)}) -} - -// Packs a given value and writes it into the specified writer. -func PackInt32(writer io.Writer, value int32) (n int, err error) { - if value < -32768 || value >= 32768 { - return writer.Write([]byte{0xd2, byte(uint32(value) >> 24), byte(uint32(value) >> 16), byte(uint32(value) >> 8), byte(value)}) - } else if value < -128 { - return writer.Write([]byte{0xd1, byte(uint32(value) >> 8), byte(value)}) - } else if value < -32 { - return writer.Write([]byte{0xd0, byte(value)}) - } else if value >= 128 { - return writer.Write([]byte{0xd1, byte(uint32(value) >> 8), byte(value)}) - } - return writer.Write([]byte{byte(value)}) -} - -// Packs a given value and writes it into the specified writer. -func PackInt64(writer io.Writer, value int64) (n int, err error) { - if value < -2147483648 || value >= 2147483648 { - return writer.Write([]byte{0xd3, byte(uint64(value) >> 56), byte(uint64(value) >> 48), byte(uint64(value) >> 40), byte(uint64(value) >> 32), byte(uint64(value) >> 24), byte(uint64(value) >> 16), byte(uint64(value) >> 8), byte(value)}) - } else if value < -32768 || value >= 32768 { - return writer.Write([]byte{0xd2, byte(uint64(value) >> 24), byte(uint64(value) >> 16), byte(uint64(value) >> 8), byte(value)}) - } else if value < -128 || value >= 128 { - return writer.Write([]byte{0xd1, byte(uint64(value) >> 8), byte(value)}) - } else if value < -32 { - return writer.Write([]byte{0xd0, byte(value)}) - } - return writer.Write([]byte{byte(value)}) -} - -// Packs a given value and writes it into the specified writer. -func PackInt(writer io.Writer, value int) (n int, err error) { - switch unsafe.Sizeof(value) { - case 4: - return PackInt32(writer, *(*int32)(unsafe.Pointer(&value))) - case 8: - return PackInt64(writer, *(*int64)(unsafe.Pointer(&value))) - } - return 0, os.ErrNotExist // never get here -} - -// Packs a given value and writes it into the specified writer. -func PackNil(writer io.Writer) (n int, err error) { - return writer.Write([]byte{0xc0}) -} - -// Packs a given value and writes it into the specified writer. -func PackBool(writer io.Writer, value bool) (n int, err error) { - var code byte - if value { - code = 0xc3 - } else { - code = 0xc2 - } - return writer.Write([]byte{code}) -} - -// Packs a given value and writes it into the specified writer. -func PackFloat32(writer io.Writer, value float32) (n int, err error) { - return PackUint32(writer, *(*uint32)(unsafe.Pointer(&value))) -} - -// Packs a given value and writes it into the specified writer. -func PackFloat64(writer io.Writer, value float64) (n int, err error) { - return PackUint64(writer, *(*uint64)(unsafe.Pointer(&value))) -} - -// Packs a given value and writes it into the specified writer. -func PackBytes(writer io.Writer, value []byte) (n int, err error) { - if len(value) < 32 { - n1, err := writer.Write([]byte{0xa0 | uint8(len(value))}) - if err != nil { - return n1, err - } - n2, err := writer.Write(value) - return n1 + n2, err - } else if len(value) < 65536 { - n1, err := writer.Write([]byte{0xda, byte(len(value) >> 16), byte(len(value))}) - if err != nil { - return n1, err - } - n2, err := writer.Write(value) - return n1 + n2, err - } - n1, err := writer.Write([]byte{0xdb, byte(len(value) >> 24), byte(len(value) >> 16), byte(len(value) >> 8), byte(len(value))}) - if err != nil { - return n1, err - } - n2, err := writer.Write(value) - return n1 + n2, err -} - -// Packs a given value and writes it into the specified writer. -func PackUint16Array(writer io.Writer, value []uint16) (n int, err error) { - if len(value) < 16 { - n, err := writer.Write([]byte{0x90 | byte(len(value))}) - if err != nil { - return n, err - } - for _, i := range value { - _n, err := PackUint16(writer, i) - if err != nil { - return n, err - } - n += _n - } - } else if len(value) < 65536 { - n, err := writer.Write([]byte{0xdc, byte(len(value) >> 8), byte(len(value))}) - if err != nil { - return n, err - } - for _, i := range value { - _n, err := PackUint16(writer, i) - if err != nil { - return n, err - } - n += _n - } - } else { - n, err := writer.Write([]byte{0xdd, byte(len(value) >> 24), byte(len(value) >> 16), byte(len(value) >> 8), byte(len(value))}) - if err != nil { - return n, err - } - for _, i := range value { - _n, err := PackUint16(writer, i) - if err != nil { - return n, err - } - n += _n - } - } - return n, nil -} - -// Packs a given value and writes it into the specified writer. -func PackUint32Array(writer io.Writer, value []uint32) (n int, err error) { - if len(value) < 16 { - n, err := writer.Write([]byte{0x90 | byte(len(value))}) - if err != nil { - return n, err - } - for _, i := range value { - _n, err := PackUint32(writer, i) - if err != nil { - return n, err - } - n += _n - } - } else if len(value) < 65536 { - n, err := writer.Write([]byte{0xdc, byte(len(value) >> 8), byte(len(value))}) - if err != nil { - return n, err - } - for _, i := range value { - _n, err := PackUint32(writer, i) - if err != nil { - return n, err - } - n += _n - } - } else { - n, err := writer.Write([]byte{0xdd, byte(len(value) >> 24), byte(len(value) >> 16), byte(len(value) >> 8), byte(len(value))}) - if err != nil { - return n, err - } - for _, i := range value { - _n, err := PackUint32(writer, i) - if err != nil { - return n, err - } - n += _n - } - } - return n, nil -} - -// Packs a given value and writes it into the specified writer. -func PackUint64Array(writer io.Writer, value []uint64) (n int, err error) { - if len(value) < 16 { - n, err := writer.Write([]byte{0x90 | byte(len(value))}) - if err != nil { - return n, err - } - for _, i := range value { - _n, err := PackUint64(writer, i) - if err != nil { - return n, err - } - n += _n - } - } else if len(value) < 65536 { - n, err := writer.Write([]byte{0xdc, byte(len(value) >> 8), byte(len(value))}) - if err != nil { - return n, err - } - for _, i := range value { - _n, err := PackUint64(writer, i) - if err != nil { - return n, err - } - n += _n - } - } else { - n, err := writer.Write([]byte{0xdd, byte(len(value) >> 24), byte(len(value) >> 16), byte(len(value) >> 8), byte(len(value))}) - if err != nil { - return n, err - } - for _, i := range value { - _n, err := PackUint64(writer, i) - if err != nil { - return n, err - } - n += _n - } - } - return n, nil -} - -// Packs a given value and writes it into the specified writer. -func PackUintArray(writer io.Writer, value []uint) (n int, err error) { - switch unsafe.Sizeof(0) { - case 4: - return PackUint32Array(writer, *(*[]uint32)(unsafe.Pointer(&value))) - case 8: - return PackUint64Array(writer, *(*[]uint64)(unsafe.Pointer(&value))) - } - return 0, os.ErrNotExist // never get here -} - -// Packs a given value and writes it into the specified writer. -func PackInt8Array(writer io.Writer, value []int8) (n int, err error) { - if len(value) < 16 { - n, err := writer.Write([]byte{0x90 | byte(len(value))}) - if err != nil { - return n, err - } - for _, i := range value { - _n, err := PackInt8(writer, i) - if err != nil { - return n, err - } - n += _n - } - } else if len(value) < 65536 { - n, err := writer.Write([]byte{0xdc, byte(len(value) >> 8), byte(len(value))}) - if err != nil { - return n, err - } - for _, i := range value { - _n, err := PackInt8(writer, i) - if err != nil { - return n, err - } - n += _n - } - } else { - n, err := writer.Write([]byte{0xdd, byte(len(value) >> 24), byte(len(value) >> 16), byte(len(value) >> 8), byte(len(value))}) - if err != nil { - return n, err - } - for _, i := range value { - _n, err := PackInt8(writer, i) - if err != nil { - return n, err - } - n += _n - } - } - return n, nil -} - -// Packs a given value and writes it into the specified writer. -func PackInt16Array(writer io.Writer, value []int16) (n int, err error) { - if len(value) < 16 { - n, err := writer.Write([]byte{0x90 | byte(len(value))}) - if err != nil { - return n, err - } - for _, i := range value { - _n, err := PackInt16(writer, i) - if err != nil { - return n, err - } - n += _n - } - } else if len(value) < 65536 { - n, err := writer.Write([]byte{0xdc, byte(len(value) >> 8), byte(len(value))}) - if err != nil { - return n, err - } - for _, i := range value { - _n, err := PackInt16(writer, i) - if err != nil { - return n, err - } - n += _n - } - } else { - n, err := writer.Write([]byte{0xdd, byte(len(value) >> 24), byte(len(value) >> 16), byte(len(value) >> 8), byte(len(value))}) - if err != nil { - return n, err - } - for _, i := range value { - _n, err := PackInt16(writer, i) - if err != nil { - return n, err - } - n += _n - } - } - return n, nil -} - -// Packs a given value and writes it into the specified writer. -func PackInt32Array(writer io.Writer, value []int32) (n int, err error) { - if len(value) < 16 { - n, err := writer.Write([]byte{0x90 | byte(len(value))}) - if err != nil { - return n, err - } - for _, i := range value { - _n, err := PackInt32(writer, i) - if err != nil { - return n, err - } - n += _n - } - } else if len(value) < 65536 { - n, err := writer.Write([]byte{0xdc, byte(len(value) >> 8), byte(len(value))}) - if err != nil { - return n, err - } - for _, i := range value { - _n, err := PackInt32(writer, i) - if err != nil { - return n, err - } - n += _n - } - } else { - n, err := writer.Write([]byte{0xdd, byte(len(value) >> 24), byte(len(value) >> 16), byte(len(value) >> 8), byte(len(value))}) - if err != nil { - return n, err - } - for _, i := range value { - _n, err := PackInt32(writer, i) - if err != nil { - return n, err - } - n += _n - } - } - return n, nil -} - -// Packs a given value and writes it into the specified writer. -func PackInt64Array(writer io.Writer, value []int64) (n int, err error) { - if len(value) < 16 { - n, err := writer.Write([]byte{0x90 | byte(len(value))}) - if err != nil { - return n, err - } - for _, i := range value { - _n, err := PackInt64(writer, i) - if err != nil { - return n, err - } - n += _n - } - } else if len(value) < 65536 { - n, err := writer.Write([]byte{0xdc, byte(len(value) >> 8), byte(len(value))}) - if err != nil { - return n, err - } - for _, i := range value { - _n, err := PackInt64(writer, i) - if err != nil { - return n, err - } - n += _n - } - } else { - n, err := writer.Write([]byte{0xdd, byte(len(value) >> 24), byte(len(value) >> 16), byte(len(value) >> 8), byte(len(value))}) - if err != nil { - return n, err - } - for _, i := range value { - _n, err := PackInt64(writer, i) - if err != nil { - return n, err - } - n += _n - } - } - return n, nil -} - -// Packs a given value and writes it into the specified writer. -func PackIntArray(writer io.Writer, value []int) (n int, err error) { - switch unsafe.Sizeof(0) { - case 4: - return PackInt32Array(writer, *(*[]int32)(unsafe.Pointer(&value))) - case 8: - return PackInt64Array(writer, *(*[]int64)(unsafe.Pointer(&value))) - } - return 0, os.ErrNotExist // never get here -} - -// Packs a given value and writes it into the specified writer. -func PackFloat32Array(writer io.Writer, value []float32) (n int, err error) { - if len(value) < 16 { - n, err := writer.Write([]byte{0x90 | byte(len(value))}) - if err != nil { - return n, err - } - for _, i := range value { - _n, err := PackFloat32(writer, i) - if err != nil { - return n, err - } - n += _n - } - } else if len(value) < 65536 { - n, err := writer.Write([]byte{0xdc, byte(len(value) >> 8), byte(len(value))}) - if err != nil { - return n, err - } - for _, i := range value { - _n, err := PackFloat32(writer, i) - if err != nil { - return n, err - } - n += _n - } - } else { - n, err := writer.Write([]byte{0xdd, byte(len(value) >> 24), byte(len(value) >> 16), byte(len(value) >> 8), byte(len(value))}) - if err != nil { - return n, err - } - for _, i := range value { - _n, err := PackFloat32(writer, i) - if err != nil { - return n, err - } - n += _n - } - } - return n, nil -} - -// Packs a given value and writes it into the specified writer. -func PackFloat64Array(writer io.Writer, value []float64) (n int, err error) { - if len(value) < 16 { - n, err := writer.Write([]byte{0x90 | byte(len(value))}) - if err != nil { - return n, err - } - for _, i := range value { - _n, err := PackFloat64(writer, i) - if err != nil { - return n, err - } - n += _n - } - } else if len(value) < 65536 { - n, err := writer.Write([]byte{0xdc, byte(len(value) >> 8), byte(len(value))}) - if err != nil { - return n, err - } - for _, i := range value { - _n, err := PackFloat64(writer, i) - if err != nil { - return n, err - } - n += _n - } - } else { - n, err := writer.Write([]byte{0xdd, byte(len(value) >> 24), byte(len(value) >> 16), byte(len(value) >> 8), byte(len(value))}) - if err != nil { - return n, err - } - for _, i := range value { - _n, err := PackFloat64(writer, i) - if err != nil { - return n, err - } - n += _n - } - } - return n, nil -} - -// Packs a given value and writes it into the specified writer. -func PackArray(writer io.Writer, value reflect.Value) (n int, err error) { - { - elemType := value.Type().Elem() - if (elemType.Kind() == reflect.Uint || elemType.Kind() == reflect.Uint8 || elemType.Kind() == reflect.Uint16 || elemType.Kind() == reflect.Uint32 || elemType.Kind() == reflect.Uint64 || elemType.Kind() == reflect.Uintptr) && - elemType.Kind() == reflect.Uint8 { - return PackBytes(writer, value.Interface().([]byte)) - } - } - - l := value.Len() - if l < 16 { - n, err := writer.Write([]byte{0x90 | byte(l)}) - if err != nil { - return n, err - } - for i := 0; i < l; i++ { - _n, err := PackValue(writer, value.Index(i)) - if err != nil { - return n, err - } - n += _n - } - } else if l < 65536 { - n, err := writer.Write([]byte{0xdc, byte(l >> 8), byte(l)}) - if err != nil { - return n, err - } - for i := 0; i < l; i++ { - _n, err := PackValue(writer, value.Index(i)) - if err != nil { - return n, err - } - n += _n - } - } else { - n, err := writer.Write([]byte{0xdd, byte(l >> 24), byte(l >> 16), byte(l >> 8), byte(l)}) - if err != nil { - return n, err - } - for i := 0; i < l; i++ { - _n, err := PackValue(writer, value.Index(i)) - if err != nil { - return n, err - } - n += _n - } - } - return n, nil -} - -// Packs a given value and writes it into the specified writer. -func PackMap(writer io.Writer, value reflect.Value) (n int, err error) { - keys := value.MapKeys() - if value.Len() < 16 { - n, err := writer.Write([]byte{0x80 | byte(len(keys))}) - if err != nil { - return n, err - } - for _, k := range keys { - _n, err := PackValue(writer, k) - if err != nil { - return n, err - } - n += _n - _n, err = PackValue(writer, value.MapIndex(k)) - if err != nil { - return n, err - } - n += _n - } - } else if value.Len() < 65536 { - n, err := writer.Write([]byte{0xde, byte(len(keys) >> 8), byte(len(keys))}) - if err != nil { - return n, err - } - for _, k := range keys { - _n, err := PackValue(writer, k) - if err != nil { - return n, err - } - n += _n - _n, err = PackValue(writer, value.MapIndex(k)) - if err != nil { - return n, err - } - n += _n - } - } else { - n, err := writer.Write([]byte{0xdf, byte(len(keys) >> 24), byte(len(keys) >> 16), byte(len(keys) >> 8), byte(len(keys))}) - if err != nil { - return n, err - } - for _, k := range keys { - _n, err := PackValue(writer, k) - if err != nil { - return n, err - } - n += _n - _n, err = PackValue(writer, value.MapIndex(k)) - if err != nil { - return n, err - } - n += _n - } - } - return n, nil -} - -// Packs a given value and writes it into the specified writer. -func PackValue(writer io.Writer, value reflect.Value) (n int, err error) { - if !value.IsValid() || value.Type() == nil { - return PackNil(writer) - } - switch _value := value; _value.Kind() { - case reflect.Bool: - return PackBool(writer, _value.Bool()) - case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: - return PackUint64(writer, _value.Uint()) - case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: - return PackInt64(writer, _value.Int()) - case reflect.Float32, reflect.Float64: - return PackFloat64(writer, _value.Float()) - case reflect.Array: - return PackArray(writer, _value) - case reflect.Slice: - return PackArray(writer, _value) - case reflect.Map: - return PackMap(writer, _value) - case reflect.String: - return PackBytes(writer, []byte(_value.String())) - case reflect.Interface: - __value := reflect.ValueOf(_value.Interface()) - - if __value.Kind() != reflect.Interface { - return PackValue(writer, __value) - } - } - panic("unsupported type: " + value.Type().String()) -} - -// Packs a given value and writes it into the specified writer. -func Pack(writer io.Writer, value interface{}) (n int, err error) { - if value == nil { - return PackNil(writer) - } - switch _value := value.(type) { - case bool: - return PackBool(writer, _value) - case uint8: - return PackUint8(writer, _value) - case uint16: - return PackUint16(writer, _value) - case uint32: - return PackUint32(writer, _value) - case uint64: - return PackUint64(writer, _value) - case uint: - return PackUint(writer, _value) - case int8: - return PackInt8(writer, _value) - case int16: - return PackInt16(writer, _value) - case int32: - return PackInt32(writer, _value) - case int64: - return PackInt64(writer, _value) - case int: - return PackInt(writer, _value) - case float32: - return PackFloat32(writer, _value) - case float64: - return PackFloat64(writer, _value) - case []byte: - return PackBytes(writer, _value) - case []uint16: - return PackUint16Array(writer, _value) - case []uint32: - return PackUint32Array(writer, _value) - case []uint64: - return PackUint64Array(writer, _value) - case []uint: - return PackUintArray(writer, _value) - case []int8: - return PackInt8Array(writer, _value) - case []int16: - return PackInt16Array(writer, _value) - case []int32: - return PackInt32Array(writer, _value) - case []int64: - return PackInt64Array(writer, _value) - case []int: - return PackIntArray(writer, _value) - case []float32: - return PackFloat32Array(writer, _value) - case []float64: - return PackFloat64Array(writer, _value) - case string: - return PackBytes(writer, []byte(_value)) - default: - return PackValue(writer, reflect.ValueOf(value)) - } - return 0, nil // never get here -} diff --git a/go/unpack.go b/go/unpack.go deleted file mode 100644 index 0f34695f..00000000 --- a/go/unpack.go +++ /dev/null @@ -1,365 +0,0 @@ -package msgpack - -import ( - "io" - "reflect" - "strconv" - "unsafe" -) - -func readByte(reader io.Reader) (v uint8, err error) { - data := [1]byte{} - _, e := reader.Read(data[0:]) - if e != nil { - return 0, e - } - return data[0], nil -} - -func readUint16(reader io.Reader) (v uint16, n int, err error) { - data := [2]byte{} - n, e := reader.Read(data[0:]) - if e != nil { - return 0, n, e - } - return (uint16(data[0]) << 8) | uint16(data[1]), n, nil -} - -func readUint32(reader io.Reader) (v uint32, n int, err error) { - data := [4]byte{} - n, e := reader.Read(data[0:]) - if e != nil { - return 0, n, e - } - return (uint32(data[0]) << 24) | (uint32(data[1]) << 16) | (uint32(data[2]) << 8) | uint32(data[3]), n, nil -} - -func readUint64(reader io.Reader) (v uint64, n int, err error) { - data := [8]byte{} - n, e := reader.Read(data[0:]) - if e != nil { - return 0, n, e - } - return (uint64(data[0]) << 56) | (uint64(data[1]) << 48) | (uint64(data[2]) << 40) | (uint64(data[3]) << 32) | (uint64(data[4]) << 24) | (uint64(data[5]) << 16) | (uint64(data[6]) << 8) | uint64(data[7]), n, nil -} - -func readInt16(reader io.Reader) (v int16, n int, err error) { - data := [2]byte{} - n, e := reader.Read(data[0:]) - if e != nil { - return 0, n, e - } - return (int16(data[0]) << 8) | int16(data[1]), n, nil -} - -func readInt32(reader io.Reader) (v int32, n int, err error) { - data := [4]byte{} - n, e := reader.Read(data[0:]) - if e != nil { - return 0, n, e - } - return (int32(data[0]) << 24) | (int32(data[1]) << 16) | (int32(data[2]) << 8) | int32(data[3]), n, nil -} - -func readInt64(reader io.Reader) (v int64, n int, err error) { - data := [8]byte{} - n, e := reader.Read(data[0:]) - if e != nil { - return 0, n, e - } - return (int64(data[0]) << 56) | (int64(data[1]) << 48) | (int64(data[2]) << 40) | (int64(data[3]) << 32) | (int64(data[4]) << 24) | (int64(data[5]) << 16) | (int64(data[6]) << 8) | int64(data[7]), n, nil -} - -func unpackArray(reader io.Reader, nelems uint) (v reflect.Value, n int, err error) { - retval := make([]interface{}, nelems) - nbytesread := 0 - var i uint - for i = 0; i < nelems; i++ { - v, n, e := Unpack(reader) - nbytesread += n - if e != nil { - return reflect.Value{}, nbytesread, e - } - retval[i] = v.Interface() - } - return reflect.ValueOf(retval), nbytesread, nil -} - -func unpackArrayReflected(reader io.Reader, nelems uint) (v reflect.Value, n int, err error) { - retval := make([]reflect.Value, nelems) - nbytesread := 0 - var i uint - for i = 0; i < nelems; i++ { - v, n, e := UnpackReflected(reader) - nbytesread += n - if e != nil { - return reflect.Value{}, nbytesread, e - } - retval[i] = v - } - return reflect.ValueOf(retval), nbytesread, nil -} - -func unpackMap(reader io.Reader, nelems uint) (v reflect.Value, n int, err error) { - retval := make(map[interface{}]interface{}) - nbytesread := 0 - var i uint - for i = 0; i < nelems; i++ { - k, n, e := Unpack(reader) - nbytesread += n - if e != nil { - return reflect.Value{}, nbytesread, e - } - v, n, e := Unpack(reader) - nbytesread += n - if e != nil { - return reflect.Value{}, nbytesread, e - } - retval[k.Interface()] = v.Interface() - } - return reflect.ValueOf(retval), nbytesread, nil -} - -func unpackMapReflected(reader io.Reader, nelems uint) (v reflect.Value, n int, err error) { - retval := make(map[interface{}]reflect.Value) - nbytesread := 0 - var i uint - for i = 0; i < nelems; i++ { - k, n, e := UnpackReflected(reader) - nbytesread += n - if e != nil { - return reflect.Value{}, nbytesread, e - } - v, n, e := UnpackReflected(reader) - nbytesread += n - if e != nil { - return reflect.Value{}, nbytesread, e - } - retval[k] = v - } - return reflect.ValueOf(retval), nbytesread, nil -} - -func unpack(reader io.Reader, reflected bool) (v reflect.Value, n int, err error) { - var retval reflect.Value - var nbytesread int = 0 - - c, e := readByte(reader) - if e != nil { - return reflect.Value{}, 0, e - } - nbytesread += 1 - if c < 0x80 || c >= 0xe0 { - retval = reflect.ValueOf(int8(c)) - } else if c >= 0x80 && c <= 0x8f { - if reflected { - retval, n, e = unpackMapReflected(reader, uint(c&0xf)) - } else { - retval, n, e = unpackMap(reader, uint(c&0xf)) - } - nbytesread += n - if e != nil { - return reflect.Value{}, nbytesread, e - } - nbytesread += n - } else if c >= 0x90 && c <= 0x9f { - if reflected { - retval, n, e = unpackArrayReflected(reader, uint(c&0xf)) - } else { - retval, n, e = unpackArray(reader, uint(c&0xf)) - } - nbytesread += n - if e != nil { - return reflect.Value{}, nbytesread, e - } - nbytesread += n - } else if c >= 0xa0 && c <= 0xbf { - data := make([]byte, c&0x1f) - n, e := reader.Read(data) - nbytesread += n - if e != nil { - return reflect.Value{}, nbytesread, e - } - retval = reflect.ValueOf(data) - } else { - switch c { - case 0xc0: - retval = reflect.ValueOf(nil) - case 0xc2: - retval = reflect.ValueOf(false) - case 0xc3: - retval = reflect.ValueOf(true) - case 0xca: - data, n, e := readUint32(reader) - nbytesread += n - if e != nil { - return reflect.Value{}, nbytesread, e - } - retval = reflect.ValueOf(*(*float32)(unsafe.Pointer(&data))) - case 0xcb: - data, n, e := readUint64(reader) - nbytesread += n - if e != nil { - return reflect.Value{}, nbytesread, e - } - retval = reflect.ValueOf(*(*float64)(unsafe.Pointer(&data))) - case 0xcc: - data, e := readByte(reader) - if e != nil { - return reflect.Value{}, nbytesread, e - } - retval = reflect.ValueOf(uint8(data)) - nbytesread += 1 - case 0xcd: - data, n, e := readUint16(reader) - nbytesread += n - if e != nil { - return reflect.Value{}, nbytesread, e - } - retval = reflect.ValueOf(data) - case 0xce: - data, n, e := readUint32(reader) - nbytesread += n - if e != nil { - return reflect.Value{}, nbytesread, e - } - retval = reflect.ValueOf(data) - case 0xcf: - data, n, e := readUint64(reader) - nbytesread += n - if e != nil { - return reflect.Value{}, nbytesread, e - } - retval = reflect.ValueOf(data) - case 0xd0: - data, e := readByte(reader) - if e != nil { - return reflect.Value{}, nbytesread, e - } - retval = reflect.ValueOf(int8(data)) - nbytesread += 1 - case 0xd1: - data, n, e := readInt16(reader) - nbytesread += n - if e != nil { - return reflect.Value{}, nbytesread, e - } - retval = reflect.ValueOf(data) - case 0xd2: - data, n, e := readInt32(reader) - nbytesread += n - if e != nil { - return reflect.Value{}, nbytesread, e - } - retval = reflect.ValueOf(data) - case 0xd3: - data, n, e := readInt64(reader) - nbytesread += n - if e != nil { - return reflect.Value{}, nbytesread, e - } - retval = reflect.ValueOf(data) - case 0xda: - nbytestoread, n, e := readUint16(reader) - nbytesread += n - if e != nil { - return reflect.Value{}, nbytesread, e - } - data := make([]byte, nbytestoread) - n, e = reader.Read(data) - nbytesread += n - if e != nil { - return reflect.Value{}, nbytesread, e - } - retval = reflect.ValueOf(data) - case 0xdb: - nbytestoread, n, e := readUint32(reader) - nbytesread += n - if e != nil { - return reflect.Value{}, nbytesread, e - } - data := make([]byte, nbytestoread) - n, e = reader.Read(data) - nbytesread += n - if e != nil { - return reflect.Value{}, nbytesread, e - } - retval = reflect.ValueOf(data) - case 0xdc: - nelemstoread, n, e := readUint16(reader) - nbytesread += n - if e != nil { - return reflect.Value{}, nbytesread, e - } - if reflected { - retval, n, e = unpackArrayReflected(reader, uint(nelemstoread)) - } else { - retval, n, e = unpackArray(reader, uint(nelemstoread)) - } - nbytesread += n - if e != nil { - return reflect.Value{}, nbytesread, e - } - case 0xdd: - nelemstoread, n, e := readUint32(reader) - nbytesread += n - if e != nil { - return reflect.Value{}, nbytesread, e - } - if reflected { - retval, n, e = unpackArrayReflected(reader, uint(nelemstoread)) - } else { - retval, n, e = unpackArray(reader, uint(nelemstoread)) - } - nbytesread += n - if e != nil { - return reflect.Value{}, nbytesread, e - } - case 0xde: - nelemstoread, n, e := readUint16(reader) - nbytesread += n - if e != nil { - return reflect.Value{}, nbytesread, e - } - if reflected { - retval, n, e = unpackMapReflected(reader, uint(nelemstoread)) - } else { - retval, n, e = unpackMap(reader, uint(nelemstoread)) - } - nbytesread += n - if e != nil { - return reflect.Value{}, nbytesread, e - } - case 0xdf: - nelemstoread, n, e := readUint32(reader) - nbytesread += n - if e != nil { - return reflect.Value{}, nbytesread, e - } - if reflected { - retval, n, e = unpackMapReflected(reader, uint(nelemstoread)) - } else { - retval, n, e = unpackMap(reader, uint(nelemstoread)) - } - nbytesread += n - if e != nil { - return reflect.Value{}, nbytesread, e - } - default: - panic("unsupported code: " + strconv.Itoa(int(c))) - } - } - return retval, nbytesread, nil -} - -// Reads a value from the reader, unpack and returns it. -func Unpack(reader io.Reader) (v reflect.Value, n int, err error) { - return unpack(reader, false) -} - -// Reads unpack a value from the reader, unpack and returns it. When the -// value is an array or map, leaves the elements wrapped by corresponding -// wrapper objects defined in reflect package. -func UnpackReflected(reader io.Reader) (v reflect.Value, n int, err error) { - return unpack(reader, true) -} diff --git a/haskell/README b/haskell/README deleted file mode 100644 index c3a919a9..00000000 --- a/haskell/README +++ /dev/null @@ -1 +0,0 @@ -MessagePack for Haskell moved to https://github.com/msgpack/msgpack-haskell. diff --git a/java/README b/java/README deleted file mode 100755 index 4cf4249e..00000000 --- a/java/README +++ /dev/null @@ -1 +0,0 @@ -MessagePack for Java was moved to https://github.com/msgpack/msgpack-java. diff --git a/ocaml/README b/ocaml/README deleted file mode 100644 index b6f4984e..00000000 --- a/ocaml/README +++ /dev/null @@ -1 +0,0 @@ -MessagePack for OCaml moved to https://github.com/msgpack/msgpack-ocaml. diff --git a/ruby/README.md b/ruby/README.md deleted file mode 100644 index b69ab833..00000000 --- a/ruby/README.md +++ /dev/null @@ -1 +0,0 @@ -MessagePack for Ruby moved to https://github.com/msgpack/msgpack-ruby. diff --git a/scala/.gitignore b/scala/.gitignore deleted file mode 100644 index 97250138..00000000 --- a/scala/.gitignore +++ /dev/null @@ -1,40 +0,0 @@ -# use glob syntax. -syntax: glob -*.ser -*.class -*~ -*.bak -#*.off -*.old - -# eclipse conf file -.settings -.classpath -.project -.manager -.scala_dependencies - -# idea -.idea -*.iml - -# building -target -build -null -tmp* -dist -test-output -build.log - -# other scm -.svn -.CVS -.hg* - -# switch to regexp syntax. -# syntax: regexp -# ^\.pc/ - -#SHITTY output not in target directory -build.log diff --git a/scala/README b/scala/README deleted file mode 100644 index 4f1701e9..00000000 --- a/scala/README +++ /dev/null @@ -1 +0,0 @@ -MessagePack for Scala moved to https://github.com/msgpack/msgpack-scala.