feat(stdlib): numeric string conversions

2026-09-03 21:53:59 -04:00
parent bcb4e259c3
commit 26786e9027
6 changed files with 2036 additions and 0 deletions
@@ -0,0 +1,149 @@
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stddef.h>
+
+#include <limits.h>
+
+#include "../internal/strtox.h"
+
+/*
+ * Shared integer subject-sequence scan (todo 11). See src/internal/strtox.h
+ * for the contract; this file is the engine the strtol/strtoul wrappers and
+ * todo 14's strtoimax/strtoumax build on.
+ *
+ * Prefix rules (C23 7.24.1.4p3-4):
+ *   - base 0: "0x"/"0X" followed by a hex digit selects base 16 and the
+ *     prefix is consumed; a bare leading 0 selects base 8 and the 0 is the
+ *     subject itself ("0" is a valid integer constant, so the subject is
+ *     never empty after an octal prefix); anything else is base 10.
+ *   - base 16: "0x"/"0X" followed by a hex digit is consumed; without a
+ *     hex digit the "0" is itself a valid hex digit and the x terminates
+ *     the subject.
+ *   - "0x" without a hex digit under base 0 is no integer-constant form,
+ *     so there is no subject sequence at all.
+ *
+ * Endptr always lands at the first character that is not part of the
+ * subject sequence, or at nptr when there is no subject (C23 7.24.1.4p5,
+ * even when whitespace or a sign was consumed).
+ */
+
+int
+__strtox_scan(const char *nptr, char **endptr, int base, int *neg, unsigned long long *mag,
+              int *over)
+{
+    const char *s = nptr;
+    int sg = 0;
+    int ov = 0;
+    int digits = 0;
+    int consumed_prefix = 0;
+    unsigned long long m = 0;
+
+    while (strtox_isspace(*s))
+    {
+        s++;
+    }
+    if (*s == '+' || *s == '-')
+    {
+        sg = (*s == '-');
+        s++;
+    }
+    if (base != 0 && (base < 2 || base > 36))
+    {
+        if (endptr)
+        {
+            *endptr = (char *)nptr;
+        }
+        *neg = 0;
+        *mag = 0;
+        *over = 0;
+        return STRTOX_BADBASE;
+    }
+
+    if (base == 0 || base == 16)
+    {
+        if (s[0] == '0' && (s[1] == 'x' || s[1] == 'X'))
+        {
+            int d2 = strtox_digit(s[2]);
+
+            if (d2 >= 0 && d2 < 16)
+            {
+                base = 16;
+                s += 2;
+            }
+            else if (base == 0)
+            {
+                /* "0x" with no hex digit is no integer-constant form. */
+                if (endptr)
+                {
+                    *endptr = (char *)nptr;
+                }
+                *neg = 0;
+                *mag = 0;
+                *over = 0;
+                return STRTOX_EMPTY;
+            }
+            /* base 16: the 0 itself is the subject; the x ends it. */
+        }
+        else if (base == 0 && s[0] == '0')
+        {
+            /* Octal prefix: the 0 opens the subject even when no octal
+             * digit follows ("0" is itself a valid integer constant). */
+            base = 8;
+            consumed_prefix = 1;
+            s++;
+        }
+        else if (base == 0)
+        {
+            /* No prefix: a decimal subject (base 0 auto-detection). */
+            base = 10;
+        }
+    }
+
+    for (;;)
+    {
+        int d = strtox_digit(*s);
+
+        if (d < 0 || d >= base)
+        {
+            break;
+        }
+        if (ov == 0)
+        {
+            unsigned long long lim =
+                (ULLONG_MAX - (unsigned long long)d) / (unsigned long long)base;
+
+            if (m > lim)
+            {
+                ov = 1;
+            }
+            else
+            {
+                m = (m * (unsigned long long)base) + (unsigned long long)d;
+            }
+        }
+        digits++;
+        s++;
+    }
+
+    if (digits == 0 && consumed_prefix == 0)
+    {
+        if (endptr)
+        {
+            *endptr = (char *)nptr;
+        }
+        *neg = 0;
+        *mag = 0;
+        *over = 0;
+        return STRTOX_EMPTY;
+    }
+    if (endptr)
+    {
+        *endptr = (char *)s;
+    }
+    *neg = sg;
+    *mag = m;
+    *over = ov;
+    return STRTOX_OK;
+}