vendor/github.com/tinylib/msgp/msgp/read.go

   1 package msgp
   2
   3 import (
   4         "github.com/philhofer/fwd"
   5         "io"
   6         "math"
   7         "sync"
   8         "time"
   9 )
  10
  11 // where we keep old *Readers
  12 var readerPool = sync.Pool{New: func() interface{} { return &Reader{} }}
  13
  14 // Type is a MessagePack wire type,
  15 // including this package's built-in
  16 // extension types.
  17 type Type byte
  18
  19 // MessagePack Types
  20 //
  21 // The zero value of Type
  22 // is InvalidType.
  23 const (
  24         InvalidType Type = iota
  25
  26         // MessagePack built-in types
  27
  28         StrType
  29         BinType
  30         MapType
  31         ArrayType
  32         Float64Type
  33         Float32Type
  34         BoolType
  35         IntType
  36         UintType
  37         NilType
  38         ExtensionType
  39
  40         // pseudo-types provided
  41         // by extensions
  42
  43         Complex64Type
  44         Complex128Type
  45         TimeType
  46
  47         _maxtype
  48 )
  49
  50 // String implements fmt.Stringer
  51 func (t Type) String() string {
  52         switch t {
  53         case StrType:
  54                 return "str"
  55         case BinType:
  56                 return "bin"
  57         case MapType:
  58                 return "map"
  59         case ArrayType:
  60                 return "array"
  61         case Float64Type:
  62                 return "float64"
  63         case Float32Type:
  64                 return "float32"
  65         case BoolType:
  66                 return "bool"
  67         case UintType:
  68                 return "uint"
  69         case IntType:
  70                 return "int"
  71         case ExtensionType:
  72                 return "ext"
  73         case NilType:
  74                 return "nil"
  75         default:
  76                 return "<invalid>"
  77         }
  78 }
  79
  80 func freeR(m *Reader) {
  81         readerPool.Put(m)
  82 }
  83
  84 // Unmarshaler is the interface fulfilled
  85 // by objects that know how to unmarshal
  86 // themselves from MessagePack.
  87 // UnmarshalMsg unmarshals the object
  88 // from binary, returing any leftover
  89 // bytes and any errors encountered.
  90 type Unmarshaler interface {
  91         UnmarshalMsg([]byte) ([]byte, error)
  92 }
  93
  94 // Decodable is the interface fulfilled
  95 // by objects that know how to read
  96 // themselves from a *Reader.
  97 type Decodable interface {
  98         DecodeMsg(*Reader) error
  99 }
 100
 101 // Decode decodes 'd' from 'r'.
 102 func Decode(r io.Reader, d Decodable) error {
 103         rd := NewReader(r)
 104         err := d.DecodeMsg(rd)
 105         freeR(rd)
 106         return err
 107 }
 108
 109 // NewReader returns a *Reader that
 110 // reads from the provided reader. The
 111 // reader will be buffered.
 112 func NewReader(r io.Reader) *Reader {
 113         p := readerPool.Get().(*Reader)
 114         if p.r == nil {
 115                 p.r = fwd.NewReader(r)
 116         } else {
 117                 p.r.Reset(r)
 118         }
 119         return p
 120 }
 121
 122 // NewReaderSize returns a *Reader with a buffer of the given size.
 123 // (This is vastly preferable to passing the decoder a reader that is already buffered.)
 124 func NewReaderSize(r io.Reader, sz int) *Reader {
 125         return &Reader{r: fwd.NewReaderSize(r, sz)}
 126 }
 127
 128 // Reader wraps an io.Reader and provides
 129 // methods to read MessagePack-encoded values
 130 // from it. Readers are buffered.
 131 type Reader struct {
 132         r       *fwd.Reader
 133         scratch []byte
 134 }
 135
 136 // Read implements `io.Reader`
 137 func (m *Reader) Read(p []byte) (int, error) {
 138         return m.r.Read(p)
 139 }
 140
 141 // ReadFull implements `io.ReadFull`
 142 func (m *Reader) ReadFull(p []byte) (int, error) {
 143         return m.r.ReadFull(p)
 144 }
 145
 146 // Reset resets the underlying reader.
 147 func (m *Reader) Reset(r io.Reader) { m.r.Reset(r) }
 148
 149 // Buffered returns the number of bytes currently in the read buffer.
 150 func (m *Reader) Buffered() int { return m.r.Buffered() }
 151
 152 // BufferSize returns the capacity of the read buffer.
 153 func (m *Reader) BufferSize() int { return m.r.BufferSize() }
 154
 155 // NextType returns the next object type to be decoded.
 156 func (m *Reader) NextType() (Type, error) {
 157         p, err := m.r.Peek(1)
 158         if err != nil {
 159                 return InvalidType, err
 160         }
 161         t := getType(p[0])
 162         if t == InvalidType {
 163                 return t, InvalidPrefixError(p[0])
 164         }
 165         if t == ExtensionType {
 166                 v, err := m.peekExtensionType()
 167                 if err != nil {
 168                         return InvalidType, err
 169                 }
 170                 switch v {
 171                 case Complex64Extension:
 172                         return Complex64Type, nil
 173                 case Complex128Extension:
 174                         return Complex128Type, nil
 175                 case TimeExtension:
 176                         return TimeType, nil
 177                 }
 178         }
 179         return t, nil
 180 }
 181
 182 // IsNil returns whether or not
 183 // the next byte is a null messagepack byte
 184 func (m *Reader) IsNil() bool {
 185         p, err := m.r.Peek(1)
 186         return err == nil && p[0] == mnil
 187 }
 188
 189 // returns (obj size, obj elements, error)
 190 // only maps and arrays have non-zero obj elements
 191 //
 192 // use uintptr b/c it's guaranteed to be large enough
 193 // to hold whatever we can fit in memory.
 194 func getNextSize(r *fwd.Reader) (uintptr, uintptr, error) {
 195         b, err := r.Peek(1)
 196         if err != nil {
 197                 return 0, 0, err
 198         }
 199         lead := b[0]
 200         spec := &sizes[lead]
 201         size, mode := spec.size, spec.extra
 202         if size == 0 {
 203                 return 0, 0, InvalidPrefixError(lead)
 204         }
 205         if mode >= 0 {
 206                 return uintptr(size), uintptr(mode), nil
 207         }
 208         b, err = r.Peek(int(size))
 209         if err != nil {
 210                 return 0, 0, err
 211         }
 212         switch mode {
 213         case extra8:
 214                 return uintptr(size) + uintptr(b[1]), 0, nil
 215         case extra16:
 216                 return uintptr(size) + uintptr(big.Uint16(b[1:])), 0, nil
 217         case extra32:
 218                 return uintptr(size) + uintptr(big.Uint32(b[1:])), 0, nil
 219         case map16v:
 220                 return uintptr(size), 2 * uintptr(big.Uint16(b[1:])), nil
 221         case map32v:
 222                 return uintptr(size), 2 * uintptr(big.Uint32(b[1:])), nil
 223         case array16v:
 224                 return uintptr(size), uintptr(big.Uint16(b[1:])), nil
 225         case array32v:
 226                 return uintptr(size), uintptr(big.Uint32(b[1:])), nil
 227         default:
 228                 return 0, 0, fatal
 229         }
 230 }
 231
 232 // Skip skips over the next object, regardless of
 233 // its type. If it is an array or map, the whole array
 234 // or map will be skipped.
 235 func (m *Reader) Skip() error {
 236         var (
 237                 v   uintptr // bytes
 238                 o   uintptr // objects
 239                 err error
 240                 p   []byte
 241         )
 242
 243         // we can use the faster
 244         // method if we have enough
 245         // buffered data
 246         if m.r.Buffered() >= 5 {
 247                 p, err = m.r.Peek(5)
 248                 if err != nil {
 249                         return err
 250                 }
 251                 v, o, err = getSize(p)
 252                 if err != nil {
 253                         return err
 254                 }
 255         } else {
 256                 v, o, err = getNextSize(m.r)
 257                 if err != nil {
 258                         return err
 259                 }
 260         }
 261
 262         // 'v' is always non-zero
 263         // if err == nil
 264         _, err = m.r.Skip(int(v))
 265         if err != nil {
 266                 return err
 267         }
 268
 269         // for maps and slices, skip elements
 270         for x := uintptr(0); x < o; x++ {
 271                 err = m.Skip()
 272                 if err != nil {
 273                         return err
 274                 }
 275         }
 276         return nil
 277 }
 278
 279 // ReadMapHeader reads the next object
 280 // as a map header and returns the size
 281 // of the map and the number of bytes written.
 282 // It will return a TypeError{} if the next
 283 // object is not a map.
 284 func (m *Reader) ReadMapHeader() (sz uint32, err error) {
 285         var p []byte
 286         var lead byte
 287         p, err = m.r.Peek(1)
 288         if err != nil {
 289                 return
 290         }
 291         lead = p[0]
 292         if isfixmap(lead) {
 293                 sz = uint32(rfixmap(lead))
 294                 _, err = m.r.Skip(1)
 295                 return
 296         }
 297         switch lead {
 298         case mmap16:
 299                 p, err = m.r.Next(3)
 300                 if err != nil {
 301                         return
 302                 }
 303                 sz = uint32(big.Uint16(p[1:]))
 304                 return
 305         case mmap32:
 306                 p, err = m.r.Next(5)
 307                 if err != nil {
 308                         return
 309                 }
 310                 sz = big.Uint32(p[1:])
 311                 return
 312         default:
 313                 err = badPrefix(MapType, lead)
 314                 return
 315         }
 316 }
 317
 318 // ReadMapKey reads either a 'str' or 'bin' field from
 319 // the reader and returns the value as a []byte. It uses
 320 // scratch for storage if it is large enough.
 321 func (m *Reader) ReadMapKey(scratch []byte) ([]byte, error) {
 322         out, err := m.ReadStringAsBytes(scratch)
 323         if err != nil {
 324                 if tperr, ok := err.(TypeError); ok && tperr.Encoded == BinType {
 325                         return m.ReadBytes(scratch)
 326                 }
 327                 return nil, err
 328         }
 329         return out, nil
 330 }
 331
 332 // MapKeyPtr returns a []byte pointing to the contents
 333 // of a valid map key. The key cannot be empty, and it
 334 // must be shorter than the total buffer size of the
 335 // *Reader. Additionally, the returned slice is only
 336 // valid until the next *Reader method call. Users
 337 // should exercise extreme care when using this
 338 // method; writing into the returned slice may
 339 // corrupt future reads.
 340 func (m *Reader) ReadMapKeyPtr() ([]byte, error) {
 341         p, err := m.r.Peek(1)
 342         if err != nil {
 343                 return nil, err
 344         }
 345         lead := p[0]
 346         var read int
 347         if isfixstr(lead) {
 348                 read = int(rfixstr(lead))
 349                 m.r.Skip(1)
 350                 goto fill
 351         }
 352         switch lead {
 353         case mstr8, mbin8:
 354                 p, err = m.r.Next(2)
 355                 if err != nil {
 356                         return nil, err
 357                 }
 358                 read = int(p[1])
 359         case mstr16, mbin16:
 360                 p, err = m.r.Next(3)
 361                 if err != nil {
 362                         return nil, err
 363                 }
 364                 read = int(big.Uint16(p[1:]))
 365         case mstr32, mbin32:
 366                 p, err = m.r.Next(5)
 367                 if err != nil {
 368                         return nil, err
 369                 }
 370                 read = int(big.Uint32(p[1:]))
 371         default:
 372                 return nil, badPrefix(StrType, lead)
 373         }
 374 fill:
 375         if read == 0 {
 376                 return nil, ErrShortBytes
 377         }
 378         return m.r.Next(read)
 379 }
 380
 381 // ReadArrayHeader reads the next object as an
 382 // array header and returns the size of the array
 383 // and the number of bytes read.
 384 func (m *Reader) ReadArrayHeader() (sz uint32, err error) {
 385         var lead byte
 386         var p []byte
 387         p, err = m.r.Peek(1)
 388         if err != nil {
 389                 return
 390         }
 391         lead = p[0]
 392         if isfixarray(lead) {
 393                 sz = uint32(rfixarray(lead))
 394                 _, err = m.r.Skip(1)
 395                 return
 396         }
 397         switch lead {
 398         case marray16:
 399                 p, err = m.r.Next(3)
 400                 if err != nil {
 401                         return
 402                 }
 403                 sz = uint32(big.Uint16(p[1:]))
 404                 return
 405
 406         case marray32:
 407                 p, err = m.r.Next(5)
 408                 if err != nil {
 409                         return
 410                 }
 411                 sz = big.Uint32(p[1:])
 412                 return
 413
 414         default:
 415                 err = badPrefix(ArrayType, lead)
 416                 return
 417         }
 418 }
 419
 420 // ReadNil reads a 'nil' MessagePack byte from the reader
 421 func (m *Reader) ReadNil() error {
 422         p, err := m.r.Peek(1)
 423         if err != nil {
 424                 return err
 425         }
 426         if p[0] != mnil {
 427                 return badPrefix(NilType, p[0])
 428         }
 429         _, err = m.r.Skip(1)
 430         return err
 431 }
 432
 433 // ReadFloat64 reads a float64 from the reader.
 434 // (If the value on the wire is encoded as a float32,
 435 // it will be up-cast to a float64.)
 436 func (m *Reader) ReadFloat64() (f float64, err error) {
 437         var p []byte
 438         p, err = m.r.Peek(9)
 439         if err != nil {
 440                 // we'll allow a coversion from float32 to float64,
 441                 // since we don't lose any precision
 442                 if err == io.EOF && len(p) > 0 && p[0] == mfloat32 {
 443                         ef, err := m.ReadFloat32()
 444                         return float64(ef), err
 445                 }
 446                 return
 447         }
 448         if p[0] != mfloat64 {
 449                 // see above
 450                 if p[0] == mfloat32 {
 451                         ef, err := m.ReadFloat32()
 452                         return float64(ef), err
 453                 }
 454                 err = badPrefix(Float64Type, p[0])
 455                 return
 456         }
 457         f = math.Float64frombits(getMuint64(p))
 458         _, err = m.r.Skip(9)
 459         return
 460 }
 461
 462 // ReadFloat32 reads a float32 from the reader
 463 func (m *Reader) ReadFloat32() (f float32, err error) {
 464         var p []byte
 465         p, err = m.r.Peek(5)
 466         if err != nil {
 467                 return
 468         }
 469         if p[0] != mfloat32 {
 470                 err = badPrefix(Float32Type, p[0])
 471                 return
 472         }
 473         f = math.Float32frombits(getMuint32(p))
 474         _, err = m.r.Skip(5)
 475         return
 476 }
 477
 478 // ReadBool reads a bool from the reader
 479 func (m *Reader) ReadBool() (b bool, err error) {
 480         var p []byte
 481         p, err = m.r.Peek(1)
 482         if err != nil {
 483                 return
 484         }
 485         switch p[0] {
 486         case mtrue:
 487                 b = true
 488         case mfalse:
 489         default:
 490                 err = badPrefix(BoolType, p[0])
 491                 return
 492         }
 493         _, err = m.r.Skip(1)
 494         return
 495 }
 496
 497 // ReadInt64 reads an int64 from the reader
 498 func (m *Reader) ReadInt64() (i int64, err error) {
 499         var p []byte
 500         var lead byte
 501         p, err = m.r.Peek(1)
 502         if err != nil {
 503                 return
 504         }
 505         lead = p[0]
 506
 507         if isfixint(lead) {
 508                 i = int64(rfixint(lead))
 509                 _, err = m.r.Skip(1)
 510                 return
 511         } else if isnfixint(lead) {
 512                 i = int64(rnfixint(lead))
 513                 _, err = m.r.Skip(1)
 514                 return
 515         }
 516
 517         switch lead {
 518         case mint8:
 519                 p, err = m.r.Next(2)
 520                 if err != nil {
 521                         return
 522                 }
 523                 i = int64(getMint8(p))
 524                 return
 525
 526         case mint16:
 527                 p, err = m.r.Next(3)
 528                 if err != nil {
 529                         return
 530                 }
 531                 i = int64(getMint16(p))
 532                 return
 533
 534         case mint32:
 535                 p, err = m.r.Next(5)
 536                 if err != nil {
 537                         return
 538                 }
 539                 i = int64(getMint32(p))
 540                 return
 541
 542         case mint64:
 543                 p, err = m.r.Next(9)
 544                 if err != nil {
 545                         return
 546                 }
 547                 i = getMint64(p)
 548                 return
 549
 550         default:
 551                 err = badPrefix(IntType, lead)
 552                 return
 553         }
 554 }
 555
 556 // ReadInt32 reads an int32 from the reader
 557 func (m *Reader) ReadInt32() (i int32, err error) {
 558         var in int64
 559         in, err = m.ReadInt64()
 560         if in > math.MaxInt32 || in < math.MinInt32 {
 561                 err = IntOverflow{Value: in, FailedBitsize: 32}
 562                 return
 563         }
 564         i = int32(in)
 565         return
 566 }
 567
 568 // ReadInt16 reads an int16 from the reader
 569 func (m *Reader) ReadInt16() (i int16, err error) {
 570         var in int64
 571         in, err = m.ReadInt64()
 572         if in > math.MaxInt16 || in < math.MinInt16 {
 573                 err = IntOverflow{Value: in, FailedBitsize: 16}
 574                 return
 575         }
 576         i = int16(in)
 577         return
 578 }
 579
 580 // ReadInt8 reads an int8 from the reader
 581 func (m *Reader) ReadInt8() (i int8, err error) {
 582         var in int64
 583         in, err = m.ReadInt64()
 584         if in > math.MaxInt8 || in < math.MinInt8 {
 585                 err = IntOverflow{Value: in, FailedBitsize: 8}
 586                 return
 587         }
 588         i = int8(in)
 589         return
 590 }
 591
 592 // ReadInt reads an int from the reader
 593 func (m *Reader) ReadInt() (i int, err error) {
 594         if smallint {
 595                 var in int32
 596                 in, err = m.ReadInt32()
 597                 i = int(in)
 598                 return
 599         }
 600         var in int64
 601         in, err = m.ReadInt64()
 602         i = int(in)
 603         return
 604 }
 605
 606 // ReadUint64 reads a uint64 from the reader
 607 func (m *Reader) ReadUint64() (u uint64, err error) {
 608         var p []byte
 609         var lead byte
 610         p, err = m.r.Peek(1)
 611         if err != nil {
 612                 return
 613         }
 614         lead = p[0]
 615         if isfixint(lead) {
 616                 u = uint64(rfixint(lead))
 617                 _, err = m.r.Skip(1)
 618                 return
 619         }
 620         switch lead {
 621         case muint8:
 622                 p, err = m.r.Next(2)
 623                 if err != nil {
 624                         return
 625                 }
 626                 u = uint64(getMuint8(p))
 627                 return
 628
 629         case muint16:
 630                 p, err = m.r.Next(3)
 631                 if err != nil {
 632                         return
 633                 }
 634                 u = uint64(getMuint16(p))
 635                 return
 636
 637         case muint32:
 638                 p, err = m.r.Next(5)
 639                 if err != nil {
 640                         return
 641                 }
 642                 u = uint64(getMuint32(p))
 643                 return
 644
 645         case muint64:
 646                 p, err = m.r.Next(9)
 647                 if err != nil {
 648                         return
 649                 }
 650                 u = getMuint64(p)
 651                 return
 652
 653         default:
 654                 err = badPrefix(UintType, lead)
 655                 return
 656
 657         }
 658 }
 659
 660 // ReadUint32 reads a uint32 from the reader
 661 func (m *Reader) ReadUint32() (u uint32, err error) {
 662         var in uint64
 663         in, err = m.ReadUint64()
 664         if in > math.MaxUint32 {
 665                 err = UintOverflow{Value: in, FailedBitsize: 32}
 666                 return
 667         }
 668         u = uint32(in)
 669         return
 670 }
 671
 672 // ReadUint16 reads a uint16 from the reader
 673 func (m *Reader) ReadUint16() (u uint16, err error) {
 674         var in uint64
 675         in, err = m.ReadUint64()
 676         if in > math.MaxUint16 {
 677                 err = UintOverflow{Value: in, FailedBitsize: 16}
 678                 return
 679         }
 680         u = uint16(in)
 681         return
 682 }
 683
 684 // ReadUint8 reads a uint8 from the reader
 685 func (m *Reader) ReadUint8() (u uint8, err error) {
 686         var in uint64
 687         in, err = m.ReadUint64()
 688         if in > math.MaxUint8 {
 689                 err = UintOverflow{Value: in, FailedBitsize: 8}
 690                 return
 691         }
 692         u = uint8(in)
 693         return
 694 }
 695
 696 // ReadUint reads a uint from the reader
 697 func (m *Reader) ReadUint() (u uint, err error) {
 698         if smallint {
 699                 var un uint32
 700                 un, err = m.ReadUint32()
 701                 u = uint(un)
 702                 return
 703         }
 704         var un uint64
 705         un, err = m.ReadUint64()
 706         u = uint(un)
 707         return
 708 }
 709
 710 func (m *Reader) ReadByte() (b byte, err error) {
 711         var in uint64
 712         in, err = m.ReadUint64()
 713         if in > math.MaxUint8 {
 714                 err = UintOverflow{Value: in, FailedBitsize: 8}
 715                 return
 716         }
 717         b = byte(in)
 718         return
 719 }
 720
 721 // ReadBytes reads a MessagePack 'bin' object
 722 // from the reader and returns its value. It may
 723 // use 'scratch' for storage if it is non-nil.
 724 func (m *Reader) ReadBytes(scratch []byte) (b []byte, err error) {
 725         var p []byte
 726         var lead byte
 727         p, err = m.r.Peek(2)
 728         if err != nil {
 729                 return
 730         }
 731         lead = p[0]
 732         var read int64
 733         switch lead {
 734         case mbin8:
 735                 read = int64(p[1])
 736                 m.r.Skip(2)
 737         case mbin16:
 738                 p, err = m.r.Next(3)
 739                 if err != nil {
 740                         return
 741                 }
 742                 read = int64(big.Uint16(p[1:]))
 743         case mbin32:
 744                 p, err = m.r.Next(5)
 745                 if err != nil {
 746                         return
 747                 }
 748                 read = int64(big.Uint32(p[1:]))
 749         default:
 750                 err = badPrefix(BinType, lead)
 751                 return
 752         }
 753         if int64(cap(scratch)) < read {
 754                 b = make([]byte, read)
 755         } else {
 756                 b = scratch[0:read]
 757         }
 758         _, err = m.r.ReadFull(b)
 759         return
 760 }
 761
 762 // ReadExactBytes reads a MessagePack 'bin'-encoded
 763 // object off of the wire into the provided slice. An
 764 // ArrayError will be returned if the object is not
 765 // exactly the length of the input slice.
 766 func (m *Reader) ReadExactBytes(into []byte) error {
 767         p, err := m.r.Peek(2)
 768         if err != nil {
 769                 return err
 770         }
 771         lead := p[0]
 772         var read int64 // bytes to read
 773         var skip int   // prefix size to skip
 774         switch lead {
 775         case mbin8:
 776                 read = int64(p[1])
 777                 skip = 2
 778         case mbin16:
 779                 p, err = m.r.Peek(3)
 780                 if err != nil {
 781                         return err
 782                 }
 783                 read = int64(big.Uint16(p[1:]))
 784                 skip = 3
 785         case mbin32:
 786                 p, err = m.r.Peek(5)
 787                 if err != nil {
 788                         return err
 789                 }
 790                 read = int64(big.Uint32(p[1:]))
 791                 skip = 5
 792         default:
 793                 return badPrefix(BinType, lead)
 794         }
 795         if read != int64(len(into)) {
 796                 return ArrayError{Wanted: uint32(len(into)), Got: uint32(read)}
 797         }
 798         m.r.Skip(skip)
 799         _, err = m.r.ReadFull(into)
 800         return err
 801 }
 802
 803 // ReadStringAsBytes reads a MessagePack 'str' (utf-8) string
 804 // and returns its value as bytes. It may use 'scratch' for storage
 805 // if it is non-nil.
 806 func (m *Reader) ReadStringAsBytes(scratch []byte) (b []byte, err error) {
 807         var p []byte
 808         var lead byte
 809         p, err = m.r.Peek(1)
 810         if err != nil {
 811                 return
 812         }
 813         lead = p[0]
 814         var read int64
 815
 816         if isfixstr(lead) {
 817                 read = int64(rfixstr(lead))
 818                 m.r.Skip(1)
 819                 goto fill
 820         }
 821
 822         switch lead {
 823         case mstr8:
 824                 p, err = m.r.Next(2)
 825                 if err != nil {
 826                         return
 827                 }
 828                 read = int64(uint8(p[1]))
 829         case mstr16:
 830                 p, err = m.r.Next(3)
 831                 if err != nil {
 832                         return
 833                 }
 834                 read = int64(big.Uint16(p[1:]))
 835         case mstr32:
 836                 p, err = m.r.Next(5)
 837                 if err != nil {
 838                         return
 839                 }
 840                 read = int64(big.Uint32(p[1:]))
 841         default:
 842                 err = badPrefix(StrType, lead)
 843                 return
 844         }
 845 fill:
 846         if int64(cap(scratch)) < read {
 847                 b = make([]byte, read)
 848         } else {
 849                 b = scratch[0:read]
 850         }
 851         _, err = m.r.ReadFull(b)
 852         return
 853 }
 854
 855 // ReadString reads a utf-8 string from the reader
 856 func (m *Reader) ReadString() (s string, err error) {
 857         var p []byte
 858         var lead byte
 859         var read int64
 860         p, err = m.r.Peek(1)
 861         if err != nil {
 862                 return
 863         }
 864         lead = p[0]
 865
 866         if isfixstr(lead) {
 867                 read = int64(rfixstr(lead))
 868                 m.r.Skip(1)
 869                 goto fill
 870         }
 871
 872         switch lead {
 873         case mstr8:
 874                 p, err = m.r.Next(2)
 875                 if err != nil {
 876                         return
 877                 }
 878                 read = int64(uint8(p[1]))
 879         case mstr16:
 880                 p, err = m.r.Next(3)
 881                 if err != nil {
 882                         return
 883                 }
 884                 read = int64(big.Uint16(p[1:]))
 885         case mstr32:
 886                 p, err = m.r.Next(5)
 887                 if err != nil {
 888                         return
 889                 }
 890                 read = int64(big.Uint32(p[1:]))
 891         default:
 892                 err = badPrefix(StrType, lead)
 893                 return
 894         }
 895 fill:
 896         if read == 0 {
 897                 s, err = "", nil
 898                 return
 899         }
 900         // reading into the memory
 901         // that will become the string
 902         // itself has vastly superior
 903         // worst-case performance, because
 904         // the reader buffer doesn't have
 905         // to be large enough to hold the string.
 906         // the idea here is to make it more
 907         // difficult for someone malicious
 908         // to cause the system to run out of
 909         // memory by sending very large strings.
 910         //
 911         // NOTE: this works because the argument
 912         // passed to (*fwd.Reader).ReadFull escapes
 913         // to the heap; its argument may, in turn,
 914         // be passed to the underlying reader, and
 915         // thus escape analysis *must* conclude that
 916         // 'out' escapes.
 917         out := make([]byte, read)
 918         _, err = m.r.ReadFull(out)
 919         if err != nil {
 920                 return
 921         }
 922         s = UnsafeString(out)
 923         return
 924 }
 925
 926 // ReadComplex64 reads a complex64 from the reader
 927 func (m *Reader) ReadComplex64() (f complex64, err error) {
 928         var p []byte
 929         p, err = m.r.Peek(10)
 930         if err != nil {
 931                 return
 932         }
 933         if p[0] != mfixext8 {
 934                 err = badPrefix(Complex64Type, p[0])
 935                 return
 936         }
 937         if int8(p[1]) != Complex64Extension {
 938                 err = errExt(int8(p[1]), Complex64Extension)
 939                 return
 940         }
 941         f = complex(math.Float32frombits(big.Uint32(p[2:])),
 942                 math.Float32frombits(big.Uint32(p[6:])))
 943         _, err = m.r.Skip(10)
 944         return
 945 }
 946
 947 // ReadComplex128 reads a complex128 from the reader
 948 func (m *Reader) ReadComplex128() (f complex128, err error) {
 949         var p []byte
 950         p, err = m.r.Peek(18)
 951         if err != nil {
 952                 return
 953         }
 954         if p[0] != mfixext16 {
 955                 err = badPrefix(Complex128Type, p[0])
 956                 return
 957         }
 958         if int8(p[1]) != Complex128Extension {
 959                 err = errExt(int8(p[1]), Complex128Extension)
 960                 return
 961         }
 962         f = complex(math.Float64frombits(big.Uint64(p[2:])),
 963                 math.Float64frombits(big.Uint64(p[10:])))
 964         _, err = m.r.Skip(18)
 965         return
 966 }
 967
 968 // ReadMapStrIntf reads a MessagePack map into a map[string]interface{}.
 969 // (You must pass a non-nil map into the function.)
 970 func (m *Reader) ReadMapStrIntf(mp map[string]interface{}) (err error) {
 971         var sz uint32
 972         sz, err = m.ReadMapHeader()
 973         if err != nil {
 974                 return
 975         }
 976         for key := range mp {
 977                 delete(mp, key)
 978         }
 979         for i := uint32(0); i < sz; i++ {
 980                 var key string
 981                 var val interface{}
 982                 key, err = m.ReadString()
 983                 if err != nil {
 984                         return
 985                 }
 986                 val, err = m.ReadIntf()
 987                 if err != nil {
 988                         return
 989                 }
 990                 mp[key] = val
 991         }
 992         return
 993 }
 994
 995 // ReadTime reads a time.Time object from the reader.
 996 // The returned time's location will be set to time.Local.
 997 func (m *Reader) ReadTime() (t time.Time, err error) {
 998         var p []byte
 999         p, err = m.r.Peek(15)
1000         if err != nil {
1001                 return
1002         }
1003         if p[0] != mext8 || p[1] != 12 {
1004                 err = badPrefix(TimeType, p[0])
1005                 return
1006         }
1007         if int8(p[2]) != TimeExtension {
1008                 err = errExt(int8(p[2]), TimeExtension)
1009                 return
1010         }
1011         sec, nsec := getUnix(p[3:])
1012         t = time.Unix(sec, int64(nsec)).Local()
1013         _, err = m.r.Skip(15)
1014         return
1015 }
1016
1017 // ReadIntf reads out the next object as a raw interface{}.
1018 // Arrays are decoded as []interface{}, and maps are decoded
1019 // as map[string]interface{}. Integers are decoded as int64
1020 // and unsigned integers are decoded as uint64.
1021 func (m *Reader) ReadIntf() (i interface{}, err error) {
1022         var t Type
1023         t, err = m.NextType()
1024         if err != nil {
1025                 return
1026         }
1027         switch t {
1028         case BoolType:
1029                 i, err = m.ReadBool()
1030                 return
1031
1032         case IntType:
1033                 i, err = m.ReadInt64()
1034                 return
1035
1036         case UintType:
1037                 i, err = m.ReadUint64()
1038                 return
1039
1040         case BinType:
1041                 i, err = m.ReadBytes(nil)
1042                 return
1043
1044         case StrType:
1045                 i, err = m.ReadString()
1046                 return
1047
1048         case Complex64Type:
1049                 i, err = m.ReadComplex64()
1050                 return
1051
1052         case Complex128Type:
1053                 i, err = m.ReadComplex128()
1054                 return
1055
1056         case TimeType:
1057                 i, err = m.ReadTime()
1058                 return
1059
1060         case ExtensionType:
1061                 var t int8
1062                 t, err = m.peekExtensionType()
1063                 if err != nil {
1064                         return
1065                 }
1066                 f, ok := extensionReg[t]
1067                 if ok {
1068                         e := f()
1069                         err = m.ReadExtension(e)
1070                         i = e
1071                         return
1072                 }
1073                 var e RawExtension
1074                 e.Type = t
1075                 err = m.ReadExtension(&e)
1076                 i = &e
1077                 return
1078
1079         case MapType:
1080                 mp := make(map[string]interface{})
1081                 err = m.ReadMapStrIntf(mp)
1082                 i = mp
1083                 return
1084
1085         case NilType:
1086                 err = m.ReadNil()
1087                 i = nil
1088                 return
1089
1090         case Float32Type:
1091                 i, err = m.ReadFloat32()
1092                 return
1093
1094         case Float64Type:
1095                 i, err = m.ReadFloat64()
1096                 return
1097
1098         case ArrayType:
1099                 var sz uint32
1100                 sz, err = m.ReadArrayHeader()
1101
1102                 if err != nil {
1103                         return
1104                 }
1105                 out := make([]interface{}, int(sz))
1106                 for j := range out {
1107                         out[j], err = m.ReadIntf()
1108                         if err != nil {
1109                                 return
1110                         }
1111                 }
1112                 i = out
1113                 return
1114
1115         default:
1116                 return nil, fatal // unreachable
1117         }
1118 }