1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
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
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
|
package json
import (
"fmt"
"reflect"
)
// Transition functions for recognizing NumberInt and NumberLong.
// Adapted from encoding/json/scanner.go.
// stateUpperNu is the state after reading `Nu`.
func stateUpperNu(s *scanner, c int) int {
if c == 'm' {
s.step = generateState("Number", []byte("ber"), stateUpperNumber)
return scanContinue
}
return s.error(c, "in literal Number (expecting 'm')")
}
// stateUpperNumber is the state after reading `Number`.
func stateUpperNumber(s *scanner, c int) int {
if c == 'I' {
s.step = generateState("NumberInt", []byte("nt"), stateConstructor)
return scanContinue
}
if c == 'L' {
s.step = generateState("NumberLong", []byte("ong"), stateConstructor)
return scanContinue
}
return s.error(c, "in literal NumberInt or NumberLong (expecting 'I' or 'L')")
}
// Decodes a NumberInt literal stored in the underlying byte data into v.
func (d *decodeState) storeNumberInt(v reflect.Value) {
op := d.scanWhile(scanSkipSpace)
if op != scanBeginCtor {
d.error(fmt.Errorf("expected beginning of constructor"))
}
args, err := d.ctor("NumberInt", []reflect.Type{numberIntType})
if err != nil {
d.error(err)
}
switch kind := v.Kind(); kind {
case reflect.Interface:
v.Set(args[0])
default:
d.error(fmt.Errorf("cannot store %v value into %v type", numberIntType, kind))
}
}
// Returns a NumberInt literal from the underlying byte data.
func (d *decodeState) getNumberInt() interface{} {
op := d.scanWhile(scanSkipSpace)
if op != scanBeginCtor {
d.error(fmt.Errorf("expected beginning of constructor"))
}
// Prevent d.convertNumber() from parsing the argument as a float64.
useNumber := d.useNumber
d.useNumber = true
args := d.ctorInterface()
if err := ctorNumArgsMismatch("NumberInt", 1, len(args)); err != nil {
d.error(err)
}
var number Number
switch v := args[0].(type) {
case Number:
number = v
case string:
number = Number(v)
default:
d.error(fmt.Errorf("expected int32 for first argument of NumberInt constructor, got %T (value was %v)", v, v))
}
d.useNumber = useNumber
arg0, err := number.Int32()
if err != nil {
d.error(fmt.Errorf("expected int32 for first argument of NumberInt constructor, got %T (value was %v)", number, number))
}
return NumberInt(arg0)
}
// Decodes a NumberLong literal stored in the underlying byte data into v.
func (d *decodeState) storeNumberLong(v reflect.Value) {
op := d.scanWhile(scanSkipSpace)
if op != scanBeginCtor {
d.error(fmt.Errorf("expected beginning of constructor"))
}
args, err := d.ctor("NumberLong", []reflect.Type{numberLongType})
if err != nil {
d.error(err)
}
switch kind := v.Kind(); kind {
case reflect.Interface:
v.Set(args[0])
default:
d.error(fmt.Errorf("cannot store %v value into %v type", numberLongType, kind))
}
}
// Returns a NumberLong literal from the underlying byte data.
func (d *decodeState) getNumberLong() interface{} {
op := d.scanWhile(scanSkipSpace)
if op != scanBeginCtor {
d.error(fmt.Errorf("expected beginning of constructor"))
}
// Prevent d.convertNumber() from parsing the argument as a float64.
useNumber := d.useNumber
d.useNumber = true
args := d.ctorInterface()
if err := ctorNumArgsMismatch("NumberLong", 1, len(args)); err != nil {
d.error(err)
}
var number Number
switch v := args[0].(type) {
case Number:
number = v
case string:
number = Number(v)
default:
d.error(fmt.Errorf("expected int64 for first argument of NumberLong constructor, got %T (value was %v)", v, v))
}
d.useNumber = useNumber
arg0, err := number.Int64()
if err != nil {
d.error(fmt.Errorf("expected int64 for first argument of NumberLong constructor, got %T (value was %v)", number, number))
}
return NumberLong(arg0)
}
|
