decode.go

// BSON library for Go
//
// Copyright (c) 2010-2012 - Gustavo Niemeyer <gustavo@niemeyer.net>
//
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// 1. Redistributions of source code must retain the above copyright notice, this
//    list of conditions and the following disclaimer.
// 2. 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.
//
// 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.
// gobson - BSON library for Go.

package bson

import (
	"errors"
	"fmt"
	"io"
	"math"
	"net/url"
	"reflect"
	"strconv"
	"sync"
	"time"
)

type decoder struct {
	in      []byte
	i       int
	docType reflect.Type
}

var typeM = reflect.TypeOf(M{})

func newDecoder(in []byte) *decoder {
	return &decoder{in, 0, typeM}
}

// --------------------------------------------------------------------------
// Some helper functions.

func corrupted() {
	panic("Document is corrupted")
}

// --------------------------------------------------------------------------
// Unmarshaling of documents.

const (
	setterUnknown = iota
	setterNone
	setterType
	setterAddr
)

var setterStyles map[reflect.Type]int
var setterIface reflect.Type
var setterMutex sync.RWMutex

func init() {
	var iface Setter
	setterIface = reflect.TypeOf(&iface).Elem()
	setterStyles = make(map[reflect.Type]int)
}

func setterStyle(outt reflect.Type) int {
	setterMutex.RLock()
	style := setterStyles[outt]
	setterMutex.RUnlock()
	if style != setterUnknown {
		return style
	}

	setterMutex.Lock()
	defer setterMutex.Unlock()
	if outt.Implements(setterIface) {
		style = setterType
	} else if reflect.PtrTo(outt).Implements(setterIface) {
		style = setterAddr
	} else {
		style = setterNone
	}
	setterStyles[outt] = style
	return style
}

func getSetter(outt reflect.Type, out reflect.Value) Setter {
	style := setterStyle(outt)
	if style == setterNone {
		return nil
	}
	if style == setterAddr {
		if !out.CanAddr() {
			return nil
		}
		out = out.Addr()
	} else if outt.Kind() == reflect.Ptr && out.IsNil() {
		out.Set(reflect.New(outt.Elem()))
	}
	return out.Interface().(Setter)
}

func clearMap(m reflect.Value) {
	var none reflect.Value
	for _, k := range m.MapKeys() {
		m.SetMapIndex(k, none)
	}
}

func (d *decoder) readDocTo(out reflect.Value) {
	var elemType reflect.Type
	outt := out.Type()
	outk := outt.Kind()

	for {
		if outk == reflect.Ptr && out.IsNil() {
			out.Set(reflect.New(outt.Elem()))
		}
		if setter := getSetter(outt, out); setter != nil {
			raw := d.readRaw(ElementDocument)
			err := setter.SetBSON(raw)
			if _, ok := err.(*TypeError); err != nil && !ok {
				panic(err)
			}
			return
		}
		if outk == reflect.Ptr {
			out = out.Elem()
			outt = out.Type()
			outk = out.Kind()
			continue
		}
		break
	}

	var fieldsMap map[string]fieldInfo
	var inlineMap reflect.Value
	if outt == typeRaw {
		out.Set(reflect.ValueOf(d.readRaw(ElementDocument)))
		return
	}

	origout := out
	if outk == reflect.Interface {
		if d.docType.Kind() == reflect.Map {
			mv := reflect.MakeMap(d.docType)
			out.Set(mv)
			out = mv
		} else {
			dv := reflect.New(d.docType).Elem()
			out.Set(dv)
			out = dv
		}
		outt = out.Type()
		outk = outt.Kind()
	}

	docType := d.docType
	keyType := typeString
	convertKey := false
	switch outk {
	case reflect.Map:
		keyType = outt.Key()
		if keyType != typeString {
			convertKey = true
		}
		elemType = outt.Elem()
		if elemType == typeIface {
			d.docType = outt
		}
		if out.IsNil() {
			out.Set(reflect.MakeMap(out.Type()))
		} else if out.Len() > 0 {
			clearMap(out)
		}
	case reflect.Struct:
		sinfo, err := getStructInfo(out.Type())
		if err != nil {
			panic(err)
		}
		fieldsMap = sinfo.FieldsMap
		if sinfo.InlineStruct {
			if useRespectNilValues {
				out.Set(sinfo.Zero)
			} else {
				out.Set(deepZero(sinfo.st))
			}
		} else {
			out.Set(sinfo.Zero)
		}

		if sinfo.InlineMap != -1 {
			inlineMap = out.Field(sinfo.InlineMap)
			if !inlineMap.IsNil() && inlineMap.Len() > 0 {
				clearMap(inlineMap)
			}
			elemType = inlineMap.Type().Elem()
			if elemType == typeIface {
				d.docType = inlineMap.Type()
			}
		}
	case reflect.Slice:
		switch outt.Elem() {
		case typeDocElem:
			origout.Set(d.readDocElems(outt))
			return
		case typeRawDocElem:
			origout.Set(d.readRawDocElems(outt))
			return
		}
		fallthrough
	default:
		panic("Unsupported document type for unmarshalling: " + out.Type().String())
	}

	end := int(d.readInt32())
	end += d.i - 4
	if end <= d.i || end > len(d.in) || d.in[end-1] != '\x00' {
		corrupted()
	}
	for d.in[d.i] != '\x00' {
		kind := d.readByte()
		name := d.readCStr()
		if d.i >= end {
			corrupted()
		}

		switch outk {
		case reflect.Map:
			e := reflect.New(elemType).Elem()
			if d.readElemTo(e, kind) {
				k := reflect.ValueOf(name)
				if convertKey {
					mapKeyType := out.Type().Key()
					mapKeyKind := mapKeyType.Kind()

					switch mapKeyKind {
					case reflect.Int:
						fallthrough
					case reflect.Int8:
						fallthrough
					case reflect.Int16:
						fallthrough
					case reflect.Int32:
						fallthrough
					case reflect.Int64:
						fallthrough
					case reflect.Uint:
						fallthrough
					case reflect.Uint8:
						fallthrough
					case reflect.Uint16:
						fallthrough
					case reflect.Uint32:
						fallthrough
					case reflect.Uint64:
						fallthrough
					case reflect.Float32:
						fallthrough
					case reflect.Float64:
						parsed := d.parseMapKeyAsFloat(k, mapKeyKind)
						k = reflect.ValueOf(parsed)
					case reflect.String:
						mapKeyType = keyType
					default:
						panic("BSON map must have string or decimal keys. Got: " + outt.String())
					}

					k = k.Convert(mapKeyType)
				}
				out.SetMapIndex(k, e)
			}
		case reflect.Struct:
			if info, ok := fieldsMap[name]; ok {
				if info.Inline == nil {
					d.readElemTo(out.Field(info.Num), kind)
				} else {
					f, err := safeFieldByIndex(out, info.Inline)
					if err != nil {
						inlineParent := info.Inline[:len(info.Inline)-1]

						// fix parent
						var fParent reflect.Value
						if fParent, err = safeFieldByIndex(out, inlineParent); err != nil {
							d.dropElem(kind)
							continue
						}

						fParent.Set(getZeroField(out, inlineParent))

						// retry now
						f, err = safeFieldByIndex(out, info.Inline)
						if err == nil {
							d.readElemTo(f, kind)
						} else {
							d.dropElem(kind)
						}

					} else {
						d.readElemTo(f, kind)
					}
				}
			} else if inlineMap.IsValid() {
				if inlineMap.IsNil() {
					inlineMap.Set(reflect.MakeMap(inlineMap.Type()))
				}
				e := reflect.New(elemType).Elem()
				if d.readElemTo(e, kind) {
					inlineMap.SetMapIndex(reflect.ValueOf(name), e)
				}
			} else {
				d.dropElem(kind)
			}
		case reflect.Slice:
		}

		if d.i >= end {
			corrupted()
		}
	}
	d.i++ // '\x00'
	if d.i != end {
		corrupted()
	}
	d.docType = docType
}

func (decoder) parseMapKeyAsFloat(k reflect.Value, mapKeyKind reflect.Kind) float64 {
	parsed, err := strconv.ParseFloat(k.String(), 64)
	if err != nil {
		panic("Map key is defined to be a decimal type (" + mapKeyKind.String() + ") but got error " +
			err.Error())
	}

	return parsed
}

func (d *decoder) readArrayDocTo(out reflect.Value) {
	end := int(d.readInt32())
	end += d.i - 4
	if end <= d.i || end > len(d.in) || d.in[end-1] != '\x00' {
		corrupted()
	}

	array := out
	if out.Kind() == reflect.Ptr {
		p := reflect.New(out.Type())
		tmp := reflect.New(p.Elem().Type().Elem())
		out.Set(tmp)
		array = tmp.Elem()
	}

	i := 0
	l := array.Len()
	for d.in[d.i] != '\x00' {
		if i >= l {
			panic("Length mismatch on array field")
		}
		kind := d.readByte()
		for d.i < end && d.in[d.i] != '\x00' {
			d.i++
		}
		if d.i >= end {
			corrupted()
		}
		d.i++
		d.readElemTo(array.Index(i), kind)
		if d.i >= end {
			corrupted()
		}
		i++
	}
	if i != l {
		panic("Length mismatch on array field")
	}
	d.i++ // '\x00'
	if d.i != end {
		corrupted()
	}
}

func (d *decoder) readSliceDoc(t reflect.Type) interface{} {
	tmp := make([]reflect.Value, 0, 8)
	elemType := t.Elem()
	if elemType == typeRawDocElem {
		d.dropElem(ElementArray)
		return reflect.Zero(t).Interface()
	}
	if elemType == typeRaw {
		return d.readSliceOfRaw()
	}

	end := int(d.readInt32())
	end += d.i - 4
	if end <= d.i || end > len(d.in) || d.in[end-1] != '\x00' {
		corrupted()
	}
	for d.in[d.i] != '\x00' {
		kind := d.readByte()
		for d.i < end && d.in[d.i] != '\x00' {
			d.i++
		}
		if d.i >= end {
			corrupted()
		}
		d.i++
		e := reflect.New(elemType).Elem()
		if d.readElemTo(e, kind) {
			tmp = append(tmp, e)
		}
		if d.i >= end {
			corrupted()
		}
	}
	d.i++ // '\x00'
	if d.i != end {
		corrupted()
	}

	n := len(tmp)
	slice := reflect.MakeSlice(t, n, n)
	for i := 0; i != n; i++ {
		slice.Index(i).Set(tmp[i])
	}
	return slice.Interface()
}

func BSONElementSize(kind byte, offset int, buffer []byte) (int, error) {
	switch kind {
	case ElementFloat64: // Float64
		return 8, nil
	case ElementJavaScriptWithoutScope: // JavaScript without scope
		fallthrough
	case ElementSymbol: // Symbol
		fallthrough
	case ElementString: // UTF-8 string
		size, err := getSize(offset, buffer)
		if err != nil {
			return 0, err
		}
		if size < 1 {
			return 0, errors.New("String size can't be less then one byte")
		}
		size += 4
		if offset+size > len(buffer) {
			return 0, io.ErrUnexpectedEOF
		}
		if buffer[offset+size-1] != 0 {
			return 0, errors.New("Invalid string: non zero-terminated")
		}
		return size, nil
	case ElementArray: // Array
		fallthrough
	case ElementDocument: // Document
		size, err := getSize(offset, buffer)
		if err != nil {
			return 0, err
		}
		if size < 5 {
			return 0, errors.New("Declared document size is too small")
		}
		return size, nil
	case ElementBinary: // Binary
		size, err := getSize(offset, buffer)
		if err != nil {
			return 0, err
		}
		if size < 0 {
			return 0, errors.New("Binary data size can't be negative")
		}
		return size + 5, nil
	case Element06: // Undefined (obsolete, but still seen in the wild)
		return 0, nil
	case ElementObjectId: // ObjectId
		return 12, nil
	case ElementBool: // Bool
		return 1, nil
	case ElementDatetime: // Timestamp
		return 8, nil
	case ElementNil: // Nil
		return 0, nil
	case ElementRegEx: // RegEx
		end := offset
		for i := 0; i < 2; i++ {
			for end < len(buffer) && buffer[end] != '\x00' {
				end++
			}
			end++
		}
		if end > len(buffer) {
			return 0, io.ErrUnexpectedEOF
		}
		return end - offset, nil
	case ElementDBPointer: // DBPointer
		size, err := getSize(offset, buffer)
		if err != nil {
			return 0, err
		}
		if size < 1 {
			return 0, errors.New("String size can't be less then one byte")
		}
		return size + 12 + 4, nil
	case ElementJavaScriptWithScope: // JavaScript with scope
		size, err := getSize(offset, buffer)
		if err != nil {
			return 0, err
		}
		if size < 4+5+5 {
			return 0, errors.New("Declared document element is too small")
		}
		return size, nil
	case ElementInt32: // Int32
		return 4, nil
	case ElementTimestamp: // Mongo-specific timestamp
		return 8, nil
	case ElementInt64: // Int64
		return 8, nil
	case ElementDecimal128: // Decimal128
		return 16, nil
	case ElementMaxKey: // Max key
		return 0, nil
	case ElementMinKey: // Min key
		return 0, nil
	default:
		return 0, errors.New(fmt.Sprintf("Unknown element kind (0x%02X)", kind))
	}
}

func (d *decoder) readRaw(kind byte) Raw {
	size, err := BSONElementSize(kind, d.i, d.in)
	if err != nil {
		corrupted()
	}
	if d.i+size > len(d.in) {
		corrupted()
	}
	d.i += size
	return Raw{
		Kind: kind,
		Data: d.in[d.i-size : d.i : d.i],
	}
}

func (d *decoder) readSliceOfRaw() interface{} {
	tmp := make([]Raw, 0, 8)
	end := int(d.readInt32())
	end += d.i - 4
	if end <= d.i || end > len(d.in) || d.in[end-1] != '\x00' {
		corrupted()
	}
	for d.in[d.i] != '\x00' {
		kind := d.readByte()
		for d.i < end && d.in[d.i] != '\x00' {
			d.i++
		}
		if d.i >= end {
			corrupted()
		}
		d.i++
		e := d.readRaw(kind)
		tmp = append(tmp, e)
		if d.i >= end {
			corrupted()
		}
	}
	d.i++ // '\x00'
	if d.i != end {
		corrupted()
	}
	return tmp
}

var typeSlice = reflect.TypeOf([]interface{}{})
var typeIface = typeSlice.Elem()

func (d *decoder) readDocElems(typ reflect.Type) reflect.Value {
	docType := d.docType
	d.docType = typ
	slice := make([]DocElem, 0, 8)
	d.readDocWith(func(kind byte, name string) {
		e := DocElem{Name: name}
		v := reflect.ValueOf(&e.Value)
		if d.readElemTo(v.Elem(), kind) {
			slice = append(slice, e)
		}
	})
	slicev := reflect.New(typ).Elem()
	slicev.Set(reflect.ValueOf(slice))
	d.docType = docType
	return slicev
}

func (d *decoder) readRawDocElems(typ reflect.Type) reflect.Value {
	docType := d.docType
	d.docType = typ
	slice := make([]RawDocElem, 0, 8)
	d.readDocWith(func(kind byte, name string) {
		e := RawDocElem{Name: name, Value: d.readRaw(kind)}
		slice = append(slice, e)
	})
	slicev := reflect.New(typ).Elem()
	slicev.Set(reflect.ValueOf(slice))
	d.docType = docType
	return slicev
}

func (d *decoder) readDocWith(f func(kind byte, name string)) {
	end := int(d.readInt32())
	end += d.i - 4
	if end <= d.i || end > len(d.in) || d.in[end-1] != '\x00' {
		corrupted()
	}
	for d.in[d.i] != '\x00' {
		kind := d.readByte()
		name := d.readCStr()
		if d.i >= end {
			corrupted()
		}
		f(kind, name)
		if d.i >= end {
			corrupted()
		}
	}
	d.i++ // '\x00'
	if d.i != end {
		corrupted()
	}
}

// --------------------------------------------------------------------------
// Unmarshaling of individual elements within a document.
func (d *decoder) dropElem(kind byte) {
	size, err := BSONElementSize(kind, d.i, d.in)
	if err != nil {
		corrupted()
	}
	if d.i+size > len(d.in) {
		corrupted()
	}
	d.i += size
}

// Attempt to decode an element from the document and put it into out.
// If the types are not compatible, the returned ok value will be
// false and out will be unchanged.
func (d *decoder) readElemTo(out reflect.Value, kind byte) (good bool) {
	outt := out.Type()

	if outt == typeRaw {
		out.Set(reflect.ValueOf(d.readRaw(kind)))
		return true
	}

	if outt == typeRawPtr {
		raw := d.readRaw(kind)
		out.Set(reflect.ValueOf(&raw))
		return true
	}

	if kind == ElementDocument {
		// Delegate unmarshaling of documents.
		outt := out.Type()
		outk := out.Kind()
		switch outk {
		case reflect.Interface, reflect.Ptr, reflect.Struct, reflect.Map:
			d.readDocTo(out)
			return true
		}
		if setterStyle(outt) != setterNone {
			d.readDocTo(out)
			return true
		}
		if outk == reflect.Slice {
			switch outt.Elem() {
			case typeDocElem:
				out.Set(d.readDocElems(outt))
			case typeRawDocElem:
				out.Set(d.readRawDocElems(outt))
			default:
				d.dropElem(kind)
			}
			return true
		}
		d.dropElem(kind)
		return true
	}

	if setter := getSetter(outt, out); setter != nil {
		err := setter.SetBSON(d.readRaw(kind))
		if err == ErrSetZero {
			out.Set(reflect.Zero(outt))
			return true
		}
		if err == nil {
			return true
		}
		if _, ok := err.(*TypeError); !ok {
			panic(err)
		}
		return false
	}

	var in interface{}

	switch kind {
	case ElementFloat64:
		in = d.readFloat64()
	case ElementString:
		in = d.readStr()
	case ElementDocument:
		panic("Can't happen. Handled above.")
	case ElementArray:
		outt := out.Type()
		if setterStyle(outt) != setterNone {
			// Skip the value so its data is handed to the setter below.
			d.dropElem(kind)
			break
		}
		for outt.Kind() == reflect.Ptr {
			outt = outt.Elem()
		}
		switch outt.Kind() {
		case reflect.Array:
			d.readArrayDocTo(out)
			return true
		case reflect.Slice:
			in = d.readSliceDoc(outt)
		default:
			in = d.readSliceDoc(typeSlice)
		}
	case ElementBinary:
		b := d.readBinary()
		if b.Kind == BinaryGeneric || b.Kind == BinaryBinaryOld {
			in = b.Data
		} else {
			in = b
		}
	case Element06: // Undefined (obsolete, but still seen in the wild)
		in = Undefined
	case ElementObjectId:
		in = ObjectId(d.readBytes(12))
	case ElementBool:
		in = d.readBool()
	case ElementDatetime: // Timestamp
		// MongoDB handles timestamps as milliseconds.
		i := d.readInt64()
		if i == -62135596800000 {
			in = time.Time{} // In UTC for convenience.
		} else {
			in = time.Unix(i/1e3, i%1e3*1e6).UTC()
		}
	case ElementNil:
		in = nil
	case ElementRegEx:
		in = d.readRegEx()
	case ElementDBPointer:
		in = DBPointer{Namespace: d.readStr(), Id: ObjectId(d.readBytes(12))}
	case ElementJavaScriptWithoutScope:
		in = JavaScript{Code: d.readStr()}
	case ElementSymbol:
		in = Symbol(d.readStr())
	case ElementJavaScriptWithScope:
		start := d.i
		l := int(d.readInt32())
		js := JavaScript{d.readStr(), make(M)}
		d.readDocTo(reflect.ValueOf(js.Scope))
		if d.i != start+l {
			corrupted()
		}
		in = js
	case ElementInt32:
		in = int(d.readInt32())
	case ElementTimestamp: // Mongo-specific timestamp
		in = MongoTimestamp(d.readInt64())
	case ElementInt64:
		switch out.Type() {
		case typeTimeDuration:
			in = time.Duration(time.Duration(d.readInt64()) * time.Millisecond)
		default:
			in = d.readInt64()
		}
	case ElementDecimal128:
		in = Decimal128{
			l: uint64(d.readInt64()),
			h: uint64(d.readInt64()),
		}
	case ElementMaxKey:
		in = MaxKey
	case ElementMinKey:
		in = MinKey
	default:
		panic(fmt.Sprintf("Unknown element kind (0x%02X)", kind))
	}

	if in == nil {
		out.Set(reflect.Zero(outt))
		return true
	}

	outk := outt.Kind()

	// Dereference and initialize pointer if necessary.
	first := true
	for outk == reflect.Ptr {
		if !out.IsNil() {
			out = out.Elem()
		} else {
			elem := reflect.New(outt.Elem())
			if first {
				// Only set if value is compatible.
				first = false
				defer func(out, elem reflect.Value) {
					if good {
						out.Set(elem)
					}
				}(out, elem)
			} else {
				out.Set(elem)
			}
			out = elem
		}
		outt = out.Type()
		outk = outt.Kind()
	}

	inv := reflect.ValueOf(in)
	if outt == inv.Type() {
		out.Set(inv)
		return true
	}

	switch outk {
	case reflect.Interface:
		out.Set(inv)
		return true
	case reflect.String:
		switch inv.Kind() {
		case reflect.String:
			out.SetString(inv.String())
			return true
		case reflect.Slice:
			if b, ok := in.([]byte); ok {
				out.SetString(string(b))
				return true
			}
		case reflect.Int, reflect.Int64:
			if outt == typeJSONNumber {
				out.SetString(strconv.FormatInt(inv.Int(), 10))
				return true
			}
		case reflect.Float64:
			if outt == typeJSONNumber {
				out.SetString(strconv.FormatFloat(inv.Float(), 'f', -1, 64))
				return true
			}
		}
	case reflect.Slice, reflect.Array:
		// Remember, array (0x04) slices are built with the correct
		// element type.  If we are here, must be a cross BSON kind
		// conversion (e.g. 0x05 unmarshalling on string).
		if outt.Elem().Kind() != reflect.Uint8 {
			break
		}
		switch inv.Kind() {
		case reflect.String:
			slice := []byte(inv.String())
			out.Set(reflect.ValueOf(slice))
			return true
		case reflect.Slice:
			switch outt.Kind() {
			case reflect.Array:
				reflect.Copy(out, inv)
			case reflect.Slice:
				out.SetBytes(inv.Bytes())
			}
			return true
		}
	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
		switch inv.Kind() {
		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
			out.SetInt(inv.Int())
			return true
		case reflect.Float32, reflect.Float64:
			out.SetInt(int64(inv.Float()))
			return true
		case reflect.Bool:
			if inv.Bool() {
				out.SetInt(1)
			} else {
				out.SetInt(0)
			}
			return true
		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
			panic("can't happen: no uint types in BSON (!?)")
		}
	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
		switch inv.Kind() {
		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
			out.SetUint(uint64(inv.Int()))
			return true
		case reflect.Float32, reflect.Float64:
			out.SetUint(uint64(inv.Float()))
			return true
		case reflect.Bool:
			if inv.Bool() {
				out.SetUint(1)
			} else {
				out.SetUint(0)
			}
			return true
		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
			panic("Can't happen. No uint types in BSON.")
		}
	case reflect.Float32, reflect.Float64:
		switch inv.Kind() {
		case reflect.Float32, reflect.Float64:
			out.SetFloat(inv.Float())
			return true
		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
			out.SetFloat(float64(inv.Int()))
			return true
		case reflect.Bool:
			if inv.Bool() {
				out.SetFloat(1)
			} else {
				out.SetFloat(0)
			}
			return true
		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
			panic("Can't happen. No uint types in BSON?")
		}
	case reflect.Bool:
		switch inv.Kind() {
		case reflect.Bool:
			out.SetBool(inv.Bool())
			return true
		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
			out.SetBool(inv.Int() != 0)
			return true
		case reflect.Float32, reflect.Float64:
			out.SetBool(inv.Float() != 0)
			return true
		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
			panic("Can't happen. No uint types in BSON?")
		}
	case reflect.Struct:
		if outt == typeURL && inv.Kind() == reflect.String {
			u, err := url.Parse(inv.String())
			if err != nil {
				panic(err)
			}
			out.Set(reflect.ValueOf(u).Elem())
			return true
		}
		if outt == typeBinary {
			if b, ok := in.([]byte); ok {
				out.Set(reflect.ValueOf(Binary{Data: b}))
				return true
			}
		}
	}

	return false
}

// --------------------------------------------------------------------------
// Parsers of basic types.

func (d *decoder) readRegEx() RegEx {
	re := RegEx{}
	re.Pattern = d.readCStr()
	re.Options = d.readCStr()
	return re
}

func (d *decoder) readBinary() Binary {
	l := d.readInt32()
	b := Binary{}
	b.Kind = d.readByte()
	if b.Kind == BinaryBinaryOld && l > 4 {
		// Weird obsolete format with redundant length.
		rl := d.readInt32()
		if rl != l-4 {
			corrupted()
		}
		l = rl
	}
	b.Data = d.readBytes(l)
	return b
}

func (d *decoder) readStr() string {
	l := d.readInt32()
	b := d.readBytes(l - 1)
	if d.readByte() != '\x00' {
		corrupted()
	}
	return string(b)
}

func (d *decoder) readCStr() string {
	start := d.i
	end := start
	l := len(d.in)
	for ; end != l; end++ {
		if d.in[end] == '\x00' {
			break
		}
	}
	d.i = end + 1
	if d.i > l {
		corrupted()
	}
	return string(d.in[start:end])
}

func (d *decoder) readBool() bool {
	b := d.readByte()
	if b == 0 {
		return false
	}
	if b == 1 {
		return true
	}
	panic(fmt.Sprintf("encoded boolean must be 1 or 0, found %d", b))
}

func (d *decoder) readFloat64() float64 {
	return math.Float64frombits(uint64(d.readInt64()))
}

func (d *decoder) readInt32() int32 {
	b := d.readBytes(4)
	return int32((uint32(b[0]) << 0) |
		(uint32(b[1]) << 8) |
		(uint32(b[2]) << 16) |
		(uint32(b[3]) << 24))
}

func getSize(offset int, b []byte) (int, error) {
	if offset+4 > len(b) {
		return 0, io.ErrUnexpectedEOF
	}
	return int((uint32(b[offset]) << 0) |
		(uint32(b[offset+1]) << 8) |
		(uint32(b[offset+2]) << 16) |
		(uint32(b[offset+3]) << 24)), nil
}

func (d *decoder) readInt64() int64 {
	b := d.readBytes(8)
	return int64((uint64(b[0]) << 0) |
		(uint64(b[1]) << 8) |
		(uint64(b[2]) << 16) |
		(uint64(b[3]) << 24) |
		(uint64(b[4]) << 32) |
		(uint64(b[5]) << 40) |
		(uint64(b[6]) << 48) |
		(uint64(b[7]) << 56))
}

func (d *decoder) readByte() byte {
	i := d.i
	d.i++
	if d.i > len(d.in) {
		corrupted()
	}
	return d.in[i]
}

func (d *decoder) readBytes(length int32) []byte {
	if length < 0 {
		corrupted()
	}
	start := d.i
	d.i += int(length)
	if d.i < start || d.i > len(d.in) {
		corrupted()
	}
	return d.in[start : start+int(length) : start+int(length)]
}