reactos/sdk/include/c++/stlport/stl/_num_get.c

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