/*

 * Copyright (c) 1999

 * Silicon Graphics Computer Systems, Inc.

 *

 * Copyright (c) 1999

 * Boris Fomitchev

 *

 * This material is provided "as is", with absolutely no warranty expressed

 * or implied. Any use is at your own risk.

 *

 * Permission to use or copy this software for any purpose is hereby granted

 * without fee, provided the above notices are retained on all copies.

 * Permission to modify the code and to distribute modified code is granted,

 * provided the above notices are retained, and a notice that the code was

 * modified is included with the above copyright notice.

 *

 */

#ifndef _STLP_NUM_GET_C

#define _STLP_NUM_GET_C

#ifndef _STLP_INTERNAL_NUM_GET_H

#  include <stl/_num_get.h>

#endif

#ifndef _STLP_INTERNAL_LIMITS

#  include <stl/_limits.h>

#endif

_STLP_BEGIN_NAMESPACE

_STLP_MOVE_TO_PRIV_NAMESPACE

_STLP_DECLSPEC unsigned char _STLP_CALL __digit_val_table(unsigned);

_STLP_DECLSPEC const char* _STLP_CALL __narrow_atoms();

template < class _InputIter, class _Integer, class _CharT>

_InputIter _STLP_CALL

__do_get_integer(_InputIter&, _InputIter&, ios_base&, ios_base::iostate&, _Integer&, _CharT*);

// __do_get_integer and its helper functions.

inline bool _STLP_CALL __get_fdigit(char __c, const char*)

{ return __c >= '0' && __c <= '9'; }

inline bool _STLP_CALL __get_fdigit_or_sep(char& __c, char __sep, const char *__digits) {

  if (__c == __sep) {

    __c = ',' ;

    return true ;

  }

  else

    return  __get_fdigit(__c, __digits);

}

inline int _STLP_CALL

__get_digit_from_table(unsigned __index)

{ return (__index > 127 ? 0xFF : __digit_val_table(__index)); }

template <class _InputIter, class _CharT>

int

__get_base_or_zero(_InputIter& __in_ite, _InputIter& __end, ios_base& __str, _CharT*) {

  _CharT __atoms[5];

  const ctype<_CharT>& __c_type = *__STATIC_CAST(const ctype<_CharT>*, __str._M_ctype_facet());

  __c_type.widen(__narrow_atoms(), __narrow_atoms() + 5, __atoms);

  bool __negative = false;

  _CharT __c = *__in_ite;

  if (__c == __atoms[1] /* __xminus_char */ ) {

    __negative = true;

    ++__in_ite;

  }

  else if (__c == __atoms[0] /* __xplus_char */ )

    ++__in_ite;

  int __base;

  int __valid_zero = 0;

  ios_base::fmtflags __basefield = __str.flags() & ios_base::basefield;

  switch (__basefield) {

  case ios_base::oct:

    __base = 8;

    break;

  case ios_base::dec:

    __base = 10;

    break;

  case ios_base::hex:

    __base = 16;

    if (__in_ite != __end && *__in_ite == __atoms[2] /* __zero_char */ ) {

      ++__in_ite;

      if (__in_ite != __end &&

          (*__in_ite == __atoms[3] /* __x_char */ || *__in_ite == __atoms[4] /* __X_char */ ))

        ++__in_ite;

      else

        __valid_zero = 1; // That zero is valid by itself.

    }

    break;

  default:

    if (__in_ite != __end && *__in_ite == __atoms[2] /* __zero_char */ ) {

      ++__in_ite;

      if (__in_ite != __end &&

          (*__in_ite == __atoms[3] /* __x_char */ || *__in_ite == __atoms[4] /* __X_char */ )) {

        ++__in_ite;

        __base = 16;

      }

      else

        {

          __base = 8;

          __valid_zero = 1; // That zero is still valid by itself.

        }

    }

    else

      __base = 10;

    break;

  }

  return (__base << 2) | ((int)__negative << 1) | __valid_zero;

}

template <class _InputIter, class _Integer, class _CharT>

bool _STLP_CALL

__get_integer(_InputIter& __first, _InputIter& __last,

              int __base, _Integer& __val,

              int __got, bool __is_negative, _CharT __separator, const string& __grouping, const __true_type& /*_IsSigned*/) {

  bool __ovflow = false;

  _Integer __result = 0;

  bool __is_group = !__grouping.empty();

  char __group_sizes[64];

  char __current_group_size = 0;

  char* __group_sizes_end = __group_sizes;

  _Integer __over_base = (numeric_limits<_Integer>::min)() / __STATIC_CAST(_Integer, __base);

   for ( ; __first != __last ; ++__first) {

     const _CharT __c = *__first;

     if (__is_group && __c == __separator) {

       *__group_sizes_end++ = __current_group_size;

       __current_group_size = 0;

       continue;

     }

     int __n = __get_digit_from_table(__c);

     if (__n >= __base)

       break;

     ++__got;

     ++__current_group_size;

     if (__result < __over_base)

       __ovflow = true;  // don't need to keep accumulating

     else {

       _Integer __next = __STATIC_CAST(_Integer, __base * __result - __n);

       if (__result != 0)

         __ovflow = __ovflow || __next >= __result;

       __result = __next;

     }

   }

   if (__is_group && __group_sizes_end != __group_sizes) {

     *__group_sizes_end++ = __current_group_size;

   }

   // fbp : added to not modify value if nothing was read

   if (__got > 0) {

       __val = __ovflow ? __is_negative ? (numeric_limits<_Integer>::min)()

                                        : (numeric_limits<_Integer>::max)()

                        : __is_negative ? __result

                                        : __STATIC_CAST(_Integer, -__result);

   }

  // overflow is being treated as failure

  return ((__got > 0) && !__ovflow) &&

          (__is_group == 0 ||

           __valid_grouping(__group_sizes, __group_sizes_end,

                            __grouping.data(), __grouping.data()+ __grouping.size()));

}

template <class _InputIter, class _Integer, class _CharT>

bool _STLP_CALL

__get_integer(_InputIter& __first, _InputIter& __last,

              int __base, _Integer& __val,

              int __got, bool __is_negative, _CharT __separator, const string& __grouping, const __false_type& /*_IsSigned*/) {

  bool __ovflow = false;

  _Integer __result = 0;

  bool __is_group = !__grouping.empty();

  char __group_sizes[64];

  char __current_group_size = 0;

  char* __group_sizes_end = __group_sizes;

  _Integer  __over_base = (numeric_limits<_Integer>::max)() / __STATIC_CAST(_Integer, __base);

  for ( ; __first != __last ; ++__first) {

    const _CharT __c = *__first;

    if (__is_group && __c == __separator) {

      *__group_sizes_end++ = __current_group_size;

      __current_group_size = 0;

      continue;

    }

    int __n = __get_digit_from_table(__c);

    if (__n >= __base)

      break;

    ++__got;

    ++__current_group_size;

    if (__result > __over_base)

      __ovflow = true;  //don't need to keep accumulating

    else {

      _Integer __next = __STATIC_CAST(_Integer, __base * __result + __n);

      if (__result != 0)

        __ovflow = __ovflow || __next <= __result;

        __result = __next;

      }

  }

  if (__is_group && __group_sizes_end != __group_sizes) {

      *__group_sizes_end++ = __current_group_size;

  }

  // fbp : added to not modify value if nothing was read

  if (__got > 0) {

      __val = __ovflow ? (numeric_limits<_Integer>::max)()

                       : (__is_negative ? __STATIC_CAST(_Integer, -__result)

                                        : __result);

  }

  // overflow is being treated as failure

  return ((__got > 0) && !__ovflow) &&

          (__is_group == 0 ||

           __valid_grouping(__group_sizes, __group_sizes_end,

                            __grouping.data(), __grouping.data()+ __grouping.size()));

}

template <class _InputIter, class _Integer, class _CharT>

bool _STLP_CALL

__get_decimal_integer(_InputIter& __first, _InputIter& __last, _Integer& __val, _CharT* /*dummy*/) {

  string __grp;

  //Here there is no grouping so separator is not important, we just pass the default charater.

  return __get_integer(__first, __last, 10, __val, 0, false, _CharT() /*separator*/, __grp, __false_type());

}

template <class _InputIter, class _Integer, class _CharT>

_InputIter _STLP_CALL

__do_get_integer(_InputIter& __in_ite, _InputIter& __end, ios_base& __str,

                 ios_base::iostate& __err, _Integer& __val, _CharT* __pc) {

#if defined (__HP_aCC) && (__HP_aCC == 1)

  bool _IsSigned = !((_Integer)(-1) > 0);

#else

  typedef typename __bool2type<numeric_limits<_Integer>::is_signed>::_Ret _IsSigned;

#endif

  const numpunct<_CharT>& __numpunct = *__STATIC_CAST(const numpunct<_CharT>*, __str._M_numpunct_facet());

  const string& __grouping = __str._M_grouping(); // cached copy

  const int __base_or_zero = __get_base_or_zero(__in_ite, __end, __str, __pc);

  int  __got = __base_or_zero & 1;

  bool __result;

  if (__in_ite == __end) {      // We may have already read a 0.  If so,

    if (__got > 0) {       // the result is 0 even if we're at eof.

      __val = 0;

      __result = true;

    }

    else

      __result = false;

  }

  else {

    const bool __negative = (__base_or_zero & 2) != 0;

    const int __base = __base_or_zero >> 2;

#if defined (__HP_aCC) && (__HP_aCC == 1)

    if (_IsSigned)

      __result = __get_integer(__in_ite, __end, __base,  __val, __got, __negative, __numpunct.thousands_sep(), __grouping, __true_type() );

    else

      __result = __get_integer(__in_ite, __end, __base,  __val, __got, __negative, __numpunct.thousands_sep(), __grouping, __false_type() );

#else

    __result = __get_integer(__in_ite, __end, __base,  __val, __got, __negative, __numpunct.thousands_sep(), __grouping, _IsSigned());

# endif

  }

  __err = __STATIC_CAST(ios_base::iostate, __result ? ios_base::goodbit : ios_base::failbit);

  if (__in_ite == __end)

    __err |= ios_base::eofbit;

  return __in_ite;

}

// __read_float and its helper functions.

template <class _InputIter, class _CharT>

_InputIter  _STLP_CALL

__copy_sign(_InputIter __first, _InputIter __last, __iostring& __v,

            _CharT __xplus, _CharT __xminus) {

  if (__first != __last) {

    _CharT __c = *__first;

    if (__c == __xplus)

      ++__first;

    else if (__c == __xminus) {

      __v.push_back('-');

      ++__first;

    }

  }

  return __first;

}

template <class _InputIter, class _CharT>

bool _STLP_CALL

__copy_digits(_InputIter& __first, _InputIter __last,

              __iostring& __v, const _CharT* __digits) {

  bool __ok = false;

  for ( ; __first != __last; ++__first) {

    _CharT __c = *__first;

    if (__get_fdigit(__c, __digits)) {

      __v.push_back((char)__c);

      __ok = true;

    }

    else

      break;

  }

  return __ok;

}

template <class _InputIter, class _CharT>

bool _STLP_CALL

__copy_grouped_digits(_InputIter& __first, _InputIter __last,

                      __iostring& __v, const _CharT * __digits,

                      _CharT __sep, const string& __grouping,

                      bool& __grouping_ok) {

  bool __ok = false;

  char __group_sizes[64];

  char*__group_sizes_end = __group_sizes;

  char __current_group_size = 0;

  for ( ; __first != __last; ++__first) {

    _CharT __c = *__first;

    bool __tmp = __get_fdigit_or_sep(__c, __sep, __digits);

    if (__tmp) {

      if (__c == ',') {

        *__group_sizes_end++ = __current_group_size;

        __current_group_size = 0;

      }

      else {

        __ok = true;

        __v.push_back((char)__c);

        ++__current_group_size;

      }

    }

    else

      break;

  }

  if (__group_sizes_end != __group_sizes)

    *__group_sizes_end++ = __current_group_size;

  __grouping_ok = __valid_grouping(__group_sizes, __group_sizes_end, __grouping.data(), __grouping.data() + __grouping.size());

  return __ok;

}

template <class _InputIter, class _CharT>

bool _STLP_CALL

__read_float(__iostring& __buf, _InputIter& __in_ite, _InputIter& __end, ios_base& __s, _CharT*) {

  // Create a string, copying characters of the form

  // [+-]? [0-9]* .? [0-9]* ([eE] [+-]? [0-9]+)?

  bool __digits_before_dot /* = false */;

  bool __digits_after_dot = false;

  bool __ok;

  bool   __grouping_ok = true;

  const ctype<_CharT>& __ct = *__STATIC_CAST(const ctype<_CharT>*, __s._M_ctype_facet());

  const numpunct<_CharT>& __numpunct = *__STATIC_CAST(const numpunct<_CharT>*, __s._M_numpunct_facet());

  const string& __grouping = __s._M_grouping(); // cached copy

  _CharT __dot = __numpunct.decimal_point();

  _CharT __sep = __numpunct.thousands_sep();

  _CharT __digits[10];

  _CharT __xplus;

  _CharT __xminus;

  _CharT __pow_e;

  _CharT __pow_E;

  _Initialize_get_float(__ct, __xplus, __xminus, __pow_e, __pow_E, __digits);

  // Get an optional sign

  __in_ite = __copy_sign(__in_ite, __end, __buf, __xplus, __xminus);

  // Get an optional string of digits.

  if (!__grouping.empty())

    __digits_before_dot = __copy_grouped_digits(__in_ite, __end, __buf, __digits,

                                                __sep, __grouping, __grouping_ok);

  else

    __digits_before_dot = __copy_digits(__in_ite, __end, __buf, __digits);

  // Get an optional decimal point, and an optional string of digits.

  if (__in_ite != __end && *__in_ite == __dot) {

    __buf.push_back('.');

    ++__in_ite;

    __digits_after_dot = __copy_digits(__in_ite, __end, __buf, __digits);

  }

  // There have to be some digits, somewhere.

  __ok = __digits_before_dot || __digits_after_dot;

  // Get an optional exponent.

  if (__ok && __in_ite != __end && (*__in_ite == __pow_e || *__in_ite == __pow_E)) {

    __buf.push_back('e');

    ++__in_ite;

    __in_ite = __copy_sign(__in_ite, __end, __buf, __xplus, __xminus);

    __ok = __copy_digits(__in_ite, __end, __buf, __digits);

    // If we have an exponent then the sign

    // is optional but the digits aren't.

  }

  return __ok;

}

_STLP_MOVE_TO_STD_NAMESPACE

//

// num_get<>, num_put<>

//

#if ( _STLP_STATIC_TEMPLATE_DATA > 0 )

#  if !defined (__BORLANDC__)

template <class _CharT, class _InputIterator>

locale::id num_get<_CharT, _InputIterator>::id;

#  endif

#  if (defined (__CYGWIN__) || defined (__MINGW32__)) && \

       defined (_STLP_USE_DYNAMIC_LIB) && !defined (__BUILDING_STLPORT)

/*

 * Under cygwin, when STLport is used as a shared library, the id needs

 * to be specified as imported otherwise they will be duplicated in the

 * calling executable.

 */

template <>

_STLP_DECLSPEC locale::id num_get<char, istreambuf_iterator<char, char_traits<char> > >::id;

/*

template <>

_STLP_DECLSPEC locale::id num_get<char, const char*>::id;

*/

#    if !defined (STLP_NO_WCHAR_T)

template <>

_STLP_DECLSPEC locale::id num_get<wchar_t, istreambuf_iterator<wchar_t, char_traits<wchar_t> > >::id;

/*

template <>

_STLP_DECLSPEC locale::id num_get<wchar_t, const wchar_t*>::id;

*/

#    endif

#  endif /* __CYGWIN__ && _STLP_USE_DYNAMIC_LIB */

#else /* ( _STLP_STATIC_TEMPLATE_DATA > 0 ) */

//typedef num_get<char, const char*> num_get_char;

typedef num_get<char, istreambuf_iterator<char, char_traits<char> > > num_get_char_2;

//__DECLARE_INSTANCE(locale::id, num_get_char::id, );

__DECLARE_INSTANCE(locale::id, num_get_char_2::id, );

#  if !defined (_STLP_NO_WCHAR_T)

//typedef num_get<wchar_t, const wchar_t*> num_get_wchar_t;

typedef num_get<wchar_t, istreambuf_iterator<wchar_t, char_traits<wchar_t> > > num_get_wchar_t_2;

//__DECLARE_INSTANCE(locale::id, num_get_wchar_t::id, );

__DECLARE_INSTANCE(locale::id, num_get_wchar_t_2::id, );

#  endif

#endif /* ( _STLP_STATIC_TEMPLATE_DATA > 0 ) */

#if !defined (_STLP_NO_BOOL)

template <class _CharT, class _InputIter>

_InputIter

num_get<_CharT, _InputIter>::do_get(_InputIter __in_ite, _InputIter __end,

                                    ios_base& __s,

                                    ios_base::iostate& __err, bool& __x) const {

  if (__s.flags() & ios_base::boolalpha) {

    locale __loc = __s.getloc();

    const _Numpunct& __np = *__STATIC_CAST(const _Numpunct*, __s._M_numpunct_facet());

    //    const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc) ;

//    const ctype<_CharT>& __ct =    use_facet<ctype<_CharT> >(__loc) ;

    const basic_string<_CharT> __truename  = __np.truename();

    const basic_string<_CharT> __falsename = __np.falsename();

    bool __true_ok  = true;

    bool __false_ok = true;

    size_t __n = 0;

    for ( ; __in_ite != __end; ++__in_ite) {

      _CharT __c = *__in_ite;

      __true_ok  = __true_ok  && (__c == __truename[__n]);

      __false_ok = __false_ok && (__c == __falsename[__n]);

      ++__n;

      if ((!__true_ok && !__false_ok) ||

          (__true_ok  && __n >= __truename.size()) ||

          (__false_ok && __n >= __falsename.size())) {

        ++__in_ite;

        break;

      }

    }

    if (__true_ok  && __n < __truename.size())  __true_ok  = false;

    if (__false_ok && __n < __falsename.size()) __false_ok = false;

    if (__true_ok || __false_ok) {

      __err = ios_base::goodbit;

      __x = __true_ok;

    }

    else

      __err = ios_base::failbit;

    if (__in_ite == __end)

      __err |= ios_base::eofbit;

    return __in_ite;

  }

  else {

    long __lx;

    _InputIter __tmp = this->do_get(__in_ite, __end, __s, __err, __lx);

    if (!(__err & ios_base::failbit)) {

      if (__lx == 0)

        __x = false;

      else if (__lx == 1)

        __x = true;

      else

        __err |= ios_base::failbit;

    }

    return __tmp;

  }

}

#endif /* _STLP_NO_BOOL */

#if defined (_STLP_FIX_LIBRARY_ISSUES)

template <class _CharT, class _InputIter>

_InputIter

num_get<_CharT, _InputIter>::do_get(_InputIter __in_ite, _InputIter __end, ios_base& __str,

                                    ios_base::iostate& __err, short& __val) const

{ return _STLP_PRIV __do_get_integer(__in_ite, __end, __str, __err, __val, (_CharT*)0 ); }

template <class _CharT, class _InputIter>

_InputIter

num_get<_CharT, _InputIter>::do_get(_InputIter __in_ite, _InputIter __end, ios_base& __str,

                                    ios_base::iostate& __err, int& __val) const

{ return _STLP_PRIV __do_get_integer(__in_ite, __end, __str, __err, __val, (_CharT*)0 ); }

#endif

template <class _CharT, class _InputIter>

_InputIter

num_get<_CharT, _InputIter>::do_get(_InputIter __in_ite, _InputIter __end, ios_base& __str,

                                    ios_base::iostate& __err, long& __val) const

{ return _STLP_PRIV __do_get_integer(__in_ite, __end, __str, __err, __val, (_CharT*)0 ); }

template <class _CharT, class _InputIter>

_InputIter

num_get<_CharT, _InputIter>::do_get(_InputIter __in_ite, _InputIter __end, ios_base& __str,

                                    ios_base::iostate& __err,

                                    unsigned short& __val) const

{ return _STLP_PRIV __do_get_integer(__in_ite, __end, __str, __err, __val, (_CharT*)0 ); }

template <class _CharT, class _InputIter>

_InputIter

num_get<_CharT, _InputIter>::do_get(_InputIter __in_ite, _InputIter __end, ios_base& __str,

                                    ios_base::iostate& __err,

                                    unsigned int& __val) const

{ return _STLP_PRIV __do_get_integer(__in_ite, __end, __str, __err, __val, (_CharT*)0 ); }

template <class _CharT, class _InputIter>

_InputIter

num_get<_CharT, _InputIter>::do_get(_InputIter __in_ite, _InputIter __end, ios_base& __str,

                                    ios_base::iostate& __err,

                                    unsigned long& __val) const

{ return _STLP_PRIV __do_get_integer(__in_ite, __end, __str, __err, __val, (_CharT*)0 ); }

template <class _CharT, class _InputIter>

_InputIter

num_get<_CharT, _InputIter>::do_get(_InputIter __in_ite, _InputIter __end, ios_base& __str,

                                    ios_base::iostate& __err,

                                    float& __val) const {

  _STLP_PRIV __iostring __buf ;

  bool __ok = _STLP_PRIV __read_float(__buf, __in_ite, __end, __str, (_CharT*)0 );

  _STLP_PRIV __string_to_float(__buf, __val);

  __err = __STATIC_CAST(ios_base::iostate, __ok ? ios_base::goodbit : ios_base::failbit);

  if (__in_ite == __end)

    __err |= ios_base::eofbit;

  return __in_ite;

}

template <class _CharT, class _InputIter>

_InputIter

num_get<_CharT, _InputIter>::do_get(_InputIter __in_ite, _InputIter __end, ios_base& __str,

                                    ios_base::iostate& __err,

                                    double& __val) const {

  _STLP_PRIV __iostring __buf ;

  bool __ok = _STLP_PRIV __read_float(__buf, __in_ite, __end, __str, (_CharT*)0 );

  _STLP_PRIV __string_to_float(__buf, __val);

  __err = __STATIC_CAST(ios_base::iostate, __ok ? ios_base::goodbit : ios_base::failbit);

  if (__in_ite == __end)

    __err |= ios_base::eofbit;

  return __in_ite;

}

#if !defined (_STLP_NO_LONG_DOUBLE)

template <class _CharT, class _InputIter>

_InputIter

num_get<_CharT, _InputIter>::do_get(_InputIter __in_ite, _InputIter __end, ios_base& __str,

                                    ios_base::iostate& __err,

                                    long double& __val) const {

  _STLP_PRIV __iostring __buf ;

  bool __ok = _STLP_PRIV __read_float(__buf, __in_ite, __end, __str, (_CharT*)0 );

  _STLP_PRIV __string_to_float(__buf, __val);

  __err = __STATIC_CAST(ios_base::iostate, __ok ? ios_base::goodbit : ios_base::failbit);

  if (__in_ite == __end)

    __err |= ios_base::eofbit;

  return __in_ite;

}

#endif /* _STLP_NO_LONG_DOUBLE */

template <class _CharT, class _InputIter>

_InputIter

num_get<_CharT, _InputIter>::do_get(_InputIter __in_ite, _InputIter __end, ios_base& __str,

                           ios_base::iostate& __err,

                           void*& __p) const {

#if defined (_STLP_LONG_LONG) && !defined (__MRC__)    //*ty 12/07/2001 - MrCpp can not cast from long long to void*

  unsigned _STLP_LONG_LONG __val;

#else

  unsigned long __val;

#endif

    iter_type __tmp = _STLP_PRIV __do_get_integer(__in_ite, __end, __str, __err, __val, (_CharT*)0 );

    if (!(__err & ios_base::failbit))

      __p = __REINTERPRET_CAST(void*,__val);

    return __tmp;

  }

#if defined (_STLP_LONG_LONG)

template <class _CharT, class _InputIter>

_InputIter

num_get<_CharT, _InputIter>::do_get(_InputIter __in_ite, _InputIter __end, ios_base& __str,

                                    ios_base::iostate& __err,

                                    _STLP_LONG_LONG& __val) const {

  return _STLP_PRIV __do_get_integer(__in_ite, __end, __str, __err, __val, (_CharT*)0 );

}

template <class _CharT, class _InputIter>

_InputIter

num_get<_CharT, _InputIter>::do_get(_InputIter __in_ite, _InputIter __end, ios_base& __str,

                                    ios_base::iostate& __err,

                                    unsigned _STLP_LONG_LONG& __val) const {

  return _STLP_PRIV __do_get_integer(__in_ite, __end, __str, __err, __val, (_CharT*)0 );

}

#endif /* _STLP_LONG_LONG */

_STLP_END_NAMESPACE

#endif /* _STLP_NUMERIC_FACETS_C */

// Local Variables:

// mode:C++

// End: