CLN: use integer parsing functions from stdlib #62658
There are no files selected for viewing
| Original file line number | Diff line number | Diff line change |
|---|---|---|
|
|
@@ -21,8 +21,11 @@ GitHub. See Python Software Foundation License and BSD licenses for these. | |
|
|
||
| #include <ctype.h> | ||
| #include <float.h> | ||
| #include <limits.h> | ||
| #include <math.h> | ||
| #include <stdbool.h> | ||
| #include <stddef.h> | ||
| #include <stdlib.h> | ||
|
|
||
| #include "pandas/portable.h" | ||
| #include "pandas/vendored/klib/khash.h" // for kh_int64_t, kh_destroy_int64 | ||
|
|
@@ -1834,201 +1837,203 @@ int uint64_conflict(uint_state *self) { | |
| return self->seen_uint && (self->seen_sint || self->seen_null); | ||
| } | ||
|
|
||
| /** | ||
| * @brief Check if the character in the pointer indicates a number. | ||
| * It expects that you consumed all leading whitespace. | ||
| * | ||
| * @param p_item Pointer to verify | ||
| * @return Non-zero integer indicating that has a digit 0 otherwise. | ||
| */ | ||
| static inline bool has_digit_int(const char *str) { | ||
| if (!str || *str == '\0') { | ||
| return false; | ||
| } | ||
|
|
||
| switch (*str) { | ||
| case '0': | ||
| case '1': | ||
| case '2': | ||
| case '3': | ||
| case '4': | ||
| case '5': | ||
| case '6': | ||
| case '7': | ||
| case '8': | ||
| case '9': | ||
| return true; | ||
| case '+': | ||
| case '-': | ||
| return isdigit_ascii(str[1]); | ||
|
||
| default: | ||
| return false; | ||
| } | ||
| } | ||
|
|
||
| static inline bool has_only_spaces(const char *str) { | ||
| while (*str != '\0' && isspace_ascii(*str)) { | ||
| str++; | ||
| } | ||
| return *str == '\0'; | ||
| } | ||
|
|
||
| static int power_int(int base, int exponent) { | ||
|
||
| // https://en.wikipedia.org/wiki/Exponentiation_by_squaring | ||
| if (exponent == 0) { | ||
| return 1; | ||
| } else if (exponent < 0) { | ||
| return 0; | ||
| } | ||
|
|
||
| int result = 1; | ||
|
|
||
| while (exponent > 1) { | ||
| if (exponent % 2 == 1) { | ||
| result *= base; | ||
| exponent--; | ||
| } | ||
| result *= result; | ||
| exponent /= 2; | ||
| } | ||
|
|
||
| return result * base; | ||
|
||
| } | ||
|
|
||
| static inline int64_t add_int_check_overflow(int64_t lhs, int64_t rhs, | ||
|
||
| int64_t mul_lhs) { | ||
| // rhs will always be positive, because this function | ||
| // only executes after the first parse, hence the sign will always go to lhs. | ||
| // if lhs > 0: | ||
| // Will overflow if (mul_lhs * lhs) + rhs > INT_MAX | ||
| // iff lhs > (INT_MAX - rhs) / mul_lhs | ||
| // if lhs < 0: | ||
| // Will underflow if (mul_lhs * lhs) - rhs < INT_MIN | ||
| // iff lhs < (INT_MIN + rhs) / mul_lhs | ||
| if (lhs >= 0) { | ||
| if (lhs > (INT_MAX - rhs) / mul_lhs) { | ||
| errno = ERANGE; | ||
|
||
| } | ||
| } else { | ||
| if (lhs < (INT_MIN + rhs) / mul_lhs) { | ||
| errno = ERANGE; | ||
| } | ||
| rhs = -rhs; | ||
| } | ||
| return lhs * mul_lhs + rhs; | ||
| } | ||
|
|
||
| static inline uint64_t add_uint_check_overflow(uint64_t lhs, uint64_t rhs, | ||
| uint64_t mul_lhs) { | ||
| if (lhs > (UINT_MAX - rhs) / mul_lhs) { | ||
| errno = ERANGE; | ||
| } | ||
| return lhs * mul_lhs + rhs; | ||
| } | ||
|
|
||
| int64_t str_to_int64(const char *p_item, int64_t int_min, int64_t int_max, | ||
| int *error, char tsep) { | ||
| if (!p_item || *p_item == '\0') { | ||
|
||
| *error = ERROR_NO_DIGITS; | ||
| return 0; | ||
| } | ||
|
|
||
| while (isspace_ascii(*p_item)) { | ||
| ++p_item; | ||
| } | ||
|
|
||
| if (!has_digit_int(p_item)) { | ||
| *error = ERROR_NO_DIGITS; | ||
| return 0; | ||
| } | ||
|
|
||
| errno = 0; | ||
|
||
| char *endptr = NULL; | ||
WillAyd marked this conversation as resolved.
Outdated
Show resolved
Hide resolved
|
||
| int64_t result = strtoll(p_item, &endptr, 10); | ||
|
|
||
| while (errno == 0 && tsep != '\0' && *endptr == tsep) { | ||
| // Skip multiple consecutive tsep | ||
| while (*endptr == tsep) { | ||
|
||
| endptr++; | ||
| } | ||
|
|
||
| char *new_end = NULL; | ||
|
||
| int64_t next_part = strtoll(endptr, &new_end, 10); | ||
| ptrdiff_t digits = new_end - endptr; | ||
| int64_t mul_result = power_int(10, (int)digits); | ||
|
||
| result = add_int_check_overflow(result, next_part, mul_result); | ||
| endptr = new_end; | ||
| } | ||
|
|
||
| if (!has_only_spaces(endptr)) { | ||
| // Check first for invalid characters because we may | ||
| // want to skip integer parsing if we find one. | ||
| *error = ERROR_INVALID_CHARS; | ||
| result = 0; | ||
| } else if (errno == ERANGE || result > int_max || result < int_min) { | ||
|
||
| *error = ERROR_OVERFLOW; | ||
| result = 0; | ||
| } else { | ||
| *error = 0; | ||
| } | ||
|
|
||
| return result; | ||
| } | ||
|
|
||
| uint64_t str_to_uint64(uint_state *state, const char *p_item, int64_t int_max, | ||
| uint64_t uint_max, int *error, char tsep) { | ||
| if (!p_item || *p_item == '\0') { | ||
| *error = ERROR_NO_DIGITS; | ||
| return 0; | ||
| } | ||
|
|
||
| while (isspace_ascii(*p_item)) { | ||
|
||
| ++p_item; | ||
| } | ||
|
|
||
| if (*p_item == '-') { | ||
| state->seen_sint = 1; | ||
| *error = 0; | ||
| return 0; | ||
| } else if (*p_item == '+') { | ||
| p_item++; | ||
| } | ||
|
|
||
| // Check that there is a first digit. | ||
| if (!isdigit_ascii(*p_item)) { | ||
| *error = ERROR_NO_DIGITS; | ||
| return 0; | ||
| } | ||
|
|
||
| errno = 0; | ||
| char *endptr = NULL; | ||
|
||
| uint64_t result = strtoull(p_item, &endptr, 10); | ||
|
|
||
| while (errno == 0 && tsep != '\0' && *endptr == tsep) { | ||
| // Skip multiple consecutive tsep | ||
| while (*endptr == tsep) { | ||
| endptr++; | ||
| } | ||
|
|
||
| char *new_end = NULL; | ||
| uint64_t next_part = strtoull(endptr, &new_end, 10); | ||
| ptrdiff_t digits = new_end - endptr; | ||
| uint64_t mul_result = power_int(10, (int)digits); | ||
| result = add_uint_check_overflow(result, next_part, mul_result); | ||
| endptr = new_end; | ||
| } | ||
|
|
||
| if (!has_only_spaces(endptr)) { | ||
| *error = ERROR_INVALID_CHARS; | ||
| result = 0; | ||
| } else if (errno == ERANGE || result > uint_max) { | ||
| *error = ERROR_OVERFLOW; | ||
| result = 0; | ||
| } else { | ||
| *error = 0; | ||
| } | ||
|
|
||
| if (result > (uint64_t)int_max) { | ||
| state->seen_uint = 1; | ||
| } | ||
|
|
||
| return result; | ||
| } | ||
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
Going back to my comment made (in another PR?) - if we replace the
char **words member with a custom struct, we could add to that struct a member that flags this as the word is built, rather than coming back after the fact.Not something to tackle in this PR - just wanted to give you an idea