py/parsenum: Extend mp_parse_num_integer() to parse long long.

projectgus · projectgus · commit 3b737ad54b7e · 2025-05-08T10:56:39.000+10:00
If long integer support is 'long long' then mp_parse_num_integer() can
parse to it directly instead of failing over from small int.

One tricky case this correctly overflows on is things like
int("9223372036854775808") which is one more than LLONG_MAX in decimal. No
unit test case added for this as it's too hard to detect 64-bit long
integer mode.

This work was funded through GitHub Sponsors.

Signed-off-by: Angus Gratton &lt;angus@redyak.com.au&gt;
diff --git a/py/objint_longlong.c b/py/objint_longlong.c
@@ -39,8 +39,6 @@
 
 #if MICROPY_LONGINT_IMPL == MICROPY_LONGINT_IMPL_LONGLONG
 
-#include <errno.h>
-
 #if MICROPY_PY_SYS_MAXSIZE
 // Export value for sys.maxsize
 const mp_obj_int_t mp_sys_maxsize_obj = {{&mp_type_int}, MP_SSIZE_MAX};
@@ -300,49 +298,6 @@ mp_obj_t mp_obj_new_int_from_ull(unsigned long long val) {
     return mp_obj_new_int_from_ll(val);
 }
 
-mp_obj_t mp_obj_new_int_from_str_len(const char **str, size_t len, bool neg, unsigned int base) {
-    char temp_buf[65]; // Large enough to hold 64-bit base 2 str + NUL terminating byte
-    const char *head = *str;
-    char *endptr;
-    long long parsed;
-
-    errno = 0;
-    parsed = strtoll(head, &endptr, base);
-
-    // If 'str' is not properly terminated and has valid digits all through
-    // and after the buffer, then strtoll will have walked off the end
-    if (endptr > head + len) {
-        // Disregard any leading zeroes to ensure the value can fit
-        while (len >= sizeof(temp_buf) && base != 0 && *head == '0') {
-            head++;
-            len--;
-        }
-        if (len < sizeof(temp_buf)) {
-            memcpy(temp_buf, head, len);
-            temp_buf[len] = 0;
-            errno = 0;
-            parsed = strtoll(temp_buf, &endptr, base);
-            assert(errno != 0 || endptr == temp_buf + len); // The first strtoll() checked all digits are valid
-            endptr = (char *)head + len;
-        }
-        // (if str doesn't fit in temp_buf, will fall through and fail below)
-    }
-
-    if (errno != 0) {
-        return mp_const_none; // Conversion failed, caller should raise OverflowError
-    }
-
-    if (neg) {
-        parsed *= -1;
-    }
-
-    mp_obj_t result = mp_obj_new_int_from_ll(parsed);
-
-    // If endptr isn't (head + len) then string contained invalid chars, caller should fail
-    *str = endptr;
-    return result;
-}
-
 mp_int_t mp_obj_int_get_truncated(mp_const_obj_t self_in) {
     if (mp_obj_is_small_int(self_in)) {
         return MP_OBJ_SMALL_INT_VALUE(self_in);
diff --git a/py/parsenum.c b/py/parsenum.c
@@ -46,6 +46,29 @@ static NORETURN void raise_exc(mp_obj_t exc, mp_lexer_t *lex) {
     nlr_raise(exc);
 }
 
+// mp_parse_num_integer parses a small integer directly, except for the
+// special case where bigint support is long long, in which case
+// it parses long long and returns either a long long or a small int.
+#if MICROPY_LONGINT_IMPL != MICROPY_LONGINT_IMPL_LONGLONG
+typedef mp_int_t parsed_int_t;
+
+#define parsed_int_mul_overflow mp_small_int_mul_overflow
+inline static bool parsed_int_fits(parsed_int_t int_val, mp_uint_t dig) {
+    return MP_SMALL_INT_FITS(int_val + dig);
+}
+#else
+typedef long long parsed_int_t;
+
+#define parsed_int_mul_overflow mp_mul_ll_overflow
+
+inline static bool parsed_int_fits(parsed_int_t int_val, mp_uint_t dig) {
+    // Unlike MP_SMALL_INT, we can't be assured that adding a digit won't
+    // trigger an overflow so need to explicitly check
+    assert(int_val >= 0);
+    return int_val <= LLONG_MAX - dig;
+}
+#endif
+
 mp_obj_t mp_parse_num_integer(const char *restrict str_, size_t len, int base, mp_lexer_t *lex) {
     const byte *restrict str = (const byte *)str_;
     const byte *restrict top = str + len;
@@ -76,7 +99,7 @@ mp_obj_t mp_parse_num_integer(const char *restrict str_, size_t len, int base, m
     str += mp_parse_num_base((const char *)str, top - str, &base);
 
     // string should be an integer number
-    mp_int_t int_val = 0;
+    parsed_int_t int_val = 0;
     const byte *restrict str_val_start = str;
     for (; str < top; str++) {
         // get next digit as a value
@@ -99,24 +122,27 @@ mp_obj_t mp_parse_num_integer(const char *restrict str_, size_t len, int base, m
         }
 
         // add next digi and check for overflow
-        if (mp_small_int_mul_overflow(int_val, base, &int_val)) {
+        if (parsed_int_mul_overflow(int_val, base, &int_val)) {
             goto overflow;
         }
-        int_val += dig;
-        if (!MP_SMALL_INT_FITS(int_val)) {
+        if (!parsed_int_fits(int_val, dig)) {
             goto overflow;
         }
+        int_val += dig;
     }
 
     // negate value if needed
     if (neg) {
         int_val = -int_val;
     }
 
-    // create the small int
+    #if MICROPY_LONGINT_IMPL == MICROPY_LONGINT_IMPL_LONGLONG
+    ret_val = mp_obj_new_int_from_ll(int_val); // Could be large or small int
+    #else
     ret_val = MP_OBJ_NEW_SMALL_INT(int_val);
-
 have_ret_val:
+    #endif
+
     // check we parsed something
     if (str == str_val_start) {
         goto value_error;
@@ -135,13 +161,17 @@ mp_obj_t mp_parse_num_integer(const char *restrict str_, size_t len, int base, m
     return ret_val;
 
 overflow:
+    #if MICROPY_LONGINT_IMPL != MICROPY_LONGINT_IMPL_LONGLONG
     // reparse using long int
     {
         const char *s2 = (const char *)str_val_start;
         ret_val = mp_obj_new_int_from_str_len(&s2, top - str_val_start, neg, base);
         str = (const byte *)s2;
         goto have_ret_val;
     }
+    #else
+    mp_raise_msg(&mp_type_OverflowError, MP_ERROR_TEXT("result overflows long long storage"));
+    #endif
 
 value_error:
     {
diff --git a/tests/extmod/uctypes_array_load_store.py b/tests/extmod/uctypes_array_load_store.py
@@ -9,7 +9,7 @@
 # 'int' needs to be able to represent UINT64 for this test
 try:
     int("FF" * 8, 16)
-except ValueError:
+except OverflowError:
     print("SKIP")
     raise SystemExit
 
