// Go support for Protocol Buffers - Google's data interchange format
  //
  // Copyright 2010 The Go Authors.  All rights reserved.
  // https://github.com/golang/protobuf
  //
  // Redistribution and use in source and binary forms, with or without
  // modification, are permitted provided that the following conditions are
  // met:
  //
  //     * Redistributions of source code must retain the above copyright
  // notice, this list of conditions and the following disclaimer.
  //     * Redistributions in binary form must reproduce the above
  // copyright notice, this list of conditions and the following disclaimer
  // in the documentation and/or other materials provided with the
  // distribution.
  //     * Neither the name of Google Inc. nor the names of its
  // contributors may be used to endorse or promote products derived from
  // this software without specific prior written permission.
  //
  // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  
  package proto
  
  /*
   * Routines for decoding protocol buffer data to construct in-memory representations.
   */
  
  import (
  	"errors"
  	"fmt"
  	"io"
  )
  
  // errOverflow is returned when an integer is too large to be represented.
  var errOverflow = errors.New("proto: integer overflow")
  
  // ErrInternalBadWireType is returned by generated code when an incorrect
  // wire type is encountered. It does not get returned to user code.
  var ErrInternalBadWireType = errors.New("proto: internal error: bad wiretype for oneof")
  
  // DecodeVarint reads a varint-encoded integer from the slice.
  // It returns the integer and the number of bytes consumed, or
  // zero if there is not enough.
  // This is the format for the
  // int32, int64, uint32, uint64, bool, and enum
  // protocol buffer types.
  func DecodeVarint(buf []byte) (x uint64, n int) {
  	for shift := uint(0); shift < 64; shift += 7 {
  		if n >= len(buf) {
  			return 0, 0
  		}
  		b := uint64(buf[n])
  		n++
  		x |= (b & 0x7F) << shift
  		if (b & 0x80) == 0 {
  			return x, n
  		}
  	}
  
  	// The number is too large to represent in a 64-bit value.
  	return 0, 0
  }
  
  func (p *Buffer) decodeVarintSlow() (x uint64, err error) {
  	i := p.index
  	l := len(p.buf)
  
  	for shift := uint(0); shift < 64; shift += 7 {
  		if i >= l {
  			err = io.ErrUnexpectedEOF
  			return
  		}
  		b := p.buf[i]
  		i++
  		x |= (uint64(b) & 0x7F) << shift
  		if b < 0x80 {
  			p.index = i
  			return
  		}
  	}
  
  	// The number is too large to represent in a 64-bit value.
  	err = errOverflow
  	return
  }
  
  // DecodeVarint reads a varint-encoded integer from the Buffer.
  // This is the format for the
  // int32, int64, uint32, uint64, bool, and enum
  // protocol buffer types.
  func (p *Buffer) DecodeVarint() (x uint64, err error) {
  	i := p.index
  	buf := p.buf
  
  	if i >= len(buf) {
  		return 0, io.ErrUnexpectedEOF
  	} else if buf[i] < 0x80 {
  		p.index++
  		return uint64(buf[i]), nil
  	} else if len(buf)-i < 10 {
  		return p.decodeVarintSlow()
  	}
  
  	var b uint64
  	// we already checked the first byte
  	x = uint64(buf[i]) - 0x80
  	i++
  
  	b = uint64(buf[i])
  	i++
  	x += b << 7
  	if b&0x80 == 0 {
  		goto done
  	}
  	x -= 0x80 << 7
  
  	b = uint64(buf[i])
  	i++
  	x += b << 14
  	if b&0x80 == 0 {
  		goto done
  	}
  	x -= 0x80 << 14
  
  	b = uint64(buf[i])
  	i++
  	x += b << 21
  	if b&0x80 == 0 {
  		goto done
  	}
  	x -= 0x80 << 21
  
  	b = uint64(buf[i])
  	i++
  	x += b << 28
  	if b&0x80 == 0 {
  		goto done
  	}
  	x -= 0x80 << 28
  
  	b = uint64(buf[i])
  	i++
  	x += b << 35
  	if b&0x80 == 0 {
  		goto done
  	}
  	x -= 0x80 << 35
  
  	b = uint64(buf[i])
  	i++
  	x += b << 42
  	if b&0x80 == 0 {
  		goto done
  	}
  	x -= 0x80 << 42
  
  	b = uint64(buf[i])
  	i++
  	x += b << 49
  	if b&0x80 == 0 {
  		goto done
  	}
  	x -= 0x80 << 49
  
  	b = uint64(buf[i])
  	i++
  	x += b << 56
  	if b&0x80 == 0 {
  		goto done
  	}
  	x -= 0x80 << 56
  
  	b = uint64(buf[i])
  	i++
  	x += b << 63
  	if b&0x80 == 0 {
  		goto done
  	}
  
  	return 0, errOverflow
  
  done:
  	p.index = i
  	return x, nil
  }
  
  // DecodeFixed64 reads a 64-bit integer from the Buffer.
  // This is the format for the
  // fixed64, sfixed64, and double protocol buffer types.
  func (p *Buffer) DecodeFixed64() (x uint64, err error) {
  	// x, err already 0
  	i := p.index + 8
  	if i < 0 || i > len(p.buf) {
  		err = io.ErrUnexpectedEOF
  		return
  	}
  	p.index = i
  
  	x = uint64(p.buf[i-8])
  	x |= uint64(p.buf[i-7]) << 8
  	x |= uint64(p.buf[i-6]) << 16
  	x |= uint64(p.buf[i-5]) << 24
  	x |= uint64(p.buf[i-4]) << 32
  	x |= uint64(p.buf[i-3]) << 40
  	x |= uint64(p.buf[i-2]) << 48
  	x |= uint64(p.buf[i-1]) << 56
  	return
  }
  
  // DecodeFixed32 reads a 32-bit integer from the Buffer.
  // This is the format for the
  // fixed32, sfixed32, and float protocol buffer types.
  func (p *Buffer) DecodeFixed32() (x uint64, err error) {
  	// x, err already 0
  	i := p.index + 4
  	if i < 0 || i > len(p.buf) {
  		err = io.ErrUnexpectedEOF
  		return
  	}
  	p.index = i
  
  	x = uint64(p.buf[i-4])
  	x |= uint64(p.buf[i-3]) << 8
  	x |= uint64(p.buf[i-2]) << 16
  	x |= uint64(p.buf[i-1]) << 24
  	return
  }
  
  // DecodeZigzag64 reads a zigzag-encoded 64-bit integer
  // from the Buffer.
  // This is the format used for the sint64 protocol buffer type.
  func (p *Buffer) DecodeZigzag64() (x uint64, err error) {
  	x, err = p.DecodeVarint()
  	if err != nil {
  		return
  	}
  	x = (x >> 1) ^ uint64((int64(x&1)<<63)>>63)
  	return
  }
  
  // DecodeZigzag32 reads a zigzag-encoded 32-bit integer
  // from  the Buffer.
  // This is the format used for the sint32 protocol buffer type.
  func (p *Buffer) DecodeZigzag32() (x uint64, err error) {
  	x, err = p.DecodeVarint()
  	if err != nil {
  		return
  	}
  	x = uint64((uint32(x) >> 1) ^ uint32((int32(x&1)<<31)>>31))
  	return
  }
  
  // DecodeRawBytes reads a count-delimited byte buffer from the Buffer.
  // This is the format used for the bytes protocol buffer
  // type and for embedded messages.
  func (p *Buffer) DecodeRawBytes(alloc bool) (buf []byte, err error) {
  	n, err := p.DecodeVarint()
  	if err != nil {
  		return nil, err
  	}
  
  	nb := int(n)
  	if nb < 0 {
  		return nil, fmt.Errorf("proto: bad byte length %d", nb)
  	}
  	end := p.index + nb
  	if end < p.index || end > len(p.buf) {
  		return nil, io.ErrUnexpectedEOF
  	}
  
  	if !alloc {
  		// todo: check if can get more uses of alloc=false
  		buf = p.buf[p.index:end]
  		p.index += nb
  		return
  	}
  
  	buf = make([]byte, nb)
  	copy(buf, p.buf[p.index:])
  	p.index += nb
  	return
  }
  
  // DecodeStringBytes reads an encoded string from the Buffer.
  // This is the format used for the proto2 string type.
  func (p *Buffer) DecodeStringBytes() (s string, err error) {
  	buf, err := p.DecodeRawBytes(false)
  	if err != nil {
  		return
  	}
  	return string(buf), nil
  }
  
  // Unmarshaler is the interface representing objects that can
  // unmarshal themselves.  The argument points to data that may be
  // overwritten, so implementations should not keep references to the
  // buffer.
  // Unmarshal implementations should not clear the receiver.
  // Any unmarshaled data should be merged into the receiver.
  // Callers of Unmarshal that do not want to retain existing data
  // should Reset the receiver before calling Unmarshal.
  type Unmarshaler interface {
  	Unmarshal([]byte) error
  }
  
  // newUnmarshaler is the interface representing objects that can
  // unmarshal themselves. The semantics are identical to Unmarshaler.
  //
  // This exists to support protoc-gen-go generated messages.
  // The proto package will stop type-asserting to this interface in the future.
  //
  // DO NOT DEPEND ON THIS.
  type newUnmarshaler interface {
  	XXX_Unmarshal([]byte) error
  }
  
  // Unmarshal parses the protocol buffer representation in buf and places the
  // decoded result in pb.  If the struct underlying pb does not match
  // the data in buf, the results can be unpredictable.
  //
  // Unmarshal resets pb before starting to unmarshal, so any
  // existing data in pb is always removed. Use UnmarshalMerge
  // to preserve and append to existing data.
  func Unmarshal(buf []byte, pb Message) error {
  	pb.Reset()
  	if u, ok := pb.(newUnmarshaler); ok {
  		return u.XXX_Unmarshal(buf)
  	}
  	if u, ok := pb.(Unmarshaler); ok {
  		return u.Unmarshal(buf)
  	}
  	return NewBuffer(buf).Unmarshal(pb)
  }
  
  // UnmarshalMerge parses the protocol buffer representation in buf and
  // writes the decoded result to pb.  If the struct underlying pb does not match
  // the data in buf, the results can be unpredictable.
  //
  // UnmarshalMerge merges into existing data in pb.
  // Most code should use Unmarshal instead.
  func UnmarshalMerge(buf []byte, pb Message) error {
  	if u, ok := pb.(newUnmarshaler); ok {
  		return u.XXX_Unmarshal(buf)
  	}
  	if u, ok := pb.(Unmarshaler); ok {
  		// NOTE: The history of proto have unfortunately been inconsistent
  		// whether Unmarshaler should or should not implicitly clear itself.
  		// Some implementations do, most do not.
  		// Thus, calling this here may or may not do what people want.
  		//
  		// See https://github.com/golang/protobuf/issues/424
  		return u.Unmarshal(buf)
  	}
  	return NewBuffer(buf).Unmarshal(pb)
  }
  
  // DecodeMessage reads a count-delimited message from the Buffer.
  func (p *Buffer) DecodeMessage(pb Message) error {
  	enc, err := p.DecodeRawBytes(false)
  	if err != nil {
  		return err
  	}
  	return NewBuffer(enc).Unmarshal(pb)
  }
  
  // DecodeGroup reads a tag-delimited group from the Buffer.
  // StartGroup tag is already consumed. This function consumes
  // EndGroup tag.
  func (p *Buffer) DecodeGroup(pb Message) error {
  	b := p.buf[p.index:]
  	x, y := findEndGroup(b)
  	if x < 0 {
  		return io.ErrUnexpectedEOF
  	}
  	err := Unmarshal(b[:x], pb)
  	p.index += y
  	return err
  }
  
  // Unmarshal parses the protocol buffer representation in the
  // Buffer and places the decoded result in pb.  If the struct
  // underlying pb does not match the data in the buffer, the results can be
  // unpredictable.
  //
  // Unlike proto.Unmarshal, this does not reset pb before starting to unmarshal.
  func (p *Buffer) Unmarshal(pb Message) error {
  	// If the object can unmarshal itself, let it.
  	if u, ok := pb.(newUnmarshaler); ok {
  		err := u.XXX_Unmarshal(p.buf[p.index:])
  		p.index = len(p.buf)
  		return err
  	}
  	if u, ok := pb.(Unmarshaler); ok {
  		// NOTE: The history of proto have unfortunately been inconsistent
  		// whether Unmarshaler should or should not implicitly clear itself.
  		// Some implementations do, most do not.
  		// Thus, calling this here may or may not do what people want.
  		//
  		// See https://github.com/golang/protobuf/issues/424
  		err := u.Unmarshal(p.buf[p.index:])
  		p.index = len(p.buf)
  		return err
  	}
  
  	// Slow workaround for messages that aren't Unmarshalers.
  	// This includes some hand-coded .pb.go files and
  	// bootstrap protos.
  	// TODO: fix all of those and then add Unmarshal to
  	// the Message interface. Then:
  	// The cast above and code below can be deleted.
  	// The old unmarshaler can be deleted.
  	// Clients can call Unmarshal directly (can already do that, actually).
  	var info InternalMessageInfo
  	err := info.Unmarshal(pb, p.buf[p.index:])
  	p.index = len(p.buf)
  	return err
  }