如何为boost :: spirit进行错误处理工作

时间:2013-10-15 07:43:38

标签: c++ boost-spirit

在boost :: spirit中,我添加了基于示例roman的错误处理代码。

#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/phoenix_operator.hpp>
#include <boost/spirit/include/phoenix_core.hpp>
#include <boost/spirit/include/phoenix_fusion.hpp>
#include <boost/spirit/include/phoenix_object.hpp>
#include <boost/foreach.hpp>

#include <iostream>
#include <fstream>
#include <string>
#include <vector>

namespace qi = boost::spirit::qi;
namespace ascii = boost::spirit::ascii;
namespace phoenix = boost::phoenix;

template <typename Iterator>
struct roman : qi::grammar<Iterator>
{
  roman() : roman::base_type(start)
  {
    using qi::eps;
    using qi::lit;
    using qi::lexeme;
    using qi::_val;
    using qi::_1;
    using ascii::char_;

    // for on_error
    using qi::on_error;
    using qi::fail;
    using phoenix::construct;
    using phoenix::val;

    start = +(lit('M') )  >> "</>";

    on_error<fail>
    (
        start
      , std::cout
            << val("Error! Expecting ")
            // << _4                            // what failed?
            << val(" here: \"")
            // << construct<std::string>(_3, _2)   // iterators to error-pos, end
            << val("\"")
            << std::endl
    );
  }
  qi::rule<Iterator> start;
};

int
main()
{
    std::cout << "/////////////////////////////////////////////////////////\n\n";
    std::cout << "\t\tRoman Numerals Parser\n\n";
    std::cout << "/////////////////////////////////////////////////////////\n\n";
    std::cout << "Type a Roman Numeral ...or [q or Q] to quit\n\n";

    typedef std::string::const_iterator iterator_type;
    typedef roman<iterator_type> roman;

    roman roman_parser; // Our grammar

    std::string str;
    unsigned result;
    while (std::getline(std::cin, str))
    {
        if (str.empty() || str[0] == 'q' || str[0] == 'Q')
            break;

        std::string::const_iterator iter = str.begin();
        std::string::const_iterator end = str.end();
        //[tutorial_roman_grammar_parse
        bool r = parse(iter, end, roman_parser, result);

        if (r && iter == end)
        {
            std::cout << "-------------------------\n";
            std::cout << "Parsing succeeded\n";
            std::cout << "result = " << result << std::endl;
            std::cout << "-------------------------\n";
        }
        else
        {
            std::string rest(iter, end);
            std::cout << "-------------------------\n";
            std::cout << "Parsing failed\n";
            std::cout << "stopped at: \": " << rest << "\"\n";
            std::cout << "-------------------------\n";
        }
        //]
    }

    std::cout << "Bye... :-) \n\n";
    return 0;
}

我的问题是:

  1. 没有触发“on_error”,为什么?
  2. 我评论“&lt;&lt;&lt; _4”,如果我想打印出失败部分,该怎么做?

1 个答案:

答案 0 :(得分:7)

三个步骤:

  1. 对占位符进行限定:

    on_error<fail>(start, 
            std::cout
               << val("Error! Expecting ")
               << qi::_4
               << val(" here: \"")
               << construct<std::string>(qi::_3, qi::_2)
               << val("\"")
               << std::endl
        );
    
  2. 您还需要确保您有期望点来触发错误处理程序。

    start = eps > +(lit('M') ) >> "</>";
    

    参见例如Boost.Spirit.Qi - Errors at the beginning of a rule获得解释

  3. 可选)命名您的规则

    start.name("start");
    

    使用BOOST_SPIRIT_DEBUG_NODE(S)是隐式命名规则的另一种方法。

  4. 查看 Live on Coliru (已清理并简化)

    现在打印(输入 iv ):

    Error! Expecting <sequence>"M""</>" here: 'iv'
    Parsing failed
    stopped at: 'iv'
    

    完整代码

    #include <boost/spirit/include/qi.hpp>
    #include <boost/spirit/include/phoenix.hpp>
    
    #include <iostream>
    #include <fstream>
    
    namespace qi  = boost::spirit::qi;
    namespace phx = boost::phoenix;
    
    template <typename Iterator>
    struct roman : qi::grammar<Iterator>
    {
        roman() : roman::base_type(start)
        {
            using namespace qi;
    
            start = eps > +lit('M') >> "</>";
            start.name("start");
    
            on_error<fail>(start, 
                    phx::ref(std::cout)
                       << "Error! Expecting "
                       << qi::_4
                       << " here: '"
                       << phx::construct<std::string>(qi::_3, qi::_2)
                       << "'\n"
                );
        }
        qi::rule<Iterator> start;
    };
    
    int main()
    {
        typedef std::string::const_iterator iterator_type;
        roman<iterator_type> roman_parser; // Our grammar
    
        std::string str;
        while (std::getline(std::cin, str))
        {
            if (str.empty() || str[0] == 'q' || str[0] == 'Q')
                break;
    
            iterator_type iter = str.begin(), end = str.end();
            unsigned result;
            bool r = parse(iter, end, roman_parser, result);
    
            if (r && iter == end)
            {
                std::cout << "Parsing succeeded\n";
                std::cout << "result = " << result << std::endl;
            }
            else
            {
                std::string rest(iter, end);
                std::cout << "Parsing failed\n";
                std::cout << "stopped at: '" << rest << "'\n";
            }
        }
    }
    

    除了评论之外:这是我一直在测试的东西 - 还没有让它完全正常工作,但是错误处理程序正在被调用并且正在进行输入。也许它会有所帮助?

    static auto const at_eol = (*_1 == '\r') || (*_1 == '\n');
    static auto const at_eoi = (_1 == _2);
    
    on_error<retry>(start, 
        (
            (phx::ref(std::cout) << "rule start: expecting " << _4 << " here: '" << escape_(_3, _2) << "'\n"),
            phx::while_ (!at_eoi && !at_eol) [ ++_1, phx::ref(std::cout) << "\nadvance to newline\n" ],
            phx::while_ (!at_eoi && at_eol)  [ ++_1, phx::ref(std::cout) << "\neat newline\n" ],
            phx::if_ (at_eoi)                [ _pass = fail ]
        )
    );
    

    另请参阅multi_pass&lt;&gt;

    文档中Important下的说明