stl_threads.h (_GLIBCPP_mutex, [...]): Declare in namespace __gnu_cxx.

	* include/bits/stl_threads.h (_GLIBCPP_mutex,
	_GLIBCPP_mutex_init,_GLIBCPP_mutex_address,
	_GLIBCPP_mutex_address_init, _GLIBCPP_once):
	Declare in namespace __gnu_cxx.
	(_STL_mutex_lock::_M_initialize): Qualify __gnu_cxx
	names.
	Adjust copyright.

From-SVN: r58092

libstdc++-v3/ChangeLog

+2002-10-13  Danny Smith  <dannysmith@users.sourceforge.net> 
+
+	* include/bits/stl_threads.h (_GLIBCPP_mutex,
+	_GLIBCPP_mutex_init,_GLIBCPP_mutex_address,
+	_GLIBCPP_mutex_address_init, _GLIBCPP_once):
+	Declare in namespace __gnu_cxx.
+	(_STL_mutex_lock::_M_initialize): Qualify __gnu_cxx
+	names.
+	Adjust copyright.
+
 2002-10-12  Benjamin Kosnik  <bkoz@redhat.com>
 
 	* testsuite/abi_check.cc (hash<string>): Specialize.

libstdc++-v3/include/bits/stl_threads.h

 // Threading support -*- C++ -*-
 
-// Copyright (C) 2001 Free Software Foundation, Inc.
+// Copyright (C) 2001, 2002 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
@@ -126,6 +126,7 @@ namespace std
     return __result;
   }
 #endif
+} //namespace std
 
   // Locking class.  Note that this class *does not have a
   // constructor*.  It must be initialized either statically, with
@@ -141,13 +142,18 @@ namespace std
   // functions, and no private or protected members.
 
 #if !defined(__GTHREAD_MUTEX_INIT) && defined(__GTHREAD_MUTEX_INIT_FUNCTION)
+namespace __gnu_cxx
+{
   extern __gthread_mutex_t _GLIBCPP_mutex;
   extern __gthread_mutex_t *_GLIBCPP_mutex_address;
   extern __gthread_once_t _GLIBCPP_once;
   extern void _GLIBCPP_mutex_init (void);
   extern void _GLIBCPP_mutex_address_init (void);
+}
 #endif
 
+namespace std
+{
   struct _STL_mutex_lock
   {
     // The class must be statically initialized with __STL_MUTEX_INITIALIZER.
@@ -164,22 +170,24 @@ namespace std
       // There should be no code in this path given the usage rules above.
 #elif defined(__GTHREAD_MUTEX_INIT_FUNCTION)
       if (_M_init_flag) return;
-      if (__gthread_once (&_GLIBCPP_once, _GLIBCPP_mutex_init) != 0
+      if (__gthread_once (&__gnu_cxx::_GLIBCPP_once,
+			  __gnu_cxx::_GLIBCPP_mutex_init) != 0
 	  && __gthread_active_p ())
 	abort ();
-      __gthread_mutex_lock (&_GLIBCPP_mutex);
+      __gthread_mutex_lock (&__gnu_cxx::_GLIBCPP_mutex);
       if (!_M_init_flag) 
 	{
 	  // Even though we have a global lock, we use __gthread_once to be
 	  // absolutely certain the _M_lock mutex is only initialized once on
 	  // multiprocessor systems.
-	  _GLIBCPP_mutex_address = &_M_lock;
-	  if (__gthread_once (&_M_once, _GLIBCPP_mutex_address_init) != 0
+	  __gnu_cxx::_GLIBCPP_mutex_address = &_M_lock;
+	  if (__gthread_once (&_M_once,
+			      __gnu_cxx::_GLIBCPP_mutex_address_init) != 0
 	    && __gthread_active_p ())
 	    abort ();
 	  _M_init_flag = 1;
 	}
-      __gthread_mutex_unlock (&_GLIBCPP_mutex);
+      __gthread_mutex_unlock (&__gnu_cxx::_GLIBCPP_mutex);
 #endif
     }