boost spiritを使用しているときの内部コンパイルエラーx12

Question

現在、boost spirit X3を使用して、DSLの式と演算子階層を実装しています。

私のパーサは意味が正しいと思うが、コンパイル中にgccとclangが大量のメモリフットプリントを持ってコンパイルしようとすると、無限にコンパイルされ、 "g ++：内部コンパイラエラー：殺された（プログラムcc1plus） "

私は表現パーサーarroundのコードを最小化しようとしましたが、その何とかその些細なことではない

Hereはデモです。

誰かが私がここで間違っていることを教えてもらえますか、これはバグですか？

EDIT： 私は問題がsomwhereあると思う：私は(idx|func)に(idx|func|data)を変更した場合、それも永遠にコンパイルされ、ラムの16ギガバイトまで使用していますが、gccはそれをコンパイルすることができます

auto const idx = as<ast::Operation>(helper::idxaccess_op > expression > ']'); 
auto const func = as<ast::Operation>(helper::func_call_op > expression%',' > ')'); 
auto const data = as<ast::Operation>(helper::access_op > expression); 

auto const func_call_expr_def = 
    primary_expr >> *(idx|func|data); 

、およびパーサはどのように動作するはずです。

EDIT II：上記のリンクをご覧ください。エラーの原因となる例があります。

Answer 1

私はソースファイルの上にたくさんの変更を加えました。

1. はASTを変更：変更があるhttp://melpon.org/wandbox/permlink/sY2CQkXiMiLoS1BM

   にあるものを確認してください。それは正しいとは思わなかった。主にバリアントに「単項」を追加する部分。

2. 文法を修正しました。これは私が実際にあなたのテストから文法を作ることができるものに基づいています。私は間違っているかもしれません、私は最初のテストケースを動作させるように試みました。より良い

特に「parser.hpp」で、あなたに対する私の変化を比較するための差分ツールを実行します。注：私の変更はあなたの要件に従って正しくない場合は、私はデバッグを有効にするために、あなたをお勧めします「BOOST_SPIRIT_X3_DEBUG」とそれをトレースします。そのような場合BOOST_SPIRIT_X3_DEBUGがどれくらい役に立つかを十分に強調することはできません。

parser.hpp

#include <boost/spirit/home/x3.hpp> 
#include "ast.hpp" 
#include "operators.hpp" 
namespace parser{ 
    namespace x3 = boost::spirit::x3; 


    template<typename T> 
    auto as = [](auto p) { return x3::rule<struct _, T>{} = as_parser(p); }; 


    typedef x3::rule<struct multiplicative_expr_class, ast::Expression> multiplicative_expr_type; 
    typedef x3::rule<struct expression_class, ast::Expression> expression_type; 
    typedef x3::rule<struct primary_expr_class, ast::Operand> primary_expr_type; 
    typedef x3::rule<struct func_call_call_class, ast::Expression> func_call_expr_type; 
    typedef x3::rule<struct unary_expr_class, ast::Operand> unary_expr_type; 



    const primary_expr_type primary_expr = "primary_expr";  
    const func_call_expr_type func_call_expr = "func_call_expr"; 
    const expression_type expression = "expression"; 
    const multiplicative_expr_type multiplicative_expr = "multiplicative_expr"; 
    const unary_expr_type unary_expr = "unary_expr"; 


    auto const primary_expr_def = 
     +(x3::alpha | x3::char_('.')) 
     | ("(" > expression > ")"); 

    auto const idx = as<ast::Operation>(helper::idxaccess_op > primary_expr > ']'); 
    auto const func = as<ast::Operation>(helper::func_call_op > primary_expr%',' > ')'); 
    auto const data = as<ast::Operation>(helper::access_op > expression); 

    auto const func_call_expr_def = 
     primary_expr >> *(idx | func | data); 

    auto const unary_expr_def = 
       func_call_expr 
         | as<ast::Operation>(helper::unary_op > func_call_expr); 

    auto const multiplicative_expr_def = 
     primary_expr >> *(idx | func); 

    auto const expression_def = multiplicative_expr_def; 


BOOST_SPIRIT_DEFINE(primary_expr, 
        func_call_expr, 
        multiplicative_expr, 
        unary_expr, 
        expression); 

} 

ast.hpp

#include <boost/spirit/home/x3.hpp> 
#include <boost/spirit/home/x3/support/ast/variant.hpp> 
#include <boost/fusion/include/adapt_struct.hpp> 

#include <vector> 

namespace ast{ 
    namespace x3 = boost::spirit::x3; 

    enum class operator_t 
    { 
     _eq_,  // == 
     _ne_,  // != 
     _lt_,  // < 
     _gt_,  // > 
     _le_,  // <= 
     _ge_,  // >= 
     _add_,  // + 
     _sub_,  // - 
     _mul_,  // * 
     _div_,  ///
     _mod_,  // % 
     _pos_,  // unary + 
     _neg_,  // unary - 
     _not_,  // unary ! 
     _size_,  // unary # 
     _bitnot_, // unary ~ 
     _bitand_, // & 
     _bitor_, // | 
     _bitxor_, //^
     _shl_,  // << 
     _shr_,  // >> 
     _and_,  // && 
     _or_,  // || 
     _idx_,  // [] 
     _apply_, //() 
     _access_ // . 
    }; 

    struct nil{}; 
    struct Expression; 

    typedef x3::variant< 
      nil, 
      std::string, 
      x3::forward_ast<Expression> 
      //std::vector<Expression> //adding this as an operand for function parameter 
    > Operand; 

    struct Operation { 
     operator_t operator_; 
     Operand operand_; 
    }; 

    struct Expression { 
     Operand first_; 
     std::vector<Operation> rest_; 
    }; 
} 
BOOST_FUSION_ADAPT_STRUCT(ast::Operation, operator_, operand_) 
BOOST_FUSION_ADAPT_STRUCT(ast::Expression, first_, rest_) 

Answer 2

問題はテンプレートのインスタンスの深さとは何かを持っています。 internal compiler errorを避け、受け入れ可能なコンパイル時間を得るために、私のパーサーでは、カスタムのパーサとして実装されたテンプレートファイアウォールのようなものを実装しなければなりませんでした。このコードexpression_implで

struct OptimizedExpressionParser : x3::parser<OptimizedExpressionParser> { 
    using attribute_type = ast::Expression; 
    static bool const has_attribute = true; 

    //parse fnction, which calls "non-templated"-firewall function 
    template <typename Iter, typename Ctx, typename Attribute> 
    bool parse(Iter& iFirst, const Iter& iLast, const Ctx& iCtx, x3::unused_type, Attribute& oAttr) const { 
     ast::Expression a; 
     return parse(iFirst, iLast, iCtx, x3::unused, a); 
    } 

    //parse fnction, which calls "non-templated"-firewall function 
    template <typename Iter, typename Ctx> 
    bool parse(Iter& iFirst, const Iter& iLast, const Ctx& iCtx, x3::unused_type, ast::Expression& oAttr) const { 
     if (iFirst != iLast) { 
     return parse_expression(iFirst, iLast, oAttr); 
     } 
     return false; 
    } 
    private: 

    //"non-template"- parse function 
    //of cause this is a template function, but the parser isnt a template argument 
    template <typename Iter> 
    bool parse_expression(Iter& iFirst, const Iter& iLast, ast::Expression& oAst) const { 
     return x3::parse(iFirst, iLast, expression_impl, oAst); 

    } 
    }; 

新しい式パーサーを「ファイアウォール」古い「重い」表現パーサ、 はこのです：私は別で式を使用したいところはどこでも

auto const expression = OptimizedExpressionParser{};

パーサー、または解析用に私はOptimizedExpressionParserパーサーのexpressionオブジェクトを使用します。 この減少のRAM使用量、compiletimesも、これは私の例でhave a look here.

正直に言うと、私が解決したことがないだろうアウトどのように動作するかを確認するには （テンプレートファイアウォールなしで約1.6 GBのだった）結果のバイナリのサイズ私自身のこの問題、アイデア、そしてコードの大部分はhereから来ています。私は与えられた例でうまくいくように少し変更しました。