以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	零個或一個匹配
Not	boolean not
Or	boolean or
True_t	boolean true
False_t	boolean false

底下是一些簡單的範例。

ab	struct AB : CharSeq<'a', 'b'> {};
abc	struct ABC : CharSeq<'a', 'b', 'c'> {};
abc*	struct ABandCstar : Seq<AB, Star<Char<'c'> > > {};
abc+	struct ABandCplus : Seq<AB, Plus<Char<'c'> > > {};
bc	struct 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集合所提供。

(下載範例)