以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集合所提供。


(下載範例)

留言

張貼留言

這個網誌中的熱門文章

以lex/yacc實作算式計算機

圖片
前面我們透過 手工的方式 實作了一個簡易的算式計算機，現在我們要開始使用工具來作同樣的事，比較看看手工和使用工具有什麼不同的差別。首先要介紹的就是lex&yacc。 lex & yacc lex(Lexical Analyzar)及yacc(Yet Another Compiler Compiler)是用來輔助程式設計師製作語法剖析器的程式工具。lex的工作就是幫助我們將輸入的資料文字串流分解成一個個有意義的token，而yacc的工作就是幫我們分析這些token和我們定義的規則作匹配。下圖中所表示的是使用lex及yacc的一般工作流程。 首先看到yacc會讀入一個.y檔案，這裡.y檔案的內容就是我們使用類似(E)BNF語法定義的語法規則，yacc會分析這些語法規則後，幫我們產生可以用來解析這些規則的程式碼，而這個檔案一般名稱預設為y.tab.c，產生的程式碼裡面最重要的一個的函式叫作yyparse。 同yacc類似，lex也會讀入一個.l的檔案，這個檔案裡面定義的是如何從文字流裡解出token的規則，使用的方法是常規表示式(regular expression)。在圖的左側中間我們還可以看到有一個叫作y.tab.h的檔案從yacc產生出來並餵給lex作輸入，這個檔案是yacc根據在讀入的.y檔裡面所定義的token代號所產生出來的一個header，這樣yacc及lex產生出來的程式碼裡面就可以使用共通定義的代碼而不必各寫個的。lex分析過.l檔案後也會產生一個一般預設叫作lex.yy.c的原始碼檔案，裡頭最重要的一個函式叫作yylex。 最後，我們把yacc產生出來的y.tab.c還有lex產生出來的lex.yy.c，以及其它我們自己撰寫的原始碼檔案一起拿來編譯再作連結，最後產生出來的就是一個可以用來解析我們定義的語法的解析器工具。以上是整個lex及yacc的使用流程概觀。 常規表示式 在正式使用lex之前，我們首先來對常規表示法作一個基本的認識。常規表示法是一種用來表示字串樣式(pattern)的中繼語言，就好比前文所介紹的(E)BNF表示式一樣，都是用來描述其它語言的語言，只不過用途不太一樣罷了。 常規表示式使用一些中繼符號(meta-symbol)以及ASCII字元定義字串樣式，以下列出一些常規表示式所使用的符號。 . 表示除了換行字元
Read more »

猜數字遊戲 (電腦猜人)

前幾天午睡時突然被告知要參加公司內部的程式設計比賽，題目是用C寫一支文字模式的4位數字猜數字遊戲，由使用者來猜電腦的數字。在上星期時其實就已經有公佈了，但我沒有注意到所以是臨時加入，還好這是個簡單的題目，不用花多少時間就可以寫出來。 規則： - 這是一對一比賽，雙方各選擇一4位數字，不讓對方知道。 - 4位數字由數字0至9組成，每位數不得重複。 - 雙方輪流猜對方的數字，直到一方猜中為止。 - A方猜B方的數字後，B方根據A方的猜測回答幾A幾B。 - 一個A表示猜中一個數字且位置正確，一個B表示猜中一個數字但位置不正確。 - 當一方猜中4A0B時即表示猜中對方全部4個數字且位置正確，贏得比賽。 - 例：B的謎底是4208，底下箭頭左測是A的猜測，箭頭右測是B的回答。 　　　1234 ==> 1A1B 　　　5678 ==> 1A0B 　　　2406 ==> 1A2B 　　　... 　　　4208 ==> 4A0B ; 寫個程式讓玩家來猜電腦的數字不難，不過我從來沒有寫過讓電腦來猜玩家數字的版本，所以花了點時間想想怎麼寫。 研究後歸納出二個點。 1, 使用窮舉法將所有可能數字組合列出。 2, 每次猜測後根據結果排除不可能是答案的組合，重複這個動作直到猜中答案為止。 第1點只是實作問題，第2點概念也很簡單，但要過濾不是答案的組合根據的是什麼？乍看之下沒什麼頭緒，不過想通之後就非常簡單了。 它的基本原理如下：假如謎底是4561，如果猜1524則會得到1A2B。從相反的角度來看，如果謎底是1524，則猜4561時也會得到1A2B的回答。 利用這個方法，每一次猜測一個數字X後，再以這個數字當作答案，來和所有剩下來的候選答案作比對，如果得到的結果(幾A幾B)和數字X是一樣的話，就把這個數字保留下來繼續作為候選答案，否則就過把這個數字過濾掉。下一把，繼續從候選答案裡選一個出來猜，重複上面的動作，直到猜中為止。 ; C++ STL的algorithm裡有個叫作next_permutation的函數，可以用來生成排列。 #include <iostream> #include <algorithm> using namespace std; int main () {   int myints[] = {1,2,3};   sort(m
Read more »

KillSudoku 4顆星精彩數獨詳解 - 鍊技巧

圖片
這題數獨(sudoku)題目估計為4+顆星，有點難度。解題需要應用多種技巧，過程非常精彩有趣，是個好題。 底下使用 KillSudoku 作詳細圖解。 １，使用基本排除法則，可以簡單填入６個數字。到此為止，開始使用 候選數法 來解題。如下所示，為填入６個數字後的狀態圖。 ２，如下圖，使用進階排除法，在第９列和第４行可以先排除幾個候選數。 ３，如圖，在第２行有一個 Naked Subset (3,4)，可以對3,4候選數作排除。附帶提一下，反過來看在同一行裡面也可以說有另一個Hidden Subset(2,5,8)存在。Naked Subset和Hidden Subset常是一體二面同時存在，只不過對我們來說，Naked Subset是相對比較容易看的出來。 排除第２行的3,4後，又可以對第２列以外的3作排除，如下圖。 ４，接著，在第５行又發現了一個 Naked Subset (3,7,8)。 對第５行三個Subset以外的候選數3,7,8作排除後，又接著產生可以對第５行以外的3作排除。 ５，這一題解到此為止，開始進入高潮。大部份能解到3顆星題目的人，猜想應該就此卡住。以下開始需要應用更高級的鍊技巧，才能夠繼續進行。 應用X-Chains鍊技巧，可以找到一條由４條強連結組成的鍊，可以排除候選數2。這裡的鍊指的是由２條以上的強連結組成，而所謂的強連結是指在同一行、或同一列或同一個Box裡，由唯二的候選數構成的連結。如上圖中的第９行中，只有二個2，這二個2構成一條強連結。為什麼說這是一條強連結？因為在這條連結的AB二個端點中，肯定會有一個2存在，要麼是A點要麼是B點。鍊技巧就是將多條強連結串連起來作候選數排除的技巧，而X-Chains是高級的鍊技巧裡面的基本技巧。 接上圖，這樣一來就又可以應用基本排除方法，填入３個數字，如下圖所示。 ６，接下來就是本題最精彩的部份，以下需要連續找到３條鍊，才能繼續往下解。 ７，找出３條鍊後，剩下來的部份就沒什麼特別的了，只需要應用基本法就能把所有剩餘數字填完。
Read more »