为什么编译器在这里错过矢量化？

Question

llm

Asked: 2024-10-10 23:15:53 +0800 CST2024-10-10 23:15:53 +0800 CST 2024-10-10 23:15:53 +0800 CST

是否可以获取已解析的字符串？

772

我得到了一个基于 Spirit 的工作解析器+AST，它可以解析参数初始化 - 一切正常

遗憾的是，有些（旧）数据库需要 AST 的部分内容作为原始字符串（我正在准备替换它，但想逐步进行更改）

（简单化）示例：a=10,b=30,c=A *B +10,d={1,A*4,3}*4

KeyValue-Rule = Identifier >> '=' >> Number|Expression

表达式是一个完整的 Sub-AST，带有 +-* 和数字（在这个简单的例子中）

std::vector<KeyValue> Parameters;

数据库希望将参数的“值”作为字符串c-A *B +10最好是精确的字符串（带有空格等）

这是 Spirit 可以保留的东西吗（或者开始/结束位置）？

上面的例子是我真正的解析器/AST的一个超级简化版本，表达式可以通过()等进行深度分级 - 所以它不是简单的按,事物分割 - 只是为了解释我试图达到的目的

类似： https: //astexplorer.net/ - 我需要字符串中逻辑 AST 部分的起点/终点

1 个回答

Voted

sehe · Answer 1 · 2024-10-11T02:26:15+08:00

是的。您可以使用语义动作：

KeyValue-Rule = raw [ (Identifier >> '=' >> Number|Expression)[assign_ast] ][assign_raw_input_sequence];

您可以将自动属性传播与语义动作结合使用，使用%=规则初始化而不是常规=分配。

您还可以使用on_success“错误”处理程序来自动化操作。请参阅我以前的回答中的一些示例：https://stackoverflow.com/search ?q=user%3A85371+qi+on_success

想象一个语法

想出最简单的没有一元运算符或运算符优先级的语法：

在 Coliru 上直播

// #define BOOST_SPIRIT_DEBUG
#include <boost/fusion/include/io.hpp>
#include <boost/phoenix.hpp>
#include <boost/spirit/include/qi.hpp>
#include <iomanip>
namespace qi = boost::spirit::qi;

// simple expression AST
namespace Ast {
    using Number     = double;
    using Variable   = std::string;
    using SimpleExpr = boost::variant<Number, Variable>;

    struct BinaryOp;
    struct Expr;
    using ExprV = boost::variant<SimpleExpr, boost::recursive_wrapper<BinaryOp>>;

    struct Expr : ExprV {
        using ExprV::ExprV;
        using ExprV::operator=;
    };

    struct BinaryOp {
        char op;
        Expr left, right;
    };

    using boost::fusion::operator<<;
} // namespace Ast

BOOST_FUSION_ADAPT_STRUCT(Ast::BinaryOp, left, op, right)

// simple expression grammar
template <typename It> struct SimpleExprGrammar : qi::grammar<It, Ast::Expr()> {
    SimpleExprGrammar() : SimpleExprGrammar::base_type(start) {
        using namespace qi;

        start   = skip(space)[expr_ >> eoi];

        binary_ = simple_ >> char_("+*/-") >> expr_;
        expr_   = binary_ | simple_;
        simple_ = double_ | var_ | ('(' >> expr_ >> ')');
        var_    = +alpha;

        BOOST_SPIRIT_DEBUG_NODES((expr_)(binary_)(binary_)(simple_)(var_))
    }

  private:
    qi::rule<It, Ast::Expr()> start;
    using Skipper = qi::space_type;
    qi::rule<It, Ast::Expr(), Skipper>     expr_;
    qi::rule<It, Ast::Expr(), Skipper>     simple_;
    qi::rule<It, Ast::BinaryOp(), Skipper> binary_;
    // lexemes
    qi::rule<It, Ast::Variable()>   var_;
};

int main() {
    SimpleExprGrammar<std::string_view::const_iterator> const p;

    for (std::string_view input : {
             "1 + 2",
             "1 + 2 * 3",
             "(1 + 2) * 3",
             "1 + 2 * (3 + 4)",
             "1 + 2 * (3 + 4) / 5",
             "1 + 2 * (3 + 4) / 5 - 6",
         }) {
        std::cout << " -- Parsing: " << quoted(input) << "\n";
        auto f = begin(input), l = end(input);

        if (Ast::Expr expr; qi::parse(f, l, p, expr))
            std::cout << "   -> " << expr << "\n";
        else
            std::cout << "   FAILED\n";
    }
}

印刷

 -- Parsing: "1 + 2"
   -> (1 + 2)
 -- Parsing: "1 + 2 * 3"
   -> (1 + (2 * 3))
 -- Parsing: "(1 + 2) * 3"
   -> ((1 + 2) * 3)
 -- Parsing: "1 + 2 * (3 + 4)"
   -> (1 + (2 * (3 + 4)))
 -- Parsing: "1 + 2 * (3 + 4) / 5"
   -> (1 + (2 * ((3 + 4) / 5)))
 -- Parsing: "1 + 2 * (3 + 4) / 5 - 6"
   -> (1 + (2 * ((3 + 4) / (5 - 6))))

添加源注释

延长Expr：

struct Expr : ExprV {
    using ExprV::ExprV;
    using ExprV::operator=;

    std::string_view source;

    ExprV&       base() { return *this; }
    ExprV const& base() const { return *this; }
};

source将包含我们的源。制作一个语义动作来从原始输入迭代器设置源：

phx::function source_ = [](Ast::Expr& ast, std::string_view sv) { ast.source = sv; };
auto set_raw_         = source_(_val, phx::construct<std::string_view>(phx::begin(_1), phx::end(_1)));

在应该传播已解析的 Ast 和源的规则中散布语义动作：

    expr_   = raw[(binary_[_val = _1] | simple_[_val = _1])][set_raw_];
    simple_ = raw[                         //
        double_[_val = _1]                 //
        | var_[_val = _1]                  //
        | ('(' >> expr_ >> ')')[_val = _1] //
    ][set_raw_];

作为奖励，添加AnnoatedPrint访客：

struct AnnotatedPrint {
    std::ostream&    os_;
    std::string_view input;
    std::string      indent = "";

    template <typename T> void operator()(T const& v) const { apply(v); }

  private:
    void apply(Ast::Expr const& e) const {
        std::cout << indent << "Source: " << quoted(e.source) << "\n";
        AnnotatedPrint{os_, input, indent + "  "}(e.base());
    }

    template <typename... Ts> void apply(boost::variant<Ts...> const& v) const {
        boost::apply_visitor(*this, v);
    }

    void apply(Ast::Number const& e) const { std::cout << indent << "Number: " << e << "\n"; }
    void apply(Ast::Variable const& e) const { std::cout << indent << "Variable: " << e << "\n"; }
    void apply(Ast::BinaryOp const& e) const {
        std::cout << indent << "BinaryOp: " << e.op << "\n";
        AnnotatedPrint{os_, input, indent + "  "}(e.left);
        AnnotatedPrint{os_, input, indent + "  "}(e.right);
    }
};

现在输出变为Live On Coliru

 -- Parsing: "1 + 2"
   -> (1 + 2)
 -- AST: Source: "1 + 2"
 -- AST:   BinaryOp: +
 -- AST:     Source: "1"
 -- AST:       Number: 1
 -- AST:     Source: "2"
 -- AST:       Number: 2
 -- Parsing: "1 + 2 * 3"
   -> (1 + (2 * 3))
 -- AST: Source: "1 + 2 * 3"
 -- AST:   BinaryOp: +
 -- AST:     Source: "1"
 -- AST:       Number: 1
 -- AST:     Source: "2 * 3"
 -- AST:       BinaryOp: *
 -- AST:         Source: "2"
 -- AST:           Number: 2
 -- AST:         Source: "3"
 -- AST:           Number: 3
 -- Parsing: "(1 + 2) * 3"
   -> ((1 + 2) * 3)
 -- AST: Source: "(1 + 2) * 3"
 -- AST:   BinaryOp: *
 -- AST:     Source: "(1 + 2)"
 -- AST:       BinaryOp: +
 -- AST:         Source: "1"
 -- AST:           Number: 1
 -- AST:         Source: "2"
 -- AST:           Number: 2
 -- AST:     Source: "3"
 -- AST:       Number: 3
 -- Parsing: "1 + 2 * (3 + 4)"
   -> (1 + (2 * (3 + 4)))
 -- AST: Source: "1 + 2 * (3 + 4)"
 -- AST:   BinaryOp: +
 -- AST:     Source: "1"
 -- AST:       Number: 1
 -- AST:     Source: "2 * (3 + 4)"
 -- AST:       BinaryOp: *
 -- AST:         Source: "2"
 -- AST:           Number: 2
 -- AST:         Source: "(3 + 4)"
 -- AST:           BinaryOp: +
 -- AST:             Source: "3"
 -- AST:               Number: 3
 -- AST:             Source: "4"
 -- AST:               Number: 4
 -- Parsing: "1 + 2 * (3 + 4) / 5"
   -> (1 + (2 * ((3 + 4) / 5)))
 -- AST: Source: "1 + 2 * (3 + 4) / 5"
 -- AST:   BinaryOp: +
 -- AST:     Source: "1"
 -- AST:       Number: 1
 -- AST:     Source: "2 * (3 + 4) / 5"
 -- AST:       BinaryOp: *
 -- AST:         Source: "2"
 -- AST:           Number: 2
 -- AST:         Source: "(3 + 4) / 5"
 -- AST:           BinaryOp: /
 -- AST:             Source: "(3 + 4)"
 -- AST:               BinaryOp: +
 -- AST:                 Source: "3"
 -- AST:                   Number: 3
 -- AST:                 Source: "4"
 -- AST:                   Number: 4
 -- AST:             Source: "5"
 -- AST:               Number: 5
 -- Parsing: "1 + 2 * (3 + 4) / 5 - 6"
   -> (1 + (2 * ((3 + 4) / (5 - 6))))
 -- AST: Source: "1 + 2 * (3 + 4) / 5 - 6"
 -- AST:   BinaryOp: +
 -- AST:     Source: "1"
 -- AST:       Number: 1
 -- AST:     Source: "2 * (3 + 4) / 5 - 6"
 -- AST:       BinaryOp: *
 -- AST:         Source: "2"
 -- AST:           Number: 2
 -- AST:         Source: "(3 + 4) / 5 - 6"
 -- AST:           BinaryOp: /
 -- AST:             Source: "(3 + 4)"
 -- AST:               BinaryOp: +
 -- AST:                 Source: "3"
 -- AST:                   Number: 3
 -- AST:                 Source: "4"
 -- AST:                   Number: 4
 -- AST:             Source: "5 - 6"
 -- AST:               BinaryOp: -
 -- AST:                 Source: "5"
 -- AST:                   Number: 5
 -- AST:                 Source: "6"
 -- AST:                   Number: 6

将其融入问题中

无需进一步评论：

在 Coliru 上直播

// #define BOOST_SPIRIT_DEBUG
#include <boost/fusion/include/adapted.hpp>
#include <boost/fusion/include/io.hpp>
#include <boost/phoenix.hpp>
#include <boost/spirit/include/qi.hpp>
#include <iomanip>
namespace qi  = boost::spirit::qi;
namespace phx = boost::phoenix;

// simple expression AST
namespace Ast {
    using Number     = double;
    using Variable   = std::string;
    using SimpleExpr = boost::variant<Number, Variable>;

    struct BinaryOp;
    struct Expr;
    using ExprV = boost::variant<SimpleExpr, boost::recursive_wrapper<BinaryOp>>;

    struct Expr : ExprV {
        using ExprV::ExprV;
        using ExprV::operator=;

        std::string_view source;

        ExprV&       base() { return *this; }
        ExprV const& base() const { return *this; }
    };

    struct BinaryOp {
        char op;
        Expr left, right;
    };

    using Def  = std::pair<Variable, Expr>;
    using Defs = std::map<Variable, Expr>;

    using boost::fusion::operator<<;
} // namespace Ast

BOOST_FUSION_ADAPT_STRUCT(Ast::BinaryOp, left, op, right)

// simple expression grammar
template <typename It> struct DefParser : qi::grammar<It, Ast::Defs()> {
    DefParser() : DefParser::base_type(start) {
        using namespace qi;

        phx::function source_ = [](Ast::Expr& ast, std::string_view sv) { ast.source = sv; };
        auto set_raw_         = source_(_val, phx::construct<std::string_view>(phx::begin(_1), phx::end(_1)));

        start   = skip(space)[defs_ >> eoi];
        defs_   = def_ % ',';
        def_    = var_ >> '=' >> expr_;
        binary_ = simple_ >> char_("+*/-") >> expr_;
        expr_   = raw[(binary_[_val = _1] | simple_[_val = _1])][set_raw_];
        simple_ = raw[                         //
            double_[_val = _1]                 //
            | var_[_val = _1]                  //
            | ('(' >> expr_ >> ')')[_val = _1] //
        ][set_raw_];
        var_    = +alpha;

        BOOST_SPIRIT_DEBUG_NODES((expr_)(binary_)(binary_)(simple_)(var_)(def_)(defs_))
    }

  private:
    qi::rule<It, Ast::Defs()> start;
    using Skipper = qi::space_type;
    qi::rule<It, Ast::Def(), Skipper>      def_;
    qi::rule<It, Ast::Defs(), Skipper>     defs_;
    qi::rule<It, Ast::Expr(), Skipper>     expr_;
    qi::rule<It, Ast::Expr(), Skipper>     simple_;
    qi::rule<It, Ast::BinaryOp(), Skipper> binary_;
    // lexemes
    qi::rule<It, Ast::Variable()>   var_;
};

int main() {
    using It = std::string_view::const_iterator;
    DefParser<It> const p;

    std::string_view input = "a=10,b=30,c=A *B +10,  PI = TAU / (((2)))";

    auto f = begin(input), l = end(input);
    if (Ast::Defs defs; qi::parse(f, l, p, defs)) {
        for (auto const& [v, e] : defs) {
            std::cout << "   -> " << v << " = " << e << "\n";
            auto pos = e.source.begin() - input.begin();
            std::cout << "Input: " << input << "\n";
            auto n = e.source.size() - 1;
            std::cout << "       " << std::setw(pos) << "" << "^" << std::string(n, '-') << "\n";
        }
    } else {
        std::cout << "FAILED\n";
    }
}

印刷

   -> PI = (TAU / 2)
Input: a=10,b=30,c=A *B +10,  PI = TAU / (((2)))
                                   ^------------
   -> a = 10
Input: a=10,b=30,c=A *B +10,  PI = TAU / (((2)))
         ^-
   -> b = 30
Input: a=10,b=30,c=A *B +10,  PI = TAU / (((2)))
              ^-
   -> c = (A * (B + 10))
Input: a=10,b=30,c=A *B +10,  PI = TAU / (((2)))
                   ^-------

是否可以获取已解析的字符串？

想象一个语法

添加源注释

将其融入问题中

`(表达式，左值) = 右值` 在 C 或 C++ 中是有效的赋值吗？为什么有些编译器会接受/拒绝它？

何时应使用 std::inplace_vector 而不是 std::vector？

在 C++ 中，一个不执行任何操作的空程序需要 204KB 的堆，但在 C 中则不需要

如果 T 既不可构造、不可复制、也不可移动，那么我可以拥有 std::optional<T> 吗？

为什么我可以定义一个 constinit 的 std::string 实例？如果对象需要动态初始化，constinit 不是被禁止的吗？

如何分配以后放置的新“如同新”

PowerBI 目前与 BigQuery 不兼容：Simba 驱动程序与 Windows 更新有关

将 NULL 和 nullptr 传递给模板参数有什么区别？

AdMob：MobileAds.initialize() - 对于某些设备，“java.lang.Integer 无法转换为 java.lang.String”

我正在尝试仅使用海龟随机和数学模块来制作吃豆人游戏

是否可以获取已解析的字符串？

1 个回答

想象一个语法

添加源注释

将其融入问题中

相关问题