1package jsoncolor
   2
   3import (
   4	"bytes"
   5	"encoding"
   6	"encoding/base64"
   7	"encoding/json"
   8	"fmt"
   9	"math"
  10	"reflect"
  11	"strconv"
  12	"time"
  13	"unsafe"
  14)
  15
  16func (d decoder) decodeNull(b []byte, p unsafe.Pointer) ([]byte, error) {
  17	if hasNullPrefix(b) {
  18		return b[4:], nil
  19	}
  20	return inputError(b, nullType)
  21}
  22
  23func (d decoder) decodeBool(b []byte, p unsafe.Pointer) ([]byte, error) {
  24	switch {
  25	case hasTruePrefix(b):
  26		*(*bool)(p) = true
  27		return b[4:], nil
  28
  29	case hasFalsePrefix(b):
  30		*(*bool)(p) = false
  31		return b[5:], nil
  32
  33	case hasNullPrefix(b):
  34		return b[4:], nil
  35
  36	default:
  37		return inputError(b, boolType)
  38	}
  39}
  40
  41func (d decoder) decodeInt(b []byte, p unsafe.Pointer) ([]byte, error) {
  42	if hasNullPrefix(b) {
  43		return b[4:], nil
  44	}
  45
  46	v, r, err := parseInt(b, intType)
  47	if err != nil {
  48		return r, err
  49	}
  50
  51	*(*int)(p) = int(v)
  52	return r, nil
  53}
  54
  55func (d decoder) decodeInt8(b []byte, p unsafe.Pointer) ([]byte, error) {
  56	if hasNullPrefix(b) {
  57		return b[4:], nil
  58	}
  59
  60	v, r, err := parseInt(b, int8Type)
  61	if err != nil {
  62		return r, err
  63	}
  64
  65	if v < math.MinInt8 || v > math.MaxInt8 {
  66		return r, unmarshalOverflow(b[:len(b)-len(r)], int8Type)
  67	}
  68
  69	*(*int8)(p) = int8(v)
  70	return r, nil
  71}
  72
  73func (d decoder) decodeInt16(b []byte, p unsafe.Pointer) ([]byte, error) {
  74	if hasNullPrefix(b) {
  75		return b[4:], nil
  76	}
  77
  78	v, r, err := parseInt(b, int16Type)
  79	if err != nil {
  80		return r, err
  81	}
  82
  83	if v < math.MinInt16 || v > math.MaxInt16 {
  84		return r, unmarshalOverflow(b[:len(b)-len(r)], int16Type)
  85	}
  86
  87	*(*int16)(p) = int16(v)
  88	return r, nil
  89}
  90
  91func (d decoder) decodeInt32(b []byte, p unsafe.Pointer) ([]byte, error) {
  92	if hasNullPrefix(b) {
  93		return b[4:], nil
  94	}
  95
  96	v, r, err := parseInt(b, int32Type)
  97	if err != nil {
  98		return r, err
  99	}
 100
 101	if v < math.MinInt32 || v > math.MaxInt32 {
 102		return r, unmarshalOverflow(b[:len(b)-len(r)], int32Type)
 103	}
 104
 105	*(*int32)(p) = int32(v)
 106	return r, nil
 107}
 108
 109func (d decoder) decodeInt64(b []byte, p unsafe.Pointer) ([]byte, error) {
 110	if hasNullPrefix(b) {
 111		return b[4:], nil
 112	}
 113
 114	v, r, err := parseInt(b, int64Type)
 115	if err != nil {
 116		return r, err
 117	}
 118
 119	*(*int64)(p) = v
 120	return r, nil
 121}
 122
 123func (d decoder) decodeUint(b []byte, p unsafe.Pointer) ([]byte, error) {
 124	if hasNullPrefix(b) {
 125		return b[4:], nil
 126	}
 127
 128	v, r, err := parseUint(b, uintType)
 129	if err != nil {
 130		return r, err
 131	}
 132
 133	*(*uint)(p) = uint(v)
 134	return r, nil
 135}
 136
 137func (d decoder) decodeUintptr(b []byte, p unsafe.Pointer) ([]byte, error) {
 138	if hasNullPrefix(b) {
 139		return b[4:], nil
 140	}
 141
 142	v, r, err := parseUint(b, uintptrType)
 143	if err != nil {
 144		return r, err
 145	}
 146
 147	*(*uintptr)(p) = uintptr(v)
 148	return r, nil
 149}
 150
 151func (d decoder) decodeUint8(b []byte, p unsafe.Pointer) ([]byte, error) {
 152	if hasNullPrefix(b) {
 153		return b[4:], nil
 154	}
 155
 156	v, r, err := parseUint(b, uint8Type)
 157	if err != nil {
 158		return r, err
 159	}
 160
 161	if v > math.MaxUint8 {
 162		return r, unmarshalOverflow(b[:len(b)-len(r)], uint8Type)
 163	}
 164
 165	*(*uint8)(p) = uint8(v)
 166	return r, nil
 167}
 168
 169func (d decoder) decodeUint16(b []byte, p unsafe.Pointer) ([]byte, error) {
 170	if hasNullPrefix(b) {
 171		return b[4:], nil
 172	}
 173
 174	v, r, err := parseUint(b, uint16Type)
 175	if err != nil {
 176		return r, err
 177	}
 178
 179	if v > math.MaxUint16 {
 180		return r, unmarshalOverflow(b[:len(b)-len(r)], uint16Type)
 181	}
 182
 183	*(*uint16)(p) = uint16(v)
 184	return r, nil
 185}
 186
 187func (d decoder) decodeUint32(b []byte, p unsafe.Pointer) ([]byte, error) {
 188	if hasNullPrefix(b) {
 189		return b[4:], nil
 190	}
 191
 192	v, r, err := parseUint(b, uint32Type)
 193	if err != nil {
 194		return r, err
 195	}
 196
 197	if v > math.MaxUint32 {
 198		return r, unmarshalOverflow(b[:len(b)-len(r)], uint32Type)
 199	}
 200
 201	*(*uint32)(p) = uint32(v)
 202	return r, nil
 203}
 204
 205func (d decoder) decodeUint64(b []byte, p unsafe.Pointer) ([]byte, error) {
 206	if hasNullPrefix(b) {
 207		return b[4:], nil
 208	}
 209
 210	v, r, err := parseUint(b, uint64Type)
 211	if err != nil {
 212		return r, err
 213	}
 214
 215	*(*uint64)(p) = v
 216	return r, nil
 217}
 218
 219func (d decoder) decodeFloat32(b []byte, p unsafe.Pointer) ([]byte, error) {
 220	if hasNullPrefix(b) {
 221		return b[4:], nil
 222	}
 223
 224	v, r, err := parseNumber(b)
 225	if err != nil {
 226		return inputError(b, float32Type)
 227	}
 228
 229	f, err := strconv.ParseFloat(*(*string)(unsafe.Pointer(&v)), 32)
 230	if err != nil {
 231		return inputError(b, float32Type)
 232	}
 233
 234	*(*float32)(p) = float32(f)
 235	return r, nil
 236}
 237
 238func (d decoder) decodeFloat64(b []byte, p unsafe.Pointer) ([]byte, error) {
 239	if hasNullPrefix(b) {
 240		return b[4:], nil
 241	}
 242
 243	v, r, err := parseNumber(b)
 244	if err != nil {
 245		return inputError(b, float64Type)
 246	}
 247
 248	f, err := strconv.ParseFloat(*(*string)(unsafe.Pointer(&v)), 64)
 249	if err != nil {
 250		return inputError(b, float64Type)
 251	}
 252
 253	*(*float64)(p) = f
 254	return r, nil
 255}
 256
 257func (d decoder) decodeNumber(b []byte, p unsafe.Pointer) ([]byte, error) {
 258	if hasNullPrefix(b) {
 259		return b[4:], nil
 260	}
 261
 262	v, r, err := parseNumber(b)
 263	if err != nil {
 264		return inputError(b, numberType)
 265	}
 266
 267	if (d.flags & DontCopyNumber) != 0 {
 268		*(*Number)(p) = *(*Number)(unsafe.Pointer(&v))
 269	} else {
 270		*(*Number)(p) = Number(v)
 271	}
 272
 273	return r, nil
 274}
 275
 276func (d decoder) decodeString(b []byte, p unsafe.Pointer) ([]byte, error) {
 277	if hasNullPrefix(b) {
 278		return b[4:], nil
 279	}
 280
 281	s, r, new, err := parseStringUnquote(b, nil)
 282	if err != nil {
 283		if len(b) == 0 || b[0] != '"' {
 284			return inputError(b, stringType)
 285		}
 286		return r, err
 287	}
 288
 289	if new || (d.flags&DontCopyString) != 0 {
 290		*(*string)(p) = *(*string)(unsafe.Pointer(&s))
 291	} else {
 292		*(*string)(p) = string(s)
 293	}
 294
 295	return r, nil
 296}
 297
 298func (d decoder) decodeFromString(b []byte, p unsafe.Pointer, decode decodeFunc) ([]byte, error) {
 299	if hasNullPrefix(b) {
 300		return decode(d, b, p)
 301	}
 302
 303	v, b, _, err := parseStringUnquote(b, nil)
 304	if err != nil {
 305		return inputError(v, stringType)
 306	}
 307
 308	if v, err = decode(d, v, p); err != nil {
 309		return b, err
 310	}
 311
 312	if v = skipSpaces(v); len(v) != 0 {
 313		return b, syntaxError(v, "unexpected trailing tokens after string value")
 314	}
 315
 316	return b, nil
 317}
 318
 319func (d decoder) decodeFromStringToInt(b []byte, p unsafe.Pointer, t reflect.Type, decode decodeFunc) ([]byte, error) {
 320	if hasPrefix(b, "null") {
 321		return decode(d, b, p)
 322	}
 323
 324	if len(b) > 0 && b[0] != '"' {
 325		v, r, err := parseNumber(b)
 326		if err == nil {
 327			// The encoding/json package will return a *json.UnmarshalTypeError if
 328			// the input was a floating point number representation, even tho a
 329			// string is expected here.
 330			isFloat := true
 331			switch {
 332			case bytes.IndexByte(v, '.') >= 0:
 333			case bytes.IndexByte(v, 'e') >= 0:
 334			case bytes.IndexByte(v, 'E') >= 0:
 335			default:
 336				isFloat = false
 337			}
 338			if isFloat {
 339				_, err := strconv.ParseFloat(*(*string)(unsafe.Pointer(&v)), 64)
 340				if err != nil {
 341					return r, unmarshalTypeError(v, t)
 342				}
 343			}
 344		}
 345		return r, fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal unquoted value into int")
 346	}
 347
 348	if len(b) > 1 && b[0] == '"' && b[1] == '"' {
 349		return b, fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal \"\" into int")
 350	}
 351
 352	v, b, _, err := parseStringUnquote(b, nil)
 353	if err != nil {
 354		return inputError(v, t)
 355	}
 356
 357	if hasLeadingZeroes(v) {
 358		// In this context the encoding/json package accepts leading zeroes because
 359		// it is not constrained by the JSON syntax, remove them so the parsing
 360		// functions don't return syntax errors.
 361		u := make([]byte, 0, len(v))
 362		i := 0
 363
 364		if i < len(v) && v[i] == '-' || v[i] == '+' {
 365			u = append(u, v[i])
 366			i++
 367		}
 368
 369		for (i+1) < len(v) && v[i] == '0' && '0' <= v[i+1] && v[i+1] <= '9' {
 370			i++
 371		}
 372
 373		v = append(u, v[i:]...)
 374	}
 375
 376	if r, err := decode(d, v, p); err != nil {
 377		if _, isSyntaxError := err.(*SyntaxError); isSyntaxError {
 378			if hasPrefix(v, "-") {
 379				// The standard library interprets sequences of '-' characters
 380				// as numbers but still returns type errors in this case...
 381				return b, unmarshalTypeError(v, t)
 382			}
 383			return b, fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into int", prefix(v))
 384		}
 385		// When the input value was a valid number representation we retain the
 386		// error returned by the decoder.
 387		if _, _, err := parseNumber(v); err != nil {
 388			// When the input value valid JSON we mirror the behavior of the
 389			// encoding/json package and return a generic error.
 390			if _, _, err := parseValue(v); err == nil {
 391				return b, fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into int", prefix(v))
 392			}
 393		}
 394		return b, err
 395	} else if len(r) != 0 {
 396		return r, unmarshalTypeError(v, t)
 397	}
 398
 399	return b, nil
 400}
 401
 402func (d decoder) decodeBytes(b []byte, p unsafe.Pointer) ([]byte, error) {
 403	if hasNullPrefix(b) {
 404		*(*[]byte)(p) = nil
 405		return b[4:], nil
 406	}
 407
 408	if len(b) < 2 {
 409		return inputError(b, bytesType)
 410	}
 411
 412	if b[0] != '"' {
 413		// Go 1.7- behavior: bytes slices may be decoded from array of integers.
 414		if len(b) > 0 && b[0] == '[' {
 415			return d.decodeSlice(b, p, 1, bytesType, decoder.decodeUint8)
 416		}
 417		return inputError(b, bytesType)
 418	}
 419
 420	// The input string contains escaped sequences, we need to parse it before
 421	// decoding it to match the encoding/json package behvaior.
 422	src, r, _, err := parseStringUnquote(b, nil)
 423	if err != nil {
 424		return inputError(b, bytesType)
 425	}
 426
 427	dst := make([]byte, base64.StdEncoding.DecodedLen(len(src)))
 428
 429	n, err := base64.StdEncoding.Decode(dst, src)
 430	if err != nil {
 431		return r, err
 432	}
 433
 434	*(*[]byte)(p) = dst[:n]
 435	return r, nil
 436}
 437
 438func (d decoder) decodeDuration(b []byte, p unsafe.Pointer) ([]byte, error) {
 439	if hasNullPrefix(b) {
 440		return b[4:], nil
 441	}
 442
 443	// in order to inter-operate with the stdlib, we must be able to interpret
 444	// durations passed as integer values.  there's some discussion about being
 445	// flexible on how durations are formatted, but for the time being, it's
 446	// been punted to go2 at the earliest: https://github.com/golang/go/issues/4712
 447	if len(b) > 0 && b[0] != '"' {
 448		v, r, err := parseInt(b, durationType)
 449		if err != nil {
 450			return inputError(b, int32Type)
 451		}
 452
 453		if v < math.MinInt64 || v > math.MaxInt64 {
 454			return r, unmarshalOverflow(b[:len(b)-len(r)], int32Type)
 455		}
 456
 457		*(*time.Duration)(p) = time.Duration(v)
 458		return r, nil
 459	}
 460
 461	if len(b) < 2 || b[0] != '"' {
 462		return inputError(b, durationType)
 463	}
 464
 465	i := bytes.IndexByte(b[1:], '"') + 1
 466	if i <= 0 {
 467		return inputError(b, durationType)
 468	}
 469
 470	s := b[1:i] // trim quotes
 471
 472	v, err := time.ParseDuration(*(*string)(unsafe.Pointer(&s)))
 473	if err != nil {
 474		return inputError(b, durationType)
 475	}
 476
 477	*(*time.Duration)(p) = v
 478	return b[i+1:], nil
 479}
 480
 481func (d decoder) decodeTime(b []byte, p unsafe.Pointer) ([]byte, error) {
 482	if hasNullPrefix(b) {
 483		return b[4:], nil
 484	}
 485
 486	if len(b) < 2 || b[0] != '"' {
 487		return inputError(b, timeType)
 488	}
 489
 490	i := bytes.IndexByte(b[1:], '"') + 1
 491	if i <= 0 {
 492		return inputError(b, timeType)
 493	}
 494
 495	s := b[1:i] // trim quotes
 496
 497	v, err := time.Parse(time.RFC3339Nano, *(*string)(unsafe.Pointer(&s)))
 498	if err != nil {
 499		return inputError(b, timeType)
 500	}
 501
 502	*(*time.Time)(p) = v
 503	return b[i+1:], nil
 504}
 505
 506func (d decoder) decodeArray(b []byte, p unsafe.Pointer, n int, size uintptr, t reflect.Type, decode decodeFunc) ([]byte, error) {
 507	if hasNullPrefix(b) {
 508		return b[4:], nil
 509	}
 510
 511	if len(b) < 2 || b[0] != '[' {
 512		return inputError(b, t)
 513	}
 514	b = b[1:]
 515
 516	var err error
 517	for i := 0; i < n; i++ {
 518		b = skipSpaces(b)
 519
 520		if i != 0 {
 521			if len(b) == 0 {
 522				return b, syntaxError(b, "unexpected EOF after array element")
 523			}
 524			switch b[0] {
 525			case ',':
 526				b = skipSpaces(b[1:])
 527			case ']':
 528				return b[1:], nil
 529			default:
 530				return b, syntaxError(b, "expected ',' after array element but found '%c'", b[0])
 531			}
 532		}
 533
 534		b, err = decode(d, b, unsafe.Pointer(uintptr(p)+(uintptr(i)*size)))
 535		if err != nil {
 536			if e, ok := err.(*UnmarshalTypeError); ok {
 537				e.Struct = t.String() + e.Struct
 538				e.Field = strconv.Itoa(i) + "." + e.Field
 539			}
 540			return b, err
 541		}
 542	}
 543
 544	// The encoding/json package ignores extra elements found when decoding into
 545	// array types (which have a fixed size).
 546	for {
 547		b = skipSpaces(b)
 548
 549		if len(b) == 0 {
 550			return b, syntaxError(b, "missing closing ']' in array value")
 551		}
 552
 553		switch b[0] {
 554		case ',':
 555			b = skipSpaces(b[1:])
 556		case ']':
 557			return b[1:], nil
 558		}
 559
 560		_, b, err = parseValue(b)
 561		if err != nil {
 562			return b, err
 563		}
 564	}
 565}
 566
 567var (
 568	// This is a placeholder used to consturct non-nil empty slices.
 569	empty struct{}
 570)
 571
 572func (d decoder) decodeSlice(b []byte, p unsafe.Pointer, size uintptr, t reflect.Type, decode decodeFunc) ([]byte, error) {
 573	if hasNullPrefix(b) {
 574		*(*slice)(p) = slice{}
 575		return b[4:], nil
 576	}
 577
 578	if len(b) < 2 {
 579		return inputError(b, t)
 580	}
 581
 582	if b[0] != '[' {
 583		// Go 1.7- behavior: fallback to decoding as a []byte if the element
 584		// type is byte; allow conversions from JSON strings even tho the
 585		// underlying type implemented unmarshaler interfaces.
 586		if t.Elem().Kind() == reflect.Uint8 {
 587			return d.decodeBytes(b, p)
 588		}
 589		return inputError(b, t)
 590	}
 591
 592	input := b
 593	b = b[1:]
 594
 595	s := (*slice)(p)
 596	s.len = 0
 597
 598	var err error
 599	for {
 600		b = skipSpaces(b)
 601
 602		if len(b) != 0 && b[0] == ']' {
 603			if s.data == nil {
 604				s.data = unsafe.Pointer(&empty)
 605			}
 606			return b[1:], nil
 607		}
 608
 609		if s.len != 0 {
 610			if len(b) == 0 {
 611				return b, syntaxError(b, "unexpected EOF after array element")
 612			}
 613			if b[0] != ',' {
 614				return b, syntaxError(b, "expected ',' after array element but found '%c'", b[0])
 615			}
 616			b = skipSpaces(b[1:])
 617		}
 618
 619		if s.len == s.cap {
 620			c := s.cap
 621
 622			if c == 0 {
 623				c = 10
 624			} else {
 625				c *= 2
 626			}
 627
 628			*s = extendSlice(t, s, c)
 629		}
 630
 631		b, err = decode(d, b, unsafe.Pointer(uintptr(s.data)+(uintptr(s.len)*size)))
 632		if err != nil {
 633			if _, r, err := parseValue(input); err != nil {
 634				return r, err
 635			} else {
 636				b = r
 637			}
 638			if e, ok := err.(*UnmarshalTypeError); ok {
 639				e.Struct = t.String() + e.Struct
 640				e.Field = strconv.Itoa(s.len) + "." + e.Field
 641			}
 642			return b, err
 643		}
 644
 645		s.len++
 646	}
 647}
 648
 649func (d decoder) decodeMap(b []byte, p unsafe.Pointer, t, kt, vt reflect.Type, kz, vz reflect.Value, decodeKey, decodeValue decodeFunc) ([]byte, error) {
 650	if hasNullPrefix(b) {
 651		*(*unsafe.Pointer)(p) = nil
 652		return b[4:], nil
 653	}
 654
 655	if len(b) < 2 || b[0] != '{' {
 656		return inputError(b, t)
 657	}
 658	i := 0
 659	m := reflect.NewAt(t, p).Elem()
 660
 661	k := reflect.New(kt).Elem()
 662	v := reflect.New(vt).Elem()
 663
 664	kptr := (*iface)(unsafe.Pointer(&k)).ptr
 665	vptr := (*iface)(unsafe.Pointer(&v)).ptr
 666	input := b
 667
 668	if m.IsNil() {
 669		m = reflect.MakeMap(t)
 670	}
 671
 672	var err error
 673	b = b[1:]
 674	for {
 675		k.Set(kz)
 676		v.Set(vz)
 677		b = skipSpaces(b)
 678
 679		if len(b) != 0 && b[0] == '}' {
 680			*(*unsafe.Pointer)(p) = unsafe.Pointer(m.Pointer())
 681			return b[1:], nil
 682		}
 683
 684		if i != 0 {
 685			if len(b) == 0 {
 686				return b, syntaxError(b, "unexpected end of JONS input after object field value")
 687			}
 688			if b[0] != ',' {
 689				return b, syntaxError(b, "expected ',' after object field value but found '%c'", b[0])
 690			}
 691			b = skipSpaces(b[1:])
 692		}
 693
 694		if hasPrefix(b, "null") {
 695			return b, syntaxError(b, "cannot decode object key string from 'null' value")
 696		}
 697
 698		if b, err = decodeKey(d, b, kptr); err != nil {
 699			return objectKeyError(b, err)
 700		}
 701		b = skipSpaces(b)
 702
 703		if len(b) == 0 {
 704			return b, syntaxError(b, "unexpected end of JSON input after object field key")
 705		}
 706		if b[0] != ':' {
 707			return b, syntaxError(b, "expected ':' after object field key but found '%c'", b[0])
 708		}
 709		b = skipSpaces(b[1:])
 710
 711		if b, err = decodeValue(d, b, vptr); err != nil {
 712			if _, r, err := parseValue(input); err != nil {
 713				return r, err
 714			} else {
 715				b = r
 716			}
 717			if e, ok := err.(*UnmarshalTypeError); ok {
 718				e.Struct = "map[" + kt.String() + "]" + vt.String() + "{" + e.Struct + "}"
 719				e.Field = fmt.Sprint(k.Interface()) + "." + e.Field
 720			}
 721			return b, err
 722		}
 723
 724		m.SetMapIndex(k, v)
 725		i++
 726	}
 727}
 728
 729func (d decoder) decodeMapStringInterface(b []byte, p unsafe.Pointer) ([]byte, error) {
 730	if hasNullPrefix(b) {
 731		*(*unsafe.Pointer)(p) = nil
 732		return b[4:], nil
 733	}
 734
 735	if len(b) < 2 || b[0] != '{' {
 736		return inputError(b, mapStringInterfaceType)
 737	}
 738
 739	i := 0
 740	m := *(*map[string]interface{})(p)
 741
 742	if m == nil {
 743		m = make(map[string]interface{}, 64)
 744	}
 745
 746	var err error
 747	var key string
 748	var val interface{}
 749	var input = b
 750
 751	b = b[1:]
 752	for {
 753		key = ""
 754		val = nil
 755
 756		b = skipSpaces(b)
 757
 758		if len(b) != 0 && b[0] == '}' {
 759			*(*unsafe.Pointer)(p) = *(*unsafe.Pointer)(unsafe.Pointer(&m))
 760			return b[1:], nil
 761		}
 762
 763		if i != 0 {
 764			if len(b) == 0 {
 765				return b, syntaxError(b, "unexpected end of JSON input after object field value")
 766			}
 767			if b[0] != ',' {
 768				return b, syntaxError(b, "expected ',' after object field value but found '%c'", b[0])
 769			}
 770			b = skipSpaces(b[1:])
 771		}
 772
 773		if hasPrefix(b, "null") {
 774			return b, syntaxError(b, "cannot decode object key string from 'null' value")
 775		}
 776
 777		b, err = d.decodeString(b, unsafe.Pointer(&key))
 778		if err != nil {
 779			return objectKeyError(b, err)
 780		}
 781		b = skipSpaces(b)
 782
 783		if len(b) == 0 {
 784			return b, syntaxError(b, "unexpected end of JSON input after object field key")
 785		}
 786		if b[0] != ':' {
 787			return b, syntaxError(b, "expected ':' after object field key but found '%c'", b[0])
 788		}
 789		b = skipSpaces(b[1:])
 790
 791		b, err = d.decodeInterface(b, unsafe.Pointer(&val))
 792		if err != nil {
 793			if _, r, err := parseValue(input); err != nil {
 794				return r, err
 795			} else {
 796				b = r
 797			}
 798			if e, ok := err.(*UnmarshalTypeError); ok {
 799				e.Struct = mapStringInterfaceType.String() + e.Struct
 800				e.Field = key + "." + e.Field
 801			}
 802			return b, err
 803		}
 804
 805		m[key] = val
 806		i++
 807	}
 808}
 809
 810func (d decoder) decodeMapStringRawMessage(b []byte, p unsafe.Pointer) ([]byte, error) {
 811	if hasNullPrefix(b) {
 812		*(*unsafe.Pointer)(p) = nil
 813		return b[4:], nil
 814	}
 815
 816	if len(b) < 2 || b[0] != '{' {
 817		return inputError(b, mapStringRawMessageType)
 818	}
 819
 820	i := 0
 821	m := *(*map[string]RawMessage)(p)
 822
 823	if m == nil {
 824		m = make(map[string]RawMessage, 64)
 825	}
 826
 827	var err error
 828	var key string
 829	var val RawMessage
 830	var input = b
 831
 832	b = b[1:]
 833	for {
 834		key = ""
 835		val = nil
 836
 837		b = skipSpaces(b)
 838
 839		if len(b) != 0 && b[0] == '}' {
 840			*(*unsafe.Pointer)(p) = *(*unsafe.Pointer)(unsafe.Pointer(&m))
 841			return b[1:], nil
 842		}
 843
 844		if i != 0 {
 845			if len(b) == 0 {
 846				return b, syntaxError(b, "unexpected end of JSON input after object field value")
 847			}
 848			if b[0] != ',' {
 849				return b, syntaxError(b, "expected ',' after object field value but found '%c'", b[0])
 850			}
 851			b = skipSpaces(b[1:])
 852		}
 853
 854		if hasPrefix(b, "null") {
 855			return b, syntaxError(b, "cannot decode object key string from 'null' value")
 856		}
 857
 858		b, err = d.decodeString(b, unsafe.Pointer(&key))
 859		if err != nil {
 860			return objectKeyError(b, err)
 861		}
 862		b = skipSpaces(b)
 863
 864		if len(b) == 0 {
 865			return b, syntaxError(b, "unexpected end of JSON input after object field key")
 866		}
 867		if b[0] != ':' {
 868			return b, syntaxError(b, "expected ':' after object field key but found '%c'", b[0])
 869		}
 870		b = skipSpaces(b[1:])
 871
 872		b, err = d.decodeRawMessage(b, unsafe.Pointer(&val))
 873		if err != nil {
 874			if _, r, err := parseValue(input); err != nil {
 875				return r, err
 876			} else {
 877				b = r
 878			}
 879			if e, ok := err.(*UnmarshalTypeError); ok {
 880				e.Struct = mapStringRawMessageType.String() + e.Struct
 881				e.Field = key + "." + e.Field
 882			}
 883			return b, err
 884		}
 885
 886		m[key] = val
 887		i++
 888	}
 889}
 890
 891func (d decoder) decodeStruct(b []byte, p unsafe.Pointer, st *structType) ([]byte, error) {
 892	if hasNullPrefix(b) {
 893		return b[4:], nil
 894	}
 895
 896	if len(b) < 2 || b[0] != '{' {
 897		return inputError(b, st.typ)
 898	}
 899
 900	var err error
 901	var k []byte
 902	var i int
 903
 904	// memory buffer used to convert short field names to lowercase
 905	var buf [64]byte
 906	var key []byte
 907	var input = b
 908
 909	b = b[1:]
 910	for {
 911		b = skipSpaces(b)
 912
 913		if len(b) != 0 && b[0] == '}' {
 914			return b[1:], nil
 915		}
 916
 917		if i != 0 {
 918			if len(b) == 0 {
 919				return b, syntaxError(b, "unexpected end of JSON input after object field value")
 920			}
 921			if b[0] != ',' {
 922				return b, syntaxError(b, "expected ',' after object field value but found '%c'", b[0])
 923			}
 924			b = skipSpaces(b[1:])
 925		}
 926		i++
 927
 928		if hasPrefix(b, "null") {
 929			return b, syntaxError(b, "cannot decode object key string from 'null' value")
 930		}
 931
 932		k, b, _, err = parseStringUnquote(b, nil)
 933		if err != nil {
 934			return objectKeyError(b, err)
 935		}
 936		b = skipSpaces(b)
 937
 938		if len(b) == 0 {
 939			return b, syntaxError(b, "unexpected end of JSON input after object field key")
 940		}
 941		if b[0] != ':' {
 942			return b, syntaxError(b, "expected ':' after object field key but found '%c'", b[0])
 943		}
 944		b = skipSpaces(b[1:])
 945
 946		f := st.fieldsIndex[string(k)]
 947
 948		if f == nil && (d.flags&DontMatchCaseInsensitiveStructFields) == 0 {
 949			key = appendToLower(buf[:0], k)
 950			f = st.ficaseIndex[string(key)]
 951		}
 952
 953		if f == nil {
 954			if (d.flags & DisallowUnknownFields) != 0 {
 955				return b, fmt.Errorf("json: unknown field %q", k)
 956			}
 957			if _, b, err = parseValue(b); err != nil {
 958				return b, err
 959			}
 960			continue
 961		}
 962
 963		if b, err = f.codec.decode(d, b, unsafe.Pointer(uintptr(p)+f.offset)); err != nil {
 964			if _, r, err := parseValue(input); err != nil {
 965				return r, err
 966			} else {
 967				b = r
 968			}
 969			if e, ok := err.(*UnmarshalTypeError); ok {
 970				e.Struct = st.typ.String() + e.Struct
 971				e.Field = string(k) + "." + e.Field
 972			}
 973			return b, err
 974		}
 975	}
 976}
 977
 978func (d decoder) decodeEmbeddedStructPointer(b []byte, p unsafe.Pointer, t reflect.Type, unexported bool, offset uintptr, decode decodeFunc) ([]byte, error) {
 979	v := *(*unsafe.Pointer)(p)
 980
 981	if v == nil {
 982		if unexported {
 983			return nil, fmt.Errorf("json: cannot set embedded pointer to unexported struct: %s", t)
 984		}
 985		v = unsafe.Pointer(reflect.New(t).Pointer())
 986		*(*unsafe.Pointer)(p) = v
 987	}
 988
 989	return decode(d, b, unsafe.Pointer(uintptr(v)+offset))
 990}
 991
 992func (d decoder) decodePointer(b []byte, p unsafe.Pointer, t reflect.Type, decode decodeFunc) ([]byte, error) {
 993	if hasNullPrefix(b) {
 994		pp := *(*unsafe.Pointer)(p)
 995		if pp != nil && t.Kind() == reflect.Ptr {
 996			return decode(d, b, pp)
 997		}
 998		*(*unsafe.Pointer)(p) = nil
 999		return b[4:], nil
1000	}
1001
1002	v := *(*unsafe.Pointer)(p)
1003	if v == nil {
1004		v = unsafe.Pointer(reflect.New(t).Pointer())
1005		*(*unsafe.Pointer)(p) = v
1006	}
1007
1008	return decode(d, b, v)
1009}
1010
1011func (d decoder) decodeInterface(b []byte, p unsafe.Pointer) ([]byte, error) {
1012	val := *(*interface{})(p)
1013	*(*interface{})(p) = nil
1014
1015	if t := reflect.TypeOf(val); t != nil && t.Kind() == reflect.Ptr {
1016		if v := reflect.ValueOf(val); v.IsNil() || t.Elem().Kind() != reflect.Ptr {
1017			// If the destination is nil the only value that is OK to decode is
1018			// `null`, and the encoding/json package always nils the destination
1019			// interface value in this case.
1020			if hasNullPrefix(b) {
1021				*(*interface{})(p) = nil
1022				return b[4:], nil
1023			}
1024		}
1025
1026		b, err := Parse(b, val, d.flags)
1027		if err == nil {
1028			*(*interface{})(p) = val
1029		}
1030		return b, err
1031	}
1032
1033	v, b, err := parseValue(b)
1034	if err != nil {
1035		return b, err
1036	}
1037
1038	switch v[0] {
1039	case '{':
1040		m := make(map[string]interface{})
1041		v, err = d.decodeMapStringInterface(v, unsafe.Pointer(&m))
1042		val = m
1043
1044	case '[':
1045		a := make([]interface{}, 0, 10)
1046		v, err = d.decodeSlice(v, unsafe.Pointer(&a), unsafe.Sizeof(a[0]), sliceInterfaceType, decoder.decodeInterface)
1047		val = a
1048
1049	case '"':
1050		s := ""
1051		v, err = d.decodeString(v, unsafe.Pointer(&s))
1052		val = s
1053
1054	case 'n':
1055		v, err = d.decodeNull(v, nil)
1056		val = nil
1057
1058	case 't', 'f':
1059		x := false
1060		v, err = d.decodeBool(v, unsafe.Pointer(&x))
1061		val = x
1062
1063	case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
1064		if (d.flags & UseNumber) != 0 {
1065			n := Number("")
1066			v, err = d.decodeNumber(v, unsafe.Pointer(&n))
1067			val = n
1068		} else {
1069			f := 0.0
1070			v, err = d.decodeFloat64(v, unsafe.Pointer(&f))
1071			val = f
1072		}
1073
1074	default:
1075		return b, syntaxError(v, "expected token but found '%c'", v[0])
1076	}
1077
1078	if err != nil {
1079		return b, err
1080	}
1081
1082	if v = skipSpaces(v); len(v) != 0 {
1083		return b, syntaxError(v, "unexpected trailing trailing tokens after json value")
1084	}
1085
1086	*(*interface{})(p) = val
1087	return b, nil
1088}
1089
1090func (d decoder) decodeMaybeEmptyInterface(b []byte, p unsafe.Pointer, t reflect.Type) ([]byte, error) {
1091	if hasNullPrefix(b) {
1092		*(*interface{})(p) = nil
1093		return b[4:], nil
1094	}
1095
1096	if x := reflect.NewAt(t, p).Elem(); !x.IsNil() {
1097		if e := x.Elem(); e.Kind() == reflect.Ptr {
1098			return Parse(b, e.Interface(), d.flags)
1099		}
1100	} else if t.NumMethod() == 0 { // empty interface
1101		return Parse(b, (*interface{})(p), d.flags)
1102	}
1103
1104	return d.decodeUnmarshalTypeError(b, p, t)
1105}
1106
1107func (d decoder) decodeUnmarshalTypeError(b []byte, p unsafe.Pointer, t reflect.Type) ([]byte, error) {
1108	v, b, err := parseValue(b)
1109	if err != nil {
1110		return b, err
1111	}
1112	return b, &UnmarshalTypeError{
1113		Value: string(v),
1114		Type:  t,
1115	}
1116}
1117
1118func (d decoder) decodeRawMessage(b []byte, p unsafe.Pointer) ([]byte, error) {
1119	v, r, err := parseValue(b)
1120	if err != nil {
1121		return inputError(b, rawMessageType)
1122	}
1123
1124	if (d.flags & DontCopyRawMessage) == 0 {
1125		v = append(make([]byte, 0, len(v)), v...)
1126	}
1127
1128	*(*RawMessage)(p) = json.RawMessage(v)
1129	return r, err
1130}
1131
1132func (d decoder) decodeJSONUnmarshaler(b []byte, p unsafe.Pointer, t reflect.Type, pointer bool) ([]byte, error) {
1133	v, b, err := parseValue(b)
1134	if err != nil {
1135		return b, err
1136	}
1137
1138	if len(v) != 0 && v[0] == 'n' { // null
1139		return b, nil
1140	}
1141
1142	u := reflect.NewAt(t, p)
1143	if !pointer {
1144		u = u.Elem()
1145		t = t.Elem()
1146	}
1147	if u.IsNil() {
1148		u.Set(reflect.New(t))
1149	}
1150	return b, u.Interface().(Unmarshaler).UnmarshalJSON(v)
1151}
1152
1153func (d decoder) decodeTextUnmarshaler(b []byte, p unsafe.Pointer, t reflect.Type, pointer bool) ([]byte, error) {
1154	var value string
1155
1156	v, b, err := parseValue(b)
1157	if err != nil {
1158		return b, err
1159	}
1160	if len(v) == 0 {
1161		return inputError(v, t)
1162	}
1163
1164	switch v[0] {
1165	case 'n':
1166		_, _, err := parseNull(v)
1167		return b, err
1168	case '"':
1169		s, _, _, err := parseStringUnquote(v, nil)
1170		if err != nil {
1171			return b, err
1172		}
1173		u := reflect.NewAt(t, p)
1174		if !pointer {
1175			u = u.Elem()
1176			t = t.Elem()
1177		}
1178		if u.IsNil() {
1179			u.Set(reflect.New(t))
1180		}
1181		return b, u.Interface().(encoding.TextUnmarshaler).UnmarshalText(s)
1182	case '{':
1183		value = "object"
1184	case '[':
1185		value = "array"
1186	case 't':
1187		value = "true"
1188	case 'f':
1189		value = "false"
1190	case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
1191		value = "number"
1192	}
1193
1194	return b, &UnmarshalTypeError{Value: value, Type: reflect.PtrTo(t)}
1195}