test: epoc32/include/tools/stlport/stl/_num

     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_PUT_C

    19 #define _STLP_NUM_PUT_C

    21 #ifndef _STLP_INTERNAL_NUM_PUT_H

    22 #  include <stl/_num_put.h>

    23 #endif

    25 #ifndef _STLP_INTERNAL_LIMITS

    26 #  include <stl/_limits.h>

    27 #endif

    29 _STLP_BEGIN_NAMESPACE

    31 _STLP_MOVE_TO_PRIV_NAMESPACE

    33 // __do_put_float and its helper functions.  Strategy: write the output

    34 // to a buffer of char, transform the buffer to _CharT, and then copy

    35 // it to the output.

    37 //----------------------------------------------------------------------

    38 // num_put facet

    40 template <class _CharT, class _OutputIter>

    41 _OutputIter  _STLP_CALL

    42 __copy_float_and_fill(const _CharT* __first, const _CharT* __last,

    43                       _OutputIter __oi,

    44                       ios_base::fmtflags __flags,

    45                       streamsize __width, _CharT __fill,

    46                       _CharT __xplus, _CharT __xminus) {

    47   if (__width <= __last - __first)

    48     return copy(__first, __last, __oi);

    49   else {

    50     streamsize __pad = __width - (__last - __first);

    51     ios_base::fmtflags __dir = __flags & ios_base::adjustfield;

    53     if (__dir == ios_base::left) {

    54       __oi = copy(__first, __last, __oi);

    55       return __fill_n(__oi, __pad, __fill);

    56     }

    57     else if (__dir == ios_base::internal && __first != __last &&

    58              (*__first == __xplus || *__first == __xminus)) {

    59       *__oi++ = *__first++;

    60       __oi = __fill_n(__oi, __pad, __fill);

    61       return copy(__first, __last, __oi);

    62     }

    63     else {

    64       __oi = __fill_n(__oi, __pad, __fill);

    65       return copy(__first, __last, __oi);

    66     }

    67   }

    68 }

    70 #if !defined (_STLP_NO_WCHAR_T)

    71 // Helper routine for wchar_t

    72 template <class _OutputIter>

    73 _OutputIter  _STLP_CALL

    74 __put_float(__iostring &__str, _OutputIter __oi,

    75             ios_base& __f, wchar_t __fill,

    76             wchar_t __decimal_point, wchar_t __sep,

    77             size_t __group_pos, const string& __grouping) {

    78   const ctype<wchar_t>& __ct = *__STATIC_CAST(const ctype<wchar_t>*, __f._M_ctype_facet());

    80   __iowstring __wbuf;

    81   __convert_float_buffer(__str, __wbuf, __ct, __decimal_point);

    83   if (!__grouping.empty()) {

    84     __insert_grouping(__wbuf, __group_pos, __grouping,

    85                       __sep, __ct.widen('+'), __ct.widen('-'), 0);

    86   }

    88   return __copy_float_and_fill(__CONST_CAST(wchar_t*, __wbuf.data()),

    89                                __CONST_CAST(wchar_t*, __wbuf.data()) + __wbuf.size(), __oi,

    90                                __f.flags(), __f.width(0), __fill, __ct.widen('+'), __ct.widen('-'));

    91 }

    92 #endif /* WCHAR_T */

    94 // Helper routine for char

    95 template <class _OutputIter>

    96 _OutputIter  _STLP_CALL

    97 __put_float(__iostring &__str, _OutputIter __oi,

    98             ios_base& __f, char __fill,

    99             char __decimal_point, char __sep,

   100             size_t __group_pos, const string& __grouping) {

   101   if ((__group_pos < __str.size()) && (__str[__group_pos] == '.')) {

   102     __str[__group_pos] = __decimal_point;

   103   }

   105   if (!__grouping.empty()) {

   106     __insert_grouping(__str, __group_pos,

   107                       __grouping, __sep, '+', '-', 0);

   108   }

   110   return __copy_float_and_fill(__CONST_CAST(char*, __str.data()),

   111                                __CONST_CAST(char*, __str.data()) + __str.size(), __oi,

   112                                __f.flags(), __f.width(0), __fill, '+', '-');

   113 }

   115 template <class _CharT, class _OutputIter, class _Float>

   116 _OutputIter _STLP_CALL

   117 __do_put_float(_OutputIter __s, ios_base& __f,

   118                 _CharT __fill, _Float __x) {

   119   __iostring __buf;

   121   size_t __group_pos = __write_float(__buf, __f.flags(), (int)__f.precision(), __x);

   123   const numpunct<_CharT>& __np = *__STATIC_CAST(const numpunct<_CharT>*, __f._M_numpunct_facet());

   125   return __put_float(__buf, __s, __f, __fill,

   126                      __np.decimal_point(), __np.thousands_sep(),

   127                      __group_pos, __f._M_grouping());

   128 }

   130 inline void __get_money_digits_aux (__iostring &__buf, ios_base &, _STLP_LONGEST_FLOAT_TYPE __x)

   131 { __get_floor_digits(__buf, __x); }

   133 #if !defined (_STLP_NO_WCHAR_T)

   134 inline void __get_money_digits_aux (__iowstring &__wbuf, ios_base &__f, _STLP_LONGEST_FLOAT_TYPE __x) {

   135   __iostring __buf;

   136   __get_floor_digits(__buf, __x);

   138   const ctype<wchar_t>& __ct = *__STATIC_CAST(const ctype<wchar_t>*, __f._M_ctype_facet());

   139   __convert_float_buffer(__buf, __wbuf, __ct, wchar_t(0), false);

   140 }

   141 #endif

   143 template <class _CharT>

   144 void _STLP_CALL __get_money_digits(_STLP_BASIC_IOSTRING(_CharT) &__buf, ios_base& __f, _STLP_LONGEST_FLOAT_TYPE __x)

   145 { __get_money_digits_aux(__buf, __f, __x); }

   147 // _M_do_put_integer and its helper functions.

   149 template <class _CharT, class _OutputIter>

   150 _OutputIter _STLP_CALL

   151 __copy_integer_and_fill(const _CharT* __buf, ptrdiff_t __len,

   152                         _OutputIter __oi,

   153                         ios_base::fmtflags __flg, streamsize __wid, _CharT __fill,

   154                         _CharT __xplus, _CharT __xminus) {

   155   if (__len >= __wid)

   156     return copy(__buf, __buf + __len, __oi);

   157   else {

   158     //casting numeric_limits<ptrdiff_t>::max to streamsize only works is ptrdiff_t is signed or streamsize representation

   159     //is larger than ptrdiff_t one.

   160     _STLP_STATIC_ASSERT((sizeof(streamsize) > sizeof(ptrdiff_t)) ||

   161                         (sizeof(streamsize) == sizeof(ptrdiff_t)) && numeric_limits<ptrdiff_t>::is_signed)

   162     ptrdiff_t __pad = __STATIC_CAST(ptrdiff_t, (min) (__STATIC_CAST(streamsize, (numeric_limits<ptrdiff_t>::max)()),

   163                                                       __STATIC_CAST(streamsize, __wid - __len)));

   164     ios_base::fmtflags __dir = __flg & ios_base::adjustfield;

   166     if (__dir == ios_base::left) {

   167       __oi = copy(__buf, __buf + __len, __oi);

   168       return __fill_n(__oi, __pad, __fill);

   169     }

   170     else if (__dir == ios_base::internal && __len != 0 &&

   171              (__buf[0] == __xplus || __buf[0] == __xminus)) {

   172       *__oi++ = __buf[0];

   173       __oi = __fill_n(__oi, __pad, __fill);

   174       return copy(__buf + 1, __buf + __len, __oi);

   175     }

   176     else if (__dir == ios_base::internal && __len >= 2  &&

   177              (__flg & ios_base::showbase) &&

   178              (__flg & ios_base::basefield) == ios_base::hex) {

   179       *__oi++ = __buf[0];

   180       *__oi++ = __buf[1];

   181       __oi = __fill_n(__oi, __pad, __fill);

   182       return copy(__buf + 2, __buf + __len, __oi);

   183     }

   184     else {

   185       __oi = __fill_n(__oi, __pad, __fill);

   186       return copy(__buf, __buf + __len, __oi);

   187     }

   188   }

   189 }

   191 #if !defined (_STLP_NO_WCHAR_T)

   192 // Helper function for wchar_t

   193 template <class _OutputIter>

   194 _OutputIter _STLP_CALL

   195 __put_integer(char* __buf, char* __iend, _OutputIter __s,

   196               ios_base& __f,

   197               ios_base::fmtflags __flags, wchar_t __fill) {

   198   locale __loc = __f.getloc();

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

   200   const ctype<wchar_t>& __ct = *__STATIC_CAST(const ctype<wchar_t>*, __f._M_ctype_facet());

   202   wchar_t __xplus  = __ct.widen('+');

   203   wchar_t __xminus = __ct.widen('-');

   205   wchar_t __wbuf[64];

   206   __ct.widen(__buf, __iend, __wbuf);

   207   ptrdiff_t __len = __iend - __buf;

   208   wchar_t* __eend = __wbuf + __len;

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

   211   //  const string& __grouping = __np.grouping();

   213   const numpunct<wchar_t>& __np = *__STATIC_CAST(const numpunct<wchar_t>*, __f._M_numpunct_facet());

   214   const string& __grouping = __f._M_grouping();

   216   if (!__grouping.empty()) {

   217     int __basechars;

   218     if (__flags & ios_base::showbase)

   219       switch (__flags & ios_base::basefield) {

   220         case ios_base::hex: __basechars = 2; break;

   221         case ios_base::oct: __basechars = 1; break;

   222         default: __basechars = 0;

   223       }

   224     else

   225       __basechars = 0;

   227     __len = __insert_grouping(__wbuf, __eend, __grouping, __np.thousands_sep(),

   228                               __xplus, __xminus, __basechars);

   229   }

   231   return __copy_integer_and_fill((wchar_t*)__wbuf, __len, __s,

   232                                  __flags, __f.width(0), __fill, __xplus, __xminus);

   233 }

   234 #endif

   236 // Helper function for char

   237 template <class _OutputIter>

   238 _OutputIter _STLP_CALL

   239 __put_integer(char* __buf, char* __iend, _OutputIter __s,

   240               ios_base& __f, ios_base::fmtflags __flags, char __fill) {

   241   char __grpbuf[64];

   242   ptrdiff_t __len = __iend - __buf;

   244   //  const numpunct<char>& __np = use_facet<numpunct<char> >(__f.getloc());

   245   //  const string& __grouping = __np.grouping();

   247   const numpunct<char>& __np = *__STATIC_CAST(const numpunct<char>*, __f._M_numpunct_facet());

   248   const string& __grouping = __f._M_grouping();

   250   if (!__grouping.empty()) {

   251     int __basechars;

   252     if (__flags & ios_base::showbase)

   253       switch (__flags & ios_base::basefield) {

   254         case ios_base::hex: __basechars = 2; break;

   255         case ios_base::oct: __basechars = 1; break;

   256         default: __basechars = 0;

   257       }

   258     else

   259       __basechars = 0;

   261      // make sure there is room at the end of the buffer

   262      // we pass to __insert_grouping

   263     copy(__buf, __iend, (char *) __grpbuf);

   264     __buf = __grpbuf;

   265     __iend = __grpbuf + __len;

   266     __len = __insert_grouping(__buf, __iend, __grouping, __np.thousands_sep(),

   267                               '+', '-', __basechars);

   268   }

   270   return __copy_integer_and_fill(__buf, __len, __s, __flags, __f.width(0), __fill, '+', '-');

   271 }

   273 #if defined (_STLP_LONG_LONG)

   274 typedef _STLP_LONG_LONG __max_int_t;

   275 typedef unsigned _STLP_LONG_LONG __umax_int_t;

   276 #else

   277 typedef long __max_int_t;

   278 typedef unsigned long __umax_int_t;

   279 #endif

   281 _STLP_DECLSPEC const char* _STLP_CALL __hex_char_table_lo();

   282 _STLP_DECLSPEC const char* _STLP_CALL __hex_char_table_hi();

   284 template <class _Integer>

   285 inline char* _STLP_CALL

   286 __write_decimal_backward(char* __ptr, _Integer __x, ios_base::fmtflags __flags, const __true_type& /* is_signed */) {

   287   const bool __negative = __x < 0 ;

   288   __max_int_t __temp = __x;

   289   __umax_int_t __utemp = __negative?-__temp:__temp;

   291   for (; __utemp != 0; __utemp /= 10)

   292     *--__ptr = (char)((int)(__utemp % 10) + '0');

   293   // put sign if needed or requested

   294   if (__negative)

   295     *--__ptr = '-';

   296   else if (__flags & ios_base::showpos)

   297     *--__ptr = '+';

   298   return __ptr;

   299 }

   301 template <class _Integer>

   302 inline char* _STLP_CALL

   303 __write_decimal_backward(char* __ptr, _Integer __x, ios_base::fmtflags __flags, const __false_type& /* is_signed */) {

   304   for (; __x != 0; __x /= 10)

   305     *--__ptr = (char)((int)(__x % 10) + '0');

   306   // put sign if requested

   307   if (__flags & ios_base::showpos)

   308     *--__ptr = '+';

   309   return __ptr;

   310 }

   312 template <class _Integer>

   313 char* _STLP_CALL

   314 __write_integer_backward(char* __buf, ios_base::fmtflags __flags, _Integer __x) {

   315   char* __ptr = __buf;

   317   if (__x == 0) {

   318     *--__ptr = '0';

   319     if ((__flags & ios_base::showpos) && ((__flags & (ios_base::oct | ios_base::hex)) == 0))

   320       *--__ptr = '+';

   321     // oct or hex base shall not be added to the 0 value (see '#' flag in C formating strings)

   322   }

   323   else {

   324     switch (__flags & ios_base::basefield) {

   325       case ios_base::oct:

   326         {

   327           __umax_int_t __temp = __x;

   328           // if the size of integer is less than 8, clear upper part

   329           if ( sizeof(__x) < 8  && sizeof(__umax_int_t) >= 8 )

   330             __temp &= 0xFFFFFFFF;

   332           for (; __temp != 0; __temp >>=3)

   333             *--__ptr = (char)((((unsigned)__temp)& 0x7) + '0');

   335           // put leading '0' if showbase is set

   336           if (__flags & ios_base::showbase)

   337             *--__ptr = '0';

   338         }

   339         break;

   340       case ios_base::hex:

   341         {

   342           const char* __table_ptr = (__flags & ios_base::uppercase) ?

   343             __hex_char_table_hi() : __hex_char_table_lo();

   344           __umax_int_t __temp = __x;

   345           // if the size of integer is less than 8, clear upper part

   346           if ( sizeof(__x) < 8  && sizeof(__umax_int_t) >= 8 )

   347             __temp &= 0xFFFFFFFF;

   349           for (; __temp != 0; __temp >>=4)

   350             *--__ptr = __table_ptr[((unsigned)__temp & 0xF)];

   352           if (__flags & ios_base::showbase) {

   353             *--__ptr = __table_ptr[16];

   354             *--__ptr = '0';

   355           }

   356         }

   357         break;

   358       //case ios_base::dec:

   359       default:

   360         {

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

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

   363           if (_IsSigned)

   364             __ptr = __write_decimal_backward(__ptr, __x, __flags, __true_type() );

   365           else

   366             __ptr = __write_decimal_backward(__ptr, __x, __flags, __false_type() );

   367 #else

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

   369           __ptr = __write_decimal_backward(__ptr, __x, __flags, _IsSigned());

   370 #endif

   371         }

   372         break;

   373     }

   374   }

   376   // return pointer to beginning of the string

   377   return __ptr;

   378 }

   380 template <class _CharT, class _OutputIter, class _Integer>

   381 _OutputIter _STLP_CALL

   382 __do_put_integer(_OutputIter __s, ios_base& __f, _CharT __fill, _Integer __x) {

   383   // buffer size = number of bytes * number of digit necessary in the smallest Standard base (base 8, 3 digits/byte)

   384   //               plus the longest base representation '0x'

   385   // Do not use __buf_size to define __buf static buffer, some compilers (HP aCC) do not accept const variable as

   386   // the specification of a static buffer size.

   387   char __buf[sizeof(_Integer) * 3 + 2];

   388   const ptrdiff_t __buf_size = sizeof(__buf) / sizeof(char);

   389   ios_base::fmtflags __flags = __f.flags();

   390   char* __ibeg = __write_integer_backward((char*)__buf+__buf_size, __flags, __x);

   391   return __put_integer(__ibeg, (char*)__buf+__buf_size, __s, __f, __flags, __fill);

   392 }

   394 _STLP_MOVE_TO_STD_NAMESPACE

   396 //

   397 // num_put<>

   398 //

   400 #if (_STLP_STATIC_TEMPLATE_DATA > 0)

   402 #  if !defined (__BORLANDC__)

   403 template <class _CharT, class _OutputIterator>

   404 locale::id num_put<_CharT, _OutputIterator>::id;

   405 #  endif

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

   408        defined (_STLP_USE_DYNAMIC_LIB) && !defined (__BUILDING_STLPORT)

   409 /*

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

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

   412  * calling executable.

   413  */

   414 template <>

   415 _STLP_DECLSPEC locale::id num_put<char, ostreambuf_iterator<char, char_traits<char> > >::id;

   416 /*

   417 template <>

   418 _STLP_DECLSPEC locale::id num_put<char, char*>::id;

   419 */

   421 #    if !defined (_STLP_NO_WCHAR_T)

   422 template <>

   423 _STLP_DECLSPEC locale::id num_put<wchar_t, ostreambuf_iterator<wchar_t, char_traits<wchar_t> > >::id;

   424 /*

   425 template <>

   426 _STLP_DECLSPEC locale::id num_put<wchar_t, wchar_t*>::id;

   427 */

   428 #    endif

   430 #  endif /* __CYGWIN__ && _STLP_USE_DYNAMIC_LIB */

   432 #else /* ( _STLP_STATIC_TEMPLATE_DATA > 0 ) */

   434 //typedef num_put<char, char*> num_put_char;

   435 typedef num_put<char, ostreambuf_iterator<char, char_traits<char> > > num_put_char_2;

   437 //__DECLARE_INSTANCE(locale::id, num_put_char::id, );

   438 __DECLARE_INSTANCE(locale::id, num_put_char_2::id, );

   440 #  if !defined (_STLP_NO_WCHAR_T)

   442 //typedef num_put<wchar_t, wchar_t*> num_put_wchar_t;

   443 typedef num_put<wchar_t, ostreambuf_iterator<wchar_t, char_traits<wchar_t> > > num_put_wchar_t_2;

   445 //__DECLARE_INSTANCE(locale::id, num_put_wchar_t::id, );

   446 __DECLARE_INSTANCE(locale::id, num_put_wchar_t_2::id, );

   448 #  endif

   450 #endif /* ( _STLP_STATIC_TEMPLATE_DATA > 0 ) */

   452 // issue 118

   454 #if !defined (_STLP_NO_BOOL)

   455 template <class _CharT, class _OutputIter>

   456 _OutputIter

   457 num_put<_CharT, _OutputIter>::do_put(_OutputIter __s, ios_base& __f,

   458                                      char_type __fill,  bool __val) const {

   459   if (!(__f.flags() & ios_base::boolalpha))

   460     return this->do_put(__s, __f, __fill, __STATIC_CAST(long,__val));

   462   locale __loc = __f.getloc();

   463   //  typedef numpunct<_CharT> _Punct;

   464   //  const _Punct& __np = use_facet<_Punct>(__loc);

   466   const numpunct<_CharT>& __np = *__STATIC_CAST(const numpunct<_CharT>*, __f._M_numpunct_facet());

   468   basic_string<_CharT> __str = __val ? __np.truename() : __np.falsename();

   470   // Reuse __copy_integer_and_fill.  Since internal padding makes no

   471   // sense for bool, though, make sure we use something else instead.

   472   // The last two argument to __copy_integer_and_fill are dummies.

   473   ios_base::fmtflags __flags = __f.flags();

   474   if ((__flags & ios_base::adjustfield) == ios_base::internal)

   475     __flags = (__flags & ~ios_base::adjustfield) | ios_base::right;

   477   return _STLP_PRIV __copy_integer_and_fill(__str.c_str(), __str.size(), __s,

   478                                             __flags, __f.width(0), __fill,

   479                                             (_CharT) 0, (_CharT) 0);

   480 }

   482 #endif

   484 template <class _CharT, class _OutputIter>

   485 _OutputIter

   486 num_put<_CharT, _OutputIter>::do_put(_OutputIter __s, ios_base& __f, _CharT __fill,

   487                                      long __val) const

   488 { return _STLP_PRIV __do_put_integer(__s, __f, __fill, __val); }

   490 template <class _CharT, class _OutputIter>

   491 _OutputIter

   492 num_put<_CharT, _OutputIter>::do_put(_OutputIter __s, ios_base& __f, _CharT __fill,

   493                                      unsigned long __val) const

   494 { return _STLP_PRIV __do_put_integer(__s, __f, __fill, __val); }

   496 template <class _CharT, class _OutputIter>

   497 _OutputIter

   498 num_put<_CharT, _OutputIter>::do_put(_OutputIter __s, ios_base& __f, _CharT __fill,

   499                                      double __val) const

   500 { return _STLP_PRIV __do_put_float(__s, __f, __fill, __val); }

   502 #if !defined (_STLP_NO_LONG_DOUBLE)

   503 template <class _CharT, class _OutputIter>

   504 _OutputIter

   505 num_put<_CharT, _OutputIter>::do_put(_OutputIter __s, ios_base& __f, _CharT __fill,

   506                                      long double __val) const

   507 { return _STLP_PRIV __do_put_float(__s, __f, __fill, __val); }

   508 #endif

   510 #if defined (_STLP_LONG_LONG)

   511 template <class _CharT, class _OutputIter>

   512 _OutputIter

   513 num_put<_CharT, _OutputIter>::do_put(_OutputIter __s, ios_base& __f, _CharT __fill,

   514                                      _STLP_LONG_LONG __val) const

   515 { return _STLP_PRIV __do_put_integer(__s, __f, __fill, __val); }

   517 template <class _CharT, class _OutputIter>

   518 _OutputIter

   519 num_put<_CharT, _OutputIter>::do_put(_OutputIter __s, ios_base& __f, _CharT __fill,

   520                                      unsigned _STLP_LONG_LONG __val) const

   521 { return _STLP_PRIV __do_put_integer(__s, __f, __fill, __val); }

   522 #endif /* _STLP_LONG_LONG */

   525 // lib.facet.num.put.virtuals "12 For conversion from void* the specifier is %p."

   526 template <class _CharT, class _OutputIter>

   527 _OutputIter

   528 num_put<_CharT, _OutputIter>::do_put(_OutputIter __s, ios_base& __f, _CharT /*__fill*/,

   529                                      const void* __val) const {

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

   531   ios_base::fmtflags __save_flags = __f.flags();

   533   __f.setf(ios_base::hex, ios_base::basefield);

   534   __f.setf(ios_base::showbase);

   535   __f.setf(ios_base::internal, ios_base::adjustfield);

   536   __f.width((sizeof(void*) * 2) + 2); // digits in pointer type plus '0x' prefix

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

   538   _OutputIter result = this->do_put(__s, __f, __c_type.widen('0'), __REINTERPRET_CAST(unsigned _STLP_LONG_LONG,__val));

   539 # else

   540   _OutputIter result = this->do_put(__s, __f, __c_type.widen('0'), __REINTERPRET_CAST(unsigned long,__val));

   541 # endif

   542   __f.flags(__save_flags);

   543   return result;

   544 }

   546 _STLP_END_NAMESPACE

   548 #endif /* _STLP_NUM_PUT_C */

   550 // Local Variables:

   551 // mode:C++

   552 // End:

author	William Roberts <williamr@symbian.org>
	Wed, 31 Mar 2010 12:33:34 +0100
branch	Symbian3
changeset 4	837f303aceeb
permissions	-rw-r--r--