/*

 * © 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.

 *

 */ 

# include "stlport_prefix.h"

#include <hash_map>

#include "locale_impl.h"

#include "c_locale.h"

#include "locale_nonclassic.h"

#include <stl/_codecvt.h>

#include <stl/_collate.h>

#include <stl/_ctype.h>

#include <stl/_monetary.h>

#include <stl/_time_facets.h>

#include <stl/_messages_facets.h>

#include <stl/_istream.h>

#include <stl/_num_get.h>

#include <stl/_num_put.h>

#include <algorithm>

// #include <stl/_ctype.h>

#include <stl/_function.h>

#include "c_locale.h"

_STLP_BEGIN_NAMESPACE

_Locale_ctype* __acquire_ctype(const char* name); 

void __release_ctype(_Locale_ctype* cat);

//----------------------------------------------------------------------

// ctype_byname<char>

_STLP_EXP_DECLSPEC ctype_byname<char>::ctype_byname(const char* name, size_t refs)

  : ctype<char>(_M_byname_table+1, false, refs),

  _M_ctype(__acquire_ctype(name))

{

  if (!_M_ctype)

    locale::_M_throw_runtime_error();

  // We have to do this, instead of just pointer twiddling, because

  // ctype_base::mask isn't the same type as _Locale_mask_t.  

  const _Locale_mask_t* p = _Locale_ctype_table(_M_ctype);

   if (!p)

     locale::_M_throw_runtime_error(); 

  for (size_t i = 0; i < table_size + 1; ++i) {

    _Locale_mask_t __m = p[i];

    if (__m & (upper | lower))

      __m |= alpha;

    _M_byname_table[i] = ctype_base::mask(__m);

  }

}

_STLP_EXP_DECLSPEC ctype_byname<char>::~ctype_byname()

{

  __release_ctype(_M_ctype);

}

_STLP_EXP_DECLSPEC char ctype_byname<char>::do_toupper(char c) const 

{

  return _Locale_toupper(_M_ctype, c);

}

_STLP_EXP_DECLSPEC char ctype_byname<char>::do_tolower(char c) const 

{

  return _Locale_tolower(_M_ctype, c);

}

_STLP_EXP_DECLSPEC const char*

ctype_byname<char>::do_toupper(char* first, const char* last) const

{

  for ( ; first != last ; ++first) 

    *first = _Locale_toupper(_M_ctype, *first);

  return last;

}

_STLP_EXP_DECLSPEC const char*

ctype_byname<char>::do_tolower(char* first, const char* last) const

{

  for ( ; first != last ; ++first) 

    *first = _Locale_tolower(_M_ctype, *first);

  return last;

}

// Some helper functions used in ctype<>::scan_is and scan_is_not.

# ifndef _STLP_NO_WCHAR_T

// ctype_byname<wchar_t>

  struct _Ctype_byname_w_is_mask {

    typedef wchar_t argument_type;

    typedef bool    result_type;

    /* ctype_base::mask*/ int  M;

    _Locale_ctype* M_ctp;

    _Ctype_byname_w_is_mask(/* ctype_base::mask */ int m, _Locale_ctype* c) : M((int)m), M_ctp(c) {}

    bool operator()(wchar_t c) const

      { return (M & _Locale_wchar_ctype(M_ctp, c, M)) != 0; }

  };

_STLP_EXP_DECLSPEC ctype_byname<wchar_t>::ctype_byname(const char* name, size_t refs)

  : ctype<wchar_t>(refs),

    _M_ctype(__acquire_ctype(name))

{

  if (!_M_ctype)

    locale::_M_throw_runtime_error();    

}

_STLP_EXP_DECLSPEC ctype_byname<wchar_t>::~ctype_byname()

{

  __release_ctype(_M_ctype);

}

_STLP_EXP_DECLSPEC bool ctype_byname<wchar_t>::do_is(ctype_base::mask  m, wchar_t c) const

{

  return (m & _Locale_wchar_ctype(_M_ctype, c, m)) != 0;

}

_STLP_EXP_DECLSPEC const wchar_t*

ctype_byname<wchar_t>::do_is(const wchar_t* low, const wchar_t* high,

                             ctype_base::mask * m) const

{

  ctype_base::mask all_bits = ctype_base::mask(

    ctype_base::space |

    ctype_base::print |

    ctype_base::cntrl |

    ctype_base::upper |

    ctype_base::lower |

    ctype_base::alpha |

    ctype_base::digit |

    ctype_base::punct |

    ctype_base::xdigit);

  for ( ; low < high; ++low, ++m)

    *m = ctype_base::mask (_Locale_wchar_ctype(_M_ctype, *low, all_bits));

  return high;

}

_STLP_EXP_DECLSPEC const wchar_t*

ctype_byname<wchar_t>

  ::do_scan_is(ctype_base::mask  m, const wchar_t* low, const wchar_t* high) const

{

  return find_if(low, high, _Ctype_byname_w_is_mask(m, _M_ctype));

}

_STLP_EXP_DECLSPEC const wchar_t*

ctype_byname<wchar_t>

  ::do_scan_not(ctype_base::mask  m, const wchar_t* low, const wchar_t* high) const

{

  return find_if(low, high, not1(_Ctype_byname_w_is_mask(m, _M_ctype)));

}

_STLP_EXP_DECLSPEC wchar_t ctype_byname<wchar_t>::do_toupper(wchar_t c) const 

{

  return _Locale_wchar_toupper(_M_ctype, c);

}

_STLP_EXP_DECLSPEC const wchar_t* 

ctype_byname<wchar_t>::do_toupper(wchar_t* low, const wchar_t* high) const

{

  for ( ; low < high; ++low)

    *low = _Locale_wchar_toupper(_M_ctype, *low);

  return high;

}

_STLP_EXP_DECLSPEC wchar_t ctype_byname<wchar_t>::do_tolower(wchar_t c) const 

{

  return _Locale_wchar_tolower(_M_ctype, c);

}

_STLP_EXP_DECLSPEC const wchar_t* 

ctype_byname<wchar_t>::do_tolower(wchar_t* low, const wchar_t* high) const

{

  for ( ; low < high; ++low)

    *low = _Locale_wchar_tolower(_M_ctype, *low);

  return high;

}

# endif /* WCHAR_T */

_STLP_END_NAMESPACE

// # include "collate_byname.cpp"

#include "stl/_collate.h"

#include "c_locale.h"

#include <vector>

_STLP_BEGIN_NAMESPACE

// collate_byname<char>

_Locale_collate* __acquire_collate(const char* name);

void __release_collate(_Locale_collate* cat);

_STLP_EXP_DECLSPEC collate_byname<char>::collate_byname(const char* name, size_t refs)

  : collate<char>(refs),

    _M_collate(__acquire_collate(name))

{

  if (!_M_collate)

    locale::_M_throw_runtime_error();

}

 _STLP_EXP_DECLSPEC collate_byname<char>::~collate_byname()

{

  __release_collate(_M_collate);

}

 _STLP_EXP_DECLSPEC int collate_byname<char>::do_compare(const char* __low1,

                                     const char* __high1,

                                     const char* __low2,

                                     const char* __high2) const {

  return _Locale_strcmp(_M_collate,

                        __low1, __high1 - __low1, 

                        __low2, __high2 - __low2);

}

collate_byname<char>::string_type

 _STLP_EXP_DECLSPEC collate_byname<char>::do_transform(const char* low, const char* high) const {

  size_t n = _Locale_strxfrm(_M_collate,

                             NULL, 0,

                             low, high - low);

  __vector__<char, allocator<char> > buf(n+1);

  _Locale_strxfrm(_M_collate, &buf.front(), n,

                              low, high - low);

   char& __c1 = *(buf.begin());

   char& __c2 = (n == (size_t)-1) ? *(buf.begin() + (high-low-1)) : *(buf.begin() + n);

   //   char& __c2 = *(buf.begin() + n);

   return string_type( &__c1, &__c2 );

}

# ifndef _STLP_NO_WCHAR_T

// collate_byname<wchar_t>

_STLP_EXP_DECLSPEC collate_byname<wchar_t>::collate_byname(const char* name, size_t refs)

  : collate<wchar_t>(refs),

    _M_collate(__acquire_collate(name))

{

  if (!_M_collate)

    locale::_M_throw_runtime_error();

}

 _STLP_EXP_DECLSPEC collate_byname<wchar_t>::~collate_byname() 

{

  __release_collate(_M_collate);

}

 _STLP_EXP_DECLSPEC int collate_byname<wchar_t>::do_compare(const wchar_t* low1,

                                        const wchar_t* high1,

                                        const wchar_t* low2,

                                        const wchar_t* high2) const

{

  return _Locale_strwcmp(_M_collate,

                         low1, high1 - low1, 

                         low2, high2 - low2);

}

 _STLP_EXP_DECLSPEC collate_byname<wchar_t>::string_type

collate_byname<wchar_t>

  ::do_transform(const wchar_t* low, const wchar_t* high) const

{

  size_t n = _Locale_strwxfrm(_M_collate,

                              NULL, 0,

                              low, high - low);

//  __vector__<wchar_t, allocator<wchar_t> > buf(high - low); //gnu bug fix 3/1/07

#ifdef	__SYMBIAN32__

	__vector__<wchar_t, allocator<wchar_t> > buf(n+1);  

  	_Locale_strwxfrm(_M_collate, &buf.front(), n+1,

                               low, high - low);

#else  

  __vector__<wchar_t, allocator<wchar_t> > buf(n);  

  _Locale_strwxfrm(_M_collate, &buf.front(), n,

                               low, high - low);

#endif                               

  wchar_t& __c1 = *(buf.begin());

  wchar_t& __c2 = (n == (size_t)-1) ? *(buf.begin() + (high-low-1)) : *(buf.begin() + n);

  // wchar_t& __c2 = *(buf.begin() + n);

  return string_type( &__c1, &__c2 );

}

# endif /*  _STLP_NO_WCHAR_T */

_STLP_END_NAMESPACE

# ifndef _STLP_NO_MBSTATE_T

#include <stl/_codecvt.h>

#include <stl/_algobase.h>

#include "c_locale.h"

_STLP_BEGIN_NAMESPACE

//----------------------------------------------------------------------

// codecvt_byname<char>

 _STLP_EXP_DECLSPEC codecvt_byname<char, char, mbstate_t>

  ::codecvt_byname(const char* /* name */, size_t refs)

    : codecvt<char, char, mbstate_t>(refs)

{}

 _STLP_EXP_DECLSPEC codecvt_byname<char, char, mbstate_t>::~codecvt_byname() {}

# ifndef _STLP_NO_WCHAR_T

//----------------------------------------------------------------------

// codecvt_byname<wchar_t>

_Locale_ctype* __acquire_ctype(const char* name);

void __release_ctype(_Locale_ctype* cat);

_STLP_EXP_DECLSPEC codecvt_byname<wchar_t, char, mbstate_t>

  ::codecvt_byname(const char* name, size_t refs)

    : codecvt<wchar_t, char, mbstate_t>(refs),

      _M_ctype(__acquire_ctype(name))

{

  if (!_M_ctype)

    locale::_M_throw_runtime_error();

}

 _STLP_EXP_DECLSPEC codecvt_byname<wchar_t, char, mbstate_t>::~codecvt_byname()

{

  __release_ctype(_M_ctype);

}

_STLP_EXP_DECLSPEC codecvt<wchar_t, char, mbstate_t>::result  

codecvt_byname<wchar_t, char, mbstate_t>

  ::do_out(state_type&     state,

           const wchar_t*  from,

           const wchar_t*  from_end,

           const wchar_t*& from_next,

           char*           to,

           char*           to_limit,

           char*&          to_next) const

{

  while (from != from_end) {

    size_t chars_stored = _Locale_wctomb(_M_ctype,

                                         to, to_limit - to, *from,

                                         &state);

    if (chars_stored == (size_t) -1) {

      from_next = from;

      to_next   = to;

      return error;

    }

    else if (chars_stored == (size_t) -2) {

      from_next = from;

      to_next   = to;

      return partial;

    }

    ++from;

    to += chars_stored;

  }

  from_next = from;

  to_next   = to;

  return ok;

}

_STLP_EXP_DECLSPEC codecvt<wchar_t, char, mbstate_t>::result  

codecvt_byname<wchar_t, char, mbstate_t>

  ::do_in(state_type&         state,

          const extern_type*  from,

          const extern_type*  from_end,

          const extern_type*& from_next,

          intern_type*        to,

          intern_type*        to_limit,

          intern_type*&       to_next) const

{

  while (from != from_end) {

    int chars_write = 0;

    size_t chars_read = _Locale_mbtowc(_M_ctype,

                                       to, to_limit-to, from, from_end - from, &chars_write,

                                       &state);

    if (chars_read == (size_t) -1) {

      from_next = from;

      to_next   = to;

      return error;

    }

    if (chars_read == (size_t) -2) {

      from_next = from;

      to_next   = to;

      return partial;

    }

    from += chars_read;

    to += chars_write;

  }

  from_next = from;

  to_next   = to;

  return ok;

}

_STLP_EXP_DECLSPEC codecvt<wchar_t, char, mbstate_t>::result  

codecvt_byname<wchar_t, char, mbstate_t>

  ::do_unshift(state_type&   state,

               extern_type*  to,

               extern_type*  to_limit,

               extern_type*& to_next) const

{

  to_next = to;

  size_t result = _Locale_unshift(_M_ctype, &state,

                                  to, to_limit - to, &to_next);

  if (result == (size_t) -1)

    return error;

  else if (result == (size_t) -2)

    return partial;

  else

#ifdef __ISCPP__

    return /*to_next == to ? noconv :*/ ok;

#else

    return to_next == to ? noconv : ok;

#endif

}

int  _STLP_EXP_DECLSPEC 

codecvt_byname<wchar_t, char, mbstate_t>::do_encoding() const _STLP_NOTHROW

{

  if (_Locale_is_stateless(_M_ctype)) {

    int max_width = _Locale_mb_cur_max(_M_ctype);

    int min_width = _Locale_mb_cur_min(_M_ctype);

    return min_width == max_width ? min_width : 0;

  }

  else

    return -1;

}

_STLP_EXP_DECLSPEC bool codecvt_byname<wchar_t, char, mbstate_t>   

  ::do_always_noconv() const _STLP_NOTHROW

{

  return false;

}

_STLP_EXP_DECLSPEC int   

codecvt_byname<wchar_t, char, mbstate_t>::do_length(

                                                    const state_type&,

                                                    const  extern_type* from, const  extern_type* end,

                                                    size_t mx) const 

{

  return (int)(min) ((size_t) (end - from), mx);

}

_STLP_EXP_DECLSPEC int 

codecvt_byname<wchar_t, char, mbstate_t>::do_max_length() const _STLP_NOTHROW

{

  return _Locale_mb_cur_max(_M_ctype);

}

# endif /* WCHAR_T */

_STLP_END_NAMESPACE

# endif /* MBSTATE_T */

#include "locale_impl.h"

# include <stl/_numpunct.h>

_STLP_BEGIN_NAMESPACE

_Locale_numeric*  _STLP_CALL __acquire_numeric(const char* name);

void  _STLP_CALL __release_numeric(_Locale_numeric* cat);

// numpunct_byname<char>

_STLP_EXP_DECLSPEC numpunct_byname<char>::numpunct_byname(const char* name, size_t refs)

  : numpunct<char>(refs),

    _M_numeric(__acquire_numeric(name))

{

  if (!_M_numeric)

    locale::_M_throw_runtime_error();

#if defined(__LIBSTD_CPP_SYMBIAN32_WSD__) || defined(_STLP_LIBSTD_CPP_NO_STATIC_VAR_)

  numpunct<char>::GetNumPunct_M_truename()  = _Locale_true(_M_numeric);

  numpunct<char>::GetNumPunct_M_falsename() = _Locale_false(_M_numeric);

#else

  _M_truename  = _Locale_true(_M_numeric);

  _M_falsename = _Locale_false(_M_numeric);

#endif

}

_STLP_EXP_DECLSPEC numpunct_byname<char>::~numpunct_byname()

{

  __release_numeric(_M_numeric);

}

_STLP_EXP_DECLSPEC char numpunct_byname<char>::do_decimal_point() const {

  return _Locale_decimal_point(_M_numeric);

}

_STLP_EXP_DECLSPEC char numpunct_byname<char>::do_thousands_sep() const {

  return _Locale_thousands_sep(_M_numeric);

}