Source file src/encoding/json/decode.go

Documentation: encoding/json

     1  // Copyright 2010 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  // Represents JSON data structure using native Go types: booleans, floats,
     6  // strings, arrays, and maps.
     7  
     8  package json
     9  
    10  import (
    11  	"encoding"
    12  	"encoding/base64"
    13  	"fmt"
    14  	"reflect"
    15  	"strconv"
    16  	"strings"
    17  	"unicode"
    18  	"unicode/utf16"
    19  	"unicode/utf8"
    20  )
    21  
    22  // Unmarshal parses the JSON-encoded data and stores the result
    23  // in the value pointed to by v. If v is nil or not a pointer,
    24  // Unmarshal returns an InvalidUnmarshalError.
    25  //
    26  // Unmarshal uses the inverse of the encodings that
    27  // Marshal uses, allocating maps, slices, and pointers as necessary,
    28  // with the following additional rules:
    29  //
    30  // To unmarshal JSON into a pointer, Unmarshal first handles the case of
    31  // the JSON being the JSON literal null. In that case, Unmarshal sets
    32  // the pointer to nil. Otherwise, Unmarshal unmarshals the JSON into
    33  // the value pointed at by the pointer. If the pointer is nil, Unmarshal
    34  // allocates a new value for it to point to.
    35  //
    36  // To unmarshal JSON into a value implementing the Unmarshaler interface,
    37  // Unmarshal calls that value's UnmarshalJSON method, including
    38  // when the input is a JSON null.
    39  // Otherwise, if the value implements encoding.TextUnmarshaler
    40  // and the input is a JSON quoted string, Unmarshal calls that value's
    41  // UnmarshalText method with the unquoted form of the string.
    42  //
    43  // To unmarshal JSON into a struct, Unmarshal matches incoming object
    44  // keys to the keys used by Marshal (either the struct field name or its tag),
    45  // preferring an exact match but also accepting a case-insensitive match. By
    46  // default, object keys which don't have a corresponding struct field are
    47  // ignored (see Decoder.DisallowUnknownFields for an alternative).
    48  //
    49  // To unmarshal JSON into an interface value,
    50  // Unmarshal stores one of these in the interface value:
    51  //
    52  //	bool, for JSON booleans
    53  //	float64, for JSON numbers
    54  //	string, for JSON strings
    55  //	[]interface{}, for JSON arrays
    56  //	map[string]interface{}, for JSON objects
    57  //	nil for JSON null
    58  //
    59  // To unmarshal a JSON array into a slice, Unmarshal resets the slice length
    60  // to zero and then appends each element to the slice.
    61  // As a special case, to unmarshal an empty JSON array into a slice,
    62  // Unmarshal replaces the slice with a new empty slice.
    63  //
    64  // To unmarshal a JSON array into a Go array, Unmarshal decodes
    65  // JSON array elements into corresponding Go array elements.
    66  // If the Go array is smaller than the JSON array,
    67  // the additional JSON array elements are discarded.
    68  // If the JSON array is smaller than the Go array,
    69  // the additional Go array elements are set to zero values.
    70  //
    71  // To unmarshal a JSON object into a map, Unmarshal first establishes a map to
    72  // use. If the map is nil, Unmarshal allocates a new map. Otherwise Unmarshal
    73  // reuses the existing map, keeping existing entries. Unmarshal then stores
    74  // key-value pairs from the JSON object into the map. The map's key type must
    75  // either be a string, an integer, or implement encoding.TextUnmarshaler.
    76  //
    77  // If a JSON value is not appropriate for a given target type,
    78  // or if a JSON number overflows the target type, Unmarshal
    79  // skips that field and completes the unmarshaling as best it can.
    80  // If no more serious errors are encountered, Unmarshal returns
    81  // an UnmarshalTypeError describing the earliest such error. In any
    82  // case, it's not guaranteed that all the remaining fields following
    83  // the problematic one will be unmarshaled into the target object.
    84  //
    85  // The JSON null value unmarshals into an interface, map, pointer, or slice
    86  // by setting that Go value to nil. Because null is often used in JSON to mean
    87  // ``not present,'' unmarshaling a JSON null into any other Go type has no effect
    88  // on the value and produces no error.
    89  //
    90  // When unmarshaling quoted strings, invalid UTF-8 or
    91  // invalid UTF-16 surrogate pairs are not treated as an error.
    92  // Instead, they are replaced by the Unicode replacement
    93  // character U+FFFD.
    94  //
    95  func Unmarshal(data []byte, v interface{}) error {
    96  	// Check for well-formedness.
    97  	// Avoids filling out half a data structure
    98  	// before discovering a JSON syntax error.
    99  	var d decodeState
   100  	err := checkValid(data, &d.scan)
   101  	if err != nil {
   102  		return err
   103  	}
   104  
   105  	d.init(data)
   106  	return d.unmarshal(v)
   107  }
   108  
   109  // Unmarshaler is the interface implemented by types
   110  // that can unmarshal a JSON description of themselves.
   111  // The input can be assumed to be a valid encoding of
   112  // a JSON value. UnmarshalJSON must copy the JSON data
   113  // if it wishes to retain the data after returning.
   114  //
   115  // By convention, to approximate the behavior of Unmarshal itself,
   116  // Unmarshalers implement UnmarshalJSON([]byte("null")) as a no-op.
   117  type Unmarshaler interface {
   118  	UnmarshalJSON([]byte) error
   119  }
   120  
   121  // An UnmarshalTypeError describes a JSON value that was
   122  // not appropriate for a value of a specific Go type.
   123  type UnmarshalTypeError struct {
   124  	Value  string       // description of JSON value - "bool", "array", "number -5"
   125  	Type   reflect.Type // type of Go value it could not be assigned to
   126  	Offset int64        // error occurred after reading Offset bytes
   127  	Struct string       // name of the struct type containing the field
   128  	Field  string       // the full path from root node to the field
   129  }
   130  
   131  func (e *UnmarshalTypeError) Error() string {
   132  	if e.Struct != "" || e.Field != "" {
   133  		return "json: cannot unmarshal " + e.Value + " into Go struct field " + e.Struct + "." + e.Field + " of type " + e.Type.String()
   134  	}
   135  	return "json: cannot unmarshal " + e.Value + " into Go value of type " + e.Type.String()
   136  }
   137  
   138  // An UnmarshalFieldError describes a JSON object key that
   139  // led to an unexported (and therefore unwritable) struct field.
   140  //
   141  // Deprecated: No longer used; kept for compatibility.
   142  type UnmarshalFieldError struct {
   143  	Key   string
   144  	Type  reflect.Type
   145  	Field reflect.StructField
   146  }
   147  
   148  func (e *UnmarshalFieldError) Error() string {
   149  	return "json: cannot unmarshal object key " + strconv.Quote(e.Key) + " into unexported field " + e.Field.Name + " of type " + e.Type.String()
   150  }
   151  
   152  // An InvalidUnmarshalError describes an invalid argument passed to Unmarshal.
   153  // (The argument to Unmarshal must be a non-nil pointer.)
   154  type InvalidUnmarshalError struct {
   155  	Type reflect.Type
   156  }
   157  
   158  func (e *InvalidUnmarshalError) Error() string {
   159  	if e.Type == nil {
   160  		return "json: Unmarshal(nil)"
   161  	}
   162  
   163  	if e.Type.Kind() != reflect.Ptr {
   164  		return "json: Unmarshal(non-pointer " + e.Type.String() + ")"
   165  	}
   166  	return "json: Unmarshal(nil " + e.Type.String() + ")"
   167  }
   168  
   169  func (d *decodeState) unmarshal(v interface{}) error {
   170  	rv := reflect.ValueOf(v)
   171  	if rv.Kind() != reflect.Ptr || rv.IsNil() {
   172  		return &InvalidUnmarshalError{reflect.TypeOf(v)}
   173  	}
   174  
   175  	d.scan.reset()
   176  	d.scanWhile(scanSkipSpace)
   177  	// We decode rv not rv.Elem because the Unmarshaler interface
   178  	// test must be applied at the top level of the value.
   179  	err := d.value(rv)
   180  	if err != nil {
   181  		return d.addErrorContext(err)
   182  	}
   183  	return d.savedError
   184  }
   185  
   186  // A Number represents a JSON number literal.
   187  type Number string
   188  
   189  // String returns the literal text of the number.
   190  func (n Number) String() string { return string(n) }
   191  
   192  // Float64 returns the number as a float64.
   193  func (n Number) Float64() (float64, error) {
   194  	return strconv.ParseFloat(string(n), 64)
   195  }
   196  
   197  // Int64 returns the number as an int64.
   198  func (n Number) Int64() (int64, error) {
   199  	return strconv.ParseInt(string(n), 10, 64)
   200  }
   201  
   202  // isValidNumber reports whether s is a valid JSON number literal.
   203  func isValidNumber(s string) bool {
   204  	// This function implements the JSON numbers grammar.
   205  	// See https://tools.ietf.org/html/rfc7159#section-6
   206  	// and https://json.org/number.gif
   207  
   208  	if s == "" {
   209  		return false
   210  	}
   211  
   212  	// Optional -
   213  	if s[0] == '-' {
   214  		s = s[1:]
   215  		if s == "" {
   216  			return false
   217  		}
   218  	}
   219  
   220  	// Digits
   221  	switch {
   222  	default:
   223  		return false
   224  
   225  	case s[0] == '0':
   226  		s = s[1:]
   227  
   228  	case '1' <= s[0] && s[0] <= '9':
   229  		s = s[1:]
   230  		for len(s) > 0 && '0' <= s[0] && s[0] <= '9' {
   231  			s = s[1:]
   232  		}
   233  	}
   234  
   235  	// . followed by 1 or more digits.
   236  	if len(s) >= 2 && s[0] == '.' && '0' <= s[1] && s[1] <= '9' {
   237  		s = s[2:]
   238  		for len(s) > 0 && '0' <= s[0] && s[0] <= '9' {
   239  			s = s[1:]
   240  		}
   241  	}
   242  
   243  	// e or E followed by an optional - or + and
   244  	// 1 or more digits.
   245  	if len(s) >= 2 && (s[0] == 'e' || s[0] == 'E') {
   246  		s = s[1:]
   247  		if s[0] == '+' || s[0] == '-' {
   248  			s = s[1:]
   249  			if s == "" {
   250  				return false
   251  			}
   252  		}
   253  		for len(s) > 0 && '0' <= s[0] && s[0] <= '9' {
   254  			s = s[1:]
   255  		}
   256  	}
   257  
   258  	// Make sure we are at the end.
   259  	return s == ""
   260  }
   261  
   262  // decodeState represents the state while decoding a JSON value.
   263  type decodeState struct {
   264  	data         []byte
   265  	off          int // next read offset in data
   266  	opcode       int // last read result
   267  	scan         scanner
   268  	errorContext struct { // provides context for type errors
   269  		Struct     reflect.Type
   270  		FieldStack []string
   271  	}
   272  	savedError            error
   273  	useNumber             bool
   274  	disallowUnknownFields bool
   275  }
   276  
   277  // readIndex returns the position of the last byte read.
   278  func (d *decodeState) readIndex() int {
   279  	return d.off - 1
   280  }
   281  
   282  // phasePanicMsg is used as a panic message when we end up with something that
   283  // shouldn't happen. It can indicate a bug in the JSON decoder, or that
   284  // something is editing the data slice while the decoder executes.
   285  const phasePanicMsg = "JSON decoder out of sync - data changing underfoot?"
   286  
   287  func (d *decodeState) init(data []byte) *decodeState {
   288  	d.data = data
   289  	d.off = 0
   290  	d.savedError = nil
   291  	d.errorContext.Struct = nil
   292  
   293  	// Reuse the allocated space for the FieldStack slice.
   294  	d.errorContext.FieldStack = d.errorContext.FieldStack[:0]
   295  	return d
   296  }
   297  
   298  // saveError saves the first err it is called with,
   299  // for reporting at the end of the unmarshal.
   300  func (d *decodeState) saveError(err error) {
   301  	if d.savedError == nil {
   302  		d.savedError = d.addErrorContext(err)
   303  	}
   304  }
   305  
   306  // addErrorContext returns a new error enhanced with information from d.errorContext
   307  func (d *decodeState) addErrorContext(err error) error {
   308  	if d.errorContext.Struct != nil || len(d.errorContext.FieldStack) > 0 {
   309  		switch err := err.(type) {
   310  		case *UnmarshalTypeError:
   311  			err.Struct = d.errorContext.Struct.Name()
   312  			err.Field = strings.Join(d.errorContext.FieldStack, ".")
   313  			return err
   314  		}
   315  	}
   316  	return err
   317  }
   318  
   319  // skip scans to the end of what was started.
   320  func (d *decodeState) skip() {
   321  	s, data, i := &d.scan, d.data, d.off
   322  	depth := len(s.parseState)
   323  	for {
   324  		op := s.step(s, data[i])
   325  		i++
   326  		if len(s.parseState) < depth {
   327  			d.off = i
   328  			d.opcode = op
   329  			return
   330  		}
   331  	}
   332  }
   333  
   334  // scanNext processes the byte at d.data[d.off].
   335  func (d *decodeState) scanNext() {
   336  	if d.off < len(d.data) {
   337  		d.opcode = d.scan.step(&d.scan, d.data[d.off])
   338  		d.off++
   339  	} else {
   340  		d.opcode = d.scan.eof()
   341  		d.off = len(d.data) + 1 // mark processed EOF with len+1
   342  	}
   343  }
   344  
   345  // scanWhile processes bytes in d.data[d.off:] until it
   346  // receives a scan code not equal to op.
   347  func (d *decodeState) scanWhile(op int) {
   348  	s, data, i := &d.scan, d.data, d.off
   349  	for i < len(data) {
   350  		newOp := s.step(s, data[i])
   351  		i++
   352  		if newOp != op {
   353  			d.opcode = newOp
   354  			d.off = i
   355  			return
   356  		}
   357  	}
   358  
   359  	d.off = len(data) + 1 // mark processed EOF with len+1
   360  	d.opcode = d.scan.eof()
   361  }
   362  
   363  // rescanLiteral is similar to scanWhile(scanContinue), but it specialises the
   364  // common case where we're decoding a literal. The decoder scans the input
   365  // twice, once for syntax errors and to check the length of the value, and the
   366  // second to perform the decoding.
   367  //
   368  // Only in the second step do we use decodeState to tokenize literals, so we
   369  // know there aren't any syntax errors. We can take advantage of that knowledge,
   370  // and scan a literal's bytes much more quickly.
   371  func (d *decodeState) rescanLiteral() {
   372  	data, i := d.data, d.off
   373  Switch:
   374  	switch data[i-1] {
   375  	case '"': // string
   376  		for ; i < len(data); i++ {
   377  			switch data[i] {
   378  			case '\\':
   379  				i++ // escaped char
   380  			case '"':
   381  				i++ // tokenize the closing quote too
   382  				break Switch
   383  			}
   384  		}
   385  	case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '-': // number
   386  		for ; i < len(data); i++ {
   387  			switch data[i] {
   388  			case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
   389  				'.', 'e', 'E', '+', '-':
   390  			default:
   391  				break Switch
   392  			}
   393  		}
   394  	case 't': // true
   395  		i += len("rue")
   396  	case 'f': // false
   397  		i += len("alse")
   398  	case 'n': // null
   399  		i += len("ull")
   400  	}
   401  	if i < len(data) {
   402  		d.opcode = stateEndValue(&d.scan, data[i])
   403  	} else {
   404  		d.opcode = scanEnd
   405  	}
   406  	d.off = i + 1
   407  }
   408  
   409  // value consumes a JSON value from d.data[d.off-1:], decoding into v, and
   410  // reads the following byte ahead. If v is invalid, the value is discarded.
   411  // The first byte of the value has been read already.
   412  func (d *decodeState) value(v reflect.Value) error {
   413  	switch d.opcode {
   414  	default:
   415  		panic(phasePanicMsg)
   416  
   417  	case scanBeginArray:
   418  		if v.IsValid() {
   419  			if err := d.array(v); err != nil {
   420  				return err
   421  			}
   422  		} else {
   423  			d.skip()
   424  		}
   425  		d.scanNext()
   426  
   427  	case scanBeginObject:
   428  		if v.IsValid() {
   429  			if err := d.object(v); err != nil {
   430  				return err
   431  			}
   432  		} else {
   433  			d.skip()
   434  		}
   435  		d.scanNext()
   436  
   437  	case scanBeginLiteral:
   438  		// All bytes inside literal return scanContinue op code.
   439  		start := d.readIndex()
   440  		d.rescanLiteral()
   441  
   442  		if v.IsValid() {
   443  			if err := d.literalStore(d.data[start:d.readIndex()], v, false); err != nil {
   444  				return err
   445  			}
   446  		}
   447  	}
   448  	return nil
   449  }
   450  
   451  type unquotedValue struct{}
   452  
   453  // valueQuoted is like value but decodes a
   454  // quoted string literal or literal null into an interface value.
   455  // If it finds anything other than a quoted string literal or null,
   456  // valueQuoted returns unquotedValue{}.
   457  func (d *decodeState) valueQuoted() interface{} {
   458  	switch d.opcode {
   459  	default:
   460  		panic(phasePanicMsg)
   461  
   462  	case scanBeginArray, scanBeginObject:
   463  		d.skip()
   464  		d.scanNext()
   465  
   466  	case scanBeginLiteral:
   467  		v := d.literalInterface()
   468  		switch v.(type) {
   469  		case nil, string:
   470  			return v
   471  		}
   472  	}
   473  	return unquotedValue{}
   474  }
   475  
   476  // indirect walks down v allocating pointers as needed,
   477  // until it gets to a non-pointer.
   478  // if it encounters an Unmarshaler, indirect stops and returns that.
   479  // if decodingNull is true, indirect stops at the last pointer so it can be set to nil.
   480  func indirect(v reflect.Value, decodingNull bool) (Unmarshaler, encoding.TextUnmarshaler, reflect.Value) {
   481  	// Issue #24153 indicates that it is generally not a guaranteed property
   482  	// that you may round-trip a reflect.Value by calling Value.Addr().Elem()
   483  	// and expect the value to still be settable for values derived from
   484  	// unexported embedded struct fields.
   485  	//
   486  	// The logic below effectively does this when it first addresses the value
   487  	// (to satisfy possible pointer methods) and continues to dereference
   488  	// subsequent pointers as necessary.
   489  	//
   490  	// After the first round-trip, we set v back to the original value to
   491  	// preserve the original RW flags contained in reflect.Value.
   492  	v0 := v
   493  	haveAddr := false
   494  
   495  	// If v is a named type and is addressable,
   496  	// start with its address, so that if the type has pointer methods,
   497  	// we find them.
   498  	if v.Kind() != reflect.Ptr && v.Type().Name() != "" && v.CanAddr() {
   499  		haveAddr = true
   500  		v = v.Addr()
   501  	}
   502  	for {
   503  		// Load value from interface, but only if the result will be
   504  		// usefully addressable.
   505  		if v.Kind() == reflect.Interface && !v.IsNil() {
   506  			e := v.Elem()
   507  			if e.Kind() == reflect.Ptr && !e.IsNil() && (!decodingNull || e.Elem().Kind() == reflect.Ptr) {
   508  				haveAddr = false
   509  				v = e
   510  				continue
   511  			}
   512  		}
   513  
   514  		if v.Kind() != reflect.Ptr {
   515  			break
   516  		}
   517  
   518  		if v.Elem().Kind() != reflect.Ptr && decodingNull && v.CanSet() {
   519  			break
   520  		}
   521  
   522  		// Prevent infinite loop if v is an interface pointing to its own address:
   523  		//     var v interface{}
   524  		//     v = &v
   525  		if v.Elem().Kind() == reflect.Interface && v.Elem().Elem() == v {
   526  			v = v.Elem()
   527  			break
   528  		}
   529  		if v.IsNil() {
   530  			v.Set(reflect.New(v.Type().Elem()))
   531  		}
   532  		if v.Type().NumMethod() > 0 && v.CanInterface() {
   533  			if u, ok := v.Interface().(Unmarshaler); ok {
   534  				return u, nil, reflect.Value{}
   535  			}
   536  			if !decodingNull {
   537  				if u, ok := v.Interface().(encoding.TextUnmarshaler); ok {
   538  					return nil, u, reflect.Value{}
   539  				}
   540  			}
   541  		}
   542  
   543  		if haveAddr {
   544  			v = v0 // restore original value after round-trip Value.Addr().Elem()
   545  			haveAddr = false
   546  		} else {
   547  			v = v.Elem()
   548  		}
   549  	}
   550  	return nil, nil, v
   551  }
   552  
   553  // array consumes an array from d.data[d.off-1:], decoding into v.
   554  // The first byte of the array ('[') has been read already.
   555  func (d *decodeState) array(v reflect.Value) error {
   556  	// Check for unmarshaler.
   557  	u, ut, pv := indirect(v, false)
   558  	if u != nil {
   559  		start := d.readIndex()
   560  		d.skip()
   561  		return u.UnmarshalJSON(d.data[start:d.off])
   562  	}
   563  	if ut != nil {
   564  		d.saveError(&UnmarshalTypeError{Value: "array", Type: v.Type(), Offset: int64(d.off)})
   565  		d.skip()
   566  		return nil
   567  	}
   568  	v = pv
   569  
   570  	// Check type of target.
   571  	switch v.Kind() {
   572  	case reflect.Interface:
   573  		if v.NumMethod() == 0 {
   574  			// Decoding into nil interface? Switch to non-reflect code.
   575  			ai := d.arrayInterface()
   576  			v.Set(reflect.ValueOf(ai))
   577  			return nil
   578  		}
   579  		// Otherwise it's invalid.
   580  		fallthrough
   581  	default:
   582  		d.saveError(&UnmarshalTypeError{Value: "array", Type: v.Type(), Offset: int64(d.off)})
   583  		d.skip()
   584  		return nil
   585  	case reflect.Array, reflect.Slice:
   586  		break
   587  	}
   588  
   589  	i := 0
   590  	for {
   591  		// Look ahead for ] - can only happen on first iteration.
   592  		d.scanWhile(scanSkipSpace)
   593  		if d.opcode == scanEndArray {
   594  			break
   595  		}
   596  
   597  		// Get element of array, growing if necessary.
   598  		if v.Kind() == reflect.Slice {
   599  			// Grow slice if necessary
   600  			if i >= v.Cap() {
   601  				newcap := v.Cap() + v.Cap()/2
   602  				if newcap < 4 {
   603  					newcap = 4
   604  				}
   605  				newv := reflect.MakeSlice(v.Type(), v.Len(), newcap)
   606  				reflect.Copy(newv, v)
   607  				v.Set(newv)
   608  			}
   609  			if i >= v.Len() {
   610  				v.SetLen(i + 1)
   611  			}
   612  		}
   613  
   614  		if i < v.Len() {
   615  			// Decode into element.
   616  			if err := d.value(v.Index(i)); err != nil {
   617  				return err
   618  			}
   619  		} else {
   620  			// Ran out of fixed array: skip.
   621  			if err := d.value(reflect.Value{}); err != nil {
   622  				return err
   623  			}
   624  		}
   625  		i++
   626  
   627  		// Next token must be , or ].
   628  		if d.opcode == scanSkipSpace {
   629  			d.scanWhile(scanSkipSpace)
   630  		}
   631  		if d.opcode == scanEndArray {
   632  			break
   633  		}
   634  		if d.opcode != scanArrayValue {
   635  			panic(phasePanicMsg)
   636  		}
   637  	}
   638  
   639  	if i < v.Len() {
   640  		if v.Kind() == reflect.Array {
   641  			// Array. Zero the rest.
   642  			z := reflect.Zero(v.Type().Elem())
   643  			for ; i < v.Len(); i++ {
   644  				v.Index(i).Set(z)
   645  			}
   646  		} else {
   647  			v.SetLen(i)
   648  		}
   649  	}
   650  	if i == 0 && v.Kind() == reflect.Slice {
   651  		v.Set(reflect.MakeSlice(v.Type(), 0, 0))
   652  	}
   653  	return nil
   654  }
   655  
   656  var nullLiteral = []byte("null")
   657  var textUnmarshalerType = reflect.TypeOf((*encoding.TextUnmarshaler)(nil)).Elem()
   658  
   659  // object consumes an object from d.data[d.off-1:], decoding into v.
   660  // The first byte ('{') of the object has been read already.
   661  func (d *decodeState) object(v reflect.Value) error {
   662  	// Check for unmarshaler.
   663  	u, ut, pv := indirect(v, false)
   664  	if u != nil {
   665  		start := d.readIndex()
   666  		d.skip()
   667  		return u.UnmarshalJSON(d.data[start:d.off])
   668  	}
   669  	if ut != nil {
   670  		d.saveError(&UnmarshalTypeError{Value: "object", Type: v.Type(), Offset: int64(d.off)})
   671  		d.skip()
   672  		return nil
   673  	}
   674  	v = pv
   675  	t := v.Type()
   676  
   677  	// Decoding into nil interface? Switch to non-reflect code.
   678  	if v.Kind() == reflect.Interface && v.NumMethod() == 0 {
   679  		oi := d.objectInterface()
   680  		v.Set(reflect.ValueOf(oi))
   681  		return nil
   682  	}
   683  
   684  	var fields structFields
   685  
   686  	// Check type of target:
   687  	//   struct or
   688  	//   map[T1]T2 where T1 is string, an integer type,
   689  	//             or an encoding.TextUnmarshaler
   690  	switch v.Kind() {
   691  	case reflect.Map:
   692  		// Map key must either have string kind, have an integer kind,
   693  		// or be an encoding.TextUnmarshaler.
   694  		switch t.Key().Kind() {
   695  		case reflect.String,
   696  			reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
   697  			reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
   698  		default:
   699  			if !reflect.PtrTo(t.Key()).Implements(textUnmarshalerType) {
   700  				d.saveError(&UnmarshalTypeError{Value: "object", Type: t, Offset: int64(d.off)})
   701  				d.skip()
   702  				return nil
   703  			}
   704  		}
   705  		if v.IsNil() {
   706  			v.Set(reflect.MakeMap(t))
   707  		}
   708  	case reflect.Struct:
   709  		fields = cachedTypeFields(t)
   710  		// ok
   711  	default:
   712  		d.saveError(&UnmarshalTypeError{Value: "object", Type: t, Offset: int64(d.off)})
   713  		d.skip()
   714  		return nil
   715  	}
   716  
   717  	var mapElem reflect.Value
   718  	origErrorContext := d.errorContext
   719  
   720  	for {
   721  		// Read opening " of string key or closing }.
   722  		d.scanWhile(scanSkipSpace)
   723  		if d.opcode == scanEndObject {
   724  			// closing } - can only happen on first iteration.
   725  			break
   726  		}
   727  		if d.opcode != scanBeginLiteral {
   728  			panic(phasePanicMsg)
   729  		}
   730  
   731  		// Read key.
   732  		start := d.readIndex()
   733  		d.rescanLiteral()
   734  		item := d.data[start:d.readIndex()]
   735  		key, ok := unquoteBytes(item)
   736  		if !ok {
   737  			panic(phasePanicMsg)
   738  		}
   739  
   740  		// Figure out field corresponding to key.
   741  		var subv reflect.Value
   742  		destring := false // whether the value is wrapped in a string to be decoded first
   743  
   744  		if v.Kind() == reflect.Map {
   745  			elemType := t.Elem()
   746  			if !mapElem.IsValid() {
   747  				mapElem = reflect.New(elemType).Elem()
   748  			} else {
   749  				mapElem.Set(reflect.Zero(elemType))
   750  			}
   751  			subv = mapElem
   752  		} else {
   753  			var f *field
   754  			if i, ok := fields.nameIndex[string(key)]; ok {
   755  				// Found an exact name match.
   756  				f = &fields.list[i]
   757  			} else {
   758  				// Fall back to the expensive case-insensitive
   759  				// linear search.
   760  				for i := range fields.list {
   761  					ff := &fields.list[i]
   762  					if ff.equalFold(ff.nameBytes, key) {
   763  						f = ff
   764  						break
   765  					}
   766  				}
   767  			}
   768  			if f != nil {
   769  				subv = v
   770  				destring = f.quoted
   771  				for _, i := range f.index {
   772  					if subv.Kind() == reflect.Ptr {
   773  						if subv.IsNil() {
   774  							// If a struct embeds a pointer to an unexported type,
   775  							// it is not possible to set a newly allocated value
   776  							// since the field is unexported.
   777  							//
   778  							// See https://golang.org/issue/21357
   779  							if !subv.CanSet() {
   780  								d.saveError(fmt.Errorf("json: cannot set embedded pointer to unexported struct: %v", subv.Type().Elem()))
   781  								// Invalidate subv to ensure d.value(subv) skips over
   782  								// the JSON value without assigning it to subv.
   783  								subv = reflect.Value{}
   784  								destring = false
   785  								break
   786  							}
   787  							subv.Set(reflect.New(subv.Type().Elem()))
   788  						}
   789  						subv = subv.Elem()
   790  					}
   791  					subv = subv.Field(i)
   792  				}
   793  				d.errorContext.FieldStack = append(d.errorContext.FieldStack, f.name)
   794  				d.errorContext.Struct = t
   795  			} else if d.disallowUnknownFields {
   796  				d.saveError(fmt.Errorf("json: unknown field %q", key))
   797  			}
   798  		}
   799  
   800  		// Read : before value.
   801  		if d.opcode == scanSkipSpace {
   802  			d.scanWhile(scanSkipSpace)
   803  		}
   804  		if d.opcode != scanObjectKey {
   805  			panic(phasePanicMsg)
   806  		}
   807  		d.scanWhile(scanSkipSpace)
   808  
   809  		if destring {
   810  			switch qv := d.valueQuoted().(type) {
   811  			case nil:
   812  				if err := d.literalStore(nullLiteral, subv, false); err != nil {
   813  					return err
   814  				}
   815  			case string:
   816  				if err := d.literalStore([]byte(qv), subv, true); err != nil {
   817  					return err
   818  				}
   819  			default:
   820  				d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal unquoted value into %v", subv.Type()))
   821  			}
   822  		} else {
   823  			if err := d.value(subv); err != nil {
   824  				return err
   825  			}
   826  		}
   827  
   828  		// Write value back to map;
   829  		// if using struct, subv points into struct already.
   830  		if v.Kind() == reflect.Map {
   831  			kt := t.Key()
   832  			var kv reflect.Value
   833  			switch {
   834  			case kt.Kind() == reflect.String:
   835  				kv = reflect.ValueOf(key).Convert(kt)
   836  			case reflect.PtrTo(kt).Implements(textUnmarshalerType):
   837  				kv = reflect.New(kt)
   838  				if err := d.literalStore(item, kv, true); err != nil {
   839  					return err
   840  				}
   841  				kv = kv.Elem()
   842  			default:
   843  				switch kt.Kind() {
   844  				case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
   845  					s := string(key)
   846  					n, err := strconv.ParseInt(s, 10, 64)
   847  					if err != nil || reflect.Zero(kt).OverflowInt(n) {
   848  						d.saveError(&UnmarshalTypeError{Value: "number " + s, Type: kt, Offset: int64(start + 1)})
   849  						break
   850  					}
   851  					kv = reflect.ValueOf(n).Convert(kt)
   852  				case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
   853  					s := string(key)
   854  					n, err := strconv.ParseUint(s, 10, 64)
   855  					if err != nil || reflect.Zero(kt).OverflowUint(n) {
   856  						d.saveError(&UnmarshalTypeError{Value: "number " + s, Type: kt, Offset: int64(start + 1)})
   857  						break
   858  					}
   859  					kv = reflect.ValueOf(n).Convert(kt)
   860  				default:
   861  					panic("json: Unexpected key type") // should never occur
   862  				}
   863  			}
   864  			if kv.IsValid() {
   865  				v.SetMapIndex(kv, subv)
   866  			}
   867  		}
   868  
   869  		// Next token must be , or }.
   870  		if d.opcode == scanSkipSpace {
   871  			d.scanWhile(scanSkipSpace)
   872  		}
   873  		// Reset errorContext to its original state.
   874  		// Keep the same underlying array for FieldStack, to reuse the
   875  		// space and avoid unnecessary allocs.
   876  		d.errorContext.FieldStack = d.errorContext.FieldStack[:len(origErrorContext.FieldStack)]
   877  		d.errorContext.Struct = origErrorContext.Struct
   878  		if d.opcode == scanEndObject {
   879  			break
   880  		}
   881  		if d.opcode != scanObjectValue {
   882  			panic(phasePanicMsg)
   883  		}
   884  	}
   885  	return nil
   886  }
   887  
   888  // convertNumber converts the number literal s to a float64 or a Number
   889  // depending on the setting of d.useNumber.
   890  func (d *decodeState) convertNumber(s string) (interface{}, error) {
   891  	if d.useNumber {
   892  		return Number(s), nil
   893  	}
   894  	f, err := strconv.ParseFloat(s, 64)
   895  	if err != nil {
   896  		return nil, &UnmarshalTypeError{Value: "number " + s, Type: reflect.TypeOf(0.0), Offset: int64(d.off)}
   897  	}
   898  	return f, nil
   899  }
   900  
   901  var numberType = reflect.TypeOf(Number(""))
   902  
   903  // literalStore decodes a literal stored in item into v.
   904  //
   905  // fromQuoted indicates whether this literal came from unwrapping a
   906  // string from the ",string" struct tag option. this is used only to
   907  // produce more helpful error messages.
   908  func (d *decodeState) literalStore(item []byte, v reflect.Value, fromQuoted bool) error {
   909  	// Check for unmarshaler.
   910  	if len(item) == 0 {
   911  		//Empty string given
   912  		d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
   913  		return nil
   914  	}
   915  	isNull := item[0] == 'n' // null
   916  	u, ut, pv := indirect(v, isNull)
   917  	if u != nil {
   918  		return u.UnmarshalJSON(item)
   919  	}
   920  	if ut != nil {
   921  		if item[0] != '"' {
   922  			if fromQuoted {
   923  				d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
   924  				return nil
   925  			}
   926  			val := "number"
   927  			switch item[0] {
   928  			case 'n':
   929  				val = "null"
   930  			case 't', 'f':
   931  				val = "bool"
   932  			}
   933  			d.saveError(&UnmarshalTypeError{Value: val, Type: v.Type(), Offset: int64(d.readIndex())})
   934  			return nil
   935  		}
   936  		s, ok := unquoteBytes(item)
   937  		if !ok {
   938  			if fromQuoted {
   939  				return fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type())
   940  			}
   941  			panic(phasePanicMsg)
   942  		}
   943  		return ut.UnmarshalText(s)
   944  	}
   945  
   946  	v = pv
   947  
   948  	switch c := item[0]; c {
   949  	case 'n': // null
   950  		// The main parser checks that only true and false can reach here,
   951  		// but if this was a quoted string input, it could be anything.
   952  		if fromQuoted && string(item) != "null" {
   953  			d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
   954  			break
   955  		}
   956  		switch v.Kind() {
   957  		case reflect.Interface, reflect.Ptr, reflect.Map, reflect.Slice:
   958  			v.Set(reflect.Zero(v.Type()))
   959  			// otherwise, ignore null for primitives/string
   960  		}
   961  	case 't', 'f': // true, false
   962  		value := item[0] == 't'
   963  		// The main parser checks that only true and false can reach here,
   964  		// but if this was a quoted string input, it could be anything.
   965  		if fromQuoted && string(item) != "true" && string(item) != "false" {
   966  			d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
   967  			break
   968  		}
   969  		switch v.Kind() {
   970  		default:
   971  			if fromQuoted {
   972  				d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
   973  			} else {
   974  				d.saveError(&UnmarshalTypeError{Value: "bool", Type: v.Type(), Offset: int64(d.readIndex())})
   975  			}
   976  		case reflect.Bool:
   977  			v.SetBool(value)
   978  		case reflect.Interface:
   979  			if v.NumMethod() == 0 {
   980  				v.Set(reflect.ValueOf(value))
   981  			} else {
   982  				d.saveError(&UnmarshalTypeError{Value: "bool", Type: v.Type(), Offset: int64(d.readIndex())})
   983  			}
   984  		}
   985  
   986  	case '"': // string
   987  		s, ok := unquoteBytes(item)
   988  		if !ok {
   989  			if fromQuoted {
   990  				return fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type())
   991  			}
   992  			panic(phasePanicMsg)
   993  		}
   994  		switch v.Kind() {
   995  		default:
   996  			d.saveError(&UnmarshalTypeError{Value: "string", Type: v.Type(), Offset: int64(d.readIndex())})
   997  		case reflect.Slice:
   998  			if v.Type().Elem().Kind() != reflect.Uint8 {
   999  				d.saveError(&UnmarshalTypeError{Value: "string", Type: v.Type(), Offset: int64(d.readIndex())})
  1000  				break
  1001  			}
  1002  			b := make([]byte, base64.StdEncoding.DecodedLen(len(s)))
  1003  			n, err := base64.StdEncoding.Decode(b, s)
  1004  			if err != nil {
  1005  				d.saveError(err)
  1006  				break
  1007  			}
  1008  			v.SetBytes(b[:n])
  1009  		case reflect.String:
  1010  			v.SetString(string(s))
  1011  		case reflect.Interface:
  1012  			if v.NumMethod() == 0 {
  1013  				v.Set(reflect.ValueOf(string(s)))
  1014  			} else {
  1015  				d.saveError(&UnmarshalTypeError{Value: "string", Type: v.Type(), Offset: int64(d.readIndex())})
  1016  			}
  1017  		}
  1018  
  1019  	default: // number
  1020  		if c != '-' && (c < '0' || c > '9') {
  1021  			if fromQuoted {
  1022  				return fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type())
  1023  			}
  1024  			panic(phasePanicMsg)
  1025  		}
  1026  		s := string(item)
  1027  		switch v.Kind() {
  1028  		default:
  1029  			if v.Kind() == reflect.String && v.Type() == numberType {
  1030  				v.SetString(s)
  1031  				if !isValidNumber(s) {
  1032  					return fmt.Errorf("json: invalid number literal, trying to unmarshal %q into Number", item)
  1033  				}
  1034  				break
  1035  			}
  1036  			if fromQuoted {
  1037  				return fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type())
  1038  			}
  1039  			d.saveError(&UnmarshalTypeError{Value: "number", Type: v.Type(), Offset: int64(d.readIndex())})
  1040  		case reflect.Interface:
  1041  			n, err := d.convertNumber(s)
  1042  			if err != nil {
  1043  				d.saveError(err)
  1044  				break
  1045  			}
  1046  			if v.NumMethod() != 0 {
  1047  				d.saveError(&UnmarshalTypeError{Value: "number", Type: v.Type(), Offset: int64(d.readIndex())})
  1048  				break
  1049  			}
  1050  			v.Set(reflect.ValueOf(n))
  1051  
  1052  		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
  1053  			n, err := strconv.ParseInt(s, 10, 64)
  1054  			if err != nil || v.OverflowInt(n) {
  1055  				d.saveError(&UnmarshalTypeError{Value: "number " + s, Type: v.Type(), Offset: int64(d.readIndex())})
  1056  				break
  1057  			}
  1058  			v.SetInt(n)
  1059  
  1060  		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
  1061  			n, err := strconv.ParseUint(s, 10, 64)
  1062  			if err != nil || v.OverflowUint(n) {
  1063  				d.saveError(&UnmarshalTypeError{Value: "number " + s, Type: v.Type(), Offset: int64(d.readIndex())})
  1064  				break
  1065  			}
  1066  			v.SetUint(n)
  1067  
  1068  		case reflect.Float32, reflect.Float64:
  1069  			n, err := strconv.ParseFloat(s, v.Type().Bits())
  1070  			if err != nil || v.OverflowFloat(n) {
  1071  				d.saveError(&UnmarshalTypeError{Value: "number " + s, Type: v.Type(), Offset: int64(d.readIndex())})
  1072  				break
  1073  			}
  1074  			v.SetFloat(n)
  1075  		}
  1076  	}
  1077  	return nil
  1078  }
  1079  
  1080  // The xxxInterface routines build up a value to be stored
  1081  // in an empty interface. They are not strictly necessary,
  1082  // but they avoid the weight of reflection in this common case.
  1083  
  1084  // valueInterface is like value but returns interface{}
  1085  func (d *decodeState) valueInterface() (val interface{}) {
  1086  	switch d.opcode {
  1087  	default:
  1088  		panic(phasePanicMsg)
  1089  	case scanBeginArray:
  1090  		val = d.arrayInterface()
  1091  		d.scanNext()
  1092  	case scanBeginObject:
  1093  		val = d.objectInterface()
  1094  		d.scanNext()
  1095  	case scanBeginLiteral:
  1096  		val = d.literalInterface()
  1097  	}
  1098  	return
  1099  }
  1100  
  1101  // arrayInterface is like array but returns []interface{}.
  1102  func (d *decodeState) arrayInterface() []interface{} {
  1103  	var v = make([]interface{}, 0)
  1104  	for {
  1105  		// Look ahead for ] - can only happen on first iteration.
  1106  		d.scanWhile(scanSkipSpace)
  1107  		if d.opcode == scanEndArray {
  1108  			break
  1109  		}
  1110  
  1111  		v = append(v, d.valueInterface())
  1112  
  1113  		// Next token must be , or ].
  1114  		if d.opcode == scanSkipSpace {
  1115  			d.scanWhile(scanSkipSpace)
  1116  		}
  1117  		if d.opcode == scanEndArray {
  1118  			break
  1119  		}
  1120  		if d.opcode != scanArrayValue {
  1121  			panic(phasePanicMsg)
  1122  		}
  1123  	}
  1124  	return v
  1125  }
  1126  
  1127  // objectInterface is like object but returns map[string]interface{}.
  1128  func (d *decodeState) objectInterface() map[string]interface{} {
  1129  	m := make(map[string]interface{})
  1130  	for {
  1131  		// Read opening " of string key or closing }.
  1132  		d.scanWhile(scanSkipSpace)
  1133  		if d.opcode == scanEndObject {
  1134  			// closing } - can only happen on first iteration.
  1135  			break
  1136  		}
  1137  		if d.opcode != scanBeginLiteral {
  1138  			panic(phasePanicMsg)
  1139  		}
  1140  
  1141  		// Read string key.
  1142  		start := d.readIndex()
  1143  		d.rescanLiteral()
  1144  		item := d.data[start:d.readIndex()]
  1145  		key, ok := unquote(item)
  1146  		if !ok {
  1147  			panic(phasePanicMsg)
  1148  		}
  1149  
  1150  		// Read : before value.
  1151  		if d.opcode == scanSkipSpace {
  1152  			d.scanWhile(scanSkipSpace)
  1153  		}
  1154  		if d.opcode != scanObjectKey {
  1155  			panic(phasePanicMsg)
  1156  		}
  1157  		d.scanWhile(scanSkipSpace)
  1158  
  1159  		// Read value.
  1160  		m[key] = d.valueInterface()
  1161  
  1162  		// Next token must be , or }.
  1163  		if d.opcode == scanSkipSpace {
  1164  			d.scanWhile(scanSkipSpace)
  1165  		}
  1166  		if d.opcode == scanEndObject {
  1167  			break
  1168  		}
  1169  		if d.opcode != scanObjectValue {
  1170  			panic(phasePanicMsg)
  1171  		}
  1172  	}
  1173  	return m
  1174  }
  1175  
  1176  // literalInterface consumes and returns a literal from d.data[d.off-1:] and
  1177  // it reads the following byte ahead. The first byte of the literal has been
  1178  // read already (that's how the caller knows it's a literal).
  1179  func (d *decodeState) literalInterface() interface{} {
  1180  	// All bytes inside literal return scanContinue op code.
  1181  	start := d.readIndex()
  1182  	d.rescanLiteral()
  1183  
  1184  	item := d.data[start:d.readIndex()]
  1185  
  1186  	switch c := item[0]; c {
  1187  	case 'n': // null
  1188  		return nil
  1189  
  1190  	case 't', 'f': // true, false
  1191  		return c == 't'
  1192  
  1193  	case '"': // string
  1194  		s, ok := unquote(item)
  1195  		if !ok {
  1196  			panic(phasePanicMsg)
  1197  		}
  1198  		return s
  1199  
  1200  	default: // number
  1201  		if c != '-' && (c < '0' || c > '9') {
  1202  			panic(phasePanicMsg)
  1203  		}
  1204  		n, err := d.convertNumber(string(item))
  1205  		if err != nil {
  1206  			d.saveError(err)
  1207  		}
  1208  		return n
  1209  	}
  1210  }
  1211  
  1212  // getu4 decodes \uXXXX from the beginning of s, returning the hex value,
  1213  // or it returns -1.
  1214  func getu4(s []byte) rune {
  1215  	if len(s) < 6 || s[0] != '\\' || s[1] != 'u' {
  1216  		return -1
  1217  	}
  1218  	var r rune
  1219  	for _, c := range s[2:6] {
  1220  		switch {
  1221  		case '0' <= c && c <= '9':
  1222  			c = c - '0'
  1223  		case 'a' <= c && c <= 'f':
  1224  			c = c - 'a' + 10
  1225  		case 'A' <= c && c <= 'F':
  1226  			c = c - 'A' + 10
  1227  		default:
  1228  			return -1
  1229  		}
  1230  		r = r*16 + rune(c)
  1231  	}
  1232  	return r
  1233  }
  1234  
  1235  // unquote converts a quoted JSON string literal s into an actual string t.
  1236  // The rules are different than for Go, so cannot use strconv.Unquote.
  1237  func unquote(s []byte) (t string, ok bool) {
  1238  	s, ok = unquoteBytes(s)
  1239  	t = string(s)
  1240  	return
  1241  }
  1242  
  1243  func unquoteBytes(s []byte) (t []byte, ok bool) {
  1244  	if len(s) < 2 || s[0] != '"' || s[len(s)-1] != '"' {
  1245  		return
  1246  	}
  1247  	s = s[1 : len(s)-1]
  1248  
  1249  	// Check for unusual characters. If there are none,
  1250  	// then no unquoting is needed, so return a slice of the
  1251  	// original bytes.
  1252  	r := 0
  1253  	for r < len(s) {
  1254  		c := s[r]
  1255  		if c == '\\' || c == '"' || c < ' ' {
  1256  			break
  1257  		}
  1258  		if c < utf8.RuneSelf {
  1259  			r++
  1260  			continue
  1261  		}
  1262  		rr, size := utf8.DecodeRune(s[r:])
  1263  		if rr == utf8.RuneError && size == 1 {
  1264  			break
  1265  		}
  1266  		r += size
  1267  	}
  1268  	if r == len(s) {
  1269  		return s, true
  1270  	}
  1271  
  1272  	b := make([]byte, len(s)+2*utf8.UTFMax)
  1273  	w := copy(b, s[0:r])
  1274  	for r < len(s) {
  1275  		// Out of room? Can only happen if s is full of
  1276  		// malformed UTF-8 and we're replacing each
  1277  		// byte with RuneError.
  1278  		if w >= len(b)-2*utf8.UTFMax {
  1279  			nb := make([]byte, (len(b)+utf8.UTFMax)*2)
  1280  			copy(nb, b[0:w])
  1281  			b = nb
  1282  		}
  1283  		switch c := s[r]; {
  1284  		case c == '\\':
  1285  			r++
  1286  			if r >= len(s) {
  1287  				return
  1288  			}
  1289  			switch s[r] {
  1290  			default:
  1291  				return
  1292  			case '"', '\\', '/', '\'':
  1293  				b[w] = s[r]
  1294  				r++
  1295  				w++
  1296  			case 'b':
  1297  				b[w] = '\b'
  1298  				r++
  1299  				w++
  1300  			case 'f':
  1301  				b[w] = '\f'
  1302  				r++
  1303  				w++
  1304  			case 'n':
  1305  				b[w] = '\n'
  1306  				r++
  1307  				w++
  1308  			case 'r':
  1309  				b[w] = '\r'
  1310  				r++
  1311  				w++
  1312  			case 't':
  1313  				b[w] = '\t'
  1314  				r++
  1315  				w++
  1316  			case 'u':
  1317  				r--
  1318  				rr := getu4(s[r:])
  1319  				if rr < 0 {
  1320  					return
  1321  				}
  1322  				r += 6
  1323  				if utf16.IsSurrogate(rr) {
  1324  					rr1 := getu4(s[r:])
  1325  					if dec := utf16.DecodeRune(rr, rr1); dec != unicode.ReplacementChar {
  1326  						// A valid pair; consume.
  1327  						r += 6
  1328  						w += utf8.EncodeRune(b[w:], dec)
  1329  						break
  1330  					}
  1331  					// Invalid surrogate; fall back to replacement rune.
  1332  					rr = unicode.ReplacementChar
  1333  				}
  1334  				w += utf8.EncodeRune(b[w:], rr)
  1335  			}
  1336  
  1337  		// Quote, control characters are invalid.
  1338  		case c == '"', c < ' ':
  1339  			return
  1340  
  1341  		// ASCII
  1342  		case c < utf8.RuneSelf:
  1343  			b[w] = c
  1344  			r++
  1345  			w++
  1346  
  1347  		// Coerce to well-formed UTF-8.
  1348  		default:
  1349  			rr, size := utf8.DecodeRune(s[r:])
  1350  			r += size
  1351  			w += utf8.EncodeRune(b[w:], rr)
  1352  		}
  1353  	}
  1354  	return b[0:w], true
  1355  }
  1356  

View as plain text