strtol.cpp

Go to the documentation of this file.

 
#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