352 lines
10 KiB
C++
352 lines
10 KiB
C++
|
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
|
||
|
// 2006, 2007, 2008, 2009
|
||
|
// Free Software Foundation, Inc.
|
||
|
//
|
||
|
// This file is part of the GNU ISO C++ Library. This library is free
|
||
|
// software; you can redistribute it and/or modify it under the
|
||
|
// terms of the GNU General Public License as published by the
|
||
|
// Free Software Foundation; either version 3, or (at your option)
|
||
|
// any later version.
|
||
|
|
||
|
// This library is distributed in the hope that it will be useful,
|
||
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
|
// GNU General Public License for more details.
|
||
|
|
||
|
// Under Section 7 of GPL version 3, you are granted additional
|
||
|
// permissions described in the GCC Runtime Library Exception, version
|
||
|
// 3.1, as published by the Free Software Foundation.
|
||
|
|
||
|
// You should have received a copy of the GNU General Public License and
|
||
|
// a copy of the GCC Runtime Library Exception along with this program;
|
||
|
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
|
||
|
// <http://www.gnu.org/licenses/>.
|
||
|
|
||
|
#include <clocale>
|
||
|
#include <cstring>
|
||
|
#include <cstdlib>
|
||
|
#include <locale>
|
||
|
|
||
|
_GLIBCXX_BEGIN_NAMESPACE(std)
|
||
|
|
||
|
using namespace __gnu_cxx;
|
||
|
|
||
|
locale::locale(const char* __s) : _M_impl(0)
|
||
|
{
|
||
|
if (__s)
|
||
|
{
|
||
|
_S_initialize();
|
||
|
if (std::strcmp(__s, "C") == 0 || std::strcmp(__s, "POSIX") == 0)
|
||
|
(_M_impl = _S_classic)->_M_add_reference();
|
||
|
else if (std::strcmp(__s, "") != 0)
|
||
|
_M_impl = new _Impl(__s, 1);
|
||
|
else
|
||
|
{
|
||
|
// Get it from the environment.
|
||
|
char* __env = std::getenv("LC_ALL");
|
||
|
// If LC_ALL is set we are done.
|
||
|
if (__env && std::strcmp(__env, "") != 0)
|
||
|
{
|
||
|
if (std::strcmp(__env, "C") == 0
|
||
|
|| std::strcmp(__env, "POSIX") == 0)
|
||
|
(_M_impl = _S_classic)->_M_add_reference();
|
||
|
else
|
||
|
_M_impl = new _Impl(__env, 1);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// LANG may set a default different from "C".
|
||
|
string __lang;
|
||
|
__env = std::getenv("LANG");
|
||
|
if (!__env || std::strcmp(__env, "") == 0
|
||
|
|| std::strcmp(__env, "C") == 0
|
||
|
|| std::strcmp(__env, "POSIX") == 0)
|
||
|
__lang = "C";
|
||
|
else
|
||
|
__lang = __env;
|
||
|
|
||
|
// Scan the categories looking for the first one
|
||
|
// different from LANG.
|
||
|
size_t __i = 0;
|
||
|
if (__lang == "C")
|
||
|
for (; __i < _S_categories_size; ++__i)
|
||
|
{
|
||
|
__env = std::getenv(_S_categories[__i]);
|
||
|
if (__env && std::strcmp(__env, "") != 0
|
||
|
&& std::strcmp(__env, "C") != 0
|
||
|
&& std::strcmp(__env, "POSIX") != 0)
|
||
|
break;
|
||
|
}
|
||
|
else
|
||
|
for (; __i < _S_categories_size; ++__i)
|
||
|
{
|
||
|
__env = std::getenv(_S_categories[__i]);
|
||
|
if (__env && std::strcmp(__env, "") != 0
|
||
|
&& __lang != __env)
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
// If one is found, build the complete string of
|
||
|
// the form LC_CTYPE=xxx;LC_NUMERIC=yyy; and so on...
|
||
|
if (__i < _S_categories_size)
|
||
|
{
|
||
|
string __str;
|
||
|
__str.reserve(128);
|
||
|
for (size_t __j = 0; __j < __i; ++__j)
|
||
|
{
|
||
|
__str += _S_categories[__j];
|
||
|
__str += '=';
|
||
|
__str += __lang;
|
||
|
__str += ';';
|
||
|
}
|
||
|
__str += _S_categories[__i];
|
||
|
__str += '=';
|
||
|
__str += __env;
|
||
|
__str += ';';
|
||
|
++__i;
|
||
|
for (; __i < _S_categories_size; ++__i)
|
||
|
{
|
||
|
__env = std::getenv(_S_categories[__i]);
|
||
|
__str += _S_categories[__i];
|
||
|
if (!__env || std::strcmp(__env, "") == 0)
|
||
|
{
|
||
|
__str += '=';
|
||
|
__str += __lang;
|
||
|
__str += ';';
|
||
|
}
|
||
|
else if (std::strcmp(__env, "C") == 0
|
||
|
|| std::strcmp(__env, "POSIX") == 0)
|
||
|
__str += "=C;";
|
||
|
else
|
||
|
{
|
||
|
__str += '=';
|
||
|
__str += __env;
|
||
|
__str += ';';
|
||
|
}
|
||
|
}
|
||
|
__str.erase(__str.end() - 1);
|
||
|
_M_impl = new _Impl(__str.c_str(), 1);
|
||
|
}
|
||
|
// ... otherwise either an additional instance of
|
||
|
// the "C" locale or LANG.
|
||
|
else if (__lang == "C")
|
||
|
(_M_impl = _S_classic)->_M_add_reference();
|
||
|
else
|
||
|
_M_impl = new _Impl(__lang.c_str(), 1);
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
__throw_runtime_error(__N("locale::locale NULL not valid"));
|
||
|
}
|
||
|
|
||
|
locale::locale(const locale& __base, const char* __s, category __cat)
|
||
|
: _M_impl(0)
|
||
|
{
|
||
|
// NB: There are complicated, yet more efficient ways to do
|
||
|
// this. Building up locales on a per-category way is tedious, so
|
||
|
// let's do it this way until people complain.
|
||
|
locale __add(__s);
|
||
|
_M_coalesce(__base, __add, __cat);
|
||
|
}
|
||
|
|
||
|
locale::locale(const locale& __base, const locale& __add, category __cat)
|
||
|
: _M_impl(0)
|
||
|
{ _M_coalesce(__base, __add, __cat); }
|
||
|
|
||
|
void
|
||
|
locale::_M_coalesce(const locale& __base, const locale& __add,
|
||
|
category __cat)
|
||
|
{
|
||
|
__cat = _S_normalize_category(__cat);
|
||
|
_M_impl = new _Impl(*__base._M_impl, 1);
|
||
|
|
||
|
__try
|
||
|
{ _M_impl->_M_replace_categories(__add._M_impl, __cat); }
|
||
|
__catch(...)
|
||
|
{
|
||
|
_M_impl->_M_remove_reference();
|
||
|
__throw_exception_again;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// Construct named _Impl.
|
||
|
locale::_Impl::
|
||
|
_Impl(const char* __s, size_t __refs)
|
||
|
: _M_refcount(__refs), _M_facets(0), _M_facets_size(_GLIBCXX_NUM_FACETS),
|
||
|
_M_caches(0), _M_names(0)
|
||
|
{
|
||
|
// Initialize the underlying locale model, which also checks to
|
||
|
// see if the given name is valid.
|
||
|
__c_locale __cloc;
|
||
|
locale::facet::_S_create_c_locale(__cloc, __s);
|
||
|
__c_locale __clocm = __cloc;
|
||
|
|
||
|
__try
|
||
|
{
|
||
|
_M_facets = new const facet*[_M_facets_size];
|
||
|
for (size_t __i = 0; __i < _M_facets_size; ++__i)
|
||
|
_M_facets[__i] = 0;
|
||
|
_M_caches = new const facet*[_M_facets_size];
|
||
|
for (size_t __j = 0; __j < _M_facets_size; ++__j)
|
||
|
_M_caches[__j] = 0;
|
||
|
_M_names = new char*[_S_categories_size];
|
||
|
for (size_t __k = 0; __k < _S_categories_size; ++__k)
|
||
|
_M_names[__k] = 0;
|
||
|
|
||
|
// Name the categories.
|
||
|
const char* __smon = __s;
|
||
|
const size_t __len = std::strlen(__s);
|
||
|
if (!std::memchr(__s, ';', __len))
|
||
|
{
|
||
|
_M_names[0] = new char[__len + 1];
|
||
|
std::memcpy(_M_names[0], __s, __len + 1);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
const char* __end = __s;
|
||
|
bool __found_ctype = false;
|
||
|
bool __found_monetary = false;
|
||
|
size_t __ci = 0, __mi = 0;
|
||
|
for (size_t __i = 0; __i < _S_categories_size; ++__i)
|
||
|
{
|
||
|
const char* __beg = std::strchr(__end + 1, '=') + 1;
|
||
|
__end = std::strchr(__beg, ';');
|
||
|
if (!__end)
|
||
|
__end = __s + __len;
|
||
|
_M_names[__i] = new char[__end - __beg + 1];
|
||
|
std::memcpy(_M_names[__i], __beg, __end - __beg);
|
||
|
_M_names[__i][__end - __beg] = '\0';
|
||
|
if (!__found_ctype
|
||
|
&& *(__beg - 2) == 'E' && *(__beg - 3) == 'P')
|
||
|
{
|
||
|
__found_ctype = true;
|
||
|
__ci = __i;
|
||
|
}
|
||
|
else if (!__found_monetary && *(__beg - 2) == 'Y')
|
||
|
{
|
||
|
__found_monetary = true;
|
||
|
__mi = __i;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if (std::strcmp(_M_names[__ci], _M_names[__mi]))
|
||
|
{
|
||
|
__smon = _M_names[__mi];
|
||
|
__clocm = locale::facet::_S_lc_ctype_c_locale(__cloc,
|
||
|
__smon);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// Construct all standard facets and add them to _M_facets.
|
||
|
_M_init_facet(new std::ctype<char>(__cloc, 0, false));
|
||
|
_M_init_facet(new codecvt<char, char, mbstate_t>(__cloc));
|
||
|
_M_init_facet(new numpunct<char>(__cloc));
|
||
|
_M_init_facet(new num_get<char>);
|
||
|
_M_init_facet(new num_put<char>);
|
||
|
_M_init_facet(new std::collate<char>(__cloc));
|
||
|
_M_init_facet(new moneypunct<char, false>(__cloc, 0));
|
||
|
_M_init_facet(new moneypunct<char, true>(__cloc, 0));
|
||
|
_M_init_facet(new money_get<char>);
|
||
|
_M_init_facet(new money_put<char>);
|
||
|
_M_init_facet(new __timepunct<char>(__cloc, __s));
|
||
|
_M_init_facet(new time_get<char>);
|
||
|
_M_init_facet(new time_put<char>);
|
||
|
_M_init_facet(new std::messages<char>(__cloc, __s));
|
||
|
|
||
|
#ifdef _GLIBCXX_USE_WCHAR_T
|
||
|
_M_init_facet(new std::ctype<wchar_t>(__cloc));
|
||
|
_M_init_facet(new codecvt<wchar_t, char, mbstate_t>(__cloc));
|
||
|
_M_init_facet(new numpunct<wchar_t>(__cloc));
|
||
|
_M_init_facet(new num_get<wchar_t>);
|
||
|
_M_init_facet(new num_put<wchar_t>);
|
||
|
_M_init_facet(new std::collate<wchar_t>(__cloc));
|
||
|
_M_init_facet(new moneypunct<wchar_t, false>(__clocm, __smon));
|
||
|
_M_init_facet(new moneypunct<wchar_t, true>(__clocm, __smon));
|
||
|
_M_init_facet(new money_get<wchar_t>);
|
||
|
_M_init_facet(new money_put<wchar_t>);
|
||
|
_M_init_facet(new __timepunct<wchar_t>(__cloc, __s));
|
||
|
_M_init_facet(new time_get<wchar_t>);
|
||
|
_M_init_facet(new time_put<wchar_t>);
|
||
|
_M_init_facet(new std::messages<wchar_t>(__cloc, __s));
|
||
|
#endif
|
||
|
locale::facet::_S_destroy_c_locale(__cloc);
|
||
|
if (__clocm != __cloc)
|
||
|
locale::facet::_S_destroy_c_locale(__clocm);
|
||
|
}
|
||
|
__catch(...)
|
||
|
{
|
||
|
locale::facet::_S_destroy_c_locale(__cloc);
|
||
|
if (__clocm != __cloc)
|
||
|
locale::facet::_S_destroy_c_locale(__clocm);
|
||
|
this->~_Impl();
|
||
|
__throw_exception_again;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void
|
||
|
locale::_Impl::
|
||
|
_M_replace_categories(const _Impl* __imp, category __cat)
|
||
|
{
|
||
|
category __mask = 1;
|
||
|
if (!_M_names[0] || !__imp->_M_names[0])
|
||
|
{
|
||
|
if (_M_names[0])
|
||
|
{
|
||
|
delete [] _M_names[0];
|
||
|
_M_names[0] = 0; // Unnamed.
|
||
|
}
|
||
|
|
||
|
for (size_t __ix = 0; __ix < _S_categories_size; ++__ix, __mask <<= 1)
|
||
|
{
|
||
|
if (__mask & __cat)
|
||
|
// Need to replace entry in _M_facets with other locale's info.
|
||
|
_M_replace_category(__imp, _S_facet_categories[__ix]);
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
if (!_M_names[1])
|
||
|
{
|
||
|
// A full set of _M_names must be prepared, all identical
|
||
|
// to _M_names[0] to begin with. Then, below, a few will
|
||
|
// be replaced by the corresponding __imp->_M_names. I.e.,
|
||
|
// not a "simple" locale anymore (see locale::operator==).
|
||
|
const size_t __len = std::strlen(_M_names[0]) + 1;
|
||
|
for (size_t __i = 1; __i < _S_categories_size; ++__i)
|
||
|
{
|
||
|
_M_names[__i] = new char[__len];
|
||
|
std::memcpy(_M_names[__i], _M_names[0], __len);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
for (size_t __ix = 0; __ix < _S_categories_size; ++__ix, __mask <<= 1)
|
||
|
{
|
||
|
if (__mask & __cat)
|
||
|
{
|
||
|
// Need to replace entry in _M_facets with other locale's info.
|
||
|
_M_replace_category(__imp, _S_facet_categories[__ix]);
|
||
|
|
||
|
// FIXME: Hack for libstdc++/29217: the numerical encodings
|
||
|
// of the time and collate categories are swapped vs the
|
||
|
// order of the names in locale::_S_categories. We'd like to
|
||
|
// adjust the former (the latter is dictated by compatibility
|
||
|
// with glibc) but we can't for binary compatibility.
|
||
|
size_t __ix_name = __ix;
|
||
|
if (__ix == 2 || __ix == 3)
|
||
|
__ix_name = 5 - __ix;
|
||
|
|
||
|
char* __src = __imp->_M_names[__ix_name] ?
|
||
|
__imp->_M_names[__ix_name] : __imp->_M_names[0];
|
||
|
const size_t __len = std::strlen(__src) + 1;
|
||
|
char* __new = new char[__len];
|
||
|
std::memcpy(__new, __src, __len);
|
||
|
delete [] _M_names[__ix_name];
|
||
|
_M_names[__ix_name] = __new;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
_GLIBCXX_END_NAMESPACE
|