/*

  * © Portions copyright (c) 2006-2007 Nokia Corporation.  All rights reserved.

  *

  * Copyright (c) 1999

  * Silicon Graphics Computer Systems, Inc.

  *

  * Copyright (c) 1999 

  * Boris Fomitchev

  *

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

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

  *

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

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

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

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

  * modified is included with the above copyright notice.

  *

  */ 

 #ifndef _STLP_MONETARY_C

 #define _STLP_MONETARY_C

 # ifndef _STLP_INTERNAL_MONETARY_H

 #  include <stl/_monetary.h>

 # endif

 # if defined (_STLP_EXPOSE_STREAM_IMPLEMENTATION)

 #ifndef _STLP_INTERNAL_IOS_H

 # include <stl/_ios.h>

 #endif

 #ifndef _STLP_INTERNAL_NUM_PUT_H

 # include <stl/_num_put.h>

 #endif

 #ifndef _STLP_INTERNAL_NUM_GET_H

 # include <stl/_num_get.h>

 #endif

 _STLP_BEGIN_NAMESPACE

 # if ( _STLP_STATIC_TEMPLATE_DATA > 0 )

 # if !defined(__LIBSTD_CPP_SYMBIAN32_WSD__) && !defined(_STLP_LIBSTD_CPP_NO_STATIC_VAR_)

 template <class _CharT, class _InputIterator>

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

 template <class _CharT, class _OutputIterator>

 locale::id money_put<_CharT, _OutputIterator>::id;

 #endif

 # else /* ( _STLP_STATIC_TEMPLATE_DATA > 0 ) */

 typedef money_get<char, const char*> money_get_char;

 typedef money_put<char, char*> money_put_char;

 typedef money_get<char, istreambuf_iterator<char, char_traits<char> > > money_get_char_2;

 typedef money_put<char, ostreambuf_iterator<char, char_traits<char> > > money_put_char_2;

 #ifndef __SYMBIAN32__

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

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

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

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

 #endif

 # ifndef _STLP_NO_WCHAR_T

 typedef money_get<wchar_t, const wchar_t*> money_get_wchar_t;

 typedef money_get<wchar_t, istreambuf_iterator<wchar_t, char_traits<wchar_t> > > money_get_wchar_t_2;

 typedef money_put<wchar_t, wchar_t*> money_put_wchar_t;

 typedef money_put<wchar_t, ostreambuf_iterator<wchar_t, char_traits<wchar_t> > > money_put_wchar_t_2;

 #ifndef __SYMBIAN32__

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

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

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

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

 #endif

 # endif

 # endif /* ( _STLP_STATIC_TEMPLATE_DATA > 0 ) */

 // money_get facets

 // helper functions for do_get

 template <class _InIt1, class _InIt2>

 pair<_InIt1, bool> __get_string(_InIt1 __first,     _InIt1 __last,

                                _InIt2 __str_first, _InIt2 __str_last) {

   pair<_InIt1, _InIt2> __pr = mismatch(__first, __last, __str_first);

   return make_pair(__pr.first, __pr.second == __str_last);

 }

 template <class _InIt, class _OuIt, class _CharT>

 bool

 __get_monetary_value(_InIt& __first, _InIt __last, _OuIt __stl_out,

                      const ctype<_CharT>& _c_type,

                      _CharT   __point,

                      int      __frac_digits,

                      _CharT __sep,

                      const string& __grouping,

                      bool&         __syntax_ok)

 {

 	size_t __digits = 0;

   if (__first == __last || !_c_type.is(ctype_base::digit, *__first))

     return false;

   char __group_sizes[128];

   char* __group_sizes_end = __grouping.size() == 0 ? 0 : __group_sizes;

   char   __current_group_size = 0;

   while (__first != __last) {

     if (_c_type.is(ctype_base::digit, *__first)) {

       ++__current_group_size;

       *__stl_out++ = *__first++;

 	  __digits++;

     }

 #ifdef __SYMBIAN32__

 else if ( (__current_group_size)&&(__group_sizes_end) ){

 #else

     else if (__group_sizes_end) {

 #endif		

       if (*__first == __sep) {

 	*__group_sizes_end++ = __current_group_size; 

 	__current_group_size = 0;

 	++__first;

       }

       else break;

     }

     else

       break;

   }

   if (__grouping.size() == 0)

     __syntax_ok = true;

   else {

     if (__group_sizes_end != __group_sizes)

      *__group_sizes_end++ = __current_group_size; 

     __syntax_ok = __valid_grouping(__group_sizes, __group_sizes_end,

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

     if (__first == __last || *__first != __point) {

       for (int __digits = 0; __digits != __frac_digits; ++__digits)

         *__stl_out++ = _CharT('0');

       return true; // OK not to have decimal point

     }

   }

 //bug fix testcase_22427 - commented

 //  ++__first; 

   //bug fix testcase_22427 - added if

   if (__first != __last && *__first == __point && __frac_digits)

   {  	

 	//bug fix testcase_22427 - commented

 	++__first; 

 	  while (__first != __last && _c_type.is(ctype_base::digit, *__first)) {

 	      *__stl_out++ = *__first++;

 	     ++__digits;

 	  }

   }

   //bug fix testcase_22427 - condition changed

 //  __syntax_ok = __syntax_ok && (__digits == __frac_digits);

  if(__digits == 0)

   	__syntax_ok = false;

   return true;

 }

 # ifndef _STLP_NO_LONG_DOUBLE

 //===== methods ======

 template <class _CharT, class _InputIter>

 _InputIter 

 money_get<_CharT, _InputIter>::do_get(_InputIter __s, _InputIter  __end, bool  __intl,

 				      ios_base&  __str, ios_base::iostate& __err,

 				      long double& __units) const {

   string_type __buf;

   __s = do_get(__s, __end, __intl, __str, __err, __buf);

   if (__err == ios_base::goodbit || __err == ios_base::eofbit) {

     __buf.push_back(0);

     typename string_type::iterator __b = __buf.begin(), __e = __buf.end();

     // Can't use atold, since it might be wchar_t. Don't get confused by name below :

     // it's perfectly capable of reading long double.

     __get_decimal_integer(__b, __e, __units);

   }

   if (__s == __end)

     __err |= ios_base::eofbit;

   return __s;

 }

 # endif

 template <class _CharT, class _InputIter>

 _InputIter 

 money_get<_CharT, _InputIter>::do_get(iter_type __s, 

 				      iter_type  __end, bool  __intl,

 				      ios_base&  __str, ios_base::iostate&  __err,

 				      string_type& __digits) const {

 	__err = 0;

   if (__s == __end) {

     __err |= ios_base::eofbit;

     return __s;

   }

   typedef moneypunct<_CharT, false> _Punct;

   typedef moneypunct<_CharT, true>  _Punct_intl;

   typedef ctype<_CharT>             _Ctype;

 #ifdef __SYMBIAN32__			

 	bool		__isSignSympresent = false;

 #endif			

  bool	__testvalid = true;

   locale __loc = __str.getloc();

   const _Punct&      __punct      = use_facet<_Punct>(__loc) ;

   const _Punct_intl& __punct_intl = use_facet<_Punct_intl>(__loc) ;

   const _Ctype&      __c_type      = use_facet<_Ctype>(__loc) ;

   money_base::pattern __format = __intl ? __punct_intl.neg_format()

                                         : __punct.neg_format();

   string_type __ns = __intl ? __punct_intl.negative_sign()

                             : __punct.negative_sign();

   string_type __ps = __intl ? __punct_intl.positive_sign()

                             : __punct.positive_sign();

   string_type __sign  = __ps;

   int __i;

   bool __is_positive = true;

   bool __symbol_required = (__str.flags() & ios_base::showbase) !=0;

   string_type __buf;

   back_insert_iterator<string_type> __stl_out(__buf);

 //  pair<iter_type, bool> __result;

   for (__i = 0; __i < 4; ++__i) {

     switch (__format.field[__i]) {

     case (char) money_base::none:

 #ifndef	__SYMBIAN32__

 	  case (char) money_base::space:

 #endif	  	

       if (__i == 3) {

         //if (__c_type.is(ctype_base::space, *__s)) { //gnu buf fix, 22/12/06

         if((__s != __end) && (!__c_type.is(ctype_base::space, *__s)) && (__ps.size()<=1) && (__ns.size()<=1) ){

           __err = ios_base::failbit;

           return __s;

         }

        // break; //gnu bug fix 2/1/07

       }

       while (__s != __end && __c_type.is(ctype_base::space, *__s))

         ++__s;

       break;

 #ifdef	__SYMBIAN32__	  

     case (char) money_base::space:

       if (!__c_type.is(ctype_base::space, *__s)) {

 #ifdef __SYMBIAN32__      

       	if(!__isSignSympresent) //if no sign symbol present, space is not mandatory.

       		break;

 #endif      	

         __err = ios_base::failbit;

         return __s;

       }

       ++__s;

       while (__s != __end && __c_type.is(ctype_base::space, *__s))

         ++__s;

       break;

 #endif	  

     case money_base::symbol: {

       string_type __curs = __intl ? __punct_intl.curr_symbol()

                                 : __punct.curr_symbol();

       pair<iter_type, bool>

       __result  = __get_string(__s, __end, __curs.begin(), __curs.end());

       if (!__result.second && __symbol_required)

         __err = ios_base::failbit;

       __s = __result.first;

       break;

     }

     case money_base::sign: {

       if (__s == __end) {

         if (__ps.size() == 0)

           break;

         if (__ns.size() == 0) {

           __is_positive = false;

 	__sign  = __ns;

           break;

         }

         __err = ios_base::failbit;

         return __s;

       }

       else {

         if (__ps.size() == 0) {

           if (__ns.size() == 0)

             break;

           if (*__s == __ns[0]) {

             ++__s;

             __is_positive = false;

 			__sign  = __ns;

 #ifdef __SYMBIAN32__			

 			__isSignSympresent = true;

 #endif			

             break;

           }

         //  __err = ios_base::failbit; //if ps !=0 and ns!=0, and no negative sign mean it is positive, not fail.

 	  //          return __s;

 	  break;

         } 

         else {

           if (*__s == __ps[0]) {

             ++__s;

 #ifdef __SYMBIAN32__			

 			__isSignSympresent = true;

 #endif			

             break;

           }

 #ifdef	__SYMBIAN32__

 	    if (__ns.size() == 0) //here positive have symbol,negative have no symbol

 	    {

 	    	__is_positive = false; // in this case if symbol not present means it is negative

 	    	__sign = __ns;

 	    	break;

 	    }

 #else          

           if (__ns.size() == 0)

             break;

 #endif          

           if (*__s == __ns[0]) {

             ++__s;

             __is_positive = false;

 			__sign  = __ns;

 #ifdef __SYMBIAN32__			

 			__isSignSympresent = true;

 #endif			

             break;

           }

           __err = ios_base::failbit;

 	  //          return __s;

         }

       }

       return __s;

       //      break;

     }

     case money_base::value: {

       _CharT __point = __intl ? __punct_intl.decimal_point()

                               : __punct.decimal_point();

       int __frac_digits = __intl ? __punct_intl.frac_digits()

                                  : __punct.frac_digits();

       string __grouping = __intl ? __punct_intl.grouping()

                                  : __punct.grouping();

       bool __syntax_ok = true;

       bool __result;

       _CharT __sep = __grouping.size() == 0 ? _CharT() : 

 	__intl ? __punct_intl.thousands_sep() : __punct.thousands_sep();

       __result = __get_monetary_value(__s, __end, __stl_out, __c_type,

                                       __point, __frac_digits,

                                       __sep,

                                       __grouping, __syntax_ok);      

       if (!__syntax_ok)

         __err |= ios_base::failbit;

       if (!__result) {

         __err = ios_base::failbit;

         return __s;

       }

       break;

     }                           // Close money_base::value case

     }                           // Close switch statement

   }                             // Close for loop

 #ifndef __SYMBIAN32__ //find the given number pos or neg, required for cases where sign is present at string starting and ending

 	do{

 	bool type = true;

 	int si = __ps.size();

 	for (int i = 1;i<__ps.size();i++)

 		{

 			if(__s[i-1]!=__ps[i])

 			{

 				type = false;

 				break;

 			}

 		}

 	if ((si!=0) && (type ==true))

 	{

 		__sign = __ps;

             break;

 	}  

           if (__ns.size() == 0)

             break;

 	type = true;

 	for (int i =1;i<__ns.size();i++)

 		{

 			if(__s[i-1]!=__ns[i])

 			{

 				type = false;

 				break;

 			}

 		}

           if (type ==true) {

             __is_positive = false;

 		__sign = __ns;

             break;

           }

 	}while(0);

 #endif

 #ifdef __SYMBIAN32__

 // Need to get the rest of the sign characters, if they exist.

       if (__sign.size() > 1)

         {

           int __len = __sign.size();

           int __i = 1;

 	  char_type __c = *__s;

 	  char_type __eol = '\0';

           for (; __c != __eol && __i < __len; __i++)

           	{

             	if (__s != __end)

               	__c = *(++__s);

           }

 		  //checking sign completely extracted successfully

           if (__i != __len)

             __testvalid = false;

         }

 #endif

   if (__is_positive) {

     if (__ps.size() > 1) {

 #ifndef __SYMBIAN32__		

       pair<_InputIter, bool>

         __result = __get_string(__s, __end, __ps.begin() + 1, __ps.end());

       __s = __result.first;

       if (!__result.second)

 	__err |= ios::failbit;

 #endif

 	if(!__testvalid)

 		__err |= ios::failbit;

     }

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

       __digits = __buf;

   }

   else {

     if (__ns.size() > 1) {

 #ifndef __SYMBIAN32__		

       pair<_InputIter, bool>

         __result = __get_string(__s, __end, __ns.begin() + 1, __ns.end());

       __s = __result.first;

       if (!__result.second)

 	__err |= ios::failbit;

 #endif

 	if(!__testvalid)

 		__err |= ios::failbit;

     }

     if (!(__err & ios::failbit) && (__ns == __sign)) {

       __buf.insert(__buf.begin(),__c_type.widen('-'));      

     }

 #ifdef __SYMBIAN32__	

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

       __digits = __buf;	

 #else  

    __digits = __buf;	

 #endif

   }

   if (__s == __end)

     __err |= ios::eofbit;

   return __s;

 }

 // money_put facets

 template <class _CharT, class _OutputIter>

 _OutputIter

 money_put<_CharT, _OutputIter>

  ::do_put(_OutputIter __s, bool __intl, ios_base& __str,

           char_type __fill,

           const string_type& __digits) const { 

   typedef ctype<_CharT>             _Ctype;

   typedef moneypunct<_CharT, false> _Punct;

   typedef moneypunct<_CharT, true>  _Punct_intl;

   locale __loc = __str.getloc();

   const _Ctype&      __c_type      = use_facet<_Ctype>(__loc) ;

   const _Punct&      __punct      = use_facet<_Punct>(__loc) ;

   const _Punct_intl& __punct_intl = use_facet<_Punct_intl>(__loc) ;

   // some special characters

   char_type __minus = __c_type.widen('-');

   char_type __plus  = __c_type.widen('+');

   char_type __space = __c_type.widen(' ');

   char_type __zero  = __c_type.widen('0');

   char_type __point = __intl ? __c_type.widen(__punct_intl.decimal_point())

 			     : __c_type.widen(__punct.decimal_point());

   char_type __sep = __intl ? __punct_intl.thousands_sep()

 			   : __punct     .thousands_sep();

   string __grouping = __intl ? __punct_intl.grouping()

 		             : __punct     .grouping();

   int __frac_digits      = __intl ? __punct_intl.frac_digits() 

                                   : __punct.frac_digits();

   string_type __curr_sym = __intl ? __punct_intl.curr_symbol() 

                                   : __punct.curr_symbol();

     // if there are no digits we are going to return __s.  If there

     // are digits, but not enough to fill the frac_digits, we are

     // going to add zeros.  I don't know whether this is right or

     // not.

   if (__digits.size() == 0) 

     return __s;

   typename string_type::const_iterator __digits_first = __digits.begin();

   typename string_type::const_iterator __digits_last  = __digits.end();

   bool __is_negative = *__digits_first == __minus;

   if (__is_negative)

     ++__digits_first;

   string_type __sign = __intl ?

 			 __is_negative ? __punct_intl.negative_sign()

 				       : __punct_intl.positive_sign()

 			      :

 			 __is_negative ? __punct.negative_sign()

 				       : __punct.positive_sign();

   typename string_type::const_iterator __cp = __digits_first;

   while (__cp != __digits_last && __c_type.is(ctype_base::digit, *__cp))

     ++__cp;

   if (__cp == __digits_first)

     return __s;

   __digits_last = __cp;

   // If grouping is required, we make a copy of __digits and

   // insert the grouping.

   // To handle the fractional digits, we augment the first group

   // by frac_digits.  If there is only one group, we need first

   // to duplicate it.

   string_type __new_digits(__digits_first, __digits_last);

 #ifdef	__SYMBIAN32__

 	int __numberofseperators = 0;

 	if (__grouping.size()>0)

 	__numberofseperators = (__new_digits.size()/__grouping[0])+1;

 	else

 		__numberofseperators = 0;

   __new_digits.resize(__new_digits.size()+__numberofseperators);

 #endif  

   if (__grouping.size() != 0) {

     if (__grouping.size() == 1)

       __grouping.push_back(__grouping[0]);

     __grouping[0] += __frac_digits;

     _CharT* __data_ptr = __CONST_CAST(_CharT*,__new_digits.data());

     _CharT* __data_end = __data_ptr + __new_digits.size();

     ptrdiff_t __value_length = __insert_grouping(__data_ptr,

 #ifdef	__SYMBIAN32__	    

 	  				         __data_end-__numberofseperators,

 #else

 							__data_end,

 #endif	  				         

 					         __grouping,

 					         __sep,

 					         __plus, __minus, 0);

     __digits_first = __new_digits.begin();

     __digits_last  = __digits_first + __value_length;

   }

   // Determine the amount of padding required, if any.  

 #ifdef	__SYMBIAN32__

 	  int __width        = __str.width(); //width returns signed value.

 #else    

   size_t __width        = __str.width();

 #endif

 #if defined(_STLP_DEBUG) && (defined(__HP_aCC) || (__HP_aCC <= 1))

   size_t __value_length = operator -(__digits_last, __digits_first);

 #else

   size_t __value_length = __digits_last - __digits_first;

 #endif

   size_t __length       = __value_length;

   __length += __sign.size();

   if (__frac_digits != 0)

     ++__length;

   bool __generate_curr = (__str.flags() & ios_base::showbase) !=0;

   if (__generate_curr)

     __length += __curr_sym.size();

   money_base::pattern __format =

     __intl ? (__is_negative ? __punct_intl.neg_format() 

                             : __punct_intl.pos_format())

            : (__is_negative ? __punct.neg_format() 

                             : __punct.pos_format());

   {

     for (int __i = 0; __i < 4; ++__i)

       if (__format.field[__i] == (char) money_base::space)

         ++__length;

   }

   size_t __fill_amt = (int)__length < __width ? __width - __length : 0;

   ios_base::fmtflags __fill_pos = __str.flags() & ios_base::adjustfield;

   if (__fill_amt != 0 &&

       !(__fill_pos & (ios_base::left | ios_base::internal)))

     __s = fill_n(__s, __fill_amt, __fill);

   for (int __i = 0; __i < 4; ++__i) {

     char __ffield = __format.field[__i];

     if (__ffield == money_base::none) {

       if (__fill_amt != 0 && __fill_pos == ios_base::internal)

         __s = fill_n(__s, __fill_amt, __fill);

     }

     else if (__ffield == money_base::space) {

 #ifdef __SYMBIAN32__

 	if(__fill != __space)

 		*__s++ = __fill;

 	else

 #endif		

       *__s++ = __space;

       if (__fill_amt != 0 && __fill_pos == ios_base::internal)

         __s = fill_n(__s, __fill_amt, __fill);

     }

     else if (__ffield == money_base::symbol) {

       if (__generate_curr)

         __s = copy(__curr_sym.begin(), __curr_sym.end(), __s);

     }

     else if (__ffield == money_base::sign) {

       if (__sign.size() != 0)

         *__s++ = __sign[0];

     }

     else if (__ffield == money_base::value) {

       if (__frac_digits == 0)

         __s = copy(__digits_first, __digits_last, __s);

       else {

         if ((int)__value_length <= __frac_digits) {

           *__s++ = __point;

           __s = copy(__digits_first, __digits_last, __s);

           __s =  fill_n(__s, __frac_digits - __value_length, __zero);

         }

         else {

 #ifdef	__SYMBIAN32__

 	  if (__frac_digits>0)

 	  	{

 #endif	  	

           __s = copy(__digits_first, __digits_last - __frac_digits, __s);

           if (__frac_digits != 0) {

             *__s++ = __point;

             __s = copy(__digits_last - __frac_digits, __digits_last, __s);

 #ifdef	__SYMBIAN32__

 	          }

 #endif			  

           }

         }

       }

     }

   } // Close for loop

   // Ouput rest of sign if necessary.

   if (__sign.size() > 1)

     __s = copy(__sign.begin() + 1, __sign.end(), __s);

   if (!(__fill_pos & (ios_base::right | ios_base::internal)))

     __s = fill_n(__s, __fill_amt, __fill);

 #ifdef __SYMBIAN32__

 	__str.width(0);

 #endif

   return __s;

 }

 #ifdef	__SYMBIAN32__

 /*

 template<class _CharT, bool _International>//__DFL_NON_TYPE_PARAM(bool, _International, false)>

 moneypunct<_CharT, _International>::moneypunct(size_t __refs = 0):_BaseFacet(__refs)

 { 

 }*/

 template<class _CharT, bool _International>//__DFL_NON_TYPE_PARAM(bool, _International, false)>

 _CharT        moneypunct<_CharT,_International>::do_decimal_point() const

 {

 	return _CharT('.');

 }

 template<class _CharT, bool _International>//__DFL_NON_TYPE_PARAM(bool, _International, false)>

 _CharT        moneypunct<_CharT,_International>::do_thousands_sep() const

 {

 	return _CharT(',');

 }

 template<class _CharT, bool _International>//__DFL_NON_TYPE_PARAM(bool, _International, false)>

 basic_string<_CharT>      moneypunct<_CharT,_International>::do_curr_symbol()   const

 {

 	return _M_currSym;

 }

 template<class _CharT, bool _International>//__DFL_NON_TYPE_PARAM(bool, _International, false)>

 basic_string<_CharT>      moneypunct<_CharT,_International>::do_positive_sign()   const

 {

 	return _M_psign;

 }

 template<class _CharT, bool _International>//__DFL_NON_TYPE_PARAM(bool, _International, false)>

 basic_string<_CharT>      moneypunct<_CharT,_International>::do_negative_sign()   const

 {

 	return _M_nsign;

 }

 template<class _CharT, bool _International>//__DFL_NON_TYPE_PARAM(bool, _International, false)>

 string      moneypunct<_CharT,_International>::do_grouping()   const

 {

 	return _M_group;

 }

 template<class _CharT, bool _International>//__DFL_NON_TYPE_PARAM(bool, _International, false)>

 money_base::pattern        moneypunct<_CharT,_International>::do_pos_format()   const

 {

 	return _M_pos_format;

 }

 template<class _CharT, bool _International>//__DFL_NON_TYPE_PARAM(bool, _International, false)>

 money_base::pattern        moneypunct<_CharT,_International>::do_neg_format()   const

 {

 	return _M_neg_format;

 }

 template<class _CharT, bool _International>

 int       moneypunct<_CharT,_International>::do_frac_digits()   const

 {

 	return 0;

 }

 //monetary_byname<any>

 template<class _CharT, bool _International>

 _CharT moneypunct_byname<_CharT, _International>::do_decimal_point() const 

   {return _Locale_mon_decimal_pointE(_M_monetary);}

 template<class _CharT, bool _International>

 _CharT moneypunct_byname<_CharT, _International>::do_thousands_sep() const

   {return _Locale_mon_thousands_sepE(_M_monetary);}

 template<class _CharT, bool _International>

 string  moneypunct_byname<_CharT, _International>::do_grouping() const

   {return moneypunct<_CharT,_International>::_M_group;}

 template<class _CharT, bool _International>

 basic_string<_CharT> moneypunct_byname<_CharT, _International>::do_curr_symbol() const

   {return moneypunct<_CharT,_International>::_M_currSym;}

 template<class _CharT, bool _International>

 basic_string<_CharT> moneypunct_byname<_CharT, _International>::do_positive_sign() const

   {return moneypunct<_CharT,_International>::_M_psign;}

 template<class _CharT, bool _International>

 basic_string<_CharT> moneypunct_byname<_CharT, _International>::do_negative_sign() const

   {return moneypunct<_CharT,_International>::_M_nsign;}

 template<class _CharT, bool _International>

 int moneypunct_byname<_CharT, _International>::do_frac_digits() const 

   {return _Locale_int_frac_digitsE(_M_monetary);}

 template<class _CharT, bool _International>

 void moneypunct_byname<_CharT, _International>::Convert_string2_string_chart(basic_string<_CharT> &dst, string src)

 	{

 		int length = src.length();

 		const char* str = src.c_str();

 		for(int i = 0; i<length;i++)

 		{

 			dst.append(1, (_CharT)*str++);

 		}

 	}

 template<class _CharT, bool _International>

 moneypunct_byname<_CharT, _International>::moneypunct_byname(const char * name,

 						  size_t refs):

   moneypunct<_CharT, _International>(refs),

   _M_monetary(__acquire_monetaryE(name))

 {

   if (!_M_monetary)

     locale::_M_throw_runtime_error();

   		moneypunct<_CharT,_International>::_M_group = _Locale_mon_groupingE(_M_monetary);

 		Convert_string2_string_chart(moneypunct<_CharT,_International>::_M_psign, _Locale_positive_signE(_M_monetary));

 		Convert_string2_string_chart(moneypunct<_CharT,_International>::_M_nsign, _Locale_negative_signE(_M_monetary));

 		Convert_string2_string_chart(moneypunct<_CharT,_International>::_M_currSym, _Locale_int_curr_symbolE(_M_monetary));

 }

 template<class _CharT, bool _International>

 moneypunct_byname<_CharT, _International>::~moneypunct_byname()

 {

   __release_monetaryE(_M_monetary);

 }

 #endif

 _STLP_END_NAMESPACE

 # endif /* EXPOSE */

 #endif /* _STLP_MONETARY_C */