2011年12月13日 星期二

以yardparser實作算式計算機

這篇文章是算式計算機系列的完結篇。
  1. (E)BNF表示式
  2. 手工打造算式計算機
  3. 以lex/yacc實作算式計算機
  4. 以Boost.Spirit實作算式計算機

;

(下載範例)

yardparser在使用上雖然沒辨法像Boost Spirit 一樣那麼直覺便利,可以將EBNF 語法規則直接定義在程式裡建立解析器,但使用類似的手法一樣可以將EBNF語法規則轉換為程式定義,建立一個語法解析器。yardparser也沒辨法像Boos Spirit那樣,可以在執行時期(run-time)動態的改變或產生新的解析器。除了上述的不同處之外,最大的差異是 yardparser 的編譯時間非常短及以 yardparser建立的parser執行速度非常快,同時產生的目的碼大小(code size)也相對小很多。

Boost Spirit 因為大量使用了 C++ Template Meta-programming 的相關技術,很完美的將EBNF語法規則語句嵌入到C++程式碼內和我們所寫的程式碼結合在一起,相當直覺也相當神奇。只不過如果從得到的編譯時間和執行效率來看,只能說 Boost Spirit 為我們提供了相當出色的語法糖(syntactic sugar),對於大型複雜的語法來說反而較難以適用。而 yardparser 雖然在使用上不如Boost Spirit那樣直覺便利,但至少在編譯時間和執行效率是大大滿足我們日常工作的需求。

底下同樣以簡單範例開始,介紹yardparser的基本使用。

A B

上面是原EBNF表示式的寫法,用來表示一個序列,在 A之後會有個B。而使用yardparser 則寫成如下的形式。

struct AB : CharSeq<'A', 'B'>
{
};

CharSeq 是 yardparser裡面事先定義好的 一個struct,作用是對輸入來源串流讀入字元來進行匹配動作。

(AB)*

以上定義了零個以上個AB序列的EBNF表示式的寫法,底下一樣轉換成yardparser的寫法。

struct StarAB : Star<AB>
{
};

AB是上一個例子裡定義,用來匹配 AB序列的規則。而Star是yardparser事先定義的一個struct,把AB作為它的參數,就能夠用來匹配零個以上的AB序列。

(AB)+

類似Star的語法,Plus是匹配一個以上的規則。

struct PlusAB : Plus<AB>
{
};

以上的規則定義用來檢驗匹配至少有一個以上的AB序列。

(AB)?

加上問號(?)表示這條規則是可有可無的(optional),或者換句話說AB序列出現的次數可以是零次或一次。轉換成yardparser的語法,如下所示。

struct OptionalAB : Opt<AB>
{
};

內建parser

yardparser 也內建了許多有用的parser,這些parser 或規則都以C/C++的struct 型式定義,主要可分為二大類。一類是基本規則,如 CharSeq、Star、Plus 等。另一類是 parser 類,如Digit、AlphaNum、Word等。除此之外包含於yardparser的範例中也內建了完整的C語言語法可以直接拿來應用,如DecNumber、Tok、Literal等。

底下列出常用基本語法規則。

Seq匹配序列
CharSeq匹配字元序列
CharSet匹配其中一個字元
CharSetRange匹配字元範圍中的一個
Star零個以上匹配
Plus一個以上匹配
Opt零個或一個匹配
Notboolean not
Orboolean or
True_tboolean true
False_tboolean false

底下是一些簡單的範例。

abstruct AB : CharSeq<'a', 'b'> {};
abcstruct ABC : CharSeq<'a', 'b', 'c'> {};
abc*struct ABandCstar : Seq<AB, Star<Char<'c'> > > {};
abc+struct ABandCplus : Seq<AB, Plus<Char<'c'> > > {};
bcstruct BC : CharSeq<'b', 'c'> {};
a(bc)+struct AandBCplus : Seq<Char<'a'>, Plus<BC> > {};
[abc]struct AorBorC : CharSet<'a', 'b', 'c'> {};
[a-z]struct AtoZ : CharSetRange<'a', 'z'> {};

下面是定義在c_grammer內的常用parser。

WS空白字元
DecNumber實數
HexNumber以0x開頭定義的十六進制數字
CharTok匹配字元,以空白字元斷開
Literal字面常數,包含數字文字等

動作程式碼

yardparser加入動作程式碼的方式和Boost Spirit的方式並不相同。底下以一個簡單的例子作比較,分別使用Boost Spirit及yardparser實作如下所列的簡單規則。

S = integer

底下是使用Boost Spirit的實作。

void get_int(int i)
{
}

rule<> S = int_p [&get_int];

可以看到以Boost Spirit實作的S解析器中,語法及動作程式碼的部份是各自獨立的。我們可以很容易的把動作程式碼([&get_int])的部份從語法S裡去掉,rule S仍然可以運作,因此在真正為語法加上動作程式碼之前就已經可以開始對語法測試,因此可以等到所有語法都完成實作後再回過頭來加入動作程式碼。

現在再來看看yardparser對S的實作。

struct Integer
{
};

struct Factor : Or<Integer, ...>
{
};

從上面的範例中可以看到,yardparser的動作程式碼定義形式和一般的語法定義形式是同樣的,也就是在yardparser中動作程式碼可以視為是一特殊的語法解析器,它並不是用作在語法的匹配上,而是用於執行對應於語法規則上的操作。以上所示範例是一個最簡單的情況,而實際上常見的情況是動作程式碼會和語法規則夾雜在一塊,這在最後實際實作算式計算機時即可見到,在這方面 yardparser 和Boost Spirit比較起來就沒那麼簡單直覺。

現在來看看yardparser的parser原型(prototype)。

struct parser
{
  template<typename ParserState_t>
  static bool Match(ParserState_t& p);
};

在yardparser裡面每一個parser都定義成一個struct,struct裡面定義一個回傳值型別是bool名稱叫作Match的static函數。這條Match函數就是yardparser的核心函數,用來作語法匹配,底下透過一個簡單的範例來看看它是如何使用。

struct Integer
{
    template<typename ParserState_T>
    static bool Match(ParserState_T& p)
    {
        const char* p0 = p.GetPos();
        if (c_grammer::DecNumber::Match(p))
        {
            string s(p0, p.GetPos());
            int n = atoi(s.c_str());
            return true;
        }
        return false;
    }
};

如上面的簡單範例,Integer 定義了 Match 方法,在 Match 方法中透過 yardparser 內建的c_grammer中的DecNumber解析器來匹配數字。如果DecNumber的Match方法回傳成功,則表示目前匹配的字串是一個數字。不像是Boost Spirit的動作程式碼那麼直接,每一個動作程式碼函數的參數本身就已是轉換好的資料,可以直接使用,yardparser的動作程式碼需要自行將這個數字由字串裡抽取出來,轉換成內部資料儲存。

使用yardparser實作算式計算機

如下所列 ,寫下算式計算機的EBNF表示式。

factor     := integer | '(' expression ')'
term       := factor (('*' factor) | ('/' factor))*
expression := term (('+' term) | ('-' term))*

首先將以上的EBNF表示式轉換為使用yardparser定義,不帶動作程式碼,如下。

struct Factor : Or<Integer, Seq<Char<'('>, Expression, Char<')'> > > {};
struct Term : Seq<Factor, Star<Or<Seq<Char<'*'>, Factor>, Seq<Char<'/'>, 

Factor> > > > {};
struct Expression : Seq<Factor, Star<Or<Seq<Char<'+'>, Term>, 
Seq<Char<'-'>, Term> > > > {};

轉換後的yardparser程式定義如果沒有問題的話,應該能夠順利通過編譯,而且已經可以實際用來解析算式語法,只不過還沒加上動作程式碼所以還不能有真正的作用。

以下開始加上動作程式碼。如同前面的範例,需要加上動作程式碼的地方有五處,其中一個是將數字取出,以及加減乘除四種運算。取出數字的動作程式碼在上一節中已列出,底下說明如何加入加減乘除運算的動作程式碼。如下所示定義為加上動作程式碼後的語法程式定義。

struct Factor : Or<Integer, Seq<Char<'('>, Expression, Char<')'> > > {};
struct Term : Seq<Factor, Star<Or<DoMul<Seq<Char<'*'>, Factor> >, 
DoDiv<Seq<Char<'/'>, Factor> > > > > {};
struct Expression : Seq<Term, Star<Or<DoAdd<Seq<Char<'+'>, Term> >, 
DoSub<Seq<Char<'-'>, Term> > > > > {};

以上四個動作程式碼:DoMul、DoDiv、DoAdd及DoSub 分別為四種運算的動作程式碼。可以很明顯的看出來,加上動作程式碼後,沒辨法像使用Boost Spirit一樣一眼就能夠分辨出那一部份是語法,那一部份是動作程式碼。

最後加上一個用來作運算的數字堆疊,再整合Integer及四則運算的動作程式碼,完成算式計算機實作,其它部份程式碼如下所示。

vector<int> stack;
template<class RuleT>
struct DoMul
{
    template<typename ParserState_T>
    static bool Match(ParserState_T& p)
    {
        if (RuleT::Match(p))
        {
            stack[stack.size() - 2] *= stack[stack.size() - 1];
            stack.pop_back();
            return true;
        }
        return false;
    }
};

template<class RuleT>
struct DoDiv
{
    template<typename ParserState_T>
    static bool Match(ParserState_T& p)
    {
        if (RuleT::Match(p))
        {
            stack[stack.size() - 2] /= stack[stack.size() - 1];
            stack.pop_back();
            return true;
        }
        return false;
    }
};

template<class RuleT>
struct DoAdd
{
    template<typename ParserState_T>
    static bool Match(ParserState_T& p)
    {
        if (RuleT::Match(p))
        {
            stack[stack.size() - 2] += stack[stack.size() - 1];
            stack.pop_back();
            return true;
        }
        return false;
    }
};

template<class RuleT>
struct DoSub
{
    template<typename ParserState_T>
    static bool Match(ParserState_T& p)
    {
        if (RuleT::Match(p))
        {
            stack[stack.size() - 2] -= stack[stack.size() - 1];
            stack.pop_back();
            return true;
        }
        return false;
    }
};

int main(void)
{
    std::string str;
    while (getline(cin, str))
    {
        if (str.empty() || str[0] == 'q' || str[0] == 'Q')
            break;
        SimpleTextParser parser(str.c_str(), str.c_str() + str.length());
        if (!parser.Parse<Seq<Expression, EndOfInput> >())
            break;
        cout << str << " = " << stack.back() << "\n";
        stack.clear();
    }
    return 0;
}

注意到上述的實作裡,將字元 parser Char 改為 CharTok,目的是允許在字元間可以插入額外空白,CharTok由c_grammer集合所提供。


(下載範例)

沒有留言:

張貼留言

Related Posts Plugin for WordPress, Blogger...