_num_get.c File Reference

#include <stl/_num_get.h>
#include <stl/_limits.h>

Include dependency graph for _num_get.c:

Go to the source code of this file.

Macros
#define	_STLP_NUM_GET_C

Functions
_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 ()
bool _STLP_CALL	__get_fdigit (char __c, const char *)
bool _STLP_CALL	__get_fdigit_or_sep (char &__c, char __sep, const char *__digits)
int _STLP_CALL	__get_digit_from_table (unsigned __index)
template<class _InputIter , class _CharT >
int	__get_base_or_zero (_InputIter &__in_ite, _InputIter &__end, ios_base::fmtflags __flags, const ctype< _CharT > &__c_type)
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 &)
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 &)
template<class _InputIter , class _Integer , class _CharT >
bool _STLP_CALL	__get_decimal_integer (_InputIter &__first, _InputIter &__last, _Integer &__val, _CharT *)
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 *)
template<class _InputIter , class _CharT >
_InputIter _STLP_CALL	__copy_sign (_InputIter __first, _InputIter __last, __iostring &__v, _CharT __xplus, _CharT __xminus)
template<class _InputIter , class _CharT >
bool _STLP_CALL	__copy_digits (_InputIter &__first, _InputIter __last, __iostring &__v, const _CharT *__digits)
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)
template<class _InputIter , class _CharT >
bool _STLP_CALL	__read_float (__iostring &__buf, _InputIter &__in_ite, _InputIter &__end, const ctype< _CharT > &__ct, const numpunct< _CharT > &__numpunct)
template<class _InputIter , class _Float , class _CharT >
_InputIter _STLP_CALL	__do_get_float (_InputIter &__in_ite, _InputIter &__end, ios_base &__str, ios_base::iostate &__err, _Float &__val, _CharT *)
template<class _InputIter , class _CharT >
_InputIter _STLP_CALL	__do_get_alphabool (_InputIter &__in_ite, _InputIter &__end, ios_base &__str, ios_base::iostate &__err, bool &__x, _CharT *)

Macro Definition Documentation

_STLP_NUM_GET_C

#define _STLP_NUM_GET_C

Definition at line 19 of file _num_get.c.

Function Documentation

__copy_digits()

template<class _InputIter , class _CharT >

bool _STLP_CALL __copy_digits	(	_InputIter &	__first,
		_InputIter	__last,
		__iostring &	__v,
		const _CharT *	__digits
	)

Definition at line 314 of file _num_get.c.

                                                       {
  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;
}

Referenced by __read_float().

__copy_grouped_digits()

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
	)

Definition at line 332 of file _num_get.c.

                                           {
  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;
}

Referenced by __read_float().

__copy_sign()

template<class _InputIter , class _CharT >

_InputIter _STLP_CALL __copy_sign	(	_InputIter	__first,
		_InputIter	__last,
		__iostring &	__v,
		_CharT	__xplus,
		_CharT	__xminus
	)

Definition at line 297 of file _num_get.c.

                                             {
  if (__first != __last) {
    _CharT __c = *__first;
    if (__c == __xplus)
      ++__first;
    else if (__c == __xminus) {
      __v.push_back('-');
      ++__first;
    }
  }
  return __first;
}

Referenced by __read_float().

__digit_val_table()

_STLP_BEGIN_NAMESPACE _STLP_MOVE_TO_PRIV_NAMESPACE _STLP_DECLSPEC unsigned char _STLP_CALL __digit_val_table

(

unsigned

__index

)

Definition at line 54 of file num_get.cpp.

                                                                            {
  static const unsigned char __val_table[128] = {
    0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
    0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
    0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
    0, 1, 2, 3, 4, 5, 6, 7, 8, 9,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
    0xFF,10,11,12,13,14,15,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
    0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
    0xFF,10,11,12,13,14,15,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
    0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF
  };
 
  return __val_table[__index];
}

Referenced by __get_digit_from_table().

__do_get_alphabool()

template<class _InputIter , class _CharT >

_InputIter _STLP_CALL __do_get_alphabool	(	_InputIter &	__in_ite,
		_InputIter &	__end,
		ios_base &	__str,
		ios_base::iostate &	__err,
		bool &	__x,
		_CharT *
	)

Definition at line 449 of file _num_get.c.

                                                                 {
  const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__str.getloc());
  const basic_string<_CharT, char_traits<_CharT>, allocator<_CharT> > __truename  = __np.truename();
  const basic_string<_CharT, char_traits<_CharT>, allocator<_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;
}

Referenced by num_get< _CharT, _InputIter >::do_get().

__do_get_float()

template<class _InputIter , class _Float , class _CharT >

_InputIter _STLP_CALL __do_get_float	(	_InputIter &	__in_ite,
		_InputIter &	__end,
		ios_base &	__str,
		ios_base::iostate &	__err,
		_Float &	__val,
		_CharT *
	)

Definition at line 427 of file _num_get.c.

                                                                 {
  locale __loc = __str.getloc();
  const ctype<_CharT> &__ctype = use_facet<ctype<_CharT> >(__loc);
  const numpunct<_CharT> &__numpunct = use_facet<numpunct<_CharT> >(__loc);
 
  __iostring __buf ;
  bool __ok = __read_float(__buf, __in_ite, __end, __ctype, __numpunct);
  if (__ok) {
    __string_to_float(__buf, __val);
    __err = ios_base::goodbit;
  }
  else {
    __err = ios_base::failbit;
  }
  if (__in_ite == __end)
    __err |= ios_base::eofbit;
  return __in_ite;
}

Referenced by num_get< _CharT, _InputIter >::do_get().

__do_get_integer()

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 *
	)

Definition at line 247 of file _num_get.c.

                                                                     {
  locale __loc = __str.getloc();
  const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
 
#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 int __base_or_zero = __get_base_or_zero(__in_ite, __end, __str.flags(), __ctype);
  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 numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc);
    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, __np.thousands_sep(), __np.grouping(), __true_type() );
    else
      __result = __get_integer(__in_ite, __end, __base,  __val, __got, __negative, __np.thousands_sep(), __np.grouping(), __false_type() );
#else
    __result = __get_integer(__in_ite, __end, __base,  __val, __got, __negative, __np.thousands_sep(), __np.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;
}

Referenced by num_get< _CharT, _InputIter >::do_get().

__get_base_or_zero()

template<class _InputIter , class _CharT >

int __get_base_or_zero	(	_InputIter &	__in_ite,
		_InputIter &	__end,
		ios_base::fmtflags	__flags,
		const ctype< _CharT > &	__c_type
	)

Definition at line 56 of file _num_get.c.

                                                                            {
  _CharT __atoms[5];
  __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 = __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;
}

Referenced by __do_get_integer().

__get_decimal_integer()

template<class _InputIter , class _Integer , class _CharT >

bool _STLP_CALL __get_decimal_integer	(	_InputIter &	__first,
		_InputIter &	__last,
		_Integer &	__val,
		_CharT *
	)

Definition at line 239 of file _num_get.c.

                                                                                           {
  string __grp;
  //Here there is no grouping so separator is not important, we just pass the default character.
  return __get_integer(__first, __last, 10, __val, 0, false, _CharT() /*separator*/, __grp, __false_type());
}

Referenced by money_get< _CharT, _InputIter >::do_get(), and time_get< _Ch, _InIt >::do_get_year().

__get_digit_from_table()

int _STLP_CALL __get_digit_from_table ( unsigned  __index )

inline

Definition at line 51 of file _num_get.c.

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

Referenced by __get_integer().

__get_fdigit()

bool _STLP_CALL __get_fdigit ( char  __c, const char *    )

inline

Definition at line 38 of file _num_get.c.

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

Referenced by __copy_digits(), and __get_fdigit_or_sep().

__get_fdigit_or_sep()

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

inline

Definition at line 41 of file _num_get.c.

                                                                                        {
  if (__c == __sep) {
    __c = ',' ;
    return true ;
  }
  else
    return  __get_fdigit(__c, __digits);
}

Referenced by __copy_grouped_digits().

__get_integer() [1/2]

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 &
	)

Definition at line 178 of file _num_get.c.

                                                                                                                  {
  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()));
}

__get_integer() [2/2]

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 &
	)

Definition at line 118 of file _num_get.c.

                                                                                                                 {
  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()));
}

Referenced by __do_get_integer(), and __get_decimal_integer().

__narrow_atoms()

_STLP_DECLSPEC const char *_STLP_CALL __narrow_atoms

(

)

Definition at line 69 of file num_get.cpp.

{ return "+-0xX"; }

Referenced by __get_base_or_zero().

__read_float()

template<class _InputIter , class _CharT >

bool _STLP_CALL __read_float	(	__iostring &	__buf,
		_InputIter &	__in_ite,
		_InputIter &	__end,
		const ctype< _CharT > &	__ct,
		const numpunct< _CharT > &	__numpunct
	)

Definition at line 368 of file _num_get.c.

                                                                            {
  // Create a string, copying characters of the form
  // [+-]? [0-9]* .? [0-9]* ([eE] [+-]? [0-9]+)?
 
  string __grouping = __numpunct.grouping();
  bool __digits_before_dot /* = false */;
  bool __digits_after_dot = false;
  bool __ok;
 
  bool   __grouping_ok = true;
 
  _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;
}

Referenced by __do_get_float().