Estou tentando usar o Spirit para analisar expressões da formaModule1.Module2.value (qualquer número de identificadores em maiúsculas separados por pontos, depois um ponto e, em seguida, um identificador em estilo OCaml em minúsculas). Minha definição atual do analisador é assim:

using namespace boost::spirit::qi;

template <typename Iter=std::string::iterator>
struct value_path : grammar<Iter, boost::tuple<std::vector<std::string>, std::string>()> {
    value_path() :
        value_path::base_type(start)
    {
        start = -(module_path<Iter>() >> '.') >> value_name<Iter>();
    }
    rule<Iter, boost::tuple<std::vector<std::string>, std::string>()> start;
};

Ondemodule_path evalue_name são estruturas de modelo semelhantes herdadas deqi::grammar com solteirostart campo atribuído a alguma regra de espírito, possivelmente usando outras gramáticas personalizadas (por exemplo,value_name depende delowercase_ident eoperator_name que são definidos analogamente) no construtor.

Ao tentarparse_phrase() com esta gramática, o programa é segmentado em algum lugar nas partes internas do Espírito (de acordo com o gdb). A definição equivalente, em que o construtor devalue_path é o seguinte (basicamente desenrolei todas as gramáticas personalizadas de que depende, deixando apenas analisadores de espírito incorporados e tentei torná-lo legível, o que, em retrospectiva, era uma tarefa tola):

start =
-((raw[upper >> *(alnum | char_('_') | char_('\''))] % '.') >> '.')
>> lexeme[((lower | char_('_')) >> *(alnum | char_('_') | char_('\'')))
         | char_('(') >>
             ( ( (char_('!') >> *char_("-+!$%&*./:<=>?@^|~")
                 | (char_("~?") >> +char_("-+!$%&*./:<=>?@^|~"))
                 | ( (char_("-+=<>@^|&*/$%") >> *char_("-+!$%&*./:<=>?@^|~"))
                   | string("mod")
                   | string("lor")
                   | string("lsl")
                   | string("lsr")
                   | string("asr")
                   | string("or")
                   | string("-.")
                   | string("!=")
                   | string("||")
                   | string("&&")
                   | string(":=")
                   | char_("*+=<>&-")
                   )
                 ) >> char_(')')
               )
             )
         ];

não segfault e parece funcionar corretamente, no entanto, prefiro evitar algo tão detalhado e ilegível no meu código. Também não é extensível.

Até agora, eu tentei várias combinações de.alias(), além de salvarvalue_name<Iter>(), module_path<Iter>() e todas as gramáticas intermediárias ao longo da cadeia de dependência em seus próprios campos. Nenhum deles funcionou. Como posso manter o alto nível de abstração do primeiro exemplo? Existe uma maneira padrão de compor gramáticas no Spirit que não tenha problemas?