Learning Spirit（zt）

Learning Spirit（zt）

spirit是boost中的语法分析框架。使用spirit可以用来编写语法分析程序。

spirit有如下特点：

l         使用递归下降分析程序（分析的效率不高）

l         模板元编程技术实现（编译慢，但是提高了程序的运行速度）

l         EBNF语法表示（使用方便直观）

 

Hello, Spirit!

下面我们就通过一个简单的例子，来看看spirit到底是怎么回事。

我们要做的是，分析类似于下面的一段文本：

1, 12,11   ,200,111

使用逗号分割的整数序列，然后求出它们的和。当然，这个程序不使用spirit能够更简单的完成，我们这里只是简单的举个例子，spirit不仅仅如此。

语法分析

首先我们来分析一下这段文本的语法，使用EBNF表示如下：（EBNF-Extend Backus Naur Form，是用来表示文法的）

S::= integer (‘,’ integer)*

如果你没有学过编译原理，那么可能看不懂上面的式子。简单的说，意思就是一个整数，然后接着重复任意次数的逗号+整数。有点类似于正则表达式的语法。

在spirit的EBNF语法中，和这个有点不一样。首先，星号* 这个运算符必须前置，因为在c++中只有前置的星号来表示指针运算（当然，spirit重载的指针运算符，使它表示重复的意思）。然后，式子中不同的部分使用>>运算符连接，表示顺序。a>>b表示ab这样的语法。最后式子就是这样的：

s=integer>>*(‘,’>>integer)

当然上面的式子还不是最终的。

Parser

在Spirit中，类似于上面的integer和’,’称为parser，parser使用来匹配文本的。

例如：int_p用来匹配一个十进制整数。也就是说，如果是用int_p来分析语法的话，” 10” ,” 123” 这样的字符串是符合语法的，而 “12ab” “//11” 是不符合语法的。

ch_p(c)用来匹配字符c，c可以是char或者wchar_t，例如：ch_p(‘,’)用来匹配一个逗号。

parser之间通过运算符的连接的结果也是一个parser。

例如：

ch_p(‘a’)>>ch_p(‘b’)匹配”ab”

ch_p(‘a’)>>*ch_(‘b’)匹配”a”,”ab”,”abb”,”abbb”,...

那么，逗号分割的整数序列的语法可以表示为：

s=int_p>>*(ch_p(‘,’)>>int_p);

有可能你会有疑问，在这里int_p和ch_p是什么？

int_p是一个类似于cout这样的已经预先定义好的对象，它的类型是int_parser<type,base,min,max>。

ch_p是一个函数，返回一个chlit<CharT>对象。

这些以后会说到。

 

最后，s的类型是什么，我们如何来定义它的类型？

s的类型一般为rule<>就可以了，rule<>是一个parser的容器，它可以保存任意类型的parser。当然rule<>本身也可以作为parser来是用。

例如：

rule<> s,t;

t=ch_(‘,’)>>int_p;

s=int_p>>*t;

这就相当于：

rule<> s= int_p>>*(ch_p(‘,’)>>int_p);

parse函数

至此，我们已经使用spirit表示了语法，那么使用这个语法来分析字符串呢？

答案就是parse函数。语法如下：

parse(str , s , space_p);

这里str是一个c语言的0节尾字符串，s就是上面的rule<>。

space_p是一个parser，在这里作为skip parser，用来过滤掉空白字符（逗号和整数之间的空格等符号）。

parse也接受迭代器的输入，parse(first,last,s,space_p)，first，last就是开始结束的迭代器。

parse返回的是parse_info<>对象，用来返回分析的结果（成功或失败）。

parse_info<>有4个成员：

stop   分析结束的位置

hit    是否成功匹配，即符合语法。

full   是否匹配所有的输入，即符合语法且没有剩余的字符没有匹配

length 匹配到的字符数

至此，我们可以写出程序了。

代码如下：

#include<iostream>

#include<string>

#include<boost/spirit.hpp>//spirit的头文件

using namespace std;

using namespace boost::spirit;

 

int main()

{

       rule<phrase_scanner_t> s       //因为下面的parse函数用到了space_p

//所以不能使用默认的模板参数

                                                 //现在不必关心这样的问题。

              =int_p >> *(ch_p(',')>>int_p);

       string str;

       while(getline(cin,str))

       {

              parse_info<> info = parse(str.c_str(),s,space_p);

              if (info.full)

              {

                     cout<<"Parse successful."<<endl;

              }

              else

              {

                     cout<<"Parse fail."<<endl;

              }

       }

       return 0;

}

parse函数有4种形式的重载。

template <typename IteratorT, typename DerivedT>

    parse_info<IteratorT>

    parse

    (

        IteratorT const&        first,

        IteratorT const&        last,

        parser<DerivedT> const& p

    );

    template <typename CharT, typename DerivedT>

    parse_info<CharT const*>

    parse

    (

        CharT const*            str,

        parser<DerivedT> const& p

    );

以上两种是字符层次的parse。

template <typename IteratorT, typename ParserT, typename SkipT>

    parse_info<IteratorT>

    parse

    (

        IteratorT const&        first,

        IteratorT const&        last,

        parser<ParserT> const&  p,

        parser<SkipT> const&    skip

    );

    template <typename CharT, typename ParserT, typename SkipT>

    parse_info<CharT const*>

    parse

    (

        CharT const*            str,

        parser<ParserT> const&  p,

        parser<SkipT> const&    skip

    );

以上是短语层次的parse。

短语层次使用一个skip parser参数来过滤输入中的“空白”符号（这里空白的意思由skip参数决定，可以是空格、回车、甚至是“/*...*/”这样的c语言注释）。而字符层次则严格的分析每一个字符。

例如：

parse(“a 123” ,ch_p(‘a’)>>int_p,space_p)==true;//phase level

parse(“a 123” ,ch_p(‘a’)>>int_p)==true;//character level

parse(“a 123” ,ch_p(‘a’)>>int_p)==false;

 

Semantic Action

语义动作是指在分析的过程中执行的动作。每个parser可以附带一个或多个语义动作，当这个parser匹配了一段输入后，就会调用这个动作。

语义动作可以是一个函数：

template<typename Iterator>

void func(Iterator first, Iterator last);

也可以是仿函数：

struct myfunctor

{

       template<typename Iterator>

       void operator()(Iterator first, Iterator last) const;

}

注意()重载的const不能去掉。

可以这样使用：

rule<> r = (a>>b)[&func];

rule<> s= (a[myfunctor()] | b[&func])[&func];

特殊的语义动作：

对于一些特殊的parser，例如：int_p,ch_p。除了可以使用上述的语义动作外，还提供了与其类型有关的语义动作。

对于int_p：void func(int val);  对于ch_p：void func(char c)。

 

那么，现在我们就可以完成我们上一篇教程的题目了。

#include<iostream>

#include<string>

#include<boost/spirit.hpp>//spirit的头文件

using namespace std;

using namespace boost::spirit;

struct Assign

{

       int & var;

       Assign(int & v):var(v){}

       void operator()(int val) const

       {

              var=val;

       }

};

struct Increase

{

       int & var;

       Increase(int & v):var(v){}

       void operator()(int val) const

       {

              var+=val;

       }

};

int main()

{

       int count;

 

       rule<phrase_scanner_t> s

              =int_p[Assign(count)]

              >> *( ch_p(',')

                     >>int_p[Increase(count)]);

 

       string str;

      

       while(getline(cin,str))

       {

              parse_info<> info = parse(str.c_str(),s,space_p);

              if (info.full)

              {

                     cout<<"Parse successful."<<endl;

                     cout<<"Result is "<<count<<endl;

              }

              else

              {

                     cout<<"Parse fail."<<endl;

              }

       }

       return 0;

}