stabilize build system: depends, installer, boost/bdb fixes, cross targets groundwork

depends/x86_64-pc-linux-gnu/include/boost/xpressive/sub_match.hpp

@@ -0,0 +1,460 @@
+///////////////////////////////////////////////////////////////////////////////
+/// \file sub_match.hpp
+/// Contains the definition of the class template sub_match\<\>
+/// and associated helper functions
+//
+//  Copyright 2008 Eric Niebler. Distributed under the Boost
+//  Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_XPRESSIVE_SUB_MATCH_HPP_EAN_10_04_2005
+#define BOOST_XPRESSIVE_SUB_MATCH_HPP_EAN_10_04_2005
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+#include <iosfwd>
+#include <string>
+#include <utility>
+#include <iterator>
+#include <algorithm>
+#include <boost/mpl/assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/iterator/iterator_traits.hpp>
+#include <boost/range/const_iterator.hpp>
+#include <boost/range/mutable_iterator.hpp>
+#include <boost/xpressive/detail/detail_fwd.hpp>
+
+//{{AFX_DOC_COMMENT
+///////////////////////////////////////////////////////////////////////////////
+// This is a hack to get Doxygen to show the inheritance relation between
+// sub_match<T> and std::pair<T,T>.
+#ifdef BOOST_XPRESSIVE_DOXYGEN_INVOKED
+/// INTERNAL ONLY
+namespace std
+{
+    /// INTERNAL ONLY
+    template<typename, typename> struct pair {};
+}
+#endif
+//}}AFX_DOC_COMMENT
+
+namespace boost { namespace xpressive
+{
+
+///////////////////////////////////////////////////////////////////////////////
+// sub_match
+//
+/// \brief Class template \c sub_match denotes the sequence of characters matched by a particular
+/// marked sub-expression.
+///
+/// When the marked sub-expression denoted by an object of type \c sub_match\<\> participated in a
+/// regular expression match then member \c matched evaluates to \c true, and members \c first and \c second
+/// denote the range of characters <tt>[first,second)</tt> which formed that match. Otherwise \c matched is \c false,
+/// and members \c first and \c second contained undefined values.
+///
+/// If an object of type \c sub_match\<\> represents sub-expression 0 - that is to say the whole match -
+/// then member \c matched is always \c true, unless a partial match was obtained as a result of the flag
+/// \c match_partial being passed to a regular expression algorithm, in which case member \c matched is
+/// \c false, and members \c first and \c second represent the character range that formed the partial match.
+template<typename BidiIter>
+struct sub_match
+  : std::pair<BidiIter, BidiIter>
+{
+private:
+    /// INTERNAL ONLY
+    ///
+    struct dummy { int i_; };
+    typedef int dummy::*bool_type;
+
+public:
+    typedef typename iterator_value<BidiIter>::type value_type;
+    typedef typename iterator_difference<BidiIter>::type difference_type;
+    typedef typename detail::string_type<value_type>::type string_type;
+    typedef BidiIter iterator;
+
+    sub_match()
+      : std::pair<BidiIter, BidiIter>()
+      , matched(false)
+    {
+    }
+
+    sub_match(BidiIter first, BidiIter second, bool matched_ = false)
+      : std::pair<BidiIter, BidiIter>(first, second)
+      , matched(matched_)
+    {
+    }
+
+    string_type str() const
+    {
+        return this->matched ? string_type(this->first, this->second) : string_type();
+    }
+
+    operator string_type() const
+    {
+        return this->matched ? string_type(this->first, this->second) : string_type();
+    }
+
+    difference_type length() const
+    {
+        return this->matched ? std::distance(this->first, this->second) : 0;
+    }
+
+    operator bool_type() const
+    {
+        return this->matched ? &dummy::i_ : 0;
+    }
+
+    bool operator !() const
+    {
+        return !this->matched;
+    }
+
+    /// \brief Performs a lexicographic string comparison
+    /// \param str the string against which to compare
+    /// \return the results of <tt>(*this).str().compare(str)</tt>
+    int compare(string_type const &str) const
+    {
+        return this->str().compare(str);
+    }
+
+    /// \overload
+    ///
+    int compare(sub_match const &sub) const
+    {
+        return this->str().compare(sub.str());
+    }
+
+    /// \overload
+    ///
+    int compare(value_type const *ptr) const
+    {
+        return this->str().compare(ptr);
+    }
+
+    /// \brief true if this sub-match participated in the full match.
+    bool matched;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+/// \brief \c range_begin() to make \c sub_match\<\> a valid range
+/// \param sub the \c sub_match\<\> object denoting the range
+/// \return \c sub.first
+/// \pre \c sub.first is not singular
+template<typename BidiIter>
+inline BidiIter range_begin(sub_match<BidiIter> &sub)
+{
+    return sub.first;
+}
+
+/// \overload
+///
+template<typename BidiIter>
+inline BidiIter range_begin(sub_match<BidiIter> const &sub)
+{
+    return sub.first;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+/// \brief \c range_end() to make \c sub_match\<\> a valid range
+/// \param sub the \c sub_match\<\> object denoting the range
+/// \return \c sub.second
+/// \pre \c sub.second is not singular
+template<typename BidiIter>
+inline BidiIter range_end(sub_match<BidiIter> &sub)
+{
+    return sub.second;
+}
+
+/// \overload
+///
+template<typename BidiIter>
+inline BidiIter range_end(sub_match<BidiIter> const &sub)
+{
+    return sub.second;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+/// \brief insertion operator for sending sub-matches to ostreams
+/// \param sout output stream.
+/// \param sub sub_match object to be written to the stream.
+/// \return sout \<\< sub.str()
+template<typename BidiIter, typename Char, typename Traits>
+inline std::basic_ostream<Char, Traits> &operator <<
+(
+    std::basic_ostream<Char, Traits> &sout
+  , sub_match<BidiIter> const &sub
+)
+{
+    typedef typename iterator_value<BidiIter>::type char_type;
+    BOOST_MPL_ASSERT_MSG(
+        (boost::is_same<Char, char_type>::value)
+      , CHARACTER_TYPES_OF_STREAM_AND_SUB_MATCH_MUST_MATCH
+      , (Char, char_type)
+    );
+    if(sub.matched)
+    {
+        std::ostream_iterator<char_type, Char, Traits> iout(sout);
+        std::copy(sub.first, sub.second, iout);
+    }
+    return sout;
+}
+
+
+// BUGBUG make these more efficient
+
+template<typename BidiIter>
+bool operator == (sub_match<BidiIter> const &lhs, sub_match<BidiIter> const &rhs)
+{
+    return lhs.compare(rhs) == 0;
+}
+
+template<typename BidiIter>
+bool operator != (sub_match<BidiIter> const &lhs, sub_match<BidiIter> const &rhs)
+{
+    return lhs.compare(rhs) != 0;
+}
+
+template<typename BidiIter>
+bool operator < (sub_match<BidiIter> const &lhs, sub_match<BidiIter> const &rhs)
+{
+    return lhs.compare(rhs) < 0;
+}
+
+template<typename BidiIter>
+bool operator <= (sub_match<BidiIter> const &lhs, sub_match<BidiIter> const &rhs)
+{
+    return lhs.compare(rhs) <= 0;
+}
+
+template<typename BidiIter>
+bool operator >= (sub_match<BidiIter> const &lhs, sub_match<BidiIter> const &rhs)
+{
+    return lhs.compare(rhs) >= 0;
+}
+
+template<typename BidiIter>
+bool operator > (sub_match<BidiIter> const &lhs, sub_match<BidiIter> const &rhs)
+{
+    return lhs.compare(rhs) > 0;
+}
+
+template<typename BidiIter>
+bool operator == (typename iterator_value<BidiIter>::type const *lhs, sub_match<BidiIter> const &rhs)
+{
+    return lhs == rhs.str();
+}
+
+template<typename BidiIter>
+bool operator != (typename iterator_value<BidiIter>::type const *lhs, sub_match<BidiIter> const &rhs)
+{
+    return lhs != rhs.str();
+}
+
+template<typename BidiIter>
+bool operator < (typename iterator_value<BidiIter>::type const *lhs, sub_match<BidiIter> const &rhs)
+{
+    return lhs < rhs.str();
+}
+
+template<typename BidiIter>
+bool operator > (typename iterator_value<BidiIter>::type const *lhs, sub_match<BidiIter> const &rhs)
+{
+    return lhs> rhs.str();
+}
+
+template<typename BidiIter>
+bool operator >= (typename iterator_value<BidiIter>::type const *lhs, sub_match<BidiIter> const &rhs)
+{
+    return lhs >= rhs.str();
+}
+
+template<typename BidiIter>
+bool operator <= (typename iterator_value<BidiIter>::type const *lhs, sub_match<BidiIter> const &rhs)
+{
+    return lhs <= rhs.str();
+}
+
+template<typename BidiIter>
+bool operator == (sub_match<BidiIter> const &lhs, typename iterator_value<BidiIter>::type const *rhs)
+{
+    return lhs.str() == rhs;
+}
+
+template<typename BidiIter>
+bool operator != (sub_match<BidiIter> const &lhs, typename iterator_value<BidiIter>::type const *rhs)
+{
+    return lhs.str() != rhs;
+}
+
+template<typename BidiIter>
+bool operator < (sub_match<BidiIter> const &lhs, typename iterator_value<BidiIter>::type const *rhs)
+{
+    return lhs.str() < rhs;
+}
+
+template<typename BidiIter>
+bool operator > (sub_match<BidiIter> const &lhs, typename iterator_value<BidiIter>::type const *rhs)
+{
+    return lhs.str() > rhs;
+}
+
+template<typename BidiIter>
+bool operator >= (sub_match<BidiIter> const &lhs, typename iterator_value<BidiIter>::type const *rhs)
+{
+    return lhs.str() >= rhs;
+}
+
+template<typename BidiIter>
+bool operator <= (sub_match<BidiIter> const &lhs, typename iterator_value<BidiIter>::type const *rhs)
+{
+    return lhs.str() <= rhs;
+}
+
+template<typename BidiIter>
+bool operator == (typename iterator_value<BidiIter>::type const &lhs, sub_match<BidiIter> const &rhs)
+{
+    return lhs == rhs.str();
+}
+
+template<typename BidiIter>
+bool operator != (typename iterator_value<BidiIter>::type const &lhs, sub_match<BidiIter> const &rhs)
+{
+    return lhs != rhs.str();
+}
+
+template<typename BidiIter>
+bool operator < (typename iterator_value<BidiIter>::type const &lhs, sub_match<BidiIter> const &rhs)
+{
+    return lhs < rhs.str();
+}
+
+template<typename BidiIter>
+bool operator > (typename iterator_value<BidiIter>::type const &lhs, sub_match<BidiIter> const &rhs)
+{
+    return lhs> rhs.str();
+}
+
+template<typename BidiIter>
+bool operator >= (typename iterator_value<BidiIter>::type const &lhs, sub_match<BidiIter> const &rhs)
+{
+    return lhs >= rhs.str();
+}
+
+template<typename BidiIter>
+bool operator <= (typename iterator_value<BidiIter>::type const &lhs, sub_match<BidiIter> const &rhs)
+{
+    return lhs <= rhs.str();
+}
+
+template<typename BidiIter>
+bool operator == (sub_match<BidiIter> const &lhs, typename iterator_value<BidiIter>::type const &rhs)
+{
+    return lhs.str() == rhs;
+}
+
+template<typename BidiIter>
+bool operator != (sub_match<BidiIter> const &lhs, typename iterator_value<BidiIter>::type const &rhs)
+{
+    return lhs.str() != rhs;
+}
+
+template<typename BidiIter>
+bool operator < (sub_match<BidiIter> const &lhs, typename iterator_value<BidiIter>::type const &rhs)
+{
+    return lhs.str() < rhs;
+}
+
+template<typename BidiIter>
+bool operator > (sub_match<BidiIter> const &lhs, typename iterator_value<BidiIter>::type const &rhs)
+{
+    return lhs.str() > rhs;
+}
+
+template<typename BidiIter>
+bool operator >= (sub_match<BidiIter> const &lhs, typename iterator_value<BidiIter>::type const &rhs)
+{
+    return lhs.str() >= rhs;
+}
+
+template<typename BidiIter>
+bool operator <= (sub_match<BidiIter> const &lhs, typename iterator_value<BidiIter>::type const &rhs)
+{
+    return lhs.str() <= rhs;
+}
+
+// Operator+ convenience function
+template<typename BidiIter>
+typename sub_match<BidiIter>::string_type
+operator + (sub_match<BidiIter> const &lhs, sub_match<BidiIter> const &rhs)
+{
+    return lhs.str() + rhs.str();
+}
+
+template<typename BidiIter>
+typename sub_match<BidiIter>::string_type
+operator + (sub_match<BidiIter> const &lhs, typename iterator_value<BidiIter>::type const &rhs)
+{
+    return lhs.str() + rhs;
+}
+
+template<typename BidiIter>
+typename sub_match<BidiIter>::string_type
+operator + (typename iterator_value<BidiIter>::type const &lhs, sub_match<BidiIter> const &rhs)
+{
+    return lhs + rhs.str();
+}
+
+template<typename BidiIter>
+typename sub_match<BidiIter>::string_type
+operator + (sub_match<BidiIter> const &lhs, typename iterator_value<BidiIter>::type const *rhs)
+{
+    return lhs.str() + rhs;
+}
+
+template<typename BidiIter>
+typename sub_match<BidiIter>::string_type
+operator + (typename iterator_value<BidiIter>::type const *lhs, sub_match<BidiIter> const &rhs)
+{
+    return lhs + rhs.str();
+}
+
+template<typename BidiIter>
+typename sub_match<BidiIter>::string_type
+operator + (sub_match<BidiIter> const &lhs, typename sub_match<BidiIter>::string_type const &rhs)
+{
+    return lhs.str() + rhs;
+}
+
+template<typename BidiIter>
+typename sub_match<BidiIter>::string_type
+operator + (typename sub_match<BidiIter>::string_type const &lhs, sub_match<BidiIter> const &rhs)
+{
+    return lhs + rhs.str();
+}
+
+}} // namespace boost::xpressive
+
+// Hook the Boost.Range customization points to make sub_match a valid range.
+namespace boost
+{
+    /// INTERNAL ONLY
+    ///
+    template<typename BidiIter>
+    struct range_mutable_iterator<xpressive::sub_match<BidiIter> >
+    {
+        typedef BidiIter type;
+    };
+
+    /// INTERNAL ONLY
+    ///
+    template<typename BidiIter>
+    struct range_const_iterator<xpressive::sub_match<BidiIter> >
+    {
+        typedef BidiIter type;
+    };
+}
+
+#endif