boostorg / spirit Goto Github PK

Boost.org spirit module

HTML 12.39% C++ 87.46% Shell 0.05% Lex 0.01% CMake 0.01% Starlark 0.08%

spirit boost c-plus-plus cpp parser-combinators

spirit's Introduction

Spirit

Spirit is a set of C++ libraries for parsing and output generation implemented as Domain Specific Embedded Languages (DSEL) using Expression templates and Template Meta-Programming. The Spirit libraries enable a target grammar to be written exclusively in C++. Inline grammar specifications can mix freely with other C++ code and, thanks to the generative power of C++ templates, are immediately executable.

Spirit.X3 (3rd generation)

Documentation

The newest Spirit shines faster compile times. Currently only a parser framework.

WARNING: C++14 compilers support will be dropped soon.

Spirit X3 in Boost 1.81 (scheduled to November 2022) will use C++17 features.

Supported compilers will be:

Clang 4 (currently 3.6)
GCC 7 (currently 5)
VS 2017 v15.8 (currently 2015 U3)

Spirit V2 (2nd generation)

Documentation

The latest Long Term Support version of Spirit. A Swiss Army knife for data manipulation on any kind of input.

Consists of:

Qi: Parser framework.
Karma: Generator framework.
Lex: Lexical analyzer framework.

Runs on most C++03 compilers (GCC 4.1, Clang 3.0, VS 2005).

Spirit.Classic (1st generation)

Documentation

An elderling member of Spirit. It receives only limited maintanance, but it is still used even inside Boost by Boost.Serialization and Boost.Wave libraries. It also contains Phoenix V1.

Spririt.Classic should support even ancient compilers.

Brief History

Date	Boost	Commit	Event
2014-03-18	1.56	8a353328	Spirit.X3 is added
2013-12-14	1.56	c0537c82	Phoenix V2 is retired
2011-03-28	1.47	400a764d	Phoenix V3 support added to Spirit V2
2009-04-30	1.41	5963a395	Spirit.Repository is appeared
2008-04-13	1.36	ffd0cc10	Spirit V2 (Qi, Karma, Lex, Phoenix V2) is added
2006-08-23	1.35	2dc892b4	Fusion V1 is retired
2003-01-31	1.30	81907916	Spirit is the part of the Boost

spirit's People

Contributors

Stargazers

Watchers

Forkers

redbaron vtnerd koolcat007 sanderbog teajay-fr jamboree wichtounet danieljames lastique sehe tomoki gigimava marcelraad damienrg bylee20 sergiud purplekarrot verisign aiche legalizeadulthood jaredgrubb lanurmi ajasty-cavium gevorgvoskanyan drivehappy tabe tomilov akrzemi1 akumta maksimmyasnikov limbolily biocomp vogelsgesang tobias-loew stac47 romain-geissler-1a qiuted davidlt crossbuild bkadar-dwp amdmi3 iwiwi hia3 kenthauser phbaer autodesk-forks kojoley mxc-commons cppljevans peterhuene zhangjiacool expertisesolutions danielae xltools dmitrifedorov inakoll think-cell mihaibabiac bradenmcd lexliy njlr fhein weejang teemperor steveshaw wanghan02 hkaiser malterlib ecatmur schra dtardon m-dhooge jeking3 bazelboost octopus-prime bonastos oracleoftroy myestro jwakely faithandbrave devindusoft kokukusiaku mike-devel spacelg godmar buckaroo-pm xeverous mitsch boostandroid gpantwrs tinko92 cmazakas rockonedege duzy stefan301 jinhang2008 danielmevi madmongo1-boostorg zhaohui0923 puetzk

spirit's Issues

Qi bad access/segmentation fault with grammar grammar alternative

Hi,

I'am writing a RTSP1.0 parser with Qi, so I created a grammar for response message types and one for request message types. All worked perfectly so far, unit tested them, using no state or semantic actions but the attributed types struct bindings. Now I just wanted to combine them as a simple alternative into a boost::variant. (see https://github.com/Superlokkus/boost_spirit_bug/blob/parser_vtable_bad_access_minimal_example/src/streaming_lib/include/rtsp_message.hpp#L142 )
(so that I can just parse in general rtsp messages, which is need for rtsp clients since they could also get request from the server, and so messages are even rfc defined as the alternative)

But this simple grammar which combines the mentioned grammars, explodes with segmentation faults/memory access violation: invalid permissions in boost::function4 with fusion while parsing.

I tested it with boost 1.66 Apple LLVM version 10.0.0 (clang-1000.11.45.2) on a mac host and with boost 1.69 gcc (SUSE Linux) 7.3.1 20180323 [gcc-7-branch revision 258812] on a suse x86-64 host.

I would paste a wandbox link, but boost::test or boost::spirit needs to much ram for compiling and quits because of this. Find a stack trace attached if you can not clone and execute it yourself.

I can try to make the example more minimal, but I hope since the grammars don't have custom side effects and valid grammars, that you can already use it.

Code/Repo: https://github.com/Superlokkus/boost_spirit_bug
boost_spirt_stack.txt

x3 cannot parse into associative containers anymore

Today i took a look at boost 1_66_0_b1 (because of boost beast).
But this broke my parser based on x3.

source/parser.cpp:48:53:   required from here
/home/mike/Downloads/boost_1_66_0_b1/boost_1_66_0/boost/spirit/home/x3/core/detail/parse_into_container.hpp:259:17: error: no matching function for call to ‘std::map<hessian::value_t, hessian::value_t>::insert(std::map<hessian::value_t, hessian::value_t>::iterator, std::map<hessian::value_t, hessian::value_t>::iterator, std::map<hessian::value_t, hessian::value_t>::iterator)’
                 attr.insert(attr.end(), rest.begin(), rest.end());

As you can see there is a attr.insert(attr.end(), rest.begin(), rest.end()); call now.
This does not work, because no associative container (std::set, std::map, ...) provides this member function.

I think this bug is result of commit: 379413a#diff-2b82341b4caa57a2a0c6bc9a616a1e1a

Karma: alternative is broken due to new `boost::optional`

See f.ex. here:

https://travis-ci.org/boostorg/boost/jobs/285871194
https://travis-ci.org/boostorg/boost/jobs/285871195

Apologies if you didn't want issues enabled.

Html docs for Karma:Iterator Based Generator API reference dead SGI link for OutputIterator

Instead of using a std::string with a back_inserter I'm trying to use a Microsoft Gudeline Support Library (GSL) string_span. A string_span<> is basically a pointer and a length that allows safer buffer manipulation.

X3: Backtrack and container attribute

Preface

The side effect of backtracking on container type attributes is a known Spirit problem. It is not only a very surprising thing for newcomers, but also the sword of Damocles to everyone.

Click for the backtrack side effect example

#include <boost/detail/lightweight_test.hpp>
#include <boost/spirit/home/x3.hpp>
#include <string>
#include "../spirit/test/x3/test.hpp"

int main()
{
    using spirit_test::test_attr;
    namespace x3 = boost::spirit::x3;

    {
        std::string s;
        BOOST_TEST(test_attr("ac", x3::char_("a") >> x3::char_("b") | x3::string("ac"), s));
        BOOST_TEST_EQ("ac", s);
    }

    return boost::report_errors();
}

Solutions

The two main suggestions for Qi users are:

Rewrite your parser to eliminate backtracking, or if it is impossible:
Use hold directive.

At the current moment there is no hold directive in X3 and that's a problem. The simple solution is to introduce hold directive and forget about the problem, however I think it is not a solution, but a dirty hack/workaround.

What I have in my mind right now:

no	description	pseudo representation
1	`hold` directive.	`hold[a] \| hold[b] \| hold[c] \| ... \| hold[z]`
2	`parse_alternative` to temporary.	Same as 1
3	`alternative::parse` to temporary.	`hold...[hold[hold[a \| b] \| c] \| ...] \| z`
4	clear the attribute before `parse_alternative` call.	`clear >> a \| clear >> b \| ... \| clear >> z`
5	clear the attribute after `parse_alternative` fail.	`a \| clear \| b \| clear \| ... \| z \| clear`
6	clear between `parse_alternative` calls in `alternative::parse`.	`a \| clear >> b \| ... \| clear >> z`

What I think about solutions above:

Easy to implement. User should know about its existence. Error prone or terrible looking because of verbosity if used in every branch. The cost is N construct + N - F move + N destruct calls, where N is number of hit hold directives, F is number of failed branches.
Easy to implement. The cost is S construct + S - F move + S destruct calls, where S is number of succeeded branches, F is number of failed branches.
The cost is S - 1 construct + S - F move + S - 1 destruct calls, where S is number of succeeded branches, F is number of failed branches.
Requires new trait. The cost is S clear trait calls, where S is number of succeeded branches.
Requires new trait. The cost is F clear trait calls, where F is number of failed branches.
Requires new trait. The cost is F - 1 clear trait calls, where F is number of failed branches.

Since all approaches have constant overhead after backtracking that had appended zero elements to the attribute the list above shows that hold directive has most performance impact, and being a 'non-automatic' solution makes it the worst decision by a large margin.

Non-container attributes handling will not changed even on asm level for all the solutions (except may be hold directive, because Qi documentation explicitly states that it creates temporary and does not make exception for non-container attributes).

Note: solutions 1-3 will make more allocate calls and perform worse on non reusing allocators, but 4-6 may end with more reserved memory (can be fixed with shrink_to_fit call, but I think it should be left up to a user to make such call).

From the solutions list it is clear that:

Solution 2 is just an automatic hold placement on every branch.
Solution 3 is a waste of memory.
Solutions 4-6 represent a single technique with various optimizations. The 4 is the slowest and 6 is the fastest. Solution 6 is more like 'zero cost exceptions' when you are paying only on failing.

Optimizations

The main question is: can we make automatic backtrack recovering as optimized as the most optimized hand placed hold directive? Let's see:

Solution 6 is already optimized to clear only between branches so it is equivalent (in terms of the result) of hold[a] | hold[b] | hold[c] | ... | z. It is nice, we do not need to clear the container if the last branch has failed.

Side note: Actually, clear is cheaper than holds in this case. Because it does the following a | clear >> b | clear >> c | ... | z there are no constructions and destructions of container type in every branch, but what most people may not realize -- memory allocations. The most used container is std::vector, it will call allocator on push_back due to growth (and may be even multiple allocations + moves or if you unclucky -- copies for its elements) on every branch (at least a single allocation on every branch that produces at least one element). This will not happen with solution 6 because we always work with the same container there are no moves/copies and the number of allocations will be as much as number of allocations for only the longest successful branch.

The two possible manual hold optimization are:

a | hold[b] | c - hold is not used on a because it does not produce an attribute (example a = lit("foo")).
It is a simple optimization and will be performed automatically when is_same<unused_type, attribute_of<decltype(a)>>.
lit("foo") >> hold[a] | b - postpone hold so if lit("foo") fails there is no cost of hold at all.
For the most of containers clear call on an empty attribute should be very cheap so this optimization will have close to zero impact on performace.
However, it also can be done automatically by performing something like this transformation lit("foo") >> (a | clear) | b. It is a complicated optimization, but I have a clear picture of how it could be done by injecting a tag into a context.

I can't say for sure there are no other possible optimizations, but it should be something very tricky.

Clang static analyzer reports a warning on qi_real.hpp

Clang static analyzer gives me the following warning.

In file included from include/boost/spirit/include/qi_real.hpp:16:
In file included from include/boost/spirit/home/qi/numeric/real.hpp:21:
include/boost/spirit/home/qi/numeric/detail/real_impl.hpp:318:31: warning: Function call argument is an uninitialized value
            traits::assign_to(traits::negate(neg, n), attr);
                              ^~~~~~~~~~~~~~~~~~~~~~

I cannot tell if it is a false-positive or if this can be silenced.

Add support for std::optional

It would be nice if Boost.Spirit recognized std::optional in C++17 the way it does boost::optional. In particular, optional parsers should support std::optional attributes.

Add continuous integration builds to improve code and pull request quality

Using these free CI services improves quality of code submissions and makes maintenance of a library a little easier, as the maintainer is freed in many cases from needing to qualify new code manually.

If you are familiar with these services, you can take the relevant files from Boost.Format or Boost.Uuid as a reference, or if you'd like I can submit a pull request containing the files you need with the combinations of windows, linux, and osx compilers you would like to qualify in pull request builds. Then all you would need to do is enable the boostorg builds in appveyor and travis.

I can also help get the project set up in Coverity Scan, if you are interested. I have Boost.Uuid and Boost.Format set to build the master branch on every push into it plus weekly, with a job that only runs against master which updates Coverity, all automated.

Nonterminal Docs Outdated/Wrong

http://www.boost.org/doc/libs/1_66_0/libs/spirit/doc/html/spirit/qi/reference/parser_concepts/nonterminal.html

^ From the above, one can read:

X::sig_type The Signature of X: An MPL Forward Sequence. The first element is the Nonterminal's synthesized attribute type and the rest are the inherited attribute types.

In all reality, the type is a function signature like std::string(void) given a rule type of qi::rule<char const*, std::string()> and as such, doesn't really work with any of the MPL functions, namely mpl::front<...>::type.

team needs communication and rules

Currently team work is bullshit:

Redundant work
Destroying work of others
No reviews
No use of tickets

So I want to strongly suggest working together - AS TEAM:

Using tickets for coordination
Doing reviews to not destroy others work
Doing reviews to find issues
Let others know about your work

So communication is most important. And there should be rules, e.g. no merge without review...

grammar_fail.cpp test fails

Environment:
VS 2017 + Windows Server 2016

Issue description:
We build and run test for Boost. And we found grammar_fail.cpp failed to build due to error C2664: 'bool boost::function4<R,T0,T1,T2,T3>::operator ()(T0,T1,T2,T3) const': cannot convert argument 4 from 'const Skipper' to 'T3'. Could you pleaes take a look? Thanks in advance.
log_x86_test_99.log

Error info:
.\boost/spirit/home/qi/nonterminal/rule.hpp(304): error C2664: 'bool boost::function4<R,T0,T1,T2,T3>::operator ()(T0,T1,T2,T3) const': cannot convert argument 4 from 'const Skipper' to 'T3'
with
[
R=bool,
T0=const char *&,
T1=const char *const &,
T2=boost::spirit::context<boost::fusion::cons<boost::spirit::unused_type &,boost::fusion::nil_>,boost::fusion::vector<>> &,
T3=const boost::spirit::qi::reference<const boost::spirit::qi::rule<const char *,boost::spirit::unused_type,boost::spirit::unused_type,boost::spirit::unused_type,boost::spirit::unused_type>> &
]
and
[
Skipper=skipper_type
]
and
[
T3=const boost::spirit::qi::reference<const boost::spirit::qi::rule<const char *,boost::spirit::unused_type,boost::spirit::unused_type,boost::spirit::unused_type,boost::spirit::unused_type>> &
]
.\boost/spirit/home/qi/nonterminal/rule.hpp(304): note: Reason: cannot convert from 'const Skipper' to 'const boost::spirit::qi::reference<const boost::spirit::qi::rule<const char *,boost::spirit::unused_type,boost::spirit::unused_type,boost::spirit::unused_type,boost::spirit::unused_type>>'
with
[
Skipper=skipper_type
]
.\boost/spirit/home/qi/nonterminal/rule.hpp(304): note: No user-defined-conversion operator available that can perform this conversion, or the operator cannot be called
.\boost/spirit/home/qi/reference.hpp(43): note: see reference to function template instantiation 'bool boost::spirit::qi::rule<Iterator,T1,T2,T3,T4>::parse<Context,Skipper,Attribute>(Iterator &,const Iterator &,Context &,const Skipper &,Attribute &) const' being compiled
with
[
Iterator=const char *,
T1=boost::spirit::qi::rule<const char *,boost::spirit::unused_type,boost::spirit::unused_type,boost::spirit::unused_type,boost::spirit::unused_type>,
T2=boost::spirit::unused_type,
T3=boost::spirit::unused_type,
T4=boost::spirit::unused_type,
Context=const boost::spirit::unused_type,
Skipper=skipper_type,
Attribute=const boost::spirit::unused_type
]
.\boost/spirit/home/qi/reference.hpp(43): note: see reference to function template instantiation 'bool boost::spirit::qi::rule<Iterator,T1,T2,T3,T4>::parse<Context,Skipper,Attribute>(Iterator &,const Iterator &,Context &,const Skipper &,Attribute &) const' being compiled
with
[
Iterator=const char *,
T1=boost::spirit::qi::rule<const char *,boost::spirit::unused_type,boost::spirit::unused_type,boost::spirit::unused_type,boost::spirit::unused_type>,
T2=boost::spirit::unused_type,
T3=boost::spirit::unused_type,
T4=boost::spirit::unused_type,
Context=const boost::spirit::unused_type,
Skipper=skipper_type,
Attribute=const boost::spirit::unused_type
]
.\boost/spirit/home/qi/detail/parse.hpp(85): note: see reference to function template instantiation 'bool boost::spirit::qi::reference<const boost::spirit::qi::rule<Iterator,T1,T2,T3,T4>>::parse<Iterator,const boost::spirit::unused_type,skipper_type,const boost::spirit::unused_type>(Iterator &,const Iterator &,Context &,const Skipper &,Attribute &) const' being compiled
with
[
Iterator=const char *,
T1=boost::spirit::qi::rule<const char *,boost::spirit::unused_type,boost::spirit::unused_type,boost::spirit::unused_type,boost::spirit::unused_type>,
T2=boost::spirit::unused_type,
T3=boost::spirit::unused_type,
T4=boost::spirit::unused_type,
Context=const boost::spirit::unused_type,
Skipper=skipper_type,
Attribute=const boost::spirit::unused_type
]
.\boost/spirit/home/qi/detail/parse.hpp(84): note: see reference to function template instantiation 'bool boost::spirit::qi::reference<const boost::spirit::qi::rule<Iterator,T1,T2,T3,T4>>::parse<Iterator,const boost::spirit::unused_type,skipper_type,const boost::spirit::unused_type>(Iterator &,const Iterator &,Context &,const Skipper &,Attribute &) const' being compiled
with
[
Iterator=const char *,
T1=boost::spirit::qi::rule<const char *,boost::spirit::unused_type,boost::spirit::unused_type,boost::spirit::unused_type,boost::spirit::unused_type>,
T2=boost::spirit::unused_type,
T3=boost::spirit::unused_type,
T4=boost::spirit::unused_type,
Context=const boost::spirit::unused_type,
Skipper=skipper_type,
Attribute=const boost::spirit::unused_type
]
.\boost/spirit/home/qi/parse.hpp(121): note: see reference to function template instantiation 'bool boost::spirit::qi::detail::phrase_parse_impl<Expr,void>::call<Iterator,Skipper>(Iterator &,Iterator,const Expr &,const Skipper &,boost::spirit::qi::skip_flag)' being compiled
with
[
Expr=num_list,
Iterator=const char *,
Skipper=boost::proto::exprns_::expr<boost::proto::tagns_::tag::bitwise_or,boost::proto::argsns_::list2<const boost::proto::exprns_::expr<boost::proto::tagns_::tag::terminal,boost::proto::argsns_::term<boost::spirit::tag::char_codeboost::spirit::tag::space,boost::spirit::char_encoding::standard>,0> &,const boost::proto::exprns_::expr<boost::proto::tagns_::tag::shift_right,boost::proto::argsns_::list2<const boost::proto::exprns_::expr<boost::proto::tagns_::tag::shift_right,boost::proto::argsns_::list2<boost::proto::exprns_::expr<boost::proto::tagns_::tag::terminal,boost::proto::argsns_::term<const char &>,0>,const boost::proto::exprns_::expr<boost::proto::tagns_::tag::dereference,boost::proto::argsns_::list1<const boost::proto::exprns_::expr<boost::proto::tagns_::tag::complement,boost::proto::argsns_::list1<const boost::proto::exprns_::expr<boost::proto::tagns_::tag::terminal,boost::proto::argsns_::term<boost::spirit::terminal_ex<boost::spirit::tag::standard::char_,boost::fusion::vector>>,0> &>,1> &>,1> &>,2> &,boost::proto::exprns_::expr<boost::proto::tagns_::tag::terminal,boost::proto::argsns_::term<const char &>,0>>,2> &>,2>
]
.\boost/spirit/home/qi/parse.hpp(120): note: see reference to function template instantiation 'bool boost::spirit::qi::detail::phrase_parse_impl<Expr,void>::call<Iterator,Skipper>(Iterator &,Iterator,const Expr &,const Skipper &,boost::spirit::qi::skip_flag)' being compiled
with
[
Expr=num_list,
Iterator=const char ,
Skipper=boost::proto::exprns_::expr<boost::proto::tagns_::tag::bitwise_or,boost::proto::argsns_::list2<const boost::proto::exprns_::expr<boost::proto::tagns_::tag::terminal,boost::proto::argsns_::term<boost::spirit::tag::char_codeboost::spirit::tag::space,boost::spirit::char_encoding::standard>,0> &,const boost::proto::exprns_::expr<boost::proto::tagns_::tag::shift_right,boost::proto::argsns_::list2<const boost::proto::exprns_::expr<boost::proto::tagns_::tag::shift_right,boost::proto::argsns_::list2<boost::proto::exprns_::expr<boost::proto::tagns_::tag::terminal,boost::proto::argsns_::term<const char &>,0>,const boost::proto::exprns_::expr<boost::proto::tagns_::tag::dereference,boost::proto::argsns_::list1<const boost::proto::exprns_::expr<boost::proto::tagns_::tag::complement,boost::proto::argsns_::list1<const boost::proto::exprns_::expr<boost::proto::tagns_::tag::terminal,boost::proto::argsns_::term<boost::spirit::terminal_ex<boost::spirit::tag::standard::char_,boost::fusion::vector>>,0> &>,1> &>,1> &>,2> &,boost::proto::exprns_::expr<boost::proto::tagns_::tag::terminal,boost::proto::argsns_::term<const char &>,0>>,2> &>,2>
]
libs\spirit\test\qi\grammar_fail.cpp(36): note: see reference to function template instantiation 'bool boost::spirit::qi::phrase_parse<const char,num_list,boost::proto::exprns_::expr<Tag,Args,2>>(Iterator &,Iterator,const Expr &,const Skipper &,boost::spirit::qi::skip_flag)' being compiled
with
[
Tag=boost::proto::tagns_::tag::bitwise_or,
Args=boost::proto::argsns_::list2<const boost::proto::exprns_::expr<boost::proto::tagns_::tag::terminal,boost::proto::argsns_::term<boost::spirit::tag::char_codeboost::spirit::tag::space,boost::spirit::char_encoding::standard>,0> &,const boost::proto::exprns_::expr<boost::proto::tagns_::tag::shift_right,boost::proto::argsns_::list2<const boost::proto::exprns_::expr<boost::proto::tagns_::tag::shift_right,boost::proto::argsns_::list2<boost::proto::exprns_::expr<boost::proto::tagns_::tag::terminal,boost::proto::argsns_::term<const char &>,0>,const boost::proto::exprns_::expr<boost::proto::tagns_::tag::dereference,boost::proto::argsns_::list1<const boost::proto::exprns_::expr<boost::proto::tagns_::tag::complement,boost::proto::argsns_::list1<const boost::proto::exprns_::expr<boost::proto::tagns_::tag::terminal,boost::proto::argsns_::term<boost::spirit::terminal_ex<boost::spirit::tag::standard::char_,boost::fusion::vector>>,0> &>,1> &>,1> &>,2> &,boost::proto::exprns_::expr<boost::proto::tagns_::tag::terminal,boost::proto::argsns_::term<const char &>,0>>,2> &>,
Iterator=const char *,
Expr=num_list,
Skipper=boost::proto::exprns_::expr<boost::proto::tagns_::tag::bitwise_or,boost::proto::argsns_::list2<const boost::proto::exprns_::expr<boost::proto::tagns_::tag::terminal,boost::proto::argsns_::term<boost::spirit::tag::char_codeboost::spirit::tag::space,boost::spirit::char_encoding::standard>,0> &,const boost::proto::exprns_::expr<boost::proto::tagns_::tag::shift_right,boost::proto::argsns_::list2<const boost::proto::exprns_::expr<boost::proto::tagns_::tag::shift_right,boost::proto::argsns_::list2<boost::proto::exprns_::expr<boost::proto::tagns_::tag::terminal,boost::proto::argsns_::term<const char &>,0>,const boost::proto::exprns_::expr<boost::proto::tagns_::tag::dereference,boost::proto::argsns_::list1<const boost::proto::exprns_::expr<boost::proto::tagns_::tag::complement,boost::proto::argsns_::list1<const boost::proto::exprns_::expr<boost::proto::tagns_::tag::terminal,boost::proto::argsns_::term<boost::spirit::terminal_ex<boost::spirit::tag::standard::char_,boost::fusion::vector>>,0> &>,1> &>,1> &>,2> &,boost::proto::exprns_::expr<boost::proto::tagns_::tag::terminal,boost::proto::argsns_::term<const char &>,0>>,2> &>,2>
]

Unsupported compilers

Compiler	Module	Problem
MSVC 7.1	fusion::fold	log
clang 3.1 c++11	spirit::lex	log
MinGW GCC 4.3	proto	log ICE

It is even hard to obtain an environment with these compilers to try to fix the problems.
I going to mark them unusable in explicit-failures-markup.xml. Any objections?

P.S.: Is there a planned date for removing Spirit.Classic?

move the trac tickets over to github

Move issues from
https://svn.boost.org/trac10/query?status=assigned&status=new&status=reopened&component=spirit&col=id&col=summary&col=status&col=type&col=milestone&col=component&order=priority
to here.

Coverity static analysis defects

(copied from https://svn.boost.org/trac10/ticket/13331, only Spirit's parts from the attached report)

Boost 1.57.0

A static analysis tool called Coverity found medium and high defects in the boost source code. See attached file for defect type, defect category, filename and line number of defect.

Defect Type	Defect Category	Line Number	Filename
Resource leak	Resource leaks	271	/boost/include/boost/spirit/home/classic/core/non_terminal/impl/grammar.ipp
Wrapper object use after free	Memory - illegal access	167	/boost/include/boost/spirit/home/classic/core/non_terminal/impl/grammar.ipp

invalid static_cast when using _val = style assignment in semantic action Boost 1.65.1

I apologize if this comes across as a usage question rather than a bug report. I do not understand why this code does not compile and wonder whether it should:

qi::rule<It, std::string()> rule = qi::int_ 
   [ _val = px::bind([](int i) -> std::string { return std::to_string(2*i); }, _1) ];

Full example here

Should it compile? The example is adopted from here and I'll note an analogous example using phx::new_ appears to compile.

If it shouldn't compile, would it be a reasonable enhancement request to support this? Thank you.

1.0#... does not work and never worked but has code for it

Update: Was already reported on trac 5 years ago https://svn.boost.org/trac10/ticket/8699.

Real parsers fail on infinity values in form 1.0#INF and it never ever worked (in both Qi and X3). The only mention that Spirit parses things like that was buried in RealPolicies documentation.

The current code

spirit/include/boost/spirit/home/qi/numeric/detail/real_impl.hpp

Lines 300 to 315 in cf631bf

 else if (traits::is_equal_to_one(acc_n)) 

 { 

 // There is a chance of having to parse one of the 1.0#... 

 // styles some implementations use for representing NaN or Inf. 

 // Check whether the number to parse is a NaN or Inf 

 if (p.parse_nan(first, last, n) || 

 p.parse_inf(first, last, n)) 

 { 

 // If we got a negative sign, negate the number 

 traits::assign_to(traits::negate(neg, n), attr); 

 return true; // got a NaN or Inf, return immediately 

 } 

 n = static_cast<T>(acc_n); 

 }

accepts values in undocumented form like 1INF and 1.INF, but it fails with mantissa - i.e., 1.0INF.

Fixing it to allow 1.0#INF scares me because it will be backward-incompatible change for users that rely on current behavior, it will break parsers like double_ >> "#...". I think this code need to be removed, as it never accepted values in documented form and has undocumented implications. Removing the code will make real parser slightly faster and will remove custom real requirement for traits::is_equal_to_one (partly solves the problem mentioned in #163).

        BOOST_TEST(test("1#INF", double_));    // Fails
        BOOST_TEST(test("1.#INF", double_));   // Fails
        BOOST_TEST(test("1.0#INF", double_));  // Fails
        BOOST_TEST(test("1INF", double_));     // Ok, but must not
        BOOST_TEST(test("1.INF", double_));    // Ok, but must not
        BOOST_TEST(test("1.0INF", double_));   // Fails

msvc-14.0 error C2039: 'on_success': is not a member of ...

Compiling this code with msvc-14.0:

#include <boost/detail/lightweight_test.hpp>
#include <boost/spirit/home/x3.hpp>
#include <boost/spirit/home/x3/support/utility/error_reporting.hpp>
#include <string>
#include <sstream>

namespace x3 = boost::spirit::x3;

struct error_handler_base
{
    template <typename Iterator, typename Exception, typename Context>
    x3::error_handler_result on_error(
        Iterator& first, Iterator const& last
      , Exception const& x, Context const& context)
    {
        std::string message = "Error! Expecting: " + x.which() + " here:";
        auto& error_handler = x3::get<x3::error_handler_tag>(context).get();
        error_handler(x.where(), message);
        return x3::error_handler_result::fail;
    }
};

struct test_rule_class : error_handler_base {};

x3::rule<test_rule_class> const test_rule;
auto const test_rule_def = x3::lit("foo") > x3::lit("bar") > x3::lit("git");

BOOST_SPIRIT_DEFINE(test_rule);

void test(std::string const& line_break) {
    std::string const input("foo" + line_break + "  foo" + line_break + "git");
    auto const begin = std::begin(input);
    auto const end = std::end(input);

    std::stringstream stream;
    x3::error_handler<std::string::const_iterator> const error_handler{begin, end, stream};

    auto const parser = x3::with<x3::error_handler_tag>(std::ref(error_handler))[test_rule];
    x3::phrase_parse(begin, end, parser, x3::space);

    BOOST_TEST_EQ(stream.str(), "In line 2:\nError! Expecting: \"bar\" here:\n  foo\n__^_\n");
}

int main() {
    test("\n");
    test("\r");
    test("\r\n");

    return boost::report_errors();
}

leads to this error messages:


error_handler.cpp
.\boost/spirit/home/x3/nonterminal/detail/rule.hpp(174): error C2039: 'on_success': is not a member of 'test_rule_class'
libs\spirit\test\x3\error_handler.cpp(29): note: see declaration of 'test_rule_class'
.\boost/spirit/home/x3/nonterminal/detail/rule.hpp(220): note: see reference to function template instantiation 'bool boost::spirit::x3::detail::rule_parser<boost::spirit::x3::unused_type,ID>::call_on_success<Iterator,Context,ActualAttribute>(Iterator &,const Iterator &,const Context &,ActualAttribute &,boost::mpl::true_)' being compiled
        with
        [
            ID=test_rule_class,
            Iterator=std::_String_const_iterator<std::_String_val<std::_Simple_types<char>>>,
            Context=boost::spirit::x3::context<boost::spirit::x3::error_handler_tag,std::reference_wrapper<const boost::spirit::x3::error_handler<std::_String_const_iterator<std::_String_val<std::_Simple_types<char>>>>>,boost::spirit::x3::context<boost::spirit::x3::skipper_tag,const boost::spirit::x3::standard::space_type,boost::spirit::x3::unused_type>>,
            ActualAttribute=transform_attr
        ]
.\boost/spirit/home/x3/nonterminal/detail/rule.hpp(219): note: see reference to function template instantiation 'bool boost::spirit::x3::detail::rule_parser<boost::spirit::x3::unused_type,ID>::call_on_success<Iterator,Context,ActualAttribute>(Iterator &,const Iterator &,const Context &,ActualAttribute &,boost::mpl::true_)' being compiled
        with
        [
            ID=test_rule_class,
            Iterator=std::_String_const_iterator<std::_String_val<std::_Simple_types<char>>>,
            Context=boost::spirit::x3::context<boost::spirit::x3::error_handler_tag,std::reference_wrapper<const boost::spirit::x3::error_handler<std::_String_const_iterator<std::_String_val<std::_Simple_types<char>>>>>,boost::spirit::x3::context<boost::spirit::x3::skipper_tag,const boost::spirit::x3::standard::space_type,boost::spirit::x3::unused_type>>,
            ActualAttribute=transform_attr
        ]
... [cut]

All other tests compile fine...
Does somebody know a workaround for this error?
Is x3 designated to compile with msvc-14.0?

hold_any: bugged or false positive?

../boost/spirit/home/support/detail/hold_any.hpp:226:17: warning: placement new constructing an object of type 'std::__cxx11::basic_string<char>' and size '32' in a region of type 'void*' and size '8' [-Wplacement-new=]

http://www.boost.org/development/tests/develop/output/teeks99-03-dg7-1z-Docker-64on64-spirit-gcc-gnu-7~c++1z-warnings.html

It looks like a false positive, but still scares me, because the author of original hold_any has rewritten it because of bugs:

Updated in 2011: After five years, I have rewritten the class from scratch to fix some really nasty bugs and to simplify the code.
https://www.codeproject.com/Articles/11250/High-Performance-Dynamic-Typing-in-C-using-a-Repla

optional_attribute is useless in x3/support/traits/attribute_category.hpp

Unlike the other *_attribute tags, optional_attribute is not used anywhere.
Shouldn't there be:

template <typename T>
struct attribute_category<boost::optional<T>>
    : mpl::identity<optional_attribute> {};

Also, in move_to.hpp, shouldn't there be a move_to function for optional?

Making an interactive shell with Spirit

Hello,
I'm trying to create an interactive shell with the help of Spirit X3. Let's say I want to create a parser for the "ls" command:

#include <iostream>
#include <boost/spirit/home/x3.hpp>
#include <boost/fusion/include/adapt_struct.hpp>
#include <boost/fusion/adapted/struct/adapt_struct.hpp>
namespace x3 = boost::spirit::x3;
struct context_path_tag;

bool checkPath(const std::vector<std::string> location, const std::string& name)
{
    // logic for checking the filesystem
}

struct ls_command {
    std::vector<std::string> options;
    std::vector<std::string> path;
};
BOOST_FUSION_ADAPT_STRUCT(ls_command, options, path)

struct name_class {
    template <typename T, typename Iterator, typename Context>
    void on_success(Iterator const&, Iterator const&, T& ast, Context const& context)
    {
        auto& context_path = x3::get<context_path_tag>(context);

        if (!checkPath(context_path, ast))
            _pass(context) = false;
        else
            context_path.push_back(ast);
    }
};

struct path_class;
struct ls_option_class;
struct ls_class;

x3::rule<name_class, std::string> name;
x3::rule<ls_option_class, std::string> ls_option;
x3::rule<path_class, std::vector<std::string>> path;
x3::rule<ls_class, ls_command> ls;

auto const name_def = +x3::alpha;
auto const ls_option_def = x3::string("--all") | x3::string("--recursive");
auto const path_def = name % '/';
auto const ls_def = x3::lit("ls") >> *ls_option >> path;
BOOST_SPIRIT_DEFINE(name, ls_option, path, ls)

int main(int argc, char* argv[])
{
    while (true) {
        std::string line;
        std::getline(std::cin, line);
        std::vector<std::string> context_path;
        auto grammar = x3::with<context_path_tag>(context_path)[ls];

        auto it = line.begin();
        ls_command cmd;
        x3::phrase_parse(it, line.end(), grammar, x3::space, cmd);
    }
    return 0;
}

The idea behind the on_success handler is, that I don't know what files are there in the filesystem, so I use the x3::alpha parser to parse anything, that could be a valid path fragment and then I use the handler to check whether that path really exists with the help of context_path and checkPath and then either failing the parser or pushing the path fragment into context_path. Now let's say I want to implement some of sort of auto-completion for my program. Now, I would like to use Spirit to parse this string and tell me which rule was the first to fail parsing. For example, the user types in "ls directory/another_dir/nonexistent_dir" and the parsing stops just before the last slash (because I would artificially fail the rule because of the nonexistent directory) and the first failed rule would be the name rule.

Qi uint_parser producing inconsistent results

Using Boost.Spirit Qi Based on the Google protobuf specification:

strLit = ( "'" { charValue } "'" ) | ( '"' { charValue } '"' )
charValue = hexEscape | octEscape | charEscape | /[^\0\n\\]/
hexEscape = '\' ( "x" | "X" ) hexDigit hexDigit
octEscape = '\' octalDigit octalDigit octalDigit
charEscape = '\' ( "a" | "b" | "f" | "n" | "r" | "t" | "v" | '\' | "'" | '"' )
quote = "'" | '"'

I have the base rules, given:

using str_t = std::string;
// ...
using char_rule_type = qi::rule<It, char()>;
using string_rule_type = qi::rule<It, ast::str_t()>;

Declared as:

char_rule_type hex_esc, oct_esc, char_esc, char_val;
string_rule_type str_lit;

And the definition:

hex_esc %= no_case["\\x"] >> uint_parser<unsigned char, 16, 2, 2>{};
oct_esc %= '\\' >> uint_parser<unsigned char, 8, 3, 3>{};
char_val %= hex_esc | oct_esc | char_esc | ~char_("\0\n\\");
str_lit %= ("'" >> *(char_val - "'") >> "'")
    | ('"' >> *(char_val - '"') >> '"');
// ...
struct escapes_t : qi::symbols<char, char> {
    escapes_t() {
        this->add("\\a", '\a')
            ("\\b", '\b')
            ("\\f", '\f')
            ("\\n", '\n')
            ("\\r", '\r')
            ("\\t", '\t')
            ("\\v", '\v')
            ("\\\\", '\\')
            ("\\'", '\'')
            ("\\\"", '"')
            ;
    }
} char_esc;

I am finding that Octal encoded strings parse and land in the raw characters. However, the Hexadecimal encoded strings are somehow landing as the string, whereas I would expect the raw character itself.

So, in other words, given input "\\100\\101\\102\\103", I get in response, "@ABC". However, given "\\x40\\x41\\x42\\x43" yields "\\x40\\x41\\x42\\x43". Not at all what I would expect; in fact, given the rules, I'm not sure how you get that and not the decoded raw result?

X3: Unwrap forward_ast in visitor (like variant does for recursive_wrapper)

unlike boost::recursive_wrapper, x3::forward_ast binds better to auto than to the underlying type.

#include <boost/variant.hpp>
#include <iostream>
#include <type_traits>
#include <utility>
#include <boost/spirit/home/x3/support/ast/variant.hpp>

template <typename...> struct overload_set {
  void operator()() {}
};

template <typename Func, typename... Funcs>
struct overload_set<Func, Funcs...> : Func, overload_set<Funcs...> {
  using Func::operator();
  using overload_set<Funcs...>::operator();

  overload_set(const Func &f, const Funcs &... fs)
      : Func(f), overload_set<Funcs...>(fs...) {}
};

template <typename... Funcs> auto overload(Funcs &&... fs) {
  using os = overload_set<typename std::remove_reference<Funcs>::type...>;
  return os(std::forward<Funcs>(fs)...);
}

struct Rec;
using Var = boost::variant<int, boost::recursive_wrapper<Rec>>;
struct Rec {
  Var var;
};

namespace x3 = boost::spirit::x3;
struct Rec2;
using Var2 = x3::variant<int, x3::forward_ast<Rec2>>;
struct Rec2 {
  Var2 var;
};

int main() {
  auto f = overload([](Rec) { std::cout << "Rec\n"; },
                    [](const auto &a) { std::cout << "other\n"; });
  boost::apply_visitor(f, Var{Rec{}});

  auto f2 = overload([](Rec2) { std::cout << "Rec\n"; },
                     [](const auto &a) { std::cout << "other\n"; });
  boost::apply_visitor(f2, Var2{Rec2{}});
}

output is

Rec
other

Boost 1.64
Tested on MSVC 15.7 and Clang 5

Variants are not supported by parsers that lazily synthesize attributes e.g. `string`

If parser lazily synthesize attribute (e.g. string) it actually exposes a pair of iterators that will be used to build an attribute inplace by qi::assign_to/x3::move_to call.

But neither x3::move_to(first, last, attr) nor qi::assign_to(first, last, attr) support variants. So next code fails to compile while logically valid:

#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/home/x3.hpp>
#include <boost/variant.hpp>
#include <string>

int main()
{
    typedef boost::variant<int, std::string> attribute_type;
#if X3
    {
        namespace x3 = boost::spirit::x3;
        x3::rule<class r, attribute_type> r;
        auto start = r = x3::string("foo");

        // need to have a parse call to instantiate the templates
        attribute_type a;
        std::string s = "foo";
        x3::parse(s.cbegin(), s.cend(), start, a);
    }
#else
    {
        namespace qi = boost::spirit::qi;
        qi::rule<const char*, attribute_type()> r;
        r = qi::string("foo");
    }
#endif
    return 0;
}

x3 literal ints

It seems that literal int parsers are not implemented yet.
For example the code

std::string input = "5";
assert(b::parse(input.begin(), input.end(), b::int_(5)));
assert(b::parse(input.begin(), input.end(), b::lit(5)));

does not compile with

namespace b = boost::spirit::x3;

but does with

namespace b = boost::spirit::qi;

see https://wandbox.org/permlink/VFrnkOt9sTibHdvA

is there an alternative or plans to support this?

Boost failed when run spirit test with MSVC on Windows.

Boost failed with run time failure when run spirit test with MSVC on Windows, I use latest source on master branch. Could you please help take a look at this?

Reproduce steps:

git clone -c core.autocrlf=true --recursive https://github.com/boostorg/boost.git D:\Boost\src
open a VS 2015 x86 command prompt and browse to D:\Boost\src
.\bootstrap
.\b2 headers variant=release --build-dir=..\out\Release --address-model=32
.\b2 variant=release --build-dir=..\out\Release --address-model=32
.\b2 -j4 variant=release --build-dir=..\out\x86rel libs\spirit\test

Expected result:
All tests passed

Actual result:
libs\spirit\test\x3\binary.cpp(65): test 'test_attr("\x01\x02", word, us) && us == 0x0102' failed in function 'int __cdecl main(void)'
libs\spirit\test\x3\binary.cpp(66): test 'test_attr("\x01\x02\x03\x04", dword, ui) && ui == 0x01020304' failed in function 'int __cdecl main(void)'
libs\spirit\test\x3\binary.cpp(69): test 'test_attr("\x01\x02\x03\x04\x05\x06\x07\x08", qword, ul) && ul == 0x0102030405060708LL' failed in function 'int __cdecl main(void)'
libs\spirit\test\x3\binary.cpp(92): test 'test("\x01\x02", word(0x0102))' failed in function 'int __cdecl main(void)'
libs\spirit\test\x3\binary.cpp(93): test 'test("\x01\x02\x03\x04", dword(0x01020304))' failed in function 'int __cdecl main(void)'
libs\spirit\test\x3\binary.cpp(96): test 'test("\x01\x02\x03\x04\x05\x06\x07\x08", qword(0x0102030405060708LL))' failed in function 'int __cdecl main(void)'
6 errors detected.

EXIT STATUS: 1
====== END OUTPUT ======

set status=0
if %status% NEQ 0 (
    echo Skipping test execution due to testing.execute=off
    exit 0
)
 "..\out\x86rel\boost\bin.v2\libs\spirit\test\x3\x3_binary.test\msvc-14.1\release\threading-multi\x3_binary.exe"   > "..\out\x86rel\boost\bin.v2\libs\spirit\test\x3\x3_binary.test\msvc-14.1\release\threading-multi\x3_binary.output" 2>&1 
set status=%ERRORLEVEL%
echo. >> "..\out\x86rel\boost\bin.v2\libs\spirit\test\x3\x3_binary.test\msvc-14.1\release\threading-multi\x3_binary.output"
echo EXIT STATUS: %status% >> "..\out\x86rel\boost\bin.v2\libs\spirit\test\x3\x3_binary.test\msvc-14.1\release\threading-multi\x3_binary.output"
if %status% EQU 0 (
    copy "..\out\x86rel\boost\bin.v2\libs\spirit\test\x3\x3_binary.test\msvc-14.1\release\threading-multi\x3_binary.output" "..\out\x86rel\boost\bin.v2\libs\spirit\test\x3\x3_binary.test\msvc-14.1\release\threading-multi\x3_binary.run"
)
set verbose=0
if %status% NEQ 0 (
    set verbose=1
)
if %verbose% EQU 1 (
    echo ====== BEGIN OUTPUT ======
    type "..\out\x86rel\boost\bin.v2\libs\spirit\test\x3\x3_binary.test\msvc-14.1\release\threading-multi\x3_binary.output"
    echo ====== END OUTPUT ======
)
exit %status%

crash when expecting a std::string literal

https://wandbox.org/permlink/qSp4Kkb1bLd5rl0u:

#include <boost/spirit/home/x3.hpp>
namespace x3 = boost::spirit::x3;

auto parser() {
    std::string b = "5";
    return x3::eps > b;
}

int main() {
    std::string input = "5";
    assert(x3::parse(input.begin(), input.end(), parser()));
}

terminating with uncaught exception of type boost::exception_detail::clone_impl<boost::exception_detail::error_info_injector<boost::spirit::x3::expectation_failure<std::__1::__wrap_iter<char*> > > >: boost::spirit::x3::expectation_failure

It seems the cause is at

spirit/include/boost/spirit/home/x3/string/literal_string.hpp

Line 231 in b023ffa

Char const*, char_encoding::standard, unused_type>

where it should be std::basic_string<Char> instead of Char const*, as currently the parser stores a pointer to the string buffer which goes out of scope.

The same code passes without problems with qi: https://wandbox.org/permlink/6xLC19SSZXQXjCp5

X3: Missing `as` directive

In my grammar there are keywords whose semantic value is their string. I need the opposite of omit, and if I understand correctly the documentation, I'm looking for as_string, or as_string. Neither exist, there's just a commented include .

Thanks!

Compiler failure when combining % with unary -

Using boost 1.61, on both clang 3.8.0, and GCC 5.4, I get errors when compiling the following code:

#include <string>
#include <boost/spirit/home/x3.hpp>
#include <boost/fusion/adapted.hpp>
#include <tuple>
#include <vector>
#include <cassert>

void do_test(std::string input)
{
    namespace x3 = boost::spirit::x3;

    using x3::char_;
    using x3::lit;
    using x3::alpha;

    auto const word = +(alpha - ' ');


    auto first = begin(input);
    auto last = end(input);

    //this works
    {
        auto const& g = word;
        std::string out;
        x3::parse(first, last, g, out);
    }
    {
        auto const& g = (word % ',');
        std::vector<std::string> out;
        x3::parse(first, last, g, out);
    }
    {
        auto const& g = lit('/') >> (word % ',');
        std::vector<std::string> out;
        x3::parse(first, last, g, out);
    }
    {
        auto const& g = -(word % ',');
        std::vector<std::string> out;
        x3::parse(first, last, g, out);
    }
    {
        auto const& g = -(lit('/') >> (word % ','));
        std::vector<std::string> out;
        x3::parse(first, last, g, out);
    }
    {
        auto const& g = -(lit('/') >> (word % ',') >> -lit('/'));
        std::vector<std::string> out;
        x3::parse(first, last, g, out);
    }
    {
        auto const& g = word >> lit(':') >> word;
        std::tuple<std::string, std::string> out;
        x3::parse(first, last, g, out);
    }
    {
        auto const& g = word >> lit(':') >> -(word % ',');
        std::tuple<std::string, std::vector<std::string>> out;
        x3::parse(first, last, g, out);
    }
    //but this fails.
    {
        auto const& g = word >> lit(':') >> -(lit('/') >> (word % ',') >> -lit('/'));
        std::tuple<std::string, std::vector<std::string>> out;
        x3::parse(first, last, g, out);
    }
    {
        auto const& g = word >> lit(':') >> -((word % ',') >> -lit('/'));
        std::tuple<std::string, std::vector<std::string>> out;
        x3::parse(first, last, g, out);
    }

}

with the following error message:

FAILED: /usr/bin/x86_64-linux-gnu-g++   -I../ext/boost-spirit/include -g -ggdb3   -fPIC -std=gnu++14 -MD -MT src/rtsp-header-parse/CMakeFiles/rtsp-header-parse.dir/rtsp-header-parse/test.cpp.o -MF src/rtsp-header-parse/CMakeFiles/rtsp-header-parse.dir/rtsp-header-parse/test.cpp.o.d -o src/rtsp-header-parse/CMakeFiles/rtsp-header-parse.dir/rtsp-header-parse/test.cpp.o -c ../src/rtsp-header-parse/rtsp-header-parse/test.cpp
In file included from ../ext/boost-spirit/include/boost/spirit/home/x3/auxiliary/any_parser.hpp:15:0,
                 from ../ext/boost-spirit/include/boost/spirit/home/x3/auxiliary.hpp:11,
                 from ../ext/boost-spirit/include/boost/spirit/home/x3.hpp:14,
                 from ../src/rtsp-header-parse/rtsp-header-parse/test.cpp:2:
../ext/boost-spirit/include/boost/spirit/home/x3/support/traits/container_traits.hpp: In instantiation of ‘struct boost::spirit::x3::traits::container_value<boost::fusion::iterator_range<boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 1>, boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 2> >, void>’:
../ext/boost-spirit/include/boost/spirit/home/x3/core/detail/parse_into_container.hpp:227:12:   required from ‘struct boost::spirit::x3::detail::parser_attr_is_substitute_for_container_value<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::fusion::iterator_range<boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 1>, boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 2> >, boost::spirit::x3::unused_type>’
../ext/boost-spirit/include/boost/mpl/aux_/nested_type_wknd.hpp:26:31:   required from ‘struct boost::mpl::aux::nested_type_wknd<boost::spirit::x3::detail::parser_attr_is_substitute_for_container_value<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::fusion::iterator_range<boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 1>, boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 2> >, boost::spirit::x3::unused_type> >’
../ext/boost-spirit/include/boost/mpl/not.hpp:39:8:   required from ‘struct boost::mpl::not_<boost::spirit::x3::detail::parser_attr_is_substitute_for_container_value<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::fusion::iterator_range<boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 1>, boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 2> >, boost::spirit::x3::unused_type> >’
../ext/boost-spirit/include/boost/mpl/aux_/nested_type_wknd.hpp:26:31:   required from ‘struct boost::mpl::aux::nested_type_wknd<boost::mpl::not_<boost::spirit::x3::detail::parser_attr_is_substitute_for_container_value<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::fusion::iterator_range<boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 1>, boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 2> >, boost::spirit::x3::unused_type> > >’
../ext/boost-spirit/include/boost/mpl/aux_/preprocessed/gcc/or.hpp:23:8:   required from ‘struct boost::mpl::aux::or_impl<false, boost::mpl::not_<boost::spirit::x3::detail::parser_attr_is_substitute_for_container_value<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::fusion::iterator_range<boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 1>, boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 2> >, boost::spirit::x3::unused_type> >, mpl_::bool_<false>, mpl_::bool_<false>, mpl_::bool_<false> >’
../ext/boost-spirit/include/boost/mpl/aux_/preprocessed/gcc/or.hpp:48:8:   [ skipping 7 instantiation contexts, use -ftemplate-backtrace-limit=0 to disable ]
../ext/boost-spirit/include/boost/spirit/home/x3/core/proxy.hpp:42:73:   required from ‘bool boost::spirit::x3::proxy<Subject, Derived>::parse(Iterator&, const Iterator&, const Context&, RuleContext&, Attribute&) const [with Iterator = __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char> >; Context = boost::spirit::x3::unused_type; RuleContext = const boost::spirit::x3::unused_type; Attribute = boost::fusion::iterator_range<boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 1>, boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 2> >; Subject = boost::spirit::x3::sequence<boost::spirit::x3::list<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> >, boost::spirit::x3::optional<boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >; Derived = boost::spirit::x3::optional<boost::spirit::x3::sequence<boost::spirit::x3::list<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> >, boost::spirit::x3::optional<boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > > >]’
../ext/boost-spirit/include/boost/spirit/home/x3/operator/detail/sequence.hpp:312:13:   required from ‘bool boost::spirit::x3::detail::parse_sequence(const Parser&, Iterator&, const Iterator&, const Context&, RContext&, Attribute&, boost::spirit::x3::traits::tuple_attribute) [with Parser = boost::spirit::x3::sequence<boost::spirit::x3::sequence<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> >, boost::spirit::x3::optional<boost::spirit::x3::sequence<boost::spirit::x3::list<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> >, boost::spirit::x3::optional<boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > > > >; Iterator = __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char> >; Context = boost::spirit::x3::unused_type; RContext = const boost::spirit::x3::unused_type; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >]’
../ext/boost-spirit/include/boost/spirit/home/x3/operator/sequence.hpp:44:42:   required from ‘bool boost::spirit::x3::sequence<Left, Right>::parse(Iterator&, const Iterator&, const Context&, RContext&, Attribute&) const [with Iterator = __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char> >; Context = boost::spirit::x3::unused_type; RContext = const boost::spirit::x3::unused_type; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >; Left = boost::spirit::x3::sequence<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> >; Right = boost::spirit::x3::optional<boost::spirit::x3::sequence<boost::spirit::x3::list<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> >, boost::spirit::x3::optional<boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > > >]’
../ext/boost-spirit/include/boost/spirit/home/x3/core/parse.hpp:35:68:   required from ‘bool boost::spirit::x3::parse_main(Iterator&, Iterator, const Parser&, Attribute&) [with Iterator = __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char> >; Parser = boost::spirit::x3::sequence<boost::spirit::x3::sequence<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> >, boost::spirit::x3::optional<boost::spirit::x3::sequence<boost::spirit::x3::list<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> >, boost::spirit::x3::optional<boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > > > >; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >]’
../ext/boost-spirit/include/boost/spirit/home/x3/core/parse.hpp:47:26:   required from ‘bool boost::spirit::x3::parse(Iterator&, Iterator, const Parser&, Attribute&) [with Iterator = __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char> >; Parser = boost::spirit::x3::sequence<boost::spirit::x3::sequence<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> >, boost::spirit::x3::optional<boost::spirit::x3::sequence<boost::spirit::x3::list<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> >, boost::spirit::x3::optional<boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > > > >; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >]’
../src/rtsp-header-parse/rtsp-header-parse/test.cpp:72:38:   required from here
../ext/boost-spirit/include/boost/spirit/home/x3/support/traits/container_traits.hpp:76:12: error: no type named ‘value_type’ in ‘struct boost::fusion::iterator_range<boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 1>, boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 2> >’
     struct container_value
            ^
In file included from ../ext/boost-spirit/include/boost/spirit/home/x3/directive/expect.hpp:12:0,
                 from ../ext/boost-spirit/include/boost/spirit/home/x3/auxiliary/guard.hpp:11,
                 from ../ext/boost-spirit/include/boost/spirit/home/x3/auxiliary.hpp:13,
                 from ../ext/boost-spirit/include/boost/spirit/home/x3.hpp:14,
                 from ../src/rtsp-header-parse/rtsp-header-parse/test.cpp:2:
../ext/boost-spirit/include/boost/spirit/home/x3/core/detail/parse_into_container.hpp: In instantiation of ‘struct boost::spirit::x3::detail::parser_attr_is_substitute_for_container_value<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::fusion::iterator_range<boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 1>, boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 2> >, boost::spirit::x3::unused_type>’:
../ext/boost-spirit/include/boost/mpl/aux_/nested_type_wknd.hpp:26:31:   required from ‘struct boost::mpl::aux::nested_type_wknd<boost::spirit::x3::detail::parser_attr_is_substitute_for_container_value<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::fusion::iterator_range<boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 1>, boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 2> >, boost::spirit::x3::unused_type> >’
../ext/boost-spirit/include/boost/mpl/not.hpp:39:8:   required from ‘struct boost::mpl::not_<boost::spirit::x3::detail::parser_attr_is_substitute_for_container_value<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::fusion::iterator_range<boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 1>, boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 2> >, boost::spirit::x3::unused_type> >’
../ext/boost-spirit/include/boost/mpl/aux_/nested_type_wknd.hpp:26:31:   required from ‘struct boost::mpl::aux::nested_type_wknd<boost::mpl::not_<boost::spirit::x3::detail::parser_attr_is_substitute_for_container_value<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::fusion::iterator_range<boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 1>, boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 2> >, boost::spirit::x3::unused_type> > >’
../ext/boost-spirit/include/boost/mpl/aux_/preprocessed/gcc/or.hpp:23:8:   required from ‘struct boost::mpl::aux::or_impl<false, boost::mpl::not_<boost::spirit::x3::detail::parser_attr_is_substitute_for_container_value<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::fusion::iterator_range<boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 1>, boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 2> >, boost::spirit::x3::unused_type> >, mpl_::bool_<false>, mpl_::bool_<false>, mpl_::bool_<false> >’
../ext/boost-spirit/include/boost/mpl/aux_/preprocessed/gcc/or.hpp:48:8:   required from ‘struct boost::mpl::or_<boost::spirit::x3::detail::parser_accepts_container<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::fusion::iterator_range<boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 1>, boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 2> >, boost::spirit::x3::unused_type>, boost::mpl::not_<boost::spirit::x3::detail::parser_attr_is_substitute_for_container_value<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::fusion::iterator_range<boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 1>, boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 2> >, boost::spirit::x3::unused_type> >, mpl_::bool_<false>, mpl_::bool_<false>, mpl_::bool_<false> >’
../ext/boost-spirit/include/boost/spirit/home/x3/core/detail/parse_into_container.hpp:275:24:   [ skipping 6 instantiation contexts, use -ftemplate-backtrace-limit=0 to disable ]
../ext/boost-spirit/include/boost/spirit/home/x3/core/proxy.hpp:42:73:   required from ‘bool boost::spirit::x3::proxy<Subject, Derived>::parse(Iterator&, const Iterator&, const Context&, RuleContext&, Attribute&) const [with Iterator = __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char> >; Context = boost::spirit::x3::unused_type; RuleContext = const boost::spirit::x3::unused_type; Attribute = boost::fusion::iterator_range<boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 1>, boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 2> >; Subject = boost::spirit::x3::sequence<boost::spirit::x3::list<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> >, boost::spirit::x3::optional<boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >; Derived = boost::spirit::x3::optional<boost::spirit::x3::sequence<boost::spirit::x3::list<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> >, boost::spirit::x3::optional<boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > > >]’
../ext/boost-spirit/include/boost/spirit/home/x3/operator/detail/sequence.hpp:312:13:   required from ‘bool boost::spirit::x3::detail::parse_sequence(const Parser&, Iterator&, const Iterator&, const Context&, RContext&, Attribute&, boost::spirit::x3::traits::tuple_attribute) [with Parser = boost::spirit::x3::sequence<boost::spirit::x3::sequence<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> >, boost::spirit::x3::optional<boost::spirit::x3::sequence<boost::spirit::x3::list<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> >, boost::spirit::x3::optional<boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > > > >; Iterator = __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char> >; Context = boost::spirit::x3::unused_type; RContext = const boost::spirit::x3::unused_type; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >]’
../ext/boost-spirit/include/boost/spirit/home/x3/operator/sequence.hpp:44:42:   required from ‘bool boost::spirit::x3::sequence<Left, Right>::parse(Iterator&, const Iterator&, const Context&, RContext&, Attribute&) const [with Iterator = __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char> >; Context = boost::spirit::x3::unused_type; RContext = const boost::spirit::x3::unused_type; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >; Left = boost::spirit::x3::sequence<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> >; Right = boost::spirit::x3::optional<boost::spirit::x3::sequence<boost::spirit::x3::list<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> >, boost::spirit::x3::optional<boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > > >]’
../ext/boost-spirit/include/boost/spirit/home/x3/core/parse.hpp:35:68:   required from ‘bool boost::spirit::x3::parse_main(Iterator&, Iterator, const Parser&, Attribute&) [with Iterator = __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char> >; Parser = boost::spirit::x3::sequence<boost::spirit::x3::sequence<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> >, boost::spirit::x3::optional<boost::spirit::x3::sequence<boost::spirit::x3::list<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> >, boost::spirit::x3::optional<boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > > > >; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >]’
../ext/boost-spirit/include/boost/spirit/home/x3/core/parse.hpp:47:26:   required from ‘bool boost::spirit::x3::parse(Iterator&, Iterator, const Parser&, Attribute&) [with Iterator = __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char> >; Parser = boost::spirit::x3::sequence<boost::spirit::x3::sequence<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> >, boost::spirit::x3::optional<boost::spirit::x3::sequence<boost::spirit::x3::list<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> >, boost::spirit::x3::optional<boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > > > >; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >]’
../src/rtsp-header-parse/rtsp-header-parse/test.cpp:72:38:   required from here
../ext/boost-spirit/include/boost/spirit/home/x3/core/detail/parse_into_container.hpp:227:12: error: no type named ‘type’ in ‘struct boost::spirit::x3::traits::container_value<boost::fusion::iterator_range<boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 1>, boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 2> >, void>’
     struct parser_attr_is_substitute_for_container_value
            ^
In file included from ../ext/boost-spirit/include/boost/mpl/not.hpp:19:0,
                 from ../ext/boost-spirit/include/boost/spirit/home/x3/support/traits/has_attribute.hpp:15,
                 from ../ext/boost-spirit/include/boost/spirit/home/x3/core/parser.hpp:19,
                 from ../ext/boost-spirit/include/boost/spirit/home/x3/auxiliary/any_parser.hpp:11,
                 from ../ext/boost-spirit/include/boost/spirit/home/x3/auxiliary.hpp:11,
                 from ../ext/boost-spirit/include/boost/spirit/home/x3.hpp:14,
                 from ../src/rtsp-header-parse/rtsp-header-parse/test.cpp:2:
../ext/boost-spirit/include/boost/mpl/aux_/nested_type_wknd.hpp: In instantiation of ‘struct boost::mpl::aux::nested_type_wknd<boost::spirit::x3::detail::parser_attr_is_substitute_for_container_value<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::fusion::iterator_range<boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 1>, boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 2> >, boost::spirit::x3::unused_type> >’:
../ext/boost-spirit/include/boost/mpl/not.hpp:39:8:   required from ‘struct boost::mpl::not_<boost::spirit::x3::detail::parser_attr_is_substitute_for_container_value<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::fusion::iterator_range<boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 1>, boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 2> >, boost::spirit::x3::unused_type> >’
../ext/boost-spirit/include/boost/mpl/aux_/nested_type_wknd.hpp:26:31:   required from ‘struct boost::mpl::aux::nested_type_wknd<boost::mpl::not_<boost::spirit::x3::detail::parser_attr_is_substitute_for_container_value<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::fusion::iterator_range<boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 1>, boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 2> >, boost::spirit::x3::unused_type> > >’
../ext/boost-spirit/include/boost/mpl/aux_/preprocessed/gcc/or.hpp:23:8:   required from ‘struct boost::mpl::aux::or_impl<false, boost::mpl::not_<boost::spirit::x3::detail::parser_attr_is_substitute_for_container_value<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::fusion::iterator_range<boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 1>, boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 2> >, boost::spirit::x3::unused_type> >, mpl_::bool_<false>, mpl_::bool_<false>, mpl_::bool_<false> >’
../ext/boost-spirit/include/boost/mpl/aux_/preprocessed/gcc/or.hpp:48:8:   required from ‘struct boost::mpl::or_<boost::spirit::x3::detail::parser_accepts_container<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::fusion::iterator_range<boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 1>, boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 2> >, boost::spirit::x3::unused_type>, boost::mpl::not_<boost::spirit::x3::detail::parser_attr_is_substitute_for_container_value<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::fusion::iterator_range<boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 1>, boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 2> >, boost::spirit::x3::unused_type> >, mpl_::bool_<false>, mpl_::bool_<false>, mpl_::bool_<false> >’
../ext/boost-spirit/include/boost/spirit/home/x3/core/detail/parse_into_container.hpp:275:24:   required from ‘static bool boost::spirit::x3::detail::parse_into_container_impl<Parser, Context, RContext, typename boost::enable_if<boost::spirit::x3::traits::handles_container<Parser, Context> >::type>::call(const Parser&, Iterator&, const Iterator&, const Context&, RContext&, Attribute&) [with Iterator = __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char> >; Attribute = boost::fusion::iterator_range<boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 1>, boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 2> >; Parser = boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >; Context = boost::spirit::x3::unused_type; RContext = const boost::spirit::x3::unused_type]’
../ext/boost-spirit/include/boost/spirit/home/x3/core/detail/parse_into_container.hpp:287:74:   [ skipping 5 instantiation contexts, use -ftemplate-backtrace-limit=0 to disable ]
../ext/boost-spirit/include/boost/spirit/home/x3/core/proxy.hpp:42:73:   required from ‘bool boost::spirit::x3::proxy<Subject, Derived>::parse(Iterator&, const Iterator&, const Context&, RuleContext&, Attribute&) const [with Iterator = __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char> >; Context = boost::spirit::x3::unused_type; RuleContext = const boost::spirit::x3::unused_type; Attribute = boost::fusion::iterator_range<boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 1>, boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 2> >; Subject = boost::spirit::x3::sequence<boost::spirit::x3::list<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> >, boost::spirit::x3::optional<boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >; Derived = boost::spirit::x3::optional<boost::spirit::x3::sequence<boost::spirit::x3::list<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> >, boost::spirit::x3::optional<boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > > >]’
../ext/boost-spirit/include/boost/spirit/home/x3/operator/detail/sequence.hpp:312:13:   required from ‘bool boost::spirit::x3::detail::parse_sequence(const Parser&, Iterator&, const Iterator&, const Context&, RContext&, Attribute&, boost::spirit::x3::traits::tuple_attribute) [with Parser = boost::spirit::x3::sequence<boost::spirit::x3::sequence<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> >, boost::spirit::x3::optional<boost::spirit::x3::sequence<boost::spirit::x3::list<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> >, boost::spirit::x3::optional<boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > > > >; Iterator = __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char> >; Context = boost::spirit::x3::unused_type; RContext = const boost::spirit::x3::unused_type; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >]’
../ext/boost-spirit/include/boost/spirit/home/x3/operator/sequence.hpp:44:42:   required from ‘bool boost::spirit::x3::sequence<Left, Right>::parse(Iterator&, const Iterator&, const Context&, RContext&, Attribute&) const [with Iterator = __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char> >; Context = boost::spirit::x3::unused_type; RContext = const boost::spirit::x3::unused_type; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >; Left = boost::spirit::x3::sequence<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> >; Right = boost::spirit::x3::optional<boost::spirit::x3::sequence<boost::spirit::x3::list<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> >, boost::spirit::x3::optional<boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > > >]’
../ext/boost-spirit/include/boost/spirit/home/x3/core/parse.hpp:35:68:   required from ‘bool boost::spirit::x3::parse_main(Iterator&, Iterator, const Parser&, Attribute&) [with Iterator = __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char> >; Parser = boost::spirit::x3::sequence<boost::spirit::x3::sequence<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> >, boost::spirit::x3::optional<boost::spirit::x3::sequence<boost::spirit::x3::list<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> >, boost::spirit::x3::optional<boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > > > >; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >]’
../ext/boost-spirit/include/boost/spirit/home/x3/core/parse.hpp:47:26:   required from ‘bool boost::spirit::x3::parse(Iterator&, Iterator, const Parser&, Attribute&) [with Iterator = __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char> >; Parser = boost::spirit::x3::sequence<boost::spirit::x3::sequence<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> >, boost::spirit::x3::optional<boost::spirit::x3::sequence<boost::spirit::x3::list<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> >, boost::spirit::x3::optional<boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > > > >; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >]’
../src/rtsp-header-parse/rtsp-header-parse/test.cpp:72:38:   required from here
../ext/boost-spirit/include/boost/mpl/aux_/nested_type_wknd.hpp:26:31: error: no type named ‘type’ in ‘struct boost::spirit::x3::detail::parser_attr_is_substitute_for_container_value<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::fusion::iterator_range<boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 1>, boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 2> >, boost::spirit::x3::unused_type>’
 template< typename T > struct nested_type_wknd
                               ^
In file included from ../ext/boost-spirit/include/boost/spirit/home/x3/support/traits/has_attribute.hpp:15:0,
                 from ../ext/boost-spirit/include/boost/spirit/home/x3/core/parser.hpp:19,
                 from ../ext/boost-spirit/include/boost/spirit/home/x3/auxiliary/any_parser.hpp:11,
                 from ../ext/boost-spirit/include/boost/spirit/home/x3/auxiliary.hpp:11,
                 from ../ext/boost-spirit/include/boost/spirit/home/x3.hpp:14,
                 from ../src/rtsp-header-parse/rtsp-header-parse/test.cpp:2:
../ext/boost-spirit/include/boost/mpl/not.hpp: In instantiation of ‘struct boost::mpl::not_<boost::spirit::x3::detail::parser_attr_is_substitute_for_container_value<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::fusion::iterator_range<boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 1>, boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 2> >, boost::spirit::x3::unused_type> >’:
../ext/boost-spirit/include/boost/mpl/aux_/nested_type_wknd.hpp:26:31:   required from ‘struct boost::mpl::aux::nested_type_wknd<boost::mpl::not_<boost::spirit::x3::detail::parser_attr_is_substitute_for_container_value<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::fusion::iterator_range<boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 1>, boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 2> >, boost::spirit::x3::unused_type> > >’
../ext/boost-spirit/include/boost/mpl/aux_/preprocessed/gcc/or.hpp:23:8:   required from ‘struct boost::mpl::aux::or_impl<false, boost::mpl::not_<boost::spirit::x3::detail::parser_attr_is_substitute_for_container_value<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::fusion::iterator_range<boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 1>, boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 2> >, boost::spirit::x3::unused_type> >, mpl_::bool_<false>, mpl_::bool_<false>, mpl_::bool_<false> >’
../ext/boost-spirit/include/boost/mpl/aux_/preprocessed/gcc/or.hpp:48:8:   required from ‘struct boost::mpl::or_<boost::spirit::x3::detail::parser_accepts_container<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::fusion::iterator_range<boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 1>, boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 2> >, boost::spirit::x3::unused_type>, boost::mpl::not_<boost::spirit::x3::detail::parser_attr_is_substitute_for_container_value<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::fusion::iterator_range<boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 1>, boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 2> >, boost::spirit::x3::unused_type> >, mpl_::bool_<false>, mpl_::bool_<false>, mpl_::bool_<false> >’
../ext/boost-spirit/include/boost/spirit/home/x3/core/detail/parse_into_container.hpp:275:24:   required from ‘static bool boost::spirit::x3::detail::parse_into_container_impl<Parser, Context, RContext, typename boost::enable_if<boost::spirit::x3::traits::handles_container<Parser, Context> >::type>::call(const Parser&, Iterator&, const Iterator&, const Context&, RContext&, Attribute&) [with Iterator = __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char> >; Attribute = boost::fusion::iterator_range<boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 1>, boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 2> >; Parser = boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >; Context = boost::spirit::x3::unused_type; RContext = const boost::spirit::x3::unused_type]’
../ext/boost-spirit/include/boost/spirit/home/x3/core/detail/parse_into_container.hpp:287:74:   required from ‘bool boost::spirit::x3::detail::parse_into_container(const Parser&, Iterator&, const Iterator&, const Context&, RContext&, Attribute&) [with Parser = boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >; Iterator = __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char> >; Context = boost::spirit::x3::unused_type; RContext = const boost::spirit::x3::unused_type; Attribute = boost::fusion::iterator_range<boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 1>, boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 2> >]’
../ext/boost-spirit/include/boost/spirit/home/x3/operator/list.hpp:34:46:   [ skipping 4 instantiation contexts, use -ftemplate-backtrace-limit=0 to disable ]
../ext/boost-spirit/include/boost/spirit/home/x3/core/proxy.hpp:42:73:   required from ‘bool boost::spirit::x3::proxy<Subject, Derived>::parse(Iterator&, const Iterator&, const Context&, RuleContext&, Attribute&) const [with Iterator = __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char> >; Context = boost::spirit::x3::unused_type; RuleContext = const boost::spirit::x3::unused_type; Attribute = boost::fusion::iterator_range<boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 1>, boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 2> >; Subject = boost::spirit::x3::sequence<boost::spirit::x3::list<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> >, boost::spirit::x3::optional<boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >; Derived = boost::spirit::x3::optional<boost::spirit::x3::sequence<boost::spirit::x3::list<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> >, boost::spirit::x3::optional<boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > > >]’
../ext/boost-spirit/include/boost/spirit/home/x3/operator/detail/sequence.hpp:312:13:   required from ‘bool boost::spirit::x3::detail::parse_sequence(const Parser&, Iterator&, const Iterator&, const Context&, RContext&, Attribute&, boost::spirit::x3::traits::tuple_attribute) [with Parser = boost::spirit::x3::sequence<boost::spirit::x3::sequence<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> >, boost::spirit::x3::optional<boost::spirit::x3::sequence<boost::spirit::x3::list<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> >, boost::spirit::x3::optional<boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > > > >; Iterator = __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char> >; Context = boost::spirit::x3::unused_type; RContext = const boost::spirit::x3::unused_type; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >]’
../ext/boost-spirit/include/boost/spirit/home/x3/operator/sequence.hpp:44:42:   required from ‘bool boost::spirit::x3::sequence<Left, Right>::parse(Iterator&, const Iterator&, const Context&, RContext&, Attribute&) const [with Iterator = __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char> >; Context = boost::spirit::x3::unused_type; RContext = const boost::spirit::x3::unused_type; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >; Left = boost::spirit::x3::sequence<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> >; Right = boost::spirit::x3::optional<boost::spirit::x3::sequence<boost::spirit::x3::list<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> >, boost::spirit::x3::optional<boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > > >]’
../ext/boost-spirit/include/boost/spirit/home/x3/core/parse.hpp:35:68:   required from ‘bool boost::spirit::x3::parse_main(Iterator&, Iterator, const Parser&, Attribute&) [with Iterator = __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char> >; Parser = boost::spirit::x3::sequence<boost::spirit::x3::sequence<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> >, boost::spirit::x3::optional<boost::spirit::x3::sequence<boost::spirit::x3::list<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> >, boost::spirit::x3::optional<boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > > > >; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >]’
../ext/boost-spirit/include/boost/spirit/home/x3/core/parse.hpp:47:26:   required from ‘bool boost::spirit::x3::parse(Iterator&, Iterator, const Parser&, Attribute&) [with Iterator = __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char> >; Parser = boost::spirit::x3::sequence<boost::spirit::x3::sequence<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> >, boost::spirit::x3::optional<boost::spirit::x3::sequence<boost::spirit::x3::list<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> >, boost::spirit::x3::optional<boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > > > >; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >]’
../src/rtsp-header-parse/rtsp-header-parse/test.cpp:72:38:   required from here
../ext/boost-spirit/include/boost/mpl/not.hpp:39:8: error: ‘value’ is not a member of ‘boost::mpl::aux::nested_type_wknd<boost::spirit::x3::detail::parser_attr_is_substitute_for_container_value<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::fusion::iterator_range<boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 1>, boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 2> >, boost::spirit::x3::unused_type> >’
 struct not_
        ^
In file included from ../ext/boost-spirit/include/boost/mpl/not.hpp:19:0,
                 from ../ext/boost-spirit/include/boost/spirit/home/x3/support/traits/has_attribute.hpp:15,
                 from ../ext/boost-spirit/include/boost/spirit/home/x3/core/parser.hpp:19,
                 from ../ext/boost-spirit/include/boost/spirit/home/x3/auxiliary/any_parser.hpp:11,
                 from ../ext/boost-spirit/include/boost/spirit/home/x3/auxiliary.hpp:11,
                 from ../ext/boost-spirit/include/boost/spirit/home/x3.hpp:14,
                 from ../src/rtsp-header-parse/rtsp-header-parse/test.cpp:2:
../ext/boost-spirit/include/boost/mpl/aux_/nested_type_wknd.hpp: In instantiation of ‘struct boost::mpl::aux::nested_type_wknd<boost::mpl::not_<boost::spirit::x3::detail::parser_attr_is_substitute_for_container_value<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::fusion::iterator_range<boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 1>, boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 2> >, boost::spirit::x3::unused_type> > >’:
../ext/boost-spirit/include/boost/mpl/aux_/preprocessed/gcc/or.hpp:23:8:   required from ‘struct boost::mpl::aux::or_impl<false, boost::mpl::not_<boost::spirit::x3::detail::parser_attr_is_substitute_for_container_value<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::fusion::iterator_range<boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 1>, boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 2> >, boost::spirit::x3::unused_type> >, mpl_::bool_<false>, mpl_::bool_<false>, mpl_::bool_<false> >’
../ext/boost-spirit/include/boost/mpl/aux_/preprocessed/gcc/or.hpp:48:8:   required from ‘struct boost::mpl::or_<boost::spirit::x3::detail::parser_accepts_container<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::fusion::iterator_range<boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 1>, boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 2> >, boost::spirit::x3::unused_type>, boost::mpl::not_<boost::spirit::x3::detail::parser_attr_is_substitute_for_container_value<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::fusion::iterator_range<boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 1>, boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 2> >, boost::spirit::x3::unused_type> >, mpl_::bool_<false>, mpl_::bool_<false>, mpl_::bool_<false> >’
../ext/boost-spirit/include/boost/spirit/home/x3/core/detail/parse_into_container.hpp:275:24:   required from ‘static bool boost::spirit::x3::detail::parse_into_container_impl<Parser, Context, RContext, typename boost::enable_if<boost::spirit::x3::traits::handles_container<Parser, Context> >::type>::call(const Parser&, Iterator&, const Iterator&, const Context&, RContext&, Attribute&) [with Iterator = __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char> >; Attribute = boost::fusion::iterator_range<boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 1>, boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 2> >; Parser = boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >; Context = boost::spirit::x3::unused_type; RContext = const boost::spirit::x3::unused_type]’
../ext/boost-spirit/include/boost/spirit/home/x3/core/detail/parse_into_container.hpp:287:74:   required from ‘bool boost::spirit::x3::detail::parse_into_container(const Parser&, Iterator&, const Iterator&, const Context&, RContext&, Attribute&) [with Parser = boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >; Iterator = __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char> >; Context = boost::spirit::x3::unused_type; RContext = const boost::spirit::x3::unused_type; Attribute = boost::fusion::iterator_range<boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 1>, boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 2> >]’
../ext/boost-spirit/include/boost/spirit/home/x3/operator/list.hpp:34:46:   required from ‘bool boost::spirit::x3::list<Left, Right>::parse(Iterator&, const Iterator&, const Context&, RContext&, Attribute&) const [with Iterator = __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char> >; Context = boost::spirit::x3::unused_type; RContext = const boost::spirit::x3::unused_type; Attribute = boost::fusion::iterator_range<boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 1>, boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 2> >; Left = boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >; Right = boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type>]’
../ext/boost-spirit/include/boost/spirit/home/x3/operator/detail/sequence.hpp:312:13:   [ skipping 3 instantiation contexts, use -ftemplate-backtrace-limit=0 to disable ]
../ext/boost-spirit/include/boost/spirit/home/x3/core/proxy.hpp:42:73:   required from ‘bool boost::spirit::x3::proxy<Subject, Derived>::parse(Iterator&, const Iterator&, const Context&, RuleContext&, Attribute&) const [with Iterator = __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char> >; Context = boost::spirit::x3::unused_type; RuleContext = const boost::spirit::x3::unused_type; Attribute = boost::fusion::iterator_range<boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 1>, boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 2> >; Subject = boost::spirit::x3::sequence<boost::spirit::x3::list<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> >, boost::spirit::x3::optional<boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >; Derived = boost::spirit::x3::optional<boost::spirit::x3::sequence<boost::spirit::x3::list<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> >, boost::spirit::x3::optional<boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > > >]’
../ext/boost-spirit/include/boost/spirit/home/x3/operator/detail/sequence.hpp:312:13:   required from ‘bool boost::spirit::x3::detail::parse_sequence(const Parser&, Iterator&, const Iterator&, const Context&, RContext&, Attribute&, boost::spirit::x3::traits::tuple_attribute) [with Parser = boost::spirit::x3::sequence<boost::spirit::x3::sequence<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> >, boost::spirit::x3::optional<boost::spirit::x3::sequence<boost::spirit::x3::list<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> >, boost::spirit::x3::optional<boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > > > >; Iterator = __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char> >; Context = boost::spirit::x3::unused_type; RContext = const boost::spirit::x3::unused_type; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >]’
../ext/boost-spirit/include/boost/spirit/home/x3/operator/sequence.hpp:44:42:   required from ‘bool boost::spirit::x3::sequence<Left, Right>::parse(Iterator&, const Iterator&, const Context&, RContext&, Attribute&) const [with Iterator = __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char> >; Context = boost::spirit::x3::unused_type; RContext = const boost::spirit::x3::unused_type; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >; Left = boost::spirit::x3::sequence<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> >; Right = boost::spirit::x3::optional<boost::spirit::x3::sequence<boost::spirit::x3::list<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> >, boost::spirit::x3::optional<boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > > >]’
../ext/boost-spirit/include/boost/spirit/home/x3/core/parse.hpp:35:68:   required from ‘bool boost::spirit::x3::parse_main(Iterator&, Iterator, const Parser&, Attribute&) [with Iterator = __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char> >; Parser = boost::spirit::x3::sequence<boost::spirit::x3::sequence<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> >, boost::spirit::x3::optional<boost::spirit::x3::sequence<boost::spirit::x3::list<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> >, boost::spirit::x3::optional<boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > > > >; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >]’
../ext/boost-spirit/include/boost/spirit/home/x3/core/parse.hpp:47:26:   required from ‘bool boost::spirit::x3::parse(Iterator&, Iterator, const Parser&, Attribute&) [with Iterator = __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char> >; Parser = boost::spirit::x3::sequence<boost::spirit::x3::sequence<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> >, boost::spirit::x3::optional<boost::spirit::x3::sequence<boost::spirit::x3::list<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> >, boost::spirit::x3::optional<boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > > > >; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >]’
../src/rtsp-header-parse/rtsp-header-parse/test.cpp:72:38:   required from here
../ext/boost-spirit/include/boost/mpl/aux_/nested_type_wknd.hpp:26:31: error: no type named ‘type’ in ‘struct boost::mpl::not_<boost::spirit::x3::detail::parser_attr_is_substitute_for_container_value<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::fusion::iterator_range<boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 1>, boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 2> >, boost::spirit::x3::unused_type> >’
 template< typename T > struct nested_type_wknd
                               ^
In file included from ../ext/boost-spirit/include/boost/mpl/aux_/include_preprocessed.hpp:37:0,
                 from ../ext/boost-spirit/include/boost/mpl/or.hpp:43,
                 from ../ext/boost-spirit/include/boost/fusion/support/is_sequence.hpp:14,
                 from ../ext/boost-spirit/include/boost/fusion/container/deque/deque.hpp:27,
                 from ../ext/boost-spirit/include/boost/fusion/container/deque.hpp:13,
                 from ../ext/boost-spirit/include/boost/fusion/include/deque.hpp:11,
                 from ../ext/boost-spirit/include/boost/spirit/home/x3/support/traits/container_traits.hpp:15,
                 from ../ext/boost-spirit/include/boost/spirit/home/x3/auxiliary/any_parser.hpp:15,
                 from ../ext/boost-spirit/include/boost/spirit/home/x3/auxiliary.hpp:11,
                 from ../ext/boost-spirit/include/boost/spirit/home/x3.hpp:14,
                 from ../src/rtsp-header-parse/rtsp-header-parse/test.cpp:2:
../ext/boost-spirit/include/boost/mpl/aux_/preprocessed/gcc/or.hpp: In instantiation of ‘struct boost::mpl::aux::or_impl<false, boost::mpl::not_<boost::spirit::x3::detail::parser_attr_is_substitute_for_container_value<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::fusion::iterator_range<boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 1>, boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 2> >, boost::spirit::x3::unused_type> >, mpl_::bool_<false>, mpl_::bool_<false>, mpl_::bool_<false> >’:
../ext/boost-spirit/include/boost/mpl/aux_/preprocessed/gcc/or.hpp:48:8:   required from ‘struct boost::mpl::or_<boost::spirit::x3::detail::parser_accepts_container<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::fusion::iterator_range<boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 1>, boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 2> >, boost::spirit::x3::unused_type>, boost::mpl::not_<boost::spirit::x3::detail::parser_attr_is_substitute_for_container_value<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::fusion::iterator_range<boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 1>, boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 2> >, boost::spirit::x3::unused_type> >, mpl_::bool_<false>, mpl_::bool_<false>, mpl_::bool_<false> >’
../ext/boost-spirit/include/boost/spirit/home/x3/core/detail/parse_into_container.hpp:275:24:   required from ‘static bool boost::spirit::x3::detail::parse_into_container_impl<Parser, Context, RContext, typename boost::enable_if<boost::spirit::x3::traits::handles_container<Parser, Context> >::type>::call(const Parser&, Iterator&, const Iterator&, const Context&, RContext&, Attribute&) [with Iterator = __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char> >; Attribute = boost::fusion::iterator_range<boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 1>, boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 2> >; Parser = boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >; Context = boost::spirit::x3::unused_type; RContext = const boost::spirit::x3::unused_type]’
../ext/boost-spirit/include/boost/spirit/home/x3/core/detail/parse_into_container.hpp:287:74:   required from ‘bool boost::spirit::x3::detail::parse_into_container(const Parser&, Iterator&, const Iterator&, const Context&, RContext&, Attribute&) [with Parser = boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >; Iterator = __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char> >; Context = boost::spirit::x3::unused_type; RContext = const boost::spirit::x3::unused_type; Attribute = boost::fusion::iterator_range<boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 1>, boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 2> >]’
../ext/boost-spirit/include/boost/spirit/home/x3/operator/list.hpp:34:46:   required from ‘bool boost::spirit::x3::list<Left, Right>::parse(Iterator&, const Iterator&, const Context&, RContext&, Attribute&) const [with Iterator = __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char> >; Context = boost::spirit::x3::unused_type; RContext = const boost::spirit::x3::unused_type; Attribute = boost::fusion::iterator_range<boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 1>, boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 2> >; Left = boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >; Right = boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type>]’
../ext/boost-spirit/include/boost/spirit/home/x3/operator/detail/sequence.hpp:312:13:   required from ‘bool boost::spirit::x3::detail::parse_sequence(const Parser&, Iterator&, const Iterator&, const Context&, RContext&, Attribute&, boost::spirit::x3::traits::tuple_attribute) [with Parser = boost::spirit::x3::sequence<boost::spirit::x3::list<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> >, boost::spirit::x3::optional<boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >; Iterator = __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char> >; Context = boost::spirit::x3::unused_type; RContext = const boost::spirit::x3::unused_type; Attribute = boost::fusion::iterator_range<boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 1>, boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 2> >]’
../ext/boost-spirit/include/boost/spirit/home/x3/operator/sequence.hpp:44:42:   [ skipping 2 instantiation contexts, use -ftemplate-backtrace-limit=0 to disable ]
../ext/boost-spirit/include/boost/spirit/home/x3/core/proxy.hpp:42:73:   required from ‘bool boost::spirit::x3::proxy<Subject, Derived>::parse(Iterator&, const Iterator&, const Context&, RuleContext&, Attribute&) const [with Iterator = __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char> >; Context = boost::spirit::x3::unused_type; RuleContext = const boost::spirit::x3::unused_type; Attribute = boost::fusion::iterator_range<boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 1>, boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 2> >; Subject = boost::spirit::x3::sequence<boost::spirit::x3::list<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> >, boost::spirit::x3::optional<boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >; Derived = boost::spirit::x3::optional<boost::spirit::x3::sequence<boost::spirit::x3::list<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> >, boost::spirit::x3::optional<boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > > >]’
../ext/boost-spirit/include/boost/spirit/home/x3/operator/detail/sequence.hpp:312:13:   required from ‘bool boost::spirit::x3::detail::parse_sequence(const Parser&, Iterator&, const Iterator&, const Context&, RContext&, Attribute&, boost::spirit::x3::traits::tuple_attribute) [with Parser = boost::spirit::x3::sequence<boost::spirit::x3::sequence<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> >, boost::spirit::x3::optional<boost::spirit::x3::sequence<boost::spirit::x3::list<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> >, boost::spirit::x3::optional<boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > > > >; Iterator = __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char> >; Context = boost::spirit::x3::unused_type; RContext = const boost::spirit::x3::unused_type; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >]’
../ext/boost-spirit/include/boost/spirit/home/x3/operator/sequence.hpp:44:42:   required from ‘bool boost::spirit::x3::sequence<Left, Right>::parse(Iterator&, const Iterator&, const Context&, RContext&, Attribute&) const [with Iterator = __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char> >; Context = boost::spirit::x3::unused_type; RContext = const boost::spirit::x3::unused_type; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >; Left = boost::spirit::x3::sequence<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> >; Right = boost::spirit::x3::optional<boost::spirit::x3::sequence<boost::spirit::x3::list<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> >, boost::spirit::x3::optional<boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > > >]’
../ext/boost-spirit/include/boost/spirit/home/x3/core/parse.hpp:35:68:   required from ‘bool boost::spirit::x3::parse_main(Iterator&, Iterator, const Parser&, Attribute&) [with Iterator = __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char> >; Parser = boost::spirit::x3::sequence<boost::spirit::x3::sequence<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> >, boost::spirit::x3::optional<boost::spirit::x3::sequence<boost::spirit::x3::list<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> >, boost::spirit::x3::optional<boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > > > >; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >]’
../ext/boost-spirit/include/boost/spirit/home/x3/core/parse.hpp:47:26:   required from ‘bool boost::spirit::x3::parse(Iterator&, Iterator, const Parser&, Attribute&) [with Iterator = __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char> >; Parser = boost::spirit::x3::sequence<boost::spirit::x3::sequence<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> >, boost::spirit::x3::optional<boost::spirit::x3::sequence<boost::spirit::x3::list<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> >, boost::spirit::x3::optional<boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > > > >; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >]’
../src/rtsp-header-parse/rtsp-header-parse/test.cpp:72:38:   required from here
../ext/boost-spirit/include/boost/mpl/aux_/preprocessed/gcc/or.hpp:23:8: error: ‘value’ is not a member of ‘boost::mpl::aux::nested_type_wknd<boost::mpl::not_<boost::spirit::x3::detail::parser_attr_is_substitute_for_container_value<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::fusion::iterator_range<boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 1>, boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 2> >, boost::spirit::x3::unused_type> > >’
 struct or_impl< false,T1,T2,T3,T4 >
        ^
In file included from ../ext/boost-spirit/include/boost/spirit/home/x3/directive/expect.hpp:12:0,
                 from ../ext/boost-spirit/include/boost/spirit/home/x3/auxiliary/guard.hpp:11,
                 from ../ext/boost-spirit/include/boost/spirit/home/x3/auxiliary.hpp:13,
                 from ../ext/boost-spirit/include/boost/spirit/home/x3.hpp:14,
                 from ../src/rtsp-header-parse/rtsp-header-parse/test.cpp:2:
../ext/boost-spirit/include/boost/spirit/home/x3/core/detail/parse_into_container.hpp: In instantiation of ‘static bool boost::spirit::x3::detail::parse_into_container_impl<Parser, Context, RContext, typename boost::enable_if<boost::spirit::x3::traits::handles_container<Parser, Context> >::type>::call(const Parser&, Iterator&, const Iterator&, const Context&, RContext&, Attribute&) [with Iterator = __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char> >; Attribute = boost::fusion::iterator_range<boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 1>, boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 2> >; Parser = boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >; Context = boost::spirit::x3::unused_type; RContext = const boost::spirit::x3::unused_type]’:
../ext/boost-spirit/include/boost/spirit/home/x3/core/detail/parse_into_container.hpp:287:74:   required from ‘bool boost::spirit::x3::detail::parse_into_container(const Parser&, Iterator&, const Iterator&, const Context&, RContext&, Attribute&) [with Parser = boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >; Iterator = __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char> >; Context = boost::spirit::x3::unused_type; RContext = const boost::spirit::x3::unused_type; Attribute = boost::fusion::iterator_range<boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 1>, boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 2> >]’
../ext/boost-spirit/include/boost/spirit/home/x3/operator/list.hpp:34:46:   required from ‘bool boost::spirit::x3::list<Left, Right>::parse(Iterator&, const Iterator&, const Context&, RContext&, Attribute&) const [with Iterator = __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char> >; Context = boost::spirit::x3::unused_type; RContext = const boost::spirit::x3::unused_type; Attribute = boost::fusion::iterator_range<boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 1>, boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 2> >; Left = boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >; Right = boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type>]’
../ext/boost-spirit/include/boost/spirit/home/x3/operator/detail/sequence.hpp:312:13:   required from ‘bool boost::spirit::x3::detail::parse_sequence(const Parser&, Iterator&, const Iterator&, const Context&, RContext&, Attribute&, boost::spirit::x3::traits::tuple_attribute) [with Parser = boost::spirit::x3::sequence<boost::spirit::x3::list<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> >, boost::spirit::x3::optional<boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >; Iterator = __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char> >; Context = boost::spirit::x3::unused_type; RContext = const boost::spirit::x3::unused_type; Attribute = boost::fusion::iterator_range<boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 1>, boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 2> >]’
../ext/boost-spirit/include/boost/spirit/home/x3/operator/sequence.hpp:44:42:   required from ‘bool boost::spirit::x3::sequence<Left, Right>::parse(Iterator&, const Iterator&, const Context&, RContext&, Attribute&) const [with Iterator = __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char> >; Context = boost::spirit::x3::unused_type; RContext = const boost::spirit::x3::unused_type; Attribute = boost::fusion::iterator_range<boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 1>, boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 2> >; Left = boost::spirit::x3::list<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> >; Right = boost::spirit::x3::optional<boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> >]’
../ext/boost-spirit/include/boost/spirit/home/x3/core/proxy.hpp:31:13:   required from ‘bool boost::spirit::x3::proxy<Subject, Derived>::parse_subject(Iterator&, const Iterator&, const Context&, RuleContext&, Attribute&, Category) const [with Iterator = __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char> >; Context = boost::spirit::x3::unused_type; RuleContext = const boost::spirit::x3::unused_type; Attribute = boost::fusion::iterator_range<boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 1>, boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 2> >; Category = boost::spirit::x3::traits::tuple_attribute; Subject = boost::spirit::x3::sequence<boost::spirit::x3::list<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> >, boost::spirit::x3::optional<boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >; Derived = boost::spirit::x3::optional<boost::spirit::x3::sequence<boost::spirit::x3::list<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> >, boost::spirit::x3::optional<boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > > >]’
../ext/boost-spirit/include/boost/spirit/home/x3/core/proxy.hpp:42:73:   required from ‘bool boost::spirit::x3::proxy<Subject, Derived>::parse(Iterator&, const Iterator&, const Context&, RuleContext&, Attribute&) const [with Iterator = __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char> >; Context = boost::spirit::x3::unused_type; RuleContext = const boost::spirit::x3::unused_type; Attribute = boost::fusion::iterator_range<boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 1>, boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 2> >; Subject = boost::spirit::x3::sequence<boost::spirit::x3::list<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> >, boost::spirit::x3::optional<boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >; Derived = boost::spirit::x3::optional<boost::spirit::x3::sequence<boost::spirit::x3::list<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> >, boost::spirit::x3::optional<boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > > >]’
../ext/boost-spirit/include/boost/spirit/home/x3/operator/detail/sequence.hpp:312:13:   required from ‘bool boost::spirit::x3::detail::parse_sequence(const Parser&, Iterator&, const Iterator&, const Context&, RContext&, Attribute&, boost::spirit::x3::traits::tuple_attribute) [with Parser = boost::spirit::x3::sequence<boost::spirit::x3::sequence<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> >, boost::spirit::x3::optional<boost::spirit::x3::sequence<boost::spirit::x3::list<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> >, boost::spirit::x3::optional<boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > > > >; Iterator = __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char> >; Context = boost::spirit::x3::unused_type; RContext = const boost::spirit::x3::unused_type; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >]’
../ext/boost-spirit/include/boost/spirit/home/x3/operator/sequence.hpp:44:42:   required from ‘bool boost::spirit::x3::sequence<Left, Right>::parse(Iterator&, const Iterator&, const Context&, RContext&, Attribute&) const [with Iterator = __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char> >; Context = boost::spirit::x3::unused_type; RContext = const boost::spirit::x3::unused_type; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >; Left = boost::spirit::x3::sequence<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> >; Right = boost::spirit::x3::optional<boost::spirit::x3::sequence<boost::spirit::x3::list<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> >, boost::spirit::x3::optional<boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > > >]’
../ext/boost-spirit/include/boost/spirit/home/x3/core/parse.hpp:35:68:   required from ‘bool boost::spirit::x3::parse_main(Iterator&, Iterator, const Parser&, Attribute&) [with Iterator = __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char> >; Parser = boost::spirit::x3::sequence<boost::spirit::x3::sequence<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> >, boost::spirit::x3::optional<boost::spirit::x3::sequence<boost::spirit::x3::list<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> >, boost::spirit::x3::optional<boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > > > >; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >]’
../ext/boost-spirit/include/boost/spirit/home/x3/core/parse.hpp:47:26:   required from ‘bool boost::spirit::x3::parse(Iterator&, Iterator, const Parser&, Attribute&) [with Iterator = __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char> >; Parser = boost::spirit::x3::sequence<boost::spirit::x3::sequence<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> >, boost::spirit::x3::optional<boost::spirit::x3::sequence<boost::spirit::x3::list<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> >, boost::spirit::x3::optional<boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > > > >; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >]’
../src/rtsp-header-parse/rtsp-header-parse/test.cpp:72:38:   required from here
../ext/boost-spirit/include/boost/spirit/home/x3/core/detail/parse_into_container.hpp:275:24: error: no matching function for call to ‘boost::spirit::x3::detail::parse_into_container_impl<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::spirit::x3::unused_type, const boost::spirit::x3::unused_type, void>::call(const boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >&, __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char> >&, const __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char> >&, const boost::spirit::x3::unused_type&, const boost::spirit::x3::unused_type&, boost::fusion::iterator_range<boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 1>, boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 2> >&, pass_attibute_as_is)’
             return call(parser, first, last, context, rcontext, attr,
                        ^
../ext/boost-spirit/include/boost/spirit/home/x3/core/detail/parse_into_container.hpp:239:21: note: candidate: template<class Iterator, class Attribute> static bool boost::spirit::x3::detail::parse_into_container_impl<Parser, Context, RContext, typename boost::enable_if<boost::spirit::x3::traits::handles_container<Parser, Context> >::type>::call(const Parser&, Iterator&, const Iterator&, const Context&, RContext&, Attribute&, mpl_::false_) [with Iterator = Iterator; Attribute = Attribute; Parser = boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >; Context = boost::spirit::x3::unused_type; RContext = const boost::spirit::x3::unused_type]
         static bool call(
                     ^
../ext/boost-spirit/include/boost/spirit/home/x3/core/detail/parse_into_container.hpp:239:21: note:   template argument deduction/substitution failed:
../ext/boost-spirit/include/boost/spirit/home/x3/core/detail/parse_into_container.hpp:275:24: note:   cannot convert ‘pass_attibute_as_is()’ (type ‘pass_attibute_as_is {aka boost::mpl::or_<boost::spirit::x3::detail::parser_accepts_container<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::fusion::iterator_range<boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 1>, boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 2> >, boost::spirit::x3::unused_type>, boost::mpl::not_<boost::spirit::x3::detail::parser_attr_is_substitute_for_container_value<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::fusion::iterator_range<boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 1>, boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 2> >, boost::spirit::x3::unused_type> >, mpl_::bool_<false>, mpl_::bool_<false>, mpl_::bool_<false> >}’) to type ‘mpl_::false_ {aka mpl_::bool_<false>}’
             return call(parser, first, last, context, rcontext, attr,
                        ^
../ext/boost-spirit/include/boost/spirit/home/x3/core/detail/parse_into_container.hpp:249:21: note: candidate: template<class Iterator, class Attribute> static bool boost::spirit::x3::detail::parse_into_container_impl<Parser, Context, RContext, typename boost::enable_if<boost::spirit::x3::traits::handles_container<Parser, Context> >::type>::call(const Parser&, Iterator&, const Iterator&, const Context&, RContext&, Attribute&, mpl_::true_) [with Iterator = Iterator; Attribute = Attribute; Parser = boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >; Context = boost::spirit::x3::unused_type; RContext = const boost::spirit::x3::unused_type]
         static bool call(
                     ^
../ext/boost-spirit/include/boost/spirit/home/x3/core/detail/parse_into_container.hpp:249:21: note:   template argument deduction/substitution failed:
../ext/boost-spirit/include/boost/spirit/home/x3/core/detail/parse_into_container.hpp:275:24: note:   cannot convert ‘pass_attibute_as_is()’ (type ‘pass_attibute_as_is {aka boost::mpl::or_<boost::spirit::x3::detail::parser_accepts_container<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::fusion::iterator_range<boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 1>, boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 2> >, boost::spirit::x3::unused_type>, boost::mpl::not_<boost::spirit::x3::detail::parser_attr_is_substitute_for_container_value<boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >, boost::fusion::iterator_range<boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 1>, boost::fusion::std_tuple_iterator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, 2> >, boost::spirit::x3::unused_type> >, mpl_::bool_<false>, mpl_::bool_<false>, mpl_::bool_<false> >}’) to type ‘mpl_::true_ {aka mpl_::bool_<true>}’
             return call(parser, first, last, context, rcontext, attr,
                        ^
../ext/boost-spirit/include/boost/spirit/home/x3/core/detail/parse_into_container.hpp:258:21: note: candidate: template<class Iterator, class Attribute> static bool boost::spirit::x3::detail::parse_into_container_impl<Parser, Context, RContext, typename boost::enable_if<boost::spirit::x3::traits::handles_container<Parser, Context> >::type>::call(const Parser&, Iterator&, const Iterator&, const Context&, RContext&, Attribute&) [with Iterator = Iterator; Attribute = Attribute; Parser = boost::spirit::x3::plus<boost::spirit::x3::difference<boost::spirit::x3::char_class<boost::spirit::char_encoding::standard, boost::spirit::x3::alpha_tag>, boost::spirit::x3::literal_char<boost::spirit::char_encoding::standard, boost::spirit::x3::unused_type> > >; Context = boost::spirit::x3::unused_type; RContext = const boost::spirit::x3::unused_type]
         static bool call(Parser const& parser
                     ^
../ext/boost-spirit/include/boost/spirit/home/x3/core/detail/parse_into_container.hpp:258:21: note:   template argument deduction/substitution failed:
../ext/boost-spirit/include/boost/spirit/home/x3/core/detail/parse_into_container.hpp:275:24: note:   candidate expects 6 arguments, 7 provided
             return call(parser, first, last, context, rcontext, attr,
                        ^
ninja: build stopped: subcommand failed.

I'm curious as to why the combination of the % operator with the inclusion of optional with an internal sequenced section causes a compilation to fail. ie: why does -(word % ',')work without issue, but -((word % ',') >> lit('/')) fail to parse into a subexpression?

I've also tried to parse into a boost::mpl::vector<std::string, std::vector<std::string>> and get the same errors.

Extend README with info of Spirit libraries

The Boost documentation for spirit (e.g. in Boost v1.66) gives the version as 2.5.x ; yet the master branch has a lot of files with x3 in their names. On the other hand, there are branches whose names begin with x3, suggesting it might not "really" be part of the main or development branch. If that's not all, there isn't a clear indication on other sites where one is supposed to find the X3 code.

I believe README.md should clarify this point.

X3: MSVC unordered containers `is_reservable<T>::value == false`

Until we have a good integration for boostorg/spirit in appveyor - this is what we get for now (via private appveyor account):

compile-c-c++ bin.v2\libs\spirit\test\x3\x3_container_support-p3.test\msvc-14.1\release\address-model-64\threadapi-win32\threading-multi\container_support.obj
container_support.cpp
libs\spirit\test\x3\container_support.cpp(181): error C2338: is_reservable problem
libs\spirit\test\x3\container_support.cpp(183): error C2338: is_reservable problem
libs\spirit\test\x3\container_support.cpp(185): error C2338: is_reservable problem
libs\spirit\test\x3\container_support.cpp(187): error C2338: is_reservable problem

https://ci.appveyor.com/project/octopus-prime/spirit

Cannot combine toolsets "gcc" and "gcc-7" in the same build with Boost.Spirit

I added a top level Jamfile which builds example/ then test/. Building example/ is a good idea to make sure examples don't rot. I wasn't able to build with a fairly standard command:

The command:

/boost/libs/spirit$ ../../b2 . toolset=gcc,gcc-7,clang cxxstd=03       variant=release,debug -j3

The result:

error: Name clash for '<pexample/qi/compiler_tutorial/bin/release>calc1'
error: 
error: Tried to build the target twice, with property sets having 
error: these incompatible properties:
error: 
error:     -  <toolset-gcc:version>4.8
error:     -  <toolset-gcc:version>7
error: 
error: Please make sure to have consistent requirements for these 
error: properties everywhere in your project, especially for install
error: targets.

I've used this successfully in Boost.Format and Boost.Uuid to build in Travis CI with gcc-4.8 and gcc-7.x in the same build job. Not working for this project.

https://travis-ci.org/jeking3/spirit/jobs/293831167

Add at least an empty CMakeLists.txt

Hello,

I am trying to integrate Boost/Spirit (minimum) into a CMake based project via ExternalProject_Add, and I am receiving the following error:

Severity	Code	Description	Project	File	Line	Suppression State
Error		The source directory "path/to/repos/boost/spirit" does not appear to contain CMakeLists.txt.	download_boost_spirit	path\to\build\CUSTOMBUILD	1

Not sure if/where Boost (or Spirit) stand WRT CMake, but would you at least add an empty CMakeLists.txt file? Probably could be a no-op, or at minimum report Spirit as header only and nominal getting started instructions.

This is from CMake for Windows, building via Microsoft Visual Studio 2015.

Thanks!

`make_primitive` and its `result_type`

Breezing through spirits internals I found a suspicious thing

spirit/include/boost/spirit/home/qi/meta_compiler.hpp

Lines 31 to 47 in 9a8cded

 template <typename T, typename Modifiers, typename Enable = void> 

 struct make_primitive // by default, return it as-is 

 { 

 typedef T result_type; 

 template <typename T_> 

 T_& operator()(T_& val, unused_type) const 

 { 

 return val; 

 } 

 template <typename T_> 

 T_ const& operator()(T_ const& val, unused_type) const 

 { 

 return val; 

 } 

 };

It looks to me that the result_type here is wrong, so the behavior on compilators w/ and w/o decltype support should be different. All of qi, karma and lex have this code.

P.S: At fixing spirits examples I have recently figured out a lot of wrong usages of result_of protocol so I would not be surprised that this is a hidden error too.

`qi_repo_keywords` test fails due to msvc-14.1 codegen bug

qi_repo_keywords test fails because of codegen bug introduced in the latest Visual Studio versions. I did find the exact version where it started to fail, but it looks like the last good version should be 15.8.2.

The issue was reported to Microsoft. ^[link]

b2 output

testing.capture-output bin.v2\libs\spirit\repository\test\qi_repo_keywords.test\msvc-14.1\release\address-model-64\threading-multi\qi_repo_keywords.run
====== BEGIN OUTPUT ======
libs\spirit\repository\test\qi\keywords.cpp(86): test 'test("a=a c=1", kwd("a")[ '=' > char_] / kwd("b")[ '=' > char_] / kwd("c")['=' > int_], space)' failed in function 'int __cdecl main(void)'
libs\spirit\repository\test\qi\keywords.cpp(91): test 'test("a=a b=b c=1", kwd("a",1)[ '=' > char_] / kwd("b")[ '=' > char_] / kwd("c")['=' > int_], space)' failed in function 'int __cdecl main(void)'
libs\spirit\repository\test\qi\keywords.cpp(92): test 'test("a=a b=c b=e c=1", kwd("a",1)[ '=' > char_] / kwd("b",2)[ '=' > char_] / kwd("c")['=' > int_], space)' failed in function 'int __cdecl main(void)'
libs\spirit\repository\test\qi\keywords.cpp(96): test 'test("a=f b=c b=e c=1", kwd("a",1,2)[ '=' > char_] / kwd("b",0,2)[ '=' > char_] / kwd("c",1,2)['=' > int_], space)' failed in function 'int __cdecl main(void)'
libs\spirit\repository\test\qi\keywords.cpp(98): test 'test("a=g a=f b=c b=e c=1", kwd("a",1,2)[ '=' > char_] / kwd("b",0,2)[ '=' > char_] / kwd("c",1,2)['=' > int_], space)' failed in function 'int __cdecl main(void)'
libs\spirit\repository\test\qi\keywords.cpp(102): test 'test("a=f b=c b=e c=1", kwd("a",1,inf)[ '=' > char_] / kwd("b",0,inf)[ '=' > char_] / kwd("c",1,inf)['=' > int_], space )' failed in function 'int __cdecl main(void)'
libs\spirit\repository\test\qi\keywords.cpp(104): test 'test("a=f a=f a=g b=c b=e c=1 a=e", kwd("a",1,inf)[ '=' > char_] / kwd("b",0,inf)[ '=' > char_] / kwd("c",1,inf)['=' > int_], space )' failed in function 'int __cdecl main(void)'
libs\spirit\repository\test\qi\keywords.cpp(134): test 'test("B=a c=1 a=E", no_case[kwd("a")[ "=E" ] / kwd("b")[ '=' > char_] / kwd("c")['=' > int_]], space)' failed in function 'int __cdecl main(void)'
libs\spirit\repository\test\qi\keywords.cpp(135): test 'test("B=a c=1 a=e", no_case[kwd("a")[ "=E" ] / kwd("b")[ '=' > char_] / kwd("c")['=' > int_]], space)' failed in function 'int __cdecl main(void)'
libs\spirit\repository\test\qi\keywords.cpp(137): test 'test("b=a c=1 A=E", no_case[kwd("a")[ '=' > char_]] / kwd("b")[ '=' > char_] / kwd("c")['=' > int_], space)' failed in function 'int __cdecl main(void)'
libs\spirit\repository\test\qi\keywords.cpp(139): test 'test("A=a c=1 a=E", ikwd("a")[ '=' > char_] / kwd("b")[ '=' > char_] / kwd("c")['=' > int_], space)' failed in function 'int __cdecl main(void)'
 
EXIT STATUS: 3 
====== END OUTPUT ======
    
    set status=0
    if %status% NEQ 0 (
        echo Skipping test execution due to testing.execute=off
        exit 0
    )
     "bin.v2\libs\spirit\repository\test\qi_repo_keywords.test\msvc-14.1\release\address-model-64\threading-multi\qi_repo_keywords.exe"   > "bin.v2\libs\spirit\repository\test\qi_repo_keywords.test\msvc-14.1\release\address-model-64\threading-multi\qi_repo_keywords.output" 2>&1 
    set status=%ERRORLEVEL%
    echo. >> "bin.v2\libs\spirit\repository\test\qi_repo_keywords.test\msvc-14.1\release\address-model-64\threading-multi\qi_repo_keywords.output"
    echo EXIT STATUS: %status% >> "bin.v2\libs\spirit\repository\test\qi_repo_keywords.test\msvc-14.1\release\address-model-64\threading-multi\qi_repo_keywords.output"
    if %status% EQU 0 (
        copy "bin.v2\libs\spirit\repository\test\qi_repo_keywords.test\msvc-14.1\release\address-model-64\threading-multi\qi_repo_keywords.output" "bin.v2\libs\spirit\repository\test\qi_repo_keywords.test\msvc-14.1\release\address-model-64\threading-multi\qi_repo_keywords.run"
    )
    set verbose=0
    if %status% NEQ 0 (
        set verbose=1
    )
    if %verbose% EQU 1 (
        echo ====== BEGIN OUTPUT ======
        type "bin.v2\libs\spirit\repository\test\qi_repo_keywords.test\msvc-14.1\release\address-model-64\threading-multi\qi_repo_keywords.output"
        echo ====== END OUTPUT ======
    )
    exit %status%
...failed testing.capture-output bin.v2\libs\spirit\repository\test\qi_repo_keywords.test\msvc-14.1\release\address-model-64\threading-multi\qi_repo_keywords.run...

Debug

I have succeeded to identify a place where the problem happens, if you mark boost::spirit::qi::sequence_base::parse_impl as noinline and place the breakpoint on first = iter; line, you will see this:

+	first	0x000000013f9e13c5 "=1"	const char * &
+	iter	0x000000013f9e13c7 ""	const char *

and after stepping over the line:

+	first	0x000000013f9e13c6 "1"	const char * &
+	iter	0x000000013f9e13c7 ""	const char *

Of course it is wrong. first cannot differ from iter after first = iter assignment.

At disassembly it looks like the optimizer throws away one of two iterator increments.

Solutions

The only found workarounds are:

Remove inline keyword from spirit::any_if function.
Move first = iter into the dedicated noinline function.
Copy the iterator before assignment first = make_copy(iter)
with a helper noinline function.

I do not see any of them as acceptable.

Qi: Ambiguity in transform_attribute trait at dealing with Fusion ADT

#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/support_adapt_adt_attributes.hpp>

struct Vec2i
{
    int x;
    int y;
};

BOOST_FUSION_ADAPT_ADT(
    Vec2i,
    (int, int, obj.x, obj.x = val)
    (int, int, obj.y, obj.y = val)
)

int main()
{
    namespace qi = boost::spirit::qi;

    qi::rule<char const*, Vec2i()> v1 = qi::uint_ >> ',' >> qi::uint_; // OK

    qi::rule<char const*, int()> coord = qi::uint_;
    qi::rule<char const*, Vec2i()> v2 = coord >> ',' >> coord; // Fails to compile
}

boost\spirit\home\qi\detail\attributes.hpp(154): error C2752: 'boost::spirit::traits::transform_attribute<Exposed,Transformed,boost::spirit::qi::domain,void>': more than one partial specialization matches the template argument list
        with
        [
            Exposed=boost::fusion::extension::adt_attribute_proxy<Vec2i,0,false>,
            Transformed=int
        ]
boost\spirit\home\qi\detail\attributes.hpp(154): note: could be 'boost::spirit::traits::transform_attribute<Exposed,Transformed,boost::spirit::qi::domain,void>'
boost\spirit\home\qi\detail\attributes.hpp(154): note: or       'boost::spirit::traits::transform_attribute<boost::fusion::extension::adt_attribute_proxy<T,N,false>,Attribute,Domain,disable_if<boost::is_reference<fusion::extension::adt_attribute_proxy<T,N,false>::type>,void>::type>'

Qi: Attributeless parsers within container handling parsers

Update: https://svn.boost.org/trac10/ticket/6444 looks like the same problem.

X3 appends a default constructed value to containers if underlying parser of container handling parser (such as kleene, plus or list) does not generate anything.

#include <boost/spirit/home/x3.hpp>
#include <boost/spirit/home/qi.hpp>
#include <vector>
#include <iostream>

template <typename F>
void test(F f)
{
    std::vector<int> v;
    char s[] = "1\n2\n3\n---\n5\n---\n---\n7\n---";
    f(std::begin(s), std::end(s), v);
    for (auto x : v) std::cout << x << '\n';
}

int main()
{
    namespace qi = boost::spirit::qi;
    namespace x3 = boost::spirit::x3;
    std::cout << "qi:\n"; test([](auto f, auto l, auto& v){ qi::parse(f, l, (qi::int_ | "---") % qi::eol, v); });
    std::cout << "x3:\n"; test([](auto f, auto l, auto& v){ x3::parse(f, l, (x3::int_ | "---") % x3::eol, v); });
}

Output:

warning: 'BOOST_ENDIAN_DEFAULT_CONSTRUCT' macro redefined

When I include both boost/spirit/include/qi.hpp and boost/endian/buffers.hpp, I got warning: 'BOOST_ENDIAN_DEFAULT_CONSTRUCT' macro redefined.

#include <boost/spirit/include/qi.hpp>
#include <boost/endian/buffers.hpp>

int main() {
}

https://wandbox.org/permlink/lwc8uW2Giwr3CWO7

It seems that the macro should be defined appropriate point, but I'm not sure where is it.

I found the issue Boost 1.66.0 (current release).

travis and appveyor integration

We should integrate travis and appveyor for building and running our tests.
In README.md should be a table with build results.

travis

Add this repository in travis.
We need a .travis.yml to configure the build.

appveyor

(don't know)

to_utf8 truncates characters instead of performing the conversion

spirit/include/boost/spirit/home/support/utf8.hpp

Line 66 in 925f40a

*utf8_iter++ = (UChar)ch;

Is it permissible - convert wchar_t to char (in the case of type of the input parameter is std::wstring)?

Is `phoenix::val(spirit::ascii::string("Hello"))` a valid `qi` expression?

This example

spirit/example/qi/reference.cpp

Line 773 in 1e31221

test_parser("Hello", val(string("Hello")));

of lazy documentation does not compile. It fails on assert BOOST_SPIRIT_ASSERT_MATCH(qi::domain, Expr); what is perfectly logical, because phoenix::val is not a qi expression.

I suppose it is an error in documentation, should not it be string("Hello")?

Include guard names collision

I'm getting this error when trying to use karma in boost 1.65.1:
'signbit': is not a member of 'boost::spirit::detail'

It seems that SPIRIT_SIGN_MAR_11_2009_0734PM is already defined in:
boost\spirit\home\x3\support\numeric_utils\sign.hpp
which triggers the include guard of:
boost\spirit\home\support\detail\sign.hpp

I can work around it by using this code:

namespace boost {
	namespace spirit {
		namespace detail {
			using boost::spirit::x3::signbit;
		}
	}
}

Error compiling samples

First is simple error:
in compiler.hpp and others hpp I must change:
error_handler = function(error_handler_)(
"Error! ", 2, phx::cref(error_handler.iters)[1]);
to
error_handler = function(error_handler)(
(char *const)("Error! "), 2, phx::cref(error_handler.iters)[_1]);
because is
/usr/include/boost/phoenix/function/detail/cpp03/preprocessed/function_operator_10.hpp
operator()(A0 const& a0 , A1 const& a1 , A2 const& a2) const
{
return detail::expression::function_eval<F, A0 , A1 , A2>::make(f, a0 , a1 , a2);
}

Second error is worse:
LLVM package changed and very interesting sample project conjure3 not compiling:
can found
#include <llvm/ExecutionEngine/ExecutionEngine.h>
but can't
#include <llvm/ExecutionEngine/JIT.h>

X3 Documentation render problems

It looks like QuickBook treats commented out links in some special way?

Compound Parser Attribute Types X3 Qi

bug in line_pos_iterator

Running this code

#include <boost/spirit/home/x3.hpp>
#include <boost/spirit/include/support_line_pos_iterator.hpp>
#include <string>
#include <iostream>
#include <iomanip>

namespace x3 = boost::spirit::x3;

int main() {
    using iterator_t = boost::spirit::line_pos_iterator<std::string::const_iterator>;

    std::string const input{"foo\nfoo\ngit"};
    iterator_t const begin{input.begin()};
    iterator_t const end{input.end()};

    try {
        x3::phrase_parse(begin, end, x3::lit("foo") > x3::lit("bar") > x3::lit("git"), x3::space);
    }
    catch (x3::expectation_failure<iterator_t> const& exception) {
        boost::iterator_range<iterator_t> const range = get_current_line(begin, exception.where(), end);
        std::string const current(range.begin(), range.end());
        std::cout << "line: " << get_line(exception.where()) << std::endl;
        std::cout << "column: " << get_column(begin, exception.where()) << std::endl;
        std::cout << "given: " << std::quoted(current) << std::endl;
        std::cout << "wanted: " << exception.which() << std::endl;
    }
    return 0;
}

gives this output:

line: 2
column: 2
given: "
foo"
wanted: "bar"

This is a bug, because the expected output is:

line: 2
column: 1
given: "foo"
wanted: "bar"

parse_nan() dereferences out of range iterator

In parse_nan(), after detecting the string "nan", while looking for parens, there is no check to make sure we didn't already reach the end of the range before dereferencing the iterator.

spirit/include/boost/spirit/home/x3/numeric/real_policies.hpp

Lines 112 to 116 in 54d5ea1

 // nan[(...)] ? 

 if (detail::string_parse("nan", "NAN", first, last, unused)) 

 { 

 if (*first == '(') 

 {

I believe the second if (line 115) should look like:

if (first != last && *first == '(')

This causes asserts to trigger with debug iterators in MSVC when using std::string or std::string_view. Here's an example with a custom iterator that throws when dereferencing the end.

http://coliru.stacked-crooked.com/a/4301f38c79b25ed6

"Phoenix" links are broken in documentation

Starting here
http://www.boost.org/doc/libs/1_65_1/libs/spirit/doc/html/spirit/qi/reference/auxiliary/lazy.html
and clicking the Phoenix link you end up with 404.

The Phoenix link is
http://www.boost.org/doc/libs/1_65_1/libs/spirit/phoenix/doc/html/index.html
but should be
http://www.boost.org/doc/libs/1_65_1/libs/phoenix/doc/html/index.html

X3: MPL usage

Currently X3 uses MPL which is still not updated for C++11. It is slow, even including it adds a big time overhead (see benchmarks on hana docs), but actually it is used intensively only in a few places.
What if we rewrite them without MPL?

Example:

spirit/include/boost/spirit/home/x3/operator/detail/sequence.hpp

Lines 237 to 294 in 49587ff

 template <typename L, typename R, typename C> 

 struct get_sequence_types 

 { 

 typedef 

 mpl::vector< 

 typename traits::attribute_of<L, C>::type 

 , typename traits::attribute_of<R, C>::type 

 > 

 type; 

 }; 

 template <typename LL, typename LR, typename R, typename C> 

 struct get_sequence_types<sequence<LL, LR>, R, C> 

 : mpl::push_back< typename get_sequence_types<LL, LR, C>::type 

 , typename traits::attribute_of<R, C>::type> {}; 

 template <typename L, typename RL, typename RR, typename C> 

 struct get_sequence_types<L, sequence<RL, RR>, C> 

 : mpl::push_front< typename get_sequence_types<RL, RR, C>::type 

 , typename traits::attribute_of<L, C>::type> {}; 

 template <typename LL, typename LR, typename RL, typename RR, typename C> 

 struct get_sequence_types<sequence<LL, LR>, sequence<RL, RR>, C> 

 { 

 typedef typename get_sequence_types<LL, LR, C>::type left; 

 typedef typename get_sequence_types<RL, RR, C>::type right; 

 typedef typename 

 mpl::insert_range<left, typename mpl::end<left>::type, right>::type 

 type; 

 }; 

 template <typename L, typename R, typename C> 

 struct attribute_of_sequence 

 { 

 // Get all sequence attribute types 

 typedef typename get_sequence_types<L, R, C>::type all_types; 

 // Filter all unused_types 

 typedef typename 

 mpl::copy_if< 

 all_types 

 , mpl::not_<is_same<mpl::_1, unused_type>> 

 , mpl::back_inserter<mpl::vector<>> 

 >::type 

 filtered_types; 

 // Build a fusion::deque if filtered_types is not empty, 

 // else just return unused_type 

 typedef typename 

 mpl::eval_if< 

 mpl::empty<filtered_types> 

 , mpl::identity<unused_type> 

 , mpl::if_<mpl::equal_to<mpl::size<filtered_types>, mpl::int_<1> >, 

 typename mpl::front<filtered_types>::type 

 , typename fusion::result_of::as_deque<filtered_types>::type > 

 >::type 

 type; 

 };

This could be easily done without any meta-library (and twice shorter):

// a helper class, may be reused in multiple places
template <typename... T>
struct type_pack
{
    template <typename... U>
    using prepend = type_pack<U..., T...>;
};

template <typename T, typename Attribute>
struct attribute_prepender { using type = typename T::template prepend<Attribute>; };
// filter unused attribute
template <typename T>
struct attribute_prepender<T, unused_type> { using type = T; };

template <typename T, typename P, typename C>
using prepend_parser_attribute = typename attribute_prepender<T, traits::attribute_of_t<P, C>>::type;

template <typename C, typename L, typename... T>
struct get_sequence_types;
// place underlying parsers of sequence_parser to the queue
template <typename C, typename T, typename L, typename R, typename... U>
struct get_sequence_types<C, T, sequence_parser<L, R>, U...> : get_sequence_types<C, T, R, L, U...> {};
// prepend an attribute of parser to type pack
template <typename C, typename T, typename H, typename... U>
struct get_sequence_types<C, T, H, U...> : get_sequence_types<C, prepend_parser_attribute<T, H, C>, U...> {};
// we are done, wrap into fusion::deque
template <typename C, typename... T>
struct get_sequence_types<C, type_pack<T...>> { using type = fusion::deque<T...>; };
// do not wrap if only a single attribute
template <typename C, typename T>
struct get_sequence_types<C, type_pack<T>> { using type = T; };
// return unused_type if no attributes in the pack
template <typename C>
struct get_sequence_types<C, type_pack<>> { using type = unused_type; };

template <typename L, typename R, typename C>
struct attribute_of_sequence : get_sequence_types<C, type_pack<>, R, L> {};

http://coliru.stacked-crooked.com/a/404f73f1f2340091

Proof of concept code

#include <type_traits>
#include <tuple>
#include <typeindex>
#include <iostream>
#include <boost/core/demangle.hpp>

template <typename... T>
struct type_pack
{
    template <typename... U>
    using prepend = type_pack<U..., T...>;
};

struct unused_type {};

struct context {};

template <typename Derived>
struct parser {};


template <typename T>
struct attr_parser : parser<attr_parser<T>>
{
    using attribute_type = T;
};

namespace traits {
    template <typename R, typename C>
    struct attribute_of { using type = typename R::attribute_type;  };
    
    template <typename R, typename C>
    using attribute_of_t = typename R::attribute_type;
}

template <typename L, typename R>
struct sequence_parser : parser<sequence_parser<L, R>> {};


template <typename T, typename Attribute>
struct attribute_prepender { using type = typename T::template prepend<Attribute>; };
// filter unused attribute
template <typename T>
struct attribute_prepender<T, unused_type> { using type = T; };

template <typename T, typename P, typename C>
using prepend_parser_attribute = typename attribute_prepender<T, traits::attribute_of_t<P, C>>::type;

template <typename C, typename L, typename... T>
struct get_sequence_types;
// place underlying parsers of sequence_parser to the queue
template <typename C, typename T, typename L, typename R, typename... U>
struct get_sequence_types<C, T, sequence_parser<L, R>, U...> : get_sequence_types<C, T, R, L, U...> {};
// prepend an attribute of parser to type pack
template <typename C, typename T, typename H, typename... U>
struct get_sequence_types<C, T, H, U...> : get_sequence_types<C, prepend_parser_attribute<T, H, C>, U...> {};
// we are done, wrap into fusion::deque
template <typename C, typename... T>
struct get_sequence_types<C, type_pack<T...>> { using type = std::tuple<T...>; };
// do not wrap if only a single attribute
template <typename C, typename T>
struct get_sequence_types<C, type_pack<T>> { using type = T; };
// return unused_type if no attributes in the pack
template <typename C>
struct get_sequence_types<C, type_pack<>> { using type = unused_type; };

template <typename L, typename R, typename C>
struct attribute_of_sequence : get_sequence_types<C, type_pack<>, R, L> {};

int main()
{
    using seq_left =
        sequence_parser<
            sequence_parser<attr_parser<bool>, attr_parser<unused_type>>
          , attr_parser<int>
        >;
    using seq_right =
        sequence_parser<
            attr_parser<unused_type>
          , sequence_parser<attr_parser<long>, attr_parser<long long>>
        >;
    
    using attr_tup = typename attribute_of_sequence<seq_left, seq_right, context>::type;
    static_assert(std::is_same<attr_tup, std::tuple<bool, int, long, long long>>::value, ":(");
    std::cout << "attr_tup: " << boost::core::demangle(typeid(attr_tup).name()) << std::endl;

    using attr_plain = typename attribute_of_sequence<attr_parser<unused_type>, attr_parser<int>, context>::type;
    static_assert(std::is_same<attr_plain, int>::value, ":(");
    std::cout << "attr_plain: " << boost::core::demangle(typeid(attr_plain).name()) << std::endl;

    using attr_unused = typename attribute_of_sequence<attr_parser<unused_type>, attr_parser<unused_type>, context>::type;
    static_assert(std::is_same<attr_unused, unused_type>::value, ":(");
    std::cout << "attr_unused: " << boost::core::demangle(typeid(attr_unused).name()) << std::endl;

    return 0;
}

Checked on GCC 4.7.3, Clang 3.2, MSVC 14.0

X3: Sequence operator doesn't collapse when attribute is a single element tuple

Hello, I'm trying to make a rule, that parses integers separated by a slash, and the last one is separated by an asterisk:

#include <boost/spirit/home/x3.hpp>
#include <boost/fusion/adapted/struct/adapt_struct.hpp>
namespace x3 = boost::spirit::x3;

struct ints_ {
    std::vector<int> m_vector;
};
BOOST_FUSION_ADAPT_STRUCT(ints_, m_vector)

struct ints_class;
x3::rule<ints_class, ints_> const ints = "ints";
auto const ints_def = x3::int_ % '/' >> '*' >> x3::int_;
BOOST_SPIRIT_DEFINE(ints)

int main(int argc, char* argv[])
{
    ints_ foo;
    std::string to_parse = "3432/432/4*4343";
    auto to_parse_iter = to_parse.begin();
    x3::parse(to_parse_iter, to_parse.end(), ints, foo);
}

Unfortunately, the code doesn't compile with this error:

/usr/include/boost/spirit/home/x3/operator/detail/sequence.hpp:150:25: error: static assertion failed: Size of the passed attribute is less than expected.
             actual_size >= expected_size

According to the Compound Attribute Rules section in the documentation, the attribute of the ints rule should be vector<int>:

a: A, b: B --> (a % b): vector<A>
a: vector<A>, b: A --> (a >> b): vector<A>

If I add another int field to the struct, it successfully compiles, but I would like to have all the integers in the same vector. Is there a solution to this? Am I not doing something right?

X3 doesn't compile on g++ 4.8 cxxstd=11

https://travis-ci.org/boostorg/boost/jobs/308195225

./boost/spirit/home/x3/support/context.hpp:28:18: error: expected primary-expression before ‘auto’
         decltype(auto) get(ID_ id) const
                  ^

These tests should probably be guarded by requires.

Also,

In file included from libs/spirit/test/x3/x3_variant.cpp:9:
./boost/spirit/home/x3/support/ast/variant.hpp:134:50: error: no template named 'remove_reference_t' in namespace 'std'; did you mean simply 'remove_reference_t'?
                                                ,std::remove_reference_t<T>

Looks like X3 wants C++14.

x3 floating point support in binary endianness parsers

In Qi there was support for

bin_float
big_bin_float
little_bin_float
bin_double
big_bin_double
little_bin_double

In X3 is not because of

    // Use a pseudo configuration macro to make clear that endian libray support
    // for floating point types is required. Must be removed as soon as the endian library
    // properly supports floating point types.

But waiting for the missing endian libray support is futile, because of

Why is there no floating point support?

    An attempt was made to support four-byte floats and eight-byte doubles, limited to IEEE 754 (also know as ISO/IEC/IEEE 60559) floating point and further limited to systems where floating point endianness does not differ from integer endianness.

    Even with those limitations, support for floating point types was not reliable and was removed. For example, simply reversing the endianness of a floating point number can result in a signaling-NAN. For all practical purposes, binary serialization and endianness for integers are one and the same problem. That is not true for floating point numbers, so binary serialization interfaces and formats for floating point does not fit well in an endian-based library.

So, if we want x3 floating point support in binary endianness parsers, we have to do it ourself - like in Qi.

Recommend Projects

React

A declarative, efficient, and flexible JavaScript library for building user interfaces.
Vue.js

🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.
Typescript

TypeScript is a superset of JavaScript that compiles to clean JavaScript output.
TensorFlow

An Open Source Machine Learning Framework for Everyone
Django

The Web framework for perfectionists with deadlines.
Laravel

A PHP framework for web artisans
D3

Bring data to life with SVG, Canvas and HTML. 📊📈🎉

Recommend Topics

javascript

JavaScript (JS) is a lightweight interpreted programming language with first-class functions.
web

Some thing interesting about web. New door for the world.
server

A server is a program made to process requests and deliver data to clients.
Machine learning

Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.
Visualization

Some thing interesting about visualization, use data art
Game

Some thing interesting about game, make everyone happy.

Recommend Org

Facebook

We are working to build community through open source technology. NB: members must have two-factor auth.
Microsoft

Open source projects and samples from Microsoft.
Google

Google ❤️ Open Source for everyone.
Alibaba

Alibaba Open Source for everyone
D3

Data-Driven Documents codes.
Tencent

China tencent open source team.

	else if (traits::is_equal_to_one(acc_n))
	{
	// There is a chance of having to parse one of the 1.0#...
	// styles some implementations use for representing NaN or Inf.

	// Check whether the number to parse is a NaN or Inf
	if (p.parse_nan(first, last, n) \|\|
	p.parse_inf(first, last, n))
	{
	// If we got a negative sign, negate the number
	traits::assign_to(traits::negate(neg, n), attr);
	return true; // got a NaN or Inf, return immediately
	}

	n = static_cast<T>(acc_n);
	}

	template <typename T, typename Modifiers, typename Enable = void>
	struct make_primitive // by default, return it as-is
	{
	typedef T result_type;

	template <typename T_>
	T_& operator()(T_& val, unused_type) const
	{
	return val;
	}

	template <typename T_>
	T_ const& operator()(T_ const& val, unused_type) const
	{
	return val;
	}
	};

	// nan[(...)] ?
	if (detail::string_parse("nan", "NAN", first, last, unused))
	{
	if (*first == '(')
	{

	template <typename L, typename R, typename C>
	struct get_sequence_types
	{
	typedef
	mpl::vector<
	typename traits::attribute_of<L, C>::type
	, typename traits::attribute_of<R, C>::type
	>
	type;
	};

	template <typename LL, typename LR, typename R, typename C>
	struct get_sequence_types<sequence<LL, LR>, R, C>
	: mpl::push_back< typename get_sequence_types<LL, LR, C>::type
	, typename traits::attribute_of<R, C>::type> {};

	template <typename L, typename RL, typename RR, typename C>
	struct get_sequence_types<L, sequence<RL, RR>, C>
	: mpl::push_front< typename get_sequence_types<RL, RR, C>::type
	, typename traits::attribute_of<L, C>::type> {};

	template <typename LL, typename LR, typename RL, typename RR, typename C>
	struct get_sequence_types<sequence<LL, LR>, sequence<RL, RR>, C>
	{
	typedef typename get_sequence_types<LL, LR, C>::type left;
	typedef typename get_sequence_types<RL, RR, C>::type right;
	typedef typename
	mpl::insert_range<left, typename mpl::end<left>::type, right>::type
	type;
	};

	template <typename L, typename R, typename C>
	struct attribute_of_sequence
	{
	// Get all sequence attribute types
	typedef typename get_sequence_types<L, R, C>::type all_types;

	// Filter all unused_types
	typedef typename
	mpl::copy_if<
	all_types
	, mpl::not_<is_same<mpl::_1, unused_type>>
	, mpl::back_inserter<mpl::vector<>>
	>::type
	filtered_types;

	// Build a fusion::deque if filtered_types is not empty,
	// else just return unused_type
	typedef typename
	mpl::eval_if<
	mpl::empty<filtered_types>
	, mpl::identity<unused_type>
	, mpl::if_<mpl::equal_to<mpl::size<filtered_types>, mpl::int_<1> >,
	typename mpl::front<filtered_types>::type
	, typename fusion::result_of::as_deque<filtered_types>::type >
	>::type
	type;
	};