libstdc++-v3/src/localename.cc - gcc - Git at Google

 // Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004
 // 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 2, 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.

 // You should have received a copy of the GNU General Public License along
 // with this library; see the file COPYING.  If not, write to the Free
 // Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
 // USA.

 // As a special exception, you may use this file as part of a free software
 // library without restriction.  Specifically, if other files instantiate
 // templates or use macros or inline functions from this file, or you compile
 // this file and link it with other files to produce an executable, this
 // file does not by itself cause the resulting executable to be covered by
 // the GNU General Public License.  This exception does not however
 // invalidate any other reasons why the executable file might be covered by
 // the GNU General Public License.

 #include <clocale>
 #include <cstring>
 #include <locale>

 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 __res;
 		char* __env = std::getenv("LANG");
 		if (!__env || std::strcmp(__env, "") == 0
 		    || std::strcmp(__env, "C") == 0
 		    || std::strcmp(__env, "POSIX") == 0)
 		  __res = "C";
 		else
 		  __res = __env;

 		// Scan the categories looking for the first one
 		// different from LANG.
 		size_t __i = 0;
 		if (__res == "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
 			  && __res != __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;
 		    for (size_t __j = 0; __j < __i; ++__j)
 		      {
 			__str += _S_categories[__j];
 			__str += '=';
 			__str += __res;
 			__str += ';';
 		      }
 		    __str += _S_categories[__i];
 		    __str += '=';
 		    __str += __env;
 		    __str += ';';
 		    __i++;
 		    for (; __i < _S_categories_size; ++__i)
 		      {
 			__env = std::getenv(_S_categories[__i]);
 			if (!__env || std::strcmp(__env, "") == 0)
 			  {
 			    __str += _S_categories[__i];
 			    __str += '=';
 			    __str += __res;
 			    __str += ';';
 			  }
 			else if (std::strcmp(__env, "C") == 0
 				 || std::strcmp(__env, "POSIX") == 0)
 			  {
 			    __str += _S_categories[__i];
 			    __str += "=C;";
 			  }
 			else
 			  {
 			    __str += _S_categories[__i];
 			    __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 (__res == "C")
 		  (_M_impl = _S_classic)->_M_add_reference();
 		else
 		  _M_impl = new _Impl(__res.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);

     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 all the categories.
 	const size_t __len = std::strlen(__s);
 	if (!std::strchr(__s, ';'))
 	  {
 	    for (size_t __i = 0; __i < _S_categories_size; ++__i)
 	      {
 		_M_names[__i] = new char[__len + 1];
 		std::strcpy(_M_names[__i], __s);
 	      }
 	  }
 	else
 	  {
 	    const char* __end = __s;
 	    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;
 		char* __new = new char[__end - __beg + 1];
 		std::memcpy(__new, __beg, __end - __beg);
 		__new[__end - __beg] = '\0';
 		_M_names[__i] = __new;
 	      }
 	  }

 	// 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, __s));
 	_M_init_facet(new moneypunct<char, true>(__cloc, __s));
 	_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>(__cloc, __s));
 	_M_init_facet(new moneypunct<wchar_t, true>(__cloc, __s));
 	_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);
       }
     catch(...)
       {
 	locale::facet::_S_destroy_c_locale(__cloc);
 	this->~_Impl();
 	__throw_exception_again;
       }
   }

   void
   locale::_Impl::
   _M_replace_categories(const _Impl* __imp, category __cat)
   {
     for (size_t __ix = 0; __ix < _S_categories_size; ++__ix)
       {
 	const category __mask = 1 << __ix;
 	if (__mask & __cat)
 	  {
 	    // Need to replace entry in _M_facets with other locale's info.
 	    _M_replace_category(__imp, _S_facet_categories[__ix]);
 	    // If both have names, go ahead and mangle.
 	    if (std::strcmp(_M_names[__ix], "*") != 0
 		&& std::strcmp(__imp->_M_names[__ix], "*") != 0)
 	      {
 		char* __new = new char[std::strlen(__imp->_M_names[__ix]) + 1];
 		std::strcpy(__new, __imp->_M_names[__ix]);
 		delete [] _M_names[__ix];
 		_M_names[__ix] = __new;
 	      }
 	  }
       }
   }
 } // namespace std
	// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004
	// 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 2, 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.

	// You should have received a copy of the GNU General Public License along
	// with this library; see the file COPYING. If not, write to the Free
	// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
	// USA.

	// As a special exception, you may use this file as part of a free software
	// library without restriction. Specifically, if other files instantiate
	// templates or use macros or inline functions from this file, or you compile
	// this file and link it with other files to produce an executable, this
	// file does not by itself cause the resulting executable to be covered by
	// the GNU General Public License. This exception does not however
	// invalidate any other reasons why the executable file might be covered by
	// the GNU General Public License.

	#include <clocale>
	#include <cstring>
	#include <locale>

	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 __res;
	char* __env = std::getenv("LANG");
	if (!__env \|\| std::strcmp(__env, "") == 0
	\|\| std::strcmp(__env, "C") == 0
	\|\| std::strcmp(__env, "POSIX") == 0)
	__res = "C";
	else
	__res = __env;

	// Scan the categories looking for the first one
	// different from LANG.
	size_t __i = 0;
	if (__res == "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
	&& __res != __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;
	for (size_t __j = 0; __j < __i; ++__j)
	{
	__str += _S_categories[__j];
	__str += '=';
	__str += __res;
	__str += ';';
	}
	__str += _S_categories[__i];
	__str += '=';
	__str += __env;
	__str += ';';
	__i++;
	for (; __i < _S_categories_size; ++__i)
	{
	__env = std::getenv(_S_categories[__i]);
	if (!__env \|\| std::strcmp(__env, "") == 0)
	{
	__str += _S_categories[__i];
	__str += '=';
	__str += __res;
	__str += ';';
	}
	else if (std::strcmp(__env, "C") == 0
	\|\| std::strcmp(__env, "POSIX") == 0)
	{
	__str += _S_categories[__i];
	__str += "=C;";
	}
	else
	{
	__str += _S_categories[__i];
	__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 (__res == "C")
	(_M_impl = _S_classic)->_M_add_reference();
	else
	_M_impl = new _Impl(__res.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);

	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 all the categories.
	const size_t __len = std::strlen(__s);
	if (!std::strchr(__s, ';'))
	{
	for (size_t __i = 0; __i < _S_categories_size; ++__i)
	{
	_M_names[__i] = new char[__len + 1];
	std::strcpy(_M_names[__i], __s);
	}
	}
	else
	{
	const char* __end = __s;
	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;
	char* __new = new char[__end - __beg + 1];
	std::memcpy(__new, __beg, __end - __beg);
	__new[__end - __beg] = '\0';
	_M_names[__i] = __new;
	}
	}

	// 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, __s));
	_M_init_facet(new moneypunct<char, true>(__cloc, __s));
	_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>(__cloc, __s));
	_M_init_facet(new moneypunct<wchar_t, true>(__cloc, __s));
	_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);
	}
	catch(...)
	{
	locale::facet::_S_destroy_c_locale(__cloc);
	this->~_Impl();
	__throw_exception_again;
	}
	}

	void
	locale::_Impl::
	_M_replace_categories(const _Impl* __imp, category __cat)
	{
	for (size_t __ix = 0; __ix < _S_categories_size; ++__ix)
	{
	const category __mask = 1 << __ix;
	if (__mask & __cat)
	{
	// Need to replace entry in _M_facets with other locale's info.
	_M_replace_category(__imp, _S_facet_categories[__ix]);
	// If both have names, go ahead and mangle.
	if (std::strcmp(_M_names[__ix], "*") != 0
	&& std::strcmp(__imp->_M_names[__ix], "*") != 0)
	{
	char* __new = new char[std::strlen(__imp->_M_names[__ix]) + 1];
	std::strcpy(__new, __imp->_M_names[__ix]);
	delete [] _M_names[__ix];
	_M_names[__ix] = __new;
	}
	}
	}
	}
	} // namespace std