C++ 程序員需要面對的最復雜的任務之一就是在一段合理的時間期限內編寫一個解析器。在為 SQL 或 C++ 這類成熟的語言開發編譯器時，使用 GNU Flex/Bison 或 ANTLR 解析器生成程序通常是不錯的選擇；但是對于使用更簡單的 Backus Naur Form（BNF）的語法，這些工具陡峭的學習曲線并不總是物有所值。另一種替代選擇是使用標準 Linux® 發行版附帶的正則表達式庫或 Boost regex 或 tokenizer 庫，但是它們不能根據日漸復雜的語法進行良好擴展。

　　本文介紹了來自 Boost 的高可擴展性 Spirit 解析器框架。該解析器生成程序遵循 Extended Backus Naur Form (EBNF) 規范并使用 C++ 編寫，可以顯著縮短開發時間。要進一步閱讀，請查看詳細的 Spirit 文檔。

　　安裝 Spirit

　　您可以從 Boost 的 Web 站點免費下載 Spirit 框架（參見 參考資料 小節）。在開始使用 Spirit 進行開發之前，需注意以下事項：

　　必須在源代碼中包含 頭文件。該頭文件將大量使用元模板編程和仿函數（functor）。本文的所有代碼均使用 g++-3.4.4 進行編譯。確保使用支持 C++ 特性的編譯器。

　　部分 Spirit 框架在內部使用來自 Boost 的正則表達式庫，在已安裝的代碼庫中檢查 regex.h 頭文件。

　　確保 Boost 安裝的根目錄位于編譯器的 include 搜索路徑中。

　　Spirit 是一個只包括頭文件的庫，因此在鏈接時不需要任何額外的庫。但是 regex 是一個例外。要將 regex 源代碼只作為頭文件包含，可在代碼中使用預處理器指令 define BOOST_SPIRIT_NO_REGEX_LIB。

　　第一個 Spirit 項目

　　如果提供一個隨機的單詞列表，您的第一個 Spirit 項目將使用 C++ 風格列出列表中 Hello World（即 Hello 和 World 兩詞在輸入流中連在一起出現）出現的次數。參見清單 1；清單 2 顯示了輸出。

　　清單 1. 列出單詞 Hello World 在輸入流中出現的次數

#define　BOOST_SPIRIT_NO_REGEX_LIB
#include "regex.h"
#include "spirit.hpp"
#include "boost/spirit/actor.hpp"
using namespace boost::spirit;
const string input = "This Hello World program using Spirit counts the number of
Hello World occurrences in the input";
int main
　{
　int count = 0;
　parse (input.c_str,
　　　　 *(str_p("Hello World") [ increment_a(count) ]
　　　　　 |
　　　　　 anychar_p)
　　　　);
　cout << count >> endl;
　return 0;
　}

　　Spirit 框架的強大在于它為大量基本類型提供了內置解析器，包括單獨的字符、數字和字符串。更復雜的解析器通常都使用這些內置解析器對象創建。在 清單 1 中，str_p 和 anychar_p 都是 Spirit 中預定義的解析器 —— str_p 匹配它所提供的字符串（在此為 Hello World）并成功調用 increment_a 例程將計數加 1。anychar_p 是另一個預定義解析器，它可以匹配任何字符。

　　讓我們看一看 parse 函數，它實際上是 Spirit 框架中最重要的例程。它接受一個輸入流和一個語法，并在內部通過語法運行此輸入流。在本例中，輸入流來自 input.c_str，而 str_p 和 anychar_p 為語法提供語義。如果熟悉解析的話，將很快就明白 parse 函數的第二個參數相當于提供了一個 BNF。

　　其他預定義的 Spirit 解析器

　　考慮符合以下模式的解析器： 。您需要根據從該字符串提取的數據填充 Employee 數據結構。下面是一個典型的字符串："Alex 8 9.2 Jim 91 5.6"。

　　Spirit 為字符串（alpha_p）、整數（int_p）、和實數（real_p）預定義了解析器。因此，可以認為 parse 例程應該使用以下語法調用：parse(input.c_str, alpha_p >> int_p >> real_p)。這里的邏輯是 parse 將在輸入流中首先查找一個字符串，然后查找整數，最后查找一個實數。這樣可行嗎？行不通。清單 2 展示了可以解析數據的可行代碼片段。

　　清單 2. 使用 alpha_p、int_p 和 real_p 預定義解析器

#define　BOOST_SPIRIT_NO_REGEX_LIB
#include "regex.h"
#include "spirit.hpp"
#include "boost/spirit/actor/assign_actor.hpp"
using namespace std;
using namespace boost::spirit;
const string input = "Alex 8 9.2 Jim 91 5.6";
typedef struct {
　string name;
　int　　idcode;
　float　rating;
} Employee;
int main
　{
　string name;
　int idcode;
　float rating;
　int status = parse (input.c_str,
　　　　　　　　　　　*((+alpha_p) [assign_a(name)] >> ' ' >>
　　　　　　　　　　　　int_p[assign_a(idcode)] >> ' ' >>
　　　　　　　　　　　　real_p[assign_a(rating)] >>　!blank_p)
　　　　).full;
　cout << status << endl;
　return 0;
　}

　　初始調用失敗有以下幾個原因：

　　alpha_p 解析了單個的字符。要解析字符，必須使用 +alpha_p（這類似于 EBNF + 操作符，表示一個或多個字符，不同的是 Spirit 在前面而不是后面使用它）。

　　使用空格分隔字符串、整數和實數。必須解釋這種行為?？梢酝ㄟ^兩種方式實現：使用 ' '；或者使用 blank_p 預定義解析器，這更好，它同時解釋了空格和制表符。

　　下面是修改后的解析調用：

    parse(input.c_str, *((+alpha_p) >> ' ' >> int_p >> ' ' >> real_p) >> !blank_p);

　　第二個參數嚴格匹配一個非字母和數字組成的字符串，該字符串后面依次為空格、整數、另一個空格，最后是一個實數。當解析器達到實數后，它將查找一個空格/制表符，并重新開始匹配序列或終止。! 操作符表示空格/制表符出現了 0 次或 1 次。* 操作符表示該序列出現了 0 次或 1 次，并因此匹配一個空字符串。

　　顯然，第二個字符串與傳統解析器使用的潛在語法規則之間存在直接聯系。下面是針對當前需求的典型語法規則：

:S -> (ALPHA INT REAL)*

　　ALPHA、INT 和 REAL 通常由 lexer 提供。例如，INT 被定義為 (0-9)+?？梢允褂?Spirit 合并這些步驟。

　　如何診斷錯誤？

　　如果解析器出現了錯誤，可以使用幾種方法診斷2錯誤。最簡單的檢驗方法是測試 parse 方法返回的數據結構。返回的數據結構被稱為 parse_info，而 hit 字段表示解析是否成功完成。清單 3 展示了來自 Boost 源代碼的 parse_info 結構。

　　清單 3. 解析方法返回的 parse_info 結構

　 template
　 struct parse_info
　 {
　　　 IteratorT　 stop;　// points to final parse position
　　　 bool　　　　hit;　　　 // true when parsing is successful
　　　 bool　　　　full;　　　// when the parser consumed all the input
　　　 std::size_t length;　// number of characters consumed by parser
　　　 parse_info(
　　　　　 IteratorT const& stop_ = IteratorT,
　　　　　 bool hit_ = false,
　　　　　 bool full_ = false,
　　　　　 std::size_t length_ = 0)
　　　 : stop(stop_)
　　　 , hit(hit_)
　　　 , full(full_)
　　　 , length(length_) {}
　　　 template
　　　 parse_info(ParseInfoT const& pi)
　　　 : stop(pi.stop)
　　　 , hit(pi.hit)
　　　 , full(pi.full)
　　　 , length(pi.length) {}
　 };

　　Spirit 操作符及其語義

　　Spirit 附帶了一些預定義的操作符。表 1 總結了這些操作符及其語義。后面的示例將使用這些操作符。

　　表 1. Spirit 操作符及其語義

　　了解到目前為止所開發的內容之后，現在可以開始定義 C 風格的浮點數語法。清單 4 展示了 BNF。

　　清單 4. 用于浮點數的 BNF

    Real-Number : Fractional-Part (Exponent-Part)?
Fractional-Part : (DIGIT)* DOT (DIGIT)+
　　　　　　　　　　　　　　　|
　　　　　　　　　　　　　　　(DIGIT)+ DOT
Exponent-Part : ('e'|'E') ('+'|'-')? (DIGIT)+
DIGIT : ['0'-'9']
DOT : '.'

　　清單 5 提供了等效的 Spirit 語法。

　　清單 5. 浮點數的 Spirit 語法，與清單 4 的 BNF 等效

    Real-Number = Fractional-Part >> ! Exponent-Part
　　　　　　　　　　　　　|　+digit_p >> Exponent-Part
　　　　　　　　　　　　　;
Fractional-Part = *digit_p >> '.' >> +digit_p
　　　　　　　　　　　　　 |　+digit_p >> '.'
　　　　　　　　　　　　　 ;
Exponent-Part =　 ('e' | 'E') >> !('+' | '-') >> +digit_p;

　　可以看到，Spirit 上下文中的 Y = A >> B 與解析器上下文的 Y : A B 相同，其中 A 和 B 可以是末端，也可以是非末端。注意，用戶并不需要為此類瑣碎的操作定義語法：Spirit 已經提供了預定義的 parser real_p 來解析實數。

　　Spirit 中的預定義解析器

　　Spirit 框架的靈活性源于它為常見處理提供了眾多預定義解析器。表 2 提供了包含其中一些解析器的列表。

　　表 2. Spirit 中的一些預定義解析器

　　Spirit 指令

　　本節討論 Spirit 的另一個強大特性 —— 指令。Pascal 和 VHDL 等大小寫敏感語言中的 lexer 要復雜一些，因為它們必須解析 begin 和 BEGin 等內容并為解析器生成相同的標記。Spirit 使用 parser directives 解決這個問題。例如，預定義指令 as_lower_d 將輸入流轉換為小寫（參見清單 6）。

　　清單 6. 使用 as_lower_d 指令進行大小寫敏感的解析

#define　BOOST_SPIRIT_NO_REGEX_LIB
#include "regex.h"
#include "spirit.hpp"
#include "boost/spirit/actor/assign_actor.hpp"
using namespace std;
using namespace boost::spirit;
const string input = "THis iS a ranDOm sTRInG";
int main
　{
　string val;
　int status = parse (input.c_str,
　　　　　　　　　　　as_lower_d[str_p ("this is a random string")
　　　　　　　　　　　　　[assign_a(val)] ]).full;
　cout << status << endl;
　cout << val << endl;
　return 0;
　}

　　清單 6 的輸出為 1, THis iS a ranDOm sTRInG。必須理解解析器與解析器指令之間的差異，后者僅修改附帶的解析器的行為，實際上擴充了該解析器的策略。

　　Spirit 提供了其他預定義解析器的指令和一些編寫解析器的方法。讓我們看一下 longest_d 解析器指令。考慮清單 7 并猜猜它的輸出是什么。

　　清單 7. 使用模糊的語法進行解析

#define　BOOST_SPIRIT_NO_REGEX_LIB
#include "regex.h"
#include "spirit.hpp"
#include "boost/spirit/actor/assign_actor.hpp"
using namespace std;
using namespace boost::spirit;
const string input = "20245.1";
int main
　{
　int val;
　int status = parse (input.c_str, int_p[assign_a(val)] | real_p).full;
　cout << status << " " << val << endl;
　return 0;
　}

　　清單 7 的輸出是 0 20245。為什么會這樣？顯然，解析期間整個輸入緩沖區都沒有被使用，因此 status 為 0。為了理解這一點，需要注意 Spirit 是如何解析的：為示例規則 S : R1 | R2 | .. | RN 提供多個替代選擇，左邊的內容獲得最大優先權。這類似于 C/C++ 處理條件的方式：在表達式 if (x && y) 中，如果 x 為真，則不計算 y。這種行為有助于保持工具的處理速度。

　　在本例中，int_p 匹配 20245 —— 但是在這之后它遇到了一個點字符，并且沒有處理它的規則。因此，解析器退出。

　　解決方法是對語法規則的所有可用的替代內容進行重新分組，但是手動重新分組很容易出錯。更好的方法是使用 longest_d 指令，該指令將嘗試匹配消耗輸入流的最大長度的規則。清單 8 展示了修改后的 parse 例程調用。

　　清單 8. 使用 longest_d 預定義的解析器指令

　int status = parse (input.c_str,
　　　　　　　　　　　longest_d [int_p | real_p[assign_a(val)] ]
　　　　).full;

　　通過這一修改，輸出現在變為 1 20245.1。

　　使用 Spirit 開發完備的語法

　　本節將討論使用 Spirit 框架設計一組用戶定義的語法規則。要設計自己的語法，Spirit 要求執行以下操作：

　　創建一個從預定義 grammar 類繼承而來的派生類。grammar 類是一個模板類，被其派生類 DerivedT 和上下文類 ContextT 參數化。語法類的聲明如下所示：template<<br /> 　　　　typename DerivedT,
　　　　typename ContextT = parser_context<> >
　　struct grammar;

　　您設計的派生類必須有一個名為 definition（可以不修改此名）的嵌套的模板類/結構。definition 類有以下特性：

　　它是類型名為 ScannerT 的模板類。

　　語法規則在其構造函數中定義。構造函數被作為引用傳遞給實際的語法 self。

　　必須提供名為 start 的成員函數，它表示 start 規則。

　　清單 9 展示了用戶定義語法的基本框架。

　　清單 9. 用戶定義的語法類的基本框架

　　struct my-grammar : public grammar
　　{
　　　　template
　　　　struct definition
　　　　{
　　　　　　rule　startRule;
　　　　　　definition(my-grammar const& self)　{ /* define grammar rules here */ }
　　　　　　rule const& start const { return startRule; }
　　　　};
　　};

　　假設您希望支持清單 10 所示的簡單語法，該語法部分解析 C/C++ 枚舉。

　　清單 10. C/C++ 枚舉的簡單語法

    enum_specifIEr : ENUM '{' enumerator_list '}'
　　　 | ENUM IDENTIFIER '{' enumerator_list '}'
　　　 | ENUM IDENTIFIER
　　　 ;
enumerator_list : enumerator
　　　 | enumerator_list ',' enumerator
　　　 ;
enumerator : IDENTIFIER
　　　 ;
ENUM: "enum";
IDENTIFIER: ['a'..'z']+;

　　清單 11 展示了相應的 Spirit 代碼。程序的輸出為 1，表示成功完成解析。

　　清單 11. 解析 C/C++ 枚舉的 Spirit 代碼

#define　BOOST_SPIRIT_NO_REGEX_LIB
#include "regex.h"
#include "spirit.hpp"
#include "boost/spirit/actor/assign_actor.hpp"
using namespace std;
using namespace boost::spirit;
struct my_enum : public grammar
　　{
　　template
　　　struct definition
　　　　{
　　　　definition(my_enum const& self)
　　　　　{
　　　　　enum_specifier = enum_p >> '{' >> enum_list >> '}';
　　　　　enum_p = str_p("enum");
　　　　　enum_list = +id_p >> *(',' >> +id_p);
　　　　　id_p = range_p('a','z');
　　　　　}
　　　　　rule enum_specifier, enum_p, enum_list, id_p;
　　　　　rule const& start const { return enum_specifier; }
　　　　};
　　};
string input = "enum { ah, bk　}";
int main
　{
　my_enum e;
　int status = parse(input.c_str, e, space_p).hit;
　cout << status << endl;
　return 0;
　}