123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089 |
- // Copyright 2010 The Go Authors. All rights reserved.
- // Use of this source code is governed by a BSD-style
- // license that can be found in the LICENSE file.
- // Represents JSON data structure using native Go types: booleans, floats,
- // strings, arrays, and maps.
- package json
- import (
- "bytes"
- "encoding"
- "encoding/base64"
- "errors"
- "fmt"
- "reflect"
- "runtime"
- "strconv"
- "unicode"
- "unicode/utf16"
- "unicode/utf8"
- )
- // Unmarshal parses the JSON-encoded data and stores the result
- // in the value pointed to by v.
- //
- // Unmarshal uses the inverse of the encodings that
- // Marshal uses, allocating maps, slices, and pointers as necessary,
- // with the following additional rules:
- //
- // To unmarshal JSON into a pointer, Unmarshal first handles the case of
- // the JSON being the JSON literal null. In that case, Unmarshal sets
- // the pointer to nil. Otherwise, Unmarshal unmarshals the JSON into
- // the value pointed at by the pointer. If the pointer is nil, Unmarshal
- // allocates a new value for it to point to.
- //
- // To unmarshal JSON into a struct, Unmarshal matches incoming object
- // keys to the keys used by Marshal (either the struct field name or its tag),
- // preferring an exact match but also accepting a case-insensitive match.
- //
- // To unmarshal JSON into an interface value,
- // Unmarshal stores one of these in the interface value:
- //
- // bool, for JSON booleans
- // float64, for JSON numbers
- // string, for JSON strings
- // []interface{}, for JSON arrays
- // map[string]interface{}, for JSON objects
- // nil for JSON null
- //
- // If a JSON value is not appropriate for a given target type,
- // or if a JSON number overflows the target type, Unmarshal
- // skips that field and completes the unmarshalling as best it can.
- // If no more serious errors are encountered, Unmarshal returns
- // an UnmarshalTypeError describing the earliest such error.
- //
- // The JSON null value unmarshals into an interface, map, pointer, or slice
- // by setting that Go value to nil. Because null is often used in JSON to mean
- // ``not present,'' unmarshaling a JSON null into any other Go type has no effect
- // on the value and produces no error.
- //
- // When unmarshaling quoted strings, invalid UTF-8 or
- // invalid UTF-16 surrogate pairs are not treated as an error.
- // Instead, they are replaced by the Unicode replacement
- // character U+FFFD.
- //
- func Unmarshal(data []byte, v interface{}) error {
- // Check for well-formedness.
- // Avoids filling out half a data structure
- // before discovering a JSON syntax error.
- var d decodeState
- err := checkValid(data, &d.scan)
- if err != nil {
- return err
- }
- d.init(data)
- return d.unmarshal(v)
- }
- // Unmarshaler is the interface implemented by objects
- // that can unmarshal a JSON description of themselves.
- // The input can be assumed to be a valid encoding of
- // a JSON value. UnmarshalJSON must copy the JSON data
- // if it wishes to retain the data after returning.
- type Unmarshaler interface {
- UnmarshalJSON([]byte) error
- }
- // An UnmarshalTypeError describes a JSON value that was
- // not appropriate for a value of a specific Go type.
- type UnmarshalTypeError struct {
- Value string // description of JSON value - "bool", "array", "number -5"
- Type reflect.Type // type of Go value it could not be assigned to
- }
- func (e *UnmarshalTypeError) Error() string {
- return "json: cannot unmarshal " + e.Value + " into Go value of type " + e.Type.String()
- }
- // An UnmarshalFieldError describes a JSON object key that
- // led to an unexported (and therefore unwritable) struct field.
- // (No longer used; kept for compatibility.)
- type UnmarshalFieldError struct {
- Key string
- Type reflect.Type
- Field reflect.StructField
- }
- func (e *UnmarshalFieldError) Error() string {
- return "json: cannot unmarshal object key " + strconv.Quote(e.Key) + " into unexported field " + e.Field.Name + " of type " + e.Type.String()
- }
- // An InvalidUnmarshalError describes an invalid argument passed to Unmarshal.
- // (The argument to Unmarshal must be a non-nil pointer.)
- type InvalidUnmarshalError struct {
- Type reflect.Type
- }
- func (e *InvalidUnmarshalError) Error() string {
- if e.Type == nil {
- return "json: Unmarshal(nil)"
- }
- if e.Type.Kind() != reflect.Ptr {
- return "json: Unmarshal(non-pointer " + e.Type.String() + ")"
- }
- return "json: Unmarshal(nil " + e.Type.String() + ")"
- }
- func (d *decodeState) unmarshal(v interface{}) (err error) {
- defer func() {
- if r := recover(); r != nil {
- if _, ok := r.(runtime.Error); ok {
- panic(r)
- }
- err = r.(error)
- }
- }()
- rv := reflect.ValueOf(v)
- if rv.Kind() != reflect.Ptr || rv.IsNil() {
- return &InvalidUnmarshalError{reflect.TypeOf(v)}
- }
- d.scan.Reset()
- // We decode rv not rv.Elem because the Unmarshaler interface
- // test must be applied at the top level of the value.
- d.value(rv)
- return d.savedError
- }
- // A Number represents a JSON number literal.
- type Number string
- // String returns the literal text of the number.
- func (n Number) String() string { return string(n) }
- // Float64 returns the number as a float64.
- func (n Number) Float64() (float64, error) {
- return strconv.ParseFloat(string(n), 64)
- }
- // Int64 returns the number as an int64.
- func (n Number) Int64() (int64, error) {
- return strconv.ParseInt(string(n), 10, 64)
- }
- // decodeState represents the state while decoding a JSON value.
- type decodeState struct {
- data []byte
- off int // read offset in data
- scan Scanner
- nextscan Scanner // for calls to NextValue
- savedError error
- useNumber bool
- }
- // errPhase is used for errors that should not happen unless
- // there is a bug in the JSON decoder or something is editing
- // the data slice while the decoder executes.
- var errPhase = errors.New("JSON decoder out of sync - data changing underfoot?")
- func (d *decodeState) init(data []byte) *decodeState {
- d.data = data
- d.off = 0
- d.savedError = nil
- return d
- }
- // error aborts the decoding by panicking with err.
- func (d *decodeState) error(err error) {
- panic(err)
- }
- // saveError saves the first err it is called with,
- // for reporting at the end of the unmarshal.
- func (d *decodeState) saveError(err error) {
- if d.savedError == nil {
- d.savedError = err
- }
- }
- // next cuts off and returns the next full JSON value in d.data[d.off:].
- // The next value is known to be an object or array, not a literal.
- func (d *decodeState) next() []byte {
- c := d.data[d.off]
- item, rest, err := NextValue(d.data[d.off:], &d.nextscan)
- if err != nil {
- d.error(err)
- }
- d.off = len(d.data) - len(rest)
- // Our scanner has seen the opening brace/bracket
- // and thinks we're still in the middle of the object.
- // invent a closing brace/bracket to get it out.
- if c == '{' {
- d.scan.Step(&d.scan, '}')
- } else {
- d.scan.Step(&d.scan, ']')
- }
- return item
- }
- // scanWhile processes bytes in d.data[d.off:] until it
- // receives a scan code not equal to op.
- // It updates d.off and returns the new scan code.
- func (d *decodeState) scanWhile(op int) int {
- var newOp int
- for {
- if d.off >= len(d.data) {
- newOp = d.scan.EOF()
- d.off = len(d.data) + 1 // mark processed EOF with len+1
- } else {
- c := int(d.data[d.off])
- d.off++
- newOp = d.scan.Step(&d.scan, c)
- }
- if newOp != op {
- break
- }
- }
- return newOp
- }
- // value decodes a JSON value from d.data[d.off:] into the value.
- // it updates d.off to point past the decoded value.
- func (d *decodeState) value(v reflect.Value) {
- if !v.IsValid() {
- _, rest, err := NextValue(d.data[d.off:], &d.nextscan)
- if err != nil {
- d.error(err)
- }
- d.off = len(d.data) - len(rest)
- // d.scan thinks we're still at the beginning of the item.
- // Feed in an empty string - the shortest, simplest value -
- // so that it knows we got to the end of the value.
- if d.scan.redo {
- // rewind.
- d.scan.redo = false
- d.scan.Step = stateBeginValue
- }
- d.scan.Step(&d.scan, '"')
- d.scan.Step(&d.scan, '"')
- n := len(d.scan.parseState)
- if n > 0 && d.scan.parseState[n-1] == parseObjectKey {
- // d.scan thinks we just read an object key; finish the object
- d.scan.Step(&d.scan, ':')
- d.scan.Step(&d.scan, '"')
- d.scan.Step(&d.scan, '"')
- d.scan.Step(&d.scan, '}')
- }
- return
- }
- switch op := d.scanWhile(ScanSkipSpace); op {
- default:
- d.error(errPhase)
- case ScanBeginArray:
- d.array(v)
- case ScanBeginObject:
- d.object(v)
- case ScanBeginLiteral:
- d.literal(v)
- }
- }
- type unquotedValue struct{}
- // valueQuoted is like value but decodes a
- // quoted string literal or literal null into an interface value.
- // If it finds anything other than a quoted string literal or null,
- // valueQuoted returns unquotedValue{}.
- func (d *decodeState) valueQuoted() interface{} {
- switch op := d.scanWhile(ScanSkipSpace); op {
- default:
- d.error(errPhase)
- case ScanBeginArray:
- d.array(reflect.Value{})
- case ScanBeginObject:
- d.object(reflect.Value{})
- case ScanBeginLiteral:
- switch v := d.literalInterface().(type) {
- case nil, string:
- return v
- }
- }
- return unquotedValue{}
- }
- // indirect walks down v allocating pointers as needed,
- // until it gets to a non-pointer.
- // if it encounters an Unmarshaler, indirect stops and returns that.
- // if decodingNull is true, indirect stops at the last pointer so it can be set to nil.
- func (d *decodeState) indirect(v reflect.Value, decodingNull bool) (Unmarshaler, encoding.TextUnmarshaler, reflect.Value) {
- // If v is a named type and is addressable,
- // start with its address, so that if the type has pointer methods,
- // we find them.
- if v.Kind() != reflect.Ptr && v.Type().Name() != "" && v.CanAddr() {
- v = v.Addr()
- }
- for {
- // Load value from interface, but only if the result will be
- // usefully addressable.
- if v.Kind() == reflect.Interface && !v.IsNil() {
- e := v.Elem()
- if e.Kind() == reflect.Ptr && !e.IsNil() && (!decodingNull || e.Elem().Kind() == reflect.Ptr) {
- v = e
- continue
- }
- }
- if v.Kind() != reflect.Ptr {
- break
- }
- if v.Elem().Kind() != reflect.Ptr && decodingNull && v.CanSet() {
- break
- }
- if v.IsNil() {
- v.Set(reflect.New(v.Type().Elem()))
- }
- if v.Type().NumMethod() > 0 {
- if u, ok := v.Interface().(Unmarshaler); ok {
- return u, nil, reflect.Value{}
- }
- if u, ok := v.Interface().(encoding.TextUnmarshaler); ok {
- return nil, u, reflect.Value{}
- }
- }
- v = v.Elem()
- }
- return nil, nil, v
- }
- // array consumes an array from d.data[d.off-1:], decoding into the value v.
- // the first byte of the array ('[') has been read already.
- func (d *decodeState) array(v reflect.Value) {
- // Check for unmarshaler.
- u, ut, pv := d.indirect(v, false)
- if u != nil {
- d.off--
- err := u.UnmarshalJSON(d.next())
- if err != nil {
- d.error(err)
- }
- return
- }
- if ut != nil {
- d.saveError(&UnmarshalTypeError{"array", v.Type()})
- d.off--
- d.next()
- return
- }
- v = pv
- // Check type of target.
- switch v.Kind() {
- case reflect.Interface:
- if v.NumMethod() == 0 {
- // Decoding into nil interface? Switch to non-reflect code.
- v.Set(reflect.ValueOf(d.arrayInterface()))
- return
- }
- // Otherwise it's invalid.
- fallthrough
- default:
- d.saveError(&UnmarshalTypeError{"array", v.Type()})
- d.off--
- d.next()
- return
- case reflect.Array:
- case reflect.Slice:
- break
- }
- i := 0
- for {
- // Look ahead for ] - can only happen on first iteration.
- op := d.scanWhile(ScanSkipSpace)
- if op == ScanEndArray {
- break
- }
- // Back up so d.value can have the byte we just read.
- d.off--
- d.scan.undo(op)
- // Get element of array, growing if necessary.
- if v.Kind() == reflect.Slice {
- // Grow slice if necessary
- if i >= v.Cap() {
- newcap := v.Cap() + v.Cap()/2
- if newcap < 4 {
- newcap = 4
- }
- newv := reflect.MakeSlice(v.Type(), v.Len(), newcap)
- reflect.Copy(newv, v)
- v.Set(newv)
- }
- if i >= v.Len() {
- v.SetLen(i + 1)
- }
- }
- if i < v.Len() {
- // Decode into element.
- d.value(v.Index(i))
- } else {
- // Ran out of fixed array: skip.
- d.value(reflect.Value{})
- }
- i++
- // Next token must be , or ].
- op = d.scanWhile(ScanSkipSpace)
- if op == ScanEndArray {
- break
- }
- if op != ScanArrayValue {
- d.error(errPhase)
- }
- }
- if i < v.Len() {
- if v.Kind() == reflect.Array {
- // Array. Zero the rest.
- z := reflect.Zero(v.Type().Elem())
- for ; i < v.Len(); i++ {
- v.Index(i).Set(z)
- }
- } else {
- v.SetLen(i)
- }
- }
- if i == 0 && v.Kind() == reflect.Slice {
- v.Set(reflect.MakeSlice(v.Type(), 0, 0))
- }
- }
- var nullLiteral = []byte("null")
- // object consumes an object from d.data[d.off-1:], decoding into the value v.
- // the first byte ('{') of the object has been read already.
- func (d *decodeState) object(v reflect.Value) {
- // Check for unmarshaler.
- u, ut, pv := d.indirect(v, false)
- if u != nil {
- d.off--
- err := u.UnmarshalJSON(d.next())
- if err != nil {
- d.error(err)
- }
- return
- }
- if ut != nil {
- d.saveError(&UnmarshalTypeError{"object", v.Type()})
- d.off--
- d.next() // skip over { } in input
- return
- }
- v = pv
- // Decoding into nil interface? Switch to non-reflect code.
- if v.Kind() == reflect.Interface && v.NumMethod() == 0 {
- v.Set(reflect.ValueOf(d.objectInterface()))
- return
- }
- // Check type of target: struct or map[string]T
- switch v.Kind() {
- case reflect.Map:
- // map must have string kind
- t := v.Type()
- if t.Key().Kind() != reflect.String {
- d.saveError(&UnmarshalTypeError{"object", v.Type()})
- d.off--
- d.next() // skip over { } in input
- return
- }
- if v.IsNil() {
- v.Set(reflect.MakeMap(t))
- }
- case reflect.Struct:
- default:
- d.saveError(&UnmarshalTypeError{"object", v.Type()})
- d.off--
- d.next() // skip over { } in input
- return
- }
- var mapElem reflect.Value
- for {
- // Read opening " of string key or closing }.
- op := d.scanWhile(ScanSkipSpace)
- if op == ScanEndObject {
- // closing } - can only happen on first iteration.
- break
- }
- if op != ScanBeginLiteral {
- d.error(errPhase)
- }
- // Read key.
- start := d.off - 1
- op = d.scanWhile(ScanContinue)
- item := d.data[start : d.off-1]
- key, ok := UnquoteBytes(item)
- if !ok {
- d.error(errPhase)
- }
- // Figure out field corresponding to key.
- var subv reflect.Value
- destring := false // whether the value is wrapped in a string to be decoded first
- if v.Kind() == reflect.Map {
- elemType := v.Type().Elem()
- if !mapElem.IsValid() {
- mapElem = reflect.New(elemType).Elem()
- } else {
- mapElem.Set(reflect.Zero(elemType))
- }
- subv = mapElem
- } else {
- var f *field
- fields := cachedTypeFields(v.Type())
- for i := range fields {
- ff := &fields[i]
- if bytes.Equal(ff.nameBytes, key) {
- f = ff
- break
- }
- if f == nil && ff.equalFold(ff.nameBytes, key) {
- f = ff
- }
- }
- if f != nil {
- subv = v
- destring = f.quoted
- for _, i := range f.index {
- if subv.Kind() == reflect.Ptr {
- if subv.IsNil() {
- subv.Set(reflect.New(subv.Type().Elem()))
- }
- subv = subv.Elem()
- }
- subv = subv.Field(i)
- }
- }
- }
- // Read : before value.
- if op == ScanSkipSpace {
- op = d.scanWhile(ScanSkipSpace)
- }
- if op != ScanObjectKey {
- d.error(errPhase)
- }
- // Read value.
- if destring {
- switch qv := d.valueQuoted().(type) {
- case nil:
- d.literalStore(nullLiteral, subv, false)
- case string:
- d.literalStore([]byte(qv), subv, true)
- default:
- d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal unquoted value into %v", item, v.Type()))
- }
- } else {
- d.value(subv)
- }
- // Write value back to map;
- // if using struct, subv points into struct already.
- if v.Kind() == reflect.Map {
- kv := reflect.ValueOf(key).Convert(v.Type().Key())
- v.SetMapIndex(kv, subv)
- }
- // Next token must be , or }.
- op = d.scanWhile(ScanSkipSpace)
- if op == ScanEndObject {
- break
- }
- if op != ScanObjectValue {
- d.error(errPhase)
- }
- }
- }
- // literal consumes a literal from d.data[d.off-1:], decoding into the value v.
- // The first byte of the literal has been read already
- // (that's how the caller knows it's a literal).
- func (d *decodeState) literal(v reflect.Value) {
- // All bytes inside literal return scanContinue op code.
- start := d.off - 1
- op := d.scanWhile(ScanContinue)
- // Scan read one byte too far; back up.
- d.off--
- d.scan.undo(op)
- d.literalStore(d.data[start:d.off], v, false)
- }
- // convertNumber converts the number literal s to a float64 or a Number
- // depending on the setting of d.useNumber.
- func (d *decodeState) convertNumber(s string) (interface{}, error) {
- if d.useNumber {
- return Number(s), nil
- }
- f, err := strconv.ParseFloat(s, 64)
- if err != nil {
- return nil, &UnmarshalTypeError{"number " + s, reflect.TypeOf(0.0)}
- }
- return f, nil
- }
- var numberType = reflect.TypeOf(Number(""))
- // literalStore decodes a literal stored in item into v.
- //
- // fromQuoted indicates whether this literal came from unwrapping a
- // string from the ",string" struct tag option. this is used only to
- // produce more helpful error messages.
- func (d *decodeState) literalStore(item []byte, v reflect.Value, fromQuoted bool) {
- // Check for unmarshaler.
- if len(item) == 0 {
- //Empty string given
- d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
- return
- }
- wantptr := item[0] == 'n' // null
- u, ut, pv := d.indirect(v, wantptr)
- if u != nil {
- err := u.UnmarshalJSON(item)
- if err != nil {
- d.error(err)
- }
- return
- }
- if ut != nil {
- if item[0] != '"' {
- if fromQuoted {
- d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
- } else {
- d.saveError(&UnmarshalTypeError{"string", v.Type()})
- }
- }
- s, ok := UnquoteBytes(item)
- if !ok {
- if fromQuoted {
- d.error(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
- } else {
- d.error(errPhase)
- }
- }
- err := ut.UnmarshalText(s)
- if err != nil {
- d.error(err)
- }
- return
- }
- v = pv
- switch c := item[0]; c {
- case 'n': // null
- switch v.Kind() {
- case reflect.Interface, reflect.Ptr, reflect.Map, reflect.Slice:
- v.Set(reflect.Zero(v.Type()))
- // otherwise, ignore null for primitives/string
- }
- case 't', 'f': // true, false
- value := c == 't'
- switch v.Kind() {
- default:
- if fromQuoted {
- d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
- } else {
- d.saveError(&UnmarshalTypeError{"bool", v.Type()})
- }
- case reflect.Bool:
- v.SetBool(value)
- case reflect.Interface:
- if v.NumMethod() == 0 {
- v.Set(reflect.ValueOf(value))
- } else {
- d.saveError(&UnmarshalTypeError{"bool", v.Type()})
- }
- }
- case '"': // string
- s, ok := UnquoteBytes(item)
- if !ok {
- if fromQuoted {
- d.error(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
- } else {
- d.error(errPhase)
- }
- }
- switch v.Kind() {
- default:
- d.saveError(&UnmarshalTypeError{"string", v.Type()})
- case reflect.Slice:
- if v.Type() != byteSliceType {
- d.saveError(&UnmarshalTypeError{"string", v.Type()})
- break
- }
- b := make([]byte, base64.StdEncoding.DecodedLen(len(s)))
- n, err := base64.StdEncoding.Decode(b, s)
- if err != nil {
- d.saveError(err)
- break
- }
- v.Set(reflect.ValueOf(b[0:n]))
- case reflect.String:
- v.SetString(string(s))
- case reflect.Interface:
- if v.NumMethod() == 0 {
- v.Set(reflect.ValueOf(string(s)))
- } else {
- d.saveError(&UnmarshalTypeError{"string", v.Type()})
- }
- }
- default: // number
- if c != '-' && (c < '0' || c > '9') {
- if fromQuoted {
- d.error(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
- } else {
- d.error(errPhase)
- }
- }
- s := string(item)
- switch v.Kind() {
- default:
- if v.Kind() == reflect.String && v.Type() == numberType {
- v.SetString(s)
- break
- }
- if fromQuoted {
- d.error(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
- } else {
- d.error(&UnmarshalTypeError{"number", v.Type()})
- }
- case reflect.Interface:
- n, err := d.convertNumber(s)
- if err != nil {
- d.saveError(err)
- break
- }
- if v.NumMethod() != 0 {
- d.saveError(&UnmarshalTypeError{"number", v.Type()})
- break
- }
- v.Set(reflect.ValueOf(n))
- case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
- n, err := strconv.ParseInt(s, 10, 64)
- if err != nil || v.OverflowInt(n) {
- d.saveError(&UnmarshalTypeError{"number " + s, v.Type()})
- break
- }
- v.SetInt(n)
- case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
- n, err := strconv.ParseUint(s, 10, 64)
- if err != nil || v.OverflowUint(n) {
- d.saveError(&UnmarshalTypeError{"number " + s, v.Type()})
- break
- }
- v.SetUint(n)
- case reflect.Float32, reflect.Float64:
- n, err := strconv.ParseFloat(s, v.Type().Bits())
- if err != nil || v.OverflowFloat(n) {
- d.saveError(&UnmarshalTypeError{"number " + s, v.Type()})
- break
- }
- v.SetFloat(n)
- }
- }
- }
- // The xxxInterface routines build up a value to be stored
- // in an empty interface. They are not strictly necessary,
- // but they avoid the weight of reflection in this common case.
- // valueInterface is like value but returns interface{}
- func (d *decodeState) valueInterface() interface{} {
- switch d.scanWhile(ScanSkipSpace) {
- default:
- d.error(errPhase)
- panic("unreachable")
- case ScanBeginArray:
- return d.arrayInterface()
- case ScanBeginObject:
- return d.objectInterface()
- case ScanBeginLiteral:
- return d.literalInterface()
- }
- }
- // arrayInterface is like array but returns []interface{}.
- func (d *decodeState) arrayInterface() []interface{} {
- var v = make([]interface{}, 0)
- for {
- // Look ahead for ] - can only happen on first iteration.
- op := d.scanWhile(ScanSkipSpace)
- if op == ScanEndArray {
- break
- }
- // Back up so d.value can have the byte we just read.
- d.off--
- d.scan.undo(op)
- v = append(v, d.valueInterface())
- // Next token must be , or ].
- op = d.scanWhile(ScanSkipSpace)
- if op == ScanEndArray {
- break
- }
- if op != ScanArrayValue {
- d.error(errPhase)
- }
- }
- return v
- }
- // objectInterface is like object but returns map[string]interface{}.
- func (d *decodeState) objectInterface() map[string]interface{} {
- m := make(map[string]interface{})
- for {
- // Read opening " of string key or closing }.
- op := d.scanWhile(ScanSkipSpace)
- if op == ScanEndObject {
- // closing } - can only happen on first iteration.
- break
- }
- if op != ScanBeginLiteral {
- d.error(errPhase)
- }
- // Read string key.
- start := d.off - 1
- op = d.scanWhile(ScanContinue)
- item := d.data[start : d.off-1]
- key, ok := unquote(item)
- if !ok {
- d.error(errPhase)
- }
- // Read : before value.
- if op == ScanSkipSpace {
- op = d.scanWhile(ScanSkipSpace)
- }
- if op != ScanObjectKey {
- d.error(errPhase)
- }
- // Read value.
- m[key] = d.valueInterface()
- // Next token must be , or }.
- op = d.scanWhile(ScanSkipSpace)
- if op == ScanEndObject {
- break
- }
- if op != ScanObjectValue {
- d.error(errPhase)
- }
- }
- return m
- }
- // literalInterface is like literal but returns an interface value.
- func (d *decodeState) literalInterface() interface{} {
- // All bytes inside literal return scanContinue op code.
- start := d.off - 1
- op := d.scanWhile(ScanContinue)
- // Scan read one byte too far; back up.
- d.off--
- d.scan.undo(op)
- item := d.data[start:d.off]
- switch c := item[0]; c {
- case 'n': // null
- return nil
- case 't', 'f': // true, false
- return c == 't'
- case '"': // string
- s, ok := unquote(item)
- if !ok {
- d.error(errPhase)
- }
- return s
- default: // number
- if c != '-' && (c < '0' || c > '9') {
- d.error(errPhase)
- }
- n, err := d.convertNumber(string(item))
- if err != nil {
- d.saveError(err)
- }
- return n
- }
- }
- // getu4 decodes \uXXXX from the beginning of s, returning the hex value,
- // or it returns -1.
- func getu4(s []byte) rune {
- if len(s) < 6 || s[0] != '\\' || s[1] != 'u' {
- return -1
- }
- r, err := strconv.ParseUint(string(s[2:6]), 16, 64)
- if err != nil {
- return -1
- }
- return rune(r)
- }
- // unquote converts a quoted JSON string literal s into an actual string t.
- // The rules are different than for Go, so cannot use strconv.Unquote.
- func unquote(s []byte) (t string, ok bool) {
- s, ok = UnquoteBytes(s)
- t = string(s)
- return
- }
- func UnquoteBytes(s []byte) (t []byte, ok bool) {
- if len(s) < 2 || s[0] != '"' || s[len(s)-1] != '"' {
- s = bytes.TrimSpace(s)
- if len(s) < 2 || s[0] != '"' || s[len(s)-1] != '"' {
- return
- }
- }
- s = s[1 : len(s)-1]
- // Check for unusual characters. If there are none,
- // then no unquoting is needed, so return a slice of the
- // original bytes.
- r := 0
- for r < len(s) {
- c := s[r]
- if c == '\\' || c == '"' || c < ' ' {
- break
- }
- if c < utf8.RuneSelf {
- r++
- continue
- }
- rr, size := utf8.DecodeRune(s[r:])
- if rr == utf8.RuneError && size == 1 {
- break
- }
- r += size
- }
- if r == len(s) {
- return s, true
- }
- b := make([]byte, len(s)+2*utf8.UTFMax)
- w := copy(b, s[0:r])
- for r < len(s) {
- // Out of room? Can only happen if s is full of
- // malformed UTF-8 and we're replacing each
- // byte with RuneError.
- if w >= len(b)-2*utf8.UTFMax {
- nb := make([]byte, (len(b)+utf8.UTFMax)*2)
- copy(nb, b[0:w])
- b = nb
- }
- switch c := s[r]; {
- case c == '\\':
- r++
- if r >= len(s) {
- return
- }
- switch s[r] {
- default:
- return
- case '"', '\\', '/', '\'':
- b[w] = s[r]
- r++
- w++
- case 'b':
- b[w] = '\b'
- r++
- w++
- case 'f':
- b[w] = '\f'
- r++
- w++
- case 'n':
- b[w] = '\n'
- r++
- w++
- case 'r':
- b[w] = '\r'
- r++
- w++
- case 't':
- b[w] = '\t'
- r++
- w++
- case 'u':
- r--
- rr := getu4(s[r:])
- if rr < 0 {
- return
- }
- r += 6
- if utf16.IsSurrogate(rr) {
- rr1 := getu4(s[r:])
- if dec := utf16.DecodeRune(rr, rr1); dec != unicode.ReplacementChar {
- // A valid pair; consume.
- r += 6
- w += utf8.EncodeRune(b[w:], dec)
- break
- }
- // Invalid surrogate; fall back to replacement rune.
- rr = unicode.ReplacementChar
- }
- w += utf8.EncodeRune(b[w:], rr)
- }
- // Quote, control characters are invalid.
- case c == '"', c < ' ':
- return
- // ASCII
- case c < utf8.RuneSelf:
- b[w] = c
- r++
- w++
- // Coerce to well-formed UTF-8.
- default:
- rr, size := utf8.DecodeRune(s[r:])
- r += size
- w += utf8.EncodeRune(b[w:], rr)
- }
- }
- return b[0:w], true
- }
|