包的下載地址：dabeaz/ply: Python Lex-Yacc (package download)
官方文檔地址：dabeaz/ply: Python Lex-Yacc (official document)
貌似本體是其他學校的編譯課設...那確實不知道比我們高到哪里去了。
這個包提供了比較強大的 Lex / Yacc 工具，能夠完成不太復雜龐大的語法的詞法、語法分析，對於學校的大作業和課設來說是足夠的。
官方文檔中介紹了該包的基本使用方法，舉的例子是表達式解析。我在使用該包做MIPS匯編的語法檢查時（代碼可見：Github: LiuRunky - SEUCSE-Lab-Minisys-1A/assembler-src），用到了大部分的特性，並且有一些文檔中沒有寫出或強調的心得，於是就在這里一邊整理一邊記錄。
目錄：
ply 包提供的 Lex 工具能夠對於給定的文本進行詞法分析，內部的實現方式是通過正則匹配獲得一個文本中包含 Token 的列表，而我們要做的工作就是給定用於匹配的正則表達式。
其中 Token 是一個形式如下的四元組：[type, value, lineno, lexpos] 。其中 type 表示詞的類型（比如 variable / number / string，由我們來命名），value 就是文本中匹配上的內容（比如 "114514" / "0x1234" 都是合法的 number 類型），lineno 表示詞出現的行號，lexpos 表示詞出現在文本中的第幾個字符。一般來說 type 和 value 比較關鍵，而 lineno 和 lexpos 一般用於生成分析的報錯信息。
按照功能來分類的話，整個 ply Lex 的代碼（不含主函數內）分為如下三個部分（細節在之后會展開說）：
# 1. 包的引入 from ply import lex # 2. Token類型列表的聲明 tokens = ( 'TOKEN_1', 'TOKEN_2', 'TOKEN_3' ) # 3. Token匹配規則的聲明（字符串，函數） t_TOKEN_1 = r"""reg_expr_1""" t_TOKEN_2 = r"""reg_expr_2""" def t_TOKEN_3(t): r"""reg_expr_3""" return t
至於主函數內的調用，可以如下進行（在真正 Lex Yacc 聯合使用的時候不需要調用 lexer.input(data)，這是因為在 Yacc 內會自動地隱式調用 Lex，不過這個之后再說）：
if __name__ == '__main__': data = 'reg_expr_3reg_expr_2reg_expr_1' lexer = lex.lex() lexer.input(data) while True: token = lexer.token() print(token) if not token: break
雖然上面的例子毫無卵用，但是其實是可以運行的。運行以上代碼，結果如下：
其中，輸出了一行 None 是因為使用 lexer.token() 會自動獲取下一 Token，直到讀到文本末尾則返回 None。而 WARNING 中涉及的規則之后再議（其實不鳥它也完全沒關系）。
從上面的例子可以看出來，Token 類型列表 tokens 就是一個簡單的、由字符串組成的元組，其中每一個字符串表示一種 Token 的名稱。不過這里只是聲明了“有一種叫這個的 Token”，具體的匹配規則和匹配成功后的操作需要在之后補充完整。
需要注意的是，Token 名稱最好定義成全大寫字母。這是因為要與 Yacc 中的產生式進行區分（產生式一般定義成全小寫字母），這樣在寫 Yacc 部分的代碼時不容易混淆。
一些特殊的規則，比如 error（匹配不上時的操作）、ignore（需要忽略的字符）、literals（長度為1的符號的簡化定義方法），不需要在 Token 類型列表中出現，只需要在 Token 匹配規則中聲明 t_error、t_ignore，literals 則需要聲明一個符號的 List。可以看出來，這些特殊規則的名稱是全小寫字母。
上文已經介紹過了，Token 匹配規則的聲明有兩種方式：字符串與函數。無論哪種方式，都需要與 Token 名稱相對應、在名稱前加上"t_"（比如 Token 叫 "TOKEN_TYPE_1"，那么匹配規則就應該命名為 "t_TOKEN_TYPE_1"）。
可以認為字符串方式定義的規則是簡化版的函數方式，即以下兩種定義方式在功能上是等價的：
t_TOKEN = r"""expr""" def t_TOKEN(t) r"""expr""" return t
簡單比較兩者的區別的話，字符串方式比較簡單（只是進行匹配）、代碼長度短，而函數方式能夠在匹配成功后進行自定義的操作、功能更強。兩者除了功能以外，還在匹配優先級上有所區別，相對而言函數方式的優先級比較容易規定，這個在之后專門開了兩小節展開說。如果不放心的話可以全定義成函數方式。
之前代碼給出的匹配規則有點太弱了，現在給兩個畫風稍微正常一點的：
def t_IDNAME(t): r"""[a-zA-Z][0-9a-zA-Z]*""" return t def t_VALUE(t): r"""(0[xX][0-9a-fA-F]+)|([0-9]+)|([01]+[bB])""" return t
其中，t_IDNAME 約定了變量名的匹配規則（首字母不為數字，之后可以是字母或數字；原代碼不是C語言的規則，所以沒考慮下划線），而 t_VALUE 約定了數值的匹配規則（可以是二進制、十進制、十六進制，當為二進制時末尾必須有 "b" 或 "B"，當為十六進制時開頭必須為 "0x" 或 "0X"）。
這些匹配規則都是需要通過正則表達式給出的，如果不太了解Python的規則的話可以參考Python 正則表達式 | 菜鳥教程 。
(1) t_ignore：在匹配時忽略的一些字符，比如空格與制表符 "\t"
一個比較常用的定義方式如下，過濾了空格與 "\t"，注意這里不為raw string（由於 t_ignore 屬於優先級最低的規則了，所以往往用字符串方式定義，類似的用法可見 官方文檔4.8 - literal characters）：
t_ignore = ' \t'
不過這樣存在了一個問題：如果我們在 t_ignore 中規定過濾空格，那么就不能用詞法分析直接獲得含空格的 Token（比如C中的 "long long"類型）。示例代碼與運行結果如下：
# 1. 包的引入 from ply import lex # 2. Token類型列表的聲明 tokens = ( 'TOKEN_1', 'TOKEN_2', 'TOKEN_3' ) # 3. Token匹配規則的聲明（字符串，函數） t_TOKEN_1 = r"""long long""" # 優先級最高 t_TOKEN_2 = r"""longlong""" # 優先級次高 t_TOKEN_3 = r"""long""" # 優先級最低 t_ignore = ' \t' if __name__ == '__main__': data = 'long long longlong' lexer = lex.lex() lexer.input(data) while True: token = lexer.token() print(token) if not token: break
> WARNING: No t_error rule is defined > LexToken(TOKEN_3,'long',1,0) > LexToken(TOKEN_3,'long',1,5) > LexToken(TOKEN_1,'longlong',1,10) > None
(2) t_error：在匹配失敗時的動作
一般用於報錯，沒什么特別高級的功能。寫了和不寫差距不大，大概只是消除 WARNING 吧。
def t_error(t): raise Exception('Lex error {} at line {}, illegal character {}' .format(t.value[0], t.lineno, t.value[0]))
(3) literals：一些長度為1的簡單符號可以這樣定義
具體信息參見 Yacc 部分的章節 Yacc： 7. 產生式中簡單符號的簡化寫法
(4) 其他：t_eof 寫和不寫感覺是真沒區別...另外的規則參考官方文檔吧，不過貌似就只有這三個。
優先級規則其實是 ply 包中最重要的內容了（畢竟別的東西都封裝好了），而官方文檔在這里講的太粗了。我在文檔的基礎上再多補充些內容。
之前說到用字符串方式和函數方式定義匹配規則在優先級方面有所區別，具體區別如下：
(1) 如果用字符串方式定義，那么用於匹配的正則表達式越長則匹配優先級越高；
(2) 如果用函數方式定義，函數在代碼中出現的位置越靠前則匹配優先級越高；
(3) 用函數方式定義的匹配規則優先級永遠高於用字符串定義的。
這也是為什么說“不確定就用函數”，因為函數相對字符串更容易控制優先級。一般來說，用字符串方式定義的規則只有 t_ignore 和一些不容易成為其他規則前綴的匹配規則，比如逗號 ","、分號 ";" 一般是可以用字符串方式定義的；而保留字（如 "int"、"double"）則不合適，因為其容易被識別成變量名。
官方文檔關於優先級的討論到前文的規則 (1) (2) (3) 就結束了，但在實際使用中真正容易遇到的問題卻被忽略了：變量名與保留字沖突應該如何解決？
根據對於字符串定義方式的分析，我們知道了保留字應當用函數方式定義（保留字 > 變量名）；但是在現實中，我們經常可能定義一個前綴是保留字的變量，比如：
int int_number = 1; bool true_or_false = true;
如果我們規定保留字的優先級高於變量名，那么經過詞法分析，我們會得到這樣的 Token："int", "int", "_number", "=", "1", ";", "bool", "true", "_or_false", "=", "true", ";"。顯然，"int_number" 和 "true_or_false" 這兩個變量的解析是存在問題的，而這樣的問題在真正debug遇到的時候很難定位到。
如果想要解決這樣的問題，我們又需要規定前綴為保留字的變量優先級高於保留字（變量名 > 保留字），這下就產生矛盾了。
對於這樣的問題沒有一個簡單的解決方法，我們必須通過分解問題來解決。我想出的解決方案是，將變量名分為兩類：保留字前綴類（必須為保留字+其他字符） 和 非保留字前綴類。保留字前綴類的優先級高於保留字，非保留字前綴類的優先級低於保留字。不過這樣一來保留字類的匹配規則就會長得十分惡心，必須考慮到所有的保留字才能實現，所以我寫了一個C++代碼來根據保留字列表自動生成保留字前綴類的匹配規則。主要思想是對保留字建 trie 樹、打標記，然后在 trie 樹上 dfs，如果遇到標記（保留字的結尾）就再進行第二個 dfs，從而生成描述保留字與保留字之間互為前綴關系的匹配規則。
#include <map> #include <cstdio> #include <vector> #include <cstring> #include <iostream> #include <algorithm> using namespace std; typedef pair<int,int> pii; const int MAX_SYMBOL=300; const int MAX_STR_LEN=100; const int MAX_NODE_NUM=10000; int symbol=63; string full_collec="[a-zA-Z0-9_]"; int mapping[300]; char rmapping[MAX_SYMBOL]; bool init_symbol[MAX_SYMBOL]; bool extra_bslash[MAX_SYMBOL]; int tot=1; int tag[MAX_NODE_NUM]; int trie[MAX_NODE_NUM][MAX_SYMBOL]; bool pool[MAX_SYMBOL]; char pref[MAX_STR_LEN]; vector<string> solve(int x,int pos,int st_pos) { vector<string> ans; if(tag[x] && pos!=st_pos) return ans; memset(pool,false,sizeof(pool)); vector<int> v; for(int i=0;i<symbol;i++) if(trie[x][i]) pool[i]=true,v.emplace_back(i); vector<pii> v_res; for(int i=0;i<symbol;) { while(i<symbol && pool[i]) i++; if(i==symbol) break; int j=i+1; while(j<symbol && !pool[j] && !init_symbol[j]) j++; v_res.emplace_back(pii(i,j-1)); i=j; } if(v.empty()) return ans; string expr; for(int i=st_pos;i<pos;i++) expr=expr+pref[i]; expr=expr+'['; for(pii tmp: v_res) { char l=rmapping[tmp.first],r=rmapping[tmp.second]; if(l==r) { if(extra_bslash[tmp.first]) expr=expr+'\\'; expr=expr+l; } else expr=expr+l+'-'+r; } expr=expr+']'; ans.emplace_back(expr); for(int y: v) { pref[pos]=rmapping[y]; vector<string> ans_nxt=solve(trie[x][y],pos+1,st_pos); ans.insert(ans.end(),ans_nxt.begin(),ans_nxt.end()); } return ans; } map<string,vector<string>> combine; void dfs(int x,int pos) { vector<int> v; for(int i=0;i<symbol;i++) if(trie[x][i]) v.emplace_back(i); if(tag[x]) { string str_pref,expr; for(int i=0;i<pos;i++) str_pref=str_pref+pref[i]; vector<string> v_mid=solve(x,pos,pos); if(v_mid.size()>1) { expr=expr+'('; for(int i=0;i<v_mid.size();i++) expr=expr+v_mid[i]+(i+1==v_mid.size()?')':'|'); } else if(!v_mid.empty()) expr=expr+v_mid[0]; expr=expr+full_collec+(v_mid.empty()?'+':'*'); combine[expr].emplace_back(str_pref); } for(int y: v) { pref[pos]=rmapping[y]; dfs(trie[x][y],pos+1); } } int n; char buf[MAX_STR_LEN]; void init() { init_symbol[0]=true; for(int i=0;i<26;i++) mapping['a'+i]=i,rmapping[i]='a'+i; init_symbol[26]=true; for(int i=0;i<26;i++) mapping['A'+i]=26+i,rmapping[26+i]='A'+i; init_symbol[52]=true; for(int i=0;i<10;i++) mapping['0'+i]=52+i,rmapping[52+i]='0'+i; init_symbol[62]=extra_bslash[62]=false; mapping['_']=62,rmapping[62]='_'; } int main() { freopen("keywords.txt","r",stdin); init(); while(~scanf("%s",buf)) { n=strlen(buf); int cur=1; for(int i=0;i<n;i++) { int ch=mapping[buf[i]]; if(!trie[cur][ch]) trie[cur][ch]=++tot; cur=trie[cur][ch]; } tag[cur]=1; } /* for(int i=1;i<=tot;i++) for(int j=0;j<26;j++) if(trie[i][j]) printf("trie[%d][%c]=%d\n",i,char(j+'a'),trie[i][j]); */ pref[0]='\0'; dfs(1,0); vector<string> items; map<string,vector<string>>::iterator it; for(it=combine.begin();it!=combine.end();it++) { string r=it->first; vector<string> vl=it->second; sort(vl.begin(),vl.end()); reverse(vl.begin(),vl.end()); string item; if(vl.size()>1) item=item+'('; for(int i=0;i+1<vl.size();i++) { item=item+vl[i]+'|'; if((i+1)%5==0) item=item+'\n'; } item=item+vl.back(); if(vl.size()>1) item=item+')'; item=item+r; items.emplace_back(item); } for(int i=0;i<items.size();i++) { cout<<"(\n"<<items[i]<<"\n)"; if(i+1<items.size()) cout<<'|'; cout<<'\n'; } return 0; }
如果使用的話，需要根據實際需求修改的包括全局變量的 symbol（保留字數量）、full_collec（保留字中所有可能出現的字符，用正則表達式給出），以及 init() 函數中字符對可用字符標號的映射規則 mapping 與其逆映射 rmapping。另外，init_symbol[i] = true 表示標號 i 為某一類連續可用字符的開始（這里的“開始”指的是 "0-9" 中的 "0" 和 "a-z" 中的 "a" 等）或單獨的字符（比如 "_" 和 "$" 等），extra_bslash[i] = true 表示標號 i 代表的字符在輸出的時候需要加反斜杠 "\\"（在使用正則表達式定義的規則中，"+|-|*|/" 需要用轉義符寫作 "\+|\-|\*|\/"，因為這些符號在正則表達式中有具體意義；需不需要加雙反斜杠取決於Python的正則表達式規則）。
（UPD：講個笑話，實際測試下來，C語言子集的保留字 比 MIPS匯編的保留字 簡單好多，甚至可以手動避免前綴沖突）
Token 內的優先級指的是正則表達式內部的模式串互為前綴時，應當優先匹配哪個。比如存在兩種類型 "longlong" 與 "long"（之前說過了 ply.lex 不能匹配帶空格的規則 "long long"），而我們想用同一個規則 t_LONG_INT 來匹配。
對於這種情況，我們需要把較長的串寫在前面、較短的串寫在后面，即：
def t_LONG_INT(t): r"""longlong|long""" return t
在這種情況下，即使匹配上了 "long"、而在匹配 "longlong" 的過程中失敗了（比如文本為 "longdouble"），仍然會正確地返回 "long"，並且在 "long" 之后接着匹配；而如果將匹配規則寫作 r"""long|longlong"""，當目標串為 "longlong" 時則會返回兩個 "long"，就不是預期的結果了。
上面說到函數方法定義的規則支持相對比較復雜的操作，這里就挑兩個例子說明一下。
(1) 維護當前行號
ply.lex 本身是不會維護行號的（畢竟在一些語言中，"\n" 是應該被放進 t_ignore 中的），所以需要在掃到文本中的 "\n" 時維護 lexer.lineno：
def t_ENDL(t): r"""\n+""" t.lexer.lineno += len(t.value) return t
(2) 與全局變量聯動（例子：統計單詞數）
token_1_cnt = 0 def t_TOKEN_1(t): r"""token_1""" global token_1_cnt token_1_cnt += 1 return t
(3) 修改返回信息
在下一節返回值中細講。
在之前的函數方式定義中，我們都在最后寫上了 return t（t 為 Token 類型），不過並沒有說明它的用途；而在字符串方法中甚至完全不顯式地產生返回值（其實內部實現也只是單純地 return t）。現在我們來進一步分析返回值的機制和作用。
return t 到底被用到哪里去了，如果不返回會有什么后果？本着這樣的思路，我們采用函數方法定義如下的規則，並將 return t 刪去：
def t_TOKEN(t): r"""token"""
然后用文本 data = 'token' 進行詞法分析，結果會報錯，信息如下：
定位到錯誤拋出的地點，發現代碼段的注釋信息為 "No match. Call t_error() if defined."。可以看出如果不將 t 返回，Lex 就會認為沒有匹配上規則。
通過進一步分析（比如修改 t.value 並輸出），我們能夠發現，返回的 t 不僅是 lexer.token() 所獲得的 Token，t.value 更會出現在 Yacc 的語法分析中（而 t.type、t.lineno 和 t.lexpos 則在語法分析時不會保留，詳見 Yacc 部分的第5小節）。所以，我們不僅有必要將 t 返回，還可能需要將重要的信息額外保存在 t.value 中（比如 t.type，或是其他一些標記）。
我們可以自由地選擇 t.value 中保存的信息格式，Python中獨特的List類型是一個不錯的選擇：
# 這里僅給出了關鍵代碼 def t_VALUE(t): r"""(0[xX][0-9a-fA-F]+)|([0-9]+)|([01]+[bB])""" t.value = [t.type, t.value] return t data = '0x233'
運行后的 Token 輸出結果為：
> LexToken(VALUE,['VALUE', '0x8c'],1,0)
官方文檔中還介紹了一些我覺得有用的特性，不過我沒有用過，如果有需求可以自行閱讀。
官方文檔4.12 - the @TOKEN decorator：關於如何用 docstring 作為匹配規則；
官方文檔4.15 - alternative specification of lexers：關於如何將 lexer 封裝進自定義類中；
官方文檔4.19 - conditional lexing and start conditions：大概是允許在多種匹配模式中切換？有點沒看懂。
ply 包提供的 Yacc 工具能夠對於給定的文本進行語法分析。Yacc 采用類似 .y 文件的格式表示產生式，而我們需要給定這些產生式。
與 Lex 工具能夠獲得 Token 序列不太一樣，如果只使用最基本的 Yacc 只能夠檢查詞法分析后的 Token 序列是否滿足給定的語法規則，並沒有什么輸出。Yacc 真正強大的地方在於完成模式匹配后，能夠方便地確定每個 Token 在模式串中的角色，從而能夠在基礎語法檢查的基礎上稍加修改就能進行更高層級的檢查（比如檢查變量的未定義/重定義）以及高級語言向低級語言的轉化。
按照功能來分類的話，整個 ply Yacc 的代碼（不含 Lex 部分以及主函數內）分為如下兩個部分（細節在之后會展開說）：
# 1. 包的引入 from ply import yacc # 2. Production匹配規則的聲明 start = 'production' # 默認的起始產生式為p_start，可以通過給start賦值來修改為p_production def p_production(p): r"""production : TOKEN_1 | production TOKEN_2"""
主函數的調用如下所示，需要顯式地定義 lexer，但不需要向其中喂文本：
if __name__ == '__main__': data = '0x233' lexer = lex.lex() parser = yacc.yacc(debug=True) parser.parse(data)
如果沒有 Token 能接收十六進制數的話，就會產生形如下面的 Lex 報錯信息（匹配不到合適的詞，詞法分析失敗）：
如果有 Token 能接受十六進制數、但不是 TOKEN_1 時，就會產生形如下面的 Yacc 報錯信息（根據產生式可知，production 的開頭必須為 TOKEN_1）：
如果 TOKEN_1 可以接收十六進制數的話，就會產生形如下面的運行成功信息：
除了一堆 WARNING 以外就是生成 LALR table 的提示（這句提示在對於同一份規則第二次運行時就沒有了），之后啥輸出都沒有，所以往往需要采用后文介紹的方法通過輸出產生式的信息來進行debug。
Production 匹配規則只有函數聲明的方式，函數的名稱為 "p_" + 產生式名稱，且產生式的左項需要與產生式名稱相同。產生式的名稱不需要像 Token 名稱一樣預先寫在列表中。
當只有一個產生式時，raw string的格式為：
r"""production_name : token_name_1 production_name_2"""
當有多個產生式時，需要換行后寫在 "|" 符號的后面：
r"""production_name : token_name_1 token_name_2 | production_name token_name_3 | token_name_4"""
為了與詞法分析得到的 Token 區分，Production 的名稱一般定義為全小寫字母。
另外需要特別注意的是，假如產生式中需要遞歸，那么必須采用左遞歸。以下是一個簡單的表達式的例子：
def p_expr(p): r"""expr : expr OPERATOR NUMBER | NUMBER"""
這里再給出一個畫風比較正常的 Production 匹配規則的聲明：
def p_if(p): r"""if : IF LBRACKET TRUE RBRACKET | IF LBRACKET FALSE RBRACKET | IF LBRACKET expr BRACKET"""
這個匹配規則給出了一個簡化的C++中 if 語句條件的語法規則。其中 IF 匹配保留字 "if"，LBRACKET 匹配左括號 "("，RBRACKET 匹配右括號 ")"，TRUE 匹配保留字 "true"，FALSE 匹配保留字 "false"，expr 匹配一個產生表達式的 Production。
要說 Yacc 中比較特殊的匹配規則，大概只有 p_empty 了。p_empty 就是一般意義上的 $\epsilon$，定義方法如下：
def p_empty(p): """empty :""" pass
那么一個 $\mathrm{production}\rightarrow \epsilon$ 的產生式就可以寫作：
def p_production(p): r"""production : empty"""
在我們聲明 Production 的匹配規則時，傳入了一個參數 p。這個參數是我們獲得該完成匹配的模式串的唯一途徑。
p 是一個長度不固定的 List，實際長度等於 匹配上的產生式長度 + 1（因為當前產生式名稱作為左項占據了 p[0]）。舉個例子：
def p_production(p): r"""production : TOKEN_1 production_2 TOKEN_2 | TOKEN_3""" # ^ ^ ^ ^ # p[0] p[1] p[2] p[3]
假如產生式 production 的匹配結果是 TOKEN_1 production_2 TOKEN_2，那么 List 的長度為 4；假如匹配結果是 TOKEN_3，那么 List 的長度為 2。
p 里面裝的是什么東西呢？對於 Token 而言，p[i] 的值就是 Token.value，而 Token.type 的信息都被丟掉了（這個在介紹 Token 匹配規則的返回值時提到過）；而對於 Production 而言，如果不做任何操作，p[i] 的值是 None。如果想讓此時代表 production_2 的 p[i] 有值，我們就需要在 production_2 的匹配規則 p_production_2 中為 p[0] 賦值。示例如下：
def p_production_2(p): r"""production : empty""" p[0] = ['production_2', 'empty']
因為 Yacc 的匹配是一個遞歸的過程，所以當我們完成了 production 的匹配時，一定在此之前也完成了 production_2 的匹配，所以此時的 p[2] = ['production_2', 'empty']。
知道了 p 是什么東西以后，對於有多個產生式的 Production，我們可以通過分類討論 len(p) 的大小 以及具體某個 p[i] 的值來加以區分。訪問和操作也與正常操作 List 沒什么區別。
由於 p 是一個 List，所以我們可以往 p[i] 里塞任何東西。不過如果要塞多個屬性的話，最好用 List 裝起來便於操作。
除了 List 中的內容以外，Production 還支持獲取 Token.lineno 和 Token.lexpos，使用方法為 p.lineno(i) 和 p.lexpos(i)。還有一些細節有需要的話可以參考 官方文檔6.9 - line number and position tracking。
一時半會並不能想起來什么太高端的操作...就拿表達式求值 和 檢查變量是否未定義/重定義來說一說吧。
(1) 表達式求值
這個是官方文檔中描述的例子，其實整體思路很簡單：對於 Token，將 Token.value 轉為 int 類型；對於 Production，根據運算的類型（通過檢查運算符對應的 p[i] 的值加以分辨）執行相應的運算，將結果賦給 p[0] 即可。
為了簡單起見，只實現操作符為加減的表達式求值，更加復雜的表達式需要根據運算優先級設計 Production 的匹配規則，這里就不展開說了。
from ply import lex, yacc tokens = ( 'NUMBER', 'PLUS', 'MINUS' ) t_PLUS = r"""\+""" t_MINUS = r"""\-""" t_ignore = ' \t' def t_NUMBER(t): r"""[0-9]+""" t.value = int(t.value) return t start = 'expr' def p_expr(p): r"""expr : NUMBER | expr PLUS NUMBER | expr MINUS NUMBER""" if len(p) == 2: p[0] = p[1] elif p[2] == '+': p[0] = p[1] + p[3] else: p[0] = p[1] - p[3] if __name__ == '__main__': data = '1+2-3+4-5' lexer = lex.lex() parser = yacc.yacc(debug=True) print(parser.parse(data)) # 運行結果：-1
(2) 檢查變量定義
這是在寫課設時碰到的問題，實現起來也並不困難。在全局維護一個 Dict，當完成變量的定義時就檢查 Dict 中是否已有該變量名，從而檢查是否重定義；當使用到某個變量時，同樣在 Dict 中檢查該變量名，從而檢查是否未定義。
因為只是展示一下思路，所以對於語法做了很多簡化，通過 define 來定義變量，在表達式中使用變量。
from ply import lex, yacc tokens = ( 'VARIABLE', 'NUMBER', 'DEFINE', 'PLUS', 'MINUS', 'ENDL' ) t_PLUS = r"""\+""" t_MINUS = r"""\-""" t_ignore = ' \t' def t_DEFINE(t): r"""define""" return t def t_VARIABLE(t): r"""[a-zA-Z][0-9a-zA-Z]*""" t.value = ['VARIABLE', t.value] return t def t_NUMBER(t): r"""[0-9]+""" t.value = ['NUMBER', t.value] return t def t_ENDL(t): r"""\n+""" t.lexer.lineno += len(t.value) return t start = 'codes' dict_variable = {} def p_codes(p): r"""codes : code | codes ENDL code""" def p_code(p): r"""code : expr | define""" def p_define(p): r"""define : DEFINE VARIABLE""" if p[2][1] in dict_variable: raise Exception('redefined {} at line {}' .format(p[2][1], p.lineno(2))) else: dict_variable[p[2][1]] = p.lineno(2) def p_expr(p): r"""expr : NUMBER | VARIABLE | expr PLUS NUMBER | expr PLUS VARIABLE | expr MINUS NUMBER | expr MINUS VARIABLE""" if p[len(p)-1][0] == 'VARIABLE': if p[len(p)-1][1] not in dict_variable: raise Exception('undefined {} at line {}' .format(p[len(p)-1][1], p.lineno(2)))
if __name__ == '__main__': data = r"""define x define a x + a + 4 + b""" lexer = lex.lex() parser = yacc.yacc(debug=True) print(parser.parse(data)) # 報錯信息：Exception: undefined b at line 3
在實際情況中，很多 .y 文件中的產生式長這個樣子：
additive_expression : multiplicative_expression | additive_expression '+' multiplicative_expression | additive_expression '-' multiplicative_expression ;
像 '+'、'-' 這些長度為1的簡單符號（如果長度不為1，則需要通過詞法規則來定義，比如 '=='），如果我們必須分別定義 t_PLUS、t_MINUS 等 Token 的話，就稍微顯得有些麻煩——在產生式規則中，這些簡單符號的出現並不會引起歧義，並且絕大多數現成的 .y 文件都是采用了上面的簡化寫法。
對於上面的規則，我們可以這樣改寫成 Production 匹配規則：
def p_additive_expression(p): r"""additive_expression : multiplicative_expression | additive_expression '+' multiplicative_expression | additive_expression '-' multiplicative_expression""" if len(p) == 4: if p[2] == '+': p[0] = p[1] + p[3] if p[2] == '-': p[0] = p[1] - p[3]
不過，對於所有在產生式中使用到的簡單符號，我們需要將他們包含在 literals 中：
literals = ['+', '-']
使用 literals 規則，獲得的 Token 的 Token.type 與 Token.value 均為符號本身（類型為 str）。
使用這種簡化寫法，我們可以重寫上一節中表達式求值的代碼：
from ply import lex, yacc tokens = ( 'NUMBER', ) t_ignore = ' \t' literals = ['+', '-'] def t_NUMBER(t): r"""[0-9]+""" t.value = int(t.value) return t start = 'expr' def p_expr(p): r"""expr : NUMBER | expr '+' NUMBER | expr '-' NUMBER""" if len(p) == 2: p[0] = p[1] elif p[2] == '+': p[0] = p[1] + p[3] else: p[0] = p[1] - p[3] if __name__ == '__main__': data = '1+2-3+4-5' lexer = lex.lex() parser = yacc.yacc(debug=True) print(parser.parse(data)) # 運行結果：-1
官方文檔6.6 - dealing with ambiguous grammars：一般來說ambiguous grammer會導致產生shift-reduce或者reduce-reduce沖突，是應當盡量避免的。不過 ply.yacc 支持通過規定優先級的方式來避免這些沖突。
官方文檔6.8 - syntax error handling：更加高階的語法錯誤檢測，不會像目前的做法一樣遇到任何錯誤就終止。不過需要設置不少東西。
官方文檔6.11 - embedded actions：算是一個trick吧，可以在語法分析的過程中輸出中間信息。為什么這樣說起來感覺就很trivial...
牡蠣~ 感覺身體被掏空
感覺自己的contribution主要在於 Lex 那邊變量名避免撞保留字前綴的代碼生成，看了一遍document應該是沒有處理吧...如果里面直接解決了就顯得我很蠢了...
（完）