Merge pull request #6339 from ebraminio/hb-number-copy-free

[number] Make integer parsings copy free
This commit is contained in:
Behdad Esfahbod authored and GitHub committed 2026-10-09 14:27:49 -06:00
commit c82300aefb
2 files changed
+797 -48

No files matched your search

+94 -33
View File
@@ -1,5 +1,5 @@
/*
* Copyright © 2019 Ebrahim Byagowi
* Copyright © 2019-2026 Ebrahim Byagowi
*
* This is part of HarfBuzz, a text shaping library.
*
@@ -31,55 +31,116 @@
#include "hb-number.hh"
#include "hb-number-parser.hh"
template<typename T, typename Func>
bool
hb_parse_double (const char **pp, const char *end, double *pv, bool whole_buffer)
{
const char *pend = end;
double value = hb_strtod (*pp, &pend);
if (unlikely (*pp == pend)) return false;
*pv = value;
*pp = pend;
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<typename T, typename Postprocess>
static bool
_parse_number (const char **pp, const char *end, T *pv,
bool whole_buffer, Func f)
bool whole_buffer, int base, Postprocess post)
{
char buf[32];
unsigned len = hb_min (ARRAY_LENGTH (buf) - 1, (unsigned) (end - *pp));
strncpy (buf, *pp, len);
buf[len] = '\0';
const char *pend = end;
const char *p = *pp;
bool neg = false, any = false, overflow = false;
char *p = buf;
char *pend = p;
while (p < pend && ISSPACE (*p)) p++;
if (p < pend && (*p == '+' || *p == '-')) { neg = (*p == '-'); p++; }
errno = 0;
*pv = f (p, &pend);
if (unlikely (errno || p == pend ||
/* Check if consumed whole buffer if is requested */
(whole_buffer && pend - p != end - *pp)))
return false;
/* 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;
*pp += pend - p;
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<int> (pp, end, pv, whole_buffer,
[] (const char *p, char **end)
{ return strtol (p, end, 10); });
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)
bool whole_buffer, int base)
{
return _parse_number<unsigned> (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)
{
const char *pend = end;
*pv = hb_strtod (*pp, &pend);
if (unlikely (*pp == pend)) return false;
*pp = pend;
return !whole_buffer || end == pend;
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 */
+703 -15
View File
@@ -1,5 +1,5 @@
/*
* Copyright © 2019 Ebrahim Byagowi
* Copyright © 2019-2026 Ebrahim Byagowi
*
* This is part of HarfBuzz, a text shaping library.
*
@@ -45,6 +45,292 @@ 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);
}
{
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);
}
{
/* 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);
}
/* 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
test_parse_uint ()
{
{
const char str[] = "123";
const char *pp = str;
@@ -85,19 +371,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 +409,410 @@ 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);
}
{
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);
}
{
/* 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);
}
/* 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
@@ -309,6 +986,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[] = ".";
@@ -316,6 +994,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-";
@@ -376,6 +1055,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[] = "";
@@ -383,6 +1063,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";
@@ -560,6 +1241,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";
@@ -567,6 +1249,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";
@@ -658,6 +1341,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";
@@ -665,6 +1349,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";
@@ -691,6 +1376,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";
@@ -699,6 +1385,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);
}
{
@@ -733,8 +1420,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;
}