Update to SGI STL 3.3

2000-06-27  Benjamin Kosnik  <bkoz@purist.soma.redhat.com>

	Update to SGI STL 3.3
	* ext/hash_map, ext/hash_set, ext/slist, ext/stl_bvector.h,
	ext/stl_rope.h, ext/ropeimpl.h: Update.
	* bits/std_bitset.h, bits/std_map, bits/std_memory.h,
	bits/stl_algo.h, bits/stl_algobase.h, bits/stl_alloc.h,
	bits/stl_config.h, bits/stl_construct.h, bits/stl_deque.h,
	bits/stl_function.h, bits/stl_heap.h, bits/stl_iterator.h,
	bits/stl_iterator_base.h, bits/stl_list.h, bits/stl_map.h,
	bits/stl_multimap.h, bits/stl_multiset.h, bits/stl_numeric.h,
	bits/stl_queue.h, bits/stl_set.h, bits/stl_stack.h,
	bits/stl_string_fwd.h, bits/stl_threads.h, bits/stl_three.h,
	bits/stl_uninitialized.h, bits/stl_vectory.h: Update.

	* src/Makefile.am (headers): Add new files.
	* src/Makefile.in: Regenerate.
	* src/stl-inst.cc (std): Add instantiation for __sink_unused_warning.
	* bits/concept_checks.h: New file.
	* bits/container_concepts.h: New file.
	* bits/sequence_concepts.h: New file.

From-SVN: r34748

libstdc++-v3/bits/container_concepts.h

+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+#ifndef __STL_CONTAINER_CONCEPTS_H
+#define __STL_CONTAINER_CONCEPTS_H
+
+
+#include <bits/concept_checks.h>
+
+#ifdef __STL_USE_CONCEPT_CHECKS
+
+
+// This file covers the following concepts:
+//       _Container
+//       _ForwardContainer
+//       _ReversibleContainer
+//       _const_ReversibleContainer
+//       _RandomAccessContainer
+//
+
+struct _ERROR_IN_STL_CONTAINER {
+
+  /* Container expresssions */
+
+  template <class _Container>
+  static void
+  __begin_iterator_accessor_requirement_violation(_Container __c) {
+    __c.begin();
+  }
+  template <class _Container>
+  static void
+  __const_begin_iterator_accessor_requirement_violation(const _Container& __c) {
+    __c.begin();
+  }
+  template <class _Container>
+  static void
+  __end_iterator_accessor_requirement_violation(_Container __c) {
+    __c.end();
+  }
+  template <class _Container>
+  static void
+  __const_end_iterator_accessor_requirement_violation(const _Container& __c) {
+    __c.end();
+  }
+
+  template <class _Container>
+  static void
+  __rbegin_iterator_accessor_requirement_violation(_Container __c) {
+    __c.rbegin();
+  }
+  template <class _Container>
+  static void
+  __const_rbegin_iterator_accessor_requirement_violation(const _Container& __c) {
+    __c.rbegin();
+  }
+  template <class _Container>
+  static void
+  __rend_iterator_accessor_requirement_violation(_Container __c) {
+    __c.rend();
+  }
+  template <class _Container>
+  static void
+  __const_rend_iterator_accessor_requirement_violation(const _Container& __c) {
+    __c.rend();
+  }
+  template <class _Container>
+  static void
+  __size_function_must_be_const(const _Container& __c) {
+    __c.size();
+  }
+  template <class _Container>
+  static void
+  __size_function_requirement_violation(_Container& __c) {
+    __c.size();
+    __size_function_must_be_const(__c);
+  }
+  template <class _Container>
+  static void
+  __max_size_function_must_be_const(const _Container& __c) {
+    __c.max_size();
+  }
+  template <class _Container>
+  static void
+  __max_size_function_requirement_violation(_Container& __c) {
+    __c.max_size();
+    __max_size_function_must_be_const(__c);
+  }
+  template <class _Container>
+  static void
+  __empty_function_must_be_const(const _Container& __c) {
+    __c.empty();
+  }
+  template <class _Container>
+  static void
+  __empty_function_requirement_violation(_Container& __c) {
+    __c.empty();
+    __empty_function_must_be_const(__c);
+  }
+  template <class _Container>
+  static void
+  __swap_function_requirement_violation(_Container& __c) {
+    __c.swap(__c);
+  }
+
+};
+
+
+__STL_TYPEDEF_REQUIREMENT(iterator);
+__STL_TYPEDEF_REQUIREMENT(const_iterator);
+
+/* Containers */
+
+template <class _Container>
+struct _Container_concept_specification {
+static void
+_Container_requirement_violation(_Container __c) {
+  // Refinement of Assignable
+  _Assignable_concept_specification<_Container>::_Assignable_requirement_violation(__c);
+  // Associated Types
+  __value_type__typedef_requirement_violation<_Container>();
+  __difference_type__typedef_requirement_violation<_Container>();
+  __size_type__typedef_requirement_violation<_Container>();
+  __reference__typedef_requirement_violation<_Container>();
+  __const_reference__typedef_requirement_violation<_Container>();
+  __pointer__typedef_requirement_violation<_Container>();
+  __const_pointer__typedef_requirement_violation<_Container>();
+  __iterator__typedef_requirement_violation<_Container>();
+  __const_iterator__typedef_requirement_violation<_Container>();
+  // Valid Expressions
+  _ERROR_IN_STL_CONTAINER::__const_begin_iterator_accessor_requirement_violation(__c);
+  _ERROR_IN_STL_CONTAINER::__const_end_iterator_accessor_requirement_violation(__c);
+  _ERROR_IN_STL_CONTAINER::__begin_iterator_accessor_requirement_violation(__c);
+  _ERROR_IN_STL_CONTAINER::__end_iterator_accessor_requirement_violation(__c);
+  _ERROR_IN_STL_CONTAINER::__size_function_requirement_violation(__c);
+  _ERROR_IN_STL_CONTAINER::__max_size_function_requirement_violation(__c);
+  _ERROR_IN_STL_CONTAINER::__empty_function_requirement_violation(__c);
+  _ERROR_IN_STL_CONTAINER::__swap_function_requirement_violation(__c);
+  // Requirements on Iterators
+  typedef typename _Container::iterator iter;
+  typedef typename _Container::const_iterator const_iter;
+  _InputIterator_concept_specification<const_iter>::_InputIterator_requirement_violation(const_iter());
+  _InputIterator_concept_specification<iter>::_InputIterator_requirement_violation(iter());
+}
+};
+
+template <class _ForwardContainer>
+struct _ForwardContainer_concept_specification {
+static void
+_ForwardContainer_requirement_violation(_ForwardContainer __c) {
+  // Refinement of Container
+  _Container_concept_specification<_ForwardContainer>::_Container_requirement_violation(__c);
+  // Requirements on Iterators
+  typedef typename _ForwardContainer::iterator iter;
+  typedef typename _ForwardContainer::const_iterator const_iter;
+  _ForwardIterator_concept_specification<const_iter>::_ForwardIterator_requirement_violation(const_iter());
+  _Mutable_ForwardIterator_concept_specification<iter>::_Mutable_ForwardIterator_requirement_violation(iter());
+}
+};
+
+
+__STL_TYPEDEF_REQUIREMENT(reverse_iterator);
+__STL_TYPEDEF_REQUIREMENT(const_reverse_iterator);
+
+template <class _ReversibleContainer>
+struct _ReversibleContainer_concept_specification {
+static void
+_ReversibleContainer_requirement_violation(_ReversibleContainer __c) {
+  // Refinement of ForwardContainer
+  _ForwardContainer_concept_specification<_ReversibleContainer>::_ForwardContainer_requirement_violation(__c);
+  // Associated types
+  __reverse_iterator__typedef_requirement_violation<_ReversibleContainer>();
+  __const_reverse_iterator__typedef_requirement_violation<_ReversibleContainer>();
+  // Valid Expressions
+  _ERROR_IN_STL_CONTAINER::__const_rbegin_iterator_accessor_requirement_violation(__c);
+  _ERROR_IN_STL_CONTAINER::__const_rend_iterator_accessor_requirement_violation(__c);
+  _ERROR_IN_STL_CONTAINER::__rbegin_iterator_accessor_requirement_violation(__c);
+  _ERROR_IN_STL_CONTAINER::__rend_iterator_accessor_requirement_violation(__c);
+  // Requirements on Iterators
+  typedef typename _ReversibleContainer::iterator iter;
+  typedef typename _ReversibleContainer::const_iterator const_iter;
+  _BidirectionalIterator_concept_specification<const_iter>::_BidirectionalIterator_requirement_violation(const_iter());
+  _Mutable_BidirectionalIterator_concept_specification<iter>::_Mutable_BidirectionalIterator_requirement_violation(iter());
+}
+};
+
+template <class _ReversibleContainer>
+struct _const_ReversibleContainer_concept_specification {
+static void
+_const_ReversibleContainer_requirement_violation(_ReversibleContainer __c) {
+  // Refinement of Container (JGS, not ForwardContainer)
+  _Container_concept_specification<_ReversibleContainer>::_Container_requirement_violation(__c);
+  // Associated types
+  __reverse_iterator__typedef_requirement_violation<_ReversibleContainer>();
+  __const_reverse_iterator__typedef_requirement_violation<_ReversibleContainer>();
+  // Valid Expressions
+  _ERROR_IN_STL_CONTAINER::__const_rbegin_iterator_accessor_requirement_violation(__c);
+  _ERROR_IN_STL_CONTAINER::__const_rend_iterator_accessor_requirement_violation(__c);
+  _ERROR_IN_STL_CONTAINER::__rbegin_iterator_accessor_requirement_violation(__c);
+  _ERROR_IN_STL_CONTAINER::__rend_iterator_accessor_requirement_violation(__c);
+  // Requirements on Iterators
+  typedef typename _ReversibleContainer::iterator iter;
+  typedef typename _ReversibleContainer::const_iterator const_iter;
+  
+  _BidirectionalIterator_concept_specification<const_iter>::_BidirectionalIterator_requirement_violation(const_iter());
+}
+};
+
+
+template <class _RandomAccessContainer>
+struct _RandomAccessContainer_concept_specification {
+static void
+_RandomAccessContainer_requirement_violation(_RandomAccessContainer __c) {
+  // Refinement of ReversibleContainer
+  _ReversibleContainer_concept_specification<_RandomAccessContainer>::_ReversibleContainer_requirement_violation(__c);
+  // Valid Expressions
+  typedef typename _RandomAccessContainer::value_type __T;
+  typedef typename _RandomAccessContainer::difference_type _Dist;
+  typedef typename _Mutable_trait<__T>::_Type Type;
+  typedef Type* _TypePtr;
+  typedef typename _Mutable_trait<_Dist>::_Type Dist;
+  _STL_ERROR::__element_access_operator_requirement_violation(__c,
+							      _TypePtr(), 
+							      Dist());
+  // Requirements on Iterators
+  typedef typename _RandomAccessContainer::iterator iter;
+  typedef typename _RandomAccessContainer::const_iterator const_iter;
+  _RandomAccessIterator_concept_specification<const_iter>::_RandomAccessIterator_requirement_violation(const_iter());
+  _Mutable_RandomAccessIterator_concept_specification<iter>::_Mutable_RandomAccessIterator_requirement_violation(iter());
+}
+};
+
+#endif /* if __STL_USE_CONCEPT_CHECKS */
+
+#endif /* __STL_CONTAINER_CONCEPTS_H */

libstdc++-v3/bits/sequence_concepts.h

+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+#ifndef STL_SEQUENCE_CONCEPTS_H
+#define STL_SEQUENCE_CONCEPTS_H
+
+#include <bits/container_concepts.h>
+
+#ifdef __STL_USE_CONCEPT_CHECKS
+
+// This file covers the following concepts:
+//       _Sequence
+//       _FrontInsertionSequence
+//       _BackInsertionSequence
+
+struct _ERROR_IN_STL_SEQ {
+
+  template <class _XX>
+  static void
+  __fill_constructor_requirement_violation(_XX& __s) {
+    typename _XX::value_type __t = typename _XX::value_type();
+    typename _XX::difference_type __n = typename _XX::difference_type();
+    _XX __x(__n, __t);
+    __sink_unused_warning(__x);
+  }
+  template <class _XX>
+  static void
+  __fill_default_constructor_requirement_violation(_XX& __s) {
+    _STL_ERROR::__default_constructor_requirement_violation(*__s.begin());
+    typename _XX::difference_type __n = typename _XX::difference_type();
+    _XX __x(__n);
+    __sink_unused_warning(__x);
+  }  
+  template <class _XX>
+  static void
+  __range_constructor_requirement_violation(_XX& __s) {
+    _XX __x(__s.begin(), __s.end());
+    __sink_unused_warning(__x);
+  }
+  template <class _XX>
+  static void
+  __insert_function_requirement_violation(_XX& __s) {
+    typename _XX::value_type __t = typename _XX::value_type();
+    typename _XX::iterator __p = typename _XX::iterator();
+    __p = __s.insert(__p, __t);
+  }
+  template <class _XX>
+  static void
+  __fill_insert_function_requirement_violation(_XX& __s) {
+    typename _XX::value_type __t = typename _XX::value_type();
+    typename _XX::iterator __p = typename _XX::iterator();
+    typename _XX::difference_type __n = typename _XX::difference_type();
+    __s.insert(__p, __n, __t);
+  }
+  template <class _XX>
+  static void
+  __range_insert_function_requirement_violation(_XX& __s) {
+    typename _XX::iterator __p = typename _XX::iterator();
+    typename _XX::iterator __i = typename _XX::iterator();
+    typename _XX::iterator __j = typename _XX::iterator();
+    __s.insert(__p, __i, __j);
+  }
+  template <class _XX>
+  static void
+  __insert_element_function_requirement_violation(_XX& __s) {
+    typename _XX::value_type __t = typename _XX::value_type();
+    std::pair<typename _XX::iterator, bool> __r;
+    __r = __s.insert(__t);
+    __sink_unused_warning(__r);
+  }
+  template <class _XX>
+  static void
+  __unconditional_insert_element_function_requirement_violation(_XX& __s) {
+    typename _XX::value_type __t = typename _XX::value_type();
+    typename _XX::iterator __p;
+    __p = __s.insert(__t);
+    __sink_unused_warning(__p);
+  }
+  template <class _XX>
+  static void
+  __erase_function_requirement_violation(_XX& __s) {
+    typename _XX::iterator __p = typename _XX::iterator();
+    __p = __s.erase(__p);
+  }
+  template <class _XX>
+  static void
+  __range_erase_function_requirement_violation(_XX& __s) {
+    typename _XX::iterator __p = typename _XX::iterator();
+    typename _XX::iterator __q = typename _XX::iterator();
+    __p = __s.erase(__p, __q);
+  }
+  template <class _XX>
+  static void
+  __const_front_function_requirement_violation(const _XX& __s) {
+    typename _XX::const_reference __t = __s.front();
+    __sink_unused_warning(__t);
+  }
+  template <class _XX>
+  static void
+  __front_function_requirement_violation(_XX& __s) {
+    typename _XX::reference __t = __s.front();
+    __const_front_function_requirement_violation(__s);
+    __sink_unused_warning(__t);
+  }
+  template <class _XX>
+  static void
+  __const_back_function_requirement_violation(const _XX& __s) {
+    typename _XX::const_reference __t = __s.back();
+    __sink_unused_warning(__t);
+  }
+  template <class _XX>
+  static void
+  __back_function_requirement_violation(_XX& __s) {
+    typename _XX::reference __t = __s.back();
+    __const_back_function_requirement_violation(__s);
+    __sink_unused_warning(__t);
+  }
+  template <class _XX>
+  static void
+  __push_front_function_requirement_violation(_XX& __s) {
+    typename _XX::value_type __t = typename _XX::value_type();
+    __s.push_front(__t);
+  }
+  template <class _XX>
+  static void
+  __pop_front_function_requirement_violation(_XX& __s) {
+    __s.pop_front();
+  }
+  template <class _XX>
+  static void
+  __push_back_function_requirement_violation(_XX& __s) {
+    typename _XX::value_type __t = typename _XX::value_type();
+    __s.push_back(__t);
+  }
+  template <class _XX>
+  static void
+  __pop_back_function_requirement_violation(_XX& __s) {
+    __s.pop_back();
+  }
+
+};
+
+/* Sequence Containers */
+
+template <class _Sequence>
+struct _Sequence_concept_specification {
+static void
+_Sequence_requirement_violation(_Sequence __s) {
+  // Refinement of ForwardContainer
+  _ForwardContainer_concept_specification<_Sequence>::_ForwardContainer_requirement_violation(__s);
+  // Refinement of DefaultConstructible
+  _DefaultConstructible_concept_specification<_Sequence>::_DefaultConstructible_requirement_violation(__s);
+  // Valid Expressions
+  _ERROR_IN_STL_SEQ::__fill_constructor_requirement_violation(__s);
+  _ERROR_IN_STL_SEQ::__fill_default_constructor_requirement_violation(__s);
+  _ERROR_IN_STL_SEQ::__range_constructor_requirement_violation(__s);
+  _ERROR_IN_STL_SEQ::__insert_function_requirement_violation(__s);
+  _ERROR_IN_STL_SEQ::__fill_insert_function_requirement_violation(__s);
+  _ERROR_IN_STL_SEQ::__range_insert_function_requirement_violation(__s);
+  _ERROR_IN_STL_SEQ::__erase_function_requirement_violation(__s);
+  _ERROR_IN_STL_SEQ::__range_erase_function_requirement_violation(__s);
+  _ERROR_IN_STL_SEQ::__front_function_requirement_violation(__s);
+}
+};
+
+template <class _FrontInsertionSequence>
+struct _FrontInsertionSequence_concept_specification {
+static void
+_FrontInsertionSequence_requirement_violation(_FrontInsertionSequence __s) {
+  // Refinement of Sequence
+  _Sequence_concept_specification<_FrontInsertionSequence>::_Sequence_requirement_violation(__s);
+  // Valid Expressions
+  _ERROR_IN_STL_SEQ::__push_front_function_requirement_violation(__s);
+  _ERROR_IN_STL_SEQ::__pop_front_function_requirement_violation(__s);
+}
+};
+
+template <class _BackInsertionSequence>
+struct _BackInsertionSequence_concept_specification {
+static void
+_BackInsertionSequence_requirement_violation(_BackInsertionSequence __s) {
+  // Refinement of Sequence
+  _Sequence_concept_specification<_BackInsertionSequence>::_Sequence_requirement_violation(__s);
+  // Valid Expressions
+  _ERROR_IN_STL_SEQ::__back_function_requirement_violation(__s);
+  _ERROR_IN_STL_SEQ::__push_back_function_requirement_violation(__s);
+  _ERROR_IN_STL_SEQ::__pop_back_function_requirement_violation(__s);
+}
+};
+
+#endif /* if __STL_USE_CONCEPT_CHECKS */
+
+
+#endif /* STL_SEQUENCE_CONCEPTS_H */