1package gojay
2
3// DecodeFloat64 reads the next JSON-encoded value from the decoder's input (io.Reader) and stores it in the float64 pointed to by v.
4//
5// See the documentation for Unmarshal for details about the conversion of JSON into a Go value.
6func (dec *Decoder) DecodeFloat64(v *float64) error {
7	if dec.isPooled == 1 {
8		panic(InvalidUsagePooledDecoderError("Invalid usage of pooled decoder"))
9	}
10	return dec.decodeFloat64(v)
11}
12func (dec *Decoder) decodeFloat64(v *float64) error {
13	for ; dec.cursor < dec.length || dec.read(); dec.cursor++ {
14		switch c := dec.data[dec.cursor]; c {
15		case ' ', '\n', '\t', '\r', ',':
16			continue
17		case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
18			val, err := dec.getFloat()
19			if err != nil {
20				return err
21			}
22			*v = val
23			return nil
24		case '-':
25			dec.cursor = dec.cursor + 1
26			val, err := dec.getFloatNegative()
27			if err != nil {
28				return err
29			}
30			*v = -val
31			return nil
32		case 'n':
33			dec.cursor++
34			err := dec.assertNull()
35			if err != nil {
36				return err
37			}
38			return nil
39		default:
40			dec.err = dec.makeInvalidUnmarshalErr(v)
41			err := dec.skipData()
42			if err != nil {
43				return err
44			}
45			return nil
46		}
47	}
48	return dec.raiseInvalidJSONErr(dec.cursor)
49}
50func (dec *Decoder) decodeFloat64Null(v **float64) error {
51	for ; dec.cursor < dec.length || dec.read(); dec.cursor++ {
52		switch c := dec.data[dec.cursor]; c {
53		case ' ', '\n', '\t', '\r', ',':
54			continue
55		case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
56			val, err := dec.getFloat()
57			if err != nil {
58				return err
59			}
60			if *v == nil {
61				*v = new(float64)
62			}
63			**v = val
64			return nil
65		case '-':
66			dec.cursor = dec.cursor + 1
67			val, err := dec.getFloatNegative()
68			if err != nil {
69				return err
70			}
71			if *v == nil {
72				*v = new(float64)
73			}
74			**v = -val
75			return nil
76		case 'n':
77			dec.cursor++
78			err := dec.assertNull()
79			if err != nil {
80				return err
81			}
82			return nil
83		default:
84			dec.err = dec.makeInvalidUnmarshalErr(v)
85			err := dec.skipData()
86			if err != nil {
87				return err
88			}
89			return nil
90		}
91	}
92	return dec.raiseInvalidJSONErr(dec.cursor)
93}
94
95func (dec *Decoder) getFloatNegative() (float64, error) {
96	// look for following numbers
97	for ; dec.cursor < dec.length || dec.read(); dec.cursor++ {
98		switch dec.data[dec.cursor] {
99		case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
100			return dec.getFloat()
101		default:
102			return 0, dec.raiseInvalidJSONErr(dec.cursor)
103		}
104	}
105	return 0, dec.raiseInvalidJSONErr(dec.cursor)
106}
107
108func (dec *Decoder) getFloat() (float64, error) {
109	var end = dec.cursor
110	var start = dec.cursor
111	// look for following numbers
112	for j := dec.cursor + 1; j < dec.length || dec.read(); j++ {
113		switch dec.data[j] {
114		case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
115			end = j
116			continue
117		case '.':
118			// we get part before decimal as integer
119			beforeDecimal := dec.atoi64(start, end)
120			// then we get part after decimal as integer
121			start = j + 1
122			// get number after the decimal point
123			for i := j + 1; i < dec.length || dec.read(); i++ {
124				c := dec.data[i]
125				if isDigit(c) {
126					end = i
127					// multiply the before decimal point portion by 10 using bitwise
128					// make sure it doesn't overflow
129					if end-start < 18 {
130						beforeDecimal = (beforeDecimal << 3) + (beforeDecimal << 1)
131					}
132					continue
133				} else if (c == 'e' || c == 'E') && j < i-1 {
134					// we have an exponent, convert first the value we got before the exponent
135					var afterDecimal int64
136					expI := end - start + 2
137					// if exp is too long, it means number is too long, just truncate the number
138					if expI >= len(pow10uint64) || expI < 0 {
139						expI = len(pow10uint64) - 2
140						afterDecimal = dec.atoi64(start, start+expI-2)
141					} else {
142						// then we add both integers
143						// then we divide the number by the power found
144						afterDecimal = dec.atoi64(start, end)
145					}
146					dec.cursor = i + 1
147					pow := pow10uint64[expI]
148					floatVal := float64(beforeDecimal+afterDecimal) / float64(pow)
149					exp, err := dec.getExponent()
150					if err != nil {
151						return 0, err
152					}
153					pExp := (exp + (exp >> 31)) ^ (exp >> 31) + 1 // absolute exponent
154					if pExp >= int64(len(pow10uint64)) || pExp < 0 {
155						return 0, dec.raiseInvalidJSONErr(dec.cursor)
156					}
157					// if exponent is negative
158					if exp < 0 {
159						return float64(floatVal) * (1 / float64(pow10uint64[pExp])), nil
160					}
161					return float64(floatVal) * float64(pow10uint64[pExp]), nil
162				}
163				dec.cursor = i
164				break
165			}
166			if end >= dec.length || end < start {
167				return 0, dec.raiseInvalidJSONErr(dec.cursor)
168			}
169			var afterDecimal int64
170			expI := end - start + 2
171			// if exp is too long, it means number is too long, just truncate the number
172			if expI >= len(pow10uint64) || expI < 0 {
173				expI = 19
174				afterDecimal = dec.atoi64(start, start+expI-2)
175			} else {
176				afterDecimal = dec.atoi64(start, end)
177			}
178
179			pow := pow10uint64[expI]
180			// then we add both integers
181			// then we divide the number by the power found
182			return float64(beforeDecimal+afterDecimal) / float64(pow), nil
183		case 'e', 'E':
184			dec.cursor = j + 1
185			// we get part before decimal as integer
186			beforeDecimal := uint64(dec.atoi64(start, end))
187			// get exponent
188			exp, err := dec.getExponent()
189			if err != nil {
190				return 0, err
191			}
192			pExp := (exp + (exp >> 31)) ^ (exp >> 31) + 1 // abs
193			if pExp >= int64(len(pow10uint64)) || pExp < 0 {
194				return 0, dec.raiseInvalidJSONErr(dec.cursor)
195			}
196			// if exponent is negative
197			if exp < 0 {
198				return float64(beforeDecimal) * (1 / float64(pow10uint64[pExp])), nil
199			}
200			return float64(beforeDecimal) * float64(pow10uint64[pExp]), nil
201		case ' ', '\n', '\t', '\r', ',', '}', ']': // does not have decimal
202			dec.cursor = j
203			return float64(dec.atoi64(start, end)), nil
204		}
205		// invalid json we expect numbers, dot (single one), comma, or spaces
206		return 0, dec.raiseInvalidJSONErr(dec.cursor)
207	}
208	return float64(dec.atoi64(start, end)), nil
209}
210
211// DecodeFloat32 reads the next JSON-encoded value from the decoder's input (io.Reader) and stores it in the float32 pointed to by v.
212//
213// See the documentation for Unmarshal for details about the conversion of JSON into a Go value.
214func (dec *Decoder) DecodeFloat32(v *float32) error {
215	if dec.isPooled == 1 {
216		panic(InvalidUsagePooledDecoderError("Invalid usage of pooled decoder"))
217	}
218	return dec.decodeFloat32(v)
219}
220func (dec *Decoder) decodeFloat32(v *float32) error {
221	for ; dec.cursor < dec.length || dec.read(); dec.cursor++ {
222		switch c := dec.data[dec.cursor]; c {
223		case ' ', '\n', '\t', '\r', ',':
224			continue
225		case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
226			val, err := dec.getFloat32()
227			if err != nil {
228				return err
229			}
230			*v = val
231			return nil
232		case '-':
233			dec.cursor = dec.cursor + 1
234			val, err := dec.getFloat32Negative()
235			if err != nil {
236				return err
237			}
238			*v = -val
239			return nil
240		case 'n':
241			dec.cursor++
242			err := dec.assertNull()
243			if err != nil {
244				return err
245			}
246			return nil
247		default:
248			dec.err = dec.makeInvalidUnmarshalErr(v)
249			err := dec.skipData()
250			if err != nil {
251				return err
252			}
253			return nil
254		}
255	}
256	return dec.raiseInvalidJSONErr(dec.cursor)
257}
258func (dec *Decoder) decodeFloat32Null(v **float32) error {
259	for ; dec.cursor < dec.length || dec.read(); dec.cursor++ {
260		switch c := dec.data[dec.cursor]; c {
261		case ' ', '\n', '\t', '\r', ',':
262			continue
263		case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
264			val, err := dec.getFloat32()
265			if err != nil {
266				return err
267			}
268			if *v == nil {
269				*v = new(float32)
270			}
271			**v = val
272			return nil
273		case '-':
274			dec.cursor = dec.cursor + 1
275			val, err := dec.getFloat32Negative()
276			if err != nil {
277				return err
278			}
279			if *v == nil {
280				*v = new(float32)
281			}
282			**v = -val
283			return nil
284		case 'n':
285			dec.cursor++
286			err := dec.assertNull()
287			if err != nil {
288				return err
289			}
290			return nil
291		default:
292			dec.err = dec.makeInvalidUnmarshalErr(v)
293			err := dec.skipData()
294			if err != nil {
295				return err
296			}
297			return nil
298		}
299	}
300	return dec.raiseInvalidJSONErr(dec.cursor)
301}
302
303func (dec *Decoder) getFloat32Negative() (float32, error) {
304	// look for following numbers
305	for ; dec.cursor < dec.length || dec.read(); dec.cursor++ {
306		switch dec.data[dec.cursor] {
307		case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
308			return dec.getFloat32()
309		default:
310			return 0, dec.raiseInvalidJSONErr(dec.cursor)
311		}
312	}
313	return 0, dec.raiseInvalidJSONErr(dec.cursor)
314}
315
316func (dec *Decoder) getFloat32() (float32, error) {
317	var end = dec.cursor
318	var start = dec.cursor
319	// look for following numbers
320	for j := dec.cursor + 1; j < dec.length || dec.read(); j++ {
321		switch dec.data[j] {
322		case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
323			end = j
324			continue
325		case '.':
326			// we get part before decimal as integer
327			beforeDecimal := dec.atoi64(start, end)
328			// then we get part after decimal as integer
329			start = j + 1
330			// get number after the decimal point
331			// multiple the before decimal point portion by 10 using bitwise
332			for i := j + 1; i < dec.length || dec.read(); i++ {
333				c := dec.data[i]
334				if isDigit(c) {
335					end = i
336					// multiply the before decimal point portion by 10 using bitwise
337					// make sure it desn't overflow
338					if end-start < 9 {
339						beforeDecimal = (beforeDecimal << 3) + (beforeDecimal << 1)
340					}
341					continue
342				} else if (c == 'e' || c == 'E') && j < i-1 {
343					// we get the number before decimal
344					var afterDecimal int64
345					expI := end - start + 2
346					// if exp is too long, it means number is too long, just truncate the number
347					if expI >= 12 || expI < 0 {
348						expI = 10
349						afterDecimal = dec.atoi64(start, start+expI-2)
350					} else {
351						afterDecimal = dec.atoi64(start, end)
352					}
353					dec.cursor = i + 1
354					pow := pow10uint64[expI]
355					// then we add both integers
356					// then we divide the number by the power found
357					floatVal := float32(beforeDecimal+afterDecimal) / float32(pow)
358					exp, err := dec.getExponent()
359					if err != nil {
360						return 0, err
361					}
362					pExp := (exp + (exp >> 31)) ^ (exp >> 31) + 1 // abs
363					if pExp >= int64(len(pow10uint64)) || pExp < 0 {
364						return 0, dec.raiseInvalidJSONErr(dec.cursor)
365					}
366					// if exponent is negative
367					if exp < 0 {
368						return float32(floatVal) * (1 / float32(pow10uint64[pExp])), nil
369					}
370					return float32(floatVal) * float32(pow10uint64[pExp]), nil
371				}
372				dec.cursor = i
373				break
374			}
375			if end >= dec.length || end < start {
376				return 0, dec.raiseInvalidJSONErr(dec.cursor)
377			}
378			// then we add both integers
379			// then we divide the number by the power found
380			var afterDecimal int64
381			expI := end - start + 2
382			// if exp is too long, it means number is too long, just truncate the number
383			if expI >= 12 || expI < 0 {
384				expI = 10
385				afterDecimal = dec.atoi64(start, start+expI-2)
386			} else {
387				// then we add both integers
388				// then we divide the number by the power found
389				afterDecimal = dec.atoi64(start, end)
390			}
391			pow := pow10uint64[expI]
392			return float32(beforeDecimal+afterDecimal) / float32(pow), nil
393		case 'e', 'E':
394			dec.cursor = j + 1
395			// we get part before decimal as integer
396			beforeDecimal := dec.atoi64(start, end)
397			// get exponent
398			exp, err := dec.getExponent()
399			if err != nil {
400				return 0, err
401			}
402			pExp := (exp + (exp >> 31)) ^ (exp >> 31) + 1
403			if pExp >= int64(len(pow10uint64)) || pExp < 0 {
404				return 0, dec.raiseInvalidJSONErr(dec.cursor)
405			}
406			// if exponent is negative
407			if exp < 0 {
408				return float32(beforeDecimal) * (1 / float32(pow10uint64[pExp])), nil
409			}
410			return float32(beforeDecimal) * float32(pow10uint64[pExp]), nil
411		case ' ', '\n', '\t', '\r', ',', '}', ']': // does not have decimal
412			dec.cursor = j
413			return float32(dec.atoi64(start, end)), nil
414		}
415		// invalid json we expect numbers, dot (single one), comma, or spaces
416		return 0, dec.raiseInvalidJSONErr(dec.cursor)
417	}
418	return float32(dec.atoi64(start, end)), nil
419}
420
421// Add Values functions
422
423// AddFloat decodes the JSON value within an object or an array to a *float64.
424// If next key value overflows float64, an InvalidUnmarshalError error will be returned.
425func (dec *Decoder) AddFloat(v *float64) error {
426	return dec.Float64(v)
427}
428
429// AddFloatNull decodes the JSON value within an object or an array to a *float64.
430// If next key value overflows float64, an InvalidUnmarshalError error will be returned.
431// If a `null` is encountered, gojay does not change the value of the pointer.
432func (dec *Decoder) AddFloatNull(v **float64) error {
433	return dec.Float64Null(v)
434}
435
436// AddFloat64 decodes the JSON value within an object or an array to a *float64.
437// If next key value overflows float64, an InvalidUnmarshalError error will be returned.
438func (dec *Decoder) AddFloat64(v *float64) error {
439	return dec.Float64(v)
440}
441
442// AddFloat64Null decodes the JSON value within an object or an array to a *float64.
443// If next key value overflows float64, an InvalidUnmarshalError error will be returned.
444// If a `null` is encountered, gojay does not change the value of the pointer.
445func (dec *Decoder) AddFloat64Null(v **float64) error {
446	return dec.Float64Null(v)
447}
448
449// AddFloat32 decodes the JSON value within an object or an array to a *float64.
450// If next key value overflows float64, an InvalidUnmarshalError error will be returned.
451func (dec *Decoder) AddFloat32(v *float32) error {
452	return dec.Float32(v)
453}
454
455// AddFloat32Null decodes the JSON value within an object or an array to a *float64.
456// If next key value overflows float64, an InvalidUnmarshalError error will be returned.
457// If a `null` is encountered, gojay does not change the value of the pointer.
458func (dec *Decoder) AddFloat32Null(v **float32) error {
459	return dec.Float32Null(v)
460}
461
462// Float decodes the JSON value within an object or an array to a *float64.
463// If next key value overflows float64, an InvalidUnmarshalError error will be returned.
464func (dec *Decoder) Float(v *float64) error {
465	return dec.Float64(v)
466}
467
468// FloatNull decodes the JSON value within an object or an array to a *float64.
469// If next key value overflows float64, an InvalidUnmarshalError error will be returned.
470func (dec *Decoder) FloatNull(v **float64) error {
471	return dec.Float64Null(v)
472}
473
474// Float64 decodes the JSON value within an object or an array to a *float64.
475// If next key value overflows float64, an InvalidUnmarshalError error will be returned.
476func (dec *Decoder) Float64(v *float64) error {
477	err := dec.decodeFloat64(v)
478	if err != nil {
479		return err
480	}
481	dec.called |= 1
482	return nil
483}
484
485// Float64Null decodes the JSON value within an object or an array to a *float64.
486// If next key value overflows float64, an InvalidUnmarshalError error will be returned.
487func (dec *Decoder) Float64Null(v **float64) error {
488	err := dec.decodeFloat64Null(v)
489	if err != nil {
490		return err
491	}
492	dec.called |= 1
493	return nil
494}
495
496// Float32 decodes the JSON value within an object or an array to a *float64.
497// If next key value overflows float64, an InvalidUnmarshalError error will be returned.
498func (dec *Decoder) Float32(v *float32) error {
499	err := dec.decodeFloat32(v)
500	if err != nil {
501		return err
502	}
503	dec.called |= 1
504	return nil
505}
506
507// Float32Null decodes the JSON value within an object or an array to a *float64.
508// If next key value overflows float64, an InvalidUnmarshalError error will be returned.
509func (dec *Decoder) Float32Null(v **float32) error {
510	err := dec.decodeFloat32Null(v)
511	if err != nil {
512		return err
513	}
514	dec.called |= 1
515	return nil
516}
517