Boost spirit x3: erro de tempo de compilação de atributo composto (classe enum)
Recentemente, eu estava escrevendo um analisador mais simples possível usando boost spirit x3 . Ele contém 2 regras: identificador e um operador de caractere único . Naturalmente, implementei o operador usando uma tabela de símbolos, que produz um tipo de operador enum class
. Os identificadores são analisados como std::string
s. No entanto, o código se recusa a compilar ao combinar identificadores e operadores em um único analisador (consulte a parte do código no final da pergunta).
Observe que, se você alterar o tipo de operador enum com um número inteiro, tudo funcionará bem. Operadores e identificadores são bem analisados quando separados também.
A mensagem de erro do modelo é muito grande para ser anexada e obscura demais para que eu entenda, mas suspeito que tenha algo a ver com a semântica de construção / movimentação de std::variant<std::string, OperType>
. No entanto, enum class
não deve ser drasticamente diferente da planície int
. Tem algo a ver com enum class
o construtor padrão? Como isso pode ser contornado?
Aqui está o codepiece
#include <variant>
#include <string>
#include <boost/spirit/home/x3.hpp>
namespace x3 = boost::spirit::x3;
auto addCharacter = [](auto &context) {
x3::_val(context).push_back(x3::_attr(context));
};
x3::rule<class IdentifierTag, std::string> identifier{"identifier"};
const auto identifier_def = x3::lexeme[x3::char_("a-zA-Z")[addCharacter] >> *(x3::char_("a-zA-Z0-9")[addCharacter])];
BOOST_SPIRIT_DEFINE(identifier);
enum class OperType
{
plus,
minus
};
struct Opers_ : x3::symbols<OperType>
{
Opers_()
{
add("+", OperType::plus)("-", OperType::minus);
}
} opers_;
x3::rule<class OperTypeTag, OperType> oper{"operator"};
const auto oper_def = x3::lexeme[opers_];
BOOST_SPIRIT_DEFINE(oper);
int main()
{
std::string input{"iden1 + - iden2"};
std::vector<std::variant<std::string, OperType>> tokens;
auto start = input.cbegin();
auto result = x3::phrase_parse(start, input.cend(), (+(identifier | oper)), x3::space, tokens);
return 0;
}
Existem armadilhas ao escrever analisadores compostos? o que estou perdendo? Obrigado pelo seu tempo.
Respostas
std::variant
ainda não tem suporte para compatibilidade de atributos.
Mudar para boost::variant
faz com que seja compilado: Compiler Explorer
Como alternativa, aqui estão maneiras de fazê-lo realmente funcionar se você precisar de std :: variant: Transitioning Boost Spirit parser de boost :: variant para std :: variant
#include <boost/spirit/home/x3.hpp>
#include <variant>
#include <fmt/ranges.h>
#include <fmt/ostream.h>
namespace x3 = boost::spirit::x3;
auto addCharacter = [](auto& context) {
x3::_val(context).push_back(x3::_attr(context));
};
x3::rule<class IdentifierTag, std::string> identifier{"identifier"};
const auto identifier_def =
x3::lexeme[x3::char_("a-zA-Z")[addCharacter] >> *(x3::char_("a-zA-Z0-9")[addCharacter])];
BOOST_SPIRIT_DEFINE(identifier)
enum class OperType
{
plus,
minus
};
static inline std::ostream& operator<<(std::ostream& os, OperType ot) {
switch(ot) {
case OperType::plus: return os << "plus";
case OperType::minus: return os << "minus";
}
return os << "?";
}
struct Opers_ : x3::symbols<OperType>
{
Opers_()
{
add("+", OperType::plus)
("-", OperType::minus);
}
} opers_;
x3::rule<class OperTypeTag, OperType> oper{"operator"};
const auto oper_def = x3::lexeme[opers_];
BOOST_SPIRIT_DEFINE(oper)
int main() {
std::string const input{"iden1 + - iden2"};
std::vector<boost::variant<std::string, OperType>> tokens;
auto f = input.begin(), l = input.end();
auto result = x3::phrase_parse(
f, l,
+(identifier | oper),
x3::space,
tokens);
if (result) {
fmt::print("Parsed: {}\n", tokens);
} else {
fmt::print("Parse failed\n");
}
if (f!=l) {
fmt::print("Remaining: '{}'\n", std::string(f,l));
}
}
Impressões
Parsed: {iden1, plus, minus, iden2}