1
2
3
4
5
6
7
8 package json
9
10 import (
11 "bytes"
12 "encoding"
13 "encoding/base64"
14 "errors"
15 "fmt"
16 "reflect"
17 "strconv"
18 "unicode"
19 "unicode/utf16"
20 "unicode/utf8"
21 )
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96 func Unmarshal(data []byte, v interface{}) error {
97
98
99
100 var d decodeState
101 err := checkValid(data, &d.scan)
102 if err != nil {
103 return err
104 }
105
106 d.init(data)
107 return d.unmarshal(v)
108 }
109
110
111
112
113
114
115
116
117
118 type Unmarshaler interface {
119 UnmarshalJSON([]byte) error
120 }
121
122
123
124 type UnmarshalTypeError struct {
125 Value string
126 Type reflect.Type
127 Offset int64
128 Struct string
129 Field string
130 }
131
132 func (e *UnmarshalTypeError) Error() string {
133 if e.Struct != "" || e.Field != "" {
134 return "json: cannot unmarshal " + e.Value + " into Go struct field " + e.Struct + "." + e.Field + " of type " + e.Type.String()
135 }
136 return "json: cannot unmarshal " + e.Value + " into Go value of type " + e.Type.String()
137 }
138
139
140
141
142
143 type UnmarshalFieldError struct {
144 Key string
145 Type reflect.Type
146 Field reflect.StructField
147 }
148
149 func (e *UnmarshalFieldError) Error() string {
150 return "json: cannot unmarshal object key " + strconv.Quote(e.Key) + " into unexported field " + e.Field.Name + " of type " + e.Type.String()
151 }
152
153
154
155 type InvalidUnmarshalError struct {
156 Type reflect.Type
157 }
158
159 func (e *InvalidUnmarshalError) Error() string {
160 if e.Type == nil {
161 return "json: Unmarshal(nil)"
162 }
163
164 if e.Type.Kind() != reflect.Ptr {
165 return "json: Unmarshal(non-pointer " + e.Type.String() + ")"
166 }
167 return "json: Unmarshal(nil " + e.Type.String() + ")"
168 }
169
170 func (d *decodeState) unmarshal(v interface{}) error {
171 rv := reflect.ValueOf(v)
172 if rv.Kind() != reflect.Ptr || rv.IsNil() {
173 return &InvalidUnmarshalError{reflect.TypeOf(v)}
174 }
175
176 d.scan.reset()
177 d.scanWhile(scanSkipSpace)
178
179
180 err := d.value(rv)
181 if err != nil {
182 return d.addErrorContext(err)
183 }
184 return d.savedError
185 }
186
187
188 type Number string
189
190
191 func (n Number) String() string { return string(n) }
192
193
194 func (n Number) Float64() (float64, error) {
195 return strconv.ParseFloat(string(n), 64)
196 }
197
198
199 func (n Number) Int64() (int64, error) {
200 return strconv.ParseInt(string(n), 10, 64)
201 }
202
203
204 func isValidNumber(s string) bool {
205
206
207
208
209 if s == "" {
210 return false
211 }
212
213
214 if s[0] == '-' {
215 s = s[1:]
216 if s == "" {
217 return false
218 }
219 }
220
221
222 switch {
223 default:
224 return false
225
226 case s[0] == '0':
227 s = s[1:]
228
229 case '1' <= s[0] && s[0] <= '9':
230 s = s[1:]
231 for len(s) > 0 && '0' <= s[0] && s[0] <= '9' {
232 s = s[1:]
233 }
234 }
235
236
237 if len(s) >= 2 && s[0] == '.' && '0' <= s[1] && s[1] <= '9' {
238 s = s[2:]
239 for len(s) > 0 && '0' <= s[0] && s[0] <= '9' {
240 s = s[1:]
241 }
242 }
243
244
245
246 if len(s) >= 2 && (s[0] == 'e' || s[0] == 'E') {
247 s = s[1:]
248 if s[0] == '+' || s[0] == '-' {
249 s = s[1:]
250 if s == "" {
251 return false
252 }
253 }
254 for len(s) > 0 && '0' <= s[0] && s[0] <= '9' {
255 s = s[1:]
256 }
257 }
258
259
260 return s == ""
261 }
262
263
264 type decodeState struct {
265 data []byte
266 off int
267 opcode int
268 scan scanner
269 errorContext struct {
270 Struct string
271 Field string
272 }
273 savedError error
274 useNumber bool
275 disallowUnknownFields bool
276 }
277
278
279 func (d *decodeState) readIndex() int {
280 return d.off - 1
281 }
282
283
284
285
286 var errPhase = errors.New("JSON decoder out of sync - data changing underfoot?")
287
288 func (d *decodeState) init(data []byte) *decodeState {
289 d.data = data
290 d.off = 0
291 d.savedError = nil
292 d.errorContext.Struct = ""
293 d.errorContext.Field = ""
294 return d
295 }
296
297
298
299 func (d *decodeState) saveError(err error) {
300 if d.savedError == nil {
301 d.savedError = d.addErrorContext(err)
302 }
303 }
304
305
306 func (d *decodeState) addErrorContext(err error) error {
307 if d.errorContext.Struct != "" || d.errorContext.Field != "" {
308 switch err := err.(type) {
309 case *UnmarshalTypeError:
310 err.Struct = d.errorContext.Struct
311 err.Field = d.errorContext.Field
312 return err
313 }
314 }
315 return err
316 }
317
318
319 func (d *decodeState) skip() {
320 s, data, i := &d.scan, d.data, d.off
321 depth := len(s.parseState)
322 for {
323 op := s.step(s, data[i])
324 i++
325 if len(s.parseState) < depth {
326 d.off = i
327 d.opcode = op
328 return
329 }
330 }
331 }
332
333
334 func (d *decodeState) scanNext() {
335 s, data, i := &d.scan, d.data, d.off
336 if i < len(data) {
337 d.opcode = s.step(s, data[i])
338 d.off = i + 1
339 } else {
340 d.opcode = s.eof()
341 d.off = len(data) + 1
342 }
343 }
344
345
346
347 func (d *decodeState) scanWhile(op int) {
348 s, data, i := &d.scan, d.data, d.off
349 for i < len(d.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(d.data) + 1
360 d.opcode = d.scan.eof()
361 }
362
363
364
365
366 func (d *decodeState) value(v reflect.Value) error {
367 switch d.opcode {
368 default:
369 return errPhase
370
371 case scanBeginArray:
372 if v.IsValid() {
373 if err := d.array(v); err != nil {
374 return err
375 }
376 } else {
377 d.skip()
378 }
379 d.scanNext()
380
381 case scanBeginObject:
382 if v.IsValid() {
383 if err := d.object(v); err != nil {
384 return err
385 }
386 } else {
387 d.skip()
388 }
389 d.scanNext()
390
391 case scanBeginLiteral:
392
393 start := d.readIndex()
394 d.scanWhile(scanContinue)
395
396 if v.IsValid() {
397 if err := d.literalStore(d.data[start:d.readIndex()], v, false); err != nil {
398 return err
399 }
400 }
401 }
402 return nil
403 }
404
405 type unquotedValue struct{}
406
407
408
409
410
411 func (d *decodeState) valueQuoted() (interface{}, error) {
412 switch d.opcode {
413 default:
414 return nil, errPhase
415
416 case scanBeginArray:
417 d.skip()
418 d.scanNext()
419
420 case scanBeginObject:
421 d.skip()
422 d.scanNext()
423
424 case scanBeginLiteral:
425 v, err := d.literalInterface()
426 if err != nil {
427 return nil, err
428 }
429 switch v.(type) {
430 case nil, string:
431 return v, nil
432 }
433 }
434 return unquotedValue{}, nil
435 }
436
437
438
439
440
441 func indirect(v reflect.Value, decodingNull bool) (Unmarshaler, encoding.TextUnmarshaler, reflect.Value) {
442
443
444
445
446
447
448
449
450
451
452
453 v0 := v
454 haveAddr := false
455
456
457
458
459 if v.Kind() != reflect.Ptr && v.Type().Name() != "" && v.CanAddr() {
460 haveAddr = true
461 v = v.Addr()
462 }
463 for {
464
465
466 if v.Kind() == reflect.Interface && !v.IsNil() {
467 e := v.Elem()
468 if e.Kind() == reflect.Ptr && !e.IsNil() && (!decodingNull || e.Elem().Kind() == reflect.Ptr) {
469 haveAddr = false
470 v = e
471 continue
472 }
473 }
474
475 if v.Kind() != reflect.Ptr {
476 break
477 }
478
479 if v.Elem().Kind() != reflect.Ptr && decodingNull && v.CanSet() {
480 break
481 }
482 if v.IsNil() {
483 v.Set(reflect.New(v.Type().Elem()))
484 }
485 if v.Type().NumMethod() > 0 {
486 if u, ok := v.Interface().(Unmarshaler); ok {
487 return u, nil, reflect.Value{}
488 }
489 if !decodingNull {
490 if u, ok := v.Interface().(encoding.TextUnmarshaler); ok {
491 return nil, u, reflect.Value{}
492 }
493 }
494 }
495
496 if haveAddr {
497 v = v0
498 haveAddr = false
499 } else {
500 v = v.Elem()
501 }
502 }
503 return nil, nil, v
504 }
505
506
507
508 func (d *decodeState) array(v reflect.Value) error {
509
510 u, ut, pv := indirect(v, false)
511 if u != nil {
512 start := d.readIndex()
513 d.skip()
514 return u.UnmarshalJSON(d.data[start:d.off])
515 }
516 if ut != nil {
517 d.saveError(&UnmarshalTypeError{Value: "array", Type: v.Type(), Offset: int64(d.off)})
518 d.skip()
519 return nil
520 }
521 v = pv
522
523
524 switch v.Kind() {
525 case reflect.Interface:
526 if v.NumMethod() == 0 {
527
528 ai, err := d.arrayInterface()
529 if err != nil {
530 return err
531 }
532 v.Set(reflect.ValueOf(ai))
533 return nil
534 }
535
536 fallthrough
537 default:
538 d.saveError(&UnmarshalTypeError{Value: "array", Type: v.Type(), Offset: int64(d.off)})
539 d.skip()
540 return nil
541 case reflect.Array:
542 case reflect.Slice:
543 break
544 }
545
546 i := 0
547 for {
548
549 d.scanWhile(scanSkipSpace)
550 if d.opcode == scanEndArray {
551 break
552 }
553
554
555 if v.Kind() == reflect.Slice {
556
557 if i >= v.Cap() {
558 newcap := v.Cap() + v.Cap()/2
559 if newcap < 4 {
560 newcap = 4
561 }
562 newv := reflect.MakeSlice(v.Type(), v.Len(), newcap)
563 reflect.Copy(newv, v)
564 v.Set(newv)
565 }
566 if i >= v.Len() {
567 v.SetLen(i + 1)
568 }
569 }
570
571 if i < v.Len() {
572
573 if err := d.value(v.Index(i)); err != nil {
574 return err
575 }
576 } else {
577
578 if err := d.value(reflect.Value{}); err != nil {
579 return err
580 }
581 }
582 i++
583
584
585 if d.opcode == scanSkipSpace {
586 d.scanWhile(scanSkipSpace)
587 }
588 if d.opcode == scanEndArray {
589 break
590 }
591 if d.opcode != scanArrayValue {
592 return errPhase
593 }
594 }
595
596 if i < v.Len() {
597 if v.Kind() == reflect.Array {
598
599 z := reflect.Zero(v.Type().Elem())
600 for ; i < v.Len(); i++ {
601 v.Index(i).Set(z)
602 }
603 } else {
604 v.SetLen(i)
605 }
606 }
607 if i == 0 && v.Kind() == reflect.Slice {
608 v.Set(reflect.MakeSlice(v.Type(), 0, 0))
609 }
610 return nil
611 }
612
613 var nullLiteral = []byte("null")
614 var textUnmarshalerType = reflect.TypeOf(new(encoding.TextUnmarshaler)).Elem()
615
616
617
618 func (d *decodeState) object(v reflect.Value) error {
619
620 u, ut, pv := indirect(v, false)
621 if u != nil {
622 start := d.readIndex()
623 d.skip()
624 return u.UnmarshalJSON(d.data[start:d.off])
625 }
626 if ut != nil {
627 d.saveError(&UnmarshalTypeError{Value: "object", Type: v.Type(), Offset: int64(d.off)})
628 d.skip()
629 return nil
630 }
631 v = pv
632
633
634 if v.Kind() == reflect.Interface && v.NumMethod() == 0 {
635 oi, err := d.objectInterface()
636 if err != nil {
637 return err
638 }
639 v.Set(reflect.ValueOf(oi))
640 return nil
641 }
642
643
644
645
646
647 switch v.Kind() {
648 case reflect.Map:
649
650
651 t := v.Type()
652 switch t.Key().Kind() {
653 case reflect.String,
654 reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
655 reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
656 default:
657 if !reflect.PtrTo(t.Key()).Implements(textUnmarshalerType) {
658 d.saveError(&UnmarshalTypeError{Value: "object", Type: v.Type(), Offset: int64(d.off)})
659 d.skip()
660 return nil
661 }
662 }
663 if v.IsNil() {
664 v.Set(reflect.MakeMap(t))
665 }
666 case reflect.Struct:
667
668 default:
669 d.saveError(&UnmarshalTypeError{Value: "object", Type: v.Type(), Offset: int64(d.off)})
670 d.skip()
671 return nil
672 }
673
674 var mapElem reflect.Value
675 originalErrorContext := d.errorContext
676
677 for {
678
679 d.scanWhile(scanSkipSpace)
680 if d.opcode == scanEndObject {
681
682 break
683 }
684 if d.opcode != scanBeginLiteral {
685 return errPhase
686 }
687
688
689 start := d.readIndex()
690 d.scanWhile(scanContinue)
691 item := d.data[start:d.readIndex()]
692 key, ok := unquoteBytes(item)
693 if !ok {
694 return errPhase
695 }
696
697
698 var subv reflect.Value
699 destring := false
700
701 if v.Kind() == reflect.Map {
702 elemType := v.Type().Elem()
703 if !mapElem.IsValid() {
704 mapElem = reflect.New(elemType).Elem()
705 } else {
706 mapElem.Set(reflect.Zero(elemType))
707 }
708 subv = mapElem
709 } else {
710 var f *field
711 fields := cachedTypeFields(v.Type())
712 for i := range fields {
713 ff := &fields[i]
714 if bytes.Equal(ff.nameBytes, key) {
715 f = ff
716 break
717 }
718 if f == nil && ff.equalFold(ff.nameBytes, key) {
719 f = ff
720 }
721 }
722 if f != nil {
723 subv = v
724 destring = f.quoted
725 for _, i := range f.index {
726 if subv.Kind() == reflect.Ptr {
727 if subv.IsNil() {
728
729
730
731
732
733 if !subv.CanSet() {
734 d.saveError(fmt.Errorf("json: cannot set embedded pointer to unexported struct: %v", subv.Type().Elem()))
735
736
737 subv = reflect.Value{}
738 destring = false
739 break
740 }
741 subv.Set(reflect.New(subv.Type().Elem()))
742 }
743 subv = subv.Elem()
744 }
745 subv = subv.Field(i)
746 }
747 d.errorContext.Field = f.name
748 d.errorContext.Struct = v.Type().Name()
749 } else if d.disallowUnknownFields {
750 d.saveError(fmt.Errorf("json: unknown field %q", key))
751 }
752 }
753
754
755 if d.opcode == scanSkipSpace {
756 d.scanWhile(scanSkipSpace)
757 }
758 if d.opcode != scanObjectKey {
759 return errPhase
760 }
761 d.scanWhile(scanSkipSpace)
762
763 if destring {
764 q, err := d.valueQuoted()
765 if err != nil {
766 return err
767 }
768 switch qv := q.(type) {
769 case nil:
770 if err := d.literalStore(nullLiteral, subv, false); err != nil {
771 return err
772 }
773 case string:
774 if err := d.literalStore([]byte(qv), subv, true); err != nil {
775 return err
776 }
777 default:
778 d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal unquoted value into %v", subv.Type()))
779 }
780 } else {
781 if err := d.value(subv); err != nil {
782 return err
783 }
784 }
785
786
787
788 if v.Kind() == reflect.Map {
789 kt := v.Type().Key()
790 var kv reflect.Value
791 switch {
792 case kt.Kind() == reflect.String:
793 kv = reflect.ValueOf(key).Convert(kt)
794 case reflect.PtrTo(kt).Implements(textUnmarshalerType):
795 kv = reflect.New(v.Type().Key())
796 if err := d.literalStore(item, kv, true); err != nil {
797 return err
798 }
799 kv = kv.Elem()
800 default:
801 switch kt.Kind() {
802 case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
803 s := string(key)
804 n, err := strconv.ParseInt(s, 10, 64)
805 if err != nil || reflect.Zero(kt).OverflowInt(n) {
806 d.saveError(&UnmarshalTypeError{Value: "number " + s, Type: kt, Offset: int64(start + 1)})
807 return nil
808 }
809 kv = reflect.ValueOf(n).Convert(kt)
810 case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
811 s := string(key)
812 n, err := strconv.ParseUint(s, 10, 64)
813 if err != nil || reflect.Zero(kt).OverflowUint(n) {
814 d.saveError(&UnmarshalTypeError{Value: "number " + s, Type: kt, Offset: int64(start + 1)})
815 return nil
816 }
817 kv = reflect.ValueOf(n).Convert(kt)
818 default:
819 panic("json: Unexpected key type")
820 }
821 }
822 v.SetMapIndex(kv, subv)
823 }
824
825
826 if d.opcode == scanSkipSpace {
827 d.scanWhile(scanSkipSpace)
828 }
829 if d.opcode == scanEndObject {
830 break
831 }
832 if d.opcode != scanObjectValue {
833 return errPhase
834 }
835
836 d.errorContext = originalErrorContext
837 }
838 return nil
839 }
840
841
842
843 func (d *decodeState) convertNumber(s string) (interface{}, error) {
844 if d.useNumber {
845 return Number(s), nil
846 }
847 f, err := strconv.ParseFloat(s, 64)
848 if err != nil {
849 return nil, &UnmarshalTypeError{Value: "number " + s, Type: reflect.TypeOf(0.0), Offset: int64(d.off)}
850 }
851 return f, nil
852 }
853
854 var numberType = reflect.TypeOf(Number(""))
855
856
857
858
859
860
861 func (d *decodeState) literalStore(item []byte, v reflect.Value, fromQuoted bool) error {
862
863 if len(item) == 0 {
864
865 d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
866 return nil
867 }
868 isNull := item[0] == 'n'
869 u, ut, pv := indirect(v, isNull)
870 if u != nil {
871 return u.UnmarshalJSON(item)
872 }
873 if ut != nil {
874 if item[0] != '"' {
875 if fromQuoted {
876 d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
877 } else {
878 var val string
879 switch item[0] {
880 case 'n':
881 val = "null"
882 case 't', 'f':
883 val = "bool"
884 default:
885 val = "number"
886 }
887 d.saveError(&UnmarshalTypeError{Value: val, Type: v.Type(), Offset: int64(d.readIndex())})
888 }
889 return nil
890 }
891 s, ok := unquoteBytes(item)
892 if !ok {
893 if fromQuoted {
894 return fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type())
895 }
896 return errPhase
897 }
898 return ut.UnmarshalText(s)
899 }
900
901 v = pv
902
903 switch c := item[0]; c {
904 case 'n':
905
906
907 if fromQuoted && string(item) != "null" {
908 d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
909 break
910 }
911 switch v.Kind() {
912 case reflect.Interface, reflect.Ptr, reflect.Map, reflect.Slice:
913 v.Set(reflect.Zero(v.Type()))
914
915 }
916 case 't', 'f':
917 value := item[0] == 't'
918
919
920 if fromQuoted && string(item) != "true" && string(item) != "false" {
921 d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
922 break
923 }
924 switch v.Kind() {
925 default:
926 if fromQuoted {
927 d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
928 } else {
929 d.saveError(&UnmarshalTypeError{Value: "bool", Type: v.Type(), Offset: int64(d.readIndex())})
930 }
931 case reflect.Bool:
932 v.SetBool(value)
933 case reflect.Interface:
934 if v.NumMethod() == 0 {
935 v.Set(reflect.ValueOf(value))
936 } else {
937 d.saveError(&UnmarshalTypeError{Value: "bool", Type: v.Type(), Offset: int64(d.readIndex())})
938 }
939 }
940
941 case '"':
942 s, ok := unquoteBytes(item)
943 if !ok {
944 if fromQuoted {
945 return fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type())
946 }
947 return errPhase
948 }
949 switch v.Kind() {
950 default:
951 d.saveError(&UnmarshalTypeError{Value: "string", Type: v.Type(), Offset: int64(d.readIndex())})
952 case reflect.Slice:
953 if v.Type().Elem().Kind() != reflect.Uint8 {
954 d.saveError(&UnmarshalTypeError{Value: "string", Type: v.Type(), Offset: int64(d.readIndex())})
955 break
956 }
957 b := make([]byte, base64.StdEncoding.DecodedLen(len(s)))
958 n, err := base64.StdEncoding.Decode(b, s)
959 if err != nil {
960 d.saveError(err)
961 break
962 }
963 v.SetBytes(b[:n])
964 case reflect.String:
965 v.SetString(string(s))
966 case reflect.Interface:
967 if v.NumMethod() == 0 {
968 v.Set(reflect.ValueOf(string(s)))
969 } else {
970 d.saveError(&UnmarshalTypeError{Value: "string", Type: v.Type(), Offset: int64(d.readIndex())})
971 }
972 }
973
974 default:
975 if c != '-' && (c < '0' || c > '9') {
976 if fromQuoted {
977 return fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type())
978 }
979 return errPhase
980 }
981 s := string(item)
982 switch v.Kind() {
983 default:
984 if v.Kind() == reflect.String && v.Type() == numberType {
985 v.SetString(s)
986 if !isValidNumber(s) {
987 return fmt.Errorf("json: invalid number literal, trying to unmarshal %q into Number", item)
988 }
989 break
990 }
991 if fromQuoted {
992 return fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type())
993 }
994 d.saveError(&UnmarshalTypeError{Value: "number", Type: v.Type(), Offset: int64(d.readIndex())})
995 case reflect.Interface:
996 n, err := d.convertNumber(s)
997 if err != nil {
998 d.saveError(err)
999 break
1000 }
1001 if v.NumMethod() != 0 {
1002 d.saveError(&UnmarshalTypeError{Value: "number", Type: v.Type(), Offset: int64(d.readIndex())})
1003 break
1004 }
1005 v.Set(reflect.ValueOf(n))
1006
1007 case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
1008 n, err := strconv.ParseInt(s, 10, 64)
1009 if err != nil || v.OverflowInt(n) {
1010 d.saveError(&UnmarshalTypeError{Value: "number " + s, Type: v.Type(), Offset: int64(d.readIndex())})
1011 break
1012 }
1013 v.SetInt(n)
1014
1015 case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
1016 n, err := strconv.ParseUint(s, 10, 64)
1017 if err != nil || v.OverflowUint(n) {
1018 d.saveError(&UnmarshalTypeError{Value: "number " + s, Type: v.Type(), Offset: int64(d.readIndex())})
1019 break
1020 }
1021 v.SetUint(n)
1022
1023 case reflect.Float32, reflect.Float64:
1024 n, err := strconv.ParseFloat(s, v.Type().Bits())
1025 if err != nil || v.OverflowFloat(n) {
1026 d.saveError(&UnmarshalTypeError{Value: "number " + s, Type: v.Type(), Offset: int64(d.readIndex())})
1027 break
1028 }
1029 v.SetFloat(n)
1030 }
1031 }
1032 return nil
1033 }
1034
1035
1036
1037
1038
1039
1040 func (d *decodeState) valueInterface() (val interface{}, err error) {
1041 switch d.opcode {
1042 default:
1043 err = errPhase
1044 case scanBeginArray:
1045 val, err = d.arrayInterface()
1046 d.scanNext()
1047 case scanBeginObject:
1048 val, err = d.objectInterface()
1049 d.scanNext()
1050 case scanBeginLiteral:
1051 val, err = d.literalInterface()
1052 }
1053 return
1054 }
1055
1056
1057 func (d *decodeState) arrayInterface() ([]interface{}, error) {
1058 var v = make([]interface{}, 0)
1059 for {
1060
1061 d.scanWhile(scanSkipSpace)
1062 if d.opcode == scanEndArray {
1063 break
1064 }
1065
1066 vi, err := d.valueInterface()
1067 if err != nil {
1068 return nil, err
1069 }
1070 v = append(v, vi)
1071
1072
1073 if d.opcode == scanSkipSpace {
1074 d.scanWhile(scanSkipSpace)
1075 }
1076 if d.opcode == scanEndArray {
1077 break
1078 }
1079 if d.opcode != scanArrayValue {
1080 return nil, errPhase
1081 }
1082 }
1083 return v, nil
1084 }
1085
1086
1087 func (d *decodeState) objectInterface() (map[string]interface{}, error) {
1088 m := make(map[string]interface{})
1089 for {
1090
1091 d.scanWhile(scanSkipSpace)
1092 if d.opcode == scanEndObject {
1093
1094 break
1095 }
1096 if d.opcode != scanBeginLiteral {
1097 return nil, errPhase
1098 }
1099
1100
1101 start := d.readIndex()
1102 d.scanWhile(scanContinue)
1103 item := d.data[start:d.readIndex()]
1104 key, ok := unquote(item)
1105 if !ok {
1106 return nil, errPhase
1107 }
1108
1109
1110 if d.opcode == scanSkipSpace {
1111 d.scanWhile(scanSkipSpace)
1112 }
1113 if d.opcode != scanObjectKey {
1114 return nil, errPhase
1115 }
1116 d.scanWhile(scanSkipSpace)
1117
1118
1119 vi, err := d.valueInterface()
1120 if err != nil {
1121 return nil, err
1122 }
1123 m[key] = vi
1124
1125
1126 if d.opcode == scanSkipSpace {
1127 d.scanWhile(scanSkipSpace)
1128 }
1129 if d.opcode == scanEndObject {
1130 break
1131 }
1132 if d.opcode != scanObjectValue {
1133 return nil, errPhase
1134 }
1135 }
1136 return m, nil
1137 }
1138
1139
1140
1141
1142 func (d *decodeState) literalInterface() (interface{}, error) {
1143
1144 start := d.readIndex()
1145 d.scanWhile(scanContinue)
1146
1147 item := d.data[start:d.readIndex()]
1148
1149 switch c := item[0]; c {
1150 case 'n':
1151 return nil, nil
1152
1153 case 't', 'f':
1154 return c == 't', nil
1155
1156 case '"':
1157 s, ok := unquote(item)
1158 if !ok {
1159 return nil, errPhase
1160 }
1161 return s, nil
1162
1163 default:
1164 if c != '-' && (c < '0' || c > '9') {
1165 return nil, errPhase
1166 }
1167 n, err := d.convertNumber(string(item))
1168 if err != nil {
1169 d.saveError(err)
1170 }
1171 return n, nil
1172 }
1173 }
1174
1175
1176
1177 func getu4(s []byte) rune {
1178 if len(s) < 6 || s[0] != '\\' || s[1] != 'u' {
1179 return -1
1180 }
1181 var r rune
1182 for _, c := range s[2:6] {
1183 switch {
1184 case '0' <= c && c <= '9':
1185 c = c - '0'
1186 case 'a' <= c && c <= 'f':
1187 c = c - 'a' + 10
1188 case 'A' <= c && c <= 'F':
1189 c = c - 'A' + 10
1190 default:
1191 return -1
1192 }
1193 r = r*16 + rune(c)
1194 }
1195 return r
1196 }
1197
1198
1199
1200 func unquote(s []byte) (t string, ok bool) {
1201 s, ok = unquoteBytes(s)
1202 t = string(s)
1203 return
1204 }
1205
1206 func unquoteBytes(s []byte) (t []byte, ok bool) {
1207 if len(s) < 2 || s[0] != '"' || s[len(s)-1] != '"' {
1208 return
1209 }
1210 s = s[1 : len(s)-1]
1211
1212
1213
1214
1215 r := 0
1216 for r < len(s) {
1217 c := s[r]
1218 if c == '\\' || c == '"' || c < ' ' {
1219 break
1220 }
1221 if c < utf8.RuneSelf {
1222 r++
1223 continue
1224 }
1225 rr, size := utf8.DecodeRune(s[r:])
1226 if rr == utf8.RuneError && size == 1 {
1227 break
1228 }
1229 r += size
1230 }
1231 if r == len(s) {
1232 return s, true
1233 }
1234
1235 b := make([]byte, len(s)+2*utf8.UTFMax)
1236 w := copy(b, s[0:r])
1237 for r < len(s) {
1238
1239
1240
1241 if w >= len(b)-2*utf8.UTFMax {
1242 nb := make([]byte, (len(b)+utf8.UTFMax)*2)
1243 copy(nb, b[0:w])
1244 b = nb
1245 }
1246 switch c := s[r]; {
1247 case c == '\\':
1248 r++
1249 if r >= len(s) {
1250 return
1251 }
1252 switch s[r] {
1253 default:
1254 return
1255 case '"', '\\', '/', '\'':
1256 b[w] = s[r]
1257 r++
1258 w++
1259 case 'b':
1260 b[w] = '\b'
1261 r++
1262 w++
1263 case 'f':
1264 b[w] = '\f'
1265 r++
1266 w++
1267 case 'n':
1268 b[w] = '\n'
1269 r++
1270 w++
1271 case 'r':
1272 b[w] = '\r'
1273 r++
1274 w++
1275 case 't':
1276 b[w] = '\t'
1277 r++
1278 w++
1279 case 'u':
1280 r--
1281 rr := getu4(s[r:])
1282 if rr < 0 {
1283 return
1284 }
1285 r += 6
1286 if utf16.IsSurrogate(rr) {
1287 rr1 := getu4(s[r:])
1288 if dec := utf16.DecodeRune(rr, rr1); dec != unicode.ReplacementChar {
1289
1290 r += 6
1291 w += utf8.EncodeRune(b[w:], dec)
1292 break
1293 }
1294
1295 rr = unicode.ReplacementChar
1296 }
1297 w += utf8.EncodeRune(b[w:], rr)
1298 }
1299
1300
1301 case c == '"', c < ' ':
1302 return
1303
1304
1305 case c < utf8.RuneSelf:
1306 b[w] = c
1307 r++
1308 w++
1309
1310
1311 default:
1312 rr, size := utf8.DecodeRune(s[r:])
1313 r += size
1314 w += utf8.EncodeRune(b[w:], rr)
1315 }
1316 }
1317 return b[0:w], true
1318 }
1319
View as plain text