home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / stlpt453.zip / STLport-4.5.3 / stlport / stl / _num_get.c < prev    next >
C/C++ Source or Header  |  2002-02-02  |  20KB  |  670 lines
  1. /*
  2.  * Copyright (c) 1999
  3.  * Silicon Graphics Computer Systems, Inc.
  4.  *
  5.  * Copyright (c) 1999 
  6.  * Boris Fomitchev
  7.  *
  8.  * This material is provided "as is", with absolutely no warranty expressed
  9.  * or implied. Any use is at your own risk.
  10.  *
  11.  * Permission to use or copy this software for any purpose is hereby granted 
  12.  * without fee, provided the above notices are retained on all copies.
  13.  * Permission to modify the code and to distribute modified code is granted,
  14.  * provided the above notices are retained, and a notice that the code was
  15.  * modified is included with the above copyright notice.
  16.  *
  17.  */ 
  18. #ifndef _STLP_NUM_GET_C
  19. #define _STLP_NUM_GET_C
  20.  
  21. #ifndef _STLP_INTERNAL_NUM_GET_H
  22. # include <stl/_num_get.h>
  23. #endif
  24.  
  25. # if defined (_STLP_EXPOSE_STREAM_IMPLEMENTATION)
  26.  
  27. #ifndef _STLP_LIMITS_H
  28. # include <stl/_limits.h>
  29. #endif
  30.  
  31. _STLP_BEGIN_NAMESPACE
  32.  
  33. extern const unsigned char __digit_val_table[];
  34.  
  35. template < class _InputIter, class _Integer, class _CharT>
  36. _InputIter _STLP_CALL
  37. _M_do_get_integer(_InputIter&, _InputIter&, ios_base&, ios_base::iostate&, _Integer&, _CharT*);
  38.  
  39. // _M_do_get_integer and its helper functions.  
  40.  
  41. inline bool _STLP_CALL __get_fdigit(char& __c, const char*)
  42.   { return __c >= '0' && __c <= '9'; }
  43.  
  44. inline bool _STLP_CALL __get_fdigit_or_sep(char& __c, char __sep, const char *)
  45. { 
  46.   if (__c == __sep) { 
  47.     __c = ',' ; 
  48.     return true ;
  49.   } else
  50.     return  ( __c >= '0' && __c <= '9');
  51. }
  52.  
  53. inline int _STLP_CALL
  54. __get_digit_from_table(unsigned __index)
  55. {
  56.   return (__index > 127 ? 0xFF : __digit_val_table[__index]);
  57. }
  58.  
  59. extern const char __narrow_atoms[];
  60.  
  61. template <class _InputIter, class _CharT>
  62. int 
  63. _M_get_base_or_zero(_InputIter& __in, _InputIter& __end, ios_base& __str, _CharT*)
  64. {
  65.   _CharT __atoms[5];
  66.   const ctype<_CharT>& __c_type = *(const ctype<_CharT>*)__str._M_ctype_facet();
  67.  
  68.   __c_type.widen(__narrow_atoms, __narrow_atoms + 5, __atoms);
  69.  
  70.   bool __negative = false;
  71.   _CharT __c = *__in;
  72.  
  73.   if (__c == __atoms[1] /* __xminus_char */ ) {
  74.     __negative = true;
  75.     ++__in;
  76.   }
  77.   else if (__c == __atoms[0] /* __xplus_char */ ) 
  78.     ++__in;
  79.  
  80.  
  81.   int __base;
  82.   int __valid_zero = 0;
  83.   
  84.   ios_base::fmtflags __basefield = __str.flags() & ios_base::basefield; 
  85.  
  86.   switch (__basefield) {
  87.   case ios_base::oct:
  88.     __base = 8;
  89.     break;
  90.   case ios_base::dec:
  91.     __base = 10;
  92.     break;
  93.   case ios_base::hex:
  94.     __base = 16;
  95.     if (__in != __end && *__in == __atoms[2] /* __zero_char */ ) {
  96.       ++__in;
  97.       if (__in != __end &&
  98.           (*__in == __atoms[3] /* __x_char */ || *__in == __atoms[4] /* __X_char */ ))
  99.         ++__in;
  100.       else
  101.         __valid_zero = 1; // That zero is valid by itself.
  102.     }
  103.     break;
  104.   default:
  105.     if (__in != __end && *__in == __atoms[2] /* __zero_char */ ) {
  106.       ++__in;
  107.       if (__in != __end &&
  108.           (*__in == __atoms[3] /* __x_char */ || *__in == __atoms[4] /* __X_char */ )) {
  109.         ++__in;
  110.         __base = 16;
  111.       }
  112.       else
  113.         {
  114.           __base = 8;
  115.           __valid_zero = 1; // That zero is still valid by itself.
  116.         }
  117.     }
  118.     else
  119.       __base = 10;
  120.     break;
  121.   }
  122.   return (__base << 2) | ((int)__negative << 1) | __valid_zero;
  123. }
  124.  
  125.  
  126. template <class _InputIter, class _Integer>
  127. bool _STLP_CALL
  128. __get_integer(_InputIter& __first, _InputIter& __last,
  129.           int __base, _Integer& __val, 
  130.           int __got, bool __is_negative, char __separator, const string& __grouping, const __true_type&) 
  131. {
  132.   bool __ovflow = false;
  133.   _Integer __result = 0;
  134.   bool __is_group = !__grouping.empty();
  135.   char __group_sizes[64];
  136.   int __current_group_size = 0;
  137.   char* __group_sizes_end = __group_sizes;
  138.   
  139.   _Integer __over_base = (numeric_limits<_Integer>::min)() / __STATIC_CAST(_Integer, __base);
  140.  
  141.    for ( ; __first != __last ; ++__first) {
  142.   
  143.      const char __c = *__first;
  144.      
  145.      if (__is_group && __c == __separator) {
  146.        *__group_sizes_end++ = __current_group_size;
  147.        __current_group_size = 0;
  148.        continue;
  149.      }
  150.      
  151.      int __n = __get_digit_from_table(__c);
  152.      
  153.      if (__n >= __base)
  154.        break;
  155.      
  156.      ++__got;
  157.      ++__current_group_size;
  158.      
  159.      if (__result < __over_base)
  160.        __ovflow = true;  // don't need to keep accumulating
  161.      else {
  162.        _Integer __next = __STATIC_CAST(_Integer, __base * __result - __n);
  163.        if (__result != 0)
  164.      __ovflow = __ovflow || __next >= __result;
  165.        __result = __next;
  166.      }
  167.    }
  168.  
  169.    if (__is_group && __group_sizes_end != __group_sizes) {
  170.      *__group_sizes_end++ = __current_group_size;
  171.    }
  172.  
  173.    // fbp : added to not modify value if nothing was read
  174.    if (__got > 0) {
  175.        __val = __ovflow
  176.      ? __is_negative ? (numeric_limits<_Integer>::min)()
  177.      : (numeric_limits<_Integer>::max)()
  178.      : (__is_negative ? __result : __STATIC_CAST(_Integer, -__result));
  179.    }
  180.   // overflow is being treated as failure
  181.   return ((__got > 0) && !__ovflow) && (__is_group == 0 || __valid_grouping(__group_sizes, __group_sizes_end,
  182.                                         __grouping.data(), __grouping.data()+ __grouping.size())) ;
  183. }
  184.  
  185. template <class _InputIter, class _Integer>
  186. bool _STLP_CALL
  187. __get_integer(_InputIter& __first, _InputIter& __last,
  188.           int __base, _Integer& __val, 
  189.           int __got, bool __is_negative, char __separator, const string& __grouping, const __false_type&) 
  190. {
  191.   bool __ovflow = false;
  192.   _Integer __result = 0;
  193.   bool __is_group = !__grouping.empty();
  194.   char __group_sizes[64];
  195.   int __current_group_size = 0;
  196.   char* __group_sizes_end = __group_sizes;
  197.  
  198.   _Integer  __over_base = (numeric_limits<_Integer>::max)() / __STATIC_CAST(_Integer, __base);
  199.  
  200.   for ( ; __first != __last ; ++__first) {
  201.  
  202.     const char __c = *__first;
  203.     
  204.     if (__is_group && __c == __separator) {
  205.       *__group_sizes_end++ = __current_group_size;
  206.       __current_group_size = 0;
  207.       continue;
  208.     }
  209.     
  210.     int __n = __get_digit_from_table(__c);
  211.     
  212.     if (__n >= __base)
  213.       break;
  214.     
  215.     ++__got;
  216.     ++__current_group_size;
  217.  
  218.     if (__result > __over_base)
  219.       __ovflow = true;  //don't need to keep accumulating
  220.     else {
  221.       _Integer __next = __STATIC_CAST(_Integer, __base * __result + __n);
  222.     if (__result != 0)
  223.       __ovflow = __ovflow || __next <= __result;
  224.     __result = __next;
  225.       }      
  226.   }
  227.  
  228.   if (__is_group && __group_sizes_end != __group_sizes) {
  229.       *__group_sizes_end++ = __current_group_size;
  230.   }
  231.  
  232.   // fbp : added to not modify value if nothing was read
  233.   if (__got > 0) {
  234.       __val = __ovflow
  235.     ? (numeric_limits<_Integer>::max)()
  236.     : (__is_negative ? __STATIC_CAST(_Integer, -__result) : __result);      
  237.   }
  238.   // overflow is being treated as failure
  239.   return ((__got > 0) && !__ovflow) && 
  240.     (__is_group == 0 || __valid_grouping(__group_sizes, __group_sizes_end,
  241.                      __grouping.data(), __grouping.data()+ __grouping.size())) ;
  242. }
  243.  
  244.  
  245. template <class _InputIter, class _Integer>
  246. bool _STLP_CALL
  247. __get_decimal_integer(_InputIter& __first, _InputIter& __last, _Integer& __val)
  248. {
  249.   string __grp;
  250.   return __get_integer(__first, __last, 10, __val, 0, false, ' ', __grp, __false_type());
  251. }
  252.  
  253. template <class _InputIter, class _Integer, class _CharT>
  254. _InputIter _STLP_CALL
  255. _M_do_get_integer(_InputIter& __in, _InputIter& __end, ios_base& __str,
  256.                   ios_base::iostate& __err, _Integer& __val, _CharT* __pc) 
  257. {
  258.  
  259. #if defined(__HP_aCC) && (__HP_aCC == 1)
  260.   bool _IsSigned = !((_Integer)(-1) > 0);
  261. #else
  262.   typedef typename __bool2type<numeric_limits<_Integer>::is_signed>::_Ret _IsSigned;
  263. #endif
  264.  
  265.   const numpunct<_CharT>& __numpunct = *(const numpunct<_CharT>*)__str._M_numpunct_facet();
  266.   const string& __grouping = __str._M_grouping(); // cached copy
  267.  
  268.   const int __base_or_zero = _M_get_base_or_zero(__in, __end, __str, __pc);
  269.   int  __got = __base_or_zero & 1;
  270.  
  271.   bool __result;
  272.  
  273.   if (__in == __end) {      // We may have already read a 0.  If so,
  274.  
  275.     if (__got > 0) {       // the result is 0 even if we're at eof.
  276.       __val = 0;
  277.       __result = true;
  278.     }
  279.     else
  280.       __result = false;    
  281.   } else {
  282.  
  283.     const bool __negative = __base_or_zero & 2;
  284.     const int __base = __base_or_zero >> 2;
  285.  
  286. #if defined(__HP_aCC) && (__HP_aCC == 1)
  287.      if (_IsSigned)
  288.        __result = __get_integer(__in, __end, __base,  __val, __got, __negative, __numpunct.thousands_sep(), __grouping, __true_type() );
  289.      else
  290.       __result = __get_integer(__in, __end, __base,  __val, __got, __negative, __numpunct.thousands_sep(), __grouping, __false_type() );
  291. #else
  292.     __result = __get_integer(__in, __end, __base,  __val, __got, __negative, __numpunct.thousands_sep(), __grouping, _IsSigned());
  293. # endif
  294.   }
  295.  
  296.   __err = __STATIC_CAST(ios_base::iostate, __result ? ios_base::goodbit : ios_base::failbit);
  297.  
  298.   if (__in == __end)
  299.     __err |= ios_base::eofbit;
  300.   return __in;
  301. }
  302.  
  303. // _M_read_float and its helper functions.
  304. template <class _InputIter, class _CharT>
  305. _InputIter  _STLP_CALL
  306. __copy_sign(_InputIter __first, _InputIter __last, string& __v,
  307.             _CharT __xplus, _CharT __xminus) {
  308.     if (__first != __last) {
  309.     _CharT __c = *__first;
  310.     if (__c == __xplus)
  311.       ++__first;
  312.     else if (__c == __xminus) {
  313.       __v.push_back('-');
  314.       ++__first;
  315.     }
  316.   }
  317.   return __first;
  318. }
  319.  
  320.  
  321. template <class _InputIter, class _CharT>
  322. bool _STLP_CALL
  323. __copy_digits(_InputIter& __first, _InputIter& __last,
  324.               string& __v, const _CharT* __digits)
  325. {
  326.   bool __ok = false;
  327.  
  328.   for ( ; __first != __last; ++__first) {
  329.     _CharT __c = *__first;
  330.     if (__get_fdigit(__c, __digits)) {
  331.       __v.push_back((char)__c);
  332.       __ok = true;
  333.     }
  334.     else
  335.       break;
  336.   }
  337.   return __ok;
  338. }
  339.  
  340. template <class _InputIter, class _CharT>
  341. bool _STLP_CALL
  342. __copy_grouped_digits(_InputIter& __first, _InputIter& __last,
  343.               string& __v, const _CharT * __digits,
  344.               _CharT __sep, const string& __grouping,
  345.               bool& __grouping_ok)
  346. {
  347.   bool __ok = false;
  348.   char __group_sizes[64];
  349.   char*__group_sizes_end = __group_sizes;
  350.   char __current_group_size = 0;
  351.  
  352.   for ( ; __first != __last; ++__first) {
  353.     _CharT __c = *__first;
  354.     bool __tmp = __get_fdigit_or_sep(__c, __sep, __digits);
  355.     if (__tmp) {
  356.       if (__c == ',') {
  357.         *__group_sizes_end++ = __current_group_size;
  358.         __current_group_size = 0;
  359.       }
  360.       else {
  361.         __ok = true;
  362.         __v.push_back((char)__c);
  363.         ++__current_group_size;
  364.       }
  365.     }
  366.     else
  367.       break;
  368.   }
  369.   
  370.   if (__group_sizes_end != __group_sizes)
  371.     *__group_sizes_end++ = __current_group_size;
  372.   __grouping_ok = __valid_grouping(__group_sizes, __group_sizes_end, __grouping.data(), __grouping.data() + __grouping.size());
  373.   return __ok;    
  374. }
  375.  
  376.  
  377. template <class _InputIter, class _CharT>
  378. bool _STLP_CALL
  379. _M_read_float(string& __buf, _InputIter& __in, _InputIter& __end, ios_base& __s, _CharT*)
  380. {
  381.   // Create a string, copying characters of the form 
  382.   // [+-]? [0-9]* .? [0-9]* ([eE] [+-]? [0-9]+)?
  383.  
  384.   bool __digits_before_dot /* = false */;
  385.   bool __digits_after_dot = false;
  386.   bool __ok;
  387.  
  388.   bool   __grouping_ok = true;
  389.  
  390.   const ctype<_CharT>& __ct = *(const ctype<_CharT>*)__s._M_ctype_facet();
  391.   const numpunct<_CharT>& __numpunct = *(const numpunct<_CharT>*)__s._M_numpunct_facet();
  392.   const string& __grouping = __s._M_grouping(); // cached copy
  393.  
  394.   _CharT __dot = __numpunct.decimal_point();
  395.   _CharT __sep = __numpunct.thousands_sep();
  396.  
  397.   _CharT __digits[10];
  398.   _CharT __xplus;
  399.   _CharT __xminus;
  400.  
  401.   _CharT __pow_e;
  402.   _CharT __pow_E;
  403.  
  404.   _Initialize_get_float(__ct, __xplus, __xminus, __pow_e, __pow_E, __digits);
  405.  
  406.   // Get an optional sign
  407.   __in = __copy_sign(__in, __end, __buf, __xplus, __xminus);
  408.  
  409.   // Get an optional string of digits.
  410.   if (__grouping.size() != 0)
  411.     __digits_before_dot = __copy_grouped_digits(__in, __end, __buf, __digits,
  412.                         __sep, __grouping, __grouping_ok);
  413.   else
  414.     __digits_before_dot = __copy_digits(__in, __end, __buf, __digits);
  415.  
  416.   // Get an optional decimal point, and an optional string of digits.
  417.   if (__in != __end && *__in == __dot) {
  418.     __buf.push_back('.');
  419.     ++__in;
  420.     __digits_after_dot = __copy_digits(__in, __end, __buf, __digits);
  421.   }
  422.  
  423.   // There have to be some digits, somewhere.
  424.   __ok = __digits_before_dot || __digits_after_dot;
  425.   
  426.   // Get an optional exponent.
  427.   if (__ok && __in != __end && (*__in == __pow_e || *__in == __pow_E)) {
  428.     __buf.push_back('e');
  429.     ++__in;
  430.     __in = __copy_sign(__in, __end, __buf, __xplus, __xminus);
  431.     __ok = __copy_digits(__in, __end, __buf, __digits);
  432.     // If we have an exponent then the sign 
  433.     // is optional but the digits aren't.
  434.   }
  435.   
  436.   return __ok;
  437. }
  438.  
  439. //
  440. // num_get<>, num_put<>
  441. //
  442.  
  443. # if ( _STLP_STATIC_TEMPLATE_DATA > 0 ) 
  444. template <class _CharT, class _InputIterator>
  445. locale::id num_get<_CharT, _InputIterator>::id;
  446. # else
  447.  
  448. typedef num_get<char, const char*> num_get_char;
  449. typedef num_get<char, istreambuf_iterator<char, char_traits<char> > > num_get_char_2;
  450.  
  451. __DECLARE_INSTANCE(locale::id, num_get_char::id, );
  452. __DECLARE_INSTANCE(locale::id, num_get_char_2::id, );
  453.  
  454. # ifndef _STLP_NO_WCHAR_T
  455.  
  456. typedef num_get<wchar_t, const wchar_t*> num_get_wchar_t;
  457. typedef num_get<wchar_t, istreambuf_iterator<wchar_t, char_traits<wchar_t> > > num_get_wchar_t_2;
  458.  
  459. __DECLARE_INSTANCE(locale::id, num_get_wchar_t::id, );
  460. __DECLARE_INSTANCE(locale::id, num_get_wchar_t_2::id, );
  461.  
  462. # endif
  463.  
  464. # endif /* ( _STLP_STATIC_TEMPLATE_DATA > 0 ) */
  465.  
  466. # ifndef _STLP_NO_BOOL
  467. template <class _CharT, class _InputIter>
  468. _InputIter
  469. num_get<_CharT, _InputIter>::do_get(_InputIter __in, _InputIter __end,
  470.                                     ios_base& __s,
  471.                                     ios_base::iostate& __err, bool& __x) const
  472. {
  473.   if (__s.flags() & ios_base::boolalpha) {
  474.     locale __loc = __s.getloc();
  475.     const _Numpunct& __np = *(const _Numpunct*)__s._M_numpunct_facet();
  476.     //    const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc) ;
  477. //    const ctype<_CharT>& __ct =    use_facet<ctype<_CharT> >(__loc) ;
  478.  
  479.     const basic_string<_CharT> __truename  = __np.truename();
  480.     const basic_string<_CharT> __falsename = __np.falsename();
  481.     bool __true_ok  = true;
  482.     bool __false_ok = true;
  483.  
  484.     size_t __n = 0;
  485.     for ( ; __in != __end; ++__in) {
  486.       _CharT __c = *__in;
  487.       __true_ok  = __true_ok  && (__c == __truename[__n]);
  488.       __false_ok = __false_ok && (__c == __falsename[__n]);
  489.       ++__n;
  490.  
  491.       if ((!__true_ok && !__false_ok) ||
  492.           (__true_ok  && __n >= __truename.size()) ||
  493.           (__false_ok && __n >= __falsename.size())) {
  494.     ++__in;
  495.         break;
  496.       }
  497.     }
  498.     if (__true_ok  && __n < __truename.size())  __true_ok  = false;
  499.     if (__false_ok && __n < __falsename.size()) __false_ok = false;
  500.     
  501.     if (__true_ok || __false_ok) {
  502.       __err = ios_base::goodbit;
  503.       __x = __true_ok;
  504.     }
  505.     else
  506.       __err = ios_base::failbit;
  507.  
  508.     if (__in == __end)
  509.       __err |= ios_base::eofbit;
  510.  
  511.     return __in;
  512.   }
  513.  
  514.   else {
  515.     long __lx;
  516.     _InputIter __tmp = this->do_get(__in, __end, __s, __err, __lx);
  517.     if (!(__err & ios_base::failbit)) {
  518.       if (__lx == 0)
  519.         __x = false;
  520.       else if (__lx == 1)
  521.         __x = true;
  522.       else
  523.         __err |= ios_base::failbit;
  524.     }
  525.     return __tmp;
  526.   }
  527. }
  528.  
  529. # endif /* _STLP_NO_BOOL */
  530.  
  531. # ifdef _STLP_FIX_LIBRARY_ISSUES
  532. template <class _CharT, class _InputIter>  
  533. _InputIter 
  534. num_get<_CharT, _InputIter>::do_get(_InputIter __in, _InputIter __end, ios_base& __str,
  535.                                     ios_base::iostate& __err, short& __val) const {
  536.   return _M_do_get_integer(__in, __end, __str, __err, __val, (_CharT*)0 );
  537. }
  538.  
  539. template <class _CharT, class _InputIter>  
  540. _InputIter 
  541. num_get<_CharT, _InputIter>::do_get(_InputIter __in, _InputIter __end, ios_base& __str,
  542.                                     ios_base::iostate& __err, int& __val) const {
  543.   return _M_do_get_integer(__in, __end, __str, __err, __val, (_CharT*)0 );
  544. }
  545.  
  546. # endif
  547.  
  548. template <class _CharT, class _InputIter>  
  549. _InputIter 
  550. num_get<_CharT, _InputIter>::do_get(_InputIter __in, _InputIter __end, ios_base& __str,
  551.                                     ios_base::iostate& __err, long& __val) const {
  552.   return _M_do_get_integer(__in, __end, __str, __err, __val, (_CharT*)0 );
  553. }
  554.  
  555. template <class _CharT, class _InputIter>  
  556. _InputIter 
  557. num_get<_CharT, _InputIter>::do_get(_InputIter __in, _InputIter __end, ios_base& __str,
  558.                                     ios_base::iostate& __err,
  559.                                     unsigned short& __val) const {
  560.   return _M_do_get_integer(__in, __end, __str, __err, __val, (_CharT*)0 );
  561. }
  562.  
  563. template <class _CharT, class _InputIter>  
  564. _InputIter 
  565. num_get<_CharT, _InputIter>::do_get(_InputIter __in, _InputIter __end, ios_base& __str,
  566.                                     ios_base::iostate& __err, 
  567.                                     unsigned int& __val) const {
  568.   return _M_do_get_integer(__in, __end, __str, __err, __val, (_CharT*)0 );
  569. }
  570.  
  571. template <class _CharT, class _InputIter>  
  572. _InputIter 
  573. num_get<_CharT, _InputIter>::do_get(_InputIter __in, _InputIter __end, ios_base& __str,
  574.                                     ios_base::iostate& __err,
  575.                                     unsigned long& __val) const {
  576.   return _M_do_get_integer(__in, __end, __str, __err, __val, (_CharT*)0 );
  577. }
  578.  
  579.  
  580. template <class _CharT, class _InputIter>  
  581. _InputIter 
  582. num_get<_CharT, _InputIter>::do_get(_InputIter __in, _InputIter __end, ios_base& __str,
  583.                                     ios_base::iostate& __err,
  584.                                     float& __val) const {
  585.   string __buf ;
  586.   bool __ok = _M_read_float(__buf, __in, __end, __str, (_CharT*)0 );
  587.   __string_to_float(__buf, __val);  
  588.   __err = __STATIC_CAST(ios_base::iostate, __ok ? ios_base::goodbit : ios_base::failbit);
  589.   if (__in == __end)
  590.     __err |= ios_base::eofbit;
  591.   return __in;
  592. }
  593.  
  594. template <class _CharT, class _InputIter>  
  595. _InputIter 
  596. num_get<_CharT, _InputIter>::do_get(_InputIter __in, _InputIter __end, ios_base& __str,
  597.                                     ios_base::iostate& __err, 
  598.                                     double& __val) const {
  599.   string __buf ;
  600.   bool __ok = _M_read_float(__buf, __in, __end, __str, (_CharT*)0 );
  601.   __string_to_float(__buf, __val);
  602.   __err = __STATIC_CAST(ios_base::iostate, __ok ? ios_base::goodbit : ios_base::failbit);
  603.   if (__in == __end)
  604.     __err |= ios_base::eofbit;
  605.   return __in;
  606. }
  607.  
  608. #ifndef _STLP_NO_LONG_DOUBLE
  609. template <class _CharT, class _InputIter>  
  610. _InputIter 
  611. num_get<_CharT, _InputIter>::do_get(_InputIter __in, _InputIter __end, ios_base& __str,
  612.                     ios_base::iostate& __err,
  613.                                     long double& __val) const {
  614.   string __buf ;
  615.   bool __ok = _M_read_float(__buf, __in, __end, __str, (_CharT*)0 );
  616.   __string_to_float(__buf, __val);
  617.   __err = __STATIC_CAST(ios_base::iostate, __ok ? ios_base::goodbit : ios_base::failbit);
  618.   if (__in == __end)
  619.     __err |= ios_base::eofbit;
  620.   return __in;
  621. }
  622. #endif /* _STLP_LONG_DOUBLE */
  623.  
  624. template <class _CharT, class _InputIter>  
  625. _InputIter 
  626. num_get<_CharT, _InputIter>::do_get(_InputIter __in, _InputIter __end, ios_base& __str,
  627.                            ios_base::iostate& __err,
  628.                            void*& __p) const {
  629. # if defined(_STLP_LONG_LONG)&&!defined(__MRC__)        //*ty 12/07/2001 - MrCpp can not cast from long long to void*
  630.   unsigned _STLP_LONG_LONG __val;
  631. # else
  632.   unsigned long __val;
  633. # endif
  634.     iter_type __tmp = _M_do_get_integer(__in, __end, __str, __err, __val, (_CharT*)0 );
  635.     if (!(__err & ios_base::failbit))
  636.       __p = __REINTERPRET_CAST(void*,__val);
  637.     return __tmp;
  638.   }
  639.  
  640.  
  641. #ifdef _STLP_LONG_LONG
  642.  
  643. template <class _CharT, class _InputIter>  
  644. _InputIter 
  645. num_get<_CharT, _InputIter>::do_get(_InputIter __in, _InputIter __end, ios_base& __str,
  646.                                     ios_base::iostate& __err,
  647.                                     _STLP_LONG_LONG& __val) const {
  648.   return _M_do_get_integer(__in, __end, __str, __err, __val, (_CharT*)0 );
  649. }
  650.  
  651. template <class _CharT, class _InputIter>  
  652. _InputIter 
  653. num_get<_CharT, _InputIter>::do_get(_InputIter __in, _InputIter __end, ios_base& __str,
  654.                                     ios_base::iostate& __err,
  655.                                     unsigned _STLP_LONG_LONG& __val) const {
  656.   return _M_do_get_integer(__in, __end, __str, __err, __val, (_CharT*)0 );
  657. }
  658.  
  659. #endif /* _STLP_LONG_LONG */
  660.  
  661. _STLP_END_NAMESPACE
  662.  
  663. # endif /* _STLP_EXPOSE_STREAM_IMPLEMENTATION */
  664.  
  665. #endif /* _STLP_NUMERIC_FACETS_C */
  666.  
  667. // Local Variables:
  668. // mode:C++
  669. // End:
  670.