blob: f9cc1c10bd1f2c4a869a25b114339fc69fe45bc6 [file] [log] [blame]
/***************************************************************************
*
* strtol.cpp - definitions of __rw_strtol, __rw_strtoul, and other helpers
*
* $Id$
*
***************************************************************************
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed
* with this work for additional information regarding copyright
* ownership. The ASF licenses this file to you under the Apache
* License, Version 2.0 (the License); you may not use this file
* except in compliance with the License. You may obtain a copy of
* the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
* implied. See the License for the specific language governing
* permissions and limitations under the License.
*
* Copyright 1994-2006 Rogue Wave Software, Inc.
*
**************************************************************************/
#define _RWSTD_LIB_SRC
#include <rw/_defs.h>
#include "strtol.h"
#include <errno.h> // for ERANGE, errno
// in case EINVAL is not #defined in errno.h
#ifdef EINVAL
# define _RWSTD_EINVAL EINVAL
#else // if !defined (EINVAL)
// actual value of EINVAL on both Linux and SunOS is 22
# define _RWSTD_EINVAL 22
#endif // EINVAL
_RWSTD_NAMESPACE (__rw) {
typedef unsigned char UChar;
// array of values of each base 2 through 36 digits, i.e., 0-9, A-Z,
// and a-z; elements with value greater than 35 do not correspond to
// any valid digit
_RWSTD_EXPORT extern const UChar
__rw_digit_map[] = {
#if 'A' == 0x41
// basic ASCII:
// 0 1 2 3 4 5 6 7 8 9 a b c d e f
// NUL SOH STX ETX EOT ENQ ACK BEL BS TAB LF VT FF CR SO SI
/* 0 */ 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
// DLE DC1 DC2 DC3 DC4 NAK SYN ETB CAN EM SUB ESC FS GS RS US
/* 1 */ 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
// SPC ! " # $ % ' ' ( ) * + , - . /
/* 2 */ 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 43, 99, 43, 99, 99,
// 0 1 2 3 4 5 6 7 8 9 : ; < = > ?
/* 3 */ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 99, 99, 99, 99, 99, 99,
// @ A B C D E F G H I J K L M N O
/* 4 */ 99, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
// P Q R S T U V W X Y Z [ \ ] ^ _
/* 5 */ 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 99, 99, 99, 99, 99,
// ` a b c d e f g h i j k l m n o
/* 6 */ 99, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
// p q r s t u v w x y z { | } ~ DEL
/* 7 */ 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 99, 99, 99, 99, 99,
// extended ASCII:
// IND NEL SSA ESA HTS HTJ VTS PLD PLU RI SS2 SS3
/* 8 */ 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
// DCS PU1 PU2 STS CCH MW SPA EPA CSI ST OSC PM APC
/* 9 */ 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
/* a */ 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
/* b */ 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
/* c */ 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
/* d */ 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
/* e */ 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
/* f */ 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99
#elif 'A' == 0xc1
// EBCDIC:
// 0 1 2 3 4 5 6 7 8 9 a b c d e f
// NUL SOH STX ETX PF HT LC DEL SMM VT FF CR SO SI
/* 0 */ 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
// DLE DC1 DC2 TM RES NL BS IL CAN EM CC CU1 IFS IGS IRS IUS
/* 1 */ 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
// DS SOS FS BYP LF ETB ESC SM CU2 ENQ ACK BEL
/* 2 */ 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
// SYN PN RS UC EOT CU3 DC4 NAK SUB
/* 3 */ 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
// SP ct. . < ( + |
/* 4 */ 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 43, 99,
// & ! $ * ) ; ~
/* 5 */ 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
// - / , % _ > ?
/* 6 */ 43, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
// : # @ ' = "
/* 7 */ 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
// a b c d e f g h i
/* 8 */ 99, 10, 11, 12, 13, 14, 15, 16, 17, 18, 99, 99, 99, 99, 99, 99,
// j k l m n o p q r
/* 9 */ 99, 19, 20, 21, 22, 23, 24, 25, 26, 27, 99, 99, 99, 99, 99, 99,
// s t u v w x y z
/* a */ 99, 99, 28, 29, 30, 31, 32, 33, 34, 35, 99, 99, 99, 99, 99, 99,
// `
/* b */ 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
// A B C D E F G H I
/* c */ 99, 10, 11, 12, 13, 14, 15, 16, 17, 18, 99, 99, 99, 99, 99, 99,
// J K L M N O P Q R
/* d */ 99, 19, 20, 21, 22, 23, 24, 25, 26, 27, 99, 99, 99, 99, 99, 99,
// S T U V W X Y Z
/* e */ 99, 99, 28, 29, 30, 31, 32, 33, 34, 35, 99, 99, 99, 99, 99, 99,
// 0 1 2 3 4 5 6 7 8 9
/* f */ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 99, 99, 99, 99, 99, 99
#else // 'A' != 0x41 && 'A' != 0xc1
# error unknown character set (neither ASCII nor EBCDIC)
#endif // ASCII or EBCDIC
};
// the number of bits necessary to exactly represent
// a single digit in base 0 - 36 (base is index)
static const char
__rw_base_bits [] = {
/* 0 - 15 */ 0, 0, 1, 0, 2, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0,
/* 16 - 31 */ 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* 32 - 36 */ 0, 0, 0, 0, 0
// Note: __rw_base_bits [32] is 0 above to eliminate overflow
// checking for strings of up to 8 hexadecimal digits
// in __rw_strtoul() below
};
#undef max
#undef min
// SHift Left and OR: helper macro used by __rw_strtol
// to multiply a number by a power of 2 (SHL) and add
// another number less than the power (OR)
//
// IMPORTANT: each argument must be evaluated exactly once
#undef SHLOR
#define SHLOR(x, dig) (((x) << shift) | __rw_digit_map [UChar (dig)])
// helper macro to keep lines under 80 characters
#define SHLOR_4_DIGITS_BEGIN(res, nptr) \
if (*++nptr) { \
res = SHLOR (res, *nptr); \
if (*++nptr) { \
res = SHLOR (res, *nptr); \
if (*++nptr) { \
res = SHLOR (res, *nptr); \
if (*++nptr) { \
res = SHLOR (res, *nptr)
#define SHLOR_4_DIGITS_END() } } } } (void)0
// MULtiply and ADD: helper macro used by __rw_strtol
//
// IMPORTANT: each argument must be evaluated exactly once
#undef MULADD
#define MULADD(x, dig) (((x) * base) + __rw_digit_map [UChar (dig)])
// helper macro to keep lines under 80 characters
#define MULADD_4_DIGITS_BEGIN(res, nptr) \
if (nptr [1]) { \
res = MULADD (res, *++nptr); \
if (nptr [1]) { \
res = MULADD (res, *++nptr); \
if (nptr [1]) { \
res = MULADD (res, *++nptr); \
if (nptr [1]) { \
res = MULADD (res, *++nptr)
#define MULADD_4_DIGITS_END() } } } } (void)0
unsigned long
__rw_strtoul (const char *nptr, int *errptr, int base) _THROWS (())
{
_RWSTD_ASSERT (0 != nptr);
_RWSTD_ASSERT (0 != errptr);
_RWSTD_ASSERT ('+' == *nptr || '-' == *nptr);
_RWSTD_ASSERT (1 < base && base < 37);
const bool neg = '-' == *nptr++;
if (!*nptr) {
*errptr = _RWSTD_EINVAL;
return 0;
}
const int shift = __rw_base_bits [base];
unsigned long res = __rw_digit_map [UChar (*nptr)];
_RWSTD_ASSERT (res < unsigned (base));
if (shift) {
// process subject sequence by shifting
if (*++nptr) {
// unroll loop w/o overflow checking for as many as
// 8 (on ILP32) or 16 (on LP64) digits (max base is 16)
// shift left and add second digit
res = SHLOR (res, *nptr);
if (*++nptr) {
// third digit
res = SHLOR (res, *nptr);
if (*++nptr) {
// fourth digit
res = SHLOR (res, *nptr);
#if 2 < _RWSTD_LONG_SIZE
// parse up to 4 more digits w/o overflow checking
// (i.e., digits 5 through 8, inclusive)
SHLOR_4_DIGITS_BEGIN (res, nptr);
# if 4 < _RWSTD_LONG_SIZE
// .2....:....1....:....0
// ULONG_MAX >= 1777777777777777777777 (oct)
// ULONG_MAX >= ffffffffffffffff (hex)
// parse up to 8 more digits w/o overflow checking
// (i.e., digits 9 through 16, inclusive)
SHLOR_4_DIGITS_BEGIN (res, nptr);
SHLOR_4_DIGITS_BEGIN (res, nptr);
# endif // 4 < _RWSTD_LONG_SIZE
#endif // 2 < _RWSTD_LONG_SIZE
// parse any remaining digits with overflow checking
// (i.e., digits 9 on ILP32 or 17 on LP64 and beyond)
while (*++nptr) {
const unsigned digit =
__rw_digit_map [UChar (*nptr)];
_RWSTD_ASSERT (digit < unsigned (base));
// check for overflow
const unsigned long save = res;
res <<= shift;
if (res < save)
goto overflow;
// can't overflow
res += digit;
}
#if 2 < _RWSTD_LONG_SIZE
# if 4 < _RWSTD_LONG_SIZE
// close brackets
SHLOR_4_DIGITS_END ();
SHLOR_4_DIGITS_END ();
# endif // 4 < _RWSTD_LONG_SIZE
// close brackets
SHLOR_4_DIGITS_END ();
#endif // 2 < _RWSTD_LONG_SIZE
}
}
}
}
else {
// process subject sequence by multiplication
// unroll loop w/o overflow checking
if (*++nptr) {
// multiply by base and add second digit
res = MULADD (res, *nptr);
#if 2 < _RWSTD_LONG_SIZE
// ....:....0 (10 decimal digits)
// ULONG_MAX >= 4294967295 (dec)
// ULONG_MAX >= 1z141z3 (base-36)
// digits 3 through 6, inclusive
MULADD_4_DIGITS_BEGIN (res, nptr);
# if 4 < _RWSTD_LONG_SIZE
// ....:....1....:....0 (20 decimal digits)
// ULONG_MAX >= 18446744073709551615 (dec)
// ULONG_MAX >= 5g24a25twkwff (base-36)
// digits 7 through 10, inclusive
MULADD_4_DIGITS_BEGIN (res, nptr);
if (nptr [1]) {
// digit 11
res = MULADD (res, *++nptr);
if (base < 12) {
// unroll w/o overflow checking for bases up to 11
// digits 12 - 19
MULADD_4_DIGITS_BEGIN (res, nptr);
MULADD_4_DIGITS_BEGIN (res, nptr);
// close brackets
MULADD_4_DIGITS_END ();
MULADD_4_DIGITS_END ();
}
}
// close brackets
MULADD_4_DIGITS_END ();
# else // if 4 >= _RWSTD_LONG_SIZE
if (base < 12) {
// unroll w/o overflow checking for bases up to 11
if (nptr [1]) {
// seventh digit
res = MULADD (res, *++nptr);
if (nptr [1]) {
// eighth digit
res = MULADD (res, *++nptr);
if (nptr [1]) {
// ninth digit
res = MULADD (res, *++nptr);
}
}
}
}
# endif // 4 < _RWSTD_LONG_SIZE
// close brackets
MULADD_4_DIGITS_END ();
#endif // 2 < _RWSTD_LONG_SIZE
for (unsigned long maxres = _RWSTD_ULONG_MAX / base; *++nptr; ) {
const unsigned digit = __rw_digit_map [UChar (*nptr)];
_RWSTD_ASSERT (digit < unsigned (base));
// check for overflow
if (maxres < res)
goto overflow;
res *= base;
if (_RWSTD_ULONG_MAX - res < digit)
goto overflow;
res += digit;
}
}
}
return neg ? 0UL - res : res;
overflow:
// set errptr to ERANGE on overflow and return ULONG_MAX
*errptr = ERANGE;
return _RWSTD_ULONG_MAX;
}
long
__rw_strtol (const char *nptr, int *errptr, int base) _THROWS (())
{
_RWSTD_ASSERT (0 != nptr);
_RWSTD_ASSERT (0 != errptr);
_RWSTD_ASSERT ('+' == *nptr || '-' == *nptr);
const bool neg = '-' == *nptr++;
if (!*nptr) {
*errptr = _RWSTD_EINVAL;
return 0;
}
const int shift = __rw_base_bits [base];
unsigned long res = __rw_digit_map [UChar (*nptr)];
_RWSTD_ASSERT (res < unsigned (base));
if (shift) {
// process subject sequence by shifting
if (*++nptr) {
// unroll loop w/o overflow checking for as many as
// 8 (on ILP32) or 16 (on LP64) digits (max base is 16)
// shift left and add second digit
res = SHLOR (res, *nptr);
if (*++nptr) {
// third digit
res = SHLOR (res, *nptr);
if (*++nptr) {
// fourth digit
res = SHLOR (res, *nptr);
#if 2 < _RWSTD_LONG_SIZE
// parse up to 4 more digits w/o overflow checking
// (i.e., digits 5 through 8, inclusive)
SHLOR_4_DIGITS_BEGIN (res, nptr);
# if 4 < _RWSTD_LONG_SIZE
// .2....:....1....:....0
// ULONG_MAX >= 1777777777777777777777 (oct)
// ULONG_MAX >= ffffffffffffffff (hex)
// parse up to 8 more digits w/o overflow checking
// (i.e., digits 9 through 16, inclusive)
SHLOR_4_DIGITS_BEGIN (res, nptr);
SHLOR_4_DIGITS_BEGIN (res, nptr);
# endif // 4 < _RWSTD_LONG_SIZE
#endif // 2 < _RWSTD_LONG_SIZE
// parse any remaining digits with overflow checking
// (i.e., digits 9 on ILP32 or 17 on LP64 and beyond)
while (*++nptr) {
const unsigned digit =
__rw_digit_map [UChar (*nptr)];
_RWSTD_ASSERT (digit < unsigned (base));
// check for overflow
const unsigned long save = res;
res <<= shift;
if (res < save)
goto overflow;
// can't overflow
res += digit;
}
#if 2 < _RWSTD_LONG_SIZE
# if 4 < _RWSTD_LONG_SIZE
// close brackets
SHLOR_4_DIGITS_END ();
SHLOR_4_DIGITS_END ();
# endif // 4 < _RWSTD_LONG_SIZE
// close brackets
SHLOR_4_DIGITS_END ();
#endif // 2 < _RWSTD_LONG_SIZE
}
}
}
}
else {
// process subject sequence by multiplication
// unroll loop w/o overflow checking
if (*++nptr) {
// multiply by base and add second digit
res = MULADD (res, *nptr);
#if 2 < _RWSTD_LONG_SIZE
// ....:....0 (10 decimal digits)
// ULONG_MAX >= 4294967295 (dec)
// ULONG_MAX >= 1z141z3 (base-36)
// digits 3 through 6, inclusive
MULADD_4_DIGITS_BEGIN (res, nptr);
# if 4 < _RWSTD_LONG_SIZE
// ....:....1....:....0 (20 decimal digits)
// ULONG_MAX >= 18446744073709551615 (dec)
// ULONG_MAX >= 5g24a25twkwff (base-36)
// digits 7 through 10, inclusive
MULADD_4_DIGITS_BEGIN (res, nptr);
if (nptr [1]) {
// digit 11
res = MULADD (res, *++nptr);
if (base < 12) {
// unroll w/o overflow checking for bases up to 11
// digits 12 - 19
MULADD_4_DIGITS_BEGIN (res, nptr);
MULADD_4_DIGITS_BEGIN (res, nptr);
// close brackets
MULADD_4_DIGITS_END ();
MULADD_4_DIGITS_END ();
}
}
// close brackets
MULADD_4_DIGITS_END ();
# else // if 4 >= _RWSTD_LONG_SIZE
if (base < 12) {
// unroll w/o overflow checking for bases up to 11
if (nptr [1]) {
// seventh digit
res = MULADD (res, *++nptr);
if (nptr [1]) {
// eighth digit
res = MULADD (res, *++nptr);
if (nptr [1]) {
// ninth digit
res = MULADD (res, *++nptr);
}
}
}
}
# endif // 4 < _RWSTD_LONG_SIZE
// close brackets
MULADD_4_DIGITS_END ();
#endif // 2 < _RWSTD_LONG_SIZE
for (unsigned long maxres = _RWSTD_ULONG_MAX / base; *++nptr; ) {
const unsigned digit = __rw_digit_map [UChar (*nptr)];
_RWSTD_ASSERT (digit < unsigned (base));
// check for overflow
if (maxres < res)
goto overflow;
res *= base;
if (_RWSTD_ULONG_MAX - res < digit)
goto overflow;
res += digit;
}
}
}
typedef unsigned long ULong;
if (neg) {
if (res > ULong (_RWSTD_LONG_MIN)) {
*errptr = ERANGE;
return _RWSTD_LONG_MIN;
}
return -long (res);
}
if (res > ULong (_RWSTD_LONG_MAX)) {
*errptr = ERANGE;
return _RWSTD_LONG_MAX;
}
return res;
overflow:
// set errptr to ERANGE on overflow and return LONG_MIN or _MAX
*errptr = ERANGE;
return ULong (neg ? _RWSTD_LONG_MIN : _RWSTD_LONG_MAX);
}
#ifdef _RWSTD_LONG_LONG
// for convenience
typedef _RWSTD_LONG_LONG LLong;
typedef unsigned _RWSTD_LONG_LONG ULLong;
// using LLONG_SIZE instead of ULLONG_MAX in the preprocessor
// conditional below to work around a gcc 3.2 bug (PR #28595)
# if (_RWSTD_LONG_SIZE < _RWSTD_LLONG_SIZE)
ULLong
__rw_strtoull (const char *nptr, int *errptr, int base) _THROWS (())
{
_RWSTD_ASSERT (0 != nptr);
_RWSTD_ASSERT (0 != errptr);
_RWSTD_ASSERT ('+' == *nptr || '-' == *nptr);
const bool neg = '-' == *nptr++;
if (!*nptr) {
*errptr = _RWSTD_EINVAL;
return 0;
}
const int shift = __rw_base_bits [base];
ULLong res = __rw_digit_map [UChar (*nptr)];
_RWSTD_ASSERT (res < unsigned (base));
if (shift) {
// process subject sequence by shifting
if (*++nptr) {
// unroll loop w/o overflow checking for as many as
// 8 (on ILP32) or 16 (on LP64) digits (max base is 16)
// shift left and add second digit
res = SHLOR (res, *nptr);
if (*++nptr) {
// third digit
res = SHLOR (res, *nptr);
if (*++nptr) {
// fourth digit
res = SHLOR (res, *nptr);
// parse up to 4 more digits w/o overflow checking
// (i.e., digits 5 through 8, inclusive)
SHLOR_4_DIGITS_BEGIN (res, nptr);
# if 4 < _RWSTD_LLONG_SIZE
// .2....:....1....:....0
// ULLONG_MAX >= 1777777777777777777777 (oct)
// ULLONG_MAX >= ffffffffffffffff (hex)
// parse up to 8 more digits w/o overflow checking
// (i.e., digits 9 through 16, inclusive)
SHLOR_4_DIGITS_BEGIN (res, nptr);
SHLOR_4_DIGITS_BEGIN (res, nptr);
# endif // 4 < _RWSTD_LLONG_SIZE
// parse any remaining digits with overflow checking
// (i.e., digits 9 on ILP32 or 17 on LP64 and beyond)
while (*++nptr) {
const unsigned digit =
__rw_digit_map [UChar (*nptr)];
_RWSTD_ASSERT (digit < unsigned (base));
// check for overflow
const ULLong save = res;
res <<= shift;
if (res < save)
goto overflow;
// can't overflow
res += digit;
}
# if 4 < _RWSTD_LLONG_SIZE
// close brackets
SHLOR_4_DIGITS_END ();
SHLOR_4_DIGITS_END ();
# endif // 4 < _RWSTD_LLONG_SIZE
// close brackets
SHLOR_4_DIGITS_END ();
}
}
}
}
else {
// process subject sequence by multiplication
// unroll loop w/o overflow checking
if (nptr [1]) {
// multiply by base and add second digit
res = MULADD (res, *++nptr);
// digits 3 through 6, inclusive
MULADD_4_DIGITS_BEGIN (res, nptr);
# if 4 < _RWSTD_LLONG_SIZE
// ....:....1....:....0 (20 decimal digits)
// ULLONG_MAX >= 18446744073709551615 (dec)
// ULLONG_MAX >= 5g24a25twkwff (base-36)
// digits 7 through 10, inclusive
MULADD_4_DIGITS_BEGIN (res, nptr);
if (nptr [1]) {
// digit 11
res = MULADD (res, *++nptr);
if (base < 12) {
// unroll w/o overflow checking for bases up to 11
// digits 12 - 19
MULADD_4_DIGITS_BEGIN (res, nptr);
MULADD_4_DIGITS_BEGIN (res, nptr);
// close brackets
MULADD_4_DIGITS_END ();
MULADD_4_DIGITS_END ();
}
}
// close brackets
MULADD_4_DIGITS_END ();
# else // if 4 >= _RWSTD_LLONG_SIZE
if (base < 12) {
// unroll w/o overflow checking for bases up to 11
if (nptr [1]) {
// seventh digit
res = MULADD (res, *++nptr);
if (nptr [1]) {
// eighth digit
res = MULADD (res, *++nptr);
if (nptr [1]) {
// ninth digit
res = MULADD (res, *++nptr);
}
}
}
}
# endif // 4 < _RWSTD_LLONG_SIZE
// close brackets
MULADD_4_DIGITS_END ();
for (ULLong maxres = _RWSTD_ULLONG_MAX / base; *++nptr; ) {
const unsigned digit = __rw_digit_map [UChar (*nptr)];
_RWSTD_ASSERT (digit < unsigned (base));
// check for overflow
if (maxres < res)
goto overflow;
res *= base;
if (_RWSTD_ULLONG_MAX - res < digit)
goto overflow;
res += digit;
}
}
}
return neg ? 0UL - res : res;
overflow:
// set errptr to ERANGE on overflow and return ULLONG_MAX
*errptr = ERANGE;
return _RWSTD_ULLONG_MAX;
}
LLong
__rw_strtoll (const char *nptr, int *errptr, int base) _THROWS (())
{
_RWSTD_ASSERT (0 != nptr);
_RWSTD_ASSERT (0 != errptr);
_RWSTD_ASSERT ('+' == *nptr || '-' == *nptr);
const bool neg = '-' == *nptr++;
if (!*nptr) {
*errptr = _RWSTD_EINVAL;
return 0;
}
const int shift = __rw_base_bits [base];
ULLong res = __rw_digit_map [UChar (*nptr)];
_RWSTD_ASSERT (res < unsigned (base));
if (shift) {
// process subject sequence by shifting
if (*++nptr) {
// unroll loop w/o overflow checking for as many as
// 8 (on ILP32) or 16 (on LP64) digits (max base is 16)
// shift left and add second digit
res = SHLOR (res, *nptr);
if (*++nptr) {
// third digit
res = SHLOR (res, *nptr);
if (*++nptr) {
// fourth digit
res = SHLOR (res, *nptr);
// parse up to 4 more digits w/o overflow checking
// (i.e., digits 5 through 8, inclusive)
SHLOR_4_DIGITS_BEGIN (res, nptr);
# if 4 < _RWSTD_LLONG_SIZE
// .2....:....1....:....0
// ULLONG_MAX >= 1777777777777777777777 (oct)
// ULLONG_MAX >= ffffffffffffffff (hex)
// parse up to 8 more digits w/o overflow checking
// (i.e., digits 9 through 16, inclusive)
SHLOR_4_DIGITS_BEGIN (res, nptr);
SHLOR_4_DIGITS_BEGIN (res, nptr);
# endif // 4 < _RWSTD_LLONG_SIZE
// parse any remaining digits with overflow checking
// (i.e., digits 9 on ILP32 or 17 on LP64 and beyond)
while (*++nptr) {
const unsigned digit =
__rw_digit_map [UChar (*nptr)];
_RWSTD_ASSERT (digit < unsigned (base));
// check for overflow
const ULLong save = res;
res <<= shift;
if (res < save)
goto overflow;
// can't overflow
res += digit;
}
# if 4 < _RWSTD_LLONG_SIZE
// close brackets
SHLOR_4_DIGITS_END ();
SHLOR_4_DIGITS_END ();
# endif // 4 < _RWSTD_LLONG_SIZE
// close brackets
SHLOR_4_DIGITS_END ();
}
}
}
}
else {
// process subject sequence by multiplication
// unroll loop w/o overflow checking
if (*++nptr) {
// multiply by base and add second digit
res = MULADD (res, *nptr);
// digits 3 through 6, inclusive
MULADD_4_DIGITS_BEGIN (res, nptr);
# if 4 < _RWSTD_LLONG_SIZE
// ....:....1....:....0 (20 decimal digits)
// ULLONG_MAX >= 18446744073709551615 (dec)
// ULLONG_MAX >= 5g24a25twkwff (base-36)
// digits 7 through 10, inclusive
MULADD_4_DIGITS_BEGIN (res, nptr);
if (nptr [1]) {
// digit 11
res = MULADD (res, *++nptr);
if (base < 12) {
// unroll w/o overflow checking for bases up to 11
// digits 12 - 19
MULADD_4_DIGITS_BEGIN (res, nptr);
MULADD_4_DIGITS_BEGIN (res, nptr);
// close brackets
MULADD_4_DIGITS_END ();
MULADD_4_DIGITS_END ();
}
}
// close brackets
MULADD_4_DIGITS_END ();
# else // if 4 >= _RWSTD_LLONG_SIZE
if (base < 12) {
// unroll w/o overflow checking for bases up to 11
if (nptr [1]) {
// seventh digit
res = MULADD (res, *++nptr);
if (nptr [1]) {
// eighth digit
res = MULADD (res, *++nptr);
if (nptr [1]) {
// ninth digit
res = MULADD (res, *++nptr);
}
}
}
}
# endif // 4 < _RWSTD_LLONG_SIZE
// close brackets
MULADD_4_DIGITS_END ();
for (ULLong maxres = _RWSTD_ULLONG_MAX / base; *++nptr; ) {
const unsigned digit = __rw_digit_map [UChar (*nptr)];
_RWSTD_ASSERT (digit < unsigned (base));
// check for overflow
if (maxres < res)
goto overflow;
res *= base;
if (_RWSTD_ULLONG_MAX - res < digit)
goto overflow;
res += digit;
}
}
}
if (neg) {
if (res > ULLong (_RWSTD_LLONG_MIN)) {
*errptr = ERANGE;
return _RWSTD_LLONG_MIN;
}
return -LLong (res);
}
if (res > ULLong (_RWSTD_LLONG_MAX)) {
*errptr = ERANGE;
return _RWSTD_LLONG_MAX;
}
return res;
overflow:
// set errptr to ERANGE on overflow and return LLONG_MIN or _MAX
*errptr = ERANGE;
return ULLong (neg ? _RWSTD_LLONG_MIN : _RWSTD_LLONG_MAX);
}
# endif // _RWSTD_LLONG_SIZE < _RWSTD_LLONG_SIZE
#endif // _RWSTD_LONG_LONG
} // namespace __rw