home *** CD-ROM | disk | FTP | other *** search
/ PC World 2008 April / PCWorld_2008-04_cd.bin / temacd / devc++ / devcpp-4.9.9.2_setup.exe / debug.h < prev    next >
C/C++ Source or Header  |  2005-01-29  |  21KB  |  532 lines
  1. // Debugging support implementation -*- C++ -*-
  2.  
  3. // Copyright (C) 2003
  4. // Free Software Foundation, Inc.
  5. //
  6. // This file is part of the GNU ISO C++ Library.  This library is free
  7. // software; you can redistribute it and/or modify it under the
  8. // terms of the GNU General Public License as published by the
  9. // Free Software Foundation; either version 2, or (at your option)
  10. // any later version.
  11.  
  12. // This library is distributed in the hope that it will be useful,
  13. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15. // GNU General Public License for more details.
  16.  
  17. // You should have received a copy of the GNU General Public License along
  18. // with this library; see the file COPYING.  If not, write to the Free
  19. // Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
  20. // USA.
  21.  
  22. // As a special exception, you may use this file as part of a free software
  23. // library without restriction.  Specifically, if other files instantiate
  24. // templates or use macros or inline functions from this file, or you compile
  25. // this file and link it with other files to produce an executable, this
  26. // file does not by itself cause the resulting executable to be covered by
  27. // the GNU General Public License.  This exception does not however
  28. // invalidate any other reasons why the executable file might be covered by
  29. // the GNU General Public License.
  30.  
  31. #ifndef _GLIBCXX_DEBUG_DEBUG_H
  32. #define _GLIBCXX_DEBUG_DEBUG_H 1
  33.  
  34. /**
  35.  * Macros used by the implementation to verify certain
  36.  * properties. These macros may only be used directly by the debug
  37.  * wrappers. Note that these are macros (instead of the more obviously
  38.  * "correct" choice of making them functions) because we need line and
  39.  * file information at the call site, to minimize the distance between
  40.  * the user error and where the error is reported.
  41.  *
  42.  */
  43. #define _GLIBCXX_DEBUG_VERIFY(_Condition,_ErrorMessage)        \
  44.   do {                                    \
  45.     if (! (_Condition))                            \
  46.       ::__gnu_debug::_Error_formatter::_M_at(__FILE__, __LINE__)    \
  47.       ._ErrorMessage._M_error();                    \
  48.   } while (false)
  49.  
  50. // Verify that [_First, _Last) forms a valid iterator range.
  51. #define __glibcxx_check_valid_range(_First,_Last)            \
  52. _GLIBCXX_DEBUG_VERIFY(::__gnu_debug::__valid_range(_First, _Last),    \
  53.               _M_message(::__gnu_debug::__msg_valid_range)    \
  54.               ._M_iterator(_First, #_First)            \
  55.               ._M_iterator(_Last, #_Last))
  56.  
  57. /** Verify that we can insert into *this with the iterator _Position.
  58.  *  Insertion into a container at a specific position requires that
  59.  *  the iterator be nonsingular (i.e., either dereferenceable or
  60.  *  past-the-end) and that it reference the sequence we are inserting
  61.  *  into. Note that this macro is only valid when the container is a
  62.  *  _Safe_sequence and the iterator is a _Safe_iterator.
  63. */
  64. #define __glibcxx_check_insert(_Position)                \
  65. _GLIBCXX_DEBUG_VERIFY(!_Position._M_singular(),                \
  66.               _M_message(::__gnu_debug::__msg_insert_singular) \
  67.               ._M_sequence(*this, "this")            \
  68.               ._M_iterator(_Position, #_Position));        \
  69. _GLIBCXX_DEBUG_VERIFY(_Position._M_attached_to(this),            \
  70.               _M_message(::__gnu_debug::__msg_insert_different) \
  71.               ._M_sequence(*this, "this")            \
  72.               ._M_iterator(_Position, #_Position))
  73.  
  74. /** Verify that we can insert the values in the iterator range
  75.  *  [_First, _Last) into *this with the iterator _Position.  Insertion
  76.  *  into a container at a specific position requires that the iterator
  77.  *  be nonsingular (i.e., either dereferenceable or past-the-end),
  78.  *  that it reference the sequence we are inserting into, and that the
  79.  *  iterator range [_First, Last) is a valid (possibly empty)
  80.  *  range. Note that this macro is only valid when the container is a
  81.  *  _Safe_sequence and the iterator is a _Safe_iterator.
  82.  *
  83.  *  @tbd We would like to be able to check for noninterference of
  84.  *  _Position and the range [_First, _Last), but that can't (in
  85.  *  general) be done.
  86. */
  87. #define __glibcxx_check_insert_range(_Position,_First,_Last)        \
  88. __glibcxx_check_valid_range(_First,_Last);                \
  89. _GLIBCXX_DEBUG_VERIFY(!_Position._M_singular(),                \
  90.               _M_message(::__gnu_debug::__msg_insert_singular) \
  91.                       ._M_sequence(*this, "this")            \
  92.               ._M_iterator(_Position, #_Position));        \
  93. _GLIBCXX_DEBUG_VERIFY(_Position._M_attached_to(this),            \
  94.               _M_message(::__gnu_debug::__msg_insert_different) \
  95.               ._M_sequence(*this, "this")            \
  96.               ._M_iterator(_Position, #_Position))
  97.  
  98. /** Verify that we can erase the element referenced by the iterator
  99.  * _Position. We can erase the element if the _Position iterator is
  100.  * dereferenceable and references this sequence.
  101. */
  102. #define __glibcxx_check_erase(_Position)                \
  103. _GLIBCXX_DEBUG_VERIFY(_Position._M_dereferenceable(),            \
  104.               _M_message(::__gnu_debug::__msg_erase_bad)    \
  105.                       ._M_sequence(*this, "this")            \
  106.               ._M_iterator(_Position, #_Position));        \
  107. _GLIBCXX_DEBUG_VERIFY(_Position._M_attached_to(this),            \
  108.               _M_message(::__gnu_debug::__msg_erase_different) \
  109.               ._M_sequence(*this, "this")            \
  110.               ._M_iterator(_Position, #_Position))
  111.  
  112. /** Verify that we can erase the elements in the iterator range
  113.  *  [_First, _Last). We can erase the elements if [_First, _Last) is a
  114.  *  valid iterator range within this sequence.
  115. */
  116. #define __glibcxx_check_erase_range(_First,_Last)            \
  117. __glibcxx_check_valid_range(_First,_Last);                \
  118. _GLIBCXX_DEBUG_VERIFY(_First._M_attached_to(this),            \
  119.               _M_message(::__gnu_debug::__msg_erase_different) \
  120.                       ._M_sequence(*this, "this")            \
  121.               ._M_iterator(_First, #_First)            \
  122.               ._M_iterator(_Last, #_Last))
  123.  
  124. // Verify that the subscript _N is less than the container's size.
  125. #define __glibcxx_check_subscript(_N)                    \
  126. _GLIBCXX_DEBUG_VERIFY(_N < this->size(),                \
  127.               _M_message(::__gnu_debug::__msg_subscript_oob) \
  128.                       ._M_sequence(*this, "this")            \
  129.               ._M_integer(_N, #_N)                \
  130.               ._M_integer(this->size(), "size"))
  131.  
  132. // Verify that the container is nonempty
  133. #define __glibcxx_check_nonempty()                    \
  134. _GLIBCXX_DEBUG_VERIFY(! this->empty(),                    \
  135.               _M_message(::__gnu_debug::__msg_empty)    \
  136.                       ._M_sequence(*this, "this"))
  137.  
  138. // Verify that the < operator for elements in the sequence is a
  139. // StrictWeakOrdering by checking that it is irreflexive.
  140. #define __glibcxx_check_strict_weak_ordering(_First,_Last)    \
  141. _GLIBCXX_DEBUG_ASSERT(_First == _Last || !(*_First < *_First))
  142.  
  143. // Verify that the predicate is StrictWeakOrdering by checking that it
  144. // is irreflexive.
  145. #define __glibcxx_check_strict_weak_ordering_pred(_First,_Last,_Pred)    \
  146. _GLIBCXX_DEBUG_ASSERT(_First == _Last || !_Pred(*_First, *_First))
  147.  
  148.  
  149. // Verify that the iterator range [_First, _Last) is sorted
  150. #define __glibcxx_check_sorted(_First,_Last)                \
  151. __glibcxx_check_valid_range(_First,_Last);                \
  152. __glibcxx_check_strict_weak_ordering(_First,_Last);            \
  153. _GLIBCXX_DEBUG_VERIFY(::__gnu_debug::__check_sorted(_First, _Last),    \
  154.               _M_message(::__gnu_debug::__msg_unsorted)    \
  155.                       ._M_iterator(_First, #_First)            \
  156.               ._M_iterator(_Last, #_Last))
  157.  
  158. /** Verify that the iterator range [_First, _Last) is sorted by the
  159.     predicate _Pred. */
  160. #define __glibcxx_check_sorted_pred(_First,_Last,_Pred)            \
  161. __glibcxx_check_valid_range(_First,_Last);                \
  162. __glibcxx_check_strict_weak_ordering_pred(_First,_Last,_Pred);            \
  163. _GLIBCXX_DEBUG_VERIFY(::__gnu_debug::__check_sorted(_First, _Last, _Pred), \
  164.               _M_message(::__gnu_debug::__msg_unsorted_pred) \
  165.                       ._M_iterator(_First, #_First)            \
  166.               ._M_iterator(_Last, #_Last)            \
  167.               ._M_string(#_Pred))
  168.  
  169. /** Verify that the iterator range [_First, _Last) is partitioned
  170.     w.r.t. the value _Value. */
  171. #define __glibcxx_check_partitioned(_First,_Last,_Value)        \
  172. __glibcxx_check_valid_range(_First,_Last);                \
  173. _GLIBCXX_DEBUG_VERIFY(::__gnu_debug::__check_partitioned(_First, _Last,    \
  174.                              _Value),    \
  175.               _M_message(::__gnu_debug::__msg_unpartitioned) \
  176.               ._M_iterator(_First, #_First)            \
  177.               ._M_iterator(_Last, #_Last)            \
  178.               ._M_string(#_Value))
  179.  
  180. /** Verify that the iterator range [_First, _Last) is partitioned
  181.     w.r.t. the value _Value and predicate _Pred. */
  182. #define __glibcxx_check_partitioned_pred(_First,_Last,_Value,_Pred)    \
  183. __glibcxx_check_valid_range(_First,_Last);                \
  184. _GLIBCXX_DEBUG_VERIFY(::__gnu_debug::__check_partitioned(_First, _Last,    \
  185.                              _Value, _Pred), \
  186.               _M_message(::__gnu_debug::__msg_unpartitioned_pred) \
  187.               ._M_iterator(_First, #_First)            \
  188.               ._M_iterator(_Last, #_Last)            \
  189.               ._M_string(#_Pred)                \
  190.                       ._M_string(#_Value))
  191.  
  192. // Verify that the iterator range [_First, _Last) is a heap
  193. #define __glibcxx_check_heap(_First,_Last)                \
  194. __glibcxx_check_valid_range(_First,_Last);                \
  195. _GLIBCXX_DEBUG_VERIFY(::std::__is_heap(_First, _Last),        \
  196.               _M_message(::__gnu_debug::__msg_not_heap)    \
  197.               ._M_iterator(_First, #_First)            \
  198.               ._M_iterator(_Last, #_Last))
  199.  
  200. /** Verify that the iterator range [_First, _Last) is a heap
  201.     w.r.t. the predicate _Pred. */
  202. #define __glibcxx_check_heap_pred(_First,_Last,_Pred)            \
  203. __glibcxx_check_valid_range(_First,_Last);                \
  204. _GLIBCXX_DEBUG_VERIFY(::std::__is_heap(_First, _Last, _Pred),        \
  205.               _M_message(::__gnu_debug::__msg_not_heap_pred) \
  206.                       ._M_iterator(_First, #_First)            \
  207.               ._M_iterator(_Last, #_Last)            \
  208.               ._M_string(#_Pred))
  209.  
  210. #ifdef _GLIBCXX_DEBUG_PEDANTIC
  211. #  define __glibcxx_check_string(_String) _GLIBCXX_DEBUG_ASSERT(_String != 0)
  212. #  define __glibcxx_check_string_len(_String,_Len) \
  213.        _GLIBCXX_DEBUG_ASSERT(_String != 0 || _Len == 0)
  214. #else
  215. #  define __glibcxx_check_string(_String)
  216. #  define __glibcxx_check_string_len(_String,_Len)
  217. #endif
  218.  
  219. /** Macros used by the implementation outside of debug wrappers to
  220.  *  verify certain properties. The __glibcxx_requires_xxx macros are
  221.  *  merely wrappers around the __glibcxx_check_xxx wrappers when we
  222.  *  are compiling with debug mode, but disappear when we are in
  223.  *  release mode so that there is no checking performed in, e.g., the
  224.  *  standard library algorithms.
  225. */
  226. #ifdef _GLIBCXX_DEBUG
  227. #  define _GLIBCXX_DEBUG_ASSERT(_Condition) assert(_Condition)
  228.  
  229. #  ifdef _GLIBXX_DEBUG_PEDANTIC
  230. #    define _GLIBCXX_DEBUG_PEDASSERT(_Condition) assert(_Condition)
  231. #  else
  232. #    define _GLIBCXX_DEBUG_PEDASSERT(_Condition)
  233. #  endif
  234.  
  235. #  define __glibcxx_requires_cond(_Cond,_Msg) _GLIBCXX_DEBUG_VERIFY(_Cond,_Msg)
  236. #  define __glibcxx_requires_valid_range(_First,_Last) \
  237.      __glibcxx_check_valid_range(_First,_Last)
  238. #  define __glibcxx_requires_sorted(_First,_Last) \
  239.      __glibcxx_check_sorted(_First,_Last)
  240. #  define __glibcxx_requires_sorted_pred(_First,_Last,_Pred) \
  241.      __glibcxx_check_sorted_pred(_First,_Last,_Pred)
  242. #  define __glibcxx_requires_partitioned(_First,_Last,_Value)    \
  243.      __glibcxx_check_partitioned(_First,_Last,_Value)
  244. #  define __glibcxx_requires_partitioned_pred(_First,_Last,_Value,_Pred) \
  245.      __glibcxx_check_partitioned_pred(_First,_Last,_Value,_Pred)
  246. #  define __glibcxx_requires_heap(_First,_Last) \
  247.      __glibcxx_check_heap(_First,_Last)
  248. #  define __glibcxx_requires_heap_pred(_First,_Last,_Pred) \
  249.      __glibcxx_check_heap_pred(_First,_Last,_Pred)
  250. #  define __glibcxx_requires_nonempty() __glibcxx_check_nonempty()
  251. #  define __glibcxx_requires_string(_String) __glibcxx_check_string(_String)
  252. #  define __glibcxx_requires_string_len(_String,_Len)    \
  253.      __glibcxx_check_string_len(_String,_Len)
  254. #  define __glibcxx_requires_subscript(_N) __glibcxx_check_subscript(_N)
  255. #else
  256. #  define _GLIBCXX_DEBUG_ASSERT(_Condition)
  257. #  define _GLIBCXX_DEBUG_PEDASSERT(_Condition)
  258. #  define __glibcxx_requires_cond(_Cond,_Msg)
  259. #  define __glibcxx_requires_valid_range(_First,_Last)
  260. #  define __glibcxx_requires_sorted(_First,_Last)
  261. #  define __glibcxx_requires_sorted_pred(_First,_Last,_Pred)
  262. #  define __glibcxx_requires_partitioned(_First,_Last,_Value)
  263. #  define __glibcxx_requires_partitioned_pred(_First,_Last,_Value,_Pred)
  264. #  define __glibcxx_requires_heap(_First,_Last)
  265. #  define __glibcxx_requires_heap_pred(_First,_Last,_Pred)
  266. #  define __glibcxx_requires_nonempty()
  267. #  define __glibcxx_requires_string(_String)
  268. #  define __glibcxx_requires_string_len(_String,_Len)
  269. #  define __glibcxx_requires_subscript(_N)
  270. #endif
  271.  
  272. #include <cassert> // TBD: temporary
  273.  
  274. #include <stddef.h>                       // for ptrdiff_t
  275. #include <bits/stl_iterator_base_types.h> // for iterator_traits, categories
  276. #include <bits/type_traits.h>             // for _Is_integer
  277.  
  278. namespace __gnu_debug
  279. {
  280.   template<typename _Iterator, typename _Sequence>
  281.     class _Safe_iterator;
  282.  
  283.   // An arbitrary iterator pointer is not singular.
  284.   inline bool
  285.   __check_singular_aux(const void*) { return false; }
  286.  
  287.   // We may have an iterator that derives from _Safe_iterator_base but isn't
  288.   // a _Safe_iterator.
  289.   template<typename _Iterator>
  290.     inline bool
  291.     __check_singular(_Iterator& __x)
  292.     { return __gnu_debug::__check_singular_aux(&__x); }
  293.  
  294.   /** Non-NULL pointers are nonsingular. */
  295.   template<typename _Tp>
  296.     inline bool
  297.     __check_singular(const _Tp* __ptr)
  298.     { return __ptr == 0; }
  299.  
  300.   /** Safe iterators know if they are singular. */
  301.   template<typename _Iterator, typename _Sequence>
  302.     inline bool
  303.     __check_singular(const _Safe_iterator<_Iterator, _Sequence>& __x)
  304.     { return __x._M_singular(); }
  305.  
  306.   /** Assume that some arbitrary iterator is dereferenceable, because we
  307.       can't prove that it isn't. */
  308.   template<typename _Iterator>
  309.     inline bool
  310.     __check_dereferenceable(_Iterator&)
  311.     { return true; }
  312.  
  313.   /** Non-NULL pointers are dereferenceable. */
  314.   template<typename _Tp>
  315.     inline bool
  316.     __check_dereferenceable(const _Tp* __ptr)
  317.     { return __ptr; }
  318.  
  319.   /** Safe iterators know if they are singular. */
  320.   template<typename _Iterator, typename _Sequence>
  321.     inline bool
  322.     __check_dereferenceable(const _Safe_iterator<_Iterator, _Sequence>& __x)
  323.     { return __x._M_dereferenceable(); }
  324.  
  325.   /** If the distance between two random access iterators is
  326.    *  nonnegative, assume the range is valid.
  327.   */
  328.   template<typename _RandomAccessIterator>
  329.     inline bool
  330.     __valid_range_aux2(const _RandomAccessIterator& __first,
  331.                const _RandomAccessIterator& __last,
  332.                std::random_access_iterator_tag)
  333.     { return __last - __first >= 0; }
  334.  
  335.   /** Can't test for a valid range with input iterators, because
  336.    *  iteration may be destructive. So we just assume that the range
  337.    *  is valid.
  338.   */
  339.   template<typename _InputIterator>
  340.     inline bool
  341.     __valid_range_aux2(const _InputIterator&, const _InputIterator&,
  342.                std::input_iterator_tag)
  343.     { return true; }
  344.  
  345.   /** We say that integral types for a valid range, and defer to other
  346.    *  routines to realize what to do with integral types instead of
  347.    *  iterators.
  348.   */
  349.   template<typename _Integral>
  350.     inline bool
  351.     __valid_range_aux(const _Integral&, const _Integral&, __true_type)
  352.     { return true; }
  353.  
  354.   /** We have iterators, so figure out what kind of iterators that are
  355.    *  to see if we can check the range ahead of time.
  356.   */
  357.   template<typename _InputIterator>
  358.     inline bool
  359.     __valid_range_aux(const _InputIterator& __first,
  360.               const _InputIterator& __last, __false_type)
  361.   {
  362.     typedef typename std::iterator_traits<_InputIterator>::iterator_category
  363.       _Category;
  364.     return __gnu_debug::__valid_range_aux2(__first, __last, _Category());
  365.   }
  366.  
  367.   /** Don't know what these iterators are, or if they are even
  368.    *  iterators (we may get an integral type for InputIterator), so
  369.    *  see if they are integral and pass them on to the next phase
  370.    *  otherwise.
  371.   */
  372.   template<typename _InputIterator>
  373.     inline bool
  374.     __valid_range(const _InputIterator& __first, const _InputIterator& __last)
  375.     {
  376.       typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
  377.       return __gnu_debug::__valid_range_aux(__first, __last, _Integral());
  378.     }
  379.  
  380.   /** Safe iterators know how to check if they form a valid range. */
  381.   template<typename _Iterator, typename _Sequence>
  382.     inline bool
  383.     __valid_range(const _Safe_iterator<_Iterator, _Sequence>& __first,
  384.           const _Safe_iterator<_Iterator, _Sequence>& __last)
  385.     { return __first._M_valid_range(__last); }
  386.  
  387.   /* Checks that [first, last) is a valid range, and then returns
  388.    * __first. This routine is useful when we can't use a separate
  389.    * assertion statement because, e.g., we are in a constructor.
  390.   */
  391.   template<typename _InputIterator>
  392.     inline _InputIterator
  393.     __check_valid_range(const _InputIterator& __first,
  394.             const _InputIterator& __last)
  395.     {
  396.       _GLIBCXX_DEBUG_ASSERT(__gnu_debug::__valid_range(__first, __last));
  397.       return __first;
  398.     }
  399.  
  400.   /** Checks that __s is non-NULL or __n == 0, and then returns __s. */
  401.   template<typename _CharT, typename _Integer>
  402.     inline const _CharT*
  403.     __check_string(const _CharT* __s, const _Integer& __n)
  404.     {
  405. #ifdef _GLIBCXX_DEBUG_PEDANTIC
  406.       _GLIBCXX_DEBUG_ASSERT(__s != 0 || __n == 0);
  407. #endif
  408.       return __s;
  409.     }
  410.  
  411.   /** Checks that __s is non-NULL and then returns __s. */
  412.   template<typename _CharT>
  413.     inline const _CharT*
  414.     __check_string(const _CharT* __s)
  415.     {
  416. #ifdef _GLIBCXX_DEBUG_PEDANTIC
  417.       _GLIBCXX_DEBUG_ASSERT(__s != 0);
  418. #endif
  419.       return __s;
  420.     }
  421.  
  422.   // Can't check if an input iterator sequence is sorted, because we
  423.   // can't step through the sequence.
  424.   template<typename _InputIterator>
  425.     inline bool
  426.     __check_sorted_aux(const _InputIterator&, const _InputIterator&,
  427.                        std::input_iterator_tag)
  428.     { return true; }
  429.  
  430.   // Can verify if a forward iterator sequence is in fact sorted using
  431.   // std::__is_sorted
  432.   template<typename _ForwardIterator>
  433.     inline bool
  434.     __check_sorted_aux(_ForwardIterator __first, _ForwardIterator __last,
  435.                        std::forward_iterator_tag)
  436.     {
  437.       if (__first == __last)
  438.         return true;
  439.  
  440.       _ForwardIterator __next = __first;
  441.       for (++__next; __next != __last; __first = __next, ++__next) {
  442.         if (*__next < *__first)
  443.           return false;
  444.       }
  445.  
  446.       return true;
  447.     }
  448.  
  449.   // Can't check if an input iterator sequence is sorted, because we can't step
  450.   // through the sequence.
  451.   template<typename _InputIterator, typename _Predicate>
  452.     inline bool
  453.     __check_sorted_aux(const _InputIterator&, const _InputIterator&,
  454.                        _Predicate, std::input_iterator_tag)
  455.     { return true; }
  456.  
  457.   // Can verify if a forward iterator sequence is in fact sorted using
  458.   // std::__is_sorted
  459.   template<typename _ForwardIterator, typename _Predicate>
  460.     inline bool
  461.     __check_sorted_aux(_ForwardIterator __first, _ForwardIterator __last,
  462.                        _Predicate __pred, std::forward_iterator_tag)
  463.     {
  464.       if (__first == __last)
  465.         return true;
  466.  
  467.       _ForwardIterator __next = __first;
  468.       for (++__next; __next != __last; __first = __next, ++__next) {
  469.         if (__pred(*__next, *__first))
  470.           return false;
  471.       }
  472.  
  473.       return true;
  474.     }
  475.  
  476.   // Determine if a sequence is sorted.
  477.   template<typename _InputIterator>
  478.     inline bool
  479.     __check_sorted(const _InputIterator& __first, const _InputIterator& __last)
  480.     {
  481.       typedef typename std::iterator_traits<_InputIterator>::iterator_category
  482.         _Category;
  483.       return __gnu_debug::__check_sorted_aux(__first, __last, _Category());
  484.     }
  485.  
  486.   template<typename _InputIterator, typename _Predicate>
  487.     inline bool
  488.     __check_sorted(const _InputIterator& __first, const _InputIterator& __last,
  489.                    _Predicate __pred)
  490.     {
  491.       typedef typename std::iterator_traits<_InputIterator>::iterator_category
  492.         _Category;
  493.       return __gnu_debug::__check_sorted_aux(__first, __last, __pred,
  494.                          _Category());
  495.     }
  496.  
  497.   // _GLIBCXX_RESOLVE_LIB_DEFECTS
  498.   // 270. Binary search requirements overly strict
  499.   // Determine if a sequence is partitioned w.r.t. this element.
  500.   template<typename _ForwardIterator, typename _Tp>
  501.     inline bool
  502.     __check_partitioned(_ForwardIterator __first, _ForwardIterator __last,
  503.             const _Tp& __value)
  504.     {
  505.       while (__first != __last && *__first < __value)
  506.     ++__first;
  507.       while (__first != __last && !(*__first < __value))
  508.     ++__first;
  509.       return __first == __last;
  510.     }
  511.  
  512.   // Determine if a sequence is partitioned w.r.t. this element.
  513.   template<typename _ForwardIterator, typename _Tp, typename _Pred>
  514.     inline bool
  515.     __check_partitioned(_ForwardIterator __first, _ForwardIterator __last,
  516.             const _Tp& __value, _Pred __pred)
  517.     {
  518.       while (__first != __last && __pred(*__first, __value))
  519.     ++__first;
  520.       while (__first != __last && !__pred(*__first, __value))
  521.     ++__first;
  522.       return __first == __last;
  523.     }
  524. } // namespace __gnu_debug
  525.  
  526. #ifdef _GLIBCXX_DEBUG
  527. // We need the error formatter
  528. #  include <debug/formatter.h>
  529. #endif
  530.  
  531. #endif
  532.