c++ - Boost::spirit(经典)基元与自定义解析器

Question

我是 Boost::spirit 的初学者，我想定义解析 TTCN 语言的语法。( http://www.trex.informatik.uni-goettingen.de/trac/wiki/ttcn-3_4.5.1 )我正在尝试为像 Alpha、AlphaNum 这样的“原始”解析器定义一些规则，使其与原始语法 1 对 1 忠实，但显然我做错了什么，因为以这种方式定义的语法不起作用。但是当我使用 primite 解析器代替 TTCN 时，它开始工作了。

有人能说出为什么“手动”定义的规则不能按预期工作吗？如何修复它，因为我想坚持原来的语法。是初学者的代码错误还是其他原因？

#define BOOST_SPIRIT_DEBUG

#include <boost/spirit/include/classic_symbols.hpp>
#include <boost/spirit/include/classic_tree_to_xml.hpp>
#include <boost/spirit/include/classic_position_iterator.hpp>
#include <boost/spirit/include/classic_core.hpp>
#include <boost/spirit/include/classic_parse_tree.hpp>
#include <boost/spirit/include/classic_ast.hpp>
#include <iostream>
#include <string>
#include <boost/spirit/home/classic/debug.hpp>
using namespace boost::spirit::classic;
using namespace std;
using namespace BOOST_SPIRIT_CLASSIC_NS;

typedef node_iter_data_factory<int> factory_t;
typedef position_iterator<std::string::iterator> pos_iterator_t;
typedef tree_match<pos_iterator_t, factory_t> parse_tree_match_t;
typedef parse_tree_match_t::const_tree_iterator iter_t;


struct ParseGrammar: public grammar<ParseGrammar>
{
      template<typename ScannerT>
      struct definition
      {
            definition(ParseGrammar const &)
            {
               KeywordImport = str_p("import");
               KeywordAll = str_p("all");
               SemiColon = ch_p(';');
               Underscore = ch_p('_');

               NonZeroNum = range_p('1','9');
               Num = ch_p('0') | NonZeroNum;
               UpperAlpha = range_p('A', 'Z');
               LowerAlpha = range_p('a', 'z');
               Alpha = UpperAlpha | LowerAlpha;
               AlphaNum = Alpha | Num;

               //this does not!
               Identifier = lexeme_d[Alpha >> *(AlphaNum | Underscore)];

               // Uncomment below line to make rule work
               // Identifier = lexeme_d[alpha_p >> *(alnum_p | Underscore)];

               Module = KeywordImport >> Identifier >> KeywordAll >> SemiColon;

               BOOST_SPIRIT_DEBUG_NODE(Module);
               BOOST_SPIRIT_DEBUG_NODE(KeywordImport);
               BOOST_SPIRIT_DEBUG_NODE(KeywordAll);
               BOOST_SPIRIT_DEBUG_NODE(Identifier);
               BOOST_SPIRIT_DEBUG_NODE(SemiColon);
            }

            rule<ScannerT> KeywordImport,KeywordAll,Module,Identifier,SemiColon;
            rule<ScannerT> Alpha,UpperAlpha,LowerAlpha,Underscore,Num,AlphaNum;
            rule<ScannerT> NonZeroNum;
            rule<ScannerT> const&
            start() const { return Module; }
      };
};

int main()
{
   ParseGrammar resolver;    //  Our parser
   BOOST_SPIRIT_DEBUG_NODE(resolver);

   string content = "import foobar all;";

   pos_iterator_t pos_begin(content.begin(), content.end());
   pos_iterator_t pos_end;

   tree_parse_info<pos_iterator_t, factory_t> info;
       info = ast_parse<factory_t>(pos_begin, pos_end, resolver, space_p);

   std::cout << "\ninfo.length : " << info.length << std::endl;
   std::cout << "info.full   : " << info.full << std::endl;

   if(info.full)
   {
      std::cout << "OK: Parsing succeeded\n\n";
   }
   else
   {
      int line = info.stop.get_position().line;
      int column = info.stop.get_position().column;
      std::cout << "-------------------------\n";
      std::cout << "ERROR: Parsing failed\n";
      std::cout << "stopped at: " << line  << ":" << column << "\n";
      std::cout << "-------------------------\n";
   }
   return 0;
}

Answer 1

我不玩 Spirit Classic(现在已经弃用多年)。

我只能假设你把 skipper 搞混了。这是翻译成 Spirit V2 的内容:

#define BOOST_SPIRIT_DEBUG
#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/support_line_pos_iterator.hpp>

namespace qi = boost::spirit::qi;

typedef boost::spirit::line_pos_iterator<std::string::const_iterator> pos_iterator_t;

template <typename Iterator = pos_iterator_t, typename Skipper = qi::space_type>
struct ParseGrammar: public qi::grammar<Iterator, Skipper>
{
    ParseGrammar() : ParseGrammar::base_type(Module)
    {
        using namespace qi;
        KeywordImport = lit("import");
        KeywordAll    = lit("all");
        SemiColon     = lit(';');

#if 1
        // this rule obviously works
        Identifier = lexeme [alpha >> *(alnum | '_')];
#else
        // this does too, but less efficiently

        Underscore    = lit('_');
        NonZeroNum    = char_('1','9');
        Num           = char_('0') | NonZeroNum;
        UpperAlpha    = char_('A', 'Z');
        LowerAlpha    = char_('a', 'z');
        Alpha         = UpperAlpha | LowerAlpha;
        AlphaNum      = Alpha | Num;

        Identifier = lexeme [Alpha >> *(AlphaNum | Underscore)];
#endif

        Module = KeywordImport >> Identifier >> KeywordAll >> SemiColon;

        BOOST_SPIRIT_DEBUG_NODES((Module)(KeywordImport)(KeywordAll)(Identifier)(SemiColon))
    }

    qi::rule<Iterator, Skipper> Module;
    qi::rule<Iterator> KeywordImport,KeywordAll,Identifier,SemiColon;
    qi::rule<Iterator> Alpha,UpperAlpha,LowerAlpha,Underscore,Num,AlphaNum;
    qi::rule<Iterator> NonZeroNum;
};

int main()
{
   std::string const content = "import \r\n\r\nfoobar\r\n\r\n all; bogus";

   pos_iterator_t first(content.begin()), iter=first, last(content.end());

   ParseGrammar<pos_iterator_t> resolver;    //  Our parser
   bool ok = phrase_parse(iter, last, resolver, qi::space);

   std::cout << std::boolalpha;
   std::cout << "\nok : " << ok << std::endl;
   std::cout << "full   : " << (iter == last) << std::endl;

   if(ok && iter==last)
   {
      std::cout << "OK: Parsing fully succeeded\n\n";
   }
   else
   {
      int line   = get_line(iter);
      int column = get_column(first, iter);
      std::cout << "-------------------------\n";
      std::cout << "ERROR: Parsing failed or not complete\n";
      std::cout << "stopped at: " << line  << ":" << column << "\n";
      std::cout << "remaining: '" << std::string(iter, last) << "'\n";
      std::cout << "-------------------------\n";
   }
   return 0;
}

我在输入的末尾添加了一点“伪造”，所以输出变成了更好的演示:

<Module>
  <try>import \r\n\r\nfoobar\r\n\r</try>
  <KeywordImport>
    <try>import \r\n\r\nfoobar\r\n\r</try>
    <success> \r\n\r\nfoobar\r\n\r\n all;</success>
    <attributes>[]</attributes>
  </KeywordImport>
  <Identifier>
    <try>foobar\r\n\r\n all; bogu</try>
    <success>\r\n\r\n all; bogus</success>
    <attributes>[]</attributes>
  </Identifier>
  <KeywordAll>
    <try>all; bogus</try>
    <success>; bogus</success>
    <attributes>[]</attributes>
  </KeywordAll>
  <SemiColon>
    <try>; bogus</try>
    <success> bogus</success>
    <attributes>[]</attributes>
  </SemiColon>
  <success> bogus</success>
  <attributes>[]</attributes>
</Module>

ok : true
full   : false
-------------------------
ERROR: Parsing failed or not complete
stopped at: 3:8
remaining: 'bogus'
-------------------------

综上所述，这就是我可能将其简化为:

template <typename Iterator, typename Skipper = qi::space_type>
struct ParseGrammar: public qi::grammar<Iterator, Skipper>
{
    ParseGrammar() : ParseGrammar::base_type(Module)
    {
        using namespace qi;

        Identifier = alpha >> *(alnum | '_');
        Module     = "import" >> Identifier >> "all" >> ';';

        BOOST_SPIRIT_DEBUG_NODES((Module)(Identifier))
    }

    qi::rule<Iterator, Skipper> Module;
    qi::rule<Iterator> Identifier;
};

如您所见，Identifier 规则隐式地是一个词素，因为它没有声明使用 skipper 。

查看 Live on Coliru