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