obtained gcc-4.6.4.tar.bz2 from upstream website;upstream

verified gcc-4.6.4.tar.bz2.sig;
imported gcc-4.6.4 source tree from verified upstream tarball.

downloading a git-generated archive based on the 'upstream' tag
should provide you with a source tree that is binary identical
to the one extracted from the above tarball.

if you have obtained the source via the command 'git clone',
however, do note that line-endings of files in your working
directory might differ from line-endings of the respective
files in the upstream repository.

1 files changed, 354 insertions, 0 deletions

diff --git a/libstdc++-v3/src/localename.cc b/libstdc++-v3/src/localename.cc
new file mode 100644
index 000000000..52e228281
--- /dev/null
+++ b/libstdc++-v3/src/localename.cc
@@ -0,0 +1,354 @@
+// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
+// 2006, 2007, 2008, 2009, 2010
+// 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>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+  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_VERSION
+} // namespace