iter_float.go raw
1 package jsoniter
2
3 import (
4 "encoding/json"
5 "io"
6 "math/big"
7 "strconv"
8 "strings"
9 "unsafe"
10 )
11
12 var floatDigits []int8
13
14 const invalidCharForNumber = int8(-1)
15 const endOfNumber = int8(-2)
16 const dotInNumber = int8(-3)
17
18 func init() {
19 floatDigits = make([]int8, 256)
20 for i := 0; i < len(floatDigits); i++ {
21 floatDigits[i] = invalidCharForNumber
22 }
23 for i := int8('0'); i <= int8('9'); i++ {
24 floatDigits[i] = i - int8('0')
25 }
26 floatDigits[','] = endOfNumber
27 floatDigits[']'] = endOfNumber
28 floatDigits['}'] = endOfNumber
29 floatDigits[' '] = endOfNumber
30 floatDigits['\t'] = endOfNumber
31 floatDigits['\n'] = endOfNumber
32 floatDigits['.'] = dotInNumber
33 }
34
35 // ReadBigFloat read big.Float
36 func (iter *Iterator) ReadBigFloat() (ret *big.Float) {
37 str := iter.readNumberAsString()
38 if iter.Error != nil && iter.Error != io.EOF {
39 return nil
40 }
41 prec := 64
42 if len(str) > prec {
43 prec = len(str)
44 }
45 val, _, err := big.ParseFloat(str, 10, uint(prec), big.ToZero)
46 if err != nil {
47 iter.Error = err
48 return nil
49 }
50 return val
51 }
52
53 // ReadBigInt read big.Int
54 func (iter *Iterator) ReadBigInt() (ret *big.Int) {
55 str := iter.readNumberAsString()
56 if iter.Error != nil && iter.Error != io.EOF {
57 return nil
58 }
59 ret = big.NewInt(0)
60 var success bool
61 ret, success = ret.SetString(str, 10)
62 if !success {
63 iter.ReportError("ReadBigInt", "invalid big int")
64 return nil
65 }
66 return ret
67 }
68
69 //ReadFloat32 read float32
70 func (iter *Iterator) ReadFloat32() (ret float32) {
71 c := iter.nextToken()
72 if c == '-' {
73 return -iter.readPositiveFloat32()
74 }
75 iter.unreadByte()
76 return iter.readPositiveFloat32()
77 }
78
79 func (iter *Iterator) readPositiveFloat32() (ret float32) {
80 i := iter.head
81 // first char
82 if i == iter.tail {
83 return iter.readFloat32SlowPath()
84 }
85 c := iter.buf[i]
86 i++
87 ind := floatDigits[c]
88 switch ind {
89 case invalidCharForNumber:
90 return iter.readFloat32SlowPath()
91 case endOfNumber:
92 iter.ReportError("readFloat32", "empty number")
93 return
94 case dotInNumber:
95 iter.ReportError("readFloat32", "leading dot is invalid")
96 return
97 case 0:
98 if i == iter.tail {
99 return iter.readFloat32SlowPath()
100 }
101 c = iter.buf[i]
102 switch c {
103 case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
104 iter.ReportError("readFloat32", "leading zero is invalid")
105 return
106 }
107 }
108 value := uint64(ind)
109 // chars before dot
110 non_decimal_loop:
111 for ; i < iter.tail; i++ {
112 c = iter.buf[i]
113 ind := floatDigits[c]
114 switch ind {
115 case invalidCharForNumber:
116 return iter.readFloat32SlowPath()
117 case endOfNumber:
118 iter.head = i
119 return float32(value)
120 case dotInNumber:
121 break non_decimal_loop
122 }
123 if value > uint64SafeToMultiple10 {
124 return iter.readFloat32SlowPath()
125 }
126 value = (value << 3) + (value << 1) + uint64(ind) // value = value * 10 + ind;
127 }
128 // chars after dot
129 if c == '.' {
130 i++
131 decimalPlaces := 0
132 if i == iter.tail {
133 return iter.readFloat32SlowPath()
134 }
135 for ; i < iter.tail; i++ {
136 c = iter.buf[i]
137 ind := floatDigits[c]
138 switch ind {
139 case endOfNumber:
140 if decimalPlaces > 0 && decimalPlaces < len(pow10) {
141 iter.head = i
142 return float32(float64(value) / float64(pow10[decimalPlaces]))
143 }
144 // too many decimal places
145 return iter.readFloat32SlowPath()
146 case invalidCharForNumber, dotInNumber:
147 return iter.readFloat32SlowPath()
148 }
149 decimalPlaces++
150 if value > uint64SafeToMultiple10 {
151 return iter.readFloat32SlowPath()
152 }
153 value = (value << 3) + (value << 1) + uint64(ind)
154 }
155 }
156 return iter.readFloat32SlowPath()
157 }
158
159 func (iter *Iterator) readNumberAsString() (ret string) {
160 strBuf := [16]byte{}
161 str := strBuf[0:0]
162 load_loop:
163 for {
164 for i := iter.head; i < iter.tail; i++ {
165 c := iter.buf[i]
166 switch c {
167 case '+', '-', '.', 'e', 'E', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
168 str = append(str, c)
169 continue
170 default:
171 iter.head = i
172 break load_loop
173 }
174 }
175 if !iter.loadMore() {
176 break
177 }
178 }
179 if iter.Error != nil && iter.Error != io.EOF {
180 return
181 }
182 if len(str) == 0 {
183 iter.ReportError("readNumberAsString", "invalid number")
184 }
185 return *(*string)(unsafe.Pointer(&str))
186 }
187
188 func (iter *Iterator) readFloat32SlowPath() (ret float32) {
189 str := iter.readNumberAsString()
190 if iter.Error != nil && iter.Error != io.EOF {
191 return
192 }
193 errMsg := validateFloat(str)
194 if errMsg != "" {
195 iter.ReportError("readFloat32SlowPath", errMsg)
196 return
197 }
198 val, err := strconv.ParseFloat(str, 32)
199 if err != nil {
200 iter.Error = err
201 return
202 }
203 return float32(val)
204 }
205
206 // ReadFloat64 read float64
207 func (iter *Iterator) ReadFloat64() (ret float64) {
208 c := iter.nextToken()
209 if c == '-' {
210 return -iter.readPositiveFloat64()
211 }
212 iter.unreadByte()
213 return iter.readPositiveFloat64()
214 }
215
216 func (iter *Iterator) readPositiveFloat64() (ret float64) {
217 i := iter.head
218 // first char
219 if i == iter.tail {
220 return iter.readFloat64SlowPath()
221 }
222 c := iter.buf[i]
223 i++
224 ind := floatDigits[c]
225 switch ind {
226 case invalidCharForNumber:
227 return iter.readFloat64SlowPath()
228 case endOfNumber:
229 iter.ReportError("readFloat64", "empty number")
230 return
231 case dotInNumber:
232 iter.ReportError("readFloat64", "leading dot is invalid")
233 return
234 case 0:
235 if i == iter.tail {
236 return iter.readFloat64SlowPath()
237 }
238 c = iter.buf[i]
239 switch c {
240 case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
241 iter.ReportError("readFloat64", "leading zero is invalid")
242 return
243 }
244 }
245 value := uint64(ind)
246 // chars before dot
247 non_decimal_loop:
248 for ; i < iter.tail; i++ {
249 c = iter.buf[i]
250 ind := floatDigits[c]
251 switch ind {
252 case invalidCharForNumber:
253 return iter.readFloat64SlowPath()
254 case endOfNumber:
255 iter.head = i
256 return float64(value)
257 case dotInNumber:
258 break non_decimal_loop
259 }
260 if value > uint64SafeToMultiple10 {
261 return iter.readFloat64SlowPath()
262 }
263 value = (value << 3) + (value << 1) + uint64(ind) // value = value * 10 + ind;
264 }
265 // chars after dot
266 if c == '.' {
267 i++
268 decimalPlaces := 0
269 if i == iter.tail {
270 return iter.readFloat64SlowPath()
271 }
272 for ; i < iter.tail; i++ {
273 c = iter.buf[i]
274 ind := floatDigits[c]
275 switch ind {
276 case endOfNumber:
277 if decimalPlaces > 0 && decimalPlaces < len(pow10) {
278 iter.head = i
279 return float64(value) / float64(pow10[decimalPlaces])
280 }
281 // too many decimal places
282 return iter.readFloat64SlowPath()
283 case invalidCharForNumber, dotInNumber:
284 return iter.readFloat64SlowPath()
285 }
286 decimalPlaces++
287 if value > uint64SafeToMultiple10 {
288 return iter.readFloat64SlowPath()
289 }
290 value = (value << 3) + (value << 1) + uint64(ind)
291 if value > maxFloat64 {
292 return iter.readFloat64SlowPath()
293 }
294 }
295 }
296 return iter.readFloat64SlowPath()
297 }
298
299 func (iter *Iterator) readFloat64SlowPath() (ret float64) {
300 str := iter.readNumberAsString()
301 if iter.Error != nil && iter.Error != io.EOF {
302 return
303 }
304 errMsg := validateFloat(str)
305 if errMsg != "" {
306 iter.ReportError("readFloat64SlowPath", errMsg)
307 return
308 }
309 val, err := strconv.ParseFloat(str, 64)
310 if err != nil {
311 iter.Error = err
312 return
313 }
314 return val
315 }
316
317 func validateFloat(str string) string {
318 // strconv.ParseFloat is not validating `1.` or `1.e1`
319 if len(str) == 0 {
320 return "empty number"
321 }
322 if str[0] == '-' {
323 return "-- is not valid"
324 }
325 dotPos := strings.IndexByte(str, '.')
326 if dotPos != -1 {
327 if dotPos == len(str)-1 {
328 return "dot can not be last character"
329 }
330 switch str[dotPos+1] {
331 case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
332 default:
333 return "missing digit after dot"
334 }
335 }
336 return ""
337 }
338
339 // ReadNumber read json.Number
340 func (iter *Iterator) ReadNumber() (ret json.Number) {
341 return json.Number(iter.readNumberAsString())
342 }
343