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