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

depends/x86_64-pc-linux-gnu/include/boost/spirit/home/x3/nonterminal/debug_handler_state.hpp

@@ -0,0 +1,20 @@
+/*=============================================================================
+    Copyright (c) 2001-2014 Joel de Guzman
+
+    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)
+==============================================================================*/
+#if !defined(BOOST_SPIRIT_X3_DEBUG_HANDLER_STATE_APR_21_2010_0733PM)
+#define BOOST_SPIRIT_X3_DEBUG_HANDLER_STATE_APR_21_2010_0733PM
+
+namespace boost { namespace spirit { namespace x3
+{
+    enum debug_handler_state
+    {
+        pre_parse
+      , successful_parse
+      , failed_parse
+    };
+}}}
+
+#endif

depends/x86_64-pc-linux-gnu/include/boost/spirit/home/x3/nonterminal/detail/rule.hpp

@@ -0,0 +1,351 @@
+/*=============================================================================
+    Copyright (c) 2001-2014 Joel de Guzman
+
+    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)
+==============================================================================*/
+#if !defined(BOOST_SPIRIT_X3_DETAIL_RULE_JAN_08_2012_0326PM)
+#define BOOST_SPIRIT_X3_DETAIL_RULE_JAN_08_2012_0326PM
+
+#include <boost/spirit/home/x3/auxiliary/guard.hpp>
+#include <boost/spirit/home/x3/core/parser.hpp>
+#include <boost/spirit/home/x3/core/skip_over.hpp>
+#include <boost/spirit/home/x3/directive/expect.hpp>
+#include <boost/spirit/home/x3/support/traits/make_attribute.hpp>
+#include <boost/spirit/home/x3/support/utility/sfinae.hpp>
+#include <boost/spirit/home/x3/nonterminal/detail/transform_attribute.hpp>
+#include <boost/utility/addressof.hpp>
+
+#if defined(BOOST_SPIRIT_X3_DEBUG)
+#include <boost/spirit/home/x3/nonterminal/simple_trace.hpp>
+#endif
+
+namespace boost { namespace spirit { namespace x3
+{
+    template <typename ID>
+    struct identity;
+
+    template <typename ID, typename Attribute = unused_type, bool force_attribute = false>
+    struct rule;
+
+    struct parse_pass_context_tag;
+
+    namespace detail
+    {
+        // we use this so we can detect if the default parse_rule
+        // is the being called.
+        struct default_parse_rule_result
+        {
+            default_parse_rule_result(bool r)
+              : r(r) {}
+            operator bool() const { return r; }
+            bool r;
+        };
+    }
+
+    // default parse_rule implementation
+    template <typename ID, typename Attribute, typename Iterator
+      , typename Context, typename ActualAttribute>
+    inline detail::default_parse_rule_result
+    parse_rule(
+        rule<ID, Attribute> rule_
+      , Iterator& first, Iterator const& last
+      , Context const& context, ActualAttribute& attr);
+}}}
+
+namespace boost { namespace spirit { namespace x3 { namespace detail
+{
+#if defined(BOOST_SPIRIT_X3_DEBUG)
+    template <typename Iterator, typename Attribute>
+    struct context_debug
+    {
+        context_debug(
+            char const* rule_name
+          , Iterator const& first, Iterator const& last
+          , Attribute const& attr
+          , bool const& ok_parse //was parse successful?
+          )
+          : ok_parse(ok_parse), rule_name(rule_name)
+          , first(first), last(last)
+          , attr(attr)
+          , f(detail::get_simple_trace())
+        {
+            f(first, last, attr, pre_parse, rule_name);
+        }
+
+        ~context_debug()
+        {
+            auto status = ok_parse ? successful_parse : failed_parse ;
+            f(first, last, attr, status, rule_name);
+        }
+
+        bool const& ok_parse;
+        char const* rule_name;
+        Iterator const& first;
+        Iterator const& last;
+        Attribute const& attr;
+        detail::simple_trace_type& f;
+    };
+#endif
+
+    template <typename ID, typename Iterator, typename Context, typename Enable = void>
+    struct has_on_error : mpl::false_ {};
+
+    template <typename ID, typename Iterator, typename Context>
+    struct has_on_error<ID, Iterator, Context,
+        typename disable_if_substitution_failure<
+            decltype(
+                std::declval<ID>().on_error(
+                    std::declval<Iterator&>()
+                  , std::declval<Iterator>()
+                  , std::declval<expectation_failure<Iterator>>()
+                  , std::declval<Context>()
+                )
+            )>::type
+        >
+      : mpl::true_
+    {};
+
+    template <typename ID, typename Iterator, typename Attribute, typename Context, typename Enable = void>
+    struct has_on_success : mpl::false_ {};
+
+    template <typename ID, typename Iterator, typename Attribute, typename Context>
+    struct has_on_success<ID, Iterator, Context, Attribute,
+        typename disable_if_substitution_failure<
+            decltype(
+                std::declval<ID>().on_success(
+                    std::declval<Iterator&>()
+                  , std::declval<Iterator>()
+                  , std::declval<Attribute&>()
+                  , std::declval<Context>()
+                )
+            )>::type
+        >
+      : mpl::true_
+    {};
+
+    template <typename ID>
+    struct make_id
+    {
+        typedef identity<ID> type;
+    };
+
+    template <typename ID>
+    struct make_id<identity<ID>>
+    {
+        typedef identity<ID> type;
+    };
+
+    template <typename ID, typename RHS, typename Context>
+    Context const&
+    make_rule_context(RHS const& rhs, Context const& context
+      , mpl::false_ /* is_default_parse_rule */)
+    {
+        return context;
+    }
+
+    template <typename ID, typename RHS, typename Context>
+    auto make_rule_context(RHS const& rhs, Context const& context
+      , mpl::true_ /* is_default_parse_rule */ )
+    {
+        return make_unique_context<ID>(rhs, context);
+    }
+
+    template <typename Attribute, typename ID>
+    struct rule_parser
+    {
+        template <typename Iterator, typename Context, typename ActualAttribute>
+        static bool call_on_success(
+            Iterator& first, Iterator const& last
+          , Context const& context, ActualAttribute& attr
+          , mpl::false_ /* No on_success handler */ )
+        {
+            return true;
+        }
+
+        template <typename Iterator, typename Context, typename ActualAttribute>
+        static bool call_on_success(
+            Iterator& first, Iterator const& last
+          , Context const& context, ActualAttribute& attr
+          , mpl::true_ /* Has on_success handler */)
+        {
+            bool pass = true;
+            ID().on_success(
+                first
+              , last
+              , attr
+              , make_context<parse_pass_context_tag>(pass, context)
+            );
+            return pass;
+        }
+
+        template <typename RHS, typename Iterator, typename Context
+          , typename RContext, typename ActualAttribute>
+        static bool parse_rhs_main(
+            RHS const& rhs
+          , Iterator& first, Iterator const& last
+          , Context const& context, RContext& rcontext, ActualAttribute& attr
+          , mpl::false_)
+        {
+            // see if the user has a BOOST_SPIRIT_DEFINE for this rule
+            typedef
+                decltype(parse_rule(
+                    rule<ID, Attribute>(), first, last
+                  , make_unique_context<ID>(rhs, context), attr))
+            parse_rule_result;
+
+            // If there is no BOOST_SPIRIT_DEFINE for this rule,
+            // we'll make a context for this rule tagged by its ID
+            // so we can extract the rule later on in the default
+            // (generic) parse_rule function.
+            typedef
+                is_same<parse_rule_result, default_parse_rule_result>
+            is_default_parse_rule;
+
+            Iterator i = first;
+            bool r = rhs.parse(
+                i
+              , last
+              , make_rule_context<ID>(rhs, context, is_default_parse_rule())
+              , rcontext
+              , attr
+            );
+
+            if (r)
+            {
+                auto first_ = first;
+                x3::skip_over(first_, last, context);
+                r = call_on_success(first_, i, context, attr
+                  , has_on_success<ID, Iterator, Context, ActualAttribute>());
+            }
+
+            if (r)
+                first = i;
+            return r;
+        }
+
+        template <typename RHS, typename Iterator, typename Context
+          , typename RContext, typename ActualAttribute>
+        static bool parse_rhs_main(
+            RHS const& rhs
+          , Iterator& first, Iterator const& last
+          , Context const& context, RContext& rcontext, ActualAttribute& attr
+          , mpl::true_ /* on_error is found */)
+        {
+            for (;;)
+            {
+                try
+                {
+                    return parse_rhs_main(
+                        rhs, first, last, context, rcontext, attr, mpl::false_());
+                }
+                catch (expectation_failure<Iterator> const& x)
+                {
+                    switch (ID().on_error(first, last, x, context))
+                    {
+                        case error_handler_result::fail:
+                            return false;
+                        case error_handler_result::retry:
+                            continue;
+                        case error_handler_result::accept:
+                            return true;
+                        case error_handler_result::rethrow:
+                            throw;
+                    }
+                }
+            }
+        }
+
+        template <typename RHS, typename Iterator
+          , typename Context, typename RContext, typename ActualAttribute>
+        static bool parse_rhs_main(
+            RHS const& rhs
+          , Iterator& first, Iterator const& last
+          , Context const& context, RContext& rcontext, ActualAttribute& attr)
+        {
+            return parse_rhs_main(
+                rhs, first, last, context, rcontext, attr
+              , has_on_error<ID, Iterator, Context>()
+            );
+        }
+
+        template <typename RHS, typename Iterator
+          , typename Context, typename RContext, typename ActualAttribute>
+        static bool parse_rhs(
+            RHS const& rhs
+          , Iterator& first, Iterator const& last
+          , Context const& context, RContext& rcontext, ActualAttribute& attr
+          , mpl::false_)
+        {
+            return parse_rhs_main(rhs, first, last, context, rcontext, attr);
+        }
+
+        template <typename RHS, typename Iterator
+          , typename Context, typename RContext, typename ActualAttribute>
+        static bool parse_rhs(
+            RHS const& rhs
+          , Iterator& first, Iterator const& last
+          , Context const& context, RContext& rcontext, ActualAttribute& attr
+          , mpl::true_)
+        {
+            return parse_rhs_main(rhs, first, last, context, rcontext, unused);
+        }
+
+        template <typename RHS, typename Iterator, typename Context
+          , typename ActualAttribute, typename ExplicitAttrPropagation>
+        static bool call_rule_definition(
+            RHS const& rhs
+          , char const* rule_name
+          , Iterator& first, Iterator const& last
+          , Context const& context, ActualAttribute& attr
+          , ExplicitAttrPropagation)
+        {
+            typedef traits::make_attribute<Attribute, ActualAttribute> make_attribute;
+
+            // do down-stream transformation, provides attribute for
+            // rhs parser
+            typedef traits::transform_attribute<
+                typename make_attribute::type, Attribute, parser_id>
+            transform;
+
+            typedef typename make_attribute::value_type value_type;
+            typedef typename transform::type transform_attr;
+            value_type made_attr = make_attribute::call(attr);
+            transform_attr attr_ = transform::pre(made_attr);
+
+            bool ok_parse
+              //Creates a place to hold the result of parse_rhs
+              //called inside the following scope.
+              ;
+            {
+             // Create a scope to cause the dbg variable below (within
+             // the #if...#endif) to call it's DTOR before any
+             // modifications are made to the attribute, attr_ passed
+             // to parse_rhs (such as might be done in
+             // traits::post_transform when, for example,
+             // ActualAttribute is a recursive variant).
+#if defined(BOOST_SPIRIT_X3_DEBUG)
+                typedef typename make_attribute::type dbg_attribute_type;
+                context_debug<Iterator, dbg_attribute_type>
+                dbg(rule_name, first, last, dbg_attribute_type(attr_), ok_parse);
+#endif
+                ok_parse = parse_rhs(rhs, first, last, context, attr_, attr_
+                   , mpl::bool_
+                     < (  RHS::has_action
+                       && !ExplicitAttrPropagation::value
+                       )
+                     >()
+                  );
+            }
+            if (ok_parse)
+            {
+                // do up-stream transformation, this integrates the results
+                // back into the original attribute value, if appropriate
+                traits::post_transform(attr, std::forward<transform_attr>(attr_));
+            }
+            return ok_parse;
+        }
+    };
+}}}}
+
+#endif

depends/x86_64-pc-linux-gnu/include/boost/spirit/home/x3/nonterminal/detail/transform_attribute.hpp

@@ -0,0 +1,110 @@
+/*=============================================================================
+    Copyright (c) 2001-2014 Joel de Guzman
+    Copyright (c) 2001-2011 Hartmut Kaiser
+
+    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)
+=============================================================================*/
+#if !defined(SPIRIT_X3_DETAIL_ATTRIBUTES_APR_18_2010_0458PM)
+#define SPIRIT_X3_DETAIL_ATTRIBUTES_APR_18_2010_0458PM
+
+#include <boost/spirit/home/x3/support/traits/transform_attribute.hpp>
+#include <boost/spirit/home/x3/support/traits/move_to.hpp>
+#include <utility>
+
+///////////////////////////////////////////////////////////////////////////////
+namespace boost { namespace spirit { namespace x3
+{
+    struct parser_id;
+
+    template <typename Exposed, typename Transformed>
+    struct default_transform_attribute
+    {
+        typedef Transformed type;
+
+        static Transformed pre(Exposed&) { return Transformed(); }
+
+        static void post(Exposed& val, Transformed&& attr)
+        {
+            traits::move_to(std::forward<Transformed>(attr), val);
+        }
+    };
+
+    // handle case where no transformation is required as the types are the same
+    template <typename Attribute>
+    struct default_transform_attribute<Attribute, Attribute>
+    {
+        typedef Attribute& type;
+        static Attribute& pre(Attribute& val) { return val; }
+        static void post(Attribute&, Attribute const&) {}
+    };
+
+    // main specialization for x3
+    template <typename Exposed, typename Transformed, typename Enable = void>
+    struct transform_attribute
+      : default_transform_attribute<Exposed, Transformed> {};
+
+    // reference types need special handling
+    template <typename Attribute>
+    struct transform_attribute<Attribute&, Attribute>
+    {
+        typedef Attribute& type;
+        static Attribute& pre(Attribute& val) { return val; }
+        static void post(Attribute&, Attribute const&) {}
+    };
+
+    // unused_type needs some special handling as well
+    template <>
+    struct transform_attribute<unused_type, unused_type>
+    {
+        typedef unused_type type;
+        static unused_type pre(unused_type) { return unused; }
+        static void post(unused_type, unused_type) {}
+    };
+
+    template <>
+    struct transform_attribute<unused_type const, unused_type>
+      : transform_attribute<unused_type, unused_type> {};
+
+    template <typename Attribute>
+    struct transform_attribute<unused_type, Attribute>
+      : transform_attribute<unused_type, unused_type> {};
+
+    template <typename Attribute>
+    struct transform_attribute<unused_type const, Attribute>
+      : transform_attribute<unused_type, unused_type> {};
+
+    template <typename Attribute>
+    struct transform_attribute<Attribute, unused_type>
+      : transform_attribute<unused_type, unused_type> {};
+
+    template <typename Attribute>
+    struct transform_attribute<Attribute const, unused_type>
+      : transform_attribute<unused_type, unused_type> {};
+}}}
+
+///////////////////////////////////////////////////////////////////////////////
+namespace boost { namespace spirit { namespace x3 { namespace traits
+{
+    template <typename Exposed, typename Transformed>
+    struct transform_attribute<Exposed, Transformed, x3::parser_id>
+      : x3::transform_attribute<Exposed, Transformed> {};
+
+    template <typename Exposed, typename Transformed>
+    struct transform_attribute<Exposed&, Transformed, x3::parser_id>
+      : transform_attribute<Exposed, Transformed, x3::parser_id> {};
+
+    template <typename Attribute>
+    struct transform_attribute<Attribute&, Attribute, x3::parser_id>
+      : x3::transform_attribute<Attribute&, Attribute> {};
+
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Exposed, typename Transformed>
+    void post_transform(Exposed& dest, Transformed&& attr)
+    {
+        return transform_attribute<Exposed, Transformed, x3::parser_id>
+            ::post(dest, std::forward<Transformed>(attr));
+    }
+}}}}
+
+#endif

depends/x86_64-pc-linux-gnu/include/boost/spirit/home/x3/nonterminal/rule.hpp

@@ -0,0 +1,183 @@
+/*=============================================================================
+    Copyright (c) 2001-2014 Joel de Guzman
+
+    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)
+==============================================================================*/
+#if !defined(BOOST_SPIRIT_X3_RULE_JAN_08_2012_0326PM)
+#define BOOST_SPIRIT_X3_RULE_JAN_08_2012_0326PM
+
+#include <boost/spirit/home/x3/nonterminal/detail/rule.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/spirit/home/x3/support/context.hpp>
+#include <boost/preprocessor/variadic/to_seq.hpp>
+#include <boost/preprocessor/variadic/elem.hpp>
+#include <boost/preprocessor/seq/for_each.hpp>
+
+#if !defined(BOOST_SPIRIT_X3_NO_RTTI)
+#include <typeinfo>
+#endif
+
+namespace boost { namespace spirit { namespace x3
+{
+    template <typename ID>
+    struct identity {};
+
+    // default parse_rule implementation
+    template <typename ID, typename Attribute, typename Iterator
+      , typename Context, typename ActualAttribute>
+    inline detail::default_parse_rule_result
+    parse_rule(
+        rule<ID, Attribute> rule_
+      , Iterator& first, Iterator const& last
+      , Context const& context, ActualAttribute& attr)
+    {
+        static_assert(!is_same<decltype(get<ID>(context)), unused_type>::value,
+            "BOOST_SPIRIT_DEFINE undefined for this rule.");
+        return get<ID>(context).parse(first, last, context, unused, attr);
+    }
+
+    template <typename ID, typename RHS, typename Attribute, bool force_attribute_>
+    struct rule_definition : parser<rule_definition<ID, RHS, Attribute, force_attribute_>>
+    {
+        typedef rule_definition<ID, RHS, Attribute, force_attribute_> this_type;
+        typedef ID id;
+        typedef RHS rhs_type;
+        typedef rule<ID, Attribute> lhs_type;
+        typedef Attribute attribute_type;
+
+        static bool const has_attribute =
+            !is_same<Attribute, unused_type>::value;
+        static bool const handles_container =
+            traits::is_container<Attribute>::value;
+        static bool const force_attribute =
+            force_attribute_;
+
+        rule_definition(RHS const& rhs, char const* name)
+          : rhs(rhs), name(name) {}
+
+        template <typename Iterator, typename Context, typename Attribute_>
+        bool parse(Iterator& first, Iterator const& last
+          , Context const& context, unused_type, Attribute_& attr) const
+        {
+            return detail::rule_parser<attribute_type, ID>
+                ::call_rule_definition(
+                    rhs, name, first, last
+                  , context
+                  , attr
+                  , mpl::bool_<force_attribute>());
+        }
+
+        RHS rhs;
+        char const* name;
+    };
+
+    template <typename ID, typename Attribute, bool force_attribute_>
+    struct rule : parser<rule<ID, Attribute>>
+    {
+        typedef ID id;
+        typedef Attribute attribute_type;
+        static bool const has_attribute =
+            !is_same<Attribute, unused_type>::value;
+        static bool const handles_container =
+            traits::is_container<Attribute>::value;
+        static bool const force_attribute = force_attribute_;
+
+#if !defined(BOOST_SPIRIT_X3_NO_RTTI)
+        rule() : name(typeid(rule).name()) {}
+#else
+        rule() : name("unnamed") {}
+#endif
+
+        rule(char const* name)
+          : name(name) {}
+
+        template <typename RHS>
+        rule_definition<
+            ID, typename extension::as_parser<RHS>::value_type, Attribute, force_attribute_>
+        operator=(RHS const& rhs) const
+        {
+            return { as_parser(rhs), name };
+        }
+
+        template <typename RHS>
+        rule_definition<
+            ID, typename extension::as_parser<RHS>::value_type, Attribute, true>
+        operator%=(RHS const& rhs) const
+        {
+            return { as_parser(rhs), name };
+        }
+
+
+        template <typename Iterator, typename Context, typename Attribute_>
+        bool parse(Iterator& first, Iterator const& last
+          , Context const& context, unused_type, Attribute_& attr) const
+        {
+            return parse_rule(*this, first, last, context, attr);
+        }
+
+        char const* name;
+    };
+
+    namespace traits
+    {
+        template <typename T, typename Enable = void>
+        struct is_rule : mpl::false_ {};
+
+        template <typename ID, typename Attribute>
+        struct is_rule<rule<ID, Attribute>> : mpl::true_ {};
+
+        template <typename ID, typename Attribute, typename RHS, bool force_attribute>
+        struct is_rule<rule_definition<ID, RHS, Attribute, force_attribute>> : mpl::true_ {};
+    }
+
+    template <typename T>
+    struct get_info<T, typename enable_if<traits::is_rule<T>>::type>
+    {
+        typedef std::string result_type;
+        std::string operator()(T const& r) const
+        {
+            return r.name;
+        }
+    };
+
+#define BOOST_SPIRIT_DECLARE_(r, data, rule_type)                               \
+    template <typename Iterator, typename Context, typename Attribute>          \
+    bool parse_rule(                                                            \
+        rule_type rule_                                                         \
+      , Iterator& first, Iterator const& last                                   \
+      , Context const& context, Attribute& attr);                               \
+    /***/
+
+#define BOOST_SPIRIT_DECLARE(...) BOOST_PP_SEQ_FOR_EACH(                        \
+    BOOST_SPIRIT_DECLARE_, _, BOOST_PP_VARIADIC_TO_SEQ(__VA_ARGS__))            \
+    /***/
+
+#define BOOST_SPIRIT_DEFINE_(r, data, rule_name)                                \
+    template <typename Iterator, typename Context, typename Attribute>          \
+    inline bool parse_rule(                                                     \
+        decltype(rule_name) rule_                                               \
+      , Iterator& first, Iterator const& last                                   \
+      , Context const& context, Attribute& attr)                                \
+    {                                                                           \
+        using boost::spirit::x3::unused;                                        \
+        static auto const def_ = (rule_name = BOOST_PP_CAT(rule_name, _def));   \
+        return def_.parse(first, last, context, unused, attr);                  \
+    }                                                                           \
+    /***/
+
+#define BOOST_SPIRIT_DEFINE(...) BOOST_PP_SEQ_FOR_EACH(                         \
+    BOOST_SPIRIT_DEFINE_, _, BOOST_PP_VARIADIC_TO_SEQ(__VA_ARGS__))             \
+    /***/
+
+#define BOOST_SPIRIT_INSTANTIATE(rule_type, Iterator, Context)                  \
+    template bool parse_rule<Iterator, Context, rule_type::attribute_type>(     \
+        rule_type rule_                                                         \
+      , Iterator& first, Iterator const& last                                   \
+      , Context const& context, rule_type::attribute_type& attr);               \
+    /***/
+
+
+}}}
+
+#endif

depends/x86_64-pc-linux-gnu/include/boost/spirit/home/x3/nonterminal/simple_trace.hpp

@@ -0,0 +1,146 @@
+/*=============================================================================
+    Copyright (c) 2001-2014 Joel de Guzman
+    Copyright (c) 2001-2011 Hartmut Kaiser
+
+    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)
+==============================================================================*/
+#if !defined(BOOST_SPIRIT_X3_SIMPLE_TRACE_DECEMBER_06_2008_1102AM)
+#define BOOST_SPIRIT_X3_SIMPLE_TRACE_DECEMBER_06_2008_1102AM
+
+#include <boost/spirit/home/x3/support/unused.hpp>
+#include <boost/spirit/home/x3/support/traits/print_token.hpp>
+#include <boost/spirit/home/x3/support/traits/print_attribute.hpp>
+#include <boost/spirit/home/x3/nonterminal/debug_handler_state.hpp>
+#include <boost/fusion/include/out.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <iostream>
+
+//  The stream to use for debug output
+#if !defined(BOOST_SPIRIT_X3_DEBUG_OUT)
+#define BOOST_SPIRIT_X3_DEBUG_OUT std::cerr
+#endif
+
+//  number of tokens to print while debugging
+#if !defined(BOOST_SPIRIT_X3_DEBUG_PRINT_SOME)
+#define BOOST_SPIRIT_X3_DEBUG_PRINT_SOME 20
+#endif
+
+//  number of spaces to indent
+#if !defined(BOOST_SPIRIT_X3_DEBUG_INDENT)
+#define BOOST_SPIRIT_X3_DEBUG_INDENT 2
+#endif
+
+namespace boost { namespace spirit { namespace x3
+{
+    namespace detail
+    {
+        template <typename Char>
+        inline void token_printer(std::ostream& o, Char c)
+        {
+            // allow customization of the token printer routine
+            x3::traits::print_token(o, c);
+        }
+    }
+
+    template <int IndentSpaces = 2, int CharsToPrint = 20>
+    struct simple_trace
+    {
+        simple_trace(std::ostream& out)
+          : out(out), indent(0) {}
+
+        void print_indent(int n) const
+        {
+            n *= IndentSpaces;
+            for (int i = 0; i != n; ++i)
+                out << ' ';
+        }
+
+        template <typename Iterator>
+        void print_some(
+            char const* tag
+          , Iterator first, Iterator const& last) const
+        {
+            print_indent(indent);
+            out << '<' << tag << '>';
+            int const n = CharsToPrint;
+            for (int i = 0; first != last && i != n && *first; ++i, ++first)
+                detail::token_printer(out, *first);
+            out << "</" << tag << '>' << std::endl;
+
+            // $$$ FIXME convert invalid xml characters (e.g. '<') to valid
+            // character entities. $$$
+        }
+
+        template <typename Iterator, typename Attribute, typename State>
+        void operator()(
+            Iterator const& first
+          , Iterator const& last
+          , Attribute const& attr
+          , State state
+          , std::string const& rule_name) const
+        {
+            switch (state)
+            {
+                case pre_parse:
+                    print_indent(indent++);
+                    out
+                        << '<' << rule_name << '>'
+                        << std::endl;
+                    print_some("try", first, last);
+                    break;
+
+                case successful_parse:
+                    print_some("success", first, last);
+                    if (!is_same<Attribute, unused_type>::value)
+                    {
+                        print_indent(indent);
+                        out
+                            << "<attributes>";
+                        traits::print_attribute(out, attr);
+                        out
+                            << "</attributes>";
+                        out << std::endl;
+                    }
+                    //~ if (!fusion::empty(context.locals))
+                        //~ out
+                            //~ << "<locals>"
+                            //~ << context.locals
+                            //~ << "</locals>";
+                    print_indent(--indent);
+                    out
+                        << "</" << rule_name << '>'
+                        << std::endl;
+                    break;
+
+                case failed_parse:
+                    print_indent(indent);
+                    out << "<fail/>" << std::endl;
+                    print_indent(--indent);
+                    out
+                        << "</" << rule_name << '>'
+                        << std::endl;
+                    break;
+            }
+        }
+
+        std::ostream& out;
+        mutable int indent;
+    };
+
+    namespace detail
+    {
+        typedef simple_trace<
+            BOOST_SPIRIT_X3_DEBUG_INDENT, BOOST_SPIRIT_X3_DEBUG_PRINT_SOME>
+        simple_trace_type;
+
+        inline simple_trace_type&
+        get_simple_trace()
+        {
+            static simple_trace_type tracer(BOOST_SPIRIT_X3_DEBUG_OUT);
+            return tracer;
+        }
+    }
+}}}
+
+#endif