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