交叉递归规则的声明

时间：2015-03-14 19:59:07

标签： c++ recursion static boost-spirit forward-declaration

我将语法规则声明为静态const。这很好，直到我尝试使用交叉递归规则（ rule1 使用 rule2 定义，使用 rule1 定义）。源代码仍然可以构建，但是解析包含这种交叉递归情况的源代码的段错误。 这是一个简化的语法代码：

template < typename Iterator >
class Skipper : public qi::grammar<Iterator> {
public:
    Skipper ( ) : Skipper::base_type(_skip_rule) { }
private:
    static qi::rule<Iterator> const
        _comment,
        _skip_rule;
};

template < typename Iterator >
typename qi::rule<Iterator> const
    Skipper<Iterator>::_comment(
        boost::spirit::repository::confix("/*", "*/")[*(qi::char_ - "*/")]          // Multi-line
        | boost::spirit::repository::confix("//", qi::eol)[*(qi::char_ - qi::eol)]   // Single-line
    );

template < typename Iterator >
typename qi::rule<Iterator> const
     Skipper<Iterator>::_skip_rule(qi::ascii::space | _comment);

template < typename Iterator, typename Skipper >
class Grammar : public qi::grammar<Iterator, Skipper > {
public:
    Grammar ( ) : Grammar::base_type(expression) { }
private:
    static qi::rule<Iterator, Skipper> const
        // Tokens
        scalar_literal,
        identifier,
        // Rules
        operand,
        expression;
};

template < typename Iterator, typename Skipper >
typename qi::rule<Iterator, Skipper> const
    Grammar<Iterator, Skipper>::scalar_literal(qi::uint_ | qi::int_);

template < typename Iterator, typename Skipper >
typename qi::rule<Iterator, Skipper> const
    Grammar<Iterator, Skipper>::identifier(qi::lexeme[(qi::alpha | '_') >> *(qi::alnum | '_')]);

template < typename Iterator, typename Skipper >
typename qi::rule<Iterator, Skipper> const
    Grammar<Iterator, Skipper>::operand((scalar_literal | identifier | ('(' >> expression >> ')')));

template < typename Iterator, typename Skipper >
typename qi::rule<Iterator, Skipper> const
    Grammar<Iterator, Skipper>::expression(operand);

（表达式规则与操作数相同，以使代码更容易理解;当然它应该更复杂但基于操作数）。 操作数声明使用表达式一个，反之亦然。尝试 parse_phrase 时会出现段错误（123）。我想这是因为使用表达式的“前进”;如果我在操作数之前放置表达式声明，也会发生同样的情况。那么应该以什么方式声明这些规则以避免运行时错误？

1 个答案:

答案 0 :(得分：1)

  1. 首先，静态与它无关：

    Live On Coliru 同样失败：

    #include <boost/spirit/include/qi.hpp>
#include <boost/spirit/repository/include/qi.hpp>

namespace qi = boost::spirit::qi;

template <typename Iterator>
struct Skipper : qi::grammar<Iterator> {
    Skipper() : Skipper::base_type(_skip_rule) { }
private:
    qi::rule<Iterator> const
        _comment { 
            boost::spirit::repository::confix("/*", "*/")    [*(qi::char_ - "*/")]     // Multi-line
        | boost::spirit::repository::confix("//", qi::eol) [*(qi::char_ - qi::eol)]  // Single-line
        },
        _skip_rule {
            qi::ascii::space | _comment
        };
};

template <typename Iterator, typename Skipper>
struct Grammar : qi::grammar<Iterator, Skipper> {
    Grammar() : Grammar::base_type(expression) { }
private:
    qi::rule<Iterator, Skipper> const
        // Tokens
        scalar_literal { qi::uint_ | qi::int_ },
        identifier     { qi::lexeme[(qi::alpha | '_') >> *(qi::alnum | '_')] },
        // Rules
        operand        { (scalar_literal | identifier | ('(' >> expression >> ')')) },
        expression     { operand };
};

int main() {
    using It = std::string::const_iterator;
    Skipper<It> s;
    Grammar<It, Skipper<It> > p;
    std::string const input = "(123)";

    It f = input.begin(), l = input.end();

    bool ok = qi::phrase_parse(f,l,p,s);

    if (ok)   std::cout << "Parse success\n";
    else      std::cout << "Parse failed\n";
    if (f!=l) std::cout << "Remaining input: '" << std::string(f,l) << "'\n";
}

  2. 其次，船长对事物没有任何意义：

    Live On Coliru 同样失败：

    #include <boost/spirit/include/qi.hpp>
#include <boost/spirit/repository/include/qi.hpp>

namespace qi = boost::spirit::qi;

template <typename Iterator, typename Skipper = qi::ascii::space_type>
struct Grammar : qi::grammar<Iterator, Skipper> {
    Grammar() : Grammar::base_type(expression) { }
private:
    qi::rule<Iterator, Skipper> const
        // Tokens
        scalar_literal { qi::uint_ | qi::int_ },
        identifier     { qi::lexeme[(qi::alpha | '_') >> *(qi::alnum | '_')] },
        // Rules
        operand        { (scalar_literal | identifier | ('(' >> expression >> ')')) },
        expression     { operand };
};

int main() {
    using It = std::string::const_iterator;
    Grammar<It> p;
    std::string const input = "(123)";

    It f = input.begin(), l = input.end();

    bool ok = qi::phrase_parse(f,l,p,qi::ascii::space);

    if (ok)   std::cout << "Parse success\n";
    else      std::cout << "Parse failed\n";
    if (f!=l) std::cout << "Remaining input: '" << std::string(f,l) << "'\n";
}

  3. 第三，初始化的时间与它有关：

    Live On Coliru 成功：

    #include <boost/spirit/include/qi.hpp>
#include <boost/spirit/repository/include/qi.hpp>

namespace qi = boost::spirit::qi;

template <typename Iterator, typename Skipper = qi::ascii::space_type>
struct Grammar : qi::grammar<Iterator, Skipper> {
    Grammar() : Grammar::base_type(expression) { 
        scalar_literal = qi::uint_ | qi::int_;
        identifier     = (qi::alpha | '_') >> *(qi::alnum | '_');
        // Rules
        operand        = (scalar_literal | identifier | ('(' >> expression >> ')'));
        expression     = operand;
    }
private:
    qi::rule<Iterator>          scalar_literal, identifier; // Tokens
    qi::rule<Iterator, Skipper> operand,        expression; // Rules
};

int main() {
    using It = std::string::const_iterator;
    Grammar<It> p;
    std::string const input = "(123)";

    It f = input.begin(), l = input.end();

    bool ok = qi::phrase_parse(f,l,p,qi::ascii::space);

    if (ok)   std::cout << "Parse success\n";
    else      std::cout << "Parse failed\n";
    if (f!=l) std::cout << "Remaining input: '" << std::string(f,l) << "'\n";
}

    打印

    Parse success

  4. 最后，你可以吃到所有的蛋糕并吃掉它：

    <强> Live On Coliru 

    #include <boost/spirit/include/qi.hpp>
#include <boost/spirit/repository/include/qi.hpp>

namespace qi = boost::spirit::qi;

namespace parsing {
    namespace detail {
        template <typename Iterator>
        struct Skipper : qi::grammar<Iterator> {
            Skipper() : Skipper::base_type(_skip_rule) {
                _comment  = boost::spirit::repository::confix("/*", "*/")    [*(qi::char_ - "*/")]     // Multi-line
                        | boost::spirit::repository::confix("//", qi::eol) [*(qi::char_ - qi::eol)]  // Single-line
                        ;

                _skip_rule = qi::ascii::space | _comment;
            }
        private:
            qi::rule<Iterator> _comment, _skip_rule;
        };

        template <typename Iterator, typename Skipper = Skipper<Iterator> >
        struct Grammar : qi::grammar<Iterator, Skipper> {
            Grammar() : Grammar::base_type(expression) {
                scalar_literal = qi::uint_ | qi::int_;
                identifier     = (qi::alpha | '_') >> *(qi::alnum | '_');
                // Rules
                operand        = (scalar_literal | identifier | ('(' >> expression >> ')'));
                expression     = operand;
            }
        private:
            qi::rule<Iterator>          scalar_literal, identifier; // Tokens
            qi::rule<Iterator, Skipper> operand,        expression; // Rules
        };
    }

    template <typename Iterator, typename Skipper = detail::Skipper<Iterator> >
    struct facade {
        template <typename Range> static bool parse(Range const& input) {
            Iterator f = boost::begin(input), l = boost::end(input);
            bool ok = qi::phrase_parse(f, l, _parser, _skipper);

            if (f!=l)
                std::cout << "Remaining input: '" << std::string(f,l) << "'\n";

            return ok;
        }

    private:
        static const detail::Skipper<Iterator>          _skipper;
        static const detail::Grammar<Iterator, Skipper> _parser;
    };

    template <class I, class S> const detail::Skipper<I>    facade<I,S>::_skipper = {};
    template <class I, class S> const detail::Grammar<I, S> facade<I,S>::_parser  = {};
}

int main() {
    using It = std::string::const_iterator;
    std::string const input = "(123)";

    bool ok = parsing::facade<It>::parse(input);

    if (ok)   std::cout << "Parse success\n";
    else      std::cout << "Parse failed\n";
}

    5. 请注意，结果是一样的，解析器/跳过器的每一位都是静态和const，就像在原始代码中一样，代码更容易维护（并且同时具有更多的结构）

    这基本上是Singletons-bad-bad主题遇到内部const-is-problematic主题的地方。你不需要使字段成为常量。您不需要将实例设置为静态。

    如果您愿意，只需创建一个实例。此外，解析器现在可以复制也不是问题（你不必复制它;但现在你可以）。

相关问题
最新问题