/***************************************************************************
 *
 * _num_get.cc - definition of std::num_get members
 *
 * $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 2001-2006 Rogue Wave Software.
 * 
 **************************************************************************/


#include <loc/_ctype.h>
#include <loc/_locale.h>
#include <loc/_numpunct.h>
#include <rw/_basic_ios.h>


_RWSTD_NAMESPACE (__rw) { 

_RWSTD_EXPORT int
 __rw_get_num (void*, const char*, int, int,
               const char*, _RWSTD_SIZE_T, const char*, _RWSTD_SIZE_T);


// array of values of each base 2 through 36 digit, i.e., 0-9, A-Z,
// and a-z; elements with a value greater than 35 do not correspond
// to any valid digit
_RWSTD_EXPORT extern const unsigned char __rw_digit_map[];

// array of 1-based indices for each 8-bit character into an internal
// table of values of each roman digit, i.e., I, V, X, L, C, D, and M
// elements with a value greater than 7 do not correspond to a roman digit
_RWSTD_EXPORT extern const unsigned char __rw_roman_inxs[];

}   // namespace __rw


_RWSTD_NAMESPACE (_V3_LOCALE) { 


template <class _CharT, class _InputIter>
_RW::__rw_facet_id num_get<_CharT, _InputIter>::id;


#ifndef _RWSTD_NO_EXT_NUM_GET

template <class _CharT, class _InputIter>
_TYPENAME num_get<_CharT, _InputIter>::iter_type
num_get<_CharT, _InputIter>::
get (iter_type __begin, iter_type __end, ios_base &__flags, 
     _RWSTD_IOSTATE &__err, short &__val) const
{
    _RWSTD_ASSERT_RANGE (__begin, __end);

    // preserve original value in case it's non-zero and
    // do_get() fails for reason other than bad grouping
    long __tmp = __val;

    __begin = do_get (__begin, __end, __flags, __err, __tmp);

    long __shrt_min;
    long __shrt_max;

    if (   __tmp < 0
        || (__flags.flags () & _RWSTD_IOS_BASEFIELD) == _RWSTD_IOS_DEC) {
        // decimal parsing overflows outside the range below
        __shrt_max = long (_RWSTD_SHRT_MAX);
        __shrt_min = long (_RWSTD_SHRT_MIN);
    }
    else {
        // other than decimal parsing overflows outside the range below
        // (unreliable if basefield is 0 and the sequence is decimal)
        __shrt_max = long (_RWSTD_USHRT_MAX);
        __shrt_min = long (_RWSTD_USHRT_MIN);
    }

    // lwg issue 23: check for overflow
    if (__tmp < __shrt_min) {
        __err |= _RW::__rw_failbit;
        __val  = short (_RWSTD_SHRT_MIN);
    }
    else if (__tmp > __shrt_max) {
        __err |= _RW::__rw_failbit;
        __val  = short (_RWSTD_SHRT_MAX);
    }
    else
        __val = _RWSTD_STATIC_CAST (short, __tmp);

    return __begin;
}


template <class _CharT, class _InputIter>
_TYPENAME num_get<_CharT, _InputIter>::iter_type
num_get<_CharT, _InputIter>::
get (iter_type __begin, iter_type __end, ios_base &__flags, 
     _RWSTD_IOSTATE &__err, int &__val) const
{
    _RWSTD_ASSERT_RANGE (__begin, __end);

    // preserve original value in case it's non-zero and
    // do_get() fails for reason other than bad grouping
    long __tmp = long (__val);

    __begin = do_get (__begin, __end, __flags, __err, __tmp);

#if _RWSTD_INT_MAX < _RWSTD_LONG_MAX

    long __int_min;
    long __int_max;

    if (   __tmp < 0
        || (__flags.flags () & _RWSTD_IOS_BASEFIELD) == _RWSTD_IOS_DEC) {
        // decimal parsing overflows outside the range below
        __int_max = long (_RWSTD_INT_MAX);
        __int_min = long (_RWSTD_INT_MIN);
    }
    else {
        // other than decimal parsing overflows outside the range below
        // (unreliable if basefield is 0 and the sequence is decimal)
        __int_max = long (_RWSTD_UINT_MAX);
        __int_min = long (_RWSTD_UINT_MIN);
    }

    // lwg issue 23: check for overflow
    if (__tmp < __int_min) {
        __err |= _RW::__rw_failbit;
        __val  = _RWSTD_INT_MIN;
    }
    else if (__tmp > __int_max) {
        __err |= _RW::__rw_failbit;
        __val  = _RWSTD_INT_MAX;
    }
    else

#endif   // _RWSTD_INT_MAX < _RWSTD_LONG_MAX

        __val = _RWSTD_STATIC_CAST (int, __tmp);

    return __begin;
}

#endif   // _RWSTD_NO_EXT_NUM_GET


#ifndef _RWSTD_NO_NATIVE_BOOL

template <class _CharT, class _InputIter /* = istreambuf_iterator<_CharT> */>
_TYPENAME num_get<_CharT, _InputIter>::iter_type
num_get<_CharT, _InputIter>::
do_get (iter_type __begin, iter_type __end, ios_base &__flags,
        _RWSTD_IOSTATE &__err, bool &__val) const
{
    if (0 == (__flags.flags () & _RWSTD_IOS_BOOLALPHA)) {
        // initialize to an invalid value
        long __lval = -1L;

        // avoid calling overridden do_get() if it exists
        typedef num_get<_CharT, _InputIter> _This;
        __begin = _This::do_get (__begin, __end, __flags, __err, __lval);

        // set failbit in accordance with 22.2.2.1.2, p14 but without
        // testing for failbit in `err' since the bit could be set even
        // for valid `val' (e.g., when the positions of thousands_seps
        // in otherwise valid input do not match grouping)
        if (_RWSTD_STATIC_CAST (unsigned long, __lval) < 2)
            __val = 0L != __lval;
        else
            __err |= _RW::__rw_failbit;

        return __begin;
    }

    __err = _RW::__rw_goodbit;

    const numpunct<char_type> &__pun = 
        _V3_USE_FACET (numpunct<char_type>, __flags.getloc ());

    // lwg issue 17
    typedef basic_string<char_type> string_type;

    const string_type __tnm = __pun.truename ();
    const string_type __fnm = __pun.falsename ();

    const char_type* const __names[] = {
        __fnm.c_str (), __tnm.c_str ()
    };

    const _RWSTD_SIZE_T __sizes[] = {
        __fnm.size (), __tnm.size ()
    };

    _RWSTD_SIZE_T __inx = 0;

    int __errtmp = 1;   // maximum number of allowed duplicates

    __begin = _RW::__rw_match_name (__begin, __end, __names, __sizes,
                                    sizeof __names / sizeof *__names,
                                    __inx, __errtmp, 0);

    if (_RWSTD_SIZE_MAX == __inx)
        __err |= _RW::__rw_failbit;
    else
        __val = !!__inx;

    __err |= _RWSTD_IOSTATE (__errtmp);

    return __begin;
}

#endif   // _RWSTD_NO_NATIVE_BOOL


template <class _CharT, class _InputIter /* = istreambuf_iterator<_CharT> */>
_TYPENAME num_get<_CharT, _InputIter>::iter_type
num_get<_CharT, _InputIter>::
_C_get (iter_type __begin, iter_type __end, ios_base &__flags,
        _RWSTD_IOSTATE &__err, int __type, void *__pval) const
{
    __err = _RW::__rw_goodbit;

    const int __fl = __flags.flags ();

    // boolalpha parsing not handled here
    _RWSTD_ASSERT (__type != _C_bool || !(__fl & _RWSTD_IOS_BOOLALPHA));

    const locale &__loc = __flags.getloc ();

    const numpunct<char_type> &__pun = 
        _V3_USE_FACET (numpunct<char_type>, __loc);

    // 22.2.2.1.2, p8: Stage 2

    char __buf [128 + 2];                     // default buffer (128 bits + 2)
    char *__pbuf            = __buf;          // pointer to allocated buffer
    char *__pcur            = __buf;          // currently processed digit
    _RWSTD_SIZE_T __bufsize = sizeof __buf;   // size of allocated buffer

    _RWSTD_UNUSED (__bufsize);

    const ctype<char_type> &__ctp = _V3_USE_FACET (ctype<char_type>, __loc);

    const _CharT __decimal_point = __pun.decimal_point ();
    const _CharT __thousands_sep = __pun.thousands_sep ();

    // grouping string and size are lazily initialized only
    // when the first thousands_sep() is encountered
    string __grouping;
    int    __grpsz = -1;

    // buffer containing the sizes of thousands_sep-separated
    // groups of digits and a pointer to the next grouping
    char __grpbuf [sizeof __buf];
    char *__pgrp = __grpbuf;

    const char *__grpbeg = 0;   // the beginning of the last group
    const char *__grpend = 0;   // the end of the last group

    int __base = unsigned (__fl) >> _RWSTD_IOS_BASEOFF;

    // switch to base-16 for pointer parsing
    if (_RW::__rw_facet::_C_pvoid == __type)
        __base = 16;
    else if (10 == __base && !(__fl & _RWSTD_IOS_BASEFIELD))
        __base = 0;

    int __subtype = __type;   // type of the number being parsed

    typedef unsigned char _UChar;

    // insert a plus sign (ovewrite it with a minus sign if found)
    // to avoid having to deal with the fact that it's optional
    *__pcur++ = '+';

    static const _UChar _HexX = _RW::__rw_digit_map [_UChar ('X')];
    static const _UChar _Sign = _RW::__rw_digit_map [_UChar ('+')];

    // 'x' or 'X' after a leading '0' (the same value for both),
    // any value outside the valid range [0, 36) is invalid and
    // will not match any character
    _UChar __hex_x = _HexX;

    // leading plus or minus sign (the same value for both)
    // any value outside the valid range [0, 36) is invalid
    _UChar __ld_sgn = _Sign;

    for ( ; ; ++__begin) {

        if (__begin == __end) {
            // 22.2.2.1, p13
            __err |= _RW::__rw_eofbit;
            break;
        }

        if (__pcur == __buf + sizeof __buf - 1) {
            // FIXME: handle long strings of digits
            __err |= _RW::__rw_failbit;
            break;
        }

        const _CharT __wc = *__begin;
        const char   __dp = __decimal_point == __wc ? '.' : '\0';

        if (   __thousands_sep == __wc
            && _RW::__rw_digit_map [_UChar (__pcur [-1])] < 36
            && (   __grpsz > 0
                || __grpsz < 0
                && (__grpsz = int((__grouping = __pun.grouping ()).size ())))) {

            // the current character is the thousands separator,
            // the previous character was a digit (and not a sign),
            // and grouping (lazily initialized above) is not empty

            if (__pcur == __pbuf + 1) {
                // 22.2.3.1, p2: thousands_sep not allowed to be first
                // non-fatal error, set failbit but continue parsing
                __err |= _RW::__rw_failbit;
            }

            if (__grpend) {
                // thousands_sep not allowed or recognized after the
                // end of the mantissa has been reached (i.e., after
                // the decimal point or after 'E' or 'e')
                break;
            }

            // add the length of the current group to the array groups
            // store UCHAR_MAX if group length exceeds the size of char
            const _RWSTD_PTRDIFF_T __len = __grpbeg ?
                __pcur - __grpbeg : __pcur - __pbuf - 1 - (_HexX != __hex_x);

            if (0 == __len) {
                // fatal error: thousands_sep characters must be separated
                // by groups of one or more digits
                __err |= _RW::__rw_failbit;                
                return __begin;
            }

            *__pgrp++ = char (__len < _UChar (_RWSTD_UCHAR_MAX) ? __len : -1);
            __grpbeg  = __pcur;
        }
        else if (!__dp) {

            const char __ch = __ctp.narrow (__wc, '\0');

            // get the digit value of the character; anything over
            // 35 is not a digit (43 is either the plus sign or
            // the minus sign, for efficiency); the value 99
            // indicates an invalid character
            const _UChar __digit = _RW::__rw_digit_map [_UChar (__ch)];

            // 22.2.2.1.2, p8: Stage 8 calls for widening of the sequence
            // of narrow digits ("0123456789abcdefABCDEFX+-") and looking
            // up the current wide character in the widened sequence, but
            // that may not possible unless the wide character type has
            // operator==() defined

            if (__subtype & _C_floating) {

                if (__digit < 10)
                    *__pcur++ = __ch;
                else if (__pcur == __pbuf + 1) {
                    // plus or minus only permitted (but not required)
                    // as the first character of the mantissa
                    if (__ld_sgn == __digit) {
                        // overwrite the default plus with the sign
                        __pcur [-1] = __ch;

                        // disable future recognition of the leading sign
                        __ld_sgn = 36;
                    }
                    else
                        break;
                }
                else {
                    if (/* 'E' or 'e' == __ch */
                        14 == _RW::__rw_digit_map [_UChar (__ch)]) {
                        const _RWSTD_PTRDIFF_T __diff = __pcur - __pbuf;

                        if (2 == __diff && '.' == __pcur [-1])
                            break;
                            
                        if (!__grpend)
                            __grpend = __pcur;
                        *__pcur++ = 'e';

                        if (__grpsz) {
                            const char __ts =
                                __ctp.narrow (__thousands_sep, '\0');
                            if (/* '+' or '-' == __ts */
                                _Sign == _RW::__rw_digit_map [_UChar (__ts)])
                                __grpsz = 0;
                        }
                    }
                    else if (   'e' == __pcur [-1]
                             && /* '+' or '-' == __ch */
                                _Sign == _RW::__rw_digit_map [_UChar (__ch)]) {
                        // '+' or '-' only permitted (but not required)
                        // as the first character after 'e' or 'E'

                        *__pcur++ = __ch;

                        // reached the exponent part of a floating point number
                        // switch to parsing a decimal integer
                        __base    = 10;
                        __subtype = _C_int;
                    }
                    else
                        break;  // invalid character terminates input
                }
            }
            else {
                if (__pcur == __pbuf + 1 && __digit == __ld_sgn) {
                    __pcur [-1] = __ch;   // overwrite the default '+'
                    __ld_sgn    = 36;     // disable leading sign
                }
                else if (16 == __base) {
                    if (__digit < 16)
                        *__pcur++ = __ch;
                    else if (   __digit == __hex_x
                             && __pcur == __pbuf + 2
                             && __pcur [-1] == '0') {
                        // don't append the 'x' part of the "0x" prefix
                        // and disable the recognition of any future 'x'
                        __hex_x = 36;
                    }
                    else
                        break;   // invalid character terminates input
                }
                else if (__base > 1) {
                    if (__digit < __base)
                        *__pcur++ = __ch;
                    else
                        break;   // invalid character terminates input
                }
                else if (0 == __base) {

                    // autodetect the base

                    if (__digit < 10) {
                        if (   __digit && __digit < 8
                            && *(__pcur - 1) == '0' && __pcur == __pbuf + 2)
                            __base = 8;
                        *__pcur++ = __ch;
                    }
                    else if (   __digit == __hex_x
                             && __pcur == __pbuf + 2
                             && __pcur [-1] == '0') {
                        __hex_x = 36;   // disable future 'x'
                        __base  = 16;   // set base-16
                        --__pcur;       // remove leading '0'
                    }
                    else
                        break;   // invalid character terminates input
                }
                else {
                    if (_RW::__rw_roman_inxs [_UChar (__ch)] <= 7)
                        *__pcur++ = __ch;
                    else if (__pcur == __pbuf + 1 && __digit < 10) {
                        *__pcur++ = __ch;
                        // if the first character is a digit
                        // switch to decimal (base-10) parsing
                        __base = 10;
                    }
                    else {
                        // invalid character terminates input
                        break;
                    }
                }
            }
        }
        else if (__subtype & _C_floating) {
            if (__grpend)
                break;

            __grpend  = __pcur;
            *__pcur++ = '.';
        }
        else
            break;
    }

    // add the length of the last group to the array of groups
    {
        // add the length of the current group to the array groups
        // store UCHAR_MAX if group length exceeds the size of char
        _RWSTD_PTRDIFF_T __len;

        if (__grpend) {

#if defined (_RWSTD_NO_STRTOLD) && defined (_RWSTD_NO_STRTOLD_IN_LIBC)

            // detect invalid formats in case strtold() is not
            // available (scanf() will not detect these)

            if (   'e' == __pcur [-1]
                || '-' == __pcur [-1] || '+' == __pcur [-1]) {
                __err |= _RW::__rw_failbit;
                return __begin;
            }

#endif   // _RWSTD_NO_STRTOLD && _RWSTD_NO_STRTOLD_IN_LIBC

        }
        else
            __grpend = __pcur;

        __len = __grpbeg ?
            __grpend - __grpbeg : __grpend - __pbuf - 1 - (_HexX != __hex_x);

        if (__grpbeg && 0 == __len) {
            // fatal error: according to the grammar in [locale.numpunct]
            // thousands_sep characters must be separated by groups of one
            // or more digits (i.e., valid input cannot start or end with
            // a thousands_sep); this needs to be clarified in the text
            __err |= _RW::__rw_failbit;
            return __begin;
        }

        *__pgrp++ = char (__len < _UChar (_RWSTD_UCHAR_MAX) ? __len : -1);
    }

    *__pgrp = '\0';
    *__pcur = '\0';

    // verify that the buffers haven't overflowed
    _RWSTD_ASSERT (__pgrp < __grpbuf + sizeof __grpbuf);
    _RWSTD_ASSERT (__pcur < __pbuf + __bufsize);

    // set the base determined above
    const unsigned __fl2 =
          __fl & ~_RWSTD_IOS_BASEFIELD
        & ~(_RWSTD_IOS_BASEMASK << _RWSTD_IOS_BASEOFF)
        | __base << _RWSTD_IOS_BASEOFF;

    // 22.2.2.1.2, p11: Stage 3
    const int __errtmp =
        _RW::__rw_get_num (__pval, __pbuf, __type, __fl2,
                           __grpbuf, __pgrp - __grpbuf,
                           __grouping.data (), __grouping.size ());

    __err |= _RWSTD_IOSTATE (__errtmp);

    return __begin;
}


}   // namespace _V3_LOCALE