⑴ 編譯原理中pl/0符號表中oddsym是代表什麼符號
判斷一個表達式的結果是否為奇數，若為奇數返回真
⑵ 求C語言編譯原理語法分析程序
一繼承的詞法來自
http://blog.sina.com.cn/s/blog_67c9fc300100srad.html
二語法
用擴充的BNF表示如下：
⑴<程序>：：=begin<語句串>end
⑵<語句串>：：=<語句>{；<語句>}
⑶<語句>：：=<賦值語句>
⑷<賦值語句>：：=ID：=<表達式>
⑸<表達式>：：=<項>{+<項> | -<項>}
⑹<項>：：=<因子>{*<因子> | /<因子>
⑺<因子>：：=ID | NUM | （<表達式>）
三要求
輸入單詞串，以「#」結束，如果是文法正確的句子，則輸出成功信息，列印「success」，否則輸出「error」。
例如：
輸入 begin a:=9; x:=2*3; b:=a+x end #
輸出 success！
輸入 x:=a+b*c end #
輸出 error!
⑶ 什麼是文法(編譯原理)
【定義】
文法G定義為四元組（VN，VT，P，S）
其中 VN ：非終結符號(即語法變數)集
VT ： 終結符號集
VN∩VT =Φ，令V= VN∪VT，V稱為文法G的字母表或字匯表。
P ：產生式(α→β)集
S ：開始符號，且S∈VN ，S至少要在一條規則的左部出現。
【約定】
一般地，文法G的 四元組 不用全部給出 ，而只將產生式寫出。
約定：
（1）第一條產生式的左部是開始符號
（2）用尖括弧括起來的（或 大寫字母 ）是非終結符號
（3）不用尖括弧括起來（或 小寫字母 ）是終結符號
（4）還有一種習慣寫法，即 G[S] ，其中 S 是 開始符號 。
【舉例】
例: G=（VN，VT，P，S）
其中 VN={S}，
VT ={0，1}，
P={S→0S1，S→01}
S是開始符號
⑷ 編譯原理全部的名詞解釋
書上有別那麼懶！。。。。
編譯過程的六個階段：詞法分析，語法分析，語義分析，中間代碼生成，代碼優化，目標代碼生成
解釋程序：把某種語言的源程序轉換成等價的另一種語言程序——目標語言程序，然後再執行目標程序。解釋方式是接受某高級語言的一個語句輸入，進行解釋並控制計算機執行，馬上得到這句的執行結果，然後再接受下一句。
編譯程序：就是指這樣一種程序，通過它能夠將用高級語言編寫的源程序轉換成與之在邏輯上等價的低級語言形式的目標程序(機器語言程序或匯編語言程序)。
解釋程序和編譯程序的根本區別：是否生成目標代碼
句子的二義性（這里的二義性是指語法結構上的。）:文法G[S]的一個句子如果能找到兩種不同的最左推導(或最右推導)，或者存在兩棵不同的語法樹，則稱這個句子是二義性的。
文法的二義性:一個文法如果包含二義性的句子，則這個文法是二義文法，否則是無二義文法。
LL(1)的含義：(LL(1)文法是無二義的； LL(1)文法不含左遞歸)
第1個L：從左到右掃描輸入串 第2個L：生成的是最左推導
1 ：向右看1個輸入符號便可決定選擇哪個產生式
某些非LL(1)文法到LL(1)文法的等價變換: 1. 提取公因子 2. 消除左遞歸
文法符號的屬性:單詞的含義，即與文法符號相關的一些信息。如，類型、值、存儲地址等。
一個屬性文法(attribute grammar)是一個三元組A=(G, V, F)
G：上下文無關文法。
V：屬性的有窮集。每個屬性與文法的一個終結符或非終結符相連。屬性與變數一樣，可以進行計算和傳遞。
F：關於屬性的斷言或謂詞(一組屬性的計算規則)的有窮集。斷言或語義規則與一個產生式相聯，只引用該產生式左端或右端的終結符或非終結符相聯的屬性。
綜合屬性:若產生式左部的單非終結符A的屬性值由右部各非終結符的屬性值決定,則A的屬性稱為綜合屬
繼承屬性:若產生式右部符號B的屬性值是根據左部非終結符的屬性值或者右部其它符號的屬性值決定的,則B的屬性為繼承屬性。
(1)非終結符既可有綜合屬性也可有繼承屬性，但文法開始符號沒有繼承屬性。
(2) 終結符只有綜合屬性，沒有繼承屬性，它們由詞法程序提供。
在計算時： 綜合屬性沿屬性語法樹向上傳遞；繼承屬性沿屬性語法樹向下傳遞。
語法制導翻譯：是指在語法分析過程中，完成附加在所使用的產生式上的語義規則描述的動作。
語法制導翻譯實現：對單詞符號串進行語法分析，構造語法分析樹，然後根據需要構造屬性依賴圖，遍歷語法樹並在語法樹的各結點處按語義規則進行計算。
中間代碼（中間語言）
1、是復雜性介於源程序語言和機器語言的一種表示形式。
2、一般，快速編譯程序直接生成目標代碼。
3、為了使編譯程序結構在邏輯上更為簡單明確，常採用中間代碼，這樣可以將與機器相關的某些實現細節置於代碼生成階段仔細處理，並且可以在中間代碼一級進行優化工作，使得代碼優化比較容易實現。
何謂中間代碼：源程序的一種內部表示，不依賴目標機的結構，易於代碼的機械生成。
為何要轉換成中間代碼:(1)邏輯結構清楚；利於不同目標機上實現同一種語言。
(2)便於移植，便於修改，便於進行與機器無關的優化。
中間代碼的幾種形式：逆波蘭記號 ，三元式和樹形表示 ，四元式
符號表的一般形式：一張符號表的的組成包括兩項，即名字欄和信息欄。
信息欄包含許多子欄和標志位，用來記錄相應名字和種種不同屬性，名字欄也稱主欄。主欄的內容稱為關鍵字（key word）。
符號表的功能：（1）收集符號屬性 (2) 上下文語義的合法性檢查的依據： 檢查標識符屬性在上下文中的一致性和合法性。(3)作為目標代碼生成階段地址分配的依據
符號的主要屬性及作用：
1. 符號名 2. 符號的類型 （整型、實型、字元串型等））3. 符號的存儲類別（公共、私有）
4. 符號的作用域及可視性 （全局、局部） 5. 符號變數的存儲分配信息 （靜態存儲區、動態存儲區）
存儲分配方案策略：靜態存儲分配；動態存儲分配：棧式、 堆式。
靜態存儲分配
1、基本策略
在編譯時就安排好目標程序運行時的全部數據空間，並能確定每個數據項的單元地址。
2、適用的分配對象：子程序的目標代碼段；全局數據目標（全局變數）
3、靜態存儲分配的要求：不允許遞歸調用，不含有可變數組。
FORTRAN程序是段結構，不允許遞歸，數據名大小、性質固定。 是典型的靜態分配
動態存儲分配
1、如果一個程序設計語言允許遞歸過程、可變數組或允許用戶自由申請和釋放空間，那麼，就需要採用動態存儲管理技術。
2、兩種動態存儲分配方式：棧式，堆式
棧式動態存儲分配
分配策略：將整個程序的數據空間設計為一個棧。
【例】在具有遞歸結構的語言程序中，每當調用一個過程時，它所需的數據空間就分配在棧頂，每當過程工作結束時就釋放這部分空間。
過程所需的數據空間包括兩部分
一部分是生存期在本過程這次活動中的數據對象。如局部變數、參數單元、臨時變數等；
另一部分則是用以管理過程活動的記錄信息(連接數據)。
活動記錄（AR）
一個過程的一次執行所需要的信息使用一個連續的存儲區來管理，這個區 (塊)叫做一個活動記錄。
構成
1、臨時工作單元；2、局部變數；3、機器狀態信息；4、存取鏈；
5、控制鏈；6、實參；7、返回地址
什麼是代碼優化
所謂優化，就是對代碼進行等價變換，使得變換後的代碼運行結果與變換前代碼運行結果相同，而運行速度加快或佔用存儲空間減少。
優化原則：等價原則：經過優化後不應改變程序運行的結果。
有效原則：使優化後所產生的目標代碼運行時間較短，佔用的存儲空間較小。
合算原則：以盡可能低的代價取得較好的優化效果。
常見的優化技術
(1) 刪除多餘運算(刪除公共子表達式) (2) 代碼外提 +刪除歸納變數+ (3)強度削弱; (4)變換循環控制條件 (5)合並已知量與復寫傳播 (6)刪除無用賦值
基本塊定義
程序中只有一個入口和一個出口的一段順序執行的語句序列，稱為程序的一個基本塊。
給我分數啊。。。
⑸ 編譯原理——LR分析表
自底向上的語法分析
LR分析表的結構如上，其分為兩個部分 Action Goto
兩個參數狀態i，終結符號a（s(i)代表第i個狀態，r(i)代表第i條表達式）
Goto[i,A]=j
文法
容易得知這個文法可以推出 0 1 00 01 等的字元串。因為它是 左遞歸 。不適用於 LL 文法分析，只能使用 LR 分析。
因為本題入口有兩個—— S → L·L S → L ，所以需要構造額外的產生式 S'->S
2.1 第一次遍歷
我們從 [S -> . L·L] 開始，構造這個狀態的閉包，也就是加上所有能從這個產生式推出的表項。
首先，判斷 . 後面是否為 非終結符號A 。如果是，那我們就得找所有由 A-> 推出的產生式，並將它們添加進入 閉包 里(也就是State包里)。循環做即可。
因此我們可以得到 State 0 有
下一步，就是我的 . 往下一位移動。對每個符號X後有個 . 的項，都可以從 State 0 過渡到其他狀態。
由以上6條式子可以得知下一位符號可以是 S L B 0 1 。所以自然可以得到5個狀態。
State 1 是由 State 0 通過 S 轉移到這里的，所以我們找出所有 State 0 中在 S 前有 . 的項。
此狀態作為結束狀態 Accept ，不需要繼續狀態轉移了。
State 2 是由 State 0 通過 L 轉移到這里的，所以我們找出所有 State 0 中在 L 前有 . 的項。
S -> . L·L S -> . L L -> . LB
有3條式子，現在我們將 . 向後推一格，就得到 State 1 的項了。
但是 . 之後的符號分別是 · $ B ， B 為非終結符號，我們得包含 B -> 的項
State 3 是由 State 0 通過 B 轉移到這里的，所以我們找出所有 State 0 中在 B 前有 . 的項。
因為 . 後沒有其他符號了，因此這個狀態不需要繼續轉移了。
State 4 是由 State 0 通過 0 轉移到這里的，所以我們找出所有 State 0 中在 0 前有 . 的項。
因為 . 後沒有其他符號了，因此這個狀態不需要繼續轉移了。
很簡單，同樣的道理找 State 5
State 5 是由 State 0 通過 1 轉移到這里的，所以我們找出所有 State 0 中在 1 前有 . 的項。
因為 . 後沒有其他符號了，因此這個狀態不需要繼續轉移了。
好的，現在我們第一次遍歷完成。
2.2 第二次遍歷
第二次遍歷自然從 State 2 開始。
我們回到 State2 ，可以看出 . 之後的符號有 · B 0 1 。
State 6 是由 State 2 通過 · 轉移到這里的，所以我們找出所有 State 2 中在 · 前有 . 的項。
S -> L. ·L 只有1條，我們往後移發現 L 又為非終結符號，參考 State 0 做的操作，我們得找出所有的式子。
共有5條式子，共同組成 State 6 ，由上面的式子可以看出我們還得繼續下一次遍歷。先不管著，我們進行下一次狀態查找。
State 7 是由 State 2 通過 B 轉移到這里的，所以我們找出所有 State 2 中在 B 前有 . 的項。
L -> L. B 也是只有1條，我們往後移發現沒有非終結符號了，那就不需要再繼續添加其他式子了。
這個狀態也不需要繼續進行轉移了。
接下來很關鍵，因為我們通過 State2 的 . 後的符號找出了 State 6 State 7 ，接下來還差符號 0 1 ，那麼是否像之前一樣按例添加狀態呢， 答案是不是的 ，因為我們發現通過 0 1 找到的閉包集分別是 B -> 0 B -> 1 ，這與我們的之前的 State 4 State 5 相同。所以我們得將其整合起來，相當於 State 2 通過 0 1 符號找到了 State 4 State 5 狀態。
2.3 第三次遍歷
回頭看第二次遍歷，可以看出只有 State 6 可以進行狀態轉移了。
那麼就將 State 6 作為第三次遍歷的源頭，可以看出 . 之後的符號有 L B 0 1 。
State 8 是由 State 6 通過 L 轉移到這里的，所以我們找出所有 State 6 在 L 前有 . 的項。
S -> L· .L L -> . LB 有兩條式子，往後移發現有非終結符號 B ，所以經過整合可以得到
可以看出 . 的後面還有一個符號，所以這里我們還得再進行一次遍歷。
接下來，又是遇到重復的包的情況，可以看出我們由 State 6 通過 B 0 1 得到的閉包分別是 L->B B->0 B->1 ，很明顯，這分別對應於 State 3 State 4 State 5 。
第三次遍歷也就結束了。
2.4 第四次遍歷
回看第三次遍歷，可以看出只有 State 8 可以進行狀態轉移，其 . 之後的符號分別是 B 0 1 。
誒，感覺很熟悉，就是上面幾行剛說的情況，也就是說通過這三個符號找到的閉包是我們之前遇到的狀態，分別是 State 3 State 4 State 5 。
做到這里，我們發現我們已經全部遍歷完畢！
總共有8個狀態，通過以上流程做成個圖是什麼樣子的？來看看！
這么一看就很清晰明了了，我們就可以通過這個圖做出我們的 LR分析表
其實就是我們之前呈現的表
在狀態 I2 和 I8 中，既有 移入 項目，也有 規約 項目，存在 移入 - 規約的沖突 ，所以不是 LR(0) 文法，但是因為 FOLLOW(S) ∩ {0, 1} = ∅，所以可以用 FOLLOW 集解決沖突，所以該文法是 SLR(1) 文法。
上表我們發現還有 r1，r2，r3 等。這個其實就是代表狀態停止轉移時為 第幾條表達式 ，r3代表第三條表達式 L -> LB 。
當我們構建了表之後，我們如何運用起來呢？
下面我們通過一個例子來說明
以上字元串是如何被SLR分析器識別的呢？
⑹ 編譯原理有有符號un-1.u=un嗎
編譯程序把源程序翻譯為目標程序。根據源程序的語言種類，翻譯程序可以分為匯編程序與編譯程序。與之相對，解釋程序是對源程序進行解釋執行的程序。相應的可以將高級語言分為
編譯型 C/C++, Swift, etc.
解釋型 Python, javascript, etc.
混合型 Java, etc.
本文重點放在編譯程序的設計上。典型的編譯程序具有 7 77 個邏輯部分
對源程序掃描一次被稱為一遍 (pass)。典型的一遍掃描編譯程序有如下形式
通常將中間代碼生成前的分析部分稱為編譯器的前端，其後的綜合部分則被稱為後端。這樣就把一個編譯程序分為了與源語言相關和與目標機有關的兩個獨立的部分，降低了程序的耦合。假設 llvm 編譯器 支持 M MM 種源語言到 N NN 種目標語言的編譯
傳統的編譯器如 gcc 可能需要開發 M × N M \times NM×N 個不同的子模塊。而 llvm 使用統一的中間語言 llvm Intermediate Representation 只需要 M MM 個前端與 N NN 個後端，大大降低了開發成本。
文法
設非空有窮集合 Σ \SigmaΣ 為一字母表，則其上的符號串為 ∀ s ∈ Σ ∗ \forall s \in \Sigma^*∀s∈Σ
∗
，其中 ∗ *∗ 表示集合的閉包。特別的記 Σ 0 = ε \Sigma^0 = {\varepsilon}Σ
0
=ε 為空串組成的集合。規則通常寫作
U : : = x or U → x , ∣ U ∣ = 1 , ∣ x ∣ ≥ 0 U ::= x\text{ or }U\rightarrow x,\quad |U| = 1, |x| \ge 0U::=x or U→x,∣U∣=1,∣x∣≥0
其中左部 U UU 是符號，右部 x xx 是有窮符號串。規則的集合 P PP 即可確定一個文法 G GG
<程序> ::= <常量說明><變數說明><函數說明>
<常量說明> ::= {const<常量定義>;}
<常量定義> ::= int<標識符>=<整數>{,<標識符>=<整數>}|char<標識符>=<字元>{,<標識符>=<字元>}
<變數說明> ::= {<類型標識符><變數定義>;}
<變數定義> ::= <標識符>[<下標>]{,<標識符>[<下標>]}
<下標> ::= '['<無符號整數>']' // <無符號整數>表示數組元素的個數，其值需大於0
<函數說明> ::= {(<類型標識符>|void)<函數定義>}void<主函數>
<函數定義> ::= <標識符>'('<參數表>')'<復合語句>
<參數表> ::= [<類型標識符><標識符>{,<類型標識符><標識符>}]
<主函數> ::= main'('')'<復合語句>
<復合語句> ::= '{'<常量說明><變數說明>{<語句>}'}'
<語句> ::= <條件語句>|'{'{<語句>}'}'|<函數調用語句>;|<賦值語句>;|<讀語句>;|<寫語句>;|<返回語句>;|;
<條件語句> ::= <if語句>|<while語句>|<do語句>|<for語句>
<if語句> ::= if'('<條件>')'<語句>[else<語句>]
<while語句> ::= while'('<條件>')'<語句>
<do語句> ::= do<語句>while'('<條件>')'
<for語句> ::= for'('<標識符>=<表達式>;<條件>;<標識符>=<標識符><加法運算符><無符號整數>')'<語句>
<條件> ::= <表達式>[<關系運算符><表達式>] // 表達式為0條件為假，否則為真
<函數調用語句> ::= <標識符>'('[<表達式>{,<表達式>}]')'
<賦值語句> ::= <標識符>['['<表達式>']']=<表達式>
<讀語句> ::= scanf'('<標識符>{,<標識符>}')'
<寫語句> ::= printf'('<字元串>[,<表達式>]')'|printf'('<表達式>')'
<返回語句> ::= return['('<表達式>')']
<表達式> ::= [<加法運算符>]<項>{<加法運算符><項>} // [+|-]只作用於第一個<項>
<項> ::= <因子>{<乘法運算符><因子>}
<因子> ::= <標識符>['['<表達式>']']|'('<表達式>')'|<整數>|<字元>|<函數調用語句>
<整數> ::= [<加法運算符>]<無符號整數>
<標識符> ::= <字母>{<字母>|<數字>}
<無符號整數> ::= <非零數字>{<數字>}|0
<數字> ::= 0|<非零數字>
<非零數字> ::= 1|...|9
<字元> ::= '<加法運算符>'|'<乘法運算符>'|'<字母>'|'<數字>'
<字元串> ::= "{十進制編碼為32,33,35-126的ASCII字元}"
<類型標識符> ::= int|char
<加法運算符> ::= +|-
<乘法運算符> ::= *|/
<關系運算符> ::= <|<=|>|>=|!=|==
<字母> ::= _|a|...|z|A|...|Z
復制
上述文法使用擴充的 BNF 表示法進行描述
符號 定義 說明
∣ \vert∣ 或 作用域由括弧限定
{ t } n m \{t\}^m_n{t}
n
m
將 t tt 重復連接 n ∼ m n \sim mn∼m 次 預設時 m = ∞ , n = 0 m = \infin,\ n = 0m=∞, n=0
[ t ] [t][t] 符號串 t tt 可有可無 等價於 { t } 1 \{t\}^1{t}
1
( t ) (t)(t) 局部作用域 主要用於限定 ∣ \vert∣ 范圍
相關概念有
概念 符號 定義 示例
識別符號 Z ZZ 文法中第一條規則的左部符號 <程序>
字匯表 V VV 文法中出現的全部符號 { <程序>, <常量說明>, …, 0, 1, … }
非終結符號集 V n V_nV
n
全部規則的左部組成的集合 { <程序>, <常量說明>, <變數說明>, … }
終結符號集 V t V_tV
t
V − V n V - V_nV−V
n
{ 0, 1, …, _, a, b, … }
設 U : : = u ∈ P U ::= u \in PU::=u∈P 則對於 ∀ x , y ∈ V ∗ \forall x, y \in V^*∀x,y∈V
∗
有直接推導 x U y ⇒ x u y xUy \Rightarrow xuyxUy⇒xuy 。如果 y ∈ V t ∗ y \in V_t^*y∈V
t
∗
則 x U y ⤃ x u y xUy\ ⤃\ xuyxUy ⤃ xuy 稱為規范推導。直接推導序列 u 0 ⇒ u 1 ⇒ ⋯ ⇒ u n u_0 \Rightarrow u_1 \Rightarrow \cdots \Rightarrow u_nu
0
⇒u
1
⇒⋯⇒u
n
可簡記為
{ u 0 ⇒ + u n n > 0 u 0 ⇒ ∗ u n n ≥ 0 \begin{cases} u_0 \mathop\Rightarrow\limits^+ u_n & n > 0\\ u_0 \mathop\Rightarrow\limits^* u_n & n \ge 0\\ \end{cases}{
u
0
⇒
+
u
n
u
0
⇒
∗
u
n
n
>
0
n
≥
0
進一步定義
句型 V ∗ ∋ x ⇐ ∗ Z V^* \ni x \mathop\Leftarrow\limits^* ZV
∗
∋x
⇐
∗
Z
句子 V t ∗ ∋ x ⇐ + Z V_t^* \ni x \mathop\Leftarrow\limits^+ ZV
t
∗
∋x
⇐
+
Z
語言 L ( G ) = { x ∣ x is sentence } L(G) = \{ x| x\text{ is sentence} \}L(G)={x∣x is sentence}
如果文法 G GG 和 G ′ G'G
′
有 L ( G ) = L ( G ′ ) L(G) = L(G')L(G)=L(G
′
) ，則稱這兩個文法等價。設 w = x u y w=xuyw=xuy 為一句型，稱 u uu 為一個相對於 U ∈ V n U \in V_nU∈V
n
的
w ww 的短語 如果 Z ⇒ ∗ x U y ∧ U ⇒ + u Z \mathop\Rightarrow\limits^* xUy \land U \mathop\Rightarrow\limits^+ uZ
⇒
∗
xUy∧U
⇒
+
u
w ww 的簡單短語 如果 u uu 是短語且 U ⇒ u U \mathop\Rightarrow\limits uU⇒u
句型的最左簡單短語稱為句柄。
二義性
文法 G GG 是二義性的，如果 ∃ x ∈ L ( G ) \exist x \in L(G)∃x∈L(G) 使下列條件之一成立
x xx 可以對應兩顆不同的語法樹
x xx 有兩個不同的規范推導
⑺ 編譯原理課程設計
%{
/* FILENAME: C.Y */
%}
#define YYDEBUG_LEXER_TEXT (yylval) /* our lexer loads this up each time */
#define YYDEBUG 1 /* get the pretty debugging code to compile*/
#define YYSTYPE char * /* interface with flex: should be in header file */
/* Define terminal tokens */
/* keywords */
%token AUTO DOUBLE INT STRUCT
%token BREAK ELSE LONG SWITCH
%token CASE ENUM REGISTER TYPEDEF
%token CHAR EXTERN RETURN UNION
%token CONST FLOAT SHORT UNSIGNED
%token CONTINUE FOR SIGNED VOID
%token DEFAULT GOTO SIZEOF VOLATILE
%token DO IF STATIC WHILE
/* ANSI Grammar suggestions */
%token IDENTIFIER STRINGliteral
%token FLOATINGconstant INTEGERconstant CHARACTERconstant
%token OCTALconstant HEXconstant
/* New Lexical element, whereas ANSI suggested non-terminal */
%token TYPEDEFname /* Lexer will tell the difference between this and
an identifier! An identifier that is CURRENTLY in scope as a
typedef name is provided to the parser as a TYPEDEFname.*/
/* Multi-Character operators */
%token ARROW /* -> */
%token ICR DECR /* ++ -- */
%token LS RS /* << >> */
%token LE GE EQ NE /* <= >= == != */
%token ANDAND OROR /* && || */
%token ELLIPSIS /* ... */
/* modifying assignment operators */
%token MULTassign DIVassign MODassign /* *= /= %= */
%token PLUSassign MINUSassign /* += -= */
%token LSassign RSassign /* <<= >>= */
%token ANDassign ERassign ORassign /* &= ^= |= */
%start translation_unit
%%
/* CONSTANTS */
constant:
INTEGERconstant
| FLOATINGconstant
/* We are not including ENUMERATIONconstant here because we
are treating it like a variable with a type of "enumeration
constant". */
| OCTALconstant
| HEXconstant
| CHARACTERconstant
;
string_literal_list:
STRINGliteral
| string_literal_list STRINGliteral
;
/************************* EXPRESSIONS ********************************/
primary_expression:
IDENTIFIER /* We cannot use a typedef name as a variable */
| constant
| string_literal_list
| '(' comma_expression ')'
;
postfix_expression:
primary_expression
| postfix_expression '[' comma_expression ']'
| postfix_expression '(' ')'
| postfix_expression '(' argument_expression_list ')'
| postfix_expression {} '.' member_name
| postfix_expression {} ARROW member_name
| postfix_expression ICR
| postfix_expression DECR
;
member_name:
IDENTIFIER
| TYPEDEFname
;
argument_expression_list:
assignment_expression
| argument_expression_list ',' assignment_expression
;
unary_expression:
postfix_expression
| ICR unary_expression
| DECR unary_expression
| unary_operator cast_expression
| SIZEOF unary_expression
| SIZEOF '(' type_name ')'
;
unary_operator:
'&'
| '*'
| '+'
| '-'
| '~'
| '!'
;
cast_expression:
unary_expression
| '(' type_name ')' cast_expression
;
multiplicative_expression:
cast_expression
| multiplicative_expression '*' cast_expression
| multiplicative_expression '/' cast_expression
| multiplicative_expression '%' cast_expression
;
additive_expression:
multiplicative_expression
| additive_expression '+' multiplicative_expression
| additive_expression '-' multiplicative_expression
;
shift_expression:
additive_expression
| shift_expression LS additive_expression
| shift_expression RS additive_expression
;
relational_expression:
shift_expression
| relational_expression '<' shift_expression
| relational_expression '>' shift_expression
| relational_expression LE shift_expression
| relational_expression GE shift_expression
;
equality_expression:
relational_expression
| equality_expression EQ relational_expression
| equality_expression NE relational_expression
;
AND_expression:
equality_expression
| AND_expression '&' equality_expression
;
exclusive_OR_expression:
AND_expression
| exclusive_OR_expression '^' AND_expression
;
inclusive_OR_expression:
exclusive_OR_expression
| inclusive_OR_expression '|' exclusive_OR_expression
;
logical_AND_expression:
inclusive_OR_expression
| logical_AND_expression ANDAND inclusive_OR_expression
;
logical_OR_expression:
logical_AND_expression
| logical_OR_expression OROR logical_AND_expression
;
conditional_expression:
logical_OR_expression
| logical_OR_expression '?' comma_expression ':'
conditional_expression
;
assignment_expression:
conditional_expression
| unary_expression assignment_operator assignment_expression
;
assignment_operator:
'='
| MULTassign
| DIVassign
| MODassign
| PLUSassign
| MINUSassign
| LSassign
| RSassign
| ANDassign
| ERassign
| ORassign
;
comma_expression:
assignment_expression
| comma_expression ',' assignment_expression
;
constant_expression:
conditional_expression
;
/* The following was used for clarity */
comma_expression_opt:
/* Nothing */
| comma_expression
;
/******************************* DECLARATIONS *********************************/
/* The following is different from the ANSI C specified grammar.
The changes were made to disambiguate typedef's presence in
declaration_specifiers (vs. in the declarator for redefinition);
to allow struct/union/enum tag declarations without declarators,
and to better reflect the parsing of declarations (declarators
must be combined with declaration_specifiers ASAP so that they
are visible in scope).
Example of typedef use as either a declaration_specifier or a
declarator:
typedef int T;
struct S { T T;}; /* redefinition of T as member name * /
Example of legal and illegal statements detected by this grammar:
int; /* syntax error: vacuous declaration * /
struct S; /* no error: tag is defined or elaborated * /
Example of result of proper declaration binding:
int a=sizeof(a); /* note that "a" is declared with a type in
the name space BEFORE parsing the initializer * /
int b, c[sizeof(b)]; /* Note that the first declarator "b" is
declared with a type BEFORE the second declarator is
parsed * /
*/
declaration:
sue_declaration_specifier ';'
| sue_type_specifier ';'
| declaring_list ';'
| default_declaring_list ';'
;
/* Note that if a typedef were redeclared, then a declaration
specifier must be supplied */
default_declaring_list: /* Can't redeclare typedef names */
declaration_qualifier_list identifier_declarator {} initializer_opt
| type_qualifier_list identifier_declarator {} initializer_opt
| default_declaring_list ',' identifier_declarator {} initializer_opt
;
declaring_list:
declaration_specifier declarator {} initializer_opt
| type_specifier declarator {} initializer_opt
| declaring_list ',' declarator {} initializer_opt
;
declaration_specifier:
basic_declaration_specifier /* Arithmetic or void */
| sue_declaration_specifier /* struct/union/enum */
| typedef_declaration_specifier /* typedef*/
;
type_specifier:
basic_type_specifier /* Arithmetic or void */
| sue_type_specifier /* Struct/Union/Enum */
| typedef_type_specifier /* Typedef */
;
declaration_qualifier_list: /* const/volatile, AND storage class */
storage_class
| type_qualifier_list storage_class
| declaration_qualifier_list declaration_qualifier
;
type_qualifier_list:
type_qualifier
| type_qualifier_list type_qualifier
;
declaration_qualifier:
storage_class
| type_qualifier /* const or volatile */
;
type_qualifier:
CONST
| VOLATILE
;
basic_declaration_specifier: /*Storage Class+Arithmetic or void*/
declaration_qualifier_list basic_type_name
| basic_type_specifier storage_class
| basic_declaration_specifier declaration_qualifier
| basic_declaration_specifier basic_type_name
;
basic_type_specifier:
basic_type_name /* Arithmetic or void */
| type_qualifier_list basic_type_name
| basic_type_specifier type_qualifier
| basic_type_specifier basic_type_name
;
sue_declaration_specifier: /* Storage Class + struct/union/enum */
declaration_qualifier_list elaborated_type_name
| sue_type_specifier storage_class
| sue_declaration_specifier declaration_qualifier
;
sue_type_specifier:
elaborated_type_name /* struct/union/enum */
| type_qualifier_list elaborated_type_name
| sue_type_specifier type_qualifier
;
typedef_declaration_specifier: /*Storage Class + typedef types */
typedef_type_specifier storage_class
| declaration_qualifier_list TYPEDEFname
| typedef_declaration_specifier declaration_qualifier
;
typedef_type_specifier: /* typedef types */
TYPEDEFname
| type_qualifier_list TYPEDEFname
| typedef_type_specifier type_qualifier
;
storage_class:
TYPEDEF
| EXTERN
| STATIC
| AUTO
| REGISTER
;
basic_type_name:
INT
| CHAR
| SHORT
| LONG
| FLOAT
| DOUBLE
| SIGNED
| UNSIGNED
| VOID
;
elaborated_type_name:
aggregate_name
| enum_name
;
aggregate_name:
aggregate_key '{' member_declaration_list '}'
| aggregate_key identifier_or_typedef_name
'{' member_declaration_list '}'
| aggregate_key identifier_or_typedef_name
;