X-Git-Url: https://perl5.git.perl.org/perl5.git/blobdiff_plain/ed140128eb692ebeaa21f2775f8d3c34e9a94094..4ed2cea49be76fa63aaf83659d2157d4aa4d69c5:/numeric.c diff --git a/numeric.c b/numeric.c index 20fd7bd..505b1ce 100644 --- a/numeric.c +++ b/numeric.c @@ -1,7 +1,7 @@ /* numeric.c * - * Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, - * 2000, 2001, 2002, 2003, 2004, 2005, 2006, by Larry Wall and others + * Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, + * 2002, 2003, 2004, 2005, 2006, 2007, 2008 by Larry Wall and others * * You may distribute under the terms of either the GNU General Public * License or the Artistic License, as specified in the README file. @@ -9,8 +9,10 @@ */ /* - * "That only makes eleven (plus one mislaid) and not fourteen, unless - * wizards count differently to other people." + * "That only makes eleven (plus one mislaid) and not fourteen, + * unless wizards count differently to other people." --Beorn + * + * [p.115 of _The Hobbit_: "Queer Lodgings"] */ /* @@ -132,27 +134,30 @@ number may use '_' characters to separate digits. */ UV -Perl_grok_bin(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result) { +Perl_grok_bin(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result) +{ const char *s = start; STRLEN len = *len_p; UV value = 0; NV value_nv = 0; const UV max_div_2 = UV_MAX / 2; - const bool allow_underscores = (bool)(*flags & PERL_SCAN_ALLOW_UNDERSCORES); + const bool allow_underscores = cBOOL(*flags & PERL_SCAN_ALLOW_UNDERSCORES); bool overflowed = FALSE; char bit; + PERL_ARGS_ASSERT_GROK_BIN; + if (!(*flags & PERL_SCAN_DISALLOW_PREFIX)) { /* strip off leading b or 0b. for compatibility silently suffer "b" and "0b" as valid binary numbers. */ if (len >= 1) { - if (s[0] == 'b') { + if (s[0] == 'b' || s[0] == 'B') { s++; len--; } - else if (len >= 2 && s[0] == '0' && s[1] == 'b') { + else if (len >= 2 && s[0] == '0' && (s[1] == 'b' || s[1] == 'B')) { s+=2; len-=2; } @@ -171,9 +176,8 @@ Perl_grok_bin(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result) { continue; } /* Bah. We're just overflowed. */ - if (ckWARN_d(WARN_OVERFLOW)) - Perl_warner(aTHX_ packWARN(WARN_OVERFLOW), - "Integer overflow in binary number"); + Perl_ck_warner_d(aTHX_ packWARN(WARN_OVERFLOW), + "Integer overflow in binary number"); overflowed = TRUE; value_nv = (NV) value; } @@ -194,9 +198,9 @@ Perl_grok_bin(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result) { ++s; goto redo; } - if (!(*flags & PERL_SCAN_SILENT_ILLDIGIT) && ckWARN(WARN_DIGIT)) - Perl_warner(aTHX_ packWARN(WARN_DIGIT), - "Illegal binary digit '%c' ignored", *s); + if (!(*flags & PERL_SCAN_SILENT_ILLDIGIT)) + Perl_ck_warner(aTHX_ packWARN(WARN_DIGIT), + "Illegal binary digit '%c' ignored", *s); break; } @@ -205,9 +209,8 @@ Perl_grok_bin(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result) { || (!overflowed && value > 0xffffffff ) #endif ) { - if (ckWARN(WARN_PORTABLE)) - Perl_warner(aTHX_ packWARN(WARN_PORTABLE), - "Binary number > 0b11111111111111111111111111111111 non-portable"); + Perl_ck_warner(aTHX_ packWARN(WARN_PORTABLE), + "Binary number > 0b11111111111111111111111111111111 non-portable"); } *len_p = s - start; if (!overflowed) { @@ -248,27 +251,29 @@ number may use '_' characters to separate digits. */ UV -Perl_grok_hex(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result) { +Perl_grok_hex(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result) +{ dVAR; const char *s = start; STRLEN len = *len_p; UV value = 0; NV value_nv = 0; - const UV max_div_16 = UV_MAX / 16; - const bool allow_underscores = (bool)(*flags & PERL_SCAN_ALLOW_UNDERSCORES); + const bool allow_underscores = cBOOL(*flags & PERL_SCAN_ALLOW_UNDERSCORES); bool overflowed = FALSE; + PERL_ARGS_ASSERT_GROK_HEX; + if (!(*flags & PERL_SCAN_DISALLOW_PREFIX)) { /* strip off leading x or 0x. for compatibility silently suffer "x" and "0x" as valid hex numbers. */ if (len >= 1) { - if (s[0] == 'x') { + if (s[0] == 'x' || s[0] == 'X') { s++; len--; } - else if (len >= 2 && s[0] == '0' && s[1] == 'x') { + else if (len >= 2 && s[0] == '0' && (s[1] == 'x' || s[1] == 'X')) { s+=2; len-=2; } @@ -288,9 +293,8 @@ Perl_grok_hex(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result) { continue; } /* Bah. We're just overflowed. */ - if (ckWARN_d(WARN_OVERFLOW)) - Perl_warner(aTHX_ packWARN(WARN_OVERFLOW), - "Integer overflow in hexadecimal number"); + Perl_ck_warner_d(aTHX_ packWARN(WARN_OVERFLOW), + "Integer overflow in hexadecimal number"); overflowed = TRUE; value_nv = (NV) value; } @@ -311,8 +315,8 @@ Perl_grok_hex(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result) { ++s; goto redo; } - if (!(*flags & PERL_SCAN_SILENT_ILLDIGIT) && ckWARN(WARN_DIGIT)) - Perl_warner(aTHX_ packWARN(WARN_DIGIT), + if (!(*flags & PERL_SCAN_SILENT_ILLDIGIT)) + Perl_ck_warner(aTHX_ packWARN(WARN_DIGIT), "Illegal hexadecimal digit '%c' ignored", *s); break; } @@ -322,9 +326,8 @@ Perl_grok_hex(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result) { || (!overflowed && value > 0xffffffff ) #endif ) { - if (ckWARN(WARN_PORTABLE)) - Perl_warner(aTHX_ packWARN(WARN_PORTABLE), - "Hexadecimal number > 0xffffffff non-portable"); + Perl_ck_warner(aTHX_ packWARN(WARN_PORTABLE), + "Hexadecimal number > 0xffffffff non-portable"); } *len_p = s - start; if (!overflowed) { @@ -346,7 +349,7 @@ On entry I and I<*len> give the string to scan, I<*flags> gives conversion flags, and I should be NULL or a pointer to an NV. The scan stops at the end of the string, or the first invalid character. Unless C is set in I<*flags>, encountering an -invalid character will also trigger a warning. +8 or 9 will also trigger a warning. On return I<*len> is set to the length of the scanned string, and I<*flags> gives output flags. @@ -363,16 +366,18 @@ number may use '_' characters to separate digits. */ UV -Perl_grok_oct(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result) { +Perl_grok_oct(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result) +{ const char *s = start; STRLEN len = *len_p; UV value = 0; NV value_nv = 0; - const UV max_div_8 = UV_MAX / 8; - const bool allow_underscores = (bool)(*flags & PERL_SCAN_ALLOW_UNDERSCORES); + const bool allow_underscores = cBOOL(*flags & PERL_SCAN_ALLOW_UNDERSCORES); bool overflowed = FALSE; + PERL_ARGS_ASSERT_GROK_OCT; + for (; len-- && *s; s++) { /* gcc 2.95 optimiser not smart enough to figure that this subtraction out front allows slicker code. */ @@ -388,9 +393,8 @@ Perl_grok_oct(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result) { continue; } /* Bah. We're just overflowed. */ - if (ckWARN_d(WARN_OVERFLOW)) - Perl_warner(aTHX_ packWARN(WARN_OVERFLOW), - "Integer overflow in octal number"); + Perl_ck_warner_d(aTHX_ packWARN(WARN_OVERFLOW), + "Integer overflow in octal number"); overflowed = TRUE; value_nv = (NV) value; } @@ -415,9 +419,9 @@ Perl_grok_oct(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result) { * as soon as non-octal characters are seen, complain only if * someone seems to want to use the digits eight and nine). */ if (digit == 8 || digit == 9) { - if (!(*flags & PERL_SCAN_SILENT_ILLDIGIT) && ckWARN(WARN_DIGIT)) - Perl_warner(aTHX_ packWARN(WARN_DIGIT), - "Illegal octal digit '%c' ignored", *s); + if (!(*flags & PERL_SCAN_SILENT_ILLDIGIT)) + Perl_ck_warner(aTHX_ packWARN(WARN_DIGIT), + "Illegal octal digit '%c' ignored", *s); } break; } @@ -427,9 +431,8 @@ Perl_grok_oct(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result) { || (!overflowed && value > 0xffffffff ) #endif ) { - if (ckWARN(WARN_PORTABLE)) - Perl_warner(aTHX_ packWARN(WARN_PORTABLE), - "Octal number > 037777777777 non-portable"); + Perl_ck_warner(aTHX_ packWARN(WARN_PORTABLE), + "Octal number > 037777777777 non-portable"); } *len_p = s - start; if (!overflowed) { @@ -465,6 +468,8 @@ Perl_scan_bin(pTHX_ const char *start, STRLEN len, STRLEN *retlen) I32 flags = *retlen ? PERL_SCAN_ALLOW_UNDERSCORES : 0; const UV ruv = grok_bin (start, &len, &flags, &rnv); + PERL_ARGS_ASSERT_SCAN_BIN; + *retlen = len; return (flags & PERL_SCAN_GREATER_THAN_UV_MAX) ? rnv : (NV)ruv; } @@ -476,6 +481,8 @@ Perl_scan_oct(pTHX_ const char *start, STRLEN len, STRLEN *retlen) I32 flags = *retlen ? PERL_SCAN_ALLOW_UNDERSCORES : 0; const UV ruv = grok_oct (start, &len, &flags, &rnv); + PERL_ARGS_ASSERT_SCAN_OCT; + *retlen = len; return (flags & PERL_SCAN_GREATER_THAN_UV_MAX) ? rnv : (NV)ruv; } @@ -487,6 +494,8 @@ Perl_scan_hex(pTHX_ const char *start, STRLEN len, STRLEN *retlen) I32 flags = *retlen ? PERL_SCAN_ALLOW_UNDERSCORES : 0; const UV ruv = grok_hex (start, &len, &flags, &rnv); + PERL_ARGS_ASSERT_SCAN_HEX; + *retlen = len; return (flags & PERL_SCAN_GREATER_THAN_UV_MAX) ? rnv : (NV)ruv; } @@ -503,6 +512,9 @@ Perl_grok_numeric_radix(pTHX_ const char **sp, const char *send) { #ifdef USE_LOCALE_NUMERIC dVAR; + + PERL_ARGS_ASSERT_GROK_NUMERIC_RADIX; + if (PL_numeric_radix_sv && IN_LOCALE) { STRLEN len; const char * const radix = SvPV(PL_numeric_radix_sv, len); @@ -514,6 +526,9 @@ Perl_grok_numeric_radix(pTHX_ const char **sp, const char *send) /* always try "." if numeric radix didn't match because * we may have data from different locales mixed */ #endif + + PERL_ARGS_ASSERT_GROK_NUMERIC_RADIX; + if (*sp < send && **sp == '.') { ++*sp; return TRUE; @@ -555,6 +570,8 @@ Perl_grok_number(pTHX_ const char *pv, STRLEN len, UV *valuep) int sawinf = 0; int sawnan = 0; + PERL_ARGS_ASSERT_GROK_NUMBER; + while (s < send && isSPACE(*s)) s++; if (s == send) { @@ -809,6 +826,9 @@ Perl_my_atof(pTHX_ const char* s) NV x = 0.0; #ifdef USE_LOCALE_NUMERIC dVAR; + + PERL_ARGS_ASSERT_MY_ATOF; + if (PL_numeric_local && IN_LOCALE) { NV y; @@ -848,6 +868,8 @@ Perl_my_atof2(pTHX_ const char* orig, NV* value) I32 old_digit = 0; I32 sig_digits = 0; /* noof significant digits seen so far */ + PERL_ARGS_ASSERT_MY_ATOF2; + /* There is no point in processing more significant digits * than the NV can hold. Note that NV_DIG is a lower-bound value, * while we need an upper-bound value. We add 2 to account for this; @@ -865,7 +887,14 @@ Perl_my_atof2(pTHX_ const char* orig, NV* value) * both the first and last digit, since neither can hold all values from * 0..9; but for calculating the value we must examine those two digits. */ -#define MAX_SIG_DIGITS (NV_DIG+2) +#ifdef MAX_SIG_DIG_PLUS + /* It is not necessarily the case that adding 2 to NV_DIG gets all the + possible digits in a NV, especially if NVs are not IEEE compliant + (e.g., long doubles on IRIX) - Allen */ +# define MAX_SIG_DIGITS (NV_DIG+MAX_SIG_DIG_PLUS) +#else +# define MAX_SIG_DIGITS (NV_DIG+2) +#endif /* the max number we can accumulate in a UV, and still safely do 10*N+9 */ #define MAX_ACCUMULATE ( (UV) ((UV_MAX - 9)/10)) @@ -953,10 +982,9 @@ Perl_my_atof2(pTHX_ const char* orig, NV* value) else if (!seen_dp && GROK_NUMERIC_RADIX(&s, send)) { seen_dp = 1; if (sig_digits > MAX_SIG_DIGITS) { - ++s; - while (isDIGIT(*s)) { + do { ++s; - } + } while (isDIGIT(*s)); break; } }