Remove using-declarations that add std names to __gnu_cxx

These using-declarations appear to have been added for simplicity when
moving the non-standard extensions from namespace std to namespace
__gnu_cxx. Dumping all these names into namespace __gnu_cxx allows
unportable uses like __gnu_cxx::size_t and __gnu_cxx::pair, which serve
no useful purpose.

This patch removes most of the using-declarations from namespace scope,
then either qualifies names as needed or adds using-declarations at
block scope or typedefs at class scope.

	* include/backward/hashtable.h (size_t, ptrdiff_t)
	(forward_iterator_tag, input_iterator_tag, _Construct, _Destroy)
	(distance, vector, pair, __iterator_category): Remove
	using-declarations that add these names to namespace __gnu_cxx.
	* include/ext/bitmap_allocator.h (size_t, ptrdiff_t): Likewise.
	* include/ext/debug_allocator.h (size_t): Likewise.
	* include/ext/functional (size_t, unary_function, binary_function)
	(mem_fun1_t, const_mem_fun1_t, mem_fun1_ref_t, const_mem_fun1_ref_t):
	Likewise.
	* include/ext/malloc_allocator.h (size_t, ptrdiff_t): Likewise.
	* include/ext/memory (ptrdiff_t, pair, __iterator_category): Likewise.
	* include/ext/mt_allocator.h (size_t, ptrdiff_t): Likewise.
	* include/ext/new_allocator.h (size_t, ptrdiff_t): Likewise.
	* include/ext/numeric (iota): Fix outdated comment.
	* include/ext/pool_allocator.h (size_t, ptrdiff_t): Likewise.
	* include/ext/rb_tree (_Rb_tree, allocator): Likewise.
	* include/ext/rope (size_t, ptrdiff_t, allocator, _Destroy): Likewise.
	* include/ext/ropeimpl.h (size_t, printf, basic_ostream)
	(__throw_length_error, _Destroy, std::__uninitialized_fill_n_a):
	Likewise.
	* include/ext/slist (size_t, ptrdiff_t, _Construct, _Destroy)
	(allocator, __true_type, __false_type): Likewise.

From-SVN: r271807

15 files changed, 413 insertions, 405 deletions

diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog
index 3fe8494..2786b67 100644
--- a/libstdc++-v3/ChangeLog
+++ b/libstdc++-v3/ChangeLog
@@ -1,3 +1,28 @@
+2019-05-31  Jonathan Wakely  <jwakely@redhat.com>
+
+	* include/backward/hashtable.h (size_t, ptrdiff_t)
+	(forward_iterator_tag, input_iterator_tag, _Construct, _Destroy)
+	(distance, vector, pair, __iterator_category): Remove
+	using-declarations that add these names to namespace __gnu_cxx.
+	* include/ext/bitmap_allocator.h (size_t, ptrdiff_t): Likewise.
+	* include/ext/debug_allocator.h (size_t): Likewise.
+	* include/ext/functional (size_t, unary_function, binary_function)
+	(mem_fun1_t, const_mem_fun1_t, mem_fun1_ref_t, const_mem_fun1_ref_t):
+	Likewise.
+	* include/ext/malloc_allocator.h (size_t, ptrdiff_t): Likewise.
+	* include/ext/memory (ptrdiff_t, pair, __iterator_category): Likewise.
+	* include/ext/mt_allocator.h (size_t, ptrdiff_t): Likewise.
+	* include/ext/new_allocator.h (size_t, ptrdiff_t): Likewise.
+	* include/ext/numeric (iota): Fix outdated comment.
+	* include/ext/pool_allocator.h (size_t, ptrdiff_t): Likewise.
+	* include/ext/rb_tree (_Rb_tree, allocator): Likewise.
+	* include/ext/rope (size_t, ptrdiff_t, allocator, _Destroy): Likewise.
+	* include/ext/ropeimpl.h (size_t, printf, basic_ostream)
+	(__throw_length_error, _Destroy, std::__uninitialized_fill_n_a):
+	Likewise.
+	* include/ext/slist (size_t, ptrdiff_t, _Construct, _Destroy)
+	(allocator, __true_type, __false_type): Likewise.
+
 2019-05-31  Antony Polukhin  <antoshkka@gmail.com>
 
 	PR libstdc++/71579
diff --git a/libstdc++-v3/include/backward/hashtable.h b/libstdc++-v3/include/backward/hashtable.h
index 28c487a..df6ad85 100644
--- a/libstdc++-v3/include/backward/hashtable.h
+++ b/libstdc++-v3/include/backward/hashtable.h
@@ -69,17 +69,6 @@ namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
 {
 _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
-  using std::size_t;
-  using std::ptrdiff_t;
-  using std::forward_iterator_tag;
-  using std::input_iterator_tag;
-  using std::_Construct;
-  using std::_Destroy;
-  using std::distance;
-  using std::vector;
-  using std::pair;
-  using std::__iterator_category;
-
   template<class _Val>
     struct _Hashtable_node
     {
@@ -112,10 +101,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 					_ExtractKey, _EqualKey, _Alloc>
         const_iterator;
       typedef _Hashtable_node<_Val> _Node;
-      typedef forward_iterator_tag iterator_category;
+      typedef std::forward_iterator_tag iterator_category;
       typedef _Val value_type;
-      typedef ptrdiff_t difference_type;
-      typedef size_t size_type;
+      typedef std::ptrdiff_t difference_type;
+      typedef std::size_t size_type;
       typedef _Val& reference;
       typedef _Val* pointer;
       
@@ -164,10 +153,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
         const_iterator;
       typedef _Hashtable_node<_Val> _Node;
 
-      typedef forward_iterator_tag iterator_category;
+      typedef std::forward_iterator_tag iterator_category;
       typedef _Val value_type;
-      typedef ptrdiff_t difference_type;
-      typedef size_t size_type;
+      typedef std::ptrdiff_t difference_type;
+      typedef std::size_t size_type;
       typedef const _Val& reference;
       typedef const _Val* pointer;
       
@@ -272,8 +261,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       typedef _HashFcn hasher;
       typedef _EqualKey key_equal;
 
-      typedef size_t            size_type;
-      typedef ptrdiff_t         difference_type;
+      typedef std::size_t            size_type;
+      typedef std::ptrdiff_t         difference_type;
       typedef value_type*       pointer;
       typedef const value_type* const_pointer;
       typedef value_type&       reference;
@@ -299,7 +288,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     private:
       typedef typename _Alloc::template rebind<_Node>::other _Node_Alloc;
       typedef typename _Alloc::template rebind<_Node*>::other _Nodeptr_Alloc;
-      typedef vector<_Node*, _Nodeptr_Alloc> _Vector_type;
+      typedef std::vector<_Node*, _Nodeptr_Alloc> _Vector_type;
 
       _Node_Alloc _M_node_allocator;
 
@@ -445,7 +434,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	return __result;
       }
 
-      pair<iterator, bool>
+      std::pair<iterator, bool>
       insert_unique(const value_type& __obj)
       {
 	resize(_M_num_elements + 1);
@@ -459,7 +448,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	return insert_equal_noresize(__obj);
       }
 
-      pair<iterator, bool>
+      std::pair<iterator, bool>
       insert_unique_noresize(const value_type& __obj);
 
       iterator
@@ -468,17 +457,17 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       template<class _InputIterator>
         void
         insert_unique(_InputIterator __f, _InputIterator __l)
-        { insert_unique(__f, __l, __iterator_category(__f)); }
+        { insert_unique(__f, __l, std::__iterator_category(__f)); }
 
       template<class _InputIterator>
         void
         insert_equal(_InputIterator __f, _InputIterator __l)
-        { insert_equal(__f, __l, __iterator_category(__f)); }
+        { insert_equal(__f, __l, std::__iterator_category(__f)); }
 
       template<class _InputIterator>
         void
         insert_unique(_InputIterator __f, _InputIterator __l,
-		      input_iterator_tag)
+		      std::input_iterator_tag)
         {
 	  for ( ; __f != __l; ++__f)
 	    insert_unique(*__f);
@@ -487,7 +476,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       template<class _InputIterator>
         void
         insert_equal(_InputIterator __f, _InputIterator __l,
-		     input_iterator_tag)
+		     std::input_iterator_tag)
         {
 	  for ( ; __f != __l; ++__f)
 	    insert_equal(*__f);
@@ -496,9 +485,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       template<class _ForwardIterator>
         void
         insert_unique(_ForwardIterator __f, _ForwardIterator __l,
-		      forward_iterator_tag)
+		      std::forward_iterator_tag)
         {
-	  size_type __n = distance(__f, __l);
+	  size_type __n = std::distance(__f, __l);
 	  resize(_M_num_elements + __n);
 	  for ( ; __n > 0; --__n, ++__f)
 	    insert_unique_noresize(*__f);
@@ -507,9 +496,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       template<class _ForwardIterator>
         void
         insert_equal(_ForwardIterator __f, _ForwardIterator __l,
-		     forward_iterator_tag)
+		     std::forward_iterator_tag)
         {
-	  size_type __n = distance(__f, __l);
+	  size_type __n = std::distance(__f, __l);
 	  resize(_M_num_elements + __n);
 	  for ( ; __n > 0; --__n, ++__f)
 	    insert_equal_noresize(*__f);
@@ -555,10 +544,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	return __result;
       }
 
-      pair<iterator, iterator>
+      std::pair<iterator, iterator>
       equal_range(const key_type& __key);
 
-      pair<const_iterator, const_iterator>
+      std::pair<const_iterator, const_iterator>
       equal_range(const key_type& __key) const;
 
       size_type
@@ -605,11 +594,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       { return _M_bkt_num_key(_M_get_key(__obj)); }
 
       size_type
-      _M_bkt_num_key(const key_type& __key, size_t __n) const
+      _M_bkt_num_key(const key_type& __key, std::size_t __n) const
       { return _M_hash(__key) % __n; }
 
       size_type
-      _M_bkt_num(const value_type& __obj, size_t __n) const
+      _M_bkt_num(const value_type& __obj, std::size_t __n) const
       { return _M_bkt_num_key(_M_get_key(__obj), __n); }
 
       _Node*
@@ -712,7 +701,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       if (__ht1._M_buckets.size() != __ht2._M_buckets.size())
 	return false;
 
-      for (size_t __n = 0; __n < __ht1._M_buckets.size(); ++__n)
+      for (std::size_t __n = 0; __n < __ht1._M_buckets.size(); ++__n)
 	{
 	  _Node* __cur1 = __ht1._M_buckets[__n];
 	  _Node* __cur2 = __ht2._M_buckets[__n];
@@ -757,7 +746,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     { __ht1.swap(__ht2); }
 
   template<class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All>
-    pair<typename hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>::iterator, bool>
+    std::pair<typename hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>::iterator,
+	      bool>
     hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>::
     insert_unique_noresize(const value_type& __obj)
     {
@@ -766,13 +756,13 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       
       for (_Node* __cur = __first; __cur; __cur = __cur->_M_next)
 	if (_M_equals(_M_get_key(__cur->_M_val), _M_get_key(__obj)))
-	  return pair<iterator, bool>(iterator(__cur, this), false);
+	  return std::pair<iterator, bool>(iterator(__cur, this), false);
       
       _Node* __tmp = _M_new_node(__obj);
       __tmp->_M_next = __first;
       _M_buckets[__n] = __tmp;
       ++_M_num_elements;
-      return pair<iterator, bool>(iterator(__tmp, this), true);
+      return std::pair<iterator, bool>(iterator(__tmp, this), true);
     }
 
   template<class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All>
@@ -822,12 +812,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     }
 
   template<class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All>
-    pair<typename hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>::iterator,
-	 typename hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>::iterator>
+    std::pair<typename hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>::iterator,
+	      typename hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>::iterator>
     hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>::
     equal_range(const key_type& __key)
     {
-      typedef pair<iterator, iterator> _Pii;
+      typedef std::pair<iterator, iterator> _Pii;
       const size_type __n = _M_bkt_num_key(__key);
 
       for (_Node* __first = _M_buckets[__n]; __first;
@@ -848,12 +838,13 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     }
 
   template<class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All>
-    pair<typename hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>::const_iterator,
-	 typename hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>::const_iterator>
+    std::pair<
+	typename hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>::const_iterator,
+	typename hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>::const_iterator>
     hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>::
     equal_range(const key_type& __key) const
     {
-      typedef pair<const_iterator, const_iterator> _Pii;
+      typedef std::pair<const_iterator, const_iterator> _Pii;
       const size_type __n = _M_bkt_num_key(__key);
 
       for (const _Node* __first = _M_buckets[__n]; __first;
diff --git a/libstdc++-v3/include/ext/bitmap_allocator.h b/libstdc++-v3/include/ext/bitmap_allocator.h
index 532bad2..27cfb07 100644
--- a/libstdc++-v3/include/ext/bitmap_allocator.h
+++ b/libstdc++-v3/include/ext/bitmap_allocator.h
@@ -46,9 +46,6 @@ namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
 {
 _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
-  using std::size_t;
-  using std::ptrdiff_t;
-
   namespace __detail
   {
     /** @class  __mini_vector bitmap_allocator.h bitmap_allocator.h
@@ -77,8 +74,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	typedef _Tp* pointer;
 	typedef _Tp& reference;
 	typedef const _Tp& const_reference;
-	typedef size_t size_type;
-	typedef ptrdiff_t difference_type;
+	typedef std::size_t size_type;
+	typedef std::ptrdiff_t difference_type;
 	typedef pointer iterator;
 
       private:
@@ -223,13 +220,13 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       struct __mv_iter_traits<_Tp*>
       {
 	typedef _Tp value_type;
-	typedef ptrdiff_t difference_type;
+	typedef std::ptrdiff_t difference_type;
       };
 
     enum 
       { 
 	bits_per_byte = 8,
-	bits_per_block = sizeof(size_t) * size_t(bits_per_byte) 
+	bits_per_block = sizeof(std::size_t) * std::size_t(bits_per_byte)
       };
 
     template<typename _ForwardIterator, typename _Tp, typename _Compare>
@@ -265,7 +262,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
      *  passed to the function.
      */
     template<typename _AddrPair>
-      inline size_t
+      inline std::size_t
       __num_blocks(_AddrPair __ap)
       { return (__ap.second - __ap.first) + 1; }
 
@@ -273,9 +270,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
      *  passed to the function.
      */
     template<typename _AddrPair>
-      inline size_t
+      inline std::size_t
       __num_bitmaps(_AddrPair __ap)
-      { return __num_blocks(__ap) / size_t(bits_per_block); }
+      { return __num_blocks(__ap) / std::size_t(bits_per_block); }
 
     // _Tp should be a pointer type.
     template<typename _Tp>
@@ -336,7 +333,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	typedef typename __detail::__mini_vector<_Block_pair> _BPVector;
 	typedef typename _BPVector::difference_type _Counter_type;
 
-	size_t* _M_pbitmap;
+	std::size_t* _M_pbitmap;
 	_Counter_type _M_data_offset;
 
       public:
@@ -346,6 +343,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	bool 
 	operator()(_Block_pair __bp) throw()
 	{
+	  using std::size_t;
 	  // Set the _rover to the last physical location bitmap,
 	  // which is the bitmap which belongs to the first free
 	  // block. Thus, the bitmaps are in exact reverse order of
@@ -377,13 +375,13 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	  return false;
 	}
     
-	size_t*
+	std::size_t*
 	_M_get() const throw()
 	{ return _M_pbitmap; }
 
 	_Counter_type
 	_M_offset() const throw()
-	{ return _M_data_offset * size_t(bits_per_block); }
+	{ return _M_data_offset * std::size_t(bits_per_block); }
       };
 
     /** @class  _Bitmap_counter bitmap_allocator.h bitmap_allocator.h
@@ -402,8 +400,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	typedef _Tp pointer;
 
 	_BPVector& _M_vbp;
-	size_t* _M_curr_bmap;
-	size_t* _M_last_bmap_in_block;
+	std::size_t* _M_curr_bmap;
+	std::size_t* _M_last_bmap_in_block;
 	_Index_type _M_curr_index;
     
       public:
@@ -424,7 +422,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	    }
 
 	  _M_curr_index = __index;
-	  _M_curr_bmap = reinterpret_cast<size_t*>
+	  _M_curr_bmap = reinterpret_cast<std::size_t*>
 	    (_M_vbp[_M_curr_index].first) - 1;
 	  
 	  _GLIBCXX_DEBUG_ASSERT(__index <= (long)_M_vbp.size() - 1);
@@ -432,14 +430,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	  _M_last_bmap_in_block = _M_curr_bmap
 	    - ((_M_vbp[_M_curr_index].second 
 		- _M_vbp[_M_curr_index].first + 1) 
-	       / size_t(bits_per_block) - 1);
+	       / std::size_t(bits_per_block) - 1);
 	}
     
 	// Dangerous Function! Use with extreme care. Pass to this
 	// function ONLY those values that are known to be correct,
 	// otherwise this will mess up big time.
 	void
-	_M_set_internal_bitmap(size_t* __new_internal_marker) throw()
+	_M_set_internal_bitmap(std::size_t* __new_internal_marker) throw()
 	{ _M_curr_bmap = __new_internal_marker; }
     
 	bool
@@ -461,7 +459,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	  return *this;
 	}
     
-	size_t*
+	std::size_t*
 	_M_get() const throw()
 	{ return _M_curr_bmap; }
     
@@ -472,8 +470,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	_Index_type
 	_M_offset() const throw()
 	{
-	  return size_t(bits_per_block)
-	    * ((reinterpret_cast<size_t*>(this->_M_base()) 
+	  return std::size_t(bits_per_block)
+	    * ((reinterpret_cast<std::size_t*>(this->_M_base())
 		- _M_curr_bmap) - 1);
 	}
     
@@ -486,9 +484,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
      *  corresponding bit in the bit-map.
      */
     inline void 
-    __bit_allocate(size_t* __pbmap, size_t __pos) throw()
+    __bit_allocate(std::size_t* __pbmap, std::size_t __pos) throw()
     {
-      size_t __mask = 1 << __pos;
+      std::size_t __mask = 1 << __pos;
       __mask = ~__mask;
       *__pbmap &= __mask;
     }
@@ -497,18 +495,18 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
      *  corresponding bit in the bit-map.
      */
     inline void 
-    __bit_free(size_t* __pbmap, size_t __pos) throw()
+    __bit_free(std::size_t* __pbmap, std::size_t __pos) throw()
     {
-      size_t __mask = 1 << __pos;
+      std::size_t __mask = 1 << __pos;
       *__pbmap |= __mask;
     }
   } // namespace __detail
 
   /** @brief  Generic Version of the bsf instruction.
    */
-  inline size_t 
-  _Bit_scan_forward(size_t __num)
-  { return static_cast<size_t>(__builtin_ctzl(__num)); }
+  inline std::size_t
+  _Bit_scan_forward(std::size_t __num)
+  { return static_cast<std::size_t>(__builtin_ctzl(__num)); }
 
   /** @class  free_list bitmap_allocator.h bitmap_allocator.h
    *
@@ -518,7 +516,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   class free_list
   {
   public:
-    typedef size_t* 				value_type;
+    typedef std::size_t* 			value_type;
     typedef __detail::__mini_vector<value_type> vector_type;
     typedef vector_type::iterator 		iterator;
     typedef __mutex				__mutex_type;
@@ -527,8 +525,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     struct _LT_pointer_compare
     {
       bool
-      operator()(const size_t* __pui, 
-		 const size_t __cui) const throw()
+      operator()(const std::size_t* __pui,
+		 const std::size_t __cui) const throw()
       { return *__pui < __cui; }
     };
 
@@ -559,7 +557,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
      *  or larger blocks from the free list.
      */
     void
-    _M_validate(size_t* __addr) throw()
+    _M_validate(std::size_t* __addr) throw()
     {
       vector_type& __free_list = _M_get_free_list();
       const vector_type::size_type __max_size = 64;
@@ -605,10 +603,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
      *  false.
      */
     bool 
-    _M_should_i_give(size_t __block_size, 
-		     size_t __required_size) throw()
+    _M_should_i_give(std::size_t __block_size,
+		     std::size_t __required_size) throw()
     {
-      const size_t __max_wastage_percentage = 36;
+      const std::size_t __max_wastage_percentage = 36;
       if (__block_size >= __required_size && 
 	  (((__block_size - __required_size) * 100 / __block_size)
 	   < __max_wastage_percentage))
@@ -625,14 +623,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
      *  by a call to the _M_get function.
      */
     inline void 
-    _M_insert(size_t* __addr) throw()
+    _M_insert(std::size_t* __addr) throw()
     {
 #if defined __GTHREADS
       __scoped_lock __bfl_lock(_M_get_mutex());
 #endif
       // Call _M_validate to decide what should be done with
       // this particular free list.
-      this->_M_validate(reinterpret_cast<size_t*>(__addr) - 1);
+      this->_M_validate(reinterpret_cast<std::size_t*>(__addr) - 1);
       // See discussion as to why this is 1!
     }
     
@@ -644,8 +642,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
      *  @return  A pointer to the new memory block of size at least
      *  equal to that requested.
      */
-    size_t*
-    _M_get(size_t __sz) _GLIBCXX_THROW(std::bad_alloc);
+    std::size_t*
+    _M_get(std::size_t __sz) _GLIBCXX_THROW(std::bad_alloc);
 
     /** @brief  This function just clears the internal Free List, and
      *  gives back all the memory to the OS.
@@ -684,8 +682,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     class bitmap_allocator : private free_list
     {
     public:
-      typedef size_t    		size_type;
-      typedef ptrdiff_t 		difference_type;
+      typedef std::size_t    		size_type;
+      typedef std::ptrdiff_t 		difference_type;
       typedef _Tp*        		pointer;
       typedef const _Tp*  		const_pointer;
       typedef _Tp&        		reference;
@@ -706,7 +704,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 #endif
 
     private:
-      template<size_t _BSize, size_t _AlignSize>
+      template<std::size_t _BSize, std::size_t _AlignSize>
         struct aligned_size
 	{
 	  enum
@@ -765,6 +763,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       void 
       _S_refill_pool() _GLIBCXX_THROW(std::bad_alloc)
       {
+	using std::size_t;
 #if defined _GLIBCXX_DEBUG
 	_S_check_for_free_blocks();
 #endif
@@ -798,7 +797,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       }
 
       static _BPVector _S_mem_blocks;
-      static size_t _S_block_size;
+      static std::size_t _S_block_size;
       static __detail::_Bitmap_counter<_Alloc_block*> _S_last_request;
       static typename _BPVector::size_type _S_last_dealloc_index;
 #if defined __GTHREADS
@@ -823,6 +822,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       pointer 
       _M_allocate_single_object() _GLIBCXX_THROW(std::bad_alloc)
       {
+	using std::size_t;
 #if defined __GTHREADS
 	__scoped_lock __bit_lock(_S_mut);
 #endif
@@ -913,6 +913,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       void 
       _M_deallocate_single_object(pointer __p) throw()
       {
+	using std::size_t;
 #if defined __GTHREADS
 	__scoped_lock __bit_lock(_S_mut);
 #endif
@@ -1109,8 +1110,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     bitmap_allocator<_Tp>::_S_mem_blocks;
 
   template<typename _Tp>
-    size_t bitmap_allocator<_Tp>::_S_block_size = 
-    2 * size_t(__detail::bits_per_block);
+    std::size_t bitmap_allocator<_Tp>::_S_block_size
+      = 2 * std::size_t(__detail::bits_per_block);
 
   template<typename _Tp>
     typename bitmap_allocator<_Tp>::_BPVector::size_type 
diff --git a/libstdc++-v3/include/ext/debug_allocator.h b/libstdc++-v3/include/ext/debug_allocator.h
index c5fc57e..08f0eb2 100644
--- a/libstdc++-v3/include/ext/debug_allocator.h
+++ b/libstdc++-v3/include/ext/debug_allocator.h
@@ -50,8 +50,6 @@ namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
 {
 _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
-  using std::size_t;
-
   /**
    *  @brief  A meta-allocator with debugging bits.
    *  @ingroup allocators
@@ -103,7 +101,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
       size_type _S_extra()
       {
-	const size_t __obj_size = sizeof(value_type);
+	const std::size_t __obj_size = sizeof(value_type);
 	return (sizeof(size_type) + __obj_size - 1) / __obj_size; 
       }
 
diff --git a/libstdc++-v3/include/ext/functional b/libstdc++-v3/include/ext/functional
index 372ea65..84aef7c 100644
--- a/libstdc++-v3/include/ext/functional
+++ b/libstdc++-v3/include/ext/functional
@@ -64,14 +64,6 @@ namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
 {
 _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
-  using std::size_t;
-  using std::unary_function;
-  using std::binary_function;
-  using std::mem_fun1_t;
-  using std::const_mem_fun1_t;
-  using std::mem_fun1_ref_t;
-  using std::const_mem_fun1_ref_t;
-
   /** The @c identity_element functions are not part of the C++
    *  standard; SGI provided them as an extension.  Its argument is an
    *  operation, and its return value is the identity element for that
@@ -123,8 +115,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   /// An \link SGIextensions SGI extension \endlink.
   template <class _Operation1, class _Operation2>
     class unary_compose
-    : public unary_function<typename _Operation2::argument_type,
-			    typename _Operation1::result_type>
+    : public std::unary_function<typename _Operation2::argument_type,
+				 typename _Operation1::result_type>
     {
     protected:
       _Operation1 _M_fn1;
@@ -148,8 +140,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   /// An \link SGIextensions SGI extension \endlink.
   template <class _Operation1, class _Operation2, class _Operation3>
     class binary_compose
-    : public unary_function<typename _Operation2::argument_type,
-			    typename _Operation1::result_type>
+    : public std::unary_function<typename _Operation2::argument_type,
+				 typename _Operation1::result_type>
     {
     protected:
       _Operation1 _M_fn1;
@@ -209,7 +201,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
   // extension documented next
   template <class _Arg1, class _Arg2>
-    struct _Project1st : public binary_function<_Arg1, _Arg2, _Arg1>
+    struct _Project1st : public std::binary_function<_Arg1, _Arg2, _Arg1>
     {
       _Arg1
       operator()(const _Arg1& __x, const _Arg2&) const
@@ -217,7 +209,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     };
 
   template <class _Arg1, class _Arg2>
-    struct _Project2nd : public binary_function<_Arg1, _Arg2, _Arg2>
+    struct _Project2nd : public std::binary_function<_Arg1, _Arg2, _Arg2>
     {
       _Arg2
       operator()(const _Arg1&, const _Arg2& __y) const
@@ -350,12 +342,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
    *  @ingroup SGIextensions
    */
   class subtractive_rng
-  : public unary_function<unsigned int, unsigned int>
+  : public std::unary_function<unsigned int, unsigned int>
   {
   private:
     unsigned int _M_table[55];
-    size_t _M_index1;
-    size_t _M_index2;
+    std::size_t _M_index1;
+    std::size_t _M_index2;
 
   public:
     /// Returns a number less than the argument.
@@ -373,10 +365,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     {
       unsigned int __k = 1;
       _M_table[54] = __seed;
-      size_t __i;
+      std::size_t __i;
       for (__i = 0; __i < 54; __i++)
 	{
-	  size_t __ii = (21 * (__i + 1) % 55) - 1;
+	  std::size_t __ii = (21 * (__i + 1) % 55) - 1;
 	  _M_table[__ii] = __k;
 	  __k = __seed - __k;
 	  __seed = _M_table[__ii];
@@ -404,24 +396,24 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   // the C++ standard.
   
   template <class _Ret, class _Tp, class _Arg>
-    inline mem_fun1_t<_Ret, _Tp, _Arg>
+    inline std::mem_fun1_t<_Ret, _Tp, _Arg>
     mem_fun1(_Ret (_Tp::*__f)(_Arg))
-    { return mem_fun1_t<_Ret, _Tp, _Arg>(__f); }
+    { return std::mem_fun1_t<_Ret, _Tp, _Arg>(__f); }
 
   template <class _Ret, class _Tp, class _Arg>
-    inline const_mem_fun1_t<_Ret, _Tp, _Arg>
+    inline std::const_mem_fun1_t<_Ret, _Tp, _Arg>
     mem_fun1(_Ret (_Tp::*__f)(_Arg) const)
-    { return const_mem_fun1_t<_Ret, _Tp, _Arg>(__f); }
+    { return std::const_mem_fun1_t<_Ret, _Tp, _Arg>(__f); }
 
   template <class _Ret, class _Tp, class _Arg>
-    inline mem_fun1_ref_t<_Ret, _Tp, _Arg>
+    inline std::mem_fun1_ref_t<_Ret, _Tp, _Arg>
     mem_fun1_ref(_Ret (_Tp::*__f)(_Arg))
-    { return mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }
+    { return std::mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }
 
   template <class _Ret, class _Tp, class _Arg>
-    inline const_mem_fun1_ref_t<_Ret, _Tp, _Arg>
+    inline std::const_mem_fun1_ref_t<_Ret, _Tp, _Arg>
     mem_fun1_ref(_Ret (_Tp::*__f)(_Arg) const)
-    { return const_mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }
+    { return std::const_mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }
 
 _GLIBCXX_END_NAMESPACE_VERSION
 } // namespace
diff --git a/libstdc++-v3/include/ext/malloc_allocator.h b/libstdc++-v3/include/ext/malloc_allocator.h
index e225923..1bc7637 100644
--- a/libstdc++-v3/include/ext/malloc_allocator.h
+++ b/libstdc++-v3/include/ext/malloc_allocator.h
@@ -42,9 +42,6 @@ namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
 {
 _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
-  using std::size_t;
-  using std::ptrdiff_t;
-
   /**
    *  @brief  An allocator that uses malloc.
    *  @ingroup allocators
@@ -57,8 +54,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     class malloc_allocator
     {
     public:
-      typedef size_t     size_type;
-      typedef ptrdiff_t  difference_type;
+      typedef std::size_t     size_type;
+      typedef std::ptrdiff_t  difference_type;
       typedef _Tp*       pointer;
       typedef const _Tp* const_pointer;
       typedef _Tp&       reference;
@@ -141,9 +138,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       max_size() const _GLIBCXX_USE_NOEXCEPT 
       {
 #if __PTRDIFF_MAX__ < __SIZE_MAX__
-	return size_t(__PTRDIFF_MAX__) / sizeof(_Tp);
+	return std::size_t(__PTRDIFF_MAX__) / sizeof(_Tp);
 #else
-	return size_t(-1) / sizeof(_Tp);
+	return std::size_t(-1) / sizeof(_Tp);
 #endif
       }
 
diff --git a/libstdc++-v3/include/ext/memory b/libstdc++-v3/include/ext/memory
index 1f37cb1..2912dcb 100644
--- a/libstdc++-v3/include/ext/memory
+++ b/libstdc++-v3/include/ext/memory
@@ -65,13 +65,10 @@ namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
 {
 _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
-  using std::ptrdiff_t;
-  using std::pair;
-  using std::__iterator_category;
   using std::_Temporary_buffer;
 
   template<typename _InputIter, typename _Size, typename _ForwardIter>
-    pair<_InputIter, _ForwardIter>
+    std::pair<_InputIter, _ForwardIter>
     __uninitialized_copy_n(_InputIter __first, _Size __count,
 			   _ForwardIter __result, std::input_iterator_tag)
     {
@@ -80,7 +77,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	{
 	  for (; __count > 0 ; --__count, ++__first, ++__cur)
 	    std::_Construct(&*__cur, *__first);
-	  return pair<_InputIter, _ForwardIter>(__first, __cur);
+	  return std::pair<_InputIter, _ForwardIter>(__first, __cur);
 	}
       __catch(...)
 	{
@@ -90,22 +87,24 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     }
 
   template<typename _RandomAccessIter, typename _Size, typename _ForwardIter>
-    inline pair<_RandomAccessIter, _ForwardIter>
+    inline std::pair<_RandomAccessIter, _ForwardIter>
     __uninitialized_copy_n(_RandomAccessIter __first, _Size __count,
 			   _ForwardIter __result,
 			   std::random_access_iterator_tag)
     {
       _RandomAccessIter __last = __first + __count;
-      return (pair<_RandomAccessIter, _ForwardIter>
+      return (std::pair<_RandomAccessIter, _ForwardIter>
 	      (__last, std::uninitialized_copy(__first, __last, __result)));
     }
 
   template<typename _InputIter, typename _Size, typename _ForwardIter>
-    inline pair<_InputIter, _ForwardIter>
+    inline std::pair<_InputIter, _ForwardIter>
     __uninitialized_copy_n(_InputIter __first, _Size __count,
 			   _ForwardIter __result)
-    { return __gnu_cxx::__uninitialized_copy_n(__first, __count, __result,
-					       __iterator_category(__first)); }
+    {
+      return __gnu_cxx::__uninitialized_copy_n(__first, __count, __result,
+	  std::__iterator_category(__first));
+    }
 
   /**
    *  @brief Copies the range [first,last) into result.
@@ -118,18 +117,20 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
    *  Like copy(), but does not require an initialized output range.
   */
   template<typename _InputIter, typename _Size, typename _ForwardIter>
-    inline pair<_InputIter, _ForwardIter>
+    inline std::pair<_InputIter, _ForwardIter>
     uninitialized_copy_n(_InputIter __first, _Size __count,
 			 _ForwardIter __result)
-    { return __gnu_cxx::__uninitialized_copy_n(__first, __count, __result,
-					       __iterator_category(__first)); }
+    {
+      return __gnu_cxx::__uninitialized_copy_n(__first, __count, __result,
+	  std::__iterator_category(__first));
+    }
 
 
   // An alternative version of uninitialized_copy_n that constructs
   // and destroys objects with a user-provided allocator.
   template<typename _InputIter, typename _Size, typename _ForwardIter,
            typename _Allocator>
-    pair<_InputIter, _ForwardIter>
+    std::pair<_InputIter, _ForwardIter>
     __uninitialized_copy_n_a(_InputIter __first, _Size __count,
 			     _ForwardIter __result,
 			     _Allocator __alloc)
@@ -139,7 +140,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	{
 	  for (; __count > 0 ; --__count, ++__first, ++__cur)
 	    __alloc.construct(&*__cur, *__first);
-	  return pair<_InputIter, _ForwardIter>(__first, __cur);
+	  return std::pair<_InputIter, _ForwardIter>(__first, __cur);
 	}
       __catch(...)
 	{
@@ -150,7 +151,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
   template<typename _InputIter, typename _Size, typename _ForwardIter,
            typename _Tp>
-    inline pair<_InputIter, _ForwardIter>
+    inline std::pair<_InputIter, _ForwardIter>
     __uninitialized_copy_n_a(_InputIter __first, _Size __count,
 			     _ForwardIter __result,
 			     std::allocator<_Tp>)
diff --git a/libstdc++-v3/include/ext/mt_allocator.h b/libstdc++-v3/include/ext/mt_allocator.h
index 43e84f4..003d792 100644
--- a/libstdc++-v3/include/ext/mt_allocator.h
+++ b/libstdc++-v3/include/ext/mt_allocator.h
@@ -42,8 +42,6 @@ namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
 {
 _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
-  using std::size_t;
-  using std::ptrdiff_t;
 
   typedef void (*__destroy_handler)(void*);
 
@@ -53,11 +51,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     // Using short int as type for the binmap implies we are never
     // caching blocks larger than 32768 with this allocator.
     typedef unsigned short int _Binmap_type;
+    typedef std::size_t size_t;
 
     // Variables used to configure the behavior of the allocator,
     // assigned and explained in detail below.
     struct _Tune
-     {
+    {
       // Compile time constants for the default _Tune values.
       enum { _S_align = 8 };
       enum { _S_max_bytes = 128 };
@@ -477,7 +476,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       
       static pool_type&
       _S_get_pool()
-      { 
+      {
+	using std::size_t;
 	// Sane defaults for the _PoolTp.
 	typedef typename pool_type::_Block_record _Block_record;
 	const static size_t __a = (__alignof__(_Tp) >= sizeof(_Block_record)
@@ -570,8 +570,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     class __mt_alloc_base 
     {
     public:
-      typedef size_t                    size_type;
-      typedef ptrdiff_t                 difference_type;
+      typedef std::size_t               size_type;
+      typedef std::ptrdiff_t            difference_type;
       typedef _Tp*                      pointer;
       typedef const _Tp*                const_pointer;
       typedef _Tp&                      reference;
@@ -594,7 +594,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
       size_type
       max_size() const _GLIBCXX_USE_NOEXCEPT 
-      { return size_t(-1) / sizeof(_Tp); }
+      { return size_type(-1) / sizeof(_Tp); }
 
 #if __cplusplus >= 201103L
       template<typename _Up, typename... _Args>
@@ -639,8 +639,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     class __mt_alloc : public __mt_alloc_base<_Tp>
     {
     public:
-      typedef size_t                    	size_type;
-      typedef ptrdiff_t                 	difference_type;
+      typedef std::size_t                    	size_type;
+      typedef std::ptrdiff_t                 	difference_type;
       typedef _Tp*                      	pointer;
       typedef const _Tp*                	const_pointer;
       typedef _Tp&                      	reference;
@@ -705,7 +705,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       // Requests larger than _M_max_bytes are handled by operator
       // new/delete directly.
       __pool_type& __pool = __policy_type::_S_get_pool();
-      const size_t __bytes = __n * sizeof(_Tp);
+      const size_type __bytes = __n * sizeof(_Tp);
       if (__pool._M_check_threshold(__bytes))
 	{
 	  void* __ret = ::operator new(__bytes);
@@ -713,8 +713,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	}
       
       // Round up to power of 2 and figure out which bin to use.
-      const size_t __which = __pool._M_get_binmap(__bytes);
-      const size_t __thread_id = __pool._M_get_thread_id();
+      const size_type __which = __pool._M_get_binmap(__bytes);
+      const size_type __thread_id = __pool._M_get_thread_id();
       
       // Find out if we have blocks on our freelist.  If so, go ahead
       // and use them directly without having to lock anything.
@@ -758,7 +758,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	  // Requests larger than _M_max_bytes are handled by
 	  // operators new/delete directly.
 	  __pool_type& __pool = __policy_type::_S_get_pool();
-	  const size_t __bytes = __n * sizeof(_Tp);
+	  const size_type __bytes = __n * sizeof(_Tp);
 	  if (__pool._M_check_threshold(__bytes))
 	    ::operator delete(__p);
 	  else
diff --git a/libstdc++-v3/include/ext/new_allocator.h b/libstdc++-v3/include/ext/new_allocator.h
index f1ff7da..ee69953 100644
--- a/libstdc++-v3/include/ext/new_allocator.h
+++ b/libstdc++-v3/include/ext/new_allocator.h
@@ -41,9 +41,6 @@ namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
 {
 _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
-  using std::size_t;
-  using std::ptrdiff_t;
-
   /**
    *  @brief  An allocator that uses global new, as per [20.4].
    *  @ingroup allocators
@@ -58,8 +55,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     class new_allocator
     {
     public:
-      typedef size_t     size_type;
-      typedef ptrdiff_t  difference_type;
+      typedef std::size_t     size_type;
+      typedef std::ptrdiff_t  difference_type;
       typedef _Tp*       pointer;
       typedef const _Tp* const_pointer;
       typedef _Tp&       reference;
@@ -140,9 +137,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       max_size() const _GLIBCXX_USE_NOEXCEPT
       {
 #if __PTRDIFF_MAX__ < __SIZE_MAX__
-	return size_t(__PTRDIFF_MAX__) / sizeof(_Tp);
+	return std::size_t(__PTRDIFF_MAX__) / sizeof(_Tp);
 #else
-	return size_t(-1) / sizeof(_Tp);
+	return std::size_t(-1) / sizeof(_Tp);
 #endif
       }
 
diff --git a/libstdc++-v3/include/ext/numeric b/libstdc++-v3/include/ext/numeric
index 72529cb..3581b47 100644
--- a/libstdc++-v3/include/ext/numeric
+++ b/libstdc++-v3/include/ext/numeric
@@ -131,7 +131,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
    *  @ingroup SGIextensions
    *  @doctodo
   */
-  // iota is not part of the C++ standard.  It is an extension.
+  // iota is not part of the standard until C++11.  It is an extension.
   template<typename _ForwardIter, typename _Tp>
     void
     iota(_ForwardIter __first, _ForwardIter __last, _Tp __value)
diff --git a/libstdc++-v3/include/ext/pool_allocator.h b/libstdc++-v3/include/ext/pool_allocator.h
index 4b23727..96685ec 100644
--- a/libstdc++-v3/include/ext/pool_allocator.h
+++ b/libstdc++-v3/include/ext/pool_allocator.h
@@ -57,9 +57,6 @@ namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
 {
 _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
-  using std::size_t;
-  using std::ptrdiff_t;
-
   /**
    *  @brief  Base class for __pool_alloc.
    *
@@ -77,6 +74,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
    */
     class __pool_alloc_base
     {
+      typedef std::size_t size_t;
     protected:
 
       enum { _S_align = 8 };
@@ -129,8 +127,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       static _Atomic_word	    _S_force_new;
 
     public:
-      typedef size_t     size_type;
-      typedef ptrdiff_t  difference_type;
+      typedef std::size_t     size_type;
+      typedef std::ptrdiff_t  difference_type;
       typedef _Tp*       pointer;
       typedef const _Tp* const_pointer;
       typedef _Tp&       reference;
@@ -166,7 +164,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
       size_type
       max_size() const _GLIBCXX_USE_NOEXCEPT 
-      { return size_t(-1) / sizeof(_Tp); }
+      { return std::size_t(-1) / sizeof(_Tp); }
 
 #if __cplusplus >= 201103L
       template<typename _Up, typename... _Args>
@@ -213,6 +211,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     _GLIBCXX_NODISCARD _Tp*
     __pool_alloc<_Tp>::allocate(size_type __n, const void*)
     {
+      using std::size_t;
       pointer __ret = 0;
       if (__builtin_expect(__n != 0, true))
 	{
@@ -266,6 +265,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     void
     __pool_alloc<_Tp>::deallocate(pointer __p, size_type __n)
     {
+      using std::size_t;
       if (__builtin_expect(__n != 0 && __p != 0, true))
 	{
 #if __cpp_aligned_new
diff --git a/libstdc++-v3/include/ext/rb_tree b/libstdc++-v3/include/ext/rb_tree
index 3e38fa6..9358766 100644
--- a/libstdc++-v3/include/ext/rb_tree
+++ b/libstdc++-v3/include/ext/rb_tree
@@ -64,9 +64,6 @@ namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
 {
 _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
-  using std::_Rb_tree;
-  using std::allocator;
-
   // Class rb_tree is not part of the C++ standard.  It is provided for
   // compatibility with the HP STL.
 
@@ -76,11 +73,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
    *  @doctodo
    */
   template <class _Key, class _Value, class _KeyOfValue, class _Compare,
-	    class _Alloc = allocator<_Value> >
+	    class _Alloc = std::allocator<_Value> >
     struct rb_tree
-    : public _Rb_tree<_Key, _Value, _KeyOfValue, _Compare, _Alloc>
+    : public std::_Rb_tree<_Key, _Value, _KeyOfValue, _Compare, _Alloc>
     {
-      typedef _Rb_tree<_Key, _Value, _KeyOfValue, _Compare, _Alloc> _Base;
+      typedef std::_Rb_tree<_Key, _Value, _KeyOfValue, _Compare, _Alloc> _Base;
       typedef typename _Base::allocator_type allocator_type;
 
       rb_tree(const _Compare& __comp = _Compare(),
diff --git a/libstdc++-v3/include/ext/rope b/libstdc++-v3/include/ext/rope
index 127d113..0788dee 100644
--- a/libstdc++-v3/include/ext/rope
+++ b/libstdc++-v3/include/ext/rope
@@ -73,11 +73,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     enum _Tag {_S_leaf, _S_concat, _S_substringfn, _S_function};
   } // namespace __detail
 
-  using std::size_t;
-  using std::ptrdiff_t;
-  using std::allocator;
-  using std::_Destroy;
-
   // See libstdc++/36832.
   template<typename _ForwardIterator, typename _Allocator>
     void
@@ -91,8 +86,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   template<typename _ForwardIterator, typename _Tp>
     inline void
     _Destroy_const(_ForwardIterator __first,
-		   _ForwardIterator __last, allocator<_Tp>)
-    { _Destroy(__first, __last); }
+		   _ForwardIterator __last, std::allocator<_Tp>)
+    { std::_Destroy(__first, __last); }
 
   // The _S_eos function is used for those functions that
   // convert to/from C-like strings to detect the end of the string.
@@ -153,7 +148,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       virtual ~char_producer() { }
 
       virtual void
-      operator()(size_t __start_pos, size_t __len,
+      operator()(std::size_t __start_pos, std::size_t __len,
 		 _CharT* __buffer) = 0;
       // Buffer should really be an arbitrary output iterator.
       // That way we could flatten directly into an ostream, etc.
@@ -175,7 +170,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   // behave a little like basic_ostringstream<sequence::value_type> and a
   // little like containers.
 
-  template<class _Sequence, size_t _Buf_sz = 100>
+  template<class _Sequence, std::size_t _Buf_sz = 100>
     class sequence_buffer
     : public std::iterator<std::output_iterator_tag, void, void, void, void>
     {
@@ -184,7 +179,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     protected:
       _Sequence* _M_prefix;
       value_type _M_buffer[_Buf_sz];
-      size_t     _M_buf_count;
+      std::size_t _M_buf_count;
     public:
 
       void
@@ -252,12 +247,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       }
       
       void
-      append(value_type* __s, size_t __len)
+      append(value_type* __s, std::size_t __len)
       {
 	if (__len + _M_buf_count <= _Buf_sz)
 	  {
-	    size_t __i = _M_buf_count;
-	    for (size_t __j = 0; __j < __len; __i++, __j++)
+	    std::size_t __i = _M_buf_count;
+	    for (std::size_t __j = 0; __j < __len; __i++, __j++)
 	      _M_buffer[__i] = __s[__j];
 	    _M_buf_count += __len;
 	  }
@@ -271,7 +266,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       }
 
       sequence_buffer&
-      write(value_type* __s, size_t __len)
+      write(value_type* __s, std::size_t __len)
       {
 	append(__s, __len);
 	return *this;
@@ -317,13 +312,13 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       virtual ~_Rope_char_consumer() { }
   
       virtual bool
-      operator()(const _CharT* __buffer, size_t __len) = 0;
+      operator()(const _CharT* __buffer, std::size_t __len) = 0;
     };
   
   // First a lot of forward declarations.  The standard seems to require
   // much stricter "declaration before use" than many of the implementations
   // that preceded it.
-  template<class _CharT, class _Alloc = allocator<_CharT> >
+  template<class _CharT, class _Alloc = std::allocator<_CharT> >
     class rope;
   
   template<class _CharT, class _Alloc>
@@ -358,16 +353,16 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   template<class _CharT, class _Alloc>
     _Rope_const_iterator<_CharT, _Alloc>
     operator-(const _Rope_const_iterator<_CharT, _Alloc>& __x,
-	      ptrdiff_t __n);
+	      std::ptrdiff_t __n);
 
   template<class _CharT, class _Alloc>
     _Rope_const_iterator<_CharT, _Alloc>
     operator+(const _Rope_const_iterator<_CharT, _Alloc>& __x,
-	      ptrdiff_t __n);
+	      std::ptrdiff_t __n);
 
   template<class _CharT, class _Alloc>
     _Rope_const_iterator<_CharT, _Alloc>
-    operator+(ptrdiff_t __n,
+    operator+(std::ptrdiff_t __n,
 	      const _Rope_const_iterator<_CharT, _Alloc>& __x);
 
   template<class _CharT, class _Alloc>
@@ -381,21 +376,21 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	      const _Rope_const_iterator<_CharT, _Alloc>& __y);
   
   template<class _CharT, class _Alloc>
-    ptrdiff_t
+    std::ptrdiff_t
     operator-(const _Rope_const_iterator<_CharT, _Alloc>& __x,
 	      const _Rope_const_iterator<_CharT, _Alloc>& __y);
 
   template<class _CharT, class _Alloc>
     _Rope_iterator<_CharT, _Alloc>
-    operator-(const _Rope_iterator<_CharT, _Alloc>& __x, ptrdiff_t __n);
+    operator-(const _Rope_iterator<_CharT, _Alloc>& __x, std::ptrdiff_t __n);
 
   template<class _CharT, class _Alloc>
     _Rope_iterator<_CharT, _Alloc>
-    operator+(const _Rope_iterator<_CharT, _Alloc>& __x, ptrdiff_t __n);
+    operator+(const _Rope_iterator<_CharT, _Alloc>& __x, std::ptrdiff_t __n);
 
   template<class _CharT, class _Alloc>
     _Rope_iterator<_CharT, _Alloc>
-    operator+(ptrdiff_t __n, const _Rope_iterator<_CharT, _Alloc>& __x);
+    operator+(std::ptrdiff_t __n, const _Rope_iterator<_CharT, _Alloc>& __x);
 
   template<class _CharT, class _Alloc>
     bool
@@ -408,7 +403,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	      const _Rope_iterator<_CharT, _Alloc>& __y);
 
   template<class _CharT, class _Alloc>
-    ptrdiff_t
+    std::ptrdiff_t
     operator-(const _Rope_iterator<_CharT, _Alloc>& __x,
 	      const _Rope_iterator<_CharT, _Alloc>& __y);
 
@@ -453,7 +448,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   struct _Refcount_Base
   {
     // The type _RC_t
-    typedef size_t _RC_t;
+    typedef std::size_t _RC_t;
     
     // The data member _M_ref_count
     volatile _RC_t _M_ref_count;
@@ -548,6 +543,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     struct _Rope_rep_base
     : public _Alloc
     {
+      typedef std::size_t size_type;
       typedef _Alloc allocator_type;
 
       allocator_type
@@ -562,17 +558,17 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       _M_get_allocator() const
       { return *static_cast<const _Alloc*>(this); }
 
-      _Rope_rep_base(size_t __size, const allocator_type&)
+      _Rope_rep_base(size_type __size, const allocator_type&)
       : _M_size(__size) { }
 
-      size_t _M_size;
+      size_type _M_size;
 
 # define __ROPE_DEFINE_ALLOC(_Tp, __name) \
         typedef typename \
           _Alloc::template rebind<_Tp>::other __name##Alloc; \
-        static _Tp* __name##_allocate(size_t __n) \
+        static _Tp* __name##_allocate(size_type __n) \
           { return __name##Alloc().allocate(__n); } \
-        static void __name##_deallocate(_Tp *__p, size_t __n) \
+        static void __name##_deallocate(_Tp *__p, size_type __n) \
           { __name##Alloc().deallocate(__p, __n); }
       __ROPE_DEFINE_ALLOCS(_Alloc)
 # undef __ROPE_DEFINE_ALLOC
@@ -603,11 +599,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
                         /* the same memory as the data field.       */
       typedef typename _Rope_rep_base<_CharT, _Alloc>::allocator_type
         allocator_type;
+      typedef std::size_t size_type;
 
       using _Rope_rep_base<_CharT, _Alloc>::get_allocator;
       using _Rope_rep_base<_CharT, _Alloc>::_M_get_allocator;
 
-      _Rope_RopeRep(__detail::_Tag __t, int __d, bool __b, size_t __size,
+      _Rope_RopeRep(__detail::_Tag __t, int __d, bool __b, size_type __size,
 		    const allocator_type& __a)
       : _Rope_rep_base<_CharT, _Alloc>(__size, __a),
 #ifndef __GC
@@ -626,7 +623,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       _M_incr () { }
 #endif
       static void
-      _S_free_string(__GC_CONST _CharT*, size_t __len,
+      _S_free_string(__GC_CONST _CharT*, size_type __len,
 		     allocator_type& __a);
 #define __STL_FREE_STRING(__s, __l, __a) _S_free_string(__s, __l, __a);
                         // Deallocate data section of a leaf.
@@ -688,6 +685,7 @@ protected:
     struct _Rope_RopeLeaf
     : public _Rope_RopeRep<_CharT, _Alloc>
     {
+      typedef std::size_t size_type;
     public:
       // Apparently needed by VC++
       // The data fields of leaves are allocated with some
@@ -695,10 +693,10 @@ protected:
       // character types, to hold a trailing eos character.
       enum { _S_alloc_granularity = 8 };
       
-      static size_t
-      _S_rounded_up_size(size_t __n)
+      static size_type
+      _S_rounded_up_size(size_type __n)
       {
-        size_t __size_with_eos;
+        size_type __size_with_eos;
 	
         if (_S_is_basic_char_type((_CharT*)0))
 	  __size_with_eos = __n + 1;
@@ -708,8 +706,8 @@ protected:
 	return __size_with_eos;
 #else
 	// Allow slop for in-place expansion.
-	return ((__size_with_eos + size_t(_S_alloc_granularity) - 1)
-		&~ (size_t(_S_alloc_granularity) - 1));
+	return ((__size_with_eos + size_type(_S_alloc_granularity) - 1)
+		&~ (size_type(_S_alloc_granularity) - 1));
 #endif
       }
       __GC_CONST _CharT* _M_data; /* Not necessarily 0 terminated. */
@@ -720,7 +718,7 @@ protected:
       typedef typename _Rope_rep_base<_CharT,_Alloc>::allocator_type
         allocator_type;
 
-      _Rope_RopeLeaf(__GC_CONST _CharT* __d, size_t __size,
+      _Rope_RopeLeaf(__GC_CONST _CharT* __d, size_type __size,
 		     const allocator_type& __a)
       : _Rope_RopeRep<_CharT, _Alloc>(__detail::_S_leaf, 0, true,
 				      __size, __a), _M_data(__d)
@@ -810,7 +808,7 @@ protected:
     typedef typename _Rope_rep_base<_CharT, _Alloc>::allocator_type
       allocator_type;
 
-      _Rope_RopeFunction(char_producer<_CharT>* __f, size_t __size,
+      _Rope_RopeFunction(char_producer<_CharT>* __f, std::size_t __size,
                         bool __d, const allocator_type& __a)
       : _Rope_RopeRep<_CharT, _Alloc>(__detail::_S_function, 0, true, __size, __a)
 	, _M_fn(__f)
@@ -852,13 +850,14 @@ protected:
     : public _Rope_RopeFunction<_CharT, _Alloc>,
       public char_producer<_CharT>
     {
+      typedef std::size_t size_type;
     public:
       // XXX this whole class should be rewritten.
       _Rope_RopeRep<_CharT,_Alloc>* _M_base;      // not 0
-      size_t _M_start;
+      size_type _M_start;
 
       virtual void
-      operator()(size_t __start_pos, size_t __req_len,
+      operator()(size_type __start_pos, size_type __req_len,
 		 _CharT* __buffer)
       {
         switch(_M_base->_M_tag)
@@ -887,8 +886,8 @@ protected:
       typedef typename _Rope_rep_base<_CharT, _Alloc>::allocator_type
         allocator_type;
 
-      _Rope_RopeSubstring(_Rope_RopeRep<_CharT, _Alloc>* __b, size_t __s,
-                          size_t __l, const allocator_type& __a)
+      _Rope_RopeSubstring(_Rope_RopeRep<_CharT, _Alloc>* __b, size_type __s,
+                          size_type __l, const allocator_type& __a)
       : _Rope_RopeFunction<_CharT, _Alloc>(this, __l, false, __a),
         char_producer<_CharT>(), _M_base(__b), _M_start(__s)
       {
@@ -966,12 +965,12 @@ protected:
 #endif
       typedef _Rope_RopeRep<_CharT, _Alloc> _RopeRep;
       typedef rope<_CharT, _Alloc> _My_rope;
-      size_t _M_pos;
+      std::size_t _M_pos;
       _CharT _M_current;
       bool _M_current_valid;
       _My_rope* _M_root;     // The whole rope.
     public:
-      _Rope_char_ref_proxy(_My_rope* __r, size_t __p)
+      _Rope_char_ref_proxy(_My_rope* __r, std::size_t __p)
       :  _M_pos(__p), _M_current(), _M_current_valid(false), _M_root(__r) { }
 
       _Rope_char_ref_proxy(const _Rope_char_ref_proxy& __x)
@@ -982,7 +981,7 @@ protected:
       // expression.  We claim that's not possible without calling
       // a copy constructor or generating reference to a proxy
       // reference.  We declare the latter to have undefined semantics.
-      _Rope_char_ref_proxy(_My_rope* __r, size_t __p, _CharT __c)
+      _Rope_char_ref_proxy(_My_rope* __r, std::size_t __p, _CharT __c)
       : _M_pos(__p), _M_current(__c), _M_current_valid(true), _M_root(__r) { }
 
       inline operator _CharT () const;
@@ -1012,7 +1011,7 @@ protected:
     {
       // XXX this class should be rewritten.
       friend class _Rope_char_ref_proxy<_CharT, _Alloc>;
-      size_t _M_pos;
+      std::size_t _M_pos;
       rope<_CharT,_Alloc>* _M_root;     // The whole rope.
     public:
       _Rope_char_ptr_proxy(const _Rope_char_ref_proxy<_CharT,_Alloc>& __x)
@@ -1064,9 +1063,9 @@ protected:
     protected:
       enum { _S_path_cache_len = 4 }; // Must be <= 9.
       enum { _S_iterator_buf_len = 15 };
-      size_t _M_current_pos;
+      std::size_t _M_current_pos;
       _RopeRep* _M_root;     // The whole rope.
-      size_t _M_leaf_pos;    // Starting position for current leaf
+      std::size_t _M_leaf_pos; // Starting position for current leaf
       __GC_CONST _CharT* _M_buf_start;
                              // Buffer possibly
                              // containing current char.
@@ -1107,13 +1106,13 @@ protected:
                                         // cache is valid for previous posn.
       _Rope_iterator_base() { }
 
-      _Rope_iterator_base(_RopeRep* __root, size_t __pos)
+      _Rope_iterator_base(_RopeRep* __root, std::size_t __pos)
       : _M_current_pos(__pos), _M_root(__root), _M_buf_ptr(0) { }
 
-      void _M_incr(size_t __n);
-      void _M_decr(size_t __n);
+      void _M_incr(std::size_t __n);
+      void _M_decr(std::size_t __n);
     public:
-      size_t
+      std::size_t
       index() const
       { return _M_current_pos; }
     
@@ -1141,7 +1140,7 @@ protected:
     protected:
       typedef _Rope_RopeRep<_CharT, _Alloc> _RopeRep;
       // The one from the base class may not be directly visible.
-      _Rope_const_iterator(const _RopeRep* __root, size_t __pos)
+      _Rope_const_iterator(const _RopeRep* __root, std::size_t __pos)
       : _Rope_iterator_base<_CharT, _Alloc>(const_cast<_RopeRep*>(__root),
 					    __pos)
                    // Only nonconst iterators modify root ref count
@@ -1160,7 +1159,7 @@ protected:
 
       _Rope_const_iterator(const _Rope_iterator<_CharT,_Alloc>& __x);
     
-      _Rope_const_iterator(const rope<_CharT, _Alloc>& __r, size_t __pos)
+      _Rope_const_iterator(const rope<_CharT, _Alloc>& __r, std::size_t __pos)
       : _Rope_iterator_base<_CharT,_Alloc>(__r._M_tree_ptr, __pos) { }
 
       _Rope_const_iterator&
@@ -1209,7 +1208,7 @@ protected:
       }
 
       _Rope_const_iterator&
-      operator+=(ptrdiff_t __n)
+      operator+=(std::ptrdiff_t __n)
       {
         if (__n >= 0)
 	  this->_M_incr(__n);
@@ -1226,7 +1225,7 @@ protected:
       }
 
       _Rope_const_iterator&
-      operator-=(ptrdiff_t __n)
+      operator-=(std::ptrdiff_t __n)
       {
         if (__n >= 0)
 	  this->_M_decr(__n);
@@ -1238,7 +1237,7 @@ protected:
       _Rope_const_iterator
       operator++(int)
       {
-        size_t __old_pos = this->_M_current_pos;
+	std::size_t __old_pos = this->_M_current_pos;
         this->_M_incr(1);
         return _Rope_const_iterator<_CharT,_Alloc>(this->_M_root, __old_pos);
         // This makes a subsequent dereference expensive.
@@ -1249,7 +1248,7 @@ protected:
       _Rope_const_iterator
       operator--(int)
       {
-        size_t __old_pos = this->_M_current_pos;
+	std::size_t __old_pos = this->_M_current_pos;
         this->_M_decr(1);
         return _Rope_const_iterator<_CharT,_Alloc>(this->_M_root, __old_pos);
       }
@@ -1257,20 +1256,20 @@ protected:
       template<class _CharT2, class _Alloc2>
         friend _Rope_const_iterator<_CharT2, _Alloc2>
         operator-(const _Rope_const_iterator<_CharT2, _Alloc2>& __x,
-		  ptrdiff_t __n);
+		  std::ptrdiff_t __n);
 
       template<class _CharT2, class _Alloc2>
         friend _Rope_const_iterator<_CharT2, _Alloc2>
         operator+(const _Rope_const_iterator<_CharT2, _Alloc2>& __x,
-		  ptrdiff_t __n);
+		  std::ptrdiff_t __n);
 
       template<class _CharT2, class _Alloc2>
         friend _Rope_const_iterator<_CharT2, _Alloc2>
-        operator+(ptrdiff_t __n,
+        operator+(std::ptrdiff_t __n,
 		  const _Rope_const_iterator<_CharT2, _Alloc2>& __x);
 
       reference
-      operator[](size_t __n)
+      operator[](std::size_t __n)
       { return rope<_CharT, _Alloc>::_S_fetch(this->_M_root,
 					      this->_M_current_pos + __n); }
 
@@ -1285,7 +1284,7 @@ protected:
 		  const _Rope_const_iterator<_CharT2, _Alloc2>& __y);
 
       template<class _CharT2, class _Alloc2>
-        friend ptrdiff_t
+        friend std::ptrdiff_t
         operator-(const _Rope_const_iterator<_CharT2, _Alloc2>& __x,
 		  const _Rope_const_iterator<_CharT2, _Alloc2>& __y);
     };
@@ -1305,7 +1304,7 @@ protected:
       // Root is included in the reference count.  This is necessary
       // so that we can detect changes reliably.  Unfortunately, it
       // requires careful bookkeeping for the nonGC case.
-      _Rope_iterator(rope<_CharT, _Alloc>* __r, size_t __pos)
+      _Rope_iterator(rope<_CharT, _Alloc>* __r, std::size_t __pos)
       : _Rope_iterator_base<_CharT, _Alloc>(__r->_M_tree_ptr, __pos),
         _M_root_rope(__r)
       { _RopeRep::_S_ref(this->_M_root);
@@ -1334,7 +1333,7 @@ protected:
         _RopeRep::_S_ref(this->_M_root);
       }
 
-      _Rope_iterator(rope<_CharT, _Alloc>& __r, size_t __pos);
+      _Rope_iterator(rope<_CharT, _Alloc>& __r, std::size_t __pos);
 
       ~_Rope_iterator()
       { _RopeRep::_S_unref(this->_M_root); }
@@ -1389,7 +1388,7 @@ protected:
       }
 
       _Rope_iterator&
-      operator+=(ptrdiff_t __n)
+      operator+=(std::ptrdiff_t __n)
       {
         if (__n >= 0)
 	  this->_M_incr(__n);
@@ -1406,7 +1405,7 @@ protected:
       }
 
       _Rope_iterator&
-      operator-=(ptrdiff_t __n)
+      operator-=(std::ptrdiff_t __n)
       {
         if (__n >= 0)
 	  this->_M_decr(__n);
@@ -1418,7 +1417,7 @@ protected:
       _Rope_iterator
       operator++(int)
       {
-        size_t __old_pos = this->_M_current_pos;
+	std::size_t __old_pos = this->_M_current_pos;
         this->_M_incr(1);
         return _Rope_iterator<_CharT,_Alloc>(_M_root_rope, __old_pos);
       }
@@ -1426,13 +1425,13 @@ protected:
       _Rope_iterator
       operator--(int)
       {
-        size_t __old_pos = this->_M_current_pos;
+	std::size_t __old_pos = this->_M_current_pos;
         this->_M_decr(1);
         return _Rope_iterator<_CharT,_Alloc>(_M_root_rope, __old_pos);
       }
 
       reference
-      operator[](ptrdiff_t __n)
+      operator[](std::ptrdiff_t __n)
       { return _Rope_char_ref_proxy<_CharT, _Alloc>(_M_root_rope,
 						    this->_M_current_pos
 						    + __n); }
@@ -1448,21 +1447,24 @@ protected:
 		  const _Rope_iterator<_CharT2, _Alloc2>& __y);
 
       template<class _CharT2, class _Alloc2>
-        friend ptrdiff_t
+        friend std::ptrdiff_t
         operator-(const _Rope_iterator<_CharT2, _Alloc2>& __x,
 		  const _Rope_iterator<_CharT2, _Alloc2>& __y);
 
       template<class _CharT2, class _Alloc2>
         friend _Rope_iterator<_CharT2, _Alloc2>
-        operator-(const _Rope_iterator<_CharT2, _Alloc2>& __x, ptrdiff_t __n);
+        operator-(const _Rope_iterator<_CharT2, _Alloc2>& __x,
+		  std::ptrdiff_t __n);
 
       template<class _CharT2, class _Alloc2>
         friend _Rope_iterator<_CharT2, _Alloc2>
-        operator+(const _Rope_iterator<_CharT2, _Alloc2>& __x, ptrdiff_t __n);
+        operator+(const _Rope_iterator<_CharT2, _Alloc2>& __x,
+		  std::ptrdiff_t __n);
 
       template<class _CharT2, class _Alloc2>
         friend _Rope_iterator<_CharT2, _Alloc2>
-        operator+(ptrdiff_t __n, const _Rope_iterator<_CharT2, _Alloc2>& __x);
+        operator+(std::ptrdiff_t __n,
+		  const _Rope_iterator<_CharT2, _Alloc2>& __x);
     };
 
 
@@ -1498,9 +1500,9 @@ protected:
 #define __ROPE_DEFINE_ALLOC(_Tp, __name) \
         typedef typename \
           _Alloc::template rebind<_Tp>::other __name##Alloc; \
-        static _Tp* __name##_allocate(size_t __n) \
+        static _Tp* __name##_allocate(std::size_t __n) \
           { return __name##Alloc().allocate(__n); } \
-        static void __name##_deallocate(_Tp *__p, size_t __n) \
+        static void __name##_deallocate(_Tp *__p, std::size_t __n) \
           { __name##Alloc().deallocate(__p, __n); }
       __ROPE_DEFINE_ALLOCS(_Alloc)
 #undef __ROPE_DEFINE_ALLOC
@@ -1522,8 +1524,8 @@ protected:
     {
     public:
       typedef _CharT value_type;
-      typedef ptrdiff_t difference_type;
-      typedef size_t size_type;
+      typedef std::ptrdiff_t difference_type;
+      typedef std::size_t size_type;
       typedef _CharT const_reference;
       typedef const _CharT* const_pointer;
       typedef _Rope_iterator<_CharT, _Alloc> iterator;
@@ -1580,7 +1582,7 @@ protected:
       _S_apply_to_pieces(// should be template parameter
 			 _Rope_char_consumer<_CharT>& __c,
 			 const _RopeRep* __r,
-			 size_t __begin, size_t __end);
+			 size_type __begin, size_type __end);
                          // begin and end are assumed to be in range.
 
 #ifndef __GC
@@ -1605,16 +1607,17 @@ protected:
 
       // _Result is counted in refcount.
       static _RopeRep* _S_substring(_RopeRep* __base,
-                                    size_t __start, size_t __endp1);
+                                    size_type __start, size_type __endp1);
 
       static _RopeRep* _S_concat_char_iter(_RopeRep* __r,
-					   const _CharT* __iter, size_t __slen);
+					   const _CharT* __iter,
+					   size_type __slen);
       // Concatenate rope and char ptr, copying __s.
       // Should really take an arbitrary iterator.
       // Result is counted in refcount.
       static _RopeRep* _S_destr_concat_char_iter(_RopeRep* __r,
 						 const _CharT* __iter,
-						 size_t __slen)
+						 size_type __slen)
 	// As above, but one reference to __r is about to be
 	// destroyed.  Thus the pieces may be recycled if all
 	// relevant reference counts are 1.
@@ -1631,18 +1634,18 @@ protected:
 
    public:
       void
-      apply_to_pieces(size_t __begin, size_t __end,
+      apply_to_pieces(size_type __begin, size_type __end,
 		      _Rope_char_consumer<_CharT>& __c) const
       { _S_apply_to_pieces(__c, this->_M_tree_ptr, __begin, __end); }
 
    protected:
 
-      static size_t
-      _S_rounded_up_size(size_t __n)
+      static size_type
+      _S_rounded_up_size(size_type __n)
       { return _RopeLeaf::_S_rounded_up_size(__n); }
 
-      static size_t
-      _S_allocated_capacity(size_t __n)
+      static size_type
+      _S_allocated_capacity(size_type __n)
       {
 	if (_S_is_basic_char_type((_CharT*)0))
 	  return _S_rounded_up_size(__n) - 1;
@@ -1655,7 +1658,7 @@ protected:
       // Takes ownership of s instead of copying.
       static _RopeLeaf*
       _S_new_RopeLeaf(__GC_CONST _CharT *__s,
-		      size_t __size, allocator_type& __a)
+		      size_type __size, allocator_type& __a)
       {
 	_RopeLeaf* __space = typename _Base::_LAlloc(__a).allocate(1);
 	return new(__space) _RopeLeaf(__s, __size, __a);
@@ -1671,15 +1674,15 @@ protected:
 
       static _RopeFunction*
       _S_new_RopeFunction(char_producer<_CharT>* __f,
-			  size_t __size, bool __d, allocator_type& __a)
+			  size_type __size, bool __d, allocator_type& __a)
       {
 	_RopeFunction* __space = typename _Base::_FAlloc(__a).allocate(1);
 	return new(__space) _RopeFunction(__f, __size, __d, __a);
       }
 
       static _RopeSubstring*
-      _S_new_RopeSubstring(_Rope_RopeRep<_CharT,_Alloc>* __b, size_t __s,
-			   size_t __l, allocator_type& __a)
+      _S_new_RopeSubstring(_Rope_RopeRep<_CharT,_Alloc>* __b, size_type __s,
+			   size_type __l, allocator_type& __a)
       {
 	_RopeSubstring* __space = typename _Base::_SAlloc(__a).allocate(1);
 	return new(__space) _RopeSubstring(__b, __s, __l, __a);
@@ -1687,7 +1690,7 @@ protected:
       
       static _RopeLeaf*
       _S_RopeLeaf_from_unowned_char_ptr(const _CharT *__s,
-					size_t __size, allocator_type& __a)
+					size_type __size, allocator_type& __a)
 #define __STL_ROPE_FROM_UNOWNED_CHAR_PTR(__s, __size, __a) \
                 _S_RopeLeaf_from_unowned_char_ptr(__s, __size, __a)
       {
@@ -1718,20 +1721,20 @@ protected:
       // Concatenation helper functions
       static _RopeLeaf*
       _S_leaf_concat_char_iter(_RopeLeaf* __r,
-			       const _CharT* __iter, size_t __slen);
+			       const _CharT* __iter, size_type __slen);
       // Concatenate by copying leaf.
       // should take an arbitrary iterator
       // result has refcount 1.
 #ifndef __GC
       static _RopeLeaf*
       _S_destr_leaf_concat_char_iter(_RopeLeaf* __r,
-				     const _CharT* __iter, size_t __slen);
+				     const _CharT* __iter, size_type __slen);
       // A version that potentially clobbers __r if __r->_M_ref_count == 1.
 #endif
 
     private:
       
-      static size_t _S_char_ptr_len(const _CharT* __s);
+      static size_type _S_char_ptr_len(const _CharT* __s);
       // slightly generalized strlen
 
       rope(_RopeRep* __t, const allocator_type& __a = allocator_type())
@@ -1746,7 +1749,7 @@ protected:
       // Again, with explicit starting position and length.
       // Assumes that buffer is uninitialized.
       static _CharT* _S_flatten(_RopeRep* __r,
-				size_t __start, size_t __len,
+				size_type __start, size_type __len,
 				_CharT* __buffer);
 
       static const unsigned long
@@ -1816,7 +1819,7 @@ protected:
 					   _M_get_allocator());
       }
 
-      rope(const _CharT* __s, size_t __len,
+      rope(const _CharT* __s, size_type __len,
 	   const allocator_type& __a = allocator_type())
       : _Base(__a)
       {
@@ -1865,14 +1868,14 @@ protected:
 	  }
       }
 
-      rope(size_t __n, _CharT __c,
+      rope(size_type __n, _CharT __c,
 	   const allocator_type& __a = allocator_type());
 
       rope(const allocator_type& __a = allocator_type())
       : _Base(0, __a) { }
 
       // Construct a rope from a function that can compute its members
-      rope(char_producer<_CharT> *__fn, size_t __len, bool __delete_fn,
+      rope(char_producer<_CharT> *__fn, size_type __len, bool __delete_fn,
 	   const allocator_type& __a = allocator_type())
       : _Base(__a)
       {
@@ -1982,8 +1985,8 @@ protected:
       size_type
       copy(size_type __pos, size_type __n, _CharT* __buffer) const
       {
-	size_t __size = size();
-	size_t __len = (__pos + __n > __size? __size - __pos : __n);
+	size_type __size = size();
+	size_type __len = (__pos + __n > __size? __size - __pos : __n);
 
 	_Destroy_const(__buffer, __buffer + __len, _M_get_allocator());
 	_S_flatten(this->_M_tree_ptr, __pos, __len, __buffer);
@@ -2108,7 +2111,7 @@ protected:
       // argument should be an input iterator or forward iterator with
       // value_type _CharT.
       rope&
-      append(const _CharT* __iter, size_t __n)
+      append(const _CharT* __iter, size_type __n)
       {
 	_RopeRep* __result =
 	  _S_destr_concat_char_iter(this->_M_tree_ptr, __iter, __n);
@@ -2120,7 +2123,7 @@ protected:
       rope&
       append(const _CharT* __c_string)
       {
-	size_t __len = _S_char_ptr_len(__c_string);
+	size_type __len = _S_char_ptr_len(__c_string);
 	append(__c_string, __len);
 	return(*this);
       }
@@ -2172,7 +2175,7 @@ protected:
       }
 
       rope&
-      append(size_t __n, _CharT __c)
+      append(size_type __n, _CharT __c)
       {
 	rope<_CharT,_Alloc> __last(__n, __c);
 	return append(__last);
@@ -2189,8 +2192,8 @@ protected:
     protected:
       // Result is included in refcount.
       static _RopeRep*
-      replace(_RopeRep* __old, size_t __pos1,
-	      size_t __pos2, _RopeRep* __r)
+      replace(_RopeRep* __old, size_type __pos1,
+	      size_type __pos2, _RopeRep* __r)
       {
 	if (0 == __old)
 	  {
@@ -2213,7 +2216,7 @@ protected:
 
     public:
       void
-      insert(size_t __p, const rope& __r)
+      insert(size_type __p, const rope& __r)
       {
 	_RopeRep* __result =
 	  replace(this->_M_tree_ptr, __p, __p, __r._M_tree_ptr);
@@ -2222,14 +2225,14 @@ protected:
       }
 
       void
-      insert(size_t __p, size_t __n, _CharT __c)
+      insert(size_type __p, size_type __n, _CharT __c)
       {
 	rope<_CharT,_Alloc> __r(__n,__c);
 	insert(__p, __r);
       }
       
       void
-      insert(size_t __p, const _CharT* __i, size_t __n)
+      insert(size_type __p, const _CharT* __i, size_type __n)
       {
 	_Self_destruct_ptr __left(_S_substring(this->_M_tree_ptr, 0, __p));
 	_Self_destruct_ptr __right(_S_substring(this->_M_tree_ptr,
@@ -2244,29 +2247,29 @@ protected:
       }
 
       void
-      insert(size_t __p, const _CharT* __c_string)
+      insert(size_type __p, const _CharT* __c_string)
       {	insert(__p, __c_string, _S_char_ptr_len(__c_string)); }
 
       void
-      insert(size_t __p, _CharT __c)
+      insert(size_type __p, _CharT __c)
       { insert(__p, &__c, 1); }
 
       void
-      insert(size_t __p)
+      insert(size_type __p)
       {
 	_CharT __c = _CharT();
 	insert(__p, &__c, 1);
       }
 
       void
-      insert(size_t __p, const _CharT* __i, const _CharT* __j)
+      insert(size_type __p, const _CharT* __i, const _CharT* __j)
       {
 	rope __r(__i, __j);
 	insert(__p, __r);
       }
 
       void
-      insert(size_t __p, const const_iterator& __i,
+      insert(size_type __p, const const_iterator& __i,
 	     const const_iterator& __j)
       {
 	rope __r(__i, __j);
@@ -2274,7 +2277,7 @@ protected:
       }
 
       void
-      insert(size_t __p, const iterator& __i,
+      insert(size_type __p, const iterator& __i,
 	     const iterator& __j)
       {
 	rope __r(__i, __j);
@@ -2284,7 +2287,7 @@ protected:
       // (position, length) versions of replace operations:
       
       void
-      replace(size_t __p, size_t __n, const rope& __r)
+      replace(size_type __p, size_type __n, const rope& __r)
       {
 	_RopeRep* __result =
 	  replace(this->_M_tree_ptr, __p, __p + __n, __r._M_tree_ptr);
@@ -2293,29 +2296,29 @@ protected:
       }
 
       void
-      replace(size_t __p, size_t __n,
-	      const _CharT* __i, size_t __i_len)
+      replace(size_type __p, size_type __n,
+	      const _CharT* __i, size_type __i_len)
       {
 	rope __r(__i, __i_len);
 	replace(__p, __n, __r);
       }
 
       void
-      replace(size_t __p, size_t __n, _CharT __c)
+      replace(size_type __p, size_type __n, _CharT __c)
       {
 	rope __r(__c);
 	replace(__p, __n, __r);
       }
 
       void
-      replace(size_t __p, size_t __n, const _CharT* __c_string)
+      replace(size_type __p, size_type __n, const _CharT* __c_string)
       {
 	rope __r(__c_string);
 	replace(__p, __n, __r);
       }
       
       void
-      replace(size_t __p, size_t __n,
+      replace(size_type __p, size_type __n,
 	      const _CharT* __i, const _CharT* __j)
       {
 	rope __r(__i, __j);
@@ -2323,7 +2326,7 @@ protected:
       }
       
       void
-      replace(size_t __p, size_t __n,
+      replace(size_type __p, size_type __n,
 	      const const_iterator& __i, const const_iterator& __j)
       {
 	rope __r(__i, __j);
@@ -2331,7 +2334,7 @@ protected:
       }
 
       void
-      replace(size_t __p, size_t __n,
+      replace(size_type __p, size_type __n,
 	      const iterator& __i, const iterator& __j)
       {
 	rope __r(__i, __j);
@@ -2340,41 +2343,41 @@ protected:
 
       // Single character variants:
       void
-      replace(size_t __p, _CharT __c)
+      replace(size_type __p, _CharT __c)
       {
 	iterator __i(this, __p);
 	*__i = __c;
       }
 
       void
-      replace(size_t __p, const rope& __r)
+      replace(size_type __p, const rope& __r)
       { replace(__p, 1, __r); }
 
       void
-      replace(size_t __p, const _CharT* __i, size_t __i_len)
+      replace(size_type __p, const _CharT* __i, size_type __i_len)
       { replace(__p, 1, __i, __i_len); }
 
       void
-      replace(size_t __p, const _CharT* __c_string)
+      replace(size_type __p, const _CharT* __c_string)
       {	replace(__p, 1, __c_string); }
 
       void
-      replace(size_t __p, const _CharT* __i, const _CharT* __j)
+      replace(size_type __p, const _CharT* __i, const _CharT* __j)
       {	replace(__p, 1, __i, __j); }
 
       void
-      replace(size_t __p, const const_iterator& __i,
+      replace(size_type __p, const const_iterator& __i,
 	      const const_iterator& __j)
       { replace(__p, 1, __i, __j); }
 
       void
-      replace(size_t __p, const iterator& __i,
+      replace(size_type __p, const iterator& __i,
 	      const iterator& __j)
       { replace(__p, 1, __i, __j); }
 
       // Erase, (position, size) variant.
       void
-      erase(size_t __p, size_t __n)
+      erase(size_type __p, size_type __n)
       {
 	_RopeRep* __result = replace(this->_M_tree_ptr, __p,
 				     __p + __n, 0);
@@ -2384,7 +2387,7 @@ protected:
 
       // Erase, single character
       void
-      erase(size_t __p)
+      erase(size_type __p)
       { erase(__p, __p + 1); }
 
       // Insert, iterator variants.
@@ -2396,7 +2399,7 @@ protected:
       }
 
       iterator
-      insert(const iterator& __p, size_t __n, _CharT __c)
+      insert(const iterator& __p, size_type __n, _CharT __c)
       {
 	insert(__p.index(), __n, __c);
 	return __p;
@@ -2423,7 +2426,7 @@ protected:
       }
       
       iterator
-      insert(const iterator& __p, const _CharT* __i, size_t __n)
+      insert(const iterator& __p, const _CharT* __i, size_type __n)
       {
 	insert(__p.index(), __i, __n);
 	return __p;
@@ -2469,7 +2472,7 @@ protected:
       
       void
       replace(const iterator& __p, const iterator& __q,
-	      const _CharT* __i, size_t __n)
+	      const _CharT* __i, size_type __n)
       { replace(__p.index(), __q.index() - __p.index(), __i, __n); }
       
       void
@@ -2501,7 +2504,7 @@ protected:
       { replace(__p.index(), __c_string); }
       
       void
-      replace(const iterator& __p, const _CharT* __i, size_t __n)
+      replace(const iterator& __p, const _CharT* __i, size_type __n)
       { replace(__p.index(), __i, __n); }
       
       void
@@ -2520,7 +2523,7 @@ protected:
       iterator
       erase(const iterator& __p, const iterator& __q)
       {
-	size_t __p_index = __p.index();
+	size_type __p_index = __p.index();
 	erase(__p_index, __q.index() - __p_index);
 	return iterator(this, __p_index);
       }
@@ -2528,13 +2531,13 @@ protected:
       iterator
       erase(const iterator& __p)
       {
-	size_t __p_index = __p.index();
+	size_type __p_index = __p.index();
 	erase(__p_index, 1);
 	return iterator(this, __p_index);
       }
 
       rope
-      substr(size_t __start, size_t __len = 1) const
+      substr(size_type __start, size_type __len = 1) const
       {
 	return rope<_CharT, _Alloc>(_S_substring(this->_M_tree_ptr,
 						 __start,
@@ -2552,7 +2555,7 @@ protected:
       rope
       substr(iterator __start) const
       {
-	size_t __pos = __start.index();
+	size_type __pos = __start.index();
 	return rope<_CharT, _Alloc>(_S_substring(this->_M_tree_ptr,
 						 __pos, __pos + 1));
       }
@@ -2570,7 +2573,7 @@ protected:
       rope<_CharT, _Alloc>
       substr(const_iterator __start)
       {
-	size_t __pos = __start.index();
+	size_type __pos = __start.index();
 	return rope<_CharT, _Alloc>(_S_substring(this->_M_tree_ptr,
 						 __pos, __pos + 1));
       }
@@ -2718,26 +2721,32 @@ protected:
     { return !(__x < __y); }
 
   template <class _CharT, class _Alloc>
-    inline ptrdiff_t
+    inline std::ptrdiff_t
     operator-(const _Rope_const_iterator<_CharT, _Alloc>& __x,
 	      const _Rope_const_iterator<_CharT, _Alloc>& __y)
-    { return (ptrdiff_t)__x._M_current_pos - (ptrdiff_t)__y._M_current_pos; }
+    {
+      return (std::ptrdiff_t)__x._M_current_pos
+	- (std::ptrdiff_t)__y._M_current_pos;
+    }
 
   template <class _CharT, class _Alloc>
     inline _Rope_const_iterator<_CharT, _Alloc>
-    operator-(const _Rope_const_iterator<_CharT, _Alloc>& __x, ptrdiff_t __n)
+    operator-(const _Rope_const_iterator<_CharT, _Alloc>& __x,
+	      std::ptrdiff_t __n)
     { return _Rope_const_iterator<_CharT, _Alloc>(__x._M_root,
 						  __x._M_current_pos - __n); }
 
   template <class _CharT, class _Alloc>
     inline _Rope_const_iterator<_CharT, _Alloc>
-    operator+(const _Rope_const_iterator<_CharT, _Alloc>& __x, ptrdiff_t __n)
+    operator+(const _Rope_const_iterator<_CharT, _Alloc>& __x,
+	      std::ptrdiff_t __n)
     { return _Rope_const_iterator<_CharT, _Alloc>(__x._M_root,
 						  __x._M_current_pos + __n); }
 
   template <class _CharT, class _Alloc>
     inline _Rope_const_iterator<_CharT, _Alloc>
-    operator+(ptrdiff_t __n, const _Rope_const_iterator<_CharT, _Alloc>& __x)
+    operator+(std::ptrdiff_t __n,
+	      const _Rope_const_iterator<_CharT, _Alloc>& __x)
   { return _Rope_const_iterator<_CharT, _Alloc>(__x._M_root,
 						__x._M_current_pos + __n); }
 
@@ -2779,28 +2788,28 @@ protected:
     { return !(__x < __y); }
 
   template <class _CharT, class _Alloc>
-    inline ptrdiff_t
+    inline std::ptrdiff_t
     operator-(const _Rope_iterator<_CharT, _Alloc>& __x,
 	      const _Rope_iterator<_CharT, _Alloc>& __y)
-    { return ((ptrdiff_t)__x._M_current_pos
-	      - (ptrdiff_t)__y._M_current_pos); }
+    { return ((std::ptrdiff_t)__x._M_current_pos
+	      - (std::ptrdiff_t)__y._M_current_pos); }
 
   template <class _CharT, class _Alloc>
     inline _Rope_iterator<_CharT, _Alloc>
     operator-(const _Rope_iterator<_CharT, _Alloc>& __x,
-	      ptrdiff_t __n)
+	      std::ptrdiff_t __n)
     { return _Rope_iterator<_CharT, _Alloc>(__x._M_root_rope,
 					    __x._M_current_pos - __n); }
 
   template <class _CharT, class _Alloc>
     inline _Rope_iterator<_CharT, _Alloc>
-    operator+(const _Rope_iterator<_CharT, _Alloc>& __x, ptrdiff_t __n)
+    operator+(const _Rope_iterator<_CharT, _Alloc>& __x, std::ptrdiff_t __n)
     { return _Rope_iterator<_CharT, _Alloc>(__x._M_root_rope,
 					    __x._M_current_pos + __n); }
 
   template <class _CharT, class _Alloc>
     inline _Rope_iterator<_CharT, _Alloc>
-    operator+(ptrdiff_t __n, const _Rope_iterator<_CharT, _Alloc>& __x)
+    operator+(std::ptrdiff_t __n, const _Rope_iterator<_CharT, _Alloc>& __x)
     { return _Rope_iterator<_CharT, _Alloc>(__x._M_root_rope,
 					    __x._M_current_pos + __n); }
 
@@ -2831,7 +2840,7 @@ protected:
 	      const _CharT* __right)
     {
       typedef rope<_CharT, _Alloc> rope_type;
-      size_t __rlen = rope_type::_S_char_ptr_len(__right);
+      std::size_t __rlen = rope_type::_S_char_ptr_len(__right);
       return rope_type(rope_type::_S_concat_char_iter(__left._M_tree_ptr,
 						      __right, __rlen));
     }
@@ -2919,11 +2928,11 @@ protected:
   typedef rope<wchar_t> wrope;
 
   inline crope::reference
-  __mutable_reference_at(crope& __c, size_t __i)
+  __mutable_reference_at(crope& __c, std::size_t __i)
   { return __c.mutable_reference_at(__i); }
 
   inline wrope::reference
-  __mutable_reference_at(wrope& __c, size_t __i)
+  __mutable_reference_at(wrope& __c, std::size_t __i)
   { return __c.mutable_reference_at(__i); }
 
   template <class _CharT, class _Alloc>
diff --git a/libstdc++-v3/include/ext/ropeimpl.h b/libstdc++-v3/include/ext/ropeimpl.h
index 9e27219..d321522 100644
--- a/libstdc++-v3/include/ext/ropeimpl.h
+++ b/libstdc++-v3/include/ext/ropeimpl.h
@@ -52,13 +52,6 @@ namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
 {
 _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
-  using std::size_t;
-  using std::printf;
-  using std::basic_ostream;
-  using std::__throw_length_error;
-  using std::_Destroy;
-  using std::__uninitialized_fill_n_a;
-
   // Set buf_start, buf_end, and buf_ptr appropriately, filling tmp_buf
   // if necessary.  Assumes _M_path_end[leaf_index] and leaf_pos are correct.
   // Results in a valid buf_ptr if the iterator can be legitimately
@@ -68,6 +61,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     _Rope_iterator_base<_CharT, _Alloc>::
     _S_setbuf(_Rope_iterator_base<_CharT, _Alloc>& __x)
     {
+      using std::size_t;
       const _RopeRep* __leaf = __x._M_path_end[__x._M_leaf_index];
       size_t __leaf_pos = __x._M_leaf_pos;
       size_t __pos = __x._M_current_pos;
@@ -113,6 +107,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     _Rope_iterator_base<_CharT, _Alloc>::
     _S_setcache(_Rope_iterator_base<_CharT, _Alloc>& __x)
     {
+      using std::size_t;
       const _RopeRep* __path[int(__detail::_S_max_rope_depth) + 1];
       const _RopeRep* __curr_rope;
       int __curr_depth = -1;  /* index into path    */
@@ -190,6 +185,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     _Rope_iterator_base<_CharT, _Alloc>::
     _S_setcache_for_incr(_Rope_iterator_base<_CharT, _Alloc>& __x)
     {
+      using std::size_t;
       int __current_index = __x._M_leaf_index;
       const _RopeRep* __current_node = __x._M_path_end[__current_index];
       size_t __len = __current_node->_M_size;
@@ -255,12 +251,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   template <class _CharT, class _Alloc>
     void
     _Rope_iterator_base<_CharT, _Alloc>::
-    _M_incr(size_t __n)
+    _M_incr(std::size_t __n)
     {
       _M_current_pos += __n;
       if (0 != _M_buf_ptr)
 	{
-	  size_t __chars_left = _M_buf_end - _M_buf_ptr;
+	  std::size_t __chars_left = _M_buf_end - _M_buf_ptr;
 	  if (__chars_left > __n)
 	    _M_buf_ptr += __n;
 	  else if (__chars_left == __n)
@@ -276,11 +272,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   template <class _CharT, class _Alloc>
     void
     _Rope_iterator_base<_CharT, _Alloc>::
-    _M_decr(size_t __n)
+    _M_decr(std::size_t __n)
     {
       if (0 != _M_buf_ptr)
 	{
-	  size_t __chars_left = _M_buf_ptr - _M_buf_start;
+	  std::size_t __chars_left = _M_buf_ptr - _M_buf_start;
 	  if (__chars_left >= __n)
 	    _M_buf_ptr -= __n;
 	  else
@@ -314,13 +310,13 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   template <class _CharT, class _Alloc>
     inline
     _Rope_iterator<_CharT, _Alloc>::
-    _Rope_iterator(rope<_CharT, _Alloc>& __r, size_t __pos)
+    _Rope_iterator(rope<_CharT, _Alloc>& __r, std::size_t __pos)
     : _Rope_iterator_base<_CharT,_Alloc>(__r._M_tree_ptr, __pos),
       _M_root_rope(&__r)
     { _RopeRep::_S_ref(this->_M_root); }
 
   template <class _CharT, class _Alloc>
-    inline size_t
+    inline std::size_t
     rope<_CharT, _Alloc>::
     _S_char_ptr_len(const _CharT* __s)
     {
@@ -342,8 +338,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       _CharT* __cstr = _M_c_string;
       if (0 != __cstr)
 	{
-	  size_t __size = this->_M_size + 1;
-	  _Destroy(__cstr, __cstr + __size, _M_get_allocator());
+	  std::size_t __size = this->_M_size + 1;
+	  std::_Destroy(__cstr, __cstr + __size, _M_get_allocator());
 	  this->_Data_deallocate(__cstr, __size);
 	}
     }
@@ -351,10 +347,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   template <class _CharT, class _Alloc>
     inline void
     _Rope_RopeRep<_CharT, _Alloc>::
-    _S_free_string(_CharT* __s, size_t __n, allocator_type& __a)
+    _S_free_string(_CharT* __s, std::size_t __n, allocator_type& __a)
     {
       if (!_S_is_basic_char_type((_CharT*)0))
-	_Destroy(__s, __s + __n, __a);
+	std::_Destroy(__s, __s + __n, __a);
       
       //  This has to be a static member, so this gets a bit messy
       __a.deallocate(__s,
@@ -415,7 +411,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   template <class _CharT, class _Alloc>
     inline void
     _Rope_RopeRep<_CharT, _Alloc>::
-    _S_free_string(const _CharT*, size_t, allocator_type)
+    _S_free_string(const _CharT*, std::size_t, allocator_type)
     { }
 
 #endif
@@ -425,9 +421,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   template <class _CharT, class _Alloc>
     typename rope<_CharT, _Alloc>::_RopeLeaf*
     rope<_CharT, _Alloc>::
-    _S_leaf_concat_char_iter(_RopeLeaf* __r, const _CharT* __iter, size_t __len)
+    _S_leaf_concat_char_iter(_RopeLeaf* __r, const _CharT* __iter,
+			     std::size_t __len)
     {
-      size_t __old_len = __r->_M_size;
+      std::size_t __old_len = __r->_M_size;
       _CharT* __new_data = (_CharT*)
 	rope::_Data_allocate(_S_rounded_up_size(__old_len + __len));
       _RopeLeaf* __result;
@@ -455,11 +452,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     typename rope<_CharT,_Alloc>::_RopeLeaf*
     rope<_CharT, _Alloc>::
     _S_destr_leaf_concat_char_iter(_RopeLeaf* __r, const _CharT* __iter,
-				   size_t __len)
+				   std::size_t __len)
     {
       if (__r->_M_ref_count > 1)
 	return _S_leaf_concat_char_iter(__r, __iter, __len);
-      size_t __old_len = __r->_M_size;
+      std::size_t __old_len = __r->_M_size;
       if (_S_allocated_capacity(__old_len) >= __old_len + __len)
 	{
 	  // The space has been partially initialized for the standard
@@ -492,6 +489,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     rope<_CharT, _Alloc>::
     _S_tree_concat(_RopeRep* __left, _RopeRep* __right)
     {
+      using std::size_t;
       _RopeConcatenation* __result = _S_new_RopeConcatenation(__left, __right,
 							      __left->
 							      _M_get_allocator());
@@ -526,8 +524,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   template <class _CharT, class _Alloc>
     typename rope<_CharT, _Alloc>::_RopeRep*
     rope<_CharT, _Alloc>::
-    _S_concat_char_iter(_RopeRep* __r, const _CharT*__s, size_t __slen)
+    _S_concat_char_iter(_RopeRep* __r, const _CharT*__s, std::size_t __slen)
     {
+      using std::size_t;
       _RopeRep* __result;
       if (0 == __slen)
 	{
@@ -585,8 +584,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   template <class _CharT, class _Alloc>
     typename rope<_CharT,_Alloc>::_RopeRep*
     rope<_CharT,_Alloc>::
-    _S_destr_concat_char_iter(_RopeRep* __r, const _CharT* __s, size_t __slen)
+    _S_destr_concat_char_iter(_RopeRep* __r, const _CharT* __s,
+			      std::size_t __slen)
     {
+      using std::size_t;
       _RopeRep* __result;
       if (0 == __r)
 	return __STL_ROPE_FROM_UNOWNED_CHAR_PTR(__s, __slen,
@@ -651,6 +652,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     rope<_CharT, _Alloc>::
     _S_concat(_RopeRep* __left, _RopeRep* __right)
     {
+      using std::size_t;
       if (0 == __left)
 	{
 	  _S_ref(__right);
@@ -712,8 +714,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   template <class _CharT, class _Alloc>
     typename rope<_CharT, _Alloc>::_RopeRep*
     rope<_CharT, _Alloc>::
-    _S_substring(_RopeRep* __base, size_t __start, size_t __endp1)
+    _S_substring(_RopeRep* __base, std::size_t __start, std::size_t __endp1)
     {
+      using std::size_t;
       if (0 == __base)
 	return 0;
       size_t __len = __base->_M_size;
@@ -849,7 +852,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       ~_Rope_flatten_char_consumer() {}
       
       bool
-      operator()(const _CharT* __leaf, size_t __n)
+      operator()(const _CharT* __leaf, std::size_t __n)
       {
 	uninitialized_copy_n(__leaf, __n, _M_buf_ptr);
 	_M_buf_ptr += __n;
@@ -864,7 +867,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     private:
       _CharT _M_pattern;
     public:
-      size_t _M_count;  // Number of nonmatching characters
+      std::size_t _M_count;  // Number of nonmatching characters
       
       _Rope_find_char_char_consumer(_CharT __p)
       : _M_pattern(__p), _M_count(0) {}
@@ -872,9 +875,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       ~_Rope_find_char_char_consumer() {}
       
       bool
-      operator()(const _CharT* __leaf, size_t __n)
+      operator()(const _CharT* __leaf, std::size_t __n)
       {
-	size_t __i;
+	std::size_t __i;
 	for (__i = 0; __i < __n; __i++)
 	  {
 	    if (__leaf[__i] == _M_pattern)
@@ -893,23 +896,23 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     : public _Rope_char_consumer<_CharT>
     {
     private:
-      typedef basic_ostream<_CharT,_Traits> _Insert_ostream;
+      typedef std::basic_ostream<_CharT,_Traits> _Insert_ostream;
       _Insert_ostream& _M_o;
     public:
       _Rope_insert_char_consumer(_Insert_ostream& __writer)
 	: _M_o(__writer) {}
       ~_Rope_insert_char_consumer() { }
       // Caller is presumed to own the ostream
-      bool operator() (const _CharT* __leaf, size_t __n);
+      bool operator() (const _CharT* __leaf, std::size_t __n);
       // Returns true to continue traversal.
     };
 
   template<class _CharT, class _Traits>
     bool
     _Rope_insert_char_consumer<_CharT, _Traits>::
-    operator()(const _CharT* __leaf, size_t __n)
+    operator()(const _CharT* __leaf, std::size_t __n)
     {
-      size_t __i;
+      std::size_t __i;
       //  We assume that formatting is set up correctly for each element.
       for (__i = 0; __i < __n; __i++)
 	_M_o.put(__leaf[__i]);
@@ -919,9 +922,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   template <class _CharT, class _Alloc>
     bool
     rope<_CharT, _Alloc>::
-    _S_apply_to_pieces(_Rope_char_consumer<_CharT>& __c,
-		       const _RopeRep* __r, size_t __begin, size_t __end)
+    _S_apply_to_pieces(_Rope_char_consumer<_CharT>& __c, const _RopeRep* __r,
+		       std::size_t __begin, std::size_t __end)
     {
+      using std::size_t;
       if (0 == __r)
 	return true;
       switch(__r->_M_tag)
@@ -981,10 +985,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
   template<class _CharT, class _Traits>
     inline void
-    _Rope_fill(basic_ostream<_CharT, _Traits>& __o, size_t __n)
+    _Rope_fill(std::basic_ostream<_CharT, _Traits>& __o, std::size_t __n)
     {
       char __f = __o.fill();
-      size_t __i;
+      std::size_t __i;
       
       for (__i = 0; __i < __n; __i++)
 	__o.put(__f);
@@ -1005,10 +1009,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   { return true; }
 
   template<class _CharT, class _Traits, class _Alloc>
-    basic_ostream<_CharT, _Traits>&
-    operator<<(basic_ostream<_CharT, _Traits>& __o,
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __o,
 	       const rope<_CharT, _Alloc>& __r)
     {
+      using std::size_t;
       size_t __w = __o.width();
       bool __left = bool(__o.flags() & std::ios::left);
       size_t __pad_len;
@@ -1045,7 +1050,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   template <class _CharT, class _Alloc>
     _CharT*
     rope<_CharT, _Alloc>::
-    _S_flatten(_RopeRep* __r, size_t __start, size_t __len,
+    _S_flatten(_RopeRep* __r, std::size_t __start, std::size_t __len,
 	       _CharT* __buffer)
     {
       _Rope_flatten_char_consumer<_CharT> __c(__buffer);
@@ -1054,9 +1059,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     }
 
   template <class _CharT, class _Alloc>
-    size_t
+    std::size_t
     rope<_CharT, _Alloc>::
-    find(_CharT __pattern, size_t __start) const
+    find(_CharT __pattern, std::size_t __start) const
     {
       _Rope_find_char_char_consumer<_CharT> __c(__pattern);
       _S_apply_to_pieces(__c, this->_M_tree_ptr, __start, size());
@@ -1110,6 +1115,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     rope<_CharT, _Alloc>::
     _S_dump(_RopeRep* __r, int __indent)
     {
+      using std::printf;
       for (int __i = 0; __i < __indent; __i++)
 	putchar(' ');
       if (0 == __r)
@@ -1236,7 +1242,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	}
       
       if (__result->_M_depth > int(__detail::_S_max_rope_depth))
-	__throw_length_error(__N("rope::_S_balance"));
+	std::__throw_length_error(__N("rope::_S_balance"));
       return(__result);
     }
 
@@ -1268,7 +1274,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       _RopeRep* __insertee;		// included in refcount
       _RopeRep* __too_tiny = 0;		// included in refcount
       int __i;				// forest[0..__i-1] is empty
-      size_t __s = __r->_M_size;
+      std::size_t __s = __r->_M_size;
       
       for (__i = 0; __s >= _S_min_len[__i+1]/* not this bucket */; ++__i)
 	{
@@ -1330,7 +1336,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	      {
 		_RopeConcatenation* __c = (_RopeConcatenation*)__r;
 		_RopeRep* __left = __c->_M_left;
-		size_t __left_len = __left->_M_size;
+		std::size_t __left_len = __left->_M_size;
 		
 		if (__i >= __left_len)
 		  {
@@ -1368,7 +1374,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     _S_fetch_ptr(_RopeRep* __r, size_type __i)
     {
       _RopeRep* __clrstack[__detail::_S_max_rope_depth];
-      size_t __csptr = 0;
+      std::size_t __csptr = 0;
       
       for(;;)
 	{
@@ -1380,7 +1386,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	      {
 		_RopeConcatenation* __c = (_RopeConcatenation*)__r;
 		_RopeRep* __left = __c->_M_left;
-		size_t __left_len = __left->_M_size;
+		std::size_t __left_len = __left->_M_size;
 		
 		if (__c->_M_c_string != 0)
 		  __clrstack[__csptr++] = __c;
@@ -1424,8 +1430,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     rope<_CharT, _Alloc>::
     _S_compare (const _RopeRep* __left, const _RopeRep* __right)
     {
-      size_t __left_len;
-      size_t __right_len;
+      std::size_t __left_len;
+      std::size_t __right_len;
       
       if (0 == __right)
 	return 0 != __left;
@@ -1524,13 +1530,15 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
   template <class _CharT, class _Alloc>
     rope<_CharT, _Alloc>::
-    rope(size_t __n, _CharT __c, const allocator_type& __a)
+    rope(std::size_t __n, _CharT __c, const allocator_type& __a)
     : _Base(__a)
     {
+      using std::__uninitialized_fill_n_a;
+
       rope<_CharT,_Alloc> __result;
-      const size_t __exponentiate_threshold = 32;
-      size_t __exponent;
-      size_t __rest;
+      const std::size_t __exponentiate_threshold = 32;
+      std::size_t __exponent;
+      std::size_t __rest;
       _CharT* __rest_buffer;
       _RopeRep* __remainder;
       rope<_CharT, _Alloc> __remainder_rope;
@@ -1617,7 +1625,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       __GC_CONST _CharT* __result = this->_M_tree_ptr->_M_c_string;
       if (0 == __result)
 	{
-	  size_t __s = size();
+	  std::size_t __s = size();
 	  __result = this->_Data_allocate(__s + 1);
 	  _S_flatten(this->_M_tree_ptr, __result);
 	  __result[__s] = _S_eos((_CharT*)0);
@@ -1640,7 +1648,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       if (__detail::_S_leaf == this->_M_tree_ptr->_M_tag
 	  && 0 != __old_c_string)
 	return(__old_c_string);
-      size_t __s = size();
+      std::size_t __s = size();
       _CharT* __result = this->_Data_allocate(_S_rounded_up_size(__s));
       _S_flatten(this->_M_tree_ptr, __result);
       __result[__s] = _S_eos((_CharT*)0);
diff --git a/libstdc++-v3/include/ext/slist b/libstdc++-v3/include/ext/slist
index 3b49ae2..ff2ea15 100644
--- a/libstdc++-v3/include/ext/slist
+++ b/libstdc++-v3/include/ext/slist
@@ -54,14 +54,6 @@ namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
 {
 _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
-  using std::size_t;
-  using std::ptrdiff_t;
-  using std::_Construct;
-  using std::_Destroy;
-  using std::allocator;
-  using std::__true_type;
-  using std::__false_type;
-
   struct _Slist_node_base
   {
     _Slist_node_base* _M_next;
@@ -138,10 +130,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     return __result;
   }
 
-  inline size_t
+  inline std::size_t
   __slist_size(_Slist_node_base* __node)
   {
-    size_t __result = 0;
+    std::size_t __result = 0;
     for (; __node != 0; __node = __node->_M_next)
       ++__result;
     return __result;
@@ -155,8 +147,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
   struct _Slist_iterator_base
   {
-    typedef size_t                    size_type;
-    typedef ptrdiff_t                 difference_type;
+    typedef std::size_t                    size_type;
+    typedef std::ptrdiff_t                 difference_type;
     typedef std::forward_iterator_tag iterator_category;
 
     _Slist_node_base* _M_node;
@@ -288,7 +280,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
    *  @ingroup SGIextensions
    *  @doctodo
    */
-  template <class _Tp, class _Alloc = allocator<_Tp> >
+  template <class _Tp, class _Alloc = std::allocator<_Tp> >
     class slist : private _Slist_base<_Tp,_Alloc>
     {
       // concept requirements
@@ -303,8 +295,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       typedef const value_type* const_pointer;
       typedef value_type&       reference;
       typedef const value_type& const_reference;
-      typedef size_t            size_type;
-      typedef ptrdiff_t         difference_type;
+      typedef std::size_t            size_type;
+      typedef std::ptrdiff_t         difference_type;
       
       typedef _Slist_iterator<_Tp, _Tp&, _Tp*>             iterator;
       typedef _Slist_iterator<_Tp, const _Tp&, const _Tp*> const_iterator;
@@ -409,13 +401,13 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
       template <class _Integer>
       void
-      _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
+      _M_assign_dispatch(_Integer __n, _Integer __val, std::__true_type)
       { _M_fill_assign((size_type) __n, (_Tp) __val); }
 
       template <class _InputIterator>
       void
       _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
-			 __false_type);
+			 std::__false_type);
 
     public:
 
@@ -533,14 +525,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       template <class _Integer>
         void
         _M_insert_after_range(_Node_base* __pos, _Integer __n, _Integer __x,
-			      __true_type)
+			      std::__true_type)
         { _M_insert_after_fill(__pos, __n, __x); }
 
       template <class _InIterator>
         void
         _M_insert_after_range(_Node_base* __pos,
 			      _InIterator __first, _InIterator __last,
-			      __false_type)
+			      std::__false_type)
         {
 	  while (__first != __last)
 	    {
@@ -771,7 +763,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       void
       slist<_Tp, _Alloc>::_M_assign_dispatch(_InputIterator __first,
 					     _InputIterator __last,
-					     __false_type)
+					     std::__false_type)
       {
 	_Node_base* __prev = &this->_M_head;
 	_Node* __node = (_Node*) this->_M_head._M_next;