admin/simdjson-simdjson
1
0
Fork 0
mirror of https://github.com/simdjson/simdjson synced 2026-06-08 17:27:07 +00:00
Code Issues Packages Projects Releases Wiki Activity

Reduce nesting somewhat with different if() order

Browse Source
This commit is contained in:
John Keiser
2020-06-26 13:31:25 -07:00
parent 85f6f5bd29
commit 4c1256acc4
1 changed files with 14 additions and 24 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/generic/stage2/numberparsing.h
+14 -24
View File
@@ -290,9 +290,8 @@ never_inline bool parse_large_integer(const uint8_t *const src,
}
}
if (negative) {
if (i > 0x8000000000000000) {
return INVALID_NUMBER(src); // overflow: -i won't fit in INT32_MIN
} else if (i == 0x8000000000000000) {
if (i > 0x8000000000000000) { return INVALID_NUMBER(src); } // overflow: -i won't fit in INT32_MIN
if (i == 0x8000000000000000) {
// In two's complement, we cannot represent 0x8000000000000000
// as a positive signed integer, but the negative version is
// possible.
@@ -385,16 +384,13 @@ really_inline bool parse_number(UNUSED const uint8_t *const src,
// the integer into a float in a lossless manner.
++p;
const char *const first_after_period = p;
if (is_integer(*p)) {
unsigned char digit = static_cast<unsigned char>(*p - '0');
++p;
i = i * 10 + digit; // might overflow + multiplication by 10 is likely
// cheaper than arbitrary mult.
// we will handle the overflow later
} else {
// There must be at least one digit after the .
return INVALID_NUMBER(src);
}
if (!is_integer(*p)) { return INVALID_NUMBER(src); } // There must be at least one digit after the .
unsigned char digit = static_cast<unsigned char>(*p - '0');
++p;
i = i * 10 + digit; // might overflow + multiplication by 10 is likely
// cheaper than arbitrary mult.
// we will handle the overflow later
#ifdef SWAR_NUMBER_PARSING
// this helps if we have lots of decimals!
// this turns out to be frequent enough.
@@ -404,15 +400,14 @@ really_inline bool parse_number(UNUSED const uint8_t *const src,
}
#endif
while (is_integer(*p)) {
unsigned char digit = static_cast<unsigned char>(*p - '0');
digit = static_cast<unsigned char>(*p - '0');
++p;
i = i * 10 + digit; // in rare cases, this will overflow, but that's ok
// because we have parse_highprecision_float later.
}
exponent = first_after_period - p;
}
int digit_count =
int(p - start_digits) - 1; // used later to guard against overflows
int digit_count = int(p - start_digits) - 1; // used later to guard against overflows
int64_t exp_number = 0; // exponential part
if (('e' == *p) || ('E' == *p)) {
is_float = true;
@@ -492,15 +487,10 @@ really_inline bool parse_number(UNUSED const uint8_t *const src,
double d = compute_float_64(exponent, i, negative, &success);
if (!success) {
// we are almost never going to get here.
success = parse_float_strtod((const char *)src, &d);
}
if (success) {
WRITE_DOUBLE(d, src, writer);
return true;
} else {
// parse_float_strtod failed!
return INVALID_NUMBER(src);
if (!parse_float_strtod((const char *)src, &d)) { return INVALID_NUMBER(src); }
}
WRITE_DOUBLE(d, src, writer);
return true;
} else {
if (unlikely(digit_count >= 18)) { // this is uncommon!!!
// there is a good chance that we had an overflow, so we need