neobrain / nihstro Goto Github PK

View Code? Open in Web Editor NEW

83.0 83.0 35.0 427 KB

3DS shader assembler and disassembler

License: BSD 3-Clause "New" or "Revised" License

CMake 0.73% C++ 99.27%

nihstro's People

Contributors

Stargazers

Watchers

nihstro's Issues

Assembler needs Boost 1.58 to build

.. because otherwise the build fails due to missing or conflicting swap() implementations.

@archshift Can we tell travis to build with that version instead? Headers-only are sufficient.

nihstro-assemble segfaults

nihstro-assemble segfaults with the example cube.
Setup:
Boost version: 1.54.0
g++ (Ubuntu 4.8.2-19ubuntu1) 4.8.2
Linux Mint 17, 3.13.0-37-generic

GDB info:
Program received signal SIGSEGV, Segmentation fault.
0x0000000000908592 in boost::fusion::cons<boost::spirit::qi::reference<boost::spirit::qi::rule<__gnu_cxx::__normal_iterator<char*, std::string>, nihstro::InputSwizzlerMask (), AssemblySkipper<__gnu_cxx::__normal_iterator<char*, std::string> >, boost::spirit::unused_type, boost::spirit::unused_type> const>, boost::fusion::nil>::cons(boost::spirit::qi::reference<boost::spirit::qi::rule<__gnu_cxx::__normal_iterator<char*, std::string>, nihstro::InputSwizzlerMask (), AssemblySkipper<__gnu_cxx::__normal_iterator<char*, std::string> >, boost::spirit::unused_type, boost::spirit::unused_type> const> const&) ()

Full backtrace: http://pastebin.com/x6nv83Q5

Doesn't compile with Boost 1.59

/usr/include/boost/spirit/home/qi/numeric/detail/real_impl.hpp:225:22: error: no matching function for call to ‘nihstro::SourceTreeIterator::SourceTreeIterator()’
             Iterator e_pos;

It appears that perhaps some change was made to spirit that requires a 0 argument constructor for SourceTreeIterator.

EX2 and LG2 only operate on scalar values

Supposedly something like EX2 r0.y, r0.xyzw will not actually store the result in r0.y. This was reported in an IRC discussion in #3dsdev on efnet on August 14, 2015. The reason remains to be investigated, but chances are nihstro should provide a diagnostic of some sorts in this case.

; Example PICA200 vertex shader

; Uniforms
.fvec projection[4]

; Constants
.constf myconst(0.0, 1.0, -1.0, -0.5)
.alias  zeros myconst.xxxx ; Vector full of zeros
.alias  ones  myconst.yyyy ; Vector full of ones

; Outputs
.out outpos position
.out outclr color

; Inputs (defined as aliases for convenience)
.alias inpos v0

.proc main
    ; Force the w component of inpos to be 1.0
    mov r0.xyz, inpos.xyz
    ex2 r0.y, r0
    mov r0.w,   ones

    ; outpos = projectionMatrix * inpos
    dp4 outpos.x, projection[0], r0
    dp4 outpos.y, projection[1], r0
    dp4 outpos.z, projection[2], r0
    dp4 outpos.w, projection[3], r0

    ; outclr = solid white color
    mov outclr, ones

    ; We're finished
    end
.end

Vector subscript out of range on decompiling shader.

Was trying to decompile sm4sh shader and it hit a "vector subscript out of range" error.
Ill include a sample to reproduce the error.

CustumShader.zip

Add a warning about `make -j5` to the readme

Multithreaded compilation is likely to eat all your system's RAM due to unoptimized usage of boost::spirit. There should be a warning about this in the readme.

Consider porting the example build setup to use CMake

CMake is required to build nihstro anyway, and cmake-3ds (https://github.com/Lectem/3ds-cmake) deals with nihstro binary discovery more cleanly.

However: People might download nihstro binaries and expect to be able to compile the examples. Not quite sure how to deal with that situation, yet.

Support compilation of multiple DVLEs into a single DVLB

The DVLB format supports the definition of multiple shaders (DVLEs). Currently, nihstro supports only generation of DVLBs with a single DVLE, which is created solely from the input source file. Anything more advanced is a nontrivial task, because it's not entirely clear how to approach this.

Workflows which should be supported:

Generating a DVLB containing a single DVLE obtained from a single source file
Generating a DVLB containing multiple DVLEs obtained from a single source file using different compile settings (e.g. entry point, macros, definitions, ...)
Generating a DVLB containing multiple DVLEs, each of which was obtained from a separate source file
Any combination of the things above

Additional features to consider:

common-code detection. This will become particularly important whenever common assembly code is included through .include.
dead-code elimination. This will become important for "uber-shaders" which implement lots of things, but only use a small subset for each entry-point.

I thought about this issue for a while, and I think the most sensible approach to solve it is the following:

Introduce a separated compiler-linker model: Source code is compiled to a DVOJ, multiple DVOJs are then linked into a DVLB.
Compile each input source file once per input configuration (i.e. compile a file multiple times if it's supposed to be compiled with different entry points).
Finally, link all compiled sources together: Since each DVLB may only contain one code binary, this involves relocating each compiled shader blob to a particular offset. To make sure we don't waste too much space (the shader binary is limited to something in the order of 1024 words), dead-code elimination and common-code detection will be required. These may be omitted for an initial implementation, however.

Lack of constant table forces crash on hardware

When attempting to run a shader written without any set constants, on hardware the thread immediately crashes, while on Citra the frame is rendered correctly.

Small pit fall to work around, but an easy fix would be to identify when there's no constants defined then inject a default one using the first unused uniform register.

Output register components may not be written more than once

According to fincs on efnet/#3dsdev, August 14, 2015:

18:39 < fincs> You can't write to an output register more than once
18:40 < fincs> Last time I checked it crashed, but that was before the libctru GPU freezing bug (TM) was fixed

This should be verified, and nihstro should error out when trying to compile shaders which don't write all output registers.

Along with #24, this means nihstro should guarantee that all declared output register components are written exactly once.

Promote "Unknown instruction format" warning to an error

e.g. a like like ; invalid-comment will trigger the warning source/vshader.vsh:15: warning: Unknown instruction format, treating like EOF: " and then abort parsing. Instead, this should be considered an error.

Failed to disassemble Luigi's Mansion: Dark Moon shader code

The disassembler crashes here:

000000dc [--------] ComputeSkinMatrix:
000000dc [0727dc96]     dp3      r9.___w       c93.yyyy    r9.xyzw   16 addr:0;      temp_9 <- const_93, temp_9
000000e0 [3b21901b]     rcp      r9.___w        r9.wwww              1b addr:0;      temp_9 <- temp_9
000000e4 [23219ca3]     mul      r9.xyzw        r9.xyzw    r9.wwww   23 addr:0;      temp_9 <- temp_9, temp_9
000000e8 [48018004]     mova             r8.xyyy               4 addr:0;      out.pos <- temp_8
000000ec [23aaaca4]     mul     r13.xyzw  c10[a0.x].xyzw    r9.xxxx   24 addr:1;      temp_d <- (?), temp_9
000000f0 [23cabca4]     mul     r14.xyzw  c11[a0.x].xyzw    r9.xxxx   24 addr:1;      temp_e <- (?), temp_9
000000f4 [23eacca4]     mul     r15.xyzw  c12[a0.x].xyzw    r9.xxxx   24 addr:1;      temp_f <- (?), temp_9
000000f8 [fdb2aba5]     mad
000000fc [feb2afc5]     mad
00000100 [ffb2b3e5]     mad

I was able to kindof fix it but I don't think i fixed it correctly.

Here's the shader code:
shadercode.zip

`CompileToRawBinary` does not handle `OpCode::Type::MultiplyAdd`

Calling nihstro::InlineAsm::CompileToRawBinary with an OpCode::Id::MAD instruction causes an Unknown instruction exception to throw.

nihstro/include/nihstro/inline_assembly.h

Lines 400 to 402 in e924e21

 
 default: 

 throw "Unknown instruction";

OpCode::Id::MAD is a OpCode::Type::MultiplyAdd which is unhandled by the switch-case and uses the exception-throwing default:-case.

Update readme to show all nihstro-assemble options

It would be nice if the readme specified you can compile geo-shaders with -g or choose the entry-point with -e for example

sf2dlib issue: Restricting output texture coordinate to two components crashes hardware

xerpi/sf2dlib@26be2ea (compiled against devkitPro/libctru@b9e5ddb) moved from aemstro shaders to nihstro. However, the shader had to be modified a bit: The aemstro shader used

.out o1, result.texcoord0, 0x3

while the nihstro shader uses

.alias outtex0 o1 as texcoord0

instead of the direct translation

.alias outtex0 o1.xy as texcoord0

This is because the direct translation caused a crash on real hardware. We're not sure why that is, currently.

MSVC warning 4715 thrown when compiling nihstro

This came up recently in a Citra PR.
Enabling warnings as errors with nihstro included is forcing us to do ugly workarounds like this: https://github.com/citra-emu/citra/pull/6456/files#diff-566073892a6d0498bdfd91d52101a9f7942a861faac247406ad2cdf9ac2e64f2R19.

The warning specifically is C4715: 'function' : not all control paths return a value.
Would be great if this could be fixed.

Optimization oportunities

Below you'll find some tests we performed to improve performance / reduce size of the generated asm in the nihstro library. All assembly was generated by the Visual Studio 2013 Update 4 compiler in the RelWithDebInfo configuration in Citra, set to Maximize Speed.

Changing nihstro::OpCode::GetInfo. The generated code was sub-optimal, as can be seen here https://gist.github.com/Subv/ea74f1b7f011838b0e08. The proposed code change is https://gist.github.com/Subv/fd53c4407894e742d6c6 which reduces the generated asm to https://gist.github.com/Subv/9cabcdda5f607d46edfd. Merged.
Remove the exception from nihstro::SwizzlePattern::DestComponentEnabled. The generated asm was too big and wasn't being inlined. Without the exception, the function is inlined to a TEST + JE instructions. Merged.

Write a "Getting Started" guide

Examples are nice and stuff, but truth be told - they don't really tell you much about the general workflow. A tutorial should be written, including the following:

Initial setup: Compiling nihstro/downloading binaries; installing
Coding a dummy homebrew
Writing a first shader (showcasing basic syntax, aliases, conditional statements, other flow control, diagnostics, etc)

Check if input operands may simultaneously be used as output operands

It sounds likely that hardware does not actually support this. A hardware test should be written to verify that it doesn't, and a diagnostic should be added to make sure source code doesn't try to do this.

Example of what I'm talking about: add r4, i0, r4. Note that r4 is used both as an input and an output of the addition.

.include directive

Having an include directive would greatly benefit this assembler. As I'm working on some larger shaders for my graphics library, I've started to write a lot of reusable functions that would benefit from being located in a common file for use across multiple shaders.

Invalid syntax compiles fine: ones.x.xxxy

E.g.

.alias outclr o1 as color
.alias ones c32 as (1.0, 1.0, 1.0, 1.0)
mov outclr, ones.x.xxxy

ones.x.xxxx might be considered legit, but ones.x.xxxy definitely is not (it accesses a "y" component in ones.x, which is a one-dimensional vector). This should trigger an error instead of compiling without any notification.

Support swizzle masks when declaring constants

e.g. to do something like

.alias zeros c32.x as 0.0
.alias ones c32.y as 1.0

How do I generate a raw disassembly, with extra information commented out if present?

When I disassemble a shader, it gives me a whole bunch of diagnostic messages in addition to the actual assembly output. These are sent to standard output along with the code, and not to standard error, so when I redirect the output to a file, I have to remove those lines. In addition, it also adds information like addresses and opcodes, which the assembler isn't able to understand. Is there some command line parameter or something that I need to pass, in order to have the disassembler generate output that's suitable for modification/reassembly?

include/nihstro/parser_assembly.h: In member function ‘bool nihstro::Expression::HasIndexExpression() const’:
include/nihstro/parser_assembly.h:133:25: erreur: cannot convert ‘const boost::optional<nihstro::IndexExpression>’ to ‘bool’ in return

This is on g++ 4.9.2 with boost 1.57.0, and happens on both Release and Debug build type,

Build Errors? "error: no match for ‘operator=’"

Here is the errors from my terminal:
Pastebin

Ubuntu 16.10

Here are my files just in case. (I didn't edit any code)
my nihstro files.tar.gz

Trying to declare multiple constant values for the same register should yield an error

E.g.

.alias zeros c32 as (0.0, 0.0, 0.0, 0.0)
.alias ones c32 as (1.0, 1.0, 1.0, 1.0)

currently compiles without error, but of course shouldn't.

Building errors

Wish I had time to be more specific and look into it, but all these templating/Boost errors seem to require more knowledge about the code than I have. So it's easier addressed by someone else.

I'm on Arch Linux with Boost version 1.58.0

Cmake builds assembler.cpp fine, but errors on parser_assembly.cpp. Here's my stderr:

http://ix.io/izC

In file included from /usr/include/boost/spirit/home/qi/detail/attributes.hpp:12:0,
                 from /usr/include/boost/spirit/home/qi/action/action.hpp:16,
                 from /usr/include/boost/spirit/home/qi/action.hpp:14,
                 from /usr/include/boost/spirit/home/qi.hpp:14,
                 from /usr/include/boost/spirit/include/qi.hpp:16,
                 from /home/thomas/dev/3ds/nihstro/src/parser_assembly.cpp:32:
/usr/include/boost/spirit/home/support/attributes.hpp: In instantiation of ‘void boost::spirit::traits::swap_impl(T&, T&) [with T = nihstro::Condition]’:
/usr/include/boost/spirit/home/qi/directive/hold.hpp:64:46:   required from ‘bool boost::spirit::qi::hold_directive<Subject>::parse(Iterator&, const Iterator&, Context&, const Skipper&, Attribute&) const [with Iterator = __gnu_cxx::__normal_iterator<char*, std::basic_string<char> >; Context = boost::spirit::context<boost::fusion::cons<nihstro::Condition&, boost::fusion::nil_>, boost::fusion::vector0<> >; Skipper = boost::spirit::qi::reference<const boost::spirit::qi::rule<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> >, boost::spirit::unused_type, boost::spirit::unused_type, boost::spirit::unused_type, boost::spirit::unused_type> >; Attribute = nihstro::Condition; Subject = boost::spirit::qi::sequence<boost::fusion::cons<boost::spirit::qi::reference<const boost::spirit::qi::rule<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> >, nihstro::ConditionInput(), AssemblySkipper<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> > >, boost::spirit::unused_type, boost::spirit::unused_type> >, boost::fusion::cons<boost::spirit::qi::reference<const boost::spirit::qi::rule<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> >, nihstro::Instruction::FlowControlType::Op(), AssemblySkipper<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> > >, boost::spirit::unused_type, boost::spirit::unused_type> >, boost::fusion::cons<boost::spirit::qi::reference<const boost::spirit::qi::rule<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> >, nihstro::ConditionInput(), AssemblySkipper<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> > >, boost::spirit::unused_type, boost::spirit::unused_type> >, boost::fusion::nil_> > > >]’
/usr/include/boost/spirit/home/qi/detail/alternative_function.hpp:70:71:   required from ‘bool boost::spirit::qi::detail::alternative_function<Iterator, Context, Skipper, Attribute>::call(const Component&, mpl_::true_) const [with Component = boost::spirit::qi::hold_directive<boost::spirit::qi::sequence<boost::fusion::cons<boost::spirit::qi::reference<const boost::spirit::qi::rule<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> >, nihstro::ConditionInput(), AssemblySkipper<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> > >, boost::spirit::unused_type, boost::spirit::unused_type> >, boost::fusion::cons<boost::spirit::qi::reference<const boost::spirit::qi::rule<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> >, nihstro::Instruction::FlowControlType::Op(), AssemblySkipper<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> > >, boost::spirit::unused_type, boost::spirit::unused_type> >, boost::fusion::cons<boost::spirit::qi::reference<const boost::spirit::qi::rule<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> >, nihstro::ConditionInput(), AssemblySkipper<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> > >, boost::spirit::unused_type, boost::spirit::unused_type> >, boost::fusion::nil_> > > > >; Iterator = __gnu_cxx::__normal_iterator<char*, std::basic_string<char> >; Context = boost::spirit::context<boost::fusion::cons<nihstro::Condition&, boost::fusion::nil_>, boost::fusion::vector0<> >; Skipper = boost::spirit::qi::reference<const boost::spirit::qi::rule<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> >, boost::spirit::unused_type, boost::spirit::unused_type, boost::spirit::unused_type, boost::spirit::unused_type> >; Attribute = nihstro::Condition; mpl_::true_ = mpl_::bool_<true>]’
/usr/include/boost/spirit/home/qi/detail/alternative_function.hpp:153:20:   required from ‘bool boost::spirit::qi::detail::alternative_function<Iterator, Context, Skipper, Attribute>::call_unused(const Component&, mpl_::true_) const [with Component = boost::spirit::qi::hold_directive<boost::spirit::qi::sequence<boost::fusion::cons<boost::spirit::qi::reference<const boost::spirit::qi::rule<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> >, nihstro::ConditionInput(), AssemblySkipper<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> > >, boost::spirit::unused_type, boost::spirit::unused_type> >, boost::fusion::cons<boost::spirit::qi::reference<const boost::spirit::qi::rule<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> >, nihstro::Instruction::FlowControlType::Op(), AssemblySkipper<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> > >, boost::spirit::unused_type, boost::spirit::unused_type> >, boost::fusion::cons<boost::spirit::qi::reference<const boost::spirit::qi::rule<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> >, nihstro::ConditionInput(), AssemblySkipper<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> > >, boost::spirit::unused_type, boost::spirit::unused_type> >, boost::fusion::nil_> > > > >; Iterator = __gnu_cxx::__normal_iterator<char*, std::basic_string<char> >; Context = boost::spirit::context<boost::fusion::cons<nihstro::Condition&, boost::fusion::nil_>, boost::fusion::vector0<> >; Skipper = boost::spirit::qi::reference<const boost::spirit::qi::rule<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> >, boost::spirit::unused_type, boost::spirit::unused_type, boost::spirit::unused_type, boost::spirit::unused_type> >; Attribute = nihstro::Condition; mpl_::true_ = mpl_::bool_<true>]’
/usr/include/boost/spirit/home/qi/detail/alternative_function.hpp:170:54:   required from ‘bool boost::spirit::qi::detail::alternative_function<Iterator, Context, Skipper, Attribute>::operator()(const Component&) const [with Component = boost::spirit::qi::hold_directive<boost::spirit::qi::sequence<boost::fusion::cons<boost::spirit::qi::reference<const boost::spirit::qi::rule<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> >, nihstro::ConditionInput(), AssemblySkipper<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> > >, boost::spirit::unused_type, boost::spirit::unused_type> >, boost::fusion::cons<boost::spirit::qi::reference<const boost::spirit::qi::rule<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> >, nihstro::Instruction::FlowControlType::Op(), AssemblySkipper<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> > >, boost::spirit::unused_type, boost::spirit::unused_type> >, boost::fusion::cons<boost::spirit::qi::reference<const boost::spirit::qi::rule<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> >, nihstro::ConditionInput(), AssemblySkipper<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> > >, boost::spirit::unused_type, boost::spirit::unused_type> >, boost::fusion::nil_> > > > >; Iterator = __gnu_cxx::__normal_iterator<char*, std::basic_string<char> >; Context = boost::spirit::context<boost::fusion::cons<nihstro::Condition&, boost::fusion::nil_>, boost::fusion::vector0<> >; Skipper = boost::spirit::qi::reference<const boost::spirit::qi::rule<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> >, boost::spirit::unused_type, boost::spirit::unused_type, boost::spirit::unused_type, boost::spirit::unused_type> >; Attribute = nihstro::Condition]’
/usr/include/boost/fusion/algorithm/query/detail/any.hpp:40:19:   required from ‘bool boost::fusion::detail::linear_any(const First&, const Last&, F&, mpl_::false_) [with First = boost::fusion::cons_iterator<const boost::fusion::cons<boost::spirit::qi::hold_directive<boost::spirit::qi::sequence<boost::fusion::cons<boost::spirit::qi::reference<const boost::spirit::qi::rule<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> >, nihstro::ConditionInput(), AssemblySkipper<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> > >, boost::spirit::unused_type, boost::spirit::unused_type> >, boost::fusion::cons<boost::spirit::qi::reference<const boost::spirit::qi::rule<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> >, nihstro::Instruction::FlowControlType::Op(), AssemblySkipper<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> > >, boost::spirit::unused_type, boost::spirit::unused_type> >, boost::fusion::cons<boost::spirit::qi::reference<const boost::spirit::qi::rule<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> >, nihstro::ConditionInput(), AssemblySkipper<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> > >, boost::spirit::unused_type, boost::spirit::unused_type> >, boost::fusion::nil_> > > > >, boost::fusion::cons<boost::spirit::qi::sequence<boost::fusion::cons<boost::spirit::qi::reference<const boost::spirit::qi::rule<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> >, nihstro::ConditionInput(), AssemblySkipper<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> > >, boost::spirit::unused_type, boost::spirit::unused_type> >, boost::fusion::cons<boost::spirit::qi::attr_parser<const nihstro::Instruction::FlowControlType::Op>, boost::fusion::cons<boost::spirit::qi::attr_parser<const nihstro::ConditionInput>, boost::fusion::nil_> > > >, boost::fusion::nil_> > >; Last = boost::fusion::cons_iterator<const boost::fusion::nil_>; F = boost::spirit::qi::detail::alternative_function<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> >, boost::spirit::context<boost::fusion::cons<nihstro::Condition&, boost::fusion::nil_>, boost::fusion::vector0<> >, boost::spirit::qi::reference<const boost::spirit::qi::rule<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> >, boost::spirit::unused_type, boost::spirit::unused_type, boost::spirit::unused_type, boost::spirit::unused_type> >, nihstro::Condition>; mpl_::false_ = mpl_::bool_<false>]’
/usr/include/boost/fusion/algorithm/query/detail/any.hpp:59:63:   [ skipping 8 instantiation contexts, use -ftemplate-backtrace-limit=0 to disable ]
/usr/include/boost/function/function_template.hpp:1077:16:   required from ‘boost::function<R(T0, T1, T2, T3)>::function(Functor, typename boost::enable_if_c<boost::type_traits::ice_not<boost::is_integral<Functor>::value>::value, int>::type) [with Functor = boost::spirit::qi::detail::parser_binder<boost::spirit::qi::alternative<boost::fusion::cons<boost::spirit::qi::hold_directive<boost::spirit::qi::sequence<boost::fusion::cons<boost::spirit::qi::reference<const boost::spirit::qi::rule<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> >, nihstro::ConditionInput(), AssemblySkipper<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> > >, boost::spirit::unused_type, boost::spirit::unused_type> >, boost::fusion::cons<boost::spirit::qi::reference<const boost::spirit::qi::rule<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> >, nihstro::Instruction::FlowControlType::Op(), AssemblySkipper<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> > >, boost::spirit::unused_type, boost::spirit::unused_type> >, boost::fusion::cons<boost::spirit::qi::reference<const boost::spirit::qi::rule<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> >, nihstro::ConditionInput(), AssemblySkipper<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> > >, boost::spirit::unused_type, boost::spirit::unused_type> >, boost::fusion::nil_> > > > >, boost::fusion::cons<boost::spirit::qi::sequence<boost::fusion::cons<boost::spirit::qi::reference<const boost::spirit::qi::rule<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> >, nihstro::ConditionInput(), AssemblySkipper<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> > >, boost::spirit::unused_type, boost::spirit::unused_type> >, boost::fusion::cons<boost::spirit::qi::attr_parser<const nihstro::Instruction::FlowControlType::Op>, boost::fusion::cons<boost::spirit::qi::attr_parser<const nihstro::ConditionInput>, boost::fusion::nil_> > > >, boost::fusion::nil_> > >, mpl_::bool_<false> >; R = bool; T0 = __gnu_cxx::__normal_iterator<char*, std::basic_string<char> >&; T1 = const __gnu_cxx::__normal_iterator<char*, std::basic_string<char> >&; T2 = boost::spirit::context<boost::fusion::cons<nihstro::Condition&, boost::fusion::nil_>, boost::fusion::vector0<> >&; T3 = const boost::spirit::qi::reference<const boost::spirit::qi::rule<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> >, boost::spirit::unused_type, boost::spirit::unused_type, boost::spirit::unused_type, boost::spirit::unused_type> >&; typename boost::enable_if_c<boost::type_traits::ice_not<boost::is_integral<Functor>::value>::value, int>::type = int]’
/usr/include/boost/function/function_template.hpp:1132:5:   required from ‘typename boost::enable_if_c<boost::type_traits::ice_not<boost::is_integral<Functor>::value>::value, boost::function<R(T0, T1, T2, T3)>&>::type boost::function<R(T0, T1, T2, T3)>::operator=(Functor) [with Functor = boost::spirit::qi::detail::parser_binder<boost::spirit::qi::alternative<boost::fusion::cons<boost::spirit::qi::hold_directive<boost::spirit::qi::sequence<boost::fusion::cons<boost::spirit::qi::reference<const boost::spirit::qi::rule<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> >, nihstro::ConditionInput(), AssemblySkipper<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> > >, boost::spirit::unused_type, boost::spirit::unused_type> >, boost::fusion::cons<boost::spirit::qi::reference<const boost::spirit::qi::rule<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> >, nihstro::Instruction::FlowControlType::Op(), AssemblySkipper<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> > >, boost::spirit::unused_type, boost::spirit::unused_type> >, boost::fusion::cons<boost::spirit::qi::reference<const boost::spirit::qi::rule<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> >, nihstro::ConditionInput(), AssemblySkipper<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> > >, boost::spirit::unused_type, boost::spirit::unused_type> >, boost::fusion::nil_> > > > >, boost::fusion::cons<boost::spirit::qi::sequence<boost::fusion::cons<boost::spirit::qi::reference<const boost::spirit::qi::rule<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> >, nihstro::ConditionInput(), AssemblySkipper<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> > >, boost::spirit::unused_type, boost::spirit::unused_type> >, boost::fusion::cons<boost::spirit::qi::attr_parser<const nihstro::Instruction::FlowControlType::Op>, boost::fusion::cons<boost::spirit::qi::attr_parser<const nihstro::ConditionInput>, boost::fusion::nil_> > > >, boost::fusion::nil_> > >, mpl_::bool_<false> >; R = bool; T0 = __gnu_cxx::__normal_iterator<char*, std::basic_string<char> >&; T1 = const __gnu_cxx::__normal_iterator<char*, std::basic_string<char> >&; T2 = boost::spirit::context<boost::fusion::cons<nihstro::Condition&, boost::fusion::nil_>, boost::fusion::vector0<> >&; T3 = const boost::spirit::qi::reference<const boost::spirit::qi::rule<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> >, boost::spirit::unused_type, boost::spirit::unused_type, boost::spirit::unused_type, boost::spirit::unused_type> >&; typename boost::enable_if_c<boost::type_traits::ice_not<boost::is_integral<Functor>::value>::value, boost::function<R(T0, T1, T2, T3)>&>::type = boost::function<bool(__gnu_cxx::__normal_iterator<char*, std::basic_string<char> >&, const __gnu_cxx::__normal_iterator<char*, std::basic_string<char> >&, boost::spirit::context<boost::fusion::cons<nihstro::Condition&, boost::fusion::nil_>, boost::fusion::vector0<> >&, const boost::spirit::qi::reference<const boost::spirit::qi::rule<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> >, boost::spirit::unused_type, boost::spirit::unused_type, boost::spirit::unused_type, boost::spirit::unused_type> >&)>&]’
/usr/include/boost/spirit/home/qi/nonterminal/rule.hpp:183:19:   required from ‘static void boost::spirit::qi::rule<Iterator, T1, T2, T3, T4>::define(boost::spirit::qi::rule<Iterator, T1, T2, T3, T4>&, const Expr&, mpl_::true_) [with Auto = mpl_::bool_<false>; Expr = boost::proto::exprns_::expr<boost::proto::tagns_::tag::bitwise_or, boost::proto::argsns_::list2<const boost::proto::exprns_::expr<boost::proto::tagns_::tag::subscript, boost::proto::argsns_::list2<const boost::proto::exprns_::expr<boost::proto::tagns_::tag::terminal, boost::proto::argsns_::term<boost::spirit::tag::hold>, 0l>&, 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::spirit::qi::rule<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> >, nihstro::ConditionInput(), AssemblySkipper<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> > >, boost::spirit::unused_type, boost::spirit::unused_type>&, boost::spirit::qi::rule<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> >, nihstro::Instruction::FlowControlType::Op(), AssemblySkipper<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> > >, boost::spirit::unused_type, boost::spirit::unused_type>&>, 2l>&, boost::spirit::qi::rule<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> >, nihstro::ConditionInput(), AssemblySkipper<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> > >, boost::spirit::unused_type, boost::spirit::unused_type>&>, 2l>&>, 2l>&, 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::spirit::qi::rule<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> >, nihstro::ConditionInput(), AssemblySkipper<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> > >, boost::spirit::unused_type, boost::spirit::unused_type>&, const boost::proto::exprns_::expr<boost::proto::tagns_::tag::terminal, boost::proto::argsns_::term<boost::spirit::terminal_ex<boost::spirit::tag::attr, boost::fusion::vector1<nihstro::Instruction::FlowControlType::Op> > >, 0l>&>, 2l>&, const boost::proto::exprns_::expr<boost::proto::tagns_::tag::terminal, boost::proto::argsns_::term<boost::spirit::terminal_ex<boost::spirit::tag::attr, boost::fusion::vector1<nihstro::ConditionInput> > >, 0l>&>, 2l>&>, 2l>; Iterator = __gnu_cxx::__normal_iterator<char*, std::basic_string<char> >; T1 = nihstro::Condition(); T2 = AssemblySkipper<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> > >; T3 = boost::spirit::unused_type; T4 = boost::spirit::unused_type; mpl_::true_ = mpl_::bool_<true>]’
/usr/include/boost/spirit/home/qi/nonterminal/rule.hpp:221:19:   required from ‘boost::spirit::qi::rule<Iterator, T1, T2, T3, T4>& boost::spirit::qi::rule<Iterator, T1, T2, T3, T4>::operator=(const Expr&) [with Expr = boost::proto::exprns_::expr<boost::proto::tagns_::tag::bitwise_or, boost::proto::argsns_::list2<const boost::proto::exprns_::expr<boost::proto::tagns_::tag::subscript, boost::proto::argsns_::list2<const boost::proto::exprns_::expr<boost::proto::tagns_::tag::terminal, boost::proto::argsns_::term<boost::spirit::tag::hold>, 0l>&, 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::spirit::qi::rule<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> >, nihstro::ConditionInput(), AssemblySkipper<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> > >, boost::spirit::unused_type, boost::spirit::unused_type>&, boost::spirit::qi::rule<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> >, nihstro::Instruction::FlowControlType::Op(), AssemblySkipper<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> > >, boost::spirit::unused_type, boost::spirit::unused_type>&>, 2l>&, boost::spirit::qi::rule<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> >, nihstro::ConditionInput(), AssemblySkipper<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> > >, boost::spirit::unused_type, boost::spirit::unused_type>&>, 2l>&>, 2l>&, 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::spirit::qi::rule<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> >, nihstro::ConditionInput(), AssemblySkipper<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> > >, boost::spirit::unused_type, boost::spirit::unused_type>&, const boost::proto::exprns_::expr<boost::proto::tagns_::tag::terminal, boost::proto::argsns_::term<boost::spirit::terminal_ex<boost::spirit::tag::attr, boost::fusion::vector1<nihstro::Instruction::FlowControlType::Op> > >, 0l>&>, 2l>&, const boost::proto::exprns_::expr<boost::proto::tagns_::tag::terminal, boost::proto::argsns_::term<boost::spirit::terminal_ex<boost::spirit::tag::attr, boost::fusion::vector1<nihstro::ConditionInput> > >, 0l>&>, 2l>&>, 2l>; Iterator = __gnu_cxx::__normal_iterator<char*, std::basic_string<char> >; T1 = nihstro::Condition(); T2 = AssemblySkipper<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> > >; T3 = boost::spirit::unused_type; T4 = boost::spirit::unused_type]’
/home/thomas/dev/3ds/nihstro/src/parser_assembly.cpp:522:19:   required from ‘FlowControlParser<Iterator>::FlowControlParser(const nihstro::ParserContext&) [with Iterator = __gnu_cxx::__normal_iterator<char*, std::basic_string<char> >]’
/home/thomas/dev/3ds/nihstro/src/parser_assembly.cpp:697:67:   required from here
/usr/include/boost/spirit/home/support/attributes.hpp:1036:18: error: call of overloaded ‘swap(nihstro::Condition&, nihstro::Condition&)’ is ambiguous
         swap(a, b);
                  ^
/usr/include/boost/spirit/home/support/attributes.hpp:1036:18: note: candidates are:
In file included from /usr/include/boost/utility/swap.hpp:15:0,
                 from /usr/include/boost/optional/optional.hpp:54,
                 from /usr/include/boost/optional.hpp:15,
                 from /usr/include/boost/spirit/home/support/container.hpp:21,
                 from /usr/include/boost/spirit/home/support/string_traits.hpp:16,
                 from /usr/include/boost/spirit/home/support/nonterminal/expand_arg.hpp:20,
                 from /usr/include/boost/spirit/home/support/context.hpp:18,
                 from /usr/include/boost/spirit/home/qi/domain.hpp:18,
                 from /usr/include/boost/spirit/home/qi/meta_compiler.hpp:15,
                 from /usr/include/boost/spirit/home/qi/action/action.hpp:14,
                 from /usr/include/boost/spirit/home/qi/action.hpp:14,
                 from /usr/include/boost/spirit/home/qi.hpp:14,
                 from /usr/include/boost/spirit/include/qi.hpp:16,
                 from /home/thomas/dev/3ds/nihstro/src/parser_assembly.cpp:32:
/usr/include/boost/core/swap.hpp:54:8: note: void boost::swap(T1&, T2&) [with T1 = nihstro::Condition; T2 = nihstro::Condition]
   void swap(T1& left, T2& right)
        ^
In file included from /usr/include/boost/fusion/sequence/intrinsic.hpp:23:0,
                 from /usr/include/boost/fusion/include/intrinsic.hpp:11,
                 from /usr/include/boost/proto/fusion.hpp:22,
                 from /usr/include/boost/proto/core.hpp:21,
                 from /usr/include/boost/proto/proto.hpp:12,
                 from /usr/include/boost/spirit/home/support/meta_compiler.hpp:19,
                 from /usr/include/boost/spirit/home/qi/meta_compiler.hpp:14,
                 from /usr/include/boost/spirit/home/qi/action/action.hpp:14,
                 from /usr/include/boost/spirit/home/qi/action.hpp:14,
                 from /usr/include/boost/spirit/home/qi.hpp:14,
                 from /usr/include/boost/spirit/include/qi.hpp:16,
                 from /home/thomas/dev/3ds/nihstro/src/parser_assembly.cpp:32:
/usr/include/boost/fusion/sequence/intrinsic/swap.hpp:57:5: note: typename boost::fusion::result_of::swap<Seq1, Seq2>::type boost::fusion::swap(Seq1&, Seq2&) [with Seq1 = nihstro::Condition; Seq2 = nihstro::Condition; typename boost::fusion::result_of::swap<Seq1, Seq2>::type = void]
     swap(Seq1& lhs, Seq2& rhs)
     ^
In file included from /usr/include/boost/fusion/container/vector/vector10.hpp:66:0,
                 from /usr/include/boost/fusion/container/vector/vector_fwd.hpp:15,
                 from /usr/include/boost/fusion/mpl/detail/clear.hpp:11,
                 from /usr/include/boost/fusion/mpl/clear.hpp:13,
                 from /usr/include/boost/fusion/mpl.hpp:17,
                 from /usr/include/boost/fusion/view/detail/strictest_traversal.hpp:16,
                 from /usr/include/boost/fusion/view/zip_view/zip_view.hpp:15,
                 from /usr/include/boost/fusion/view/zip_view.hpp:12,
                 from /usr/include/boost/fusion/sequence/intrinsic/swap.hpp:15,
                 from /usr/include/boost/fusion/sequence/intrinsic.hpp:23,
                 from /usr/include/boost/fusion/include/intrinsic.hpp:11,
                 from /usr/include/boost/proto/fusion.hpp:22,
                 from /usr/include/boost/proto/core.hpp:21,
                 from /usr/include/boost/proto/proto.hpp:12,
                 from /usr/include/boost/spirit/home/support/meta_compiler.hpp:19,
                 from /usr/include/boost/spirit/home/qi/meta_compiler.hpp:14,
                 from /usr/include/boost/spirit/home/qi/action/action.hpp:14,
                 from /usr/include/boost/spirit/home/qi/action.hpp:14,
                 from /usr/include/boost/spirit/home/qi.hpp:14,
                 from /usr/include/boost/spirit/include/qi.hpp:16,
                 from /home/thomas/dev/3ds/nihstro/src/parser_assembly.cpp:32:
/usr/include/boost/fusion/container/vector/detail/preprocessed/vector10.hpp: In instantiation of ‘static boost::fusion::vector_data2<T0, T1> boost::fusion::vector_data2<T0, T1>::init_from_sequence(const Sequence&) [with Sequence = boost::fusion::vector3<boost::fusion::vector<boost::optional<int>, std::basic_string<char> >, boost::optional<nihstro::IndexExpression>, std::vector<nihstro::InputSwizzlerMask> >; T0 = boost::optional<int>; T1 = std::basic_string<char>]’:
/usr/include/boost/fusion/container/vector/detail/preprocessed/vector10.hpp:336:58:   required from ‘boost::fusion::vector2<T0, T1>::vector2(const Sequence&, typename boost::enable_if<boost::fusion::traits::is_sequence<Sequence> >::type*) [with Sequence = boost::fusion::vector3<boost::fusion::vector<boost::optional<int>, std::basic_string<char> >, boost::optional<nihstro::IndexExpression>, std::vector<nihstro::InputSwizzlerMask> >; T0 = boost::optional<int>; T1 = std::basic_string<char>; typename boost::enable_if<boost::fusion::traits::is_sequence<Sequence> >::type = void]’
/usr/include/boost/fusion/container/vector/detail/preprocessed/vvector10.hpp:48:50:   required from ‘constexpr boost::fusion::vector<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::vector(const Sequence&, typename boost::enable_if<boost::fusion::traits::is_sequence<Sequence> >::type*) [with Sequence = boost::fusion::vector3<boost::fusion::vector<boost::optional<int>, std::basic_string<char> >, boost::optional<nihstro::IndexExpression>, std::vector<nihstro::InputSwizzlerMask> >; T0 = boost::optional<int>; T1 = std::basic_string<char>; T2 = boost::fusion::void_; T3 = boost::fusion::void_; T4 = boost::fusion::void_; T5 = boost::fusion::void_; T6 = boost::fusion::void_; T7 = boost::fusion::void_; T8 = boost::fusion::void_; T9 = boost::fusion::void_; typename boost::enable_if<boost::fusion::traits::is_sequence<Sequence> >::type = void]’
/usr/include/boost/type_traits/is_convertible.hpp:86:31:   required by substitution of ‘template<class From1, class To1> static decltype ((test_aux<To1>(declval<From1>()), boost::detail::is_convertible_basic_impl<From, To, false>::one())) boost::detail::is_convertible_basic_impl<From, To, false>::test(int) [with From1 = boost::fusion::vector3<boost::fusion::vector<boost::optional<int>, std::basic_string<char> >, boost::optional<nihstro::IndexExpression>, std::vector<nihstro::InputSwizzlerMask> >; To1 = boost::fusion::vector<boost::optional<int>, std::basic_string<char> >]’
/usr/include/boost/type_traits/is_convertible.hpp:92:44:   required from ‘const bool boost::detail::is_convertible_basic_impl<boost::fusion::vector3<boost::fusion::vector<boost::optional<int>, std::basic_string<char> >, boost::optional<nihstro::IndexExpression>, std::vector<nihstro::InputSwizzlerMask> >, boost::fusion::vector<boost::optional<int>, std::basic_string<char> >, false>::value’
/usr/include/boost/type_traits/is_convertible.hpp:357:5:   required from ‘const bool boost::detail::is_convertible_impl<boost::fusion::vector3<boost::fusion::vector<boost::optional<int>, std::basic_string<char> >, boost::optional<nihstro::IndexExpression>, std::vector<nihstro::InputSwizzlerMask> >, boost::fusion::vector<boost::optional<int>, std::basic_string<char> > >::value’
/usr/include/boost/type_traits/is_convertible.hpp:482:1:   [ skipping 21 instantiation contexts, use -ftemplate-backtrace-limit=0 to disable ]
/usr/include/boost/function/function_template.hpp:1077:16:   required from ‘boost::function<R(T0, T1, T2, T3)>::function(Functor, typename boost::enable_if_c<boost::type_traits::ice_not<boost::is_integral<Functor>::value>::value, int>::type) [with Functor = boost::spirit::qi::detail::parser_binder<boost::spirit::qi::expect<boost::fusion::cons<boost::spirit::qi::reference<const boost::spirit::qi::rule<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> >, nihstro::Expression(), AssemblySkipper<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> > >, boost::spirit::unused_type, boost::spirit::unused_type> >, boost::fusion::cons<boost::spirit::qi::literal_char<boost::spirit::char_encoding::standard, true, false>, boost::fusion::cons<boost::spirit::qi::reference<const boost::spirit::qi::rule<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> >, nihstro::Expression(), AssemblySkipper<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> > >, boost::spirit::unused_type, boost::spirit::unused_type> >, boost::fusion::nil_> > > >, mpl_::bool_<false> >; R = bool; T0 = __gnu_cxx::__normal_iterator<char*, std::basic_string<char> >&; T1 = const __gnu_cxx::__normal_iterator<char*, std::basic_string<char> >&; T2 = boost::spirit::context<boost::fusion::cons<std::vector<nihstro::Expression>&, boost::fusion::nil_>, boost::fusion::vector0<> >&; T3 = const boost::spirit::qi::reference<const boost::spirit::qi::rule<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> >, boost::spirit::unused_type, boost::spirit::unused_type, boost::spirit::unused_type, boost::spirit::unused_type> >&; typename boost::enable_if_c<boost::type_traits::ice_not<boost::is_integral<Functor>::value>::value, int>::type = int]’
/usr/include/boost/function/function_template.hpp:1132:5:   required from ‘typename boost::enable_if_c<boost::type_traits::ice_not<boost::is_integral<Functor>::value>::value, boost::function<R(T0, T1, T2, T3)>&>::type boost::function<R(T0, T1, T2, T3)>::operator=(Functor) [with Functor = boost::spirit::qi::detail::parser_binder<boost::spirit::qi::expect<boost::fusion::cons<boost::spirit::qi::reference<const boost::spirit::qi::rule<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> >, nihstro::Expression(), AssemblySkipper<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> > >, boost::spirit::unused_type, boost::spirit::unused_type> >, boost::fusion::cons<boost::spirit::qi::literal_char<boost::spirit::char_encoding::standard, true, false>, boost::fusion::cons<boost::spirit::qi::reference<const boost::spirit::qi::rule<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> >, nihstro::Expression(), AssemblySkipper<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> > >, boost::spirit::unused_type, boost::spirit::unused_type> >, boost::fusion::nil_> > > >, mpl_::bool_<false> >; R = bool; T0 = __gnu_cxx::__normal_iterator<char*, std::basic_string<char> >&; T1 = const __gnu_cxx::__normal_iterator<char*, std::basic_string<char> >&; T2 = boost::spirit::context<boost::fusion::cons<std::vector<nihstro::Expression>&, boost::fusion::nil_>, boost::fusion::vector0<> >&; T3 = const boost::spirit::qi::reference<const boost::spirit::qi::rule<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> >, boost::spirit::unused_type, boost::spirit::unused_type, boost::spirit::unused_type, boost::spirit::unused_type> >&; typename boost::enable_if_c<boost::type_traits::ice_not<boost::is_integral<Functor>::value>::value, boost::function<R(T0, T1, T2, T3)>&>::type = boost::function<bool(__gnu_cxx::__normal_iterator<char*, std::basic_string<char> >&, const __gnu_cxx::__normal_iterator<char*, std::basic_string<char> >&, boost::spirit::context<boost::fusion::cons<std::vector<nihstro::Expression>&, boost::fusion::nil_>, boost::fusion::vector0<> >&, const boost::spirit::qi::reference<const boost::spirit::qi::rule<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> >, boost::spirit::unused_type, boost::spirit::unused_type, boost::spirit::unused_type, boost::spirit::unused_type> >&)>&]’
/usr/include/boost/spirit/home/qi/nonterminal/rule.hpp:183:19:   required from ‘static void boost::spirit::qi::rule<Iterator, T1, T2, T3, T4>::define(boost::spirit::qi::rule<Iterator, T1, T2, T3, T4>&, const Expr&, mpl_::true_) [with Auto = mpl_::bool_<false>; Expr = boost::proto::exprns_::expr<boost::proto::tagns_::tag::greater, boost::proto::argsns_::list2<const boost::proto::exprns_::expr<boost::proto::tagns_::tag::greater, boost::proto::argsns_::list2<boost::spirit::qi::rule<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> >, nihstro::Expression(), AssemblySkipper<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> > >, boost::spirit::unused_type, boost::spirit::unused_type>&, boost::proto::exprns_::expr<boost::proto::tagns_::tag::terminal, boost::proto::argsns_::term<boost::spirit::terminal_ex<boost::spirit::tag::lit, boost::fusion::vector1<char> > >, 0l>&>, 2l>&, boost::spirit::qi::rule<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> >, nihstro::Expression(), AssemblySkipper<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> > >, boost::spirit::unused_type, boost::spirit::unused_type>&>, 2l>; Iterator = __gnu_cxx::__normal_iterator<char*, std::basic_string<char> >; T1 = std::vector<nihstro::Expression>(); T2 = AssemblySkipper<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> > >; T3 = boost::spirit::unused_type; T4 = boost::spirit::unused_type; mpl_::true_ = mpl_::bool_<true>]’
/usr/include/boost/spirit/home/qi/nonterminal/rule.hpp:221:19:   required from ‘boost::spirit::qi::rule<Iterator, T1, T2, T3, T4>& boost::spirit::qi::rule<Iterator, T1, T2, T3, T4>::operator=(const Expr&) [with Expr = boost::proto::exprns_::expr<boost::proto::tagns_::tag::greater, boost::proto::argsns_::list2<const boost::proto::exprns_::expr<boost::proto::tagns_::tag::greater, boost::proto::argsns_::list2<boost::spirit::qi::rule<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> >, nihstro::Expression(), AssemblySkipper<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> > >, boost::spirit::unused_type, boost::spirit::unused_type>&, boost::proto::exprns_::expr<boost::proto::tagns_::tag::terminal, boost::proto::argsns_::term<boost::spirit::terminal_ex<boost::spirit::tag::lit, boost::fusion::vector1<char> > >, 0l>&>, 2l>&, boost::spirit::qi::rule<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> >, nihstro::Expression(), AssemblySkipper<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> > >, boost::spirit::unused_type, boost::spirit::unused_type>&>, 2l>; Iterator = __gnu_cxx::__normal_iterator<char*, std::basic_string<char> >; T1 = std::vector<nihstro::Expression>(); T2 = AssemblySkipper<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> > >; T3 = boost::spirit::unused_type; T4 = boost::spirit::unused_type]’
/home/thomas/dev/3ds/nihstro/src/parser_assembly.cpp:448:25:   required from ‘CompareParser<Iterator>::CompareParser(const nihstro::ParserContext&) [with Iterator = __gnu_cxx::__normal_iterator<char*, std::basic_string<char> >]’
/home/thomas/dev/3ds/nihstro/src/parser_assembly.cpp:697:67:   required from here
/usr/include/boost/fusion/container/vector/detail/preprocessed/vector10.hpp:251:42: error: no matching function for call to ‘boost::fusion::vector_data2<boost::optional<int>, std::basic_string<char> >::vector_data2(const boost::fusion::vector<boost::optional<int>, std::basic_string<char> >&, const boost::optional<nihstro::IndexExpression>&)’
             return vector_data2(*i0 , *i1);
                                          ^
/usr/include/boost/fusion/container/vector/detail/preprocessed/vector10.hpp:251:42: note: candidates are:
/usr/include/boost/fusion/container/vector/detail/preprocessed/vector10.hpp:230:9: note: constexpr boost::fusion::vector_data2<T0, T1>::vector_data2(const boost::fusion::vector_data2<T0, T1>&) [with T0 = boost::optional<int>; T1 = std::basic_string<char>]
         vector_data2(
         ^
/usr/include/boost/fusion/container/vector/detail/preprocessed/vector10.hpp:230:9: note:   candidate expects 1 argument, 2 provided
/usr/include/boost/fusion/container/vector/detail/preprocessed/vector10.hpp:226:9: note: constexpr boost::fusion::vector_data2<T0, T1>::vector_data2(typename boost::fusion::detail::call_param<T>::type, typename boost::fusion::detail::call_param<Cdr>::type) [with T0 = boost::optional<int>; T1 = std::basic_string<char>; typename boost::fusion::detail::call_param<T>::type = const boost::optional<int>&; typename boost::fusion::detail::call_param<Cdr>::type = const std::basic_string<char>&]
         vector_data2(
         ^
/usr/include/boost/fusion/container/vector/detail/preprocessed/vector10.hpp:226:9: note:   no known conversion for argument 1 from ‘const boost::fusion::vector<boost::optional<int>, std::basic_string<char> >’ to ‘boost::fusion::detail::call_param<boost::optional<int> >::type {aka const boost::optional<int>&}’
/usr/include/boost/fusion/container/vector/detail/preprocessed/vector10.hpp:218:9: note: boost::fusion::vector_data2<T0, T1>::vector_data2(boost::fusion::vector_data2<T0, T1>&&) [with T0 = boost::optional<int>; T1 = std::basic_string<char>]
         vector_data2(
         ^
/usr/include/boost/fusion/container/vector/detail/preprocessed/vector10.hpp:218:9: note:   candidate expects 1 argument, 2 provided
/usr/include/boost/fusion/container/vector/detail/preprocessed/vector10.hpp:213:9: note: template<class U0, class U1> boost::fusion::vector_data2<T0, T1>::vector_data2(U0&&, U1&&, typename boost::enable_if<boost::is_convertible<Sequence, Car> >::type*)
         vector_data2(U0 && arg0 , U1 && arg1
         ^
/usr/include/boost/fusion/container/vector/detail/preprocessed/vector10.hpp:213:9: note:   template argument deduction/substitution failed:
/usr/include/boost/fusion/container/vector/detail/preprocessed/vector10.hpp: In substitution of ‘template<class U0, class U1> boost::fusion::vector_data2<T0, T1>::vector_data2(U0&&, U1&&, typename boost::enable_if<boost::is_convertible<Sequence, Car> >::type*) [with U0 = const boost::fusion::vector<boost::optional<int>, std::basic_string<char> >&; U1 = const boost::optional<nihstro::IndexExpression>&]’:
/usr/include/boost/fusion/container/vector/detail/preprocessed/vector10.hpp:251:42:   required from ‘static boost::fusion::vector_data2<T0, T1> boost::fusion::vector_data2<T0, T1>::init_from_sequence(const Sequence&) [with Sequence = boost::fusion::vector3<boost::fusion::vector<boost::optional<int>, std::basic_string<char> >, boost::optional<nihstro::IndexExpression>, std::vector<nihstro::InputSwizzlerMask> >; T0 = boost::optional<int>; T1 = std::basic_string<char>]’
/usr/include/boost/fusion/container/vector/detail/preprocessed/vector10.hpp:336:58:   required from ‘boost::fusion::vector2<T0, T1>::vector2(const Sequence&, typename boost::enable_if<boost::fusion::traits::is_sequence<Sequence> >::type*) [with Sequence = boost::fusion::vector3<boost::fusion::vector<boost::optional<int>, std::basic_string<char> >, boost::optional<nihstro::IndexExpression>, std::vector<nihstro::InputSwizzlerMask> >; T0 = boost::optional<int>; T1 = std::basic_string<char>; typename boost::enable_if<boost::fusion::traits::is_sequence<Sequence> >::type = void]’
/usr/include/boost/fusion/container/vector/detail/preprocessed/vvector10.hpp:48:50:   required from ‘constexpr boost::fusion::vector<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::vector(const Sequence&, typename boost::enable_if<boost::fusion::traits::is_sequence<Sequence> >::type*) [with Sequence = boost::fusion::vector3<boost::fusion::vector<boost::optional<int>, std::basic_string<char> >, boost::optional<nihstro::IndexExpression>, std::vector<nihstro::InputSwizzlerMask> >; T0 = boost::optional<int>; T1 = std::basic_string<char>; T2 = boost::fusion::void_; T3 = boost::fusion::void_; T4 = boost::fusion::void_; T5 = boost::fusion::void_; T6 = boost::fusion::void_; T7 = boost::fusion::void_; T8 = boost::fusion::void_; T9 = boost::fusion::void_; typename boost::enable_if<boost::fusion::traits::is_sequence<Sequence> >::type = void]’
/usr/include/boost/type_traits/is_convertible.hpp:86:31:   required by substitution of ‘template<class From1, class To1> static decltype ((test_aux<To1>(declval<From1>()), boost::detail::is_convertible_basic_impl<From, To, false>::one())) boost::detail::is_convertible_basic_impl<From, To, false>::test(int) [with From1 = boost::fusion::vector3<boost::fusion::vector<boost::optional<int>, std::basic_string<char> >, boost::optional<nihstro::IndexExpression>, std::vector<nihstro::InputSwizzlerMask> >; To1 = boost::fusion::vector<boost::optional<int>, std::basic_string<char> >]’
/usr/include/boost/type_traits/is_convertible.hpp:92:44:   required from ‘const bool boost::detail::is_convertible_basic_impl<boost::fusion::vector3<boost::fusion::vector<boost::optional<int>, std::basic_string<char> >, boost::optional<nihstro::IndexExpression>, std::vector<nihstro::InputSwizzlerMask> >, boost::fusion::vector<boost::optional<int>, std::basic_string<char> >, false>::value’
/usr/include/boost/type_traits/is_convertible.hpp:357:5:   [ skipping 22 instantiation contexts, use -ftemplate-backtrace-limit=0 to disable ]
/usr/include/boost/function/function_template.hpp:1077:16:   required from ‘boost::function<R(T0, T1, T2, T3)>::function(Functor, typename boost::enable_if_c<boost::type_traits::ice_not<boost::is_integral<Functor>::value>::value, int>::type) [with Functor = boost::spirit::qi::detail::parser_binder<boost::spirit::qi::expect<boost::fusion::cons<boost::spirit::qi::reference<const boost::spirit::qi::rule<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> >, nihstro::Expression(), AssemblySkipper<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> > >, boost::spirit::unused_type, boost::spirit::unused_type> >, boost::fusion::cons<boost::spirit::qi::literal_char<boost::spirit::char_encoding::standard, true, false>, boost::fusion::cons<boost::spirit::qi::reference<const boost::spirit::qi::rule<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> >, nihstro::Expression(), AssemblySkipper<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> > >, boost::spirit::unused_type, boost::spirit::unused_type> >, boost::fusion::nil_> > > >, mpl_::bool_<false> >; R = bool; T0 = __gnu_cxx::__normal_iterator<char*, std::basic_string<char> >&; T1 = const __gnu_cxx::__normal_iterator<char*, std::basic_string<char> >&; T2 = boost::spirit::context<boost::fusion::cons<std::vector<nihstro::Expression>&, boost::fusion::nil_>, boost::fusion::vector0<> >&; T3 = const boost::spirit::qi::reference<const boost::spirit::qi::rule<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> >, boost::spirit::unused_type, boost::spirit::unused_type, boost::spirit::unused_type, boost::spirit::unused_type> >&; typename boost::enable_if_c<boost::type_traits::ice_not<boost::is_integral<Functor>::value>::value, int>::type = int]’
/usr/include/boost/function/function_template.hpp:1132:5:   required from ‘typename boost::enable_if_c<boost::type_traits::ice_not<boost::is_integral<Functor>::value>::value, boost::function<R(T0, T1, T2, T3)>&>::type boost::function<R(T0, T1, T2, T3)>::operator=(Functor) [with Functor = boost::spirit::qi::detail::parser_binder<boost::spirit::qi::expect<boost::fusion::cons<boost::spirit::qi::reference<const boost::spirit::qi::rule<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> >, nihstro::Expression(), AssemblySkipper<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> > >, boost::spirit::unused_type, boost::spirit::unused_type> >, boost::fusion::cons<boost::spirit::qi::literal_char<boost::spirit::char_encoding::standard, true, false>, boost::fusion::cons<boost::spirit::qi::reference<const boost::spirit::qi::rule<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> >, nihstro::Expression(), AssemblySkipper<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> > >, boost::spirit::unused_type, boost::spirit::unused_type> >, boost::fusion::nil_> > > >, mpl_::bool_<false> >; R = bool; T0 = __gnu_cxx::__normal_iterator<char*, std::basic_string<char> >&; T1 = const __gnu_cxx::__normal_iterator<char*, std::basic_string<char> >&; T2 = boost::spirit::context<boost::fusion::cons<std::vector<nihstro::Expression>&, boost::fusion::nil_>, boost::fusion::vector0<> >&; T3 = const boost::spirit::qi::reference<const boost::spirit::qi::rule<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> >, boost::spirit::unused_type, boost::spirit::unused_type, boost::spirit::unused_type, boost::spirit::unused_type> >&; typename boost::enable_if_c<boost::type_traits::ice_not<boost::is_integral<Functor>::value>::value, boost::function<R(T0, T1, T2, T3)>&>::type = boost::function<bool(__gnu_cxx::__normal_iterator<char*, std::basic_string<char> >&, const __gnu_cxx::__normal_iterator<char*, std::basic_string<char> >&, boost::spirit::context<boost::fusion::cons<std::vector<nihstro::Expression>&, boost::fusion::nil_>, boost::fusion::vector0<> >&, const boost::spirit::qi::reference<const boost::spirit::qi::rule<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> >, boost::spirit::unused_type, boost::spirit::unused_type, boost::spirit::unused_type, boost::spirit::unused_type> >&)>&]’
/usr/include/boost/spirit/home/qi/nonterminal/rule.hpp:183:19:   required from ‘static void boost::spirit::qi::rule<Iterator, T1, T2, T3, T4>::define(boost::spirit::qi::rule<Iterator, T1, T2, T3, T4>&, const Expr&, mpl_::true_) [with Auto = mpl_::bool_<false>; Expr = boost::proto::exprns_::expr<boost::proto::tagns_::tag::greater, boost::proto::argsns_::list2<const boost::proto::exprns_::expr<boost::proto::tagns_::tag::greater, boost::proto::argsns_::list2<boost::spirit::qi::rule<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> >, nihstro::Expression(), AssemblySkipper<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> > >, boost::spirit::unused_type, boost::spirit::unused_type>&, boost::proto::exprns_::expr<boost::proto::tagns_::tag::terminal, boost::proto::argsns_::term<boost::spirit::terminal_ex<boost::spirit::tag::lit, boost::fusion::vector1<char> > >, 0l>&>, 2l>&, boost::spirit::qi::rule<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> >, nihstro::Expression(), AssemblySkipper<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> > >, boost::spirit::unused_type, boost::spirit::unused_type>&>, 2l>; Iterator = __gnu_cxx::__normal_iterator<char*, std::basic_string<char> >; T1 = std::vector<nihstro::Expression>(); T2 = AssemblySkipper<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> > >; T3 = boost::spirit::unused_type; T4 = boost::spirit::unused_type; mpl_::true_ = mpl_::bool_<true>]’
/usr/include/boost/spirit/home/qi/nonterminal/rule.hpp:221:19:   required from ‘boost::spirit::qi::rule<Iterator, T1, T2, T3, T4>& boost::spirit::qi::rule<Iterator, T1, T2, T3, T4>::operator=(const Expr&) [with Expr = boost::proto::exprns_::expr<boost::proto::tagns_::tag::greater, boost::proto::argsns_::list2<const boost::proto::exprns_::expr<boost::proto::tagns_::tag::greater, boost::proto::argsns_::list2<boost::spirit::qi::rule<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> >, nihstro::Expression(), AssemblySkipper<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> > >, boost::spirit::unused_type, boost::spirit::unused_type>&, boost::proto::exprns_::expr<boost::proto::tagns_::tag::terminal, boost::proto::argsns_::term<boost::spirit::terminal_ex<boost::spirit::tag::lit, boost::fusion::vector1<char> > >, 0l>&>, 2l>&, boost::spirit::qi::rule<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> >, nihstro::Expression(), AssemblySkipper<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> > >, boost::spirit::unused_type, boost::spirit::unused_type>&>, 2l>; Iterator = __gnu_cxx::__normal_iterator<char*, std::basic_string<char> >; T1 = std::vector<nihstro::Expression>(); T2 = AssemblySkipper<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> > >; T3 = boost::spirit::unused_type; T4 = boost::spirit::unused_type]’
/home/thomas/dev/3ds/nihstro/src/parser_assembly.cpp:448:25:   required from ‘CompareParser<Iterator>::CompareParser(const nihstro::ParserContext&) [with Iterator = __gnu_cxx::__normal_iterator<char*, std::basic_string<char> >]’
/home/thomas/dev/3ds/nihstro/src/parser_assembly.cpp:697:67:   required from here
/usr/include/boost/fusion/container/vector/detail/preprocessed/vector10.hpp:213:9: error: no type named ‘type’ in ‘struct boost::enable_if<boost::is_convertible<const boost::fusion::vector<boost::optional<int>, std::basic_string<char> >&, boost::optional<int> >, void>’
/usr/include/boost/fusion/container/vector/detail/preprocessed/vector10.hpp: In instantiation of ‘static boost::fusion::vector_data2<T0, T1> boost::fusion::vector_data2<T0, T1>::init_from_sequence(const Sequence&) [with Sequence = boost::fusion::vector3<boost::fusion::vector<boost::optional<int>, std::basic_string<char> >, boost::optional<nihstro::IndexExpression>, std::vector<nihstro::InputSwizzlerMask> >; T0 = boost::optional<int>; T1 = std::basic_string<char>]’:
/usr/include/boost/fusion/container/vector/detail/preprocessed/vector10.hpp:336:58:   required from ‘boost::fusion::vector2<T0, T1>::vector2(const Sequence&, typename boost::enable_if<boost::fusion::traits::is_sequence<Sequence> >::type*) [with Sequence = boost::fusion::vector3<boost::fusion::vector<boost::optional<int>, std::basic_string<char> >, boost::optional<nihstro::IndexExpression>, std::vector<nihstro::InputSwizzlerMask> >; T0 = boost::optional<int>; T1 = std::basic_string<char>; typename boost::enable_if<boost::fusion::traits::is_sequence<Sequence> >::type = void]’
/usr/include/boost/fusion/container/vector/detail/preprocessed/vvector10.hpp:48:50:   required from ‘constexpr boost::fusion::vector<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::vector(const Sequence&, typename boost::enable_if<boost::fusion::traits::is_sequence<Sequence> >::type*) [with Sequence = boost::fusion::vector3<boost::fusion::vector<boost::optional<int>, std::basic_string<char> >, boost::optional<nihstro::IndexExpression>, std::vector<nihstro::InputSwizzlerMask> >; T0 = boost::optional<int>; T1 = std::basic_string<char>; T2 = boost::fusion::void_; T3 = boost::fusion::void_; T4 = boost::fusion::void_; T5 = boost::fusion::void_; T6 = boost::fusion::void_; T7 = boost::fusion::void_; T8 = boost::fusion::void_; T9 = boost::fusion::void_; typename boost::enable_if<boost::fusion::traits::is_sequence<Sequence> >::type = void]’
/usr/include/boost/type_traits/is_convertible.hpp:86:31:   required by substitution of ‘template<class From1, class To1> static decltype ((test_aux<To1>(declval<From1>()), boost::detail::is_convertible_basic_impl<From, To, false>::one())) boost::detail::is_convertible_basic_impl<From, To, false>::test(int) [with From1 = boost::fusion::vector3<boost::fusion::vector<boost::optional<int>, std::basic_string<char> >, boost::optional<nihstro::IndexExpression>, std::vector<nihstro::InputSwizzlerMask> >; To1 = boost::fusion::vector<boost::optional<int>, std::basic_string<char> >]’
/usr/include/boost/type_traits/is_convertible.hpp:92:44:   required from ‘const bool boost::detail::is_convertible_basic_impl<boost::fusion::vector3<boost::fusion::vector<boost::optional<int>, std::basic_string<char> >, boost::optional<nihstro::IndexExpression>, std::vector<nihstro::InputSwizzlerMask> >, boost::fusion::vector<boost::optional<int>, std::basic_string<char> >, false>::value’
/usr/include/boost/type_traits/is_convertible.hpp:357:5:   required from ‘const bool boost::detail::is_convertible_impl<boost::fusion::vector3<boost::fusion::vector<boost::optional<int>, std::basic_string<char> >, boost::optional<nihstro::IndexExpression>, std::vector<nihstro::InputSwizzlerMask> >, boost::fusion::vector<boost::optional<int>, std::basic_string<char> > >::value’
/usr/include/boost/type_traits/is_convertible.hpp:482:1:   [ skipping 21 instantiation contexts, use -ftemplate-backtrace-limit=0 to disable ]
/usr/include/boost/function/function_template.hpp:1077:16:   required from ‘boost::function<R(T0, T1, T2, T3)>::function(Functor, typename boost::enable_if_c<boost::type_traits::ice_not<boost::is_integral<Functor>::value>::value, int>::type) [with Functor = boost::spirit::qi::detail::parser_binder<boost::spirit::qi::expect<boost::fusion::cons<boost::spirit::qi::reference<const boost::spirit::qi::rule<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> >, nihstro::Expression(), AssemblySkipper<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> > >, boost::spirit::unused_type, boost::spirit::unused_type> >, boost::fusion::cons<boost::spirit::qi::literal_char<boost::spirit::char_encoding::standard, true, false>, boost::fusion::cons<boost::spirit::qi::reference<const boost::spirit::qi::rule<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> >, nihstro::Expression(), AssemblySkipper<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> > >, boost::spirit::unused_type, boost::spirit::unused_type> >, boost::fusion::nil_> > > >, mpl_::bool_<false> >; R = bool; T0 = __gnu_cxx::__normal_iterator<char*, std::basic_string<char> >&; T1 = const __gnu_cxx::__normal_iterator<char*, std::basic_string<char> >&; T2 = boost::spirit::context<boost::fusion::cons<std::vector<nihstro::Expression>&, boost::fusion::nil_>, boost::fusion::vector0<> >&; T3 = const boost::spirit::qi::reference<const boost::spirit::qi::rule<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> >, boost::spirit::unused_type, boost::spirit::unused_type, boost::spirit::unused_type, boost::spirit::unused_type> >&; typename boost::enable_if_c<boost::type_traits::ice_not<boost::is_integral<Functor>::value>::value, int>::type = int]’
/usr/include/boost/function/function_template.hpp:1132:5:   required from ‘typename boost::enable_if_c<boost::type_traits::ice_not<boost::is_integral<Functor>::value>::value, boost::function<R(T0, T1, T2, T3)>&>::type boost::function<R(T0, T1, T2, T3)>::operator=(Functor) [with Functor = boost::spirit::qi::detail::parser_binder<boost::spirit::qi::expect<boost::fusion::cons<boost::spirit::qi::reference<const boost::spirit::qi::rule<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> >, nihstro::Expression(), AssemblySkipper<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> > >, boost::spirit::unused_type, boost::spirit::unused_type> >, boost::fusion::cons<boost::spirit::qi::literal_char<boost::spirit::char_encoding::standard, true, false>, boost::fusion::cons<boost::spirit::qi::reference<const boost::spirit::qi::rule<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> >, nihstro::Expression(), AssemblySkipper<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> > >, boost::spirit::unused_type, boost::spirit::unused_type> >, boost::fusion::nil_> > > >, mpl_::bool_<false> >; R = bool; T0 = __gnu_cxx::__normal_iterator<char*, std::basic_string<char> >&; T1 = const __gnu_cxx::__normal_iterator<char*, std::basic_string<char> >&; T2 = boost::spirit::context<boost::fusion::cons<std::vector<nihstro::Expression>&, boost::fusion::nil_>, boost::fusion::vector0<> >&; T3 = const boost::spirit::qi::reference<const boost::spirit::qi::rule<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> >, boost::spirit::unused_type, boost::spirit::unused_type, boost::spirit::unused_type, boost::spirit::unused_type> >&; typename boost::enable_if_c<boost::type_traits::ice_not<boost::is_integral<Functor>::value>::value, boost::function<R(T0, T1, T2, T3)>&>::type = boost::function<bool(__gnu_cxx::__normal_iterator<char*, std::basic_string<char> >&, const __gnu_cxx::__normal_iterator<char*, std::basic_string<char> >&, boost::spirit::context<boost::fusion::cons<std::vector<nihstro::Expression>&, boost::fusion::nil_>, boost::fusion::vector0<> >&, const boost::spirit::qi::reference<const boost::spirit::qi::rule<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> >, boost::spirit::unused_type, boost::spirit::unused_type, boost::spirit::unused_type, boost::spirit::unused_type> >&)>&]’
/usr/include/boost/spirit/home/qi/nonterminal/rule.hpp:183:19:   required from ‘static void boost::spirit::qi::rule<Iterator, T1, T2, T3, T4>::define(boost::spirit::qi::rule<Iterator, T1, T2, T3, T4>&, const Expr&, mpl_::true_) [with Auto = mpl_::bool_<false>; Expr = boost::proto::exprns_::expr<boost::proto::tagns_::tag::greater, boost::proto::argsns_::list2<const boost::proto::exprns_::expr<boost::proto::tagns_::tag::greater, boost::proto::argsns_::list2<boost::spirit::qi::rule<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> >, nihstro::Expression(), AssemblySkipper<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> > >, boost::spirit::unused_type, boost::spirit::unused_type>&, boost::proto::exprns_::expr<boost::proto::tagns_::tag::terminal, boost::proto::argsns_::term<boost::spirit::terminal_ex<boost::spirit::tag::lit, boost::fusion::vector1<char> > >, 0l>&>, 2l>&, boost::spirit::qi::rule<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> >, nihstro::Expression(), AssemblySkipper<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> > >, boost::spirit::unused_type, boost::spirit::unused_type>&>, 2l>; Iterator = __gnu_cxx::__normal_iterator<char*, std::basic_string<char> >; T1 = std::vector<nihstro::Expression>(); T2 = AssemblySkipper<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> > >; T3 = boost::spirit::unused_type; T4 = boost::spirit::unused_type; mpl_::true_ = mpl_::bool_<true>]’
/usr/include/boost/spirit/home/qi/nonterminal/rule.hpp:221:19:   required from ‘boost::spirit::qi::rule<Iterator, T1, T2, T3, T4>& boost::spirit::qi::rule<Iterator, T1, T2, T3, T4>::operator=(const Expr&) [with Expr = boost::proto::exprns_::expr<boost::proto::tagns_::tag::greater, boost::proto::argsns_::list2<const boost::proto::exprns_::expr<boost::proto::tagns_::tag::greater, boost::proto::argsns_::list2<boost::spirit::qi::rule<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> >, nihstro::Expression(), AssemblySkipper<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> > >, boost::spirit::unused_type, boost::spirit::unused_type>&, boost::proto::exprns_::expr<boost::proto::tagns_::tag::terminal, boost::proto::argsns_::term<boost::spirit::terminal_ex<boost::spirit::tag::lit, boost::fusion::vector1<char> > >, 0l>&>, 2l>&, boost::spirit::qi::rule<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> >, nihstro::Expression(), AssemblySkipper<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> > >, boost::spirit::unused_type, boost::spirit::unused_type>&>, 2l>; Iterator = __gnu_cxx::__normal_iterator<char*, std::basic_string<char> >; T1 = std::vector<nihstro::Expression>(); T2 = AssemblySkipper<__gnu_cxx::__normal_iterator<char*, std::basic_string<char> > >; T3 = boost::spirit::unused_type; T4 = boost::spirit::unused_type]’
/home/thomas/dev/3ds/nihstro/src/parser_assembly.cpp:448:25:   required from ‘CompareParser<Iterator>::CompareParser(const nihstro::ParserContext&) [with Iterator = __gnu_cxx::__normal_iterator<char*, std::basic_string<char> >]’
/home/thomas/dev/3ds/nihstro/src/parser_assembly.cpp:697:67:   required from here
/usr/include/boost/fusion/container/vector/detail/preprocessed/vector10.hpp:205:9: note: constexpr boost::fusion::vector_data2<T0, T1>::vector_data2() [with T0 = boost::optional<int>; T1 = std::basic_string<char>]
         vector_data2()
         ^
/usr/include/boost/fusion/container/vector/detail/preprocessed/vector10.hpp:205:9: note:   candidate expects 0 arguments, 2 provided
make[2]: *** [CMakeFiles/nihstro-assemble.dir/src/parser_assembly.cpp.o] Error 1
make[1]: *** [CMakeFiles/nihstro-assemble.dir/all] Error 2
make: *** [all] Error 2

Crash when trying to assemble invalid code

As reported by fincs on #3dsdev. Trying to assemble https://github.com/smealum/3dscraft/blob/master/data/test.vsh just outright crashes the assembler.

E.g. nihstro-assemble test.shbin test.vsh => crash.

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.