From 1622d7cb09beb79565d1d44fb9b67966c436cecd Mon Sep 17 00:00:00 2001 From: Ebrahim Date: Fri, 9 Oct 2026 13:29:49 +0330 Subject: [PATCH 1/4] [test][number] Expand the testing This only adds new tests to the current implementation but changes nothing. --- src/test-number.cc | 535 +++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 521 insertions(+), 14 deletions(-) diff --git a/src/test-number.cc b/src/test-number.cc index e10efc82b..088151943 100644 --- a/src/test-number.cc +++ b/src/test-number.cc @@ -45,6 +45,217 @@ test_parse_int () hb_always_assert (!*end); } + { + const char str[] = "-123"; + const char *pp = str; + const char *end = str + 4; + + int pv; + hb_always_assert (hb_parse_int (&pp, end, &pv)); + hb_always_assert (pv == -123); + hb_always_assert (pp - str == 4); + hb_always_assert (end - pp == 0); + hb_always_assert (!*end); + } + + /* Leading whitespace */ + { + const char str[] = " 123"; + const char *pp = str; + const char *end = str + ARRAY_LENGTH (str) - 1; + int pv; + hb_always_assert (hb_parse_int (&pp, end, &pv)); + hb_always_assert (pv == 123); + hb_always_assert (pp == end); + } + { + const char str[] = "\t123"; + const char *pp = str; + const char *end = str + ARRAY_LENGTH (str) - 1; + int pv; + hb_always_assert (hb_parse_int (&pp, end, &pv)); + hb_always_assert (pv == 123); + hb_always_assert (pp == end); + } + { + const char str[] = "\n123"; + const char *pp = str; + const char *end = str + ARRAY_LENGTH (str) - 1; + int pv; + hb_always_assert (hb_parse_int (&pp, end, &pv)); + hb_always_assert (pv == 123); + hb_always_assert (pp == end); + } + { + const char str[] = " -123"; + const char *pp = str; + const char *end = str + ARRAY_LENGTH (str) - 1; + int pv; + hb_always_assert (hb_parse_int (&pp, end, &pv)); + hb_always_assert (pv == -123); + hb_always_assert (pp == end); + } + + /* Leading '+' sign */ + { + const char str[] = "+123"; + const char *pp = str; + const char *end = str + ARRAY_LENGTH (str) - 1; + int pv; + hb_always_assert (hb_parse_int (&pp, end, &pv)); + hb_always_assert (pv == 123); + hb_always_assert (pp == end); + } + { + const char str[] = "+0"; + const char *pp = str; + const char *end = str + ARRAY_LENGTH (str) - 1; + int pv; + hb_always_assert (hb_parse_int (&pp, end, &pv)); + hb_always_assert (pv == 0); + hb_always_assert (pp == end); + } + + /* Leading zeros are decimal, not octal (base is passed as 10) */ + { + const char str[] = "007"; + const char *pp = str; + const char *end = str + ARRAY_LENGTH (str) - 1; + int pv; + hb_always_assert (hb_parse_int (&pp, end, &pv)); + hb_always_assert (pv == 7); + hb_always_assert (pp == end); + } + + /* Negative zero */ + { + const char str[] = "-0"; + const char *pp = str; + const char *end = str + ARRAY_LENGTH (str) - 1; + int pv; + hb_always_assert (hb_parse_int (&pp, end, &pv)); + hb_always_assert (pv == 0); + hb_always_assert (pp == end); + } + + /* Partial parse: stops at first non-digit */ + { + const char str[] = "123abc"; + const char *pp = str; + const char *end = str + ARRAY_LENGTH (str) - 1; + int pv; + hb_always_assert (hb_parse_int (&pp, end, &pv)); + hb_always_assert (pv == 123); + hb_always_assert (pp == str + 3); + } + + /* INT_MAX / INT_MIN (fits in long on every supported platform) */ + { + const char str[] = "2147483647"; + const char *pp = str; + const char *end = str + ARRAY_LENGTH (str) - 1; + int pv; + hb_always_assert (hb_parse_int (&pp, end, &pv)); + hb_always_assert (pv == 2147483647); + hb_always_assert (pp == end); + } + { + const char str[] = "-2147483648"; + const char *pp = str; + const char *end = str + ARRAY_LENGTH (str) - 1; + int pv; + hb_always_assert (hb_parse_int (&pp, end, &pv)); + hb_always_assert (pv == -2147483647 - 1); + hb_always_assert (pp == end); + } + + /* Failures: no digits */ + { + const char str[] = " "; + const char *pp = str; + const char *end = str + ARRAY_LENGTH (str) - 1; + int pv = 99; + hb_always_assert (!hb_parse_int (&pp, end, &pv)); + hb_always_assert (pp == str); + // hb_always_assert (pv == 99); This shouldn't fail but it does with the current implementation + } + { + const char str[] = "+"; + const char *pp = str; + const char *end = str + ARRAY_LENGTH (str) - 1; + int pv = 99; + hb_always_assert (!hb_parse_int (&pp, end, &pv)); + } + { + const char str[] = "-"; + const char *pp = str; + const char *end = str + ARRAY_LENGTH (str) - 1; + int pv = 99; + hb_always_assert (!hb_parse_int (&pp, end, &pv)); + } + { + const char str[] = "abc"; + const char *pp = str; + const char *end = str + ARRAY_LENGTH (str) - 1; + int pv = 99; + hb_always_assert (!hb_parse_int (&pp, end, &pv)); + } + + /* Multiple signs fail */ + { + const char str[] = "++1"; + const char *pp = str; + const char *end = str + ARRAY_LENGTH (str) - 1; + int pv = 99; + hb_always_assert (!hb_parse_int (&pp, end, &pv)); + } + { + const char str[] = "--1"; + const char *pp = str; + const char *end = str + ARRAY_LENGTH (str) - 1; + int pv = 99; + hb_always_assert (!hb_parse_int (&pp, end, &pv)); + } + { + const char str[] = "+-1"; + const char *pp = str; + const char *end = str + ARRAY_LENGTH (str) - 1; + int pv = 99; + hb_always_assert (!hb_parse_int (&pp, end, &pv)); + } + { + const char str[] = "-+1"; + const char *pp = str; + const char *end = str + ARRAY_LENGTH (str) - 1; + int pv = 99; + hb_always_assert (!hb_parse_int (&pp, end, &pv)); + } + + /* whole_buffer: leading whitespace ok, trailing content rejected, + * and *pp / *pv are left untouched on failure */ + { + const char str[] = " 123"; + const char *pp = str; + const char *end = str + ARRAY_LENGTH (str) - 1; + int pv; + hb_always_assert (hb_parse_int (&pp, end, &pv, true)); + hb_always_assert (pv == 123); + hb_always_assert (pp == end); + } + { + const char str[] = "123abc"; + const char *pp = str; + const char *end = str + ARRAY_LENGTH (str) - 1; + int pv = 99; + hb_always_assert (!hb_parse_int (&pp, end, &pv, true)); + hb_always_assert (pp == str); + // hb_always_assert (pv == 99); This shouldn't fail but it does with the current implementation + } +} + +static void +test_parse_uint () +{ { const char str[] = "123"; const char *pp = str; @@ -85,19 +296,6 @@ test_parse_int () hb_always_assert (!*end); } - { - const char str[] = "-123"; - const char *pp = str; - const char *end = str + 4; - - int pv; - hb_always_assert (hb_parse_int (&pp, end, &pv)); - hb_always_assert (pv == -123); - hb_always_assert (pp - str == 4); - hb_always_assert (end - pp == 0); - hb_always_assert (!*end); - } - { const char str[] = "123"; const char *pp = str; @@ -136,6 +334,314 @@ test_parse_int () hb_always_assert (pp - str == 3); hb_always_assert (end - pp == 2); } + + { + const char str[] = "123abc"; + const char *pp = str; + const char *end = str + ARRAY_LENGTH (str) - 1; + unsigned int pv = 99; + hb_always_assert (!hb_parse_uint (&pp, end, &pv, true)); + hb_always_assert (pp == str); + // hb_always_assert (pv == 99); this shouldn't fail but it does with the current implementation + } + + /* Leading whitespace */ + { + const char str[] = " 123"; + const char *pp = str; + const char *end = str + ARRAY_LENGTH (str) - 1; + unsigned int pv; + hb_always_assert (hb_parse_uint (&pp, end, &pv)); + hb_always_assert (pv == 123); + hb_always_assert (pp == end); + } + { + const char str[] = "\t123"; + const char *pp = str; + const char *end = str + ARRAY_LENGTH (str) - 1; + unsigned int pv; + hb_always_assert (hb_parse_uint (&pp, end, &pv)); + hb_always_assert (pv == 123); + hb_always_assert (pp == end); + } + + /* Leading zeros (still decimal when base is 10) */ + { + const char str[] = "007"; + const char *pp = str; + const char *end = str + ARRAY_LENGTH (str) - 1; + unsigned int pv; + hb_always_assert (hb_parse_uint (&pp, end, &pv)); + hb_always_assert (pv == 7); + hb_always_assert (pp == end); + } + { + const char str[] = "000"; + const char *pp = str; + const char *end = str + ARRAY_LENGTH (str) - 1; + unsigned int pv; + hb_always_assert (hb_parse_uint (&pp, end, &pv)); + hb_always_assert (pv == 0); + hb_always_assert (pp == end); + } + + /* UINT_MAX */ + { + const char str[] = "4294967295"; + const char *pp = str; + const char *end = str + ARRAY_LENGTH (str) - 1; + unsigned int pv; + hb_always_assert (hb_parse_uint (&pp, end, &pv)); + hb_always_assert (pv == 4294967295u); + hb_always_assert (pp == end); + } + + /* Negative wraps in two's complement (matches strtoul on unsigned) */ + { + const char str[] = "-1"; + const char *pp = str; + const char *end = str + ARRAY_LENGTH (str) - 1; + unsigned int pv; + hb_always_assert (hb_parse_uint (&pp, end, &pv)); + hb_always_assert (pv == 4294967295u); + hb_always_assert (pp == end); + } + { + const char str[] = "-0"; + const char *pp = str; + const char *end = str + ARRAY_LENGTH (str) - 1; + unsigned int pv = 99; + hb_always_assert (hb_parse_uint (&pp, end, &pv)); + hb_always_assert (pv == 0); + hb_always_assert (pp == end); + } + + /* Base 2 */ + { + const char str[] = "1010"; + const char *pp = str; + const char *end = str + ARRAY_LENGTH (str) - 1; + unsigned int pv; + hb_always_assert (hb_parse_uint (&pp, end, &pv, true, 2)); + hb_always_assert (pv == 10); + hb_always_assert (pp == end); + } + { + const char str[] = "11111111"; + const char *pp = str; + const char *end = str + ARRAY_LENGTH (str) - 1; + unsigned int pv; + hb_always_assert (hb_parse_uint (&pp, end, &pv, true, 2)); + hb_always_assert (pv == 255); + hb_always_assert (pp == end); + } + { + const char str[] = "12"; + const char *pp = str; + const char *end = str + ARRAY_LENGTH (str) - 1; + unsigned int pv; + /* '2' is not a base-2 digit; parse stops at index 1 */ + hb_always_assert (hb_parse_uint (&pp, end, &pv, false, 2)); + hb_always_assert (pv == 1); + hb_always_assert (pp == str + 1); + } + + /* Base 8 */ + { + const char str[] = "777"; + const char *pp = str; + const char *end = str + ARRAY_LENGTH (str) - 1; + unsigned int pv; + hb_always_assert (hb_parse_uint (&pp, end, &pv, true, 8)); + hb_always_assert (pv == 511); + hb_always_assert (pp == end); + } + { + const char str[] = "010"; + const char *pp = str; + const char *end = str + ARRAY_LENGTH (str) - 1; + unsigned int pv; + hb_always_assert (hb_parse_uint (&pp, end, &pv, true, 8)); + hb_always_assert (pv == 8); + hb_always_assert (pp == end); + } + + /* Base 16, with and without 0x prefix, mixed case */ + { + const char str[] = "FF"; + const char *pp = str; + const char *end = str + ARRAY_LENGTH (str) - 1; + unsigned int pv; + hb_always_assert (hb_parse_uint (&pp, end, &pv, true, 16)); + hb_always_assert (pv == 255); + hb_always_assert (pp == end); + } + { + const char str[] = "ff"; + const char *pp = str; + const char *end = str + ARRAY_LENGTH (str) - 1; + unsigned int pv; + hb_always_assert (hb_parse_uint (&pp, end, &pv, true, 16)); + hb_always_assert (pv == 255); + hb_always_assert (pp == end); + } + { + const char str[] = "Ff"; + const char *pp = str; + const char *end = str + ARRAY_LENGTH (str) - 1; + unsigned int pv; + hb_always_assert (hb_parse_uint (&pp, end, &pv, true, 16)); + hb_always_assert (pv == 255); + hb_always_assert (pp == end); + } + { + const char str[] = "0xFF"; + const char *pp = str; + const char *end = str + ARRAY_LENGTH (str) - 1; + unsigned int pv; + hb_always_assert (hb_parse_uint (&pp, end, &pv, true, 16)); + hb_always_assert (pv == 255); + hb_always_assert (pp == end); + } + { + const char str[] = "0XFF"; + const char *pp = str; + const char *end = str + ARRAY_LENGTH (str) - 1; + unsigned int pv; + hb_always_assert (hb_parse_uint (&pp, end, &pv, true, 16)); + hb_always_assert (pv == 255); + hb_always_assert (pp == end); + } + + /* Base 36 */ + { + const char str[] = "Z"; + const char *pp = str; + const char *end = str + ARRAY_LENGTH (str) - 1; + unsigned int pv; + hb_always_assert (hb_parse_uint (&pp, end, &pv, true, 36)); + hb_always_assert (pv == 35); + hb_always_assert (pp == end); + } + { + const char str[] = "z"; + const char *pp = str; + const char *end = str + ARRAY_LENGTH (str) - 1; + unsigned int pv; + hb_always_assert (hb_parse_uint (&pp, end, &pv, true, 36)); + hb_always_assert (pv == 35); + hb_always_assert (pp == end); + } + { + const char str[] = "10"; + const char *pp = str; + const char *end = str + ARRAY_LENGTH (str) - 1; + unsigned int pv; + hb_always_assert (hb_parse_uint (&pp, end, &pv, true, 36)); + hb_always_assert (pv == 36); + hb_always_assert (pp == end); + } + + /* Failures */ + { + const char str[] = "abc"; + const char *pp = str; + const char *end = str + ARRAY_LENGTH (str) - 1; + unsigned int pv = 99; + /* 'a' isn't a decimal digit; whole parse fails */ + hb_always_assert (!hb_parse_uint (&pp, end, &pv, false, 10)); + hb_always_assert (pp == str); + // hb_always_assert (pv == 99); this shouldn't fail but it does with the current implementation + } + { + const char str[] = "+"; + const char *pp = str; + const char *end = str + ARRAY_LENGTH (str) - 1; + unsigned int pv = 99; + hb_always_assert (!hb_parse_uint (&pp, end, &pv)); + } + { + const char str[] = "-"; + const char *pp = str; + const char *end = str + ARRAY_LENGTH (str) - 1; + unsigned int pv = 99; + hb_always_assert (!hb_parse_uint (&pp, end, &pv)); + } + { + const char str[] = ""; + const char *pp = str; + const char *end = str; + unsigned int pv = 99; + hb_always_assert (!hb_parse_uint (&pp, end, &pv)); + } + + { + const char str[] = "0XFF"; + const char *pp = str; + const char *end = str + ARRAY_LENGTH (str) - 1; + unsigned int pv; + hb_always_assert (hb_parse_uint (&pp, end, &pv, true, 16)); + hb_always_assert (pv == 255); + hb_always_assert (pp == end); + } + { + const char str[] = "0xff"; + const char *pp = str; + const char *end = str + ARRAY_LENGTH (str) - 1; + unsigned int pv; + hb_always_assert (hb_parse_uint (&pp, end, &pv, true, 16)); + hb_always_assert (pv == 255); + hb_always_assert (pp == end); + } + { + const char str[] = "0x0"; + const char *pp = str; + const char *end = str + ARRAY_LENGTH (str) - 1; + unsigned int pv; + hb_always_assert (hb_parse_uint (&pp, end, &pv, true, 16)); + hb_always_assert (pv == 0); + hb_always_assert (pp == end); + } + /* "0x" alone: consume only the 0, leave the x */ + { + const char str[] = "0x"; + const char *pp = str; + const char *end = str + ARRAY_LENGTH (str) - 1; + unsigned int pv; + hb_always_assert (hb_parse_uint (&pp, end, &pv, false, 16)); + hb_always_assert (pv == 0); + hb_always_assert (pp == str + 1); + } + /* "0xG": 0 is consumed, xG left */ + { + const char str[] = "0xG"; + const char *pp = str; + const char *end = str + ARRAY_LENGTH (str) - 1; + unsigned int pv; + hb_always_assert (hb_parse_uint (&pp, end, &pv, false, 16)); + hb_always_assert (pv == 0); + hb_always_assert (pp == str + 1); + } + /* Negative with prefix */ + { + const char str[] = "-0xFF"; + const char *pp = str; + const char *end = str + ARRAY_LENGTH (str) - 1; + unsigned int pv; + hb_always_assert (hb_parse_uint (&pp, end, &pv, true, 16)); + hb_always_assert (pv == (unsigned) -255); + hb_always_assert (pp == end); + } + /* Prefix rule doesn't fire for base 10 */ + { + const char str[] = "0xFF"; + const char *pp = str; + const char *end = str + ARRAY_LENGTH (str) - 1; + unsigned int pv; + hb_always_assert (hb_parse_uint (&pp, end, &pv, false, 10)); + hb_always_assert (pv == 0); + hb_always_assert (pp == str + 1); + } } /* Tolerate 1 ULP difference. Needed because 32-bit x86 (x87) computes @@ -733,8 +1239,9 @@ test_parse_double (void) int main (int argc, char **argv) { - test_parse_int (); test_parse_double (); + test_parse_int (); + test_parse_uint (); return 0; } From 30f2eae3c7d93488451e6f1d41cf6f446ac08059 Mon Sep 17 00:00:00 2001 From: Ebrahim Date: Fri, 9 Oct 2026 13:41:22 +0330 Subject: [PATCH 2/4] [number] Only alter value pointer if parsing was successful Previously it was changing value's pointer even if the parsing was declarad a failure, this fixes it by changing the value only if the parsing was successful. --- src/hb-number.cc | 6 ++++-- src/test-number.cc | 16 +++++++++++++--- 2 files changed, 17 insertions(+), 5 deletions(-) diff --git a/src/hb-number.cc b/src/hb-number.cc index b6e7d69c5..bab70e5c7 100644 --- a/src/hb-number.cc +++ b/src/hb-number.cc @@ -45,12 +45,13 @@ _parse_number (const char **pp, const char *end, T *pv, char *pend = p; errno = 0; - *pv = f (p, &pend); + T value = f (p, &pend); if (unlikely (errno || p == pend || /* Check if consumed whole buffer if is requested */ (whole_buffer && pend - p != end - *pp))) return false; + *pv = value; *pp += pend - p; return true; } @@ -76,8 +77,9 @@ bool hb_parse_double (const char **pp, const char *end, double *pv, bool whole_buffer) { const char *pend = end; - *pv = hb_strtod (*pp, &pend); + double value = hb_strtod (*pp, &pend); if (unlikely (*pp == pend)) return false; + *pv = value; *pp = pend; return !whole_buffer || end == pend; } diff --git a/src/test-number.cc b/src/test-number.cc index 088151943..4654ba6d3 100644 --- a/src/test-number.cc +++ b/src/test-number.cc @@ -177,7 +177,7 @@ test_parse_int () int pv = 99; hb_always_assert (!hb_parse_int (&pp, end, &pv)); hb_always_assert (pp == str); - // hb_always_assert (pv == 99); This shouldn't fail but it does with the current implementation + hb_always_assert (pv == 99); } { const char str[] = "+"; @@ -249,7 +249,7 @@ test_parse_int () int pv = 99; hb_always_assert (!hb_parse_int (&pp, end, &pv, true)); hb_always_assert (pp == str); - // hb_always_assert (pv == 99); This shouldn't fail but it does with the current implementation + hb_always_assert (pv == 99); } } @@ -551,7 +551,7 @@ test_parse_uint () /* 'a' isn't a decimal digit; whole parse fails */ hb_always_assert (!hb_parse_uint (&pp, end, &pv, false, 10)); hb_always_assert (pp == str); - // hb_always_assert (pv == 99); this shouldn't fail but it does with the current implementation + hb_always_assert (pv == 99); } { const char str[] = "+"; @@ -815,6 +815,7 @@ test_parse_double (void) const char *end = str + ARRAY_LENGTH (str) - 1; double pv = 99.0; hb_always_assert (!hb_parse_double (&pp, end, &pv)); + hb_always_assert (pv == 99); } { const char str[] = "."; @@ -822,6 +823,7 @@ test_parse_double (void) const char *end = str + ARRAY_LENGTH (str) - 1; double pv = 99.0; hb_always_assert (!hb_parse_double (&pp, end, &pv)); + hb_always_assert (pv == 99); } { const char str[] = "1e-"; @@ -882,6 +884,7 @@ test_parse_double (void) const char *end = str + ARRAY_LENGTH (str) - 1; double pv = 99.0; hb_always_assert (!hb_parse_double (&pp, end, &pv)); + hb_always_assert (pv == 99.0); } { const char str[] = ""; @@ -889,6 +892,7 @@ test_parse_double (void) const char *end = str; double pv = 99.0; hb_always_assert (!hb_parse_double (&pp, end, &pv)); + hb_always_assert (pv == 99.0); } { const char str[] = " \t 123"; @@ -1066,6 +1070,7 @@ test_parse_double (void) const char *end = str + ARRAY_LENGTH (str) - 1; double pv = 99.0; hb_always_assert (!hb_parse_double (&pp, end, &pv)); + hb_always_assert (pv == 99.0); } { const char str[] = "+-1"; @@ -1073,6 +1078,7 @@ test_parse_double (void) const char *end = str + ARRAY_LENGTH (str) - 1; double pv = 99.0; hb_always_assert (!hb_parse_double (&pp, end, &pv)); + hb_always_assert (pv == 99.0); } { const char str[] = "0e5"; @@ -1164,6 +1170,7 @@ test_parse_double (void) const char *end = str + ARRAY_LENGTH (str) - 1; double pv = 99.0; hb_always_assert (!hb_parse_double (&pp, end, &pv)); + hb_always_assert (pv == 99.0); } { const char str[] = "inf"; @@ -1171,6 +1178,7 @@ test_parse_double (void) const char *end = str + ARRAY_LENGTH (str) - 1; double pv = 99.0; hb_always_assert (!hb_parse_double (&pp, end, &pv)); + hb_always_assert (pv == 99.0); } { const char str[] = "1..5"; @@ -1197,6 +1205,7 @@ test_parse_double (void) const char *end = str + ARRAY_LENGTH (str) - 1; double pv = 99.0; hb_always_assert (!hb_parse_double (&pp, end, &pv)); + hb_always_assert (pv == 99.0); } { const char str[] = " abc"; @@ -1205,6 +1214,7 @@ test_parse_double (void) double pv = 99.0; hb_always_assert (!hb_parse_double (&pp, end, &pv)); hb_always_assert (pp == str); + hb_always_assert (pv == 99.0); } { From f8ba9744b1630ac617cfdcd22d11895fccdb7af9 Mon Sep 17 00:00:00 2001 From: Ebrahim Date: Fri, 9 Oct 2026 15:32:30 +0330 Subject: [PATCH 3/4] [number] Make hb_parse_int and hb_parse_uint copy free There is one known difference before and after the change that comes from 32bit/64bit machines difference on long size which is documented in the tests. --- src/hb-number.cc | 143 ++++++++++++++++++++++++++++++++------------- src/test-number.cc | 24 ++++++++ 2 files changed, 125 insertions(+), 42 deletions(-) diff --git a/src/hb-number.cc b/src/hb-number.cc index bab70e5c7..c10fa25a8 100644 --- a/src/hb-number.cc +++ b/src/hb-number.cc @@ -31,48 +31,6 @@ #include "hb-number.hh" #include "hb-number-parser.hh" -template -static bool -_parse_number (const char **pp, const char *end, T *pv, - bool whole_buffer, Func f) -{ - char buf[32]; - unsigned len = hb_min (ARRAY_LENGTH (buf) - 1, (unsigned) (end - *pp)); - strncpy (buf, *pp, len); - buf[len] = '\0'; - - char *p = buf; - char *pend = p; - - errno = 0; - T value = f (p, &pend); - if (unlikely (errno || p == pend || - /* Check if consumed whole buffer if is requested */ - (whole_buffer && pend - p != end - *pp))) - return false; - - *pv = value; - *pp += pend - p; - return true; -} - -bool -hb_parse_int (const char **pp, const char *end, int *pv, bool whole_buffer) -{ - return _parse_number (pp, end, pv, whole_buffer, - [] (const char *p, char **end) - { return strtol (p, end, 10); }); -} - -bool -hb_parse_uint (const char **pp, const char *end, unsigned *pv, - bool whole_buffer, int base) -{ - return _parse_number (pp, end, pv, whole_buffer, - [base] (const char *p, char **end) - { return strtoul (p, end, base); }); -} - bool hb_parse_double (const char **pp, const char *end, double *pv, bool whole_buffer) { @@ -84,5 +42,106 @@ hb_parse_double (const char **pp, const char *end, double *pv, bool whole_buffer return !whole_buffer || end == pend; } +/* Returns the digit value of c in the given base (2..36), or -1 if c + * isn't a digit in that base. */ +static int +_hb_digit_value (char c, int base) +{ + int d; + if ('0' <= c && c <= '9') d = c - '0'; + else if ('a' <= c && c <= 'z') d = c - 'a' + 10; + else if ('A' <= c && c <= 'Z') d = c - 'A' + 10; + else return -1; + return d < base ? d : -1; +} + +/* Consumes digits in [p, pe) into *value (magnitude). Sets *overflow + * if the value would exceed UINT64_MAX. Sets *any_digits if at least + * one digit was consumed. Returns the position past the last digit. */ +static const char * +_hb_scan_digits (const char *p, const char *pe, int base, + uint64_t *value, bool *overflow, bool *any_digits) +{ + const uint64_t cutoff = UINT64_MAX / (unsigned) base; + const uint64_t cutlim = UINT64_MAX % (unsigned) base; + uint64_t v = 0; + bool ov = false, any = false; + + for (; p < pe; p++) + { + int d = _hb_digit_value (*p, base); + if (d < 0) break; + any = true; + if (v > cutoff || (v == cutoff && (uint64_t) d > cutlim)) + ov = true; + else + v = v * (unsigned) base + (uint64_t) d; + } + + *value = v; + *overflow = ov; + *any_digits = any; + return p; +} + +template +static bool +_parse_number (const char **pp, const char *end, T *pv, + bool whole_buffer, int base, Postprocess post) +{ + const char *pend = end; + const char *p = *pp; + bool neg = false, any = false, overflow = false; + + while (p < pend && ISSPACE (*p)) p++; + if (p < pend && (*p == '+' || *p == '-')) { neg = (*p == '-'); p++; } + + /* Skip an optional "0x"/"0X" prefix for base 16, but only when a hex + * digit follows — "0x" alone parses as the digit 0, matching strtoul. */ + if (base == 16 && p + 2 < pend && p[0] == '0' && + (p[1] == 'x' || p[1] == 'X') && _hb_digit_value (p[2], 16) >= 0) + p += 2; + + uint64_t v = 0; + p = _hb_scan_digits (p, pend, base, &v, &overflow, &any); + if (!any || overflow) return false; + + T out; + if (!post (v, neg, &out)) return false; + if (whole_buffer && p != pend) return false; + + *pv = out; + *pp = p; + return true; +} + +bool +hb_parse_int (const char **pp, const char *end, int *pv, bool whole_buffer) +{ + return _parse_number (pp, end, pv, whole_buffer, 10, + [] (uint64_t v, bool neg, int *out) { + /* INT_MAX = 2^31-1, INT_MIN magnitude = 2^31 */ + uint64_t limit = neg ? (uint64_t) INT_MAX + 1 : (uint64_t) INT_MAX; + if (v > limit) return false; + *out = (int) (neg ? -(int64_t) v : (int64_t) v); + return true; + }); +} + +bool +hb_parse_uint (const char **pp, const char *end, unsigned *pv, + bool whole_buffer, int base) +{ + return _parse_number (pp, end, pv, whole_buffer, base, + [] (uint64_t v, bool neg, unsigned *out) { + if (v > UINT_MAX) return false; + /* Negate in unsigned so -1 wraps to UINT_MAX, matching strtoul + * truncated to unsigned. */ + unsigned u = (unsigned) v; + *out = neg ? (unsigned) (0u - u) : u; + return true; + }); +} + #endif /* HB_NUMBER_CC pacify */ #endif /* HB_NUMBER_CC guard */ diff --git a/src/test-number.cc b/src/test-number.cc index 4654ba6d3..43e0ce4cf 100644 --- a/src/test-number.cc +++ b/src/test-number.cc @@ -251,6 +251,18 @@ test_parse_int () hb_always_assert (pp == str); hb_always_assert (pv == 99); } + { + /* 10 digits > INT_MAX. The old strtol-based implementation silently + * truncated on 64-bit platforms (long is 64-bit) but rejected on + * 32-bit; the new implementation rejects uniformly. */ + const char str[] = "9999999999"; /* 10 digits, > INT_MAX */ + const char *pp = str; + const char *end = str + ARRAY_LENGTH (str) - 1; + int pv = 99; + hb_always_assert (!hb_parse_int (&pp, end, &pv)); + hb_always_assert (pp == str); + hb_always_assert (pv == 99); + } } static void @@ -642,6 +654,18 @@ test_parse_uint () hb_always_assert (pv == 0); hb_always_assert (pp == str + 1); } + { + /* 10 digits > UINT_MAX. The old strtol-based implementation silently + * truncated on 64-bit platforms (unsigned long is 64-bit) but rejected on + * 32-bit; the new implementation rejects uniformly. */ + const char str[] = "9999999999"; /* 10 digits, > UINT_MAX */ + const char *pp = str; + const char *end = str + ARRAY_LENGTH (str) - 1; + unsigned int pv = 99; + hb_always_assert (!hb_parse_uint (&pp, end, &pv)); + hb_always_assert (pp == str); + hb_always_assert (pv == 99); + } } /* Tolerate 1 ULP difference. Needed because 32-bit x86 (x87) computes From 97513326fc3d563959a380bb4eac6ddf9fc9d99f Mon Sep 17 00:00:00 2001 From: Ebrahim Date: Fri, 9 Oct 2026 15:57:46 +0330 Subject: [PATCH 4/4] [number][test] Add some more tests for the expected behavior --- src/hb-number.cc | 2 +- src/test-number.cc | 149 ++++++++++++++++++++++++++++++++++++++++++++- 2 files changed, 149 insertions(+), 2 deletions(-) diff --git a/src/hb-number.cc b/src/hb-number.cc index c10fa25a8..03d8db45b 100644 --- a/src/hb-number.cc +++ b/src/hb-number.cc @@ -1,5 +1,5 @@ /* - * Copyright © 2019 Ebrahim Byagowi + * Copyright © 2019-2026 Ebrahim Byagowi * * This is part of HarfBuzz, a text shaping library. * diff --git a/src/test-number.cc b/src/test-number.cc index 43e0ce4cf..740082022 100644 --- a/src/test-number.cc +++ b/src/test-number.cc @@ -1,5 +1,5 @@ /* - * Copyright © 2019 Ebrahim Byagowi + * Copyright © 2019-2026 Ebrahim Byagowi * * This is part of HarfBuzz, a text shaping library. * @@ -263,6 +263,69 @@ test_parse_int () hb_always_assert (pp == str); hb_always_assert (pv == 99); } + + /* INT_MAX / INT_MIN - exactly representable */ + { + const char str[] = "2147483647"; + const char *pp = str; + const char *end = str + ARRAY_LENGTH (str) - 1; + int pv; + hb_always_assert (hb_parse_int (&pp, end, &pv)); + hb_always_assert (pv == 2147483647); + hb_always_assert (pp == end); + } + { + const char str[] = "-2147483648"; + const char *pp = str; + const char *end = str + ARRAY_LENGTH (str) - 1; + int pv; + hb_always_assert (hb_parse_int (&pp, end, &pv)); + hb_always_assert (pv == -2147483647 - 1); /* not -2147483648, that's UB as an int literal */ + hb_always_assert (pp == end); + } + + /* One past INT_MAX - must fail */ + { + const char str[] = "2147483648"; + const char *pp = str; + const char *end = str + ARRAY_LENGTH (str) - 1; + int pv = 99; + hb_always_assert (!hb_parse_int (&pp, end, &pv)); + hb_always_assert (pp == str); + hb_always_assert (pv == 99); + } + /* One past INT_MIN - must fail */ + { + const char str[] = "-2147483649"; + const char *pp = str; + const char *end = str + ARRAY_LENGTH (str) - 1; + int pv = 99; + hb_always_assert (!hb_parse_int (&pp, end, &pv)); + hb_always_assert (pp == str); + hb_always_assert (pv == 99); + } + + /* Same for signed */ + { + const char str[] = "9999999999999999999999999999999999999999"; + const char *pp = str; + const char *end = str + ARRAY_LENGTH (str) - 1; + int pv = 99; + hb_always_assert (!hb_parse_int (&pp, end, &pv)); + hb_always_assert (pp == str); + hb_always_assert (pv == 99); + } + + { + /* Verify *pv and *pp are untouched when a range check rejects. */ + const char str[] = "9999999999"; + const char *pp = str; + const char *end = str + ARRAY_LENGTH (str) - 1; + int pv = 42; + hb_always_assert (!hb_parse_int (&pp, end, &pv)); + hb_always_assert (pp == str); + hb_always_assert (pv == 42); + } } static void @@ -666,6 +729,90 @@ test_parse_uint () hb_always_assert (pp == str); hb_always_assert (pv == 99); } + + /* UINT_MAX - exactly representable */ + { + const char str[] = "4294967295"; + const char *pp = str; + const char *end = str + ARRAY_LENGTH (str) - 1; + unsigned int pv; + hb_always_assert (hb_parse_uint (&pp, end, &pv)); + hb_always_assert (pv == 4294967295u); + hb_always_assert (pp == end); + } + /* One past UINT_MAX - must fail (currently truncates to 0) */ + { + const char str[] = "4294967296"; + const char *pp = str; + const char *end = str + ARRAY_LENGTH (str) - 1; + unsigned int pv = 99; + hb_always_assert (!hb_parse_uint (&pp, end, &pv)); + hb_always_assert (pp == str); + hb_always_assert (pv == 99); + } + + /* 20 digits, way past UINT_MAX */ + { + const char str[] = "99999999999999999999"; + const char *pp = str; + const char *end = str + ARRAY_LENGTH (str) - 1; + unsigned int pv = 99; + hb_always_assert (!hb_parse_uint (&pp, end, &pv)); + hb_always_assert (pp == str); + hb_always_assert (pv == 99); + } + /* 40 digits, past the old 32-byte stack buffer */ + { + const char str[] = "9999999999999999999999999999999999999999"; + const char *pp = str; + const char *end = str + ARRAY_LENGTH (str) - 1; + unsigned int pv = 99; + hb_always_assert (!hb_parse_uint (&pp, end, &pv)); + hb_always_assert (pp == str); + hb_always_assert (pv == 99); + } + + /* 0xFFFFFFFF = UINT_MAX */ + { + const char str[] = "0xFFFFFFFF"; + const char *pp = str; + const char *end = str + ARRAY_LENGTH (str) - 1; + unsigned int pv; + hb_always_assert (hb_parse_uint (&pp, end, &pv, true, 16)); + hb_always_assert (pv == 4294967295u); + hb_always_assert (pp == end); + } + /* 0x100000000 = UINT_MAX + 1 */ + { + const char str[] = "0x100000000"; + const char *pp = str; + const char *end = str + ARRAY_LENGTH (str) - 1; + unsigned int pv = 99; + hb_always_assert (!hb_parse_uint (&pp, end, &pv, true, 16)); + hb_always_assert (pp == str); + hb_always_assert (pv == 99); + } + + /* 13 'Z's = 36^13 - 1, comfortably > UINT64_MAX would need ~12 digits */ + { + const char str[] = "ZZZZZZZZZZZZZZ"; /* 14 Z's */ + const char *pp = str; + const char *end = str + ARRAY_LENGTH (str) - 1; + unsigned int pv = 99; + hb_always_assert (!hb_parse_uint (&pp, end, &pv, true, 36)); + hb_always_assert (pp == str); + hb_always_assert (pv == 99); + } + + { + const char str[] = "9999999999"; + const char *pp = str; + const char *end = str + ARRAY_LENGTH (str) - 1; + unsigned int pv = 42; + hb_always_assert (!hb_parse_uint (&pp, end, &pv)); + hb_always_assert (pp == str); + hb_always_assert (pv == 42); + } } /* Tolerate 1 ULP difference. Needed because 32-bit x86 (x87) computes