實現一個C++實現的拓展C0文法MIPS交叉編譯器

本文禁止任何爬蟲爬取!來源：http://www.cnblogs.com/sciencefans/

學期終於結束了~這學期學習了編譯原理，同時做了北航最高難度的編譯課程設計——設計實現一個拓展C0文法的編譯器。

那么接下來貼一下編譯器設計的設計和實現細節吧。

本文將介紹一個小型編譯系統的實現，通過作者在兩個月的課程設計中總結出來的一些經驗接地氣地講一講如何一步一步構建一個編譯器，詳盡的說明其中的很多困難，以及作者是如何一步一步解決他們的。讓擁有很少編程經驗的同學也能夠有所收獲。

本系統實現了一個以擴充C0文法為輸入語言的采用C++語言和面向過程的思路設計的編譯器，采用遞歸子程序的方法來設計分析過程。可以生成符合MIPS指令集規范的匯編代碼，用MARS匯編可生成32位應用程序。

本系統考慮到不同MIPS模擬器的功能和使用方法的差異，以及用戶手工鍵入匯編，多有不便，本系統采用了在windows，Linux和mac系統下均可是用的Mars simulator作為模擬工具。

課程設計一發下來，只有一個PPT，一個文檔樣例，一個需求說明和三種難度的文法。沒有任何的指導手冊和講解，完全要靠自己啦~

畢竟初生牛犢不怕虎，習慣性地選擇了高難度。點開之后發現居然有四十多條文法，很多還是復合文法。感覺有些復雜，再加上這種比較大的工程如果一開始沒有設計好到最后會非常痛苦，所以即使有一些設計的想法在證明完備之前也一時不敢下手。

后來去圖書館查閱了一些相關的書籍，發現不論是C，Pascal還是Fortran，都是遵循詞法分析->一種語法語義分析的方法->轉換為中間代碼->生成機器指令並鏈接這樣的步驟來的，感覺如果自己這樣也應該不會有什么大錯，於是就從詞法分析開始寫起。

剛開始寫lax的時候感覺不就是一個狀態比較多的自動機么，於是就很快設計了一個NFA，結果發現光有NFA是遠遠不行滴，因為存在很多的不確定分支。於是重新翻課本，按照課本上的方法確定花最小化成DFA然后代碼實現之后寫完了。比如舉一個簡單的例子，首先我們看下面的NFA，它是從一組詞法分析所用的正則表達式轉換而來的。這個NFA合並了IF、ID、NUM、error這四個單詞的NFA。因此，它的四個接受狀態分別代表遇到了四種不同的單詞。

設計好之后因為它包含很多的不確定分支和ε，所以需要做一次NFA->DFA的確定化。按照課本上的方法，用ε-閉包的方法就求得了一個DFA，用上圖的例子，我們可以得到如下DFA，可以證明這個DFA和上圖中的NFA是等價的。

之后，可以采用直接狀態機的編碼方式來編寫，也可以采用逐步判斷分支的方式來編寫，我采用的是后者，在程序中可以清晰的看見。

在編寫的過程中也沒有遇到太多困難，我覺得其中值得一提的就是預讀行緩沖這個部分了。記得在做這個實驗之前就已經閱讀了pl0編譯器的源碼，它也采用了行緩沖技術。當時在閱讀源碼的時候還感覺很奇怪，從小文件里讀字符何必要采用這種十來個byte的buffer緩沖技術呢，當我自己實現的時候我才意識到它的重要性。在出錯處理的時候，需要用到它來記錄定位出錯的位置，此外，在閱讀需要回溯的個別文法的時候比如定義變量和定義函數具有相同的前三個詞型，這時當判斷出了是哪一類的時候需要回溯處理（雖然改寫了文法消除了回溯但是回溯會使得程序更加好寫，且並不會增加太多效率負擔），行緩沖技術在這里就派上用場了，他可以直接讀取前幾個字符，而不需要再對文件指針進行處理。

詞法分析第二個值得一提的就是對於常數的處理了。有些同學采用讀取有符號常數的方法，比如“-123”會被當做一個詞語讀入。但是我覺得這樣會導致在語法分析中的極大不便。比如在處理“—123”，“+-123”等這種語句的時候會非常麻煩。於是我將常熟前面的符號都提出來，分別當成兩個單詞讀入，這在后面的語法分析的過程中證明了這是一個非常好的設計選擇。

詞法分析之后就該寫語法分語義分析了。因為是自己開發能，本着能用即可的原則，我才用了最好用程序實現的遞歸子程序的方法。也稱為遞歸下降法，這是一種適合手寫語法編譯器的方法，且非常簡單。遞歸下降法對語言所用的文法有一些限制，但遞歸下降是現階段主流的語法分析方法，因為它可以由開發人員高度控制，在提供錯誤信息方面也很有優勢。就連微軟C#官方的編譯器也是手寫而成的遞歸下降語法分析器。使用遞歸下降法編寫語法分析器無需任何類庫，編寫簡單的分析器時甚至連前面學習的詞法分析庫都無需使用。

我思考了一下語法分析的過程，聯想起課堂上老師講的LL分析法，LR分析法等，感覺每種文法都要有自己的條件，那么我所選到的文法是否符合這個條件呢？這是我當時遇到的難題。盡管當時老師說使用這個方法是問題不大的，頂多需要改一點點文法，但是仍然想自己證明一下放置到最后出現文法不匹配的問題。因為是上下文無關的文法，首先必須要通過超前查看進行分支預測。支持遞歸下降的文法，必須能通過從左往右超前查看k個字符決定采用哪一個產生式。書上稱這種文法為LL(k)文法。這里的超前閱讀正是使用了之前我所說的行緩沖技術才能達到這一點，否則直接面向文件操作，一旦涉及到回溯會非常痛苦。這個名字中第一個L表示從左往右掃描字符串，其實就是在行緩沖中進行掃描，這一點可以從我的編譯程序中的nnum變量從0開始遞增的特性看出來；而第二個L表示最左推導，對於每一個產生式都要從左往右開始分析即可。但是僅僅滿足這個是不一定能夠使用遞歸下降分析的。比如如下這個文法：

F → ( E )

E → F * F

E → F / F

當編寫非終結符E的解析方法時，需要在兩個E產生式中進行分支預測。然而兩個E產生式都以F開頭，而且F本身又可能是任意長的表達式，無論超前查看多少字符，都無法判定到底應該用乘號的產生式還是除號的產生式。遇到這種情況，我們可以用提取左公因式的方法，將它轉化為LL(k)的文法。

我所抽到的文法中不包含左遞歸問題，但是包含回溯問題，通過稍微改寫文法和一些程序上的技巧就輕松解決了，這並不是什么問題。

因為我采用的是一遍掃描的方式，所以在語法分析的時候會同時進行超前一個單詞的詞法分析以及和語法分析相同位置的語義分析。

語言語義，就是這段代碼實際的含義。編程語言的代碼必須有絕對明確的含義，這樣人們才能讓程序做自己想做的事情，在語義不通的情況下需要及時報錯。比如最簡單的一行代碼：a = 1; 它的語義是“將32位整型常量存儲到變量a中”。首先我們對“1”有明確的定義，它是32位有符號整型字面量，這里“32位有符號整型”就是表達式“1”的類型。其次，這句話成為合法的編程語言，32位整型常量必須能夠隱式轉換為a的類型。假設a就是int型變量，那么這條語句就直接將1存儲到a所在內存里。如果a是浮點數類型的，那么這句話就隱含着將整型常量1轉換為浮點類型的步驟。在語義分析中，類型檢查是貫穿始終的一個步驟。類型檢查要做到判定每一個表達式的聲明類型，判定每一個字段、形式參數、變量聲明的類型，判斷每一次賦值、傳參數時，是否存在合法的隱式類型轉換，判斷一元和二元運算符左右兩側的類型是否合法（比如+不就不能在bool和int之間進行，但是我得到的問法只包含CHAR和INT這兩個類型，所以暫時不用考慮這個問題）。

在語義分析中，符號表和四元式也相繼建立起來。

符號表設計是一個很頭疼的事情，因為又涉及到一時設計終身受用或者一時馬虎終身麻煩的那個關鍵的“一時”這個階段。最開始我的設計里只有變量名，類型，值和地址這幾個項目。到后來發現在處理函數參數的時候如果不能知道函數定義的參數是多少個，是很難判斷函數參數是否正確的，以及在數組定義和使用的過程中很難知道這個變量名是不是數組名，如果是數組名的話那么這個數組應該有多大，引用的時候是否越界等。這時候這些信息從哪來呢？只能從符號表來了。於是又硬生生的給符號表加上了“isVector”、“para”這樣的字段，分別表示是否是數組以及數組元素數量、函數參數數量這樣的信息。每次定義函數和數組的時候填入這兩個字段，之后只需要查詢就完美解決了上述問題。

出錯處理部分：這個部分是我覺得最繁雜的一個部分了。因為在不同的地方出錯，跳讀的區間是不同的。所以需要慢慢磨。但是由於技術性較低，所以花了一些時間就搞定了，復雜但不難。

四元式的設計：原以為四元式的設計會比較難，因為對這方面並沒有太多了解，但是直到寫的時候才發現並不是很難。四元式設計我總結出來需要注意兩點：1.一定要設計成上下文無關的四元式，否則轉匯編的時候會非常的麻煩；2.數組操作一定要小心。為了給數組賦值我專門創造了一個運算符”[]=, var1, var2, var3”, 它代表VAR1[VAR2] = VAR3。此外還設計了一個“GETA, VAR1， VAR2， VAR3”來表示var3 = VAR1[VAR2]，這樣就完美的解決了數組操作的問題。

       再往后就是轉成匯編了。這一塊兒存在一些難點。

       首先我就在運行棧的設計上卡殼了。因為我並不想把全局變量存在data段上，雖然C采用了這種設計但是我仍然覺得不夠“美”。於是我就把全局變量塞到運行棧的棧底區域。但是這就帶來一個問題——如何給這些常量變量定位？這個問題也同樣存在於之后的函數中的變量常量定位。在臨時符號表中不能存出絕對地址，因為我們無法預測在運行的時候運行棧內是怎樣的。其實一開始我確實寫的是絕對地址…后來我發現這個問題的時候只好全部重新來過，建立用了一個臨時符號表來存儲變量的相對地址。這樣一來變得簡單多了——每個函數內的變量常量個數在編譯的時候就已經確定好了。於是完全可以用相對於函數起始位置的地址來表示變量的地址。當要對變量進行讀寫操作的時候只需要將它的相對地址addr進行如下操作就是它的絕對地址：addr($fp)。

       但是第一個問題依舊存在——在任何時候都能訪問的全局變量該怎么算地址呢？在這里我做了一個小trick，把整個棧底的基地址寫在了$t9中，由於T9這個寄存器在我的設計中是不會用到的，所以這樣$t9就相當於一個全局FP一樣，其中的全局變量和常量都用相對於$t9的相對偏移作為地址存儲，這樣就完美的解決了變量常量的存儲問題。

最后就是優化部分了。我才用了DAG消除公共子表達式，窺孔優化，消除死代碼，以及引用計數和FIFO的寄存器分配策略。這些寫起來都還挺快的。唯一需要說的就是消除共公共子表達式了。課本用了一個啟發式算法求解，但是經過我的大量測試發現很多情況是不適用的。比如當整個圖中沒有父節點的點有很多的時候，通常采用最左或者隨機選點的方式。但是這樣冥想是不正確的，因為當一個點所代表的變量是父節點之一，而這個變量在改變之前又被別的節點調用做子節點，這時就會出現使用修改后的數據這一現象的產生。舉一個最簡單的例子：C=A, A=B, B=C，在到處過程中C有可能寫入了A的新數據，而不是A0。為此我自己寫了一個可證正確性的算法：

1. 通過掃描基本塊，由上向下找出有相同的op（對應DAG圖中的父節點），var1（對應DAG圖中的左子節點），var2（對應DAG圖中的右子節點）且var3為臨時變量的四元式對（A, B）；
2. 從B向下繼續掃描四元式，尋找所有與B具有相同var3的四元式C1，C2，…；
3. 將Ci的var3置為A.var3；
4. 刪除B，將B之后的四元式前移。

正確性證明：

              對於任意在語法分析過程中定義的臨時變量$_ti（詳見syn.cpp），均有如下定理：$_ti僅會出現在之后四元式的var1和var2位置，永不會被修改

                   因此我們無需擔心DAG圖中會出現臨時變量重定義的情況。

                   因此，一旦出現任意兩個臨時變量有相同的子表達式，完全可以用其中一個代替全部。因此以上算法正確。

至此，整個編譯器就已經實現了。

接下來說說具體實現：

 

1.我所收到的文發如下：

C0文法-數組-無實型-高級

1.＜加法運算符＞ ::= +｜-

定義加減法運算符

例子：3+4 a+b 3+a

2.＜乘法運算符＞ ::= *｜/

定義乘除法運算符

例子：1/2 a/2 a/b

3.＜關系運算符＞ ::= <｜<=｜>｜>=｜!=｜==

定義關系運算符

例子：1<2 a>=3 b!=8

4.＜字母＞ ::= ＿｜a｜．．．｜z｜A｜．．．｜Z

定義字母可以為大小寫字母或者下划線

例子：_ a B

5.＜數字＞ ::= ０｜＜非零數字＞

定義數字為0~9的單位數字字符

例子： 0 1 8

6.＜非零數字＞ ::= １｜．．．｜９

定義非零數字為1~9的單位數字字符

例子： 1 8

7.＜字符＞ ::= '＜加法運算符＞'｜'＜乘法運算符＞'｜'＜字母＞'｜'＜數字＞'

定義字符為以單引號開始和結束，其間有且僅有一個字符。

例子： '+' '/' 'a' '8'

8.＜字符串＞ ::= "｛十進制編碼為32,33,35-126的ASCII字符｝"

定義字符串可以為0個，1個，或多個十進制編碼為32,33,35-126的ASCII字符

需要注意的是不包括雙引號,但是包括空格

字符串的第一個和最后一個字符為雙引號

例子："hello, world~"

9.＜程序＞ ::= ［＜常量說明＞］［＜變量說明＞］{＜有返回值函數定義＞|＜無返回值函數定義＞}＜主函數＞

定義程序。

限定程序的子成分順序，必須為常量說明在前，然后是變量說明，以上兩者均可沒有。

然后是有返回或者無返回的函數定義若干（可以是0個），然后才是主函數

例子: const int a = 3;

int b = 4;

void f(int a);

int f2();

void main(){...}

10.＜常量說明＞ ::= const＜常量定義＞;{ const＜常量定義＞;}

定義常量說明可以是一個或者多個const<常量定義>；這樣的格式

例子： const int a = 2;

const char c = 'b';

11.＜常量定義＞ ::= int＜標識符＞＝＜整數＞{,＜標識符＞＝＜整數＞} | char＜標識符＞＝＜字符＞{,＜標識符＞＝＜字符＞}

定義常量定義可以是整型常量或者字符型常量

整型常量的定義格式是int后跟一個或多個＜標識符＞＝＜整數＞的形式，之間用逗號隔開

字符型常量同理

例子： int a = 2;

char b = 'b';

12.＜無符號整數＞ ::= ＜非零數字＞｛＜數字＞｝

定義無符號整數的開頭必為非零數字，其后可跟若干個數字

該限定表明以0開頭的數字串不屬於無符號整數

0就不是無符號整數

例子： 1 99

13.＜整數＞ ::= ［＋｜－］＜無符號整數＞｜０

定義整數是以可省略的正負號開頭，后跟無符號整數或者0的字符串

例子： 0 1 3

14.＜標識符＞ ::= ＜字母＞｛＜字母＞｜＜數字＞｝

定義標志符是必須由字母為開頭，后跟0到多個字母或者數字的字符串

15.＜聲明頭部＞ ::= int＜標識符＞ | char＜標識符＞

定義聲明頭部

16.＜變量說明＞ ::= ＜變量定義＞;{＜變量定義＞;}

定義變量說明為一個或多個變量定義和分號組成的字符串

17.＜變量定義＞ ::= ＜類型標識符＞(＜標識符＞|＜標識符＞‘[’＜無符號整數＞‘]’){,(＜標識符＞|＜標識符＞‘[’＜無符號整數＞‘]’ )}

定義變量定義，變量可以為一個標志符或者由標志符為起始的數組形式。

例子： int a2bc_d

int word[10]

但是不能如下定義：

int 34dfn

int word[-1]

18.＜類型標識符＞ ::= int | char

定義類型標識符為整數和字符這兩種

19.＜有返回值函數定義＞ ::= ＜聲明頭部＞‘(’＜參數＞‘)’ ‘{’＜復合語句＞‘}’

定義有返回值函數。必須包含頭聲明頭部，參數和復合語句以及必要的括號

例子： int f(char a){

...

...

}

char f(char a){

...

...

}

20.＜無返回值函數定義＞ ::= void＜標識符＞‘(’＜參數＞‘)’ ‘{’＜復合語句＞‘}’

沒啥好說的。

例子： void f(char a){

...

...

}

21.＜復合語句＞ ::= ［＜常量說明＞］［＜變量說明＞］＜語句列＞

定義復合語句是現場兩再變量再語句的順序。

例子： const int a = 2;

char b = '4';

...

22.＜參數＞ ::= ＜參數表＞

。。。

23.＜參數表＞ ::= ＜類型標識符＞＜標識符＞{,＜類型標識符＞＜標識符＞}| ＜空＞

參數表由若干個類型標識符和標志符的集合組成，其間用逗號隔開。可以為空。

類型標識符和標志符的順序不能反。

需要注意的事不能有數組形式

例如： int a, char b, int c,

24.＜主函數＞ ::= void main ‘(’ ‘)’ ‘{’＜復合語句＞‘}’

例子： void main() {

...

}

25.＜表達式＞ ::= ［＋｜－］＜項＞{＜加法運算符＞＜項＞}

表達式是由可省略的+-開頭的若干個由加法運算符連接的項的字符串

例如： 3*4+2/6-4*a

26.＜項＞ ::= ＜因子＞{＜乘法運算符＞＜因子＞}

項是由乘法運算符連接的一個或多個因子

例如： 4*b*a

13*6*num[15]

27.＜因子＞ ::= ＜標識符＞｜＜標識符＞‘[’＜表達式＞‘]’｜＜整數＞|＜字符＞｜＜有返回值函數調用語句＞|‘(’＜表達式＞‘)’

因子是由標志符或標志符后跟方括號括起來的表達式或整數或者字符或者有返回值得函數調用語句或以圓括號括起來的表達式

例如： num[15]

num[a]

a

4

(3*13+5*a-2/f)

28.＜語句＞ ::= ＜條件語句＞｜＜循環語句＞｜‘{’＜語句列＞‘}’｜＜有返回值函數調用語句＞;

|＜無返回值函數調用語句＞;｜＜賦值語句＞;｜＜讀語句＞;｜＜寫語句＞;｜＜空＞;｜＜返回語句＞;

29.＜賦值語句＞ ::= ＜標識符＞＝＜表達式＞|＜標識符＞‘[’＜表達式＞‘]’=＜表達式＞

例如： a[3] = 4

b = 5

30.＜條件語句＞ ::= if ‘(’＜條件＞‘)’＜語句＞［else＜語句＞］

例如： if(a > b){

a = 1;

b = 2;

}

31.＜條件＞ ::= ＜表達式＞＜關系運算符＞＜表達式＞｜＜表達式＞

表達式為0條件為假，否則為真，值得注意的是一個條件中只有一個關系運算符，不支持嵌套

例如：

1&2 a&b a 0 1

32.＜循環語句＞ ::= while ‘(’＜條件＞‘)’＜語句＞| for‘(’＜標識符＞＝＜表達式＞;＜條件＞;＜標識符＞＝＜標識符＞(+|-)＜步長＞‘)’＜語句＞

循環語句具有如下形式：

while(...){

...

}

for(...;...;...){

...

}

其中大括號有時可省略

for的括號中各類型元素不能省略也不能亂位。

33.＜步長＞ ::= ＜非零數字＞｛＜數字＞}

步長為以非零數字開始數字串

形式和無符號整數類似

34.＜有返回值函數調用語句＞ ::= ＜標識符＞‘(’＜值參數表＞‘)’

例如： f(2, 3)

35.＜無返回值函數調用語句＞ ::= ＜標識符＞‘(’＜值參數表＞‘)’

同上

36.＜值參數表＞ ::= ＜表達式＞{,＜表達式＞}｜＜空＞

值參數表是若干個（包括0）表達式的集合

37.＜語句列＞ ::= ｛＜語句＞｝

語句列是若干（包括0）個連續語句的集合

38.＜讀語句＞ ::= scanf ‘(’＜標識符＞{,＜標識符＞}‘)’

定義讀語句是以scanf起始，后接圓括號闊起來的一個或多個以逗號隔開的標識符。

例子: scanf(a, b)

39.＜寫語句＞ ::= printf ‘(’＜字符串＞,＜表達式＞‘)’| printf ‘(’＜字符串＞‘)’| printf ‘(’＜表達式＞‘)’

定義寫語句是以printf為起始的，后接圓括號括起來的字符串或表達式或者兩者都有，若兩者都存在，則字符串在先，以逗號隔開。

例子： printf("%d", a)

printf(a)

printf("Hello, compilier!\n")

40.＜返回語句＞ ::= return[‘(’＜表達式＞‘)’]

返回語句是以return開始，后接可有可無的以圓括號包圍的表達式

例子： return 0

　　

2．目標代碼說明

目標代碼選擇為32位MIPS指令集，輸出的MIPS匯編程序的后綴名為.s，可以直接在MARS, PCSpim等虛擬機上運行。目標代碼生成程序的輸入為中間代碼生成的DAG圖，才用DAG圖節點生成的順序將各個節點依次翻譯為MIPS匯編代碼。

指令	示例	語義
系統調用	syscall
取立即數	Li $s1, 100	$s1 = 100
加	Add $s1,$s2,$s3	$s3=$s1+$s2
立即數加	Addi $s1,$s2,100	$s3=$s1+100
立即數減	Subi $s1,$s2,100	$s3=$s1-100
減	sub $s1,$s2,$s3	$s3=$s1-$s2
乘	mult $s2,$s3	Hi，Lo=$s2*$s3
除	div $s2,$s3	Lo=$s2/$s3 Hi=$s2 Mod $s3
取字	Lw $s1,100($s2)	$s1=memory[$s2+100]
存字	sw $s1,100($s2)	memory[$s2+100]=$s1
Beq	beq $s1,$s2,100	If（$s1==$s2） goto PC+4+400
Bne	beq $s1,$s2,100	If（$s1！=$s2） goto PC+4+400
Slt	slt $s1,$s2, $s3	If（$s2<$s3） $s1=1; Else $s1=0;
j	J 2000	Goto 8000
jr	Ja $ra	Goto $ra
jal	Jal 2500	$ra=PC+4; Goto 10000;

3. 優化方案*

1.消除局部公共子表達式

2.常數合並（窺孔優化）

3.消除死代碼

4.刪除冗余跳轉代碼

5.通過引用計數和FIFO策略的寄存器分配方案

二．詳細設計

1．程序結構

如下圖所示

共有七個文件（綠色塊表示）。

其中六個功能塊分別進行詞法分析，語法分析和語義分析，生成中間代碼，生成匯編指令，出錯處理和優化。

上圖中省略的函數和方法包括：

Lax.cpp:

Syn.cpp:

Midcode:

2．類/方法/函數功能

函數功能見上圖。

所有函數：

函數名	作用和功能
詞法分析：
void getch();	獲取一個字符
int getsym();	獲取一個詞語
語法分析：
void program();	程序遞歸子程序
void defhead();	定義頭部遞歸子程序
void varstate();	變量聲明遞歸子程序
void vardef();	變量定義遞歸子程序
void constdef(int tclass);	常量定義遞歸子程序
void conststate();	常量聲明遞歸子程序
void sentencelist();	語句列遞歸子程序
void complexsentence();	復雜語句遞歸子程序
void sentence();	語句遞歸子程序
void condition();	條件遞歸子程序
void loopsentence();	循環語句遞歸子程序
void valueofpara();	值參數表遞歸子程序
void scanfsentence();	讀語句遞歸子程序
void printfsentence();	寫語句遞歸子程序
void parametertable();	參數表遞歸子程序
void returnsentence();	返回語句遞歸子程序
void expression();	表達式遞歸子程序
void item();	項遞歸子程序
void factor();	因子遞歸子程序
中間代碼：
void insmidcode(char* op, char* t1, char* t2, char* t3);	插入中間代碼
void insmidcode(char* op, int t1, int t2, char* t3);
void insmidcode(char* op, char t1, int t2, char* t3);
char* nextlab();	返回下一個label名
char* nextvar();	返回下一個臨時變量名
匯編相關：
void midcode2asm();	中間代碼轉匯編
int findvartable(char *name);	在變量表中查找
void midcode2asm();	中間代碼轉匯編
void insertaddress(int kind, int addr = -1, int nmi = -1);	向變量表中插入一個變量和地址
void pushstack(char* item = "0", int lenth = 1);	壓棧lenth*4個字節
void funcasm();	開始函數定義
int varaddr(char *name);	求變量的相對fp的地址
void dataseg();	數據段
void jmpasm();	跳轉
void printint();	寫一個整數語句
void callasm();	調用函數
void setlabasm();	放置標簽
void addasm();	四則運算
void subasm();
void mulasm();
void divasm();
void greasm();	比較運算
void geqasm();
void lssasm();
void leqasm();
void eqlasm();
void neqasm();
void assasm();	變量賦值語句
void aassasm();	包含數組元素的操作
void assaasm();
void scfasm();	讀語句
void prtasm();	寫語句
void fupaasm();	填入參數語句
void retasm();	函數返回
void paraasm();	參數聲明處理
void jneasm();	否定則跳轉
void intcharasm();	變量定義語句
void constdefasm();	常亮定義語句
void intcharaasm();	變量定義語句

3．調用依賴關系

如圖所示。
4．符號表管理方案

typedef struct{

char name[ MAXIDENLEN ]; //identifier name

int kind; //identifier kind (define as follow)

int value; //1對於函數來說，表示返回值為Int 0返回值為void

int address; //address

int paranum; //

}symb;

#define CONST 0 //常亮

#define VARIABLE 1 //變量

#define FUNCTION 2 //函數

#define PARA 3 //參數

typedef struct {

symb element[ MAXSYMTABLENUM ];

int index;

int ftotal; //分程序總數

int findextable[ MAXSYMTABLENUM ];//分程序索引數組

}symtable;

extern symtable maintable;

 

符號管理結構由一張符號表，分程序總數，分程序索引數組和符號表棧頂指針構成。

其中符號表含有名稱，類型，值，地址和參數個數這幾個屬性。

其代表的含義如下所示：

表項	含義
名稱	符號的名稱，如name, functiona, para1
類型	CONST 0 //常亮 VARIABLE 1 //變量 FUNCTION 2 //函數 PARA 3 //參數
值	存儲常量的值
地址	存儲這個變量在符號表里的地址
參數個數	表示函數的參數個數 表示數組的元素數量

5．存儲分配方案

1.存儲方式：采用引用計數算法進行寄存器分配

2.運行棧結構：

如下圖所示：

6. 解釋執行程序*

本編譯器不采用解釋執行方式。

7. 四元式設計*

四元式種類	代表的含義
= , 2 , , temp	temp = 2;
[]= , a , i , t	a[i] = t;
int , , , a	int a;
const,int,5 , a	const int a = 5;
char, , 30, a	char a[30];
fupa, , , a	a is a function parameter
call, f , , a	a = f()
call, f , ,	f()
<=.., a , b ,	a <= b
jne , , , lable	if not satisfy(==false) then jump
jmp , , , label	jump to label
lab:, , , labx	set label
geta, a , n , b	b = a[n]
ret , , , (a)	return a / return
prt , a , b , symb	print("a", b)
scf , , , a	scanf(a)
func,int, , f	start of function int f()
para,int, , a	f(int a, ...)
end , , , f	end of function f

8. 優化方案*

0.划分基本快：

很明顯，在本設計中，有關影響數據的操作只有以+, -, *, /, []=為operation的語句。所以我們只需要不斷讀取以這些符號為開頭的連續四元式規約為同一基本塊即可。

1.窺孔優化：

通過窺孔優化合並常數。

不斷讀取四元式，一旦發現有常數運算的立即變為賦值操作。

2.消除公共子表達式（書上算法有誤，自創算法）：

課本上DAG圖算法的漏洞：由於課本上的通過構造DAG圖消除公共子表達式的啟發式算法存在明顯問題，當有多個變量沒有父節點時，啟發式算法中進入隊列的順序將會直接影響結果。一旦進入隊列順序不正確，將會導致導出的代碼使用了錯誤的節點變量。

因此，我在這里提出一個新的可證明正確性的算法：

新算法：

1. 通過掃描基本塊，由上向下找出有相同的op（對應DAG圖中的父節點），var1（對應DAG圖中的左子節點），var2（對應DAG圖中的右子節點）且var3為臨時變量的四元式對（A, B）；

2. 從B向下繼續掃描四元式，尋找所有與B具有相同var3的四元式C1，C2，…；

3. 將Ci的var3置為A.var3；

4. 刪除B，將B之后的四元式前移。

正確性證明：

對於任意在語法分析過程中定義的臨時變量$_ti（詳見syn.cpp），均有如下定理：

$_ti僅會出現在之后四元式的var1和var2位置，永不會被修改

因此我們無需擔心DAG圖中會出現臨時變量重定義的情況。

因此，一旦出現任意兩個臨時變量有相同的子表達式，完全可以用其中一個代替全部。因此以上算法正確。

3.刪除冗余代碼標簽：

很多情況下，程序或出現如下的句型：

If(xxxxx){

……

}

……

即不存在else。

此外，還有很多情況會導致在轉化成四元式的時候兩個甚至多個label連在一起，這樣就導致了代碼冗余。

算法：

掃描整個四元式，一旦遇到lab:,刪除其后的所有相鄰lab代碼，並更改所有var3為被刪除的lab的四元式中跳轉指令的var3為最先發現的lab，反復執行直到讀完整個四元式。

4.通過引用計數和FIFO策略的寄存器分配方案：

本程序使用s0到s7存儲局部變量。

建立一個寄存器表，如下所示：

寄存器	變量編號
$s0	1
$s1	8
$s2	7
$s3	…
$s4	…
$s5	…
$s6	…
$s7	…

實際運行時的情況舉例：

其中symbnum指的是變量在變量表中的編號，cnt為計數的積分，越高使用頻率就越大。

通過引用計數算法，掃描整個函數，查找每個變量使用的頻度值，從大到小排序，分配寄存器。

9. 出錯處理

0.接口：void error(int _errsig, int signal)

 

1.出錯類型和相關信息：

出錯名稱	出錯代碼	出錯原因
NOSUCHFILE	999	源文件缺少
FILEINCOMPLETE	0	文件不完整
DOUBLEQUOTESLACK	1	缺少“"”
UNACCEPTATLECHAR	2	不可接受的字符
SINGLEQUOTESLACK	3	缺少“'”
OUTOFTABLE	4	符號表爆了
SYMBOLCONFLICT	5	變量名沖突
CSTDEFINEFAIL	6	常量聲明失敗
VARNOTINIT	7	變量未初始化
UNKNOWRIGHTSYM	8	等號右邊字符非法
SEMICOLONLACK	9	丟失“；”
KEYWORDERROR	10	關鍵字錯誤
IDENTIFIERLACK	11	丟失標志符
RIGHTBRACKLACK	12	丟失“]”
FUNCTIONNOTFOUND	13	調用函數未定義
FORMALPARANUMUNMATCH	14	形參個數不匹配
VARNOTDEFINE	15	未定義變量
LEFTPARENTLACK	16	丟失“（”
RIGHTPARENTLACK	17	丟失“）”
IMMLACK	18	丟失立即數
RIGHTBRACELACK	19	丟失“}”
FUNCTIONRETURNNULL	20	函數無返回值卻被用於參數
EXPRESSIONERROR	21	表達式缺失或錯誤
UNACCEPTABLESENTENCE	22	句子不合法
ASSIGNCONST	23	給常數賦值
LEFTBRACELACK	24	缺少“{”
NONERETURN	25	缺少返回值
PLUSMINULACK	26	缺少‘+’或‘-’
MAINLACK	27	缺少main函數
MOREWORD	28	main函數后面有多余字符
CONSTNOTINIT	29	常量沒有初始化

2.出錯處理方式種類：

處理方式名稱	代碼	處理方式
QUIT	1	直接退出程序
DONOTHING	2	不做任何處理
ICV	3	跳到下一個類型聲明符號int/char/void
CICVIFIRSP	4	跳到下一個以下集合的元素 { CONSTTK INTTK CHARTK VOIDTK IFTK WHILETK FORTK IDEN RETURNTK SCANFTK PRINTFTK}
CS	5	跳到下一個逗號或者分號
CLR	6	跳到下一個逗號或者括號
IWFRSPIFCV	7	跳到下一個語句列的FIRST集合元素之一
IWFLIRSPE	8	跳到下一個以下集合的元素： {IFTK WHILETK FORTK LBRACK IDEN RETURNTK SCANFTK PRINTFTK ELSETK RBRACE}
IWFXXXANE	9	跳到下一個以下集合的元素： { IFTK WHILETK FORTK LBRACK IDEN RETURNTK SCANFTK PRINTFTK SEMICN ELSETK RPARENT COMMA PLUS MINU MULT DIV LSS LEQ GRE GEQ NEQ EQL}

3.出錯處理方式：

1.遞歸子程序發現錯誤立即調用error()並傳遞出錯信號;

2.error函數通過接收到的出錯信號打印出出錯信息和位置信息；

3.通過出錯類型型號和位置判斷應該如何進行跳讀，基本上是遇到錯誤則跳到同層符號的FIRST集合元素。具體情況具體分析，詳見err.cpp。

4.繼續執行編譯，直到文件結束。

三．操作說明

1．運行環境

代碼可在windows，Linux和mac下編譯正常執行；

需要Mars進行模擬；

在三種平台下均可使用Mars進行模擬執行生成的匯編代碼。

2．操作步驟

1.使用VS201*編譯本程序后會出現如下exC0compiler.exe的程序。此即為編譯器的主程序。

2.運行編譯器程序。

3.將需要編譯的文件拖入程序框內，如果路徑存在空格，需要加上引號。之后按回車。如圖所示：

4.如果編譯成功，會出現如下提示，並跳轉到第六步：

5.如果編譯失敗，會出現如下提示：

6.編譯成功后，將會生成如下幾個文件：

7.可以通過optMidCode.txt和midcode.txt進行比對來看優化效果

8.接下來打開MARS模擬器，導入asmrst.asm,如圖：

9.編譯執行即可，如圖：

10.需要注意的是，任何輸入都必須用換行符隔開，這是Mars定義的模擬特性。

下圖就是一個正確的輸入：

而下圖用空格隔開將會導致程序出錯：

最后貼一下工程代碼，需要注意的是這個代碼是歷史版本存在一些漏洞：

//
//  glob.h
//  exc0compiler
//
//  Created by sciencefans on 14/11/19.
//  Copyright (c) 2014年 sciencefans. All rights reserved.
//

#ifndef exc0compiler_glob_h
#define exc0compiler_glob_h
#include <string>
#include <iostream>
#include <fstream>
#include <algorithm>
#include <vector>
#include <map>
#include <ctype.h>

using namespace std;

///======================================lax

extern const int kwdnum;
extern char *word[];

extern char *wsym[];

#define BEGINTK     1
#define CALLTK      2
#define CASETK      3
#define CHARTK      4
#define CONSTTK     5
#define DEFAULTTK   6
#define DOTK        7
#define ELSETK      8
#define ENDTK       9
#define FLOATTK     10
#define FORTK       11
#define IFTK        12
#define INTTK       13
#define MAINTK      14
#define ODDTK       15
#define PRINTFTK    16
#define PROCETK     17
#define READTK      18
#define RETURNTK    19
#define RPTTK       20
#define SCANFTK     21
#define SWITCHTK    22
#define THENTK      23
#define UTLTK       24
#define VARTK       25
#define VOIDTK      26
#define WHILETK     27
#define WRITETK     28
#define IDEN        29
#define INTCON      30
#define CHARCON     31
#define STRCON      32
#define PLUS        33
#define MINU        34
#define MULT        35
#define PERIOD      36
#define DIV         37
#define COLON       38
#define LSS         39
#define QMARK       40
#define LEQ         41
#define DQMARK      42
#define GRE         43
#define LPARENT     44
#define GEQ         45
#define RPARENT     46
#define EQL         47
#define LBRACK      48
#define NEQ         49
#define RBRACK      50
#define ASSIGN      51
#define LBRACE      52
#define SEMICN      53
#define RBRACE      54
#define COMMA       55

#define CINTCON     56
#define CCHARCON    57

extern ofstream laxrst, midcoderst, asmrst, symtablehis;
extern int ch;//the

extern int line[ 500 ], backupline[ 500 ];
extern int lnum , cnum , llen, prllen;
extern FILE* src;

//define id, num and sym
extern string id, prid;
extern int num;
extern string sym;
extern double dnum;
extern int symid;

//declare functioint getsym();
void getch();
int getsym();
bool stringcmp(char* a, char* b);


///======================================syn
void program();
void defhead();
void varstate();
void vardef();
void constdef(int tclass);
void conststate();
void sentencelist();
void complexsentence();
void sentence();
void condition();
void loopsentence();
void valueofpara();
void scanfsentence();
void printfsentence();
void parametertable();
void returnsentence();
void expression();
void item();
void factor();
void lower(char* s);
//the word tobe dealwith
extern int wd;

#define MAXIDENLEN      30
#define MAXSYMTABLENUM  200

//define symbol table
typedef struct{
    char name[ MAXIDENLEN ];  //identifier name
    int kind;               //identifier kind (define as follow)
    int value;              //1對於函數來說，表示返回值為Int 0返回值為void
    int address;            //address
    int paranum;            //
}symb;
#define CONST       0   //常亮
#define VARIABLE    1   //變量
#define FUNCTION    2   //函數
#define PARA        3   //參數
/****************************
*                  symbol table
*  name    kind    value   address     paranum
*
*
*
*
*
***************************/
typedef struct {
    symb element[ MAXSYMTABLENUM ];
    int index;
    int ftotal;                 //分程序總數
    int findextable[ MAXSYMTABLENUM ];//分程序索引數組
}symtable;
extern symtable maintable;
extern int  value;     //保存常量的值；對於子程序，0表示void，1表示int
extern int  address;   //變量的地址；函數返回值的地址
extern int  paranum;   //全局變量，用來處理函數定義，因為函數的參數個數只能在參數表子程序執行結束之后才知道，所以只能在后面才插入符號表信息
extern int  kind;      //正在處理的標志符的類型
extern char name[ MAXIDENLEN ]; //標志符的名字，包括常量變量和函數
extern int hsymid; //上一個單詞類型
extern char nowitem[ 200 ];
extern int returnnum; //記錄是否有返回值
extern char procname[ 100 ];
extern int mf; //主函數個數


///=====================================四元式
void insmidcode(char* op, char* t1, char* t2, char* t3);
void insmidcode(char* op, int t1, int t2, char* t3);
void insmidcode(char* op, char t1, int t2, char* t3);
char* nextlab();
char* nextvar();
#define MAXMIDCODE 1000
/****************************
* op:      symbol of operator
* var1:    op1
* var2:    op2
* var3:    distination var
* e.g.
*      =   , 2 ,   , temp  ==> temp = 2;
*       []= , a , i , t       ==> a[i] = t;
*      int ,   ,   , a     ==> int  a;
*      const,int,5 , a     ==> const int a = 5;
*      char,   , 30, a     ==> char a[30];
*      fupa,   ,   , a     ==> a is a function parameter
*      call, f ,   , a     ==> a = f()
*      call, f ,   ,       ==> f()
*      <=.., a , b ,       ==> a <= b
*      jne ,   ,   , lable ==> if not satisfy(==false) then jump
*      jmp ,   ,   , label ==> jump to label
*      lab:,   ,   , labx  ==> set label
*      geta, a , n , b     ==> b = a[n]
*      ret ,   ,   , (a)   ==> return a / return
*      prt , a , b , symb  ==> print("a", b)
*      scf ,   ,   , a     ==> scanf(a)
*      func,int,   , f     ==> start of function int f()
*      para,int,   , a     ==> f(int a, ...)
*      end ,   ,   , f     ==> end of function f
****************************/
typedef struct{
    char op[ 10 ];
    char var1[ 200 ];
    char var2[ 30 ];
    char var3[ 30 ];
}fourvarcode;
extern fourvarcode midcode[ MAXMIDCODE ];
extern int midcodeiter;
extern int labelcnt;
extern int varcnt;

///=====================================優化
extern FILE* optcodefile;
void printOptimize();
int isconst(char name[]);
void delsetlab();
void delpublic();
void combine();
void scan();


///=====================================匯編
extern int mi;
extern int sp;
extern int x;
void midcode2asm();
int findvartable(char *name);
void midcode2asm();
void insertaddress(int kind, int addr = -1, int nmi = -1);
void pushstack(char* item = "0", int lenth = 1);
void funcasm();
int varaddr(char *name);
void dataseg();
void jmpasm();
void printint();
void callasm();
void setlabasm();
void addasm();
void subasm();
void mulasm();
void divasm();
void greasm();
void geqasm();
void lssasm();
void leqasm();
void eqlasm();
void neqasm();
void assasm();
void aassasm();
void assaasm();
void scfasm();
void prtasm();
void fupaasm();
void retasm();
void paraasm();
void jneasm();
void intcharasm();
void constdefasm();
void intcharaasm();
void savesreg();
void loadsreg();
void cnt(char * name);
void cntopt();
#endif

//
//  err.h
//  exc0compiler
//
//  Created by sciencefans on 14/11/15.
//  Copyright (c) 2014年 sciencefans. All rights reserved.
//

#ifndef exc0compiler_err_h
#define exc0compiler_err_h

#define NOSUCHFILE            999
#define FILEINCOMPLETE      0
#define DOUBLEQUOTESLACK    1
#define UNACCEPTATLECHAR    2
#define SINGLEQUOTESLACK    3
#define OUTOFTABLE          4
#define SYMBOLCONFLICT      5
#define CSTDEFINEFAIL       6   //常亮聲明失敗
#define VARNOTINIT          7   //變量未初始化
#define UNKNOWRIGHTSYM      8   //等號右邊字符非法
#define SEMICOLONLACK       9   //丟失“；”
#define KEYWORDERROR        10  //關鍵字錯誤
#define IDENTIFIERLACK      11  //丟失標志符
#define RIGHTBRACKLACK      12  //丟失“]”
#define FUNCTIONNOTFOUND    13  //調用函數未定義
#define FORMALPARANUMUNMATCH 14 //形參個數不匹配
#define VARNOTDEFINE        15  //未定義變量
#define LEFTPARENTLACK      16  //丟失“（”
#define RIGHTPARENTLACK     17  //丟失“）”
#define IMMLACK             18  //丟失立即數
#define RIGHTBRACELACK      19  //丟失“}”
#define FUNCTIONRETURNNULL  20  //函數無返回值卻被用於參數
#define EXPRESSIONERROR     21  //表達式缺失或錯誤
#define UNACCEPTABLESENTENCE 22 //句子不合法
#define ASSIGNCONST         23  //給常數賦值
#define LEFTBRACELACK       24  //缺少“{”
#define NONERETURN          25  //缺少返回值
#define PLUSMINULACK        26  //缺少‘+’或‘-’
#define MAINLACK            27  //缺少main函數
#define MOREWORD            28  //main函數后面有多余字符
#define CONSTNOTINIT        29    //常量沒有初始化

extern void error(int _errsig, int signal = 0);
extern int errnum;
#endif

//
//  main.cpp
//  exc0compiler
//
//  Created by sciencefans on 14/11/14.
//  Copyright (c) 2014年 sciencefans. All rights reserved.
//

#include "glob.h"
#include "err.h"

using namespace std;

int prllen;
const int kwdnum = 28;
char *word[] = {
    "begin", "$call", "case", "char", "const",//0~4
    "default", "do", "else", "$end", "float",  //5~9
    "for", "if", "int", "main", "$odd",//10~14
    "printf", "$procedure", "$read", "return", "$repeat",  //15~19
    "scanf", "switch", "$then", "until", "$var",//20~24
    "void", "while", "$write"//25~27
};
char *wsym[] = {
    "BEGINTK", "CALLTK", "CASETK", "CHARTK", "CONSTTK",
    "DEFAULTTK", "DOTK", "ELSETK", "ENDTK", "FLOATTK",
    "FORTK", "IFTK", "INTTK", "MAINTK", "ODDTK",
    "PRINTFTK", "PROCETK", "READTK", "RETURNTK", "RPTTK",
    "SCANFTK", "SWITCHTK", "THENTK", "UTLTK", "VARTK",
    "VOIDTK", "WHILETK", "WRITETK"
};

int ch = ' ';//the

int line[ 500 ], backupline[ 500 ];
int lnum = 0, cnum = 0, llen = 0;
FILE* src = NULL;

//define id, num and sym
string id = "";
int num;
string sym;
double dnum;
int symid;
string prid;


int getsym(){
    prid = id;
    id = "";
    while ( isspace(ch) && ch != EOF ) {
        getch();
    }
    if ( ch == EOF ){
        symid = -1;
        return -1;
    }
    //when the ch is alpha
    //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
    //!!!   this version donnot has lenth limit
    //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
    if ( isalpha(ch) || ch == '_' ){
        string tempstr;
        while ( isalpha(ch) || isdigit(ch) || ch == '_' ) {
            ch = tolower(ch);
            tempstr += ch;
            getch();
        }
        id = tempstr;
        //seatch reserved word table
        int iter = 0;
        for ( iter = 0; iter < kwdnum; iter++ ) {
            if ( stringcmp(word[ iter ], (char*)tempstr.c_str()) ) {
                sym = wsym[ iter ];
                symid = iter + 1;
                break;
            }
        }
        if ( iter == kwdnum ) {
            sym = "IDEN";
            symid = IDEN;
        }
    }
    else if ( isdigit(ch) ){
        
        sym = "INTCON";
        symid = INTCON;
        num = 0;
        while ( isdigit(ch) ){
            id += ch;
            num = num * 10 + (int)( ch - '0' );
            getch();
        }
        if ( ch == '.' ) {
            id += ch;
            sym = "FLOATCON";
            symid = -1;
            double t = 0.1;
            dnum = num;
            getch();
            while ( isdigit(ch) ){
                id += ch;
                dnum = dnum + (int)( ch - '0' ) * t;
                t /= 10;
                getch();
            }
        }
    }
    else if ( ch == '=' ){
        id += ch;
        sym = "ASSIGN";
        symid = ASSIGN;
        getch();
        if ( ch == '=' ) {
            id += ch;
            sym = "EQL";
            symid = EQL;
            getch();
        }
    }
    else if ( ch == '<' ){
        id += ch;
        getch();
        if ( ch == '=' ) {
            id += ch;
            sym = "LEQ";
            symid = LEQ;
            getch();
        }
        else{
            sym = "LSS";
            symid = LSS;
        }
    }
    else if ( ch == '>' ){
        id += ch;
        getch();
        if ( ch == '=' ) {
            id += ch;
            sym = "GEQ";
            symid = GEQ;
            getch();
        }
        else{
            sym = "GRE";
            symid = GRE;
        }
    }
    else if ( ch == '!' ){
        id += ch;
        getch();
        if ( ch == '=' ) {
            id += ch;
            sym = "NEQ";
            symid = NEQ;
            getch();
        }
    }
    else if ( ch == '\"' ){
        string tempstr;
        getch();
        while ( ch == 32 || ch == 33 || (ch <= 126 && ch >= 35) ) {
            tempstr += ch;
            getch();
        }
        if ( ch == '\"' ) {
            getch();
            sym = "STRCON";
            symid = STRCON;
            id = tempstr;
        }
        else{
            error(DOUBLEQUOTESLACK);
            return -1;
        }
    }
    else if ( ch == '\'' ){
        getch();
        if ( ch == '+' || ch == '-' || ch == '*' || ch == '/' || ch == '_' || isalnum(ch) ) {
            id += ch;
            getch();
        }
        else{
            error(UNACCEPTATLECHAR);
            return -1;
        }
        if ( ch == '\'' ){
            sym = "CHARCON";
            symid = CHARCON;
            getch();
        }
        else{
            error(SINGLEQUOTESLACK);
            return -1;
        }
    }
    else {
        if ( ch == '+' ){
            sym = "PLUS";
            symid = PLUS;
        }
        else if ( ch == '-' ){
            sym = "MINU";
            symid = MINU;
        }
        else if ( ch == '*' ){
            sym = "MULT";
            symid = MULT;
        }
        else if ( ch == '/' ){
            sym = "DIV";
            symid = DIV;
        }
        else if ( ch == ',' ){
            sym = "COMMA";
            symid = COMMA;
        }
        else if ( ch == ':' ){
            sym = "COLON";
            symid = COLON;
        }
        else if ( ch == ';' ){
            sym = "SEMICN";
            symid = SEMICN;
        }
        else if ( ch == '{' ){
            sym = "LBRACE";
            symid = LBRACE;
        }
        else if ( ch == '[' ){
            sym = "LBRACK";
            symid = LBRACK;
        }
        else if ( ch == '(' ){
            sym = "LPARENT";
            symid = LPARENT;
        }
        else if ( ch == '}' ){
            sym = "RBRACE";
            symid = RBRACE;
        }
        else if ( ch == ']' ){
            sym = "RBRACK";
            symid = RBRACK;
        }
        else if ( ch == ')' ){
            sym = "RPARENT";
            symid = RPARENT;
        }
        id += ch;
        getch();
    }
    if ( !strcmp(sym.c_str(), "INTCON") ) {
        laxrst << sym << ' ' << num << endl;
    }
    else if ( !strcmp(sym.c_str(), "FLOATCON") ){
        laxrst << sym << ' ' << dnum << endl;
    }
    else{
        laxrst << sym << ' ' << id << endl;
    }

    return 0;
}

///read one character in source file and store in 'ch'
void getch(){
    int i = 0;
    prllen = llen;
    if ( cnum == llen && ~line[ llen ] ) {

        ch = fgetc(src);
        while ( ch == ' ' || ch == '\n' || ch == '\t' ){
            if (ch == '\n') {
                lnum++;
            }
            backupline[ i++ ] = ch;  //保存源文件的行，用於發生錯誤時輸出
            ch = fgetc(src);
        }
        //保存過濾掉空白字符后的一行字符
        for ( llen = 0; ch != '\n' && ch != EOF; llen++ ) {
            line[ llen ] = ch;
            backupline[ i++ ] = ch;   //保存源文件的行，用於發生錯誤時輸出
            ch = fgetc(src);
        }
        if ( ch == EOF )
            line[ llen ] = EOF;
        else
            line[ llen ] = '\n';
        backupline[ i ] = '\0';

        cnum = 0;
        ch = '\n';
        lnum++;
        /*midcoderst << "##LINE " << lnum << ": ";
        for ( int t = 0; t < llen; t++ ){
            midcoderst << (char)line[ t ];
        }
        midcoderst << endl;*/
    }
    else{
        ch = line[ cnum++ ];
    }
}


//return:
//  true:   a > b
//  false:  a < b
bool stringcmp(char *a, char *b){
    int i = 0;
    while ( true ){
        if (( a[ i ] == 0) && (b[ i ] == 0 )) {
            return true;
        }
        else if ( a[ i ] != b[ i ] ){
            return false;
        }
        else{
            i++;
        }

    }
}

//
//  syn.cpp
//  exc0compiler
//
//  Created by sciencefans on 14/11/18.
//  Copyright (c) 2014年 sciencefans. All rights reserved.
//



#include "glob.h"
#include "err.h"



int wd = -1;
symtable maintable;
int  value;     //保存常量的值；對於子程序，0表示void，1表示int
int  address;   //變量的地址；函數返回值的地址
int  paranum;   //全局變量，用來處理函數定義，因為函數的參數個數只能在參數表子程序執行結束之后才知道，所以只能在后面才插入符號表信息
int  kind;      //正在處理的標志符的類型
char name[ MAXIDENLEN ]; //標志符的名字，包括常量變量和函數
int hsymid; //上一個單詞類型
char nowitem[ 200 ];
int returnnum = 0; //記錄是否有返回值
char procname[ 100 ];
int hiscnt = 1;
int sislob = 1;
int factclass = 0;
#define INT 1
#define CHAR 2
#define subfuncindex(n) maintable.findextable[(n)]

//fill in symbol table
//name:     symbol name
//kind:     the kind of name(see syn.h)
//value:    the value of const
//address:  the address of the var
//para:     the formal parameter of function
int arrnum(char *name){
    int n;
    int m = maintable.findextable[ 1 ];
    n = maintable.findextable[ maintable.ftotal ];
    //查找符號表中是否有
    while ( n < maintable.index ) {
        if ( strcmp(maintable.element[ n ].name, name) == 0 )
            return maintable.element[ n ].paranum;
        n++;
    }

    //如果分程序符號表中無定義，查找最外層符號表
    if ( n == maintable.index ) {
        n = 0;
        while ( n < m ) {
            if ( strcmp(maintable.element[ n ].name, name) == 0 )
                return maintable.element[ n ].paranum;
            n++;
        }
        //符號表中沒有定義
        if ( n == m ) {
            printf("\"%s\" ", name);
            //error(VARNOTDEFINE);
            return -1;
        }
    }
}

void pushtable(char* name, int kind, int value, int address, int paranum, int isVec = 0){

    //whether table is full
    if ( maintable.index >= MAXSYMTABLENUM ){
        error(OUTOFTABLE);
        exit(0);
    }

    //whether conflict
    //function
    if ( kind == FUNCTION ) {
        int iter = 1;
        for ( iter = 1; iter <= maintable.ftotal; iter++ ) {
            if ( !strcmp(maintable.element[ maintable.findextable[ iter ] ].name, name) ) {
                error(SYMBOLCONFLICT);
                return;
            }
        }
        maintable.findextable[ ++maintable.ftotal ] = maintable.index;
    }
    else{
        //others
        int iter = maintable.findextable[ maintable.ftotal ];
        for ( ; iter < maintable.index; iter++ ) {
            if ( !strcmp(maintable.element[ iter ].name, name) ) {
                error(SYMBOLCONFLICT);
                return;
            }
        }
        //if not para and non-glob-var, compare with global var.
        if ( kind != PARA && sislob) {
            iter = 0;
            while ( iter < maintable.findextable[ 1 ] ) {
                if ( !strcmp(maintable.element[ iter ].name, name) ) {
                    error(SYMBOLCONFLICT);
                    return;
                }
                iter++;
            }
        }
    }

    strcpy(maintable.element[ maintable.index ].name, name);
    maintable.element[ maintable.index ].kind = kind;
    maintable.element[ maintable.index ].value = value;
    maintable.element[ maintable.index ].address = maintable.index;
    maintable.element[ maintable.index ].paranum = isVec ? isVec : paranum;
    if (maintable.index <= hiscnt) {
        symtablehis << "----------------------------------------------------------------" << endl;
    }
    hiscnt = maintable.index;
    symtablehis << maintable.index << "\t" << name << "\t" << kind << "\t" << value << "\t" << address << "\t" << paranum << "\t" << isVec << endl;
    maintable.index++;
}

void insertproc(int paranum)
{
    int x = maintable.findextable[ maintable.ftotal ];   //array[i]，指向的是當前正在被分析的函數在符號表中的索引
    maintable.element[ x ].paranum = paranum;//插入函數參數個數信息
    return;
}

//look up symbol table
//flag=1時，說明要在分程序索引里查找，flag=0時，在當前所在分程序符號表中查找
//flag2=1時，只在當前函數作用域里找
int searchst(char* name, int flag, int flag2 = 0){
    int n;
    int m = maintable.findextable[ 1 ];
    if ( flag == 1 ) {
        n = 1;
        while ( n <= maintable.ftotal ) {
            if ( strcmp(maintable.element[ maintable.findextable[ n ] ].name, name) == 0 )
                break;
            n++;
        }

        //如果函數標志符沒有定義
        if ( n > maintable.ftotal ) {
            printf("\"%s\" ", name);
            //error(FUNCTIONNOTFOUND);
            return -1 * FUNCTIONNOTFOUND;
        }

        //如果函數的實參個數與形參個數不匹配
        if ( maintable.element[ maintable.findextable[ n ] ].paranum != paranum ) {
            printf("\"%s\" ", name);
            //error(FORMALPARANUMUNMATCH);
            return -1 * FORMALPARANUMUNMATCH;
        }

        //如果函數標識符無內容
        if ( maintable.element[ maintable.findextable[ n ] ].value == 0 )
            return -1 * FUNCTIONRETURNNULL;

        return maintable.element[ maintable.findextable[ n ] ].address;
    }
    else{
        n = maintable.findextable[ maintable.ftotal ];
        //查找符號表中是否有
        while ( n < maintable.index ) {
            if ( strcmp(maintable.element[ n ].name, name) == 0 )
                break;
            n++;
        }

        //如果分程序符號表中無定義，查找最外層符號表
        if ( n == maintable.index ) {
            n = 0;
            while ( n < m ) {
                if ( strcmp(maintable.element[ n ].name, name) == 0 )
                    break;
                n++;
            }
            //符號表中沒有定義
            if ( n == m ) {
                printf("\"%s\" ", name);
                //error(VARNOTDEFINE);
                return -1;
            }
        }
        if ( maintable.element[ n ].kind == INTTK || maintable.element[ n ].kind == CHARTK )
            return maintable.element[ n ].address;
        if ( maintable.element[ n ].kind == CINTCON || maintable.element[ n ].kind == CCHARCON )
            return -2;    //const 返回負兩倍地址
        if ( maintable.element[ n ].kind == PARA )
            return maintable.element[ n ].address;    //參數標志
        return -1;
    }
}



//clear symbol table
void flushst(){
    int x = maintable.index - 1;
    int y;
    while ( ( maintable.element[ x ].kind == INTTK || maintable.element[ x ].kind == CHARTK || maintable.element[ x ].kind == CINTCON
        || maintable.element[ x ].kind == CCHARCON || maintable.element[ x ].kind == PARA ) && strcmp(maintable.element[ x ].name, procname) != 0 ) {
        maintable.element[ x ].kind = 0;
        maintable.element[ x ].address = 0;
        maintable.element[ x ].paranum = 0;
        maintable.element[ x ].value = 0;
        y = 0;
        while ( y<30 )
            maintable.element[ x ].name[ y++ ] = '\0';
        x--;
    }
    maintable.index = x + 1;
    return;
}

//9.＜程序＞    ::= ［＜常量說明＞］［＜變量說明＞］{＜有返回值函數定義＞|＜無返回值函數定義＞}＜主函數＞
void program(){
    getsym();

    if ( symid == CONSTTK ) {
        //調用常量說明子程序
        conststate();
        //如果是分號,則是正常的
    }

    //變量定義和有返回值的函數是相同的聲明頭部。因此預讀3個單詞用於判斷
    while ( symid == INTTK || symid == CHARTK ) {
        int tempid = symid;//恢復現場用
        char tempch = ch;//恢復現場用
        int tempcnum = cnum;//恢復現場用
        kind = symid;
        getsym();
        strcpy(name, id.c_str());//拷貝名字

        //如果標識符合法
        if ( symid != IDEN ) {
            error(IDENTIFIERLACK);//notdone
            continue;
        }
        getsym();
        //如果是逗號或者分號，則是變量定義
        if ( symid == COMMA || symid == LBRACK ) {
            symid = tempid;
            cnum = tempcnum;
            ch = tempch;
            varstate();
            continue;
        }
        else if ( symid == SEMICN ) {
            value = 0;
            address = 0;
            paranum = 0;
            pushtable(name, kind, value, address, paranum);
            if ( kind == INTTK ) insmidcode("int", "  ", "  ", name);
            else if ( kind == CHARTK ) insmidcode("char", "  ", "  ", name);
            getsym();
            continue;
        }
        else{
            symid = tempid;
            cnum = tempcnum;
            ch = tempch;
            break;
        }
    }
    if ( symid == CONSTTK ) {
        errnum++;
        printf("Error %d: Line %d, 常量定義位置錯誤！\n", errnum, lnum);
        conststate();
        //如果是分號,則是正常的
    }
    sislob = 0;
    //進入函數部分
    while ( symid == INTTK || symid == CHARTK || symid == VOIDTK ) {
        int temp = symid;

        //19.＜有返回值函數定義＞  ::=  ＜聲明頭部＞‘(’＜參數＞‘)’  ‘{’＜復合語句＞‘}’
        if ( symid == INTTK || symid == CHARTK ) {
            defhead();
            if ( symid != LPARENT ) {
                error(LEFTPARENTLACK);
                continue;
            }
            varcnt = 0;     //臨時變量重新開始計數
            returnnum = 0;//將是否存在返回值的標記初始化，0表示無返回值，即未出現return
            kind = FUNCTION;//表示當前的函數是子程序，即非主函數
            value = 1;//1對於函數來說，表示返回值為Int 0返回值為void
            address = 0;
            paranum = 0;
            pushtable(name, kind, value, address, paranum);
            strcpy(procname, name);//函數名拷貝
            if ( temp == INTTK ) insmidcode("func", "int", "  ", procname);
            if ( temp == CHARTK ) insmidcode("func", "char", "  ", procname);
            getsym();
            parametertable();
            //缺'('＜參數＞')'的右小括號
            if ( symid != RPARENT ){
                error(RIGHTPARENTLACK);
                continue;
            }
            getsym();
            //缺'{'＜復合語句＞'}'的左大括號
            if ( symid != LBRACE ) {
                error(LEFTBRACELACK);
                continue;
            }
            getsym();
            complexsentence();
            //缺'{'＜復合語句＞'}'的右大括號
            if ( symid != RBRACE ) {
                error(RIGHTBRACELACK);
                continue;
            }

            //函數缺少返回值
            if ( returnnum == 0 ) {
                error(NONERETURN);
                continue;
            }
            getsym();
            insmidcode("end", "  ", "  ", procname);//函數部分四元式結束
            flushst();//清除符號表，這里清空的是此子函數的符號表,不清除子函數名
        }

        if ( symid == VOIDTK ) {
            getsym();
            //如果下一個單詞是main，則是＜主函數＞    ::= void main '(' ')'  '{'＜復合語句＞'}'
            if ( symid == MAINTK ) {
                varcnt = 0;        //臨時變量重新開始計數
                strcpy(name, "main");
                kind = FUNCTION;
                value = 0;
                address = 0;
                paranum = 0;
                pushtable(name, kind, value, address, paranum);
                strcpy(procname, name);
                insmidcode("func", "  ", "  ", procname);
                getsym();
                if ( symid != LPARENT ) {
                    error(LEFTPARENTLACK);
                    continue;
                }
                getsym();
                if ( symid != RPARENT ) {
                    error(RIGHTPARENTLACK); 
                    continue;
                }
                getsym();
                if ( symid != LBRACE ) {
                    error(LEFTBRACELACK);
                    continue;
                }
                getsym();
                complexsentence();
                mf++;    //主函數的個數+1
                insmidcode("end", "  ", "  ", procname);
                if ( symid != RBRACE )
                {
                    error(RIGHTBRACELACK);
                    continue;
                }
                return;    //源程序結束，跳出
            }

            //20.＜無返回值函數定義＞  ::= void＜標識符＞‘(’＜參數＞‘)’  ‘{’＜復合語句＞‘}’
            if ( symid != IDEN ) {
                error(IDENTIFIERLACK);
                continue;
            }
            varcnt = 0;          //臨時變量重新開始計數
            strcpy(name, id.c_str());

            kind = FUNCTION;
            value = 0;
            address = 0;
            paranum = 0;
            pushtable(name, kind, value, address, paranum);
            strcpy(procname, name);
            insmidcode("func", "void", "  ", procname);
            getsym();
            if ( symid != LPARENT ) {
                error(LEFTPARENTLACK);
                continue;
            }
            getsym();
            parametertable();
            if ( symid != RPARENT ) {
                error(RIGHTPARENTLACK);
                continue;
            }
            getsym();
            if ( symid != LBRACE ) {
                error(LEFTBRACELACK);
                continue;
            }
            getsym();
            complexsentence();
            if ( symid != RBRACE ) {
                error(RIGHTBRACELACK);
                continue;
            }
            getsym();
            insmidcode("end", "  ", "  ", procname);
            flushst();
        }
    }
}


//18.＜類型標識符＞   ::=    int | float | char
//22.＜參數＞         ::=    ＜參數表＞
//23.＜參數表＞    ::=  ＜類型標識符＞＜標識符＞{,＜類型標識符＞＜標識符＞}| ＜空＞
void parametertable()
{
    int i = 0;     //記錄參數個數
    int temp;
    if ( symid == INTTK || symid == CHARTK ) {
        do{
            if ( symid == COMMA )
                getsym();
            temp = symid;
            defhead();    //函數參數和變量定義時完全相同的，只是最后不是以分號結尾
            kind = PARA;     //4表示為函數參數
            value = 0;
            address = i;  //地址為i，即參數的位置，地址全部為相對地址？
            paranum = 0;
            pushtable(name, kind, value, address, paranum);  //將行數參數插入符號表
            if ( temp == INTTK ) insmidcode("para", "int", "  ", name);
            else if ( temp == CHARTK ) insmidcode("para", "char", "  ", name);
            i++;//參數個數加一
        } while ( symid == COMMA );//如果是逗號，則還有其他的參數
    }
    paranum = i;//當前的參數個數
    insertproc(paranum);//插入函數的參數個數
    return;
}

//10.＜常量說明＞ ::=  const＜常量定義＞;{ const＜常量定義＞;}
//ATTENTION:在這里會直接讀出類型
void conststate(){
    while ( symid == CONSTTK ) {
        getsym();
        int tclass;
        if ( symid == INTTK || symid == CHARTK ) {
            kind = ( symid == INTTK ) ? CINTCON : CCHARCON;
            address = 0;
            paranum = 0;
            tclass = symid;
            getsym();
            constdef(tclass);
            while ( symid == COMMA ) {
                getsym();
                constdef(tclass);
            }
            //定義結束，下一個字符一定是分號
            if ( symid != SEMICN ) {
                error(SEMICOLONLACK);
                return;
            }
            hsymid = symid;
            getsym();
        }
        else{
            error(KEYWORDERROR);
            return;
        }
    }
    return;
}

//11.＜常量定義＞   ::=   int＜標識符＞＝＜整數＞{,＜標識符＞＝＜整數＞}    | char＜標識符＞＝＜字符＞{,＜標識符＞＝＜字符＞}
//ATTENTION:這里不包含int和char, int, 這兩者將從tclass傳入
void constdef(int tclass){
    //without int or char
    char temp[ 200 ];
    //結構：IDEN = XXXX
    if ( symid == IDEN ) {
        strcpy(name, id.c_str());
        getsym();
        //if is '='
        if ( symid == ASSIGN ) {
            getsym();
            // if is '+' or '-'
            if ( symid == PLUS || symid == MINU ) {
                int symb = symid;
                getsym();
                // if is integer
                if ( tclass == INTTK && symid == INTCON ) {
                    if ( symb == PLUS ) {
                        value = num;
                    }
                    else{
                        value = 0 - num;
                    }
                    pushtable(name, kind, value, address, paranum);
                    sprintf(temp, "%d", value);
                    insmidcode("const", "int", temp, name);
                }

                // if is char
            }
            else if ( symid == CHARCON ){
                value = id.c_str()[ 0 ];
                pushtable(name, kind, value, address, paranum);
                sprintf(temp, "%d", value);
                insmidcode("const", "char", temp, name);
            }
            else if ( symid == INTCON ){
                value = num;
                pushtable(name, kind, value, address, paranum);
                sprintf(temp, "%d", value);
                insmidcode("const", "int", temp, name);
            }
            else{
                error(UNKNOWRIGHTSYM);
                return;
            }
        }else{
            error(CONSTNOTINIT);
            return;
        }
    }
    else{
        error(CSTDEFINEFAIL);
    }
    getsym();
    return;
}

//15.＜聲明頭部＞   ::=  int＜標識符＞ | char＜標識符＞
//ATTENTION: 讀到的是int/char和標識符以及其后面的一個單詞！！
void defhead()
{
    if ( symid == INTTK || symid == CHARTK ) {
        kind = symid;
        getsym();

        if ( symid != IDEN ) {
            error(IDENTIFIERLACK, 1);
            return;
        }
        else {
            strcpy(name, id.c_str());//拷貝函數的名字
        }
    }
    else{
        error(KEYWORDERROR, 1);
        return;
    }
    getsym();
    return;
}

//16.＜變量說明＞  ::= ＜變量定義＞;{＜變量定義＞;}
void varstate()
{
    vardef();
    //缺少';'
    if ( symid != SEMICN ) {
        error(SEMICOLONLACK, 1);
    }
    getsym();
    return;
}


//17.＜變量定義＞  ::= ＜類型標識符＞(＜標識符＞|＜標識符＞‘[’＜無符號整數＞‘]’){,(＜標識符＞|＜標識符＞‘[’＜無符號整數＞‘]’ )}
void vardef()
{
    if ( symid == INTTK || symid == CHARTK ) {
        kind = symid;
        getsym();

        if ( symid != IDEN ) {
            error(IDENTIFIERLACK, 2);
            return;
        }
        else {
            strcpy(name, id.c_str());//拷貝函數的名字
        }
    }
    else{
        error(KEYWORDERROR, 2);
        return;
    }
    getsym();
    int isVec = ( symid == LBRACK );
    value = 0;
    address = 0;
    paranum = 0;
    if ( isVec ) {    //如果是數組
        getsym();
        if ( symid != INTCON ) {
            error(IMMLACK);
            return;
        }
        else{
            pushtable(name, kind, value, address, paranum, num);
            if ( kind == INTTK )
                insmidcode("inta", 0, num, name);
            else if ( kind == CHARTK )
                insmidcode("chara", 0, num, name);
            getsym();
            if ( symid != RBRACK ) {
                error(RIGHTBRACKLACK, 1);
                return;
            }
            else{
                getsym();
            }
        }
    }
    else{
        pushtable(name, kind, value, address, paranum, isVec);
        if ( kind == INTTK )
            insmidcode("int", "  ", "  ", name);
        else if ( kind == CHARTK )
            insmidcode("char", "  ", "  ", name);
    }

    //如果后面是逗號，那么變量定義未結束
    while ( symid == COMMA ) {
        getsym();
        //出現不合法的標志符
        if ( symid != IDEN ) {
            error(IDENTIFIERLACK, 2);
            return;
        }
        strcpy(name, id.c_str());
        getsym();
        isVec = ( symid == LBRACK );
        if ( isVec ) {    //如果是數組
            getsym();
            if ( symid != INTCON ) {
                error(IMMLACK);
                return;
            }
            else{
                pushtable(name, kind, value, address, paranum, num);
                if ( kind == INTTK )
                    insmidcode("int", 0, num, name);
                else if ( kind == CHARTK )
                    insmidcode("char", 0, num, name);
                getsym();
                if ( symid != RBRACK ) {
                    error(RIGHTBRACKLACK);
                    return;
                }
                else{
                    getsym();
                }
            }
        }
        else{
            pushtable(name, kind, value, address, paranum, isVec);
            if ( kind == INTTK )
                insmidcode("int", "  ", "  ", name);
            else if ( kind == CHARTK )
                insmidcode("char", "  ", "  ", name);
        }
    }
    return;
}

//21.＜復合語句＞   ::=  ［＜常量說明＞］［＜變量說明＞］＜語句列＞
void complexsentence()
{
    if ( symid == CONSTTK ) {
        //調用常量說明子程序
        conststate();
        //如果是分號,則是正常的
        while ( hsymid == SEMICN ) {
            if ( symid == CONSTTK )
                conststate();
            else break;
        }
    }

    //判斷是否為變量說明
    //設置部分變量用於恢復現場
    while ( symid == INTTK || symid == CHARTK ) {
        int tempid = symid;//恢復現場用
        char tempch = ch;//恢復現場用
        int tempcnum = cnum;//恢復現場用
        kind = symid;
        getsym();
        strcpy(name, id.c_str());//拷貝名字

        //如果標識符合法
        if ( symid != IDEN ) {
            error(IDENTIFIERLACK, 2);
            return;
        }
        getsym();
        //如果是逗號或者分號，則是變量定義
        if ( symid == COMMA || symid == LBRACK) {
            symid = tempid;
            cnum = tempcnum;
            ch = tempch;
            varstate();
            continue;
        }
        else if ( symid == SEMICN ) {
            value = 0;
            address = 0;
            paranum = 0;
            pushtable(name, kind, value, address, paranum);
            if ( kind == INTTK ) insmidcode("int", "  ", "  ", name);
            else if ( kind == CHARTK ) insmidcode("char", "  ", "  ", name);
            getsym();
            continue;
        }
        else{
            error(SEMICOLONLACK, 1);
            return;
        }
    }

    //語句列
    sentencelist();
    return;
}

//37.＜語句列＞   ::= ｛＜語句＞｝
void sentencelist()
{
    sentence();
    //語句，如果讀到的是如下的東西，那么還是語句
    while ( symid == IFTK || symid == WHILETK || symid == FORTK || symid == LBRACE
        || symid == IDEN || symid == RETURNTK || symid == SCANFTK || symid == PRINTFTK ) {
        sentence();
    }
}

//30.＜條件語句＞  ::=  if ‘(’＜條件＞‘)’＜語句＞［else＜語句＞］
void ifsentence()
{
    char label1[ 10 ], label2[ 10 ], conditionvalue[ 30 ];
    strcpy(label1, nextlab());  //如果不滿足if，則跳過label1，label1是if的結束部分
    strcpy(label2, nextlab());  //如果還有else，則else的結束位置是label2
    getsym();
    //少“(”
    if ( symid != LPARENT ) {
        error(LEFTPARENTLACK, 1);
        return;
    }
    getsym();
    //＜條件＞
    condition();
    strcpy(conditionvalue, nowitem);  //條件計算的值在nowitem里面,此處應該是個臨時變量$_x
    insmidcode("jne", "  ", "  ", label1);  //比較，為假的時候跳轉
    if ( symid != RPARENT ) {
        error(RIGHTPARENTLACK, 1);
        return;
    }
    getsym();
    sentence();
    insmidcode("jmp", "  ", "  ", label2);//不執行else的部分
    insmidcode("lab:", "  ", "  ", label1);
    if ( symid == ELSETK ) {
        getsym();
        sentence();
    }
    insmidcode("lab:", "  ", "  ", label2);
    return;
}

//31.＜條件＞    ::=  ＜表達式＞＜關系運算符＞＜表達式＞｜＜表達式＞
void condition()
{
    char place1[ 30 ], place2[ 30 ];
    expression();
    strcpy(place1, nowitem);  //條件至少有一個表達式
    //關系運算符
    if ( symid == LSS || symid == LEQ || symid == GRE || symid == GEQ || symid == NEQ || symid == EQL ) {
        if ( symid == LSS ) {
            getsym();
            expression();
            strcpy(place2, nowitem);
            insmidcode("<", place1, place2, "  ");
        }
        else if ( symid == LEQ ) {
            getsym();
            expression();
            strcpy(place2, nowitem);
            insmidcode("<=", place1, place2, "  ");
        }
        else if ( symid == GRE ) {
            getsym();
            expression();
            strcpy(place2, nowitem);
            insmidcode(">", place1, place2, "  ");
        }
        else if ( symid == GEQ ) {
            getsym();
            expression();
            strcpy(place2, nowitem);
            insmidcode(">=", place1, place2, "  ");
        }
        else if ( symid == NEQ ) {
            getsym();
            expression();
            strcpy(place2, nowitem);
            insmidcode("!=", place1, place2, "  ");
        }
        else if ( symid == EQL ) {
            getsym();
            expression();
            strcpy(place2, nowitem);
            insmidcode("==", place1, place2, "  ");
        }
        return;
    }
    strcpy(place2, "0");
    insmidcode("!=", place1, place2, "  ");
    return;
}

//32.＜循環語句＞   ::=   while '('＜條件＞')'＜語句＞
//                   | for'('＜標識符＞＝＜表達式＞;＜條件＞;＜標識符＞＝＜標識符＞(+|-)＜步長＞')'＜語句＞
void loopsentence()
{
    int s = 0;
    char names[ 30 ], names1[ 30 ], names2[ 30 ], place2[ 30 ], place3[ 30 ];
    char label1[ 10 ], label2[ 10 ], op_flag[ 5 ];
    strcpy(label1, nextlab());
    strcpy(label2, nextlab());
    if ( symid == WHILETK ) {
        getsym();
        if ( symid != LPARENT ) {
            error(LEFTPARENTLACK, 1);
            return;
        }
        insmidcode("lab:", "  ", "  ", label1);
        getsym();
        condition();
        if ( symid != RPARENT ) {
            error(RIGHTPARENTLACK, 1);
            return;
        }
        insmidcode("jne", "  ", "  ", label2);
        getsym();
        sentence();
        insmidcode("jmp", "  ", "  ", label1);
        insmidcode("lab:", "  ", "  ", label2);
        return;
    }

    if ( symid == FORTK ) {    //for|(...)
        getsym();
        if ( symid != LPARENT ) {//for(|...)
            error(LEFTPARENTLACK, 1);
            return;
        }
        getsym();

        if ( symid != IDEN ) {    //for(i|=x;...;...)
            error(UNACCEPTABLESENTENCE);//不合法的句子
            return;
        }
        strcpy(names, id.c_str());
        getsym();
        if ( symid != ASSIGN ) {    //for(i=|..;...;...)
            error(UNACCEPTABLESENTENCE);
            return;
        }
        s = searchst(names, 0);
        if ( s < 0 ) {     //如果是常量
            if ( s == -1 ) error(VARNOTDEFINE, 1);  //"="左邊是不合法的標識符
            else    error(ASSIGNCONST);
            return;
        }
        getsym();
        expression();    //for(i=a+b|;...;...)
        insmidcode("=", nowitem, "  ", names);
        if ( symid != SEMICN ) {
            error(SEMICOLONLACK, 2);
            return;
        }
        getsym();//for(i=a+b;|...;...)
        insmidcode("lab:", "  ", "  ", label1);
        condition();//for(i=a+b;...;|...)
        insmidcode("jne", "  ", "  ", label2);
        if ( symid != SEMICN ) {
            error(SEMICOLONLACK, 2);
            return;
        }
        getsym();        //for(i=a+b;...;|...)
        //＜標識符＞＝＜標識符＞(+|-)＜步長＞!!!!!!!!!!!
        if ( symid != IDEN ) {
            error(IDENTIFIERLACK, 3);
            return;
        }
        strcpy(names1, id.c_str());
        s = searchst(names1, 0);
        if ( s < 0 ) {     //如果是常量
            if ( s == -1 ) error(VARNOTDEFINE, 1);  //"="左邊是不合法的標識符
            else    error(ASSIGNCONST);
            return;
        }
        getsym();
        if ( symid != ASSIGN ) {
            error(UNACCEPTABLESENTENCE);
            return;
        }
        getsym();
        if ( symid != IDEN ) {
            error(IDENTIFIERLACK, 3);
            return;
        }
        strcpy(names2, id.c_str());
        s = searchst(names2, 0);
        if ( s < 0 ) {     //如果是常量
            if ( s == -1 ) error(VARNOTDEFINE, 1);  //"="左邊是不合法的標識符
            else    error(ASSIGNCONST);
            return;
        }

        getsym();
        if ( symid != PLUS && symid != MINU ) {
            error(PLUSMINULACK);
            return;
        }
        if ( symid == PLUS ) strcpy(op_flag, "+ ");
        else if ( symid == MINU ) strcpy(op_flag, "- ");

        getsym();
        if ( symid != INTCON || num == 0 ) {
            error(UNKNOWRIGHTSYM, 1);     //等號右邊不是合法的整數
            return;
        }
        strcpy(place2, id.c_str());

        getsym();
        if ( symid != RPARENT ) {
            error(RIGHTPARENTLACK, 1);
            return;
        }

        getsym();
        sentence();
        strcpy(place3, nextvar());
        insmidcode(op_flag, names2, place2, place3);
        insmidcode("=", place3, "  ", names1);

        insmidcode("jmp", "  ", "  ", label1);
        insmidcode("lab:", "  ", "  ", label2);
        return;
    }
}

//28.＜語句＞    ::= ＜條件語句＞｜＜循環語句＞｜‘{’＜語句列＞‘}’｜＜有返回值函數調用語句＞;
//|＜無返回值函數調用語句＞;｜＜賦值語句＞;｜＜讀語句＞;｜＜寫語句＞;｜＜空＞;｜＜返回語句＞;
void sentence(){
    int s;

    //條件語句
    if ( symid == IFTK ) {
        ifsentence();
        return;
    }

    //循環語句
    if ( symid == WHILETK || symid == FORTK ) {
        loopsentence();
        return;
    }

    //{‘語句列’}
    if ( symid == LBRACE ) {
        getsym();
        sentencelist();
        //缺“}”
        if ( symid != RBRACE ) {
            error(RIGHTBRACELACK, 1);
            return;
        }
        //不缺“}”
        getsym();
        return;
    }

    //函數調用語句｜＜賦值語句＞;
    
    if ( symid == IDEN ) {
        int isVec = 0;
        char names[ MAXIDENLEN ];
        strcpy(names, id.c_str());
        getsym();
        //＜賦值語句＞;
        //29.＜賦值語句＞   ::=  ＜標識符＞＝＜表達式＞|＜標識符＞'['<表達式>']'＝＜表達式＞
        char place2[ 100 ];
        if ( symid == LBRACK ){ //如果是數組
            s = searchst(names, 0);
            if ( s == -1 )
            {
                error(VARNOTDEFINE, 1);
                return;
            }
            getsym();
            expression();
            strcpy(place2, nowitem);
            if (isdigit(nowitem[0])){
                int arrnums = 0;
                arrnums = arrnum(names);
                if (atoi(nowitem) >= arrnums){
                    printf("Warning: Line:%d index of array out of boundary, which should be less than %d.\n",lnum, atoi(nowitem));
                }
            }
            isVec = 1;
            if ( symid != RBRACK ) {
                error(RIGHTBRACKLACK, 1);
                return;
            }
            getsym();
        }
        if ( symid == ASSIGN ) {
            s = searchst(names, 0);
            if ( s < -1 ) {     //如果是常量
                error(ASSIGNCONST);            //"="左邊是不合法的標識符
                return;
            }
            getsym();
            expression();
            if ( isVec ){
                insmidcode("[]=", names, place2, nowitem);
            }
            else{
                insmidcode("=", nowitem, "  ", names);
            }
            
            if ( symid != SEMICN ) {
                error(SEMICOLONLACK, 2);
                return;
            }
            getsym();
            return;
        }

        //函數調用語句
        if ( symid == LPARENT ) {
            getsym();
            valueofpara();  //計算並記錄參數的值以及個數
            if ( symid != RPARENT ) {
                error(RIGHTPARENTLACK, 1);
                return;
            }
            s = searchst(names, 1);
            if ( s == -1 * FUNCTIONNOTFOUND ) {
                error(FUNCTIONNOTFOUND);
                return;
            }
            else if ( s == -1 * FORMALPARANUMUNMATCH ){
                error(FORMALPARANUMUNMATCH, 1);
                return;
            }
            insmidcode("call", names, "  ", "  ");
            getsym();
            if ( symid != SEMICN ) {
                error(SEMICOLONLACK, 2);
                return;
            }
            getsym();
        }

        else {
            error(UNACCEPTABLESENTENCE);    //不合法的句子
            return;
        }
        return;
    }

    //讀語句
    if ( symid == SCANFTK ) {
        scanfsentence();
        if ( symid != SEMICN ) {
            error(SEMICOLONLACK, 2);
            return;
        }
        getsym();
        return;
    }

    //寫語句
    if ( symid == PRINTFTK ) {
        printfsentence();
        if ( symid != SEMICN ) {
            error(SEMICOLONLACK, 2);
            return;
        }
        getsym();
        return;
    }

    //返回語句
    if ( symid == RETURNTK ) {
        returnsentence();
        //返回語句后缺“；”
        if ( symid != SEMICN ) {
            error(SEMICOLONLACK, 2);
            return;
        }
        getsym();
        return;
    }
    if ( symid == SEMICN )
    {
        getsym();
        return;
    }

    //不合法的句子
    error(UNACCEPTABLESENTENCE);
    return;
}

//36.＜值參數表＞   ::=   ＜表達式＞{,＜表達式＞}｜＜空＞
void valueofpara()
{
    int j = 0;
    vector<string> paraqueue;
    do {
        if ( symid == COMMA )
            getsym();
        if ( symid == PLUS || symid == MINU || symid == IDEN || symid == LPARENT || symid == CHARCON || symid == INTCON ) {
            expression();
            paraqueue.push_back(nowitem);
            j++;
        }
    } while ( symid == COMMA );
    char tc[ 20 ];
    for ( int i = 0; i < paraqueue.size(); i++ ) {
        strcpy(tc, paraqueue[ i ].c_str());
        insmidcode("fupa", "  ", "  ", tc);
    }
    paranum = j;
    paraqueue.~vector();
    return;
}

//38.＜讀語句＞    ::=  scanf ‘(’＜標識符＞{,＜標識符＞}‘)’
void scanfsentence()
{
    char names[ 30 ];
    int s;
    getsym();
    if ( symid != LPARENT ) {
        error(LEFTPARENTLACK, 1);
        return;
    }

    do{
        getsym();
        if ( symid != IDEN ) {
            error(IDENTIFIERLACK, 3);         //不合法的標志符
            return;
        }
        strcpy(names, id.c_str());
        s = searchst(names, 0);
        if ( s < 0 ) {
            if ( s == -1 )
                error(VARNOTDEFINE, 1);            //未定義標志符
            else
                error(ASSIGNCONST, 1);
            return;
        }
        insmidcode("scf", "  ", "  ", names);
        getsym();
    } while ( symid == COMMA );

    if ( symid != RPARENT ) {
        error(RIGHTPARENTLACK, 1);
        return;
    }
    getsym();
    return;
}

//39.＜寫語句＞    ::=   printf ‘(’＜字符串＞,＜表達式＞‘)’|
//                     printf ‘(’＜字符串＞‘)’| printf ‘(’＜表達式＞‘)’
void printfsentence()
{
    char place1[ 200 ] = "", place2[ 30 ] = ""; //place1是字符串，place2是表達式
    getsym();
    if ( symid != LPARENT ) {
        error(LEFTPARENTLACK, 1);
        return;
    }
    getsym();
    if ( symid == STRCON ) {
        strcpy(place1, id.c_str());
        getsym();
        if ( symid == COMMA ) {
            getsym();
            expression();
            strcpy(place2, nowitem);
        }
    }
    else {
        expression();
        strcpy(place2, nowitem);
    }
    if ( symid != RPARENT ) {
        error(RIGHTPARENTLACK, 1);
        return;
    }
    insmidcode("prt", place1, place2, (factclass == CHAR) ? "char" : "int");
    getsym();
    return;
}

//40.＜返回語句＞   ::=  return[‘(’＜表達式＞‘)’]
void returnsentence()
{
    char place3[ 30 ];
    getsym();
    if ( symid == LPARENT ) {
        getsym();
        expression();//表達式子程序
        strcpy(place3, nowitem);
        if ( symid != RPARENT ) {
            error(RIGHTPARENTLACK, 1);
            return;
        }
        insmidcode("ret", "  ", "  ", place3);
        returnnum++;
        getsym();
        return;
    }
    insmidcode("ret", "  ", "  ", "  ");
    return;
}

//25.＜表達式＞    ::= ［＋｜－］＜項＞{＜加法運算符＞＜項＞}
void expression()
{
    factclass = 0;
    char place1[ 30 ], place2[ 30 ], place3[ 30 ];
    //有＋｜－的情況
    if ( symid == PLUS || symid == MINU ) {
        factclass = INT;
        if ( symid == PLUS ) {
            getsym();
            item();//項，結束后，項的結果會放入全局變量nowitem
            strcpy(place3, nowitem);//把項的結果放入臨時變量的位置
        }
        if ( symid == MINU ) {
            getsym();
            item();//項
            strcpy(place1, nowitem);
            strcpy(place3, nextvar());
            insmidcode("-", "0 ", place1, place3); //place3 = 0 - (place1)
        }
    }
    else {
        item();
        strcpy(place3, nowitem);
    }
    while ( symid == PLUS || symid == MINU ) {
        factclass = INT;
        strcpy(place1, place3);
        if ( symid == PLUS ) {
            getsym();
            item();
            strcpy(place2, nowitem);
            strcpy(place3, nextvar());
            insmidcode("+", place1, place2, place3);
            continue;
        }
        else {
            getsym();
            item();
            strcpy(place2, nowitem);
            strcpy(place3, nextvar());
            insmidcode("-", place1, place2, place3);
            continue;
        }
    }
    strcpy(nowitem, place3);//把表達式的最終值存放在p之中
    return;
}

//26.＜項＞     ::= ＜因子＞{＜乘法運算符＞＜因子＞}
void item()
{
    char place1[ 200 ], place2[ 200 ], place3[ 200 ];
    factor();
    strcpy(place3, nowitem);//這種操作是為了對付只有賦值的情況
    while ( symid == MULT || symid == DIV ) {
        factclass = INT;
        strcpy(place1, place3);
        if ( symid == MULT ) {
            getsym();
            factor();
            strcpy(place2, nowitem);
            strcpy(place3, nextvar());//申請臨時變量
            insmidcode("*", place1, place2, place3);
            continue;
        }
        if ( symid == DIV ) {
            getsym();
            factor();
            strcpy(place2, nowitem);
            strcpy(place3, nextvar());
            insmidcode("/", place1, place2, place3);
            continue;
        }
    }
    strcpy(nowitem, place3);  //每一個項，計算后的值都在變量nowitem里面
    return;
}


//27.＜因子＞    ::= ＜標識符＞｜＜標識符＞‘[’＜表達式＞‘]’｜＜整數＞|＜字符＞｜＜有返回值函數調用語句＞|‘(’＜表達式＞‘)’
void factor()
{
    int t = -1;
    char names[ 30 ], place3[ 30 ];
    //＜標識符＞｜＜有返回值函數調用語句＞
    if ( symid == IDEN ) {
        strcpy(names, id.c_str());
        getsym();
        //如果有左括號，則是＜有返回值函數調用語句＞
        if ( symid == LPARENT ) {
            getsym();
            valueofpara();
            if ( symid != RPARENT ) {
                error(LEFTPARENTLACK, 2);
                return;
            }
            t = searchst(names, 1);
            if ( t < 0 ) {
                if ( t == -1 * FUNCTIONRETURNNULL )
                    error(FUNCTIONRETURNNULL);   //函數無返回值，不能出現在表達式中
                else if ( t == -1 * FUNCTIONNOTFOUND )
                    error(FUNCTIONNOTFOUND, 1);
                return;
            }
            strcpy(place3, nextvar());//生成臨時變量
            insmidcode("call", names, "  ", place3);//將調用的返回值存放在臨時變量里面
            strcpy(nowitem, place3);
            getsym();
            return;
        }

        //如果是變量、數組、
        else if ( symid != LBRACK ){
            t = searchst(names, 0);      //查表，查找到標識符對應的地址
            if (t == -1) {
                error(IDENTIFIERLACK, 4);
                return;
            }
            if ( t < -1 ) {
                t = -t / 2;
            }
            strcpy(nowitem, names);
        }
        else if ( symid == LBRACK ){      //如果是數組
            getsym();
            int tclass = factclass;
            expression();
            factclass = tclass;
            char ttt[ 30 ];
            strcpy(ttt, nowitem);
            
            if (isdigit(nowitem[0])){
                int arrnums = 0;
                arrnums = arrnum(names);
                if (atoi(ttt) >= arrnums){
                    printf("Warning: Line:%d index of array out of boundary, which should be less than %d.\n",lnum, atoi(ttt));
                }
            }
            if ( symid != RBRACK ) {
                error(RIGHTBRACKLACK);
                return;
            }
            else{
                strcpy(nowitem, nextvar());
                insmidcode("geta", names, ttt, nowitem);
                getsym();
            }
        }
        return;
    }

    //'('＜表達式＞')'
    if ( symid == LPARENT ) {
        getsym();
        expression();
        if ( symid != RPARENT ) {
            error(RIGHTPARENTLACK, 2);
            return;
        }
        getsym();
        return;
    }

    // ＜整數＞｜＜字符＞
    if ( symid == PLUS || symid == MINU || symid == INTCON || symid == CHARCON ) {
        int temp = 1;
        if ( symid == PLUS )
            getsym();
        else if ( symid == MINU ) {
            temp = -1;
            getsym();
        }
        if ( symid != INTCON ) {
            if ( symid == CHARCON ){
                if ( factclass != INT ) {
                    factclass = CHAR;
                }
                sprintf(nowitem, "%d", id.c_str()[0]);
                getsym();
                return;
            }
            error(IMMLACK);
            return;
        }
        sprintf(nowitem, "%d", temp * num);
        factclass = INT;
        getsym();
        return;
    }

    error(EXPRESSIONERROR);                  //表達式缺失或錯誤
    return;
}

//
//  midcode.cpp
//  exc0compiler
//
//  Created by sciencefans on 14/11/29.
//  Copyright (c) 2014年 sciencefans. All rights reserved.
//



#include "glob.h"

fourvarcode midcode[ MAXMIDCODE ];
int midcodeiter = 0;
int labelcnt = 0;
int varcnt = 0;
vector <char*> hisvar;

char* itoa(int i){
    char *temp = (char*)malloc(sizeof(char) * 10);
    sprintf(temp, "%d", i);
    return temp;
}

//插入中間代碼
void insmidcode(char* op, char* t1, char* t2, char* t3){
    if ( strcmp(op, "func") == 0 ){
        midcoderst << endl << endl;
    }
    midcoderst << "\t\t";
    midcoderst << op << "\t," << t1 << "\t," << t2 << "\t," << t3 << endl;
    strcpy(midcode[ midcodeiter ].op, op);
    strcpy(midcode[ midcodeiter ].var1, t1);
    strcpy(midcode[ midcodeiter ].var2, t2);
    strcpy(midcode[ midcodeiter ].var3, t3);
    midcodeiter++;
}
void insmidcode(char* op, int t1, int t2, char* t3){
    midcoderst << "\t\t";
    midcoderst << op << "\t," << t1 << "\t," << t2 << "\t," << t3 << endl;
    strcpy(midcode[ midcodeiter ].op, op);
    char *t;

    strcpy(midcode[ midcodeiter ].var1, strcmp(t = itoa(t1), "0") == 0 ? "  " : t);
    strcpy(midcode[ midcodeiter ].var2, t = itoa(t2));
    strcpy(midcode[ midcodeiter ].var3, t3);
    midcodeiter++;
    free(t);
}
void insmidcode(char* op, char* t1, int t2, char* t3){
    midcoderst << "\t\t";
    midcoderst << op << "\t," << t1 << "\t," << t2 << "\t," << t3 << endl;
    strcpy(midcode[ midcodeiter ].op, op);
    char *t;
    strcpy(midcode[ midcodeiter ].var1, t1);
    strcpy(midcode[ midcodeiter ].var2, t = itoa(t2));
    strcpy(midcode[ midcodeiter ].var3, t3);
    midcodeiter++;
    free(t);
}
//生成新的標記
char* nextlab(){
    char *label = (char*)malloc(sizeof(char) * 20);
    strcpy(label, "_LABEL_");
    sprintf(label, "_LABEL_%d", labelcnt++);
    return label;
}

//生成新的變量
char* nextvar()
{
    char *var = (char*)malloc(sizeof(char) * 20);
    sprintf(var, "$_%d", varcnt++);
    //insmidcode("int", "  ", "  ", var);
    hisvar.push_back(var);
    return var;
}

void freetempvar(){
    for ( int i = 0; i < hisvar.size(); i++ ) {
        free(hisvar[ i ]);
    }
}

//
//  main.cpp
//  exc0compiler
//
//  Created by sciencefans on 14/11/22.
//  Copyright (c) 2014年 sciencefans. All rights reserved.
//


#include "glob.h"
#include "err.h"
int mf;
ofstream laxrst, midcoderst, asmrst, symtablehis;
FILE* optcodefile;
int main(int argc, char **argv){
    char filename[500] = "in.c";
    printf("Input the source file:\n");
    char tempsrc[ 500 ];
    gets(tempsrc);
    if ( strlen(tempsrc) > 2 )
        if ( tempsrc[ 0 ] == '\"' ){
            strcpy(filename, tempsrc + 1 );
            filename[ strlen(filename) - 1 ] = 0;
        }else            
            strcpy(filename, tempsrc);
    src = fopen(filename, "r");
    if ( src == NULL )
    {
        error(NOSUCHFILE);
        system("pause");
        return 0;
    }
    laxrst.open("laxrst.txt");
    midcoderst.open("midcode.txt");
    asmrst.open("asmrst.asm");
    symtablehis.open("symbolTable.txt");
    symtablehis << "index" << "\t" << "name" << "\t" << "kind" << "\t" << "value" << "\t" << "address" << "\t" << "paranum" << "\t" << "isVec" << endl;
    getch();
    program();

    if ( mf < 1 ) error(MAINLACK);                         //沒有定義主函數
    do  getsym(); while ( ch == '\n' || ch == ' ' || ch == '\t' );
    if ( symid != -1 )  error(MOREWORD);                //主函數后有多余的代碼

    if ( errnum == 0 ) {
        printf("\n\n編譯成功，沒有語法語義錯誤!\n\n");
        printOptimize();     //打印優化后的四元式
        printf("四元式 生成完成...\n");
        midcode2asm();   //生成匯編碼
        printf("匯編指令 生成完成...\n");
        scan();          //掃描四元式結構數組，完成優化
        printOptimize();
        printf("優化后的四元式 生成完成...\n");
    }

    laxrst.close();
    asmrst.close();
    midcoderst.close();
    symtablehis.close();
    fclose(src);
    
    printf("\n-----------------------------\n");
    if ( errnum == 0 )
    {
        printf("Compile Success.\n");
    }
    printf("Errors:\t%d\tTotal Line: %d\n", errnum, lnum);
    system("pause");
    return 0;
}

#include "err.h"
#include "glob.h"

#define QUIT 1
#define DONOTHING 2
#define ICV    3
#define CICVIFIRSP 4
#define CS    5
#define CLR 6
#define IWFRSPIFCV 7
#define IWFLIRSPE 8
#define IWFXXXANE 9
int errnum = 0;

void error(int _errsig, int signal){
    int errclass = -1;
    errnum++;
    printf("Error %d: LINE %d, COLUMN %d: Near \"%s\" : ", errnum, cnum == 0 ? lnum - 1 : lnum, cnum == 0 ? prllen : cnum + 1, prid.c_str());
    switch ( _errsig ) {
        case  NOSUCHFILE:            errclass = QUIT;    printf("NO SUCH FILE\n");    break;
        case  FILEINCOMPLETE:        errclass = DONOTHING;    printf("FILEINCOMPLETE\n");    break;
        case  DOUBLEQUOTESLACK:        errclass = DONOTHING;    printf("DOUBLEQUOTESLACK\n");    break;
        case  UNACCEPTATLECHAR:        errclass = DONOTHING;    printf("UNACCEPTATLECHAR\n");    break;
        case  SINGLEQUOTESLACK:        errclass = DONOTHING;    printf("SINGLEQUOTESLACK\n");    break;
        case  OUTOFTABLE:            errclass = QUIT;    printf("OUT OF TABLE\n");    break;
        case  SYMBOLCONFLICT:        errclass = DONOTHING;    printf("SYMBOL CONFLICT\n");    break;
        case  CSTDEFINEFAIL:        errclass = CS;    printf("CST DEFINE FAIL\n");    break;
        case  VARNOTINIT:            errclass = DONOTHING;    printf("VARNOTINIT\n");    break;
        case  UNKNOWRIGHTSYM:        errclass =
            signal == 0 ? CS :
            signal == 1 ? IWFLIRSPE :
            -1;
            printf("UNKNOWRIGHTSYM\n");    break;
        case  SEMICOLONLACK:        errclass =
            signal == 0 ? CICVIFIRSP :
            signal == 1 ? IWFRSPIFCV :
            signal == 2 ? IWFLIRSPE :
            -1;
            printf("SEMICOLONLACK\n");
            break;
        case  KEYWORDERROR:
            errclass = signal == 0 ? CICVIFIRSP :
                signal == 1 ? CLR :
                signal == 2 ? IWFRSPIFCV :
                printf("KEYWORDERROR\n");
            break;
        case  IDENTIFIERLACK:        errclass =
            signal == 0 ? ICV :
            signal == 1 ? CLR :
            signal == 2 ? IWFRSPIFCV :
            signal == 3 ? IWFLIRSPE :
            signal == 4 ? IWFXXXANE :
            -1;
            printf("IDENTIFIER LACK\n");
            break;
        case  RIGHTBRACKLACK:        errclass =
            signal == 0 ? IWFXXXANE :
            signal == 1 ? IWFRSPIFCV :
            -1;
            printf("RIGHT BRACK LACK\n");
            break;
        case  FUNCTIONNOTFOUND:        errclass = 
            signal == 0 ? IWFLIRSPE :
            signal == 1 ? IWFXXXANE :
            -1;    
            printf("FUNCTION NOT FOUND\n");    break;
        case  FORMALPARANUMUNMATCH:    errclass =
            signal == 0 ? DONOTHING :
            signal == 1 ? IWFLIRSPE :
            -1;
            printf("FORMAL PARA NUM UNMATCH\n");    break;
        case  VARNOTDEFINE:            errclass =
            signal == 0 ? DONOTHING :
            signal == 1 ? IWFLIRSPE :
            -1;
            printf("VAR NOT DEFINE\n");    break;
        case  LEFTPARENTLACK:        errclass =
            signal == 0 ? ICV :
            signal == 1 ? IWFLIRSPE :
            signal == 2 ? IWFXXXANE :
            -1;
            printf("LEFT PARENT LACK\n");    break;
        case  RIGHTPARENTLACK:        errclass =
            signal == 0 ? ICV :
            signal == 1 ? IWFLIRSPE :
            signal == 2 ? IWFXXXANE :
            -1;
            printf("RIGHT PARENT LACK\n");    break;
        case  IMMLACK:                errclass = IWFRSPIFCV;    printf("IMM LACK\n");    break;
        case  RIGHTBRACELACK:        errclass =
            signal == 0 ? ICV :
            signal == 1 ? IWFLIRSPE :
            -1;    printf("RIGHT BRACE LACK\n");    break;
        case  FUNCTIONRETURNNULL:    errclass = IWFXXXANE;    printf("FUNCTION RETURN NULL\n");    break;
        case  EXPRESSIONERROR:        errclass = IWFXXXANE;    printf("EXPRESSION ERROR\n");    break;
        case  UNACCEPTABLESENTENCE:    errclass = IWFLIRSPE;    printf("UNACCEPTABLE SENTENCE\n");    break;
        case  ASSIGNCONST:            errclass =
            signal == 0 ? IWFLIRSPE :
            signal == 1 ? IWFLIRSPE :
            -1;
            printf("ASSIGN CONST\n");    break;
        case  LEFTBRACELACK:        errclass = ICV;    printf("LEFT BRACE LACK\n");    break;
        case  NONERETURN:            errclass = ICV;    printf("NON ERETURN\n");    break;
        case  PLUSMINULACK:            errclass = IWFLIRSPE;    printf("PLUS or MINU LACK\n");    break;
        case  MAINLACK:                errclass = DONOTHING;    printf("MAIN LACK\n");    break;
        case  MOREWORD:                errclass = DONOTHING;    printf("MORE WORD\n");    break;
        case  CONSTNOTINIT:        errclass = CS;    printf("CONST NOT INIT\n");    break;
        default:                    errclass = QUIT;    printf("Unknow error occurs! [error code: %d]\n", _errsig);
    }
    /*
    laxrst.close();
    asmrst.close();
    midcoderst.close();
    symtablehis.close();
    fclose(src);
    system("pause");
    exit(0);
    */
    switch ( errclass ){
        case QUIT:
            system("pause");
            exit(0);
            break;
        case DONOTHING:
            break;
        case ICV:
            while ( symid != INTTK && symid != CHARTK && symid != VOIDTK ) {
                if ( symid == -1 )
                {
                    system("pause");    exit(0);
                }
                getsym();
            }
            break;
        case CICVIFIRSP:
            while ( symid != CONSTTK && symid != INTTK && symid != CHARTK && symid != VOIDTK && symid != IFTK && symid != WHILETK
                && symid != FORTK && symid != IDEN && symid != RETURNTK && symid != SCANFTK && symid != PRINTFTK ){
                if ( symid == -1 ) { system("pause");    exit(0); }
                getsym();
            }
            break;
        case CS:
            while ( symid != COMMA && symid != SEMICN ) {
                if ( symid == -1 ) { system("pause");    exit(0); }
                getsym();
            }
            break;
        case CLR:
            while ( symid != COMMA && symid != LPARENT && symid != RPARENT ) {
                if ( symid == -1 ) { system("pause");    exit(0); }
                getsym();
            }
            break;
        case IWFRSPIFCV:
            while ( symid != IFTK && symid != WHILETK && symid != FORTK && symid != RETURNTK && symid != SCANFTK
                && symid != PRINTFTK && symid != INTTK && symid != CHARTK && symid != VOIDTK ) {
                if ( symid == -1 ) { system("pause");    exit(0); }
                getsym();
            }
            break;
        case IWFLIRSPE:
            while ( symid != IFTK && symid != WHILETK && symid != FORTK && symid != LBRACK && symid != IDEN
                && symid != RETURNTK && symid != SCANFTK && symid != PRINTFTK && symid != ELSETK && symid != RBRACE) {
                if ( symid == -1 ) { system("pause");    exit(0); }
                getsym();
            }
            break;
        case IWFXXXANE:
            while ( symid != IFTK && symid != WHILETK && symid != FORTK && symid != LBRACK && symid != IDEN && symid != RETURNTK
                && symid != SCANFTK && symid != PRINTFTK && symid != SEMICN && symid != ELSETK && symid != RPARENT
                && symid != COMMA && symid != PLUS && symid != MINU && symid != MULT && symid != DIV
                && symid != LSS && symid != LEQ && symid != GRE && symid != GEQ && symid != NEQ && symid != EQL ) {
                if ( symid == -1 ) { system("pause");    exit(0); }
                getsym();
            }
            break;
        default:
            break;
    }

}

#include <string.h>
#include "glob.h"

int codeindex = 0;


//掃描這個四元式數組，處理所有的基本塊
void scan()
{
    //找到函數開始
    while ( strcmp(midcode[ codeindex ].op, "func") != 0 ) codeindex++;

    while ( codeindex < midcodeiter ) {
        combine();
        delpublic();
        codeindex++;
    }
    delsetlab();
    return;
}

//合並常數
void combine() {
    int i = codeindex, num1, num2, temp;
    char sum[ 30 ];
    while ( strcmp(midcode[ i ].op, "+") == 0 || strcmp(midcode[ i ].op, "-") == 0 || strcmp(midcode[ i ].op, "*") == 0 || strcmp(midcode[ i ].op, "/") == 0 ) {
        if ( isconst(midcode[ i ].var1) && isconst(midcode[ i ].var2) ) {
            num1 = atoi(midcode[ i ].var1);
            num2 = atoi(midcode[ i ].var2);
            if ( strcmp(midcode[ i ].op, "+") == 0 ) temp = num1 + num2;
            if ( strcmp(midcode[ i ].op, "-") == 0 ) temp = num1 - num2;
            if ( strcmp(midcode[ i ].op, "*") == 0 ) temp = num1*num2;
            if ( strcmp(midcode[ i ].op, "/") == 0 ) temp = num1 / num2;
            sprintf(sum, "%d", temp);
            strcpy(midcode[ i ].op, "=");
            strcpy(midcode[ i ].var1, sum);
            strcpy(midcode[ i ].var2, "  ");
        }
        i++;
    }
}

//刪除公共子表達式
void delpublic()
{
    int i, j, h, k;
    //划分基本塊
    for ( i = codeindex; strcmp(midcode[ i ].op, "+") == 0 || strcmp(midcode[ i ].op, "-") == 0 || strcmp(midcode[ i ].op, "*") == 0 || strcmp(midcode[ i ].op, "/") == 0 || strcmp(midcode[ i ].op, "=") == 0; i++ ) {
        if ( i >= midcodeiter ){
            return;
        }
        if ( midcode[ i ].var3[ 0 ] == '$' ) {
            for ( j = i + 1; strcmp(midcode[ j ].op, "+") == 0 || strcmp(midcode[ j ].op, "-") == 0 || strcmp(midcode[ j ].op, "*") == 0 || strcmp(midcode[ j ].op, "/") == 0 || strcmp(midcode[ j ].op, "=") == 0; j++ ) {
                if ( j >= midcodeiter ){
                    return;
                }
                //尋找公共子表達式
                if ( strcmp(midcode[ j ].op, midcode[ i ].op) == 0 && strcmp(midcode[ j ].var1, midcode[ i ].var1) == 0 && strcmp(midcode[ j ].var2, midcode[ i ].var2) == 0 && midcode[ j ].var3[ 0 ] == '$' ) {
                    //修改變量的名字
                    for ( h = j + 1; strcmp(midcode[ h ].op, "+") == 0 || strcmp(midcode[ h ].op, "-") == 0 || strcmp(midcode[ h ].op, "*") == 0 || strcmp(midcode[ h ].op, "/") == 0 || strcmp(midcode[ h ].op, "=") == 0; h++ ) {
                        if ( h >= midcodeiter ){
                            return;
                        }
                        if ( strcmp(midcode[ h ].var1, midcode[ j ].var3) == 0 )
                            strcpy(midcode[ h ].var1, midcode[ i ].var3);
                        if ( strcmp(midcode[ h ].var2, midcode[ j ].var3) == 0 )
                            strcpy(midcode[ h ].var2, midcode[ i ].var3);
                    }
                    for ( k = j; k< midcodeiter; k++ ) {
                        strcpy(midcode[ k ].op, midcode[ k + 1 ].op);     //刪除
                        strcpy(midcode[ k ].var1, midcode[ k + 1 ].var1);
                        strcpy(midcode[ k ].var2, midcode[ k + 1 ].var2);
                        strcpy(midcode[ k ].var3, midcode[ k + 1 ].var3);
                    }
                    midcodeiter--;
                    j--;
                }
            }
        }
    }
}

//刪除冗余跳轉代碼
void delsetlab()
{
    int i, k, j, t, flag;
    char temp[ 30 ][ 10 ];
    for ( i = 0; i < midcodeiter; i++ ) {
        if ( i >= midcodeiter ){
            return;
        }
        if ( strcmp(midcode[ i ].op, "lab:") == 0 ) {
            j = 0;
            flag = i;
            i = i + 1;
            while ( strcmp(midcode[ i ].op, "lab:") == 0 ) {
                strcpy(temp[ j++ ], midcode[ i ].var3);
                for ( k = i; k<midcodeiter; k++ ) {
                    strcpy(midcode[ k ].op, midcode[ k + 1 ].op);     //刪除
                    strcpy(midcode[ k ].var1, midcode[ k + 1 ].var1);
                    strcpy(midcode[ k ].var2, midcode[ k + 1 ].var2);
                    strcpy(midcode[ k ].var3, midcode[ k + 1 ].var3);
                }
                midcodeiter--;
            }
            if ( j == 0 ) continue;
            for ( k = 0; k <= midcodeiter; k++ ) {
                if ( k >= midcodeiter ){
                    return;
                }
                if ( strcmp(midcode[ k ].op, "jmp") == 0 || strcmp(midcode[ k ].op, "jne") == 0 ) {
                    for ( t = 0; t<j; t++ ) {
                        if ( strcmp(midcode[ k ].var3, temp[ t ]) == 0 )
                            strcpy(midcode[ k ].var3, midcode[ flag ].var3);
                    }
                }
            }
        }
    }
}

//判斷是不是數字
int isconst(char name[])
{
    int i = 0;
    if ( name[ i ] == '-' ) i++;
    while ( name[ i ] != '\0' ) {
        if ( name[ i ]>'9' || name[ i ]<'0' ) return 0;
        i++;
    }
    return 1;
}

//打印優化后的四元式
void printOptimize()
{
    optcodefile = fopen("optMidCode.txt", "w");
    int i = 0;
    while ( i<midcodeiter ) {
        fprintf(optcodefile, "%s,\t", midcode[ i ].op);
        fprintf(optcodefile, "%s,\t", midcode[ i ].var1);
        fprintf(optcodefile, "%s,\t", midcode[ i ].var2);
        fprintf(optcodefile, "%s;\n", midcode[ i ].var3);
        if ( strcmp(midcode[ i ].op, "end") == 0 )
            fprintf(optcodefile, "\n\n");
        i++;
    }
    fclose(optcodefile);
    return;
}

#include "glob.h"
#define rsT asmrst
#define VOID 0
#define INT 1
#define CHAR 2
#define WINT 3
#define WCHAR 4
#define INITSTACK 0x7fffeffc
#define INITDATA 0x10010000
#define OPTFLAG 0    //優化開關

int mi = 0;    //四元式處理的行數
int sp = INITSTACK;    //棧指針,此地址為即將分配的！！相對fp！！地址
int fp = 0;//幀指針
int ap;//地址表計數器
int paran = 0;
int constedge = 0;
int tmi;
int ismain = 0;
int tlabelnum = 0;
int isglob;
int funckin;
int funcnum = 0;

typedef struct {
    char name[ 100 ];
    int kind;
}funcclass;
vector<funcclass> fc;//函數表

typedef struct {
    char name[ 100 ];
    int address;
    int kind;
    int cnt;
}tempvaraddress;//變量表
tempvaraddress addrtable[ 1000 ];//臨時變量在棧中的地址表

typedef struct {
    int symbnum;
    int cnt;
}cntstruct;
cntstruct cnttable[200];//計數器
int cntindex = 0;

int varreg[ 200 ];

bool cmpcnt(cntstruct a, cntstruct b) {
    return a.cnt > b.cnt;
}

int funckind(char *fname) {
    for ( int i = 0; i < fc.size(); i++ ) {
        if ( strcmp(fc[i].name, fname) == 0 ) {
            return fc[ i ].kind;
        }
    }
}

int findvartable(char *name) {
    int t = ap - 1;
    if ( name[ 0 ] == '+' || name[ 0 ] == '-' || name[ 0 ] >= '0'&&name[ 0 ] <= '9' )
        return -1;
    while ( t >= 0 ) {
        if ( strcmp(addrtable[ t ].name, name) == 0 )
            return t;
        t--;
    }
    return -1;
}

int varkind(char *name) {
    int t = ap - 1;
    if ( name[ 0 ] == '+' || name[ 0 ] == '-' || name[ 0 ] >= '0'&&name[ 0 ] <= '9' )
        return -1;
    while ( t >= 0 ) {
        if ( strcmp(addrtable[ t ].name, name) == 0 )
            return addrtable[ t ].kind;
        t--;
    }
    return -1;
}

void midcode2asm(){
    memset(varreg, 0xff, sizeof(int) * 200);
    rsT << "\t.text" << endl;
    rsT << "\t\tori\t$fp\t$sp\t0" << endl;
    rsT << "\t\tli\t$t9\t0x7fffeffc\t#global stack bottom" << endl;
    rsT << "\t\tli\t$t8\t0x10010000\t#save word" << endl;
    sp = 0;
    mi = ap = 0;

    while ( mi < midcodeiter ){
        //全局常量定義
        while ( strcmp(midcode[ mi ].op, "const") == 0 ) {
            pushstack(midcode[ mi ].var2);
            if ( strcmp(midcode[ mi ].var1, "int") == 0 ) {
                insertaddress(WINT);
            } else {
                insertaddress(WCHAR);
            }
            mi++;
        }
        //全局變量定義
        while ( strcmp(midcode[ mi ].op, "int") == 0 || strcmp(midcode[ mi ].op, "char") == 0 ) {
            pushstack("0");
            if ( strcmp(midcode[ mi ].op, "int") == 0 ) {
                insertaddress(WINT);
            } else {
                insertaddress(WCHAR);
            }
            mi++;
        }
        //全局數組定義
        while ( strcmp(midcode[ mi ].op, "inta") == 0 || strcmp(midcode[ mi ].op, "chara") == 0 ) {
            pushstack("0", atoi(midcode[mi].var2));
            if ( strcmp(midcode[ mi ].op, "inta") == 0 ) {
                insertaddress(WINT);
            } else {
                insertaddress(WCHAR);
            }
            mi++;
        }
        rsT << "\t\tj\t__main" << endl;
        constedge = ap;
        //函數定義
        funcclass tfc;
        while ( strcmp(midcode[mi].op, "func") == 0 ) {
            funcnum++;
            if ( strcmp(midcode[ mi ].var1, "char") == 0 ) {
                tfc.kind = CHAR;
                strcpy(tfc.name, midcode[ mi ].var3);
                fc.push_back(tfc);
            } else if ( strcmp(midcode[ mi ].var1, "int") == 0 ) {
                tfc.kind = INT;
                strcpy(tfc.name, midcode[ mi ].var3);
                fc.push_back(tfc);
            } else {
                tfc.kind = VOID;
                strcpy(tfc.name, midcode[ mi ].var3);
                fc.push_back(tfc);
            }
            if ( strcmp(midcode[ mi ].var3, "main") == 0 ) {
                ismain = 1;
                rsT << "__main:" << endl;
            } else {
                ismain = 0;
                rsT << midcode[ mi ].var3 << ":" << endl;
            }
            mi++;
            funcasm();
        }
    }
}

//給地址表插入相對地址，sp不變
void insertaddress(int kind, int addr, int nmi) {
    if ( nmi == -1 ) {
        strcpy(addrtable[ ap ].name, midcode[ mi ].var3);
    } else {
        strcpy(addrtable[ ap ].name, midcode[ nmi ].var3);
    }
    if ( addr == -1 ) {
        addrtable[ ap ].address = sp + 4;
    } else {
        addrtable[ ap ].address = addr;
    }
    addrtable[ ap ].kind = kind;
    addrtable[ ap ].cnt = 0;
    ap++;
}

void pushstack(char* item, int lenth) {
    if ( lenth == 1 ) {
        rsT << "\t\tli\t$t0\t" << item << "\t#" << midcode[tmi].var3 << endl; //li    $t0 item
        rsT << "\t\tsw\t$t0\t($sp)" << endl;      //sw    $t0 $sp
    }
    sp -= ( 4 * lenth );
    rsT << "\t\tsubi\t$sp\t$sp\t" << 4 * lenth << endl; //subi  $sp $sp 4  
    return;
}

//處理函數內容，不處理最后的end和開始的func
void funcasm() {
    memset(varreg, 0xff, sizeof(int) * 200);
    sp = 0;//相對偏移為0
    //保存現場
    rsT << "\t\t#Save Register" << endl;//
    savesreg();
    rsT << "\t\tsw\t$fp\t($sp)" << endl;//保存上一個函數的$fp
    rsT << "\t\tadd\t$fp\t$sp\t$0" << endl;//設置本函數$fp：$fp=$sp
    sp -= 4;
    rsT << "\t\tsubi\t$sp\t$sp\t4" << endl;//$sp-=4
    rsT << "\t\tsw\t$ra\t($sp)" << endl;//保存$ra
    sp -= 4;
    rsT << "\t\tsubi\t$sp\t$sp\t4" << endl;//$sp-=4
    rsT << "\t\t#Save Register Done!" << endl;//
    
    //while ( strcmp(midcode[ mi ].op, "int") == 0 || strcmp(midcode[ mi ].op, "char") == 0
    //    || strcmp(midcode[ mi ].op, "inta") == 0 || strcmp(midcode[ mi ].op, "chara") == 0 ) {
    //    ////變量定義
    //    //while ( strcmp(midcode[ mi ].op, "int") == 0 || strcmp(midcode[ mi ].op, "char") == 0 ) {
    //    //    pushstack("0");
    //    //    if ( strcmp(midcode[ mi ].var1, "int") == 0 ) {
    //    //        insertaddress(INT);
    //    //    } else {
    //    //        insertaddress(CHAR);
    //    //    }
    //    //    mi++;
    //    //}
    //    ////數組定義
    //    //while ( strcmp(midcode[ mi ].op, "inta") == 0 || strcmp(midcode[ mi ].op, "chara") == 0 ) {
    //    //    pushstack("0", atoi(midcode[ mi ].var2));
    //    //    if ( strcmp(midcode[ mi ].var1, "inta") == 0 ) {
    //    //        insertaddress(INT);
    //    //    } else {
    //    //        insertaddress(CHAR);
    //    //    }
    //    //    mi++;
    //    //}
    //}
    //臨時變量定義
    tmi = mi;
    while ( strcmp(midcode[ tmi ].op, "end") != 0 ) {
        char v1[100], v2[100], v3[100];
        strcpy(v1, midcode[ tmi ].var1);
        strcpy(v2, midcode[ tmi ].var2);
        strcpy(v3, midcode[ tmi ].var3);
        

        if ( v1[ 0 ] == '$' && varaddr(v1) == -1 ) {
            pushstack("0");
            insertaddress(INT, -1, tmi);
        }
        if ( v2[ 0 ] == '$' && varaddr(v2) == -1 ) {
            pushstack("0");
            insertaddress(INT, -1, tmi);
        }
        if ( v3[0] == '$' && varaddr(v3) == -1 ) {
            pushstack("0");
            if ( strcmp(midcode[tmi].op, "call") == 0 ) {
                insertaddress(funckind(midcode[tmi].var1), -1, tmi);
            }
            else if ( strcmp(midcode[ tmi ].op, "geta") == 0 ){
                insertaddress(varkind(v1), -1, tmi);
            }
            else{
                insertaddress(INT, -1, tmi);
            }
        }
        tmi++;
    }

    while ( strcmp(midcode[ mi ].op, "end") != 0 ) {
        paran = 0;
        for ( int i = 0; i < strlen(midcode[ mi ].op); i++ ) {
            if ( midcode[ mi ].op[ i ] == ' ' ) {
                midcode[ mi ].op[ i ] = '\0';
                break;
            }
        }
        if ( strcmp(midcode[ mi ].op, "+") == 0 ) addasm();
        if ( strcmp(midcode[ mi ].op, "-") == 0 ) subasm();
        if ( strcmp(midcode[ mi ].op, "*") == 0 ) mulasm();
        if ( strcmp(midcode[ mi ].op, "/") == 0 ) divasm();
        if ( strcmp(midcode[ mi ].op, ">") == 0 ) greasm();
        if ( strcmp(midcode[ mi ].op, ">=") == 0 ) geqasm();
        if ( strcmp(midcode[ mi ].op, "<") == 0 ) lssasm();
        if ( strcmp(midcode[ mi ].op, "<=") == 0 ) leqasm();
        if ( strcmp(midcode[ mi ].op, "!=") == 0 ) neqasm();
        if ( strcmp(midcode[ mi ].op, "==") == 0 ) eqlasm();
        if ( strcmp(midcode[ mi ].op, "=") == 0 ) assasm();
        if ( strcmp(midcode[ mi ].op, "[]=") == 0 ) aassasm();
        if ( strcmp(midcode[ mi ].op, "geta") == 0 ) assaasm();
        if ( strcmp(midcode[ mi ].op, "lab:") == 0 ) setlabasm();
        if ( strcmp(midcode[ mi ].op, "scf") == 0 ) {
            scfasm();
        }
        if ( strcmp(midcode[ mi ].op, "prt") == 0 ) {
            prtasm();
        }
        if ( strcmp(midcode[ mi ].op, "jne") == 0 ) jneasm();
        if ( strcmp(midcode[ mi ].op, "jmp") == 0 ) jmpasm();
        if ( strcmp(midcode[ mi ].op, "fupa") == 0 ) fupaasm();
        if ( strcmp(midcode[ mi ].op, "call") == 0 ) callasm();
        if ( strcmp(midcode[ mi ].op, "ret") == 0 ) retasm();
        if ( strcmp(midcode[ mi ].op, "para") == 0 ) paraasm();
        if ( OPTFLAG ) {
            int flag = 0;
            while ( strcmp(midcode[ mi ].op, "int") == 0
                || strcmp(midcode[ mi ].op, "char") == 0 ) {
                flag = 1;
                intcharasm();
                mi++;
            }
            if (flag)    mi--;
            //引用計數優化
            cntopt();
        } else {
            if ( strcmp(midcode[ mi ].op, "int") == 0
                        || strcmp(midcode[ mi ].op, "char") == 0 ) intcharasm();
        }
        
        if ( strcmp(midcode[ mi ].op, "const") == 0 ) constdefasm();
        if ( strcmp(midcode[ mi ].op, "inta") == 0 || strcmp(midcode[ mi ].op, "chara") == 0 ) intcharaasm();
        mi++;
    }
    ap = constedge;
    //恢復現場
    rsT << "__FEND_LAB_" << funcnum << ":" << endl;//結束開始
    rsT << "\t\tlw\t$ra\t-4($fp)" << endl;//恢復$ra
    rsT << "\t\tadd\t$sp\t$fp\t$0" << endl;//退棧,恢復$sp
    rsT << "\t\tlw\t$fp\t($fp)" << endl;//恢復上一個函數的fp
    loadsreg();//恢復$s0-$s7
    if ( ismain ) {
        rsT << "\t\tli\t$v0\t10" << endl;
        rsT << "\t\tsyscall" << endl;//終止程序
    } else {
        rsT << "\t\tjr\t$ra\t" << endl;//返回
    }
    mi = mi + 1;
    return;
}

//查找匯編變量地址
int varaddr(char *name) {
    int t = ap - 1;
    isglob = 0;
    if ( name[ 0 ] == '+' || name[ 0 ] == '-' || name[ 0 ] >= '0'&&name[ 0 ] <= '9' )
        return -1;
    while ( t >= 0 ) {
        if ( strcmp(addrtable[ t ].name, name) == 0 ) {
            if ( t < constedge ) {
                isglob = 1;
            }
            return addrtable[ t ].address;
        }
        t--;
    }
    return -1;
}

//void dataseg() {
//    rsT << "\t.data" << endl;
//    while ( strcmp(midcode[mi].op, "const") == 0 ) {
//        if ( strcmp(midcode[mi].var1, "int") == 0 || 
//            strcmp(midcode[mi].var1, "char") == 0 ) {
//            rsT << ".word" << endl;
//        }
//    }
//}

//    jmp ,  ,  ,
void jmpasm() {
    rsT << "\t\tj\t" << midcode[ mi ].var3 << endl;
}

//    jne
void jneasm() {
    rsT << "\t\tbne\t$t0\t1\t" << midcode[ mi ].var3 << endl;
}

//    call, f ,   , a 
void callasm() {
    rsT << "\t\tjal\t" << midcode[ mi ].var1 << endl;
    rsT << "\t\tnop\n";
    if ( midcode[ mi ].var3[ 0 ] != ' ' && midcode[ mi ].var3[ 0 ] != '\0' ) {
        int addr2;
        addr2 = varaddr(midcode[ mi ].var3);
        if ( isglob )
            rsT << "\t\tsw\t$v0\t" << addr2 << "($t9)" << endl;
        else
            rsT << "\t\tsw\t$v0\t" << addr2 << "($fp)" << endl;
    }
}

//    lab,  ,  ,
void setlabasm() {
    rsT << midcode[ mi ].var3 << ":\n";
}

//    add, a, b, c
void addasm() {
    int addr1, addr2, addr3;
    if ( isdigit(midcode[ mi ].var1[ 0 ]) || midcode[ mi ].var1[ 0 ] == '-' || midcode[ mi ].var1[ 0 ] == '+' ) {
        rsT << "\t\tli\t$t0\t" << midcode[ mi ].var1 << endl;
    } else {
        addr1 = varaddr(midcode[ mi ].var1);
        if ( isglob )
            rsT << "\t\tlw\t$t0\t" << addr1 << "($t9)" << endl;
        else
            rsT << "\t\tlw\t$t0\t" << addr1 << "($fp)" << endl;
    }
    if ( isdigit(midcode[ mi ].var2[ 0 ]) || midcode[ mi ].var2[ 0 ] == '-' || midcode[ mi ].var2[ 0 ] == '+' ) {
        rsT << "\t\tli\t$t1\t" << midcode[ mi ].var2 << endl;
    } else {
        addr2 = varaddr(midcode[ mi ].var2);
        if ( isglob )
            rsT << "\t\tlw\t$t1\t" << addr2 << "($t9)" << endl;
        else
            rsT << "\t\tlw\t$t1\t" << addr2 << "($fp)" << endl;
    }
    addr3 = varaddr(midcode[ mi ].var3);
    rsT << "\t\tadd\t$t0\t$t0\t$t1" << endl;
    if ( isglob )
        rsT << "\t\tsw\t$t0\t" << addr1 << "($t9)" << endl;
    else
        rsT << "\t\tsw\t$t0\t" << addr3 << "($fp)" << endl;
}

//    sub, a, b, c
void subasm() {
    int addr1, addr2, addr3;
    if ( isdigit(midcode[ mi ].var1[ 0 ]) || midcode[ mi ].var1[ 0 ] == '-' || midcode[ mi ].var1[ 0 ] == '+' ) {
        rsT << "\t\tli\t$t0\t" << midcode[ mi ].var1 << endl;
    } else {
        addr1 = varaddr(midcode[ mi ].var1);
        if ( isglob ) 
            rsT << "\t\tlw\t$t0\t" << addr1 << "($t9)" << endl;
        else
            rsT << "\t\tlw\t$t0\t" << addr1 << "($fp)" << endl;
    }
    if ( isdigit(midcode[ mi ].var2[ 0 ]) || midcode[ mi ].var2[ 0 ] == '-' || midcode[ mi ].var2[ 0 ] == '+' ) {
        rsT << "\t\tli\t$t1\t" << midcode[ mi ].var2 << endl;
    } else {
        addr2 = varaddr(midcode[ mi ].var2);
        if ( isglob )
            rsT << "\t\tlw\t$t1\t" << addr2 << "($t9)" << endl;
        else
            rsT << "\t\tlw\t$t1\t" << addr2 << "($fp)" << endl;
    }
    addr3 = varaddr(midcode[ mi ].var3);
    rsT << "\t\tsub\t$t0\t$t0\t$t1" << endl;
    if ( isglob ) 
        rsT << "\t\tsw\t$t0\t" << addr3 << "($t9)" << endl;
    else
        rsT << "\t\tsw\t$t0\t" << addr3 << "($fp)" << endl;
}

//    mul, a, b, c
void mulasm() {
    int addr1, addr2, addr3;
    if ( isdigit(midcode[ mi ].var1[ 0 ]) || midcode[ mi ].var1[ 0 ] == '-' || midcode[ mi ].var1[ 0 ] == '+' ) {
        rsT << "\t\tli\t$t0\t" << midcode[ mi ].var1 << endl;
    } else {
        addr1 = varaddr(midcode[ mi ].var1);
        if ( isglob )
            rsT << "\t\tlw\t$t0\t" << addr1 << "($t9)" << endl;
        else
            rsT << "\t\tlw\t$t0\t" << addr1 << "($fp)" << endl;
    }
    if ( isdigit(midcode[ mi ].var2[ 0 ]) || midcode[ mi ].var2[ 0 ] == '-' || midcode[ mi ].var2[ 0 ] == '+' ) {
        rsT << "\t\tli\t$t1\t" << midcode[ mi ].var2 << endl;
    } else {
        addr2 = varaddr(midcode[ mi ].var2);
        if ( isglob )
            rsT << "\t\tlw\t$t1\t" << addr2 << "($t9)" << endl;
        else
            rsT << "\t\tlw\t$t1\t" << addr2 << "($fp)" << endl;
    }
    addr3 = varaddr(midcode[ mi ].var3);
    rsT << "\t\tmul\t$t0\t$t0\t$t1" << endl;
    if ( isglob )
        rsT << "\t\tsw\t$t0\t" << addr3 << "($t9)" << endl;
    else
        rsT << "\t\tsw\t$t0\t" << addr3 << "($fp)" << endl;
}

//    div, a, b, c
void divasm() {
    int addr1, addr2, addr3;
    if ( isdigit(midcode[ mi ].var1[ 0 ]) || midcode[ mi ].var1[ 0 ] == '-' || midcode[ mi ].var1[ 0 ] == '+' ) {
        rsT << "\t\tli\t$t0\t" << midcode[ mi ].var1 << endl;
    } else {
        addr1 = varaddr(midcode[ mi ].var1);
        if ( isglob )
            rsT << "\t\tlw\t$t0\t" << addr1 << "($t9)" << endl;
        else
            rsT << "\t\tlw\t$t0\t" << addr1 << "($fp)" << endl;
    }
    if ( isdigit(midcode[ mi ].var2[ 0 ]) || midcode[ mi ].var2[ 0 ] == '-' || midcode[ mi ].var2[ 0 ] == '+' ) {
        rsT << "\t\tli\t$t1\t" << midcode[ mi ].var2 << endl;
    } else {
        addr2 = varaddr(midcode[ mi ].var2);
        if ( isglob )
            rsT << "\t\tlw\t$t1\t" << addr2 << "($t9)" << endl;
        else
            rsT << "\t\tlw\t$t1\t" << addr2 << "($fp)" << endl;
    }
    addr3 = varaddr(midcode[ mi ].var3);
    rsT << "\t\tdiv\t$t0\t$t0\t$t1" << endl;
    if ( isglob )
        rsT << "\t\tsw\t$t0\t" << addr3 << "($t9)" << endl;
    else
        rsT << "\t\tsw\t$t0\t" << addr3 << "($fp)" << endl;
}

//    > , a, b, c
void greasm() {
    int addr1, addr2;
    if ( isdigit(midcode[ mi ].var1[ 0 ]) || midcode[ mi ].var1[ 0 ] == '-' || midcode[ mi ].var1[ 0 ] == '+' ) {
        rsT << "\t\tli\t$t0\t" << midcode[ mi ].var1 << endl;
    } else {
        addr1 = varaddr(midcode[ mi ].var1);
        if ( isglob ) 
            rsT << "\t\tlw\t$t0\t" << addr1 << "($t9)" << endl;
        else
            rsT << "\t\tlw\t$t0\t" << addr1 << "($fp)" << endl;
    }
    if ( isdigit(midcode[ mi ].var2[ 0 ]) || midcode[ mi ].var2[ 0 ] == '-' || midcode[ mi ].var2[ 0 ] == '+' ) {
        rsT << "\t\tli\t$t1\t" << midcode[ mi ].var2 << endl;
    } else {
        addr2 = varaddr(midcode[ mi ].var2);
        if ( isglob )
            rsT << "\t\tlw\t$t1\t" << addr2 << "($t9)" << endl;
        else
            rsT << "\t\tlw\t$t1\t" << addr2 << "($fp)" << endl;
    }
    rsT << "\t\tslt\t$t0\t$t1\t$t0" << endl;
}

//    >=
void geqasm() {
    int addr1, addr2;
    if ( isdigit(midcode[ mi ].var1[ 0 ]) || midcode[ mi ].var1[ 0 ] == '-' || midcode[ mi ].var1[ 0 ] == '+' ) {
        rsT << "\t\tli\t$t0\t" << midcode[ mi ].var1 << endl;
    } else {
        addr1 = varaddr(midcode[ mi ].var1);
        if ( isglob )
            rsT << "\t\tlw\t$t0\t" << addr1 << "($t9)" << endl;
        else
            rsT << "\t\tlw\t$t0\t" << addr1 << "($fp)" << endl;
    }
    if ( isdigit(midcode[ mi ].var2[ 0 ]) || midcode[ mi ].var2[ 0 ] == '-' || midcode[ mi ].var2[ 0 ] == '+' ) {
        rsT << "\t\tli\t$t1\t" << midcode[ mi ].var2 << endl;
    } else {
        addr2 = varaddr(midcode[ mi ].var2);
        if ( isglob )
            rsT << "\t\tlw\t$t1\t" << addr2 << "($t9)" << endl;
        else
            rsT << "\t\tlw\t$t1\t" << addr2 << "($fp)" << endl;
    }
    rsT << "\t\tslt\t$t0\t$t0\t$t1" << endl;
    rsT << "\t\tli\t$t1\t1" << endl;
    rsT << "\t\tsub\t$t0\t$t1\t$t0" << endl;
}

//    <
void lssasm() {
    int addr1, addr2;
    if ( isdigit(midcode[ mi ].var1[ 0 ]) || midcode[ mi ].var1[ 0 ] == '-' || midcode[ mi ].var1[ 0 ] == '+' ) {
        rsT << "\t\tli\t$t0\t" << midcode[ mi ].var1 << endl;
    } else {
        addr1 = varaddr(midcode[ mi ].var1);
        if ( isglob )
            rsT << "\t\tlw\t$t0\t" << addr1 << "($t9)" << endl;
        else
            rsT << "\t\tlw\t$t0\t" << addr1 << "($fp)" << endl;
    }
    if ( isdigit(midcode[ mi ].var2[ 0 ]) || midcode[ mi ].var2[ 0 ] == '-' || midcode[ mi ].var2[ 0 ] == '+' ) {
        rsT << "\t\tli\t$t1\t" << midcode[ mi ].var2 << endl;
    } else {
        addr2 = varaddr(midcode[ mi ].var2);
        if ( isglob )
            rsT << "\t\tlw\t$t1\t" << addr2 << "($t9)" << endl;
        else
            rsT << "\t\tlw\t$t1\t" << addr2 << "($fp)" << endl;
    }
    rsT << "\t\tslt\t$t0\t$t0\t$t1" << endl;
}

//    <=
void leqasm() {
    int addr1, addr2;
    if ( isdigit(midcode[ mi ].var1[ 0 ]) || midcode[ mi ].var1[ 0 ] == '-' || midcode[ mi ].var1[ 0 ] == '+' ) {
        rsT << "\t\tli\t$t0\t" << midcode[ mi ].var1 << endl;
    } else {
        addr1 = varaddr(midcode[ mi ].var1);
        if ( isglob )
            rsT << "\t\tlw\t$t0\t" << addr1 << "($t9)" << endl;
        else
            rsT << "\t\tlw\t$t0\t" << addr1 << "($fp)" << endl;
    }
    if ( isdigit(midcode[ mi ].var2[ 0 ]) || midcode[ mi ].var2[ 0 ] == '-' || midcode[ mi ].var2[ 0 ] == '+' ) {
        rsT << "\t\tli\t$t1\t" << midcode[ mi ].var2 << endl;
    } else {
        addr2 = varaddr(midcode[ mi ].var2);
        if ( isglob )
            rsT << "\t\tlw\t$t1\t" << addr2 << "($t9)" << endl;
        else
            rsT << "\t\tlw\t$t1\t" << addr2 << "($fp)" << endl;
    }
    rsT << "\t\tslt\t$t0\t$t1\t$t0" << endl;
    rsT << "\t\tli\t$t1\t1" << endl;
    rsT << "\t\tsub\t$t0\t$t1\t$t0" << endl;
}

//    ==
void eqlasm() {
    int addr1, addr2;
    if ( isdigit(midcode[ mi ].var1[ 0 ]) || midcode[ mi ].var1[ 0 ] == '-' || midcode[ mi ].var1[ 0 ] == '+' ) {
        rsT << "\t\tli\t$t0\t" << midcode[ mi ].var1 << endl;
    } else {
        addr1 = varaddr(midcode[ mi ].var1);
        if ( isglob )
            rsT << "\t\tlw\t$t0\t" << addr1 << "($t9)" << endl;
        else
            rsT << "\t\tlw\t$t0\t" << addr1 << "($fp)" << endl;
    }
    if ( isdigit(midcode[ mi ].var2[ 0 ]) || midcode[ mi ].var2[ 0 ] == '-' || midcode[ mi ].var2[ 0 ] == '+' ) {
        rsT << "\t\tli\t$t1\t" << midcode[ mi ].var2 << endl;
    } else {
        addr2 = varaddr(midcode[ mi ].var2);
        if ( isglob )
            rsT << "\t\tlw\t$t1\t" << addr2 << "($t9)" << endl;
        else
            rsT << "\t\tlw\t$t1\t" << addr2 << "($fp)" << endl;
    }

    int t1 = tlabelnum++;
    int t2 = tlabelnum++;
    rsT << "\t\tbne\t$t0\t$t1\t__tLABEL" << t1 << endl;
    rsT << "\t\tli\t$t0\t1" << endl;
    rsT << "\t\tj\t__tLABEL" << t2 << endl;
    rsT << "__tLABEL" << t1 << ":" << endl;
    //cout << "__tLABEL" << t1 << ":" << endl;
    rsT << "\t\tli\t$t0\t0" << endl;
    rsT << "__tLABEL" << t2 << ":" << endl;
}

//    !=
void neqasm() {
    int addr1, addr2;
    if ( isdigit(midcode[ mi ].var1[ 0 ]) || midcode[ mi ].var1[ 0 ] == '-' || midcode[ mi ].var1[ 0 ] == '+' ) {
        rsT << "\t\tli\t$t0\t" << midcode[ mi ].var1 << endl;
    } else {
        addr1 = varaddr(midcode[ mi ].var1);
        if ( isglob )
            rsT << "\t\tlw\t$t0\t" << addr1 << "($t9)" << endl;
        else
            rsT << "\t\tlw\t$t0\t" << addr1 << "($fp)" << endl;
    }
    if ( isdigit(midcode[ mi ].var2[ 0 ]) || midcode[ mi ].var2[ 0 ] == '-' || midcode[ mi ].var2[ 0 ] == '+' ) {
        rsT << "\t\tli\t$t1\t" << midcode[ mi ].var2 << endl;
    } else {
        addr2 = varaddr(midcode[ mi ].var2);
        if ( isglob )
            rsT << "\t\tlw\t$t1\t" << addr2 << "($t9)" << endl;
        else
            rsT << "\t\tlw\t$t1\t" << addr2 << "($fp)" << endl;
    }
    int t1 = tlabelnum++;
    int t2 = tlabelnum++;
    rsT << "\t\tbeq\t$t0\t$t1\t__tLABEL" << t1 << endl;
    rsT << "\t\tli\t$t0\t1" << endl;
    rsT << "\t\tj\t__tLABEL" << t2 << endl;
    rsT << "__tLABEL" << t1 << ":" << endl;
    //cout << "__tLABEL" << t1 << ":" << endl;
    rsT << "\t\tli\t$t0\t0" << endl;
    rsT << "__tLABEL" << t2 << ":" << endl;
}

//    =
void assasm() {
    int addr1, addr2;
    if ( isdigit(midcode[ mi ].var1[ 0 ]) || midcode[ mi ].var1[ 0 ] == '-' || midcode[ mi ].var1[ 0 ] == '+' ) {
        rsT << "\t\tli\t$t0\t" << midcode[ mi ].var1 << endl;
    } else {
        addr1 = varaddr(midcode[ mi ].var1);
        if ( isglob )
            rsT << "\t\tlw\t$t0\t" << addr1 << "($t9)" << endl;
        else
            rsT << "\t\tlw\t$t0\t" << addr1 << "($fp)" << endl;
    }
    addr2 = varaddr(midcode[ mi ].var3);
    if (isglob )
        rsT << "\t\tsw\t$t0\t" << addr2 << "($t9)" << endl;
    else
        rsT << "\t\tsw\t$t0\t" << addr2 << "($fp)" << endl;
}

//    []= , a , i , t
void aassasm() {
    int addr1, addr2, addrt;
    addr1 = varaddr(midcode[ mi ].var1);
    int tisglob = isglob;
    if ( isdigit(midcode[ mi ].var2[0]) ) {
        addr1 += (atoi(midcode[ mi ].var2) * 4);
        if ( isdigit(midcode[ mi ].var3[ 0 ]) || midcode[ mi ].var3[ 0 ] == '-' || midcode[ mi ].var3[ 0 ] == '+' ) {
            rsT << "\t\tli\t$t0\t" << midcode[ mi ].var3 << endl;
        } else {
            addr2 = varaddr(midcode[ mi ].var3);
            if ( isglob ) {
                rsT << "\t\tlw\t$t0\t" << addr2 << "($t9)" << endl;
            }else
                rsT << "\t\tlw\t$t0\t" << addr2 << "($fp)" << endl;
        }
        if (isglob)
            rsT << "\t\tsw\t$t0\t" << addr1 << "($t9)" << endl;
        else
            rsT << "\t\tsw\t$t0\t" << addr1 << "($fp)" << endl;
    } else {
        //求數組元素a[i]地址
        addrt = varaddr(midcode[ mi ].var2);//addrt = &i
        if (isglob)
            rsT << "\t\tlw\t$t1\t" << addrt << "($t9)" << endl;    //t1 = i
        else
            rsT << "\t\tlw\t$t1\t" << addrt << "($fp)" << endl;    //t1 = i
        rsT << "\t\tmul\t$t1\t$t1\t4\n";    //t1 = t1 * 4 (t1 = offset)
        rsT << "\t\taddi\t$t1\t$t1\t" << addr1 << endl;    //t1 = &a[i] - $fp
        rsT << "\t\tadd\t$t1\t$t1\t$fp" << endl;//t1 = &a[i]
        if ( isdigit(midcode[ mi ].var3[ 0 ]) || midcode[ mi ].var3[ 0 ] == '-' || midcode[ mi ].var3[ 0 ] == '+' ) {
            rsT << "\t\tli\t$t0\t" << midcode[ mi ].var3 << endl;
        } else {
            addr2 = varaddr(midcode[ mi ].var3);
            if ( isglob ) {
                rsT << "\t\tlw\t$t0\t" << addr2 << "($t9)" << endl;
            } else {
                rsT << "\t\tlw\t$t0\t" << addr2 << "($fp)" << endl;
            }
            
        }
        rsT << "\t\tsw\t$t0\t0($t1)" << endl;
    }
}

//geta, a, n, b
void assaasm() {
    int addr1 = varaddr(midcode[ mi ].var1);
    int tisglob = isglob;
    int addr2;
    if ( isdigit(midcode[ mi ].var2[ 0 ]) || midcode[ mi ].var2[ 0 ] == '-' || midcode[ mi ].var2[ 0 ] == '+' ) {
        addr1 += ( atoi(midcode[ mi ].var2) * 4 );    //addr1 = &a[n]
        addr2 = varaddr(midcode[ mi ].var3);        //addr2 = &b
        if ( tisglob ) {
            rsT << "\t\tlw\t$t0\t" << addr1 << "($t9)" << endl;
        }else
            rsT << "\t\tlw\t$t0\t" << addr1 << "($fp)" << endl;
        if ( isglob ) {
            rsT << "\t\tsw\t$t0\t" << addr2 << "($t9)" << endl;
        }else
            rsT << "\t\tsw\t$t0\t" << addr2 << "($fp)" << endl;
    } else {
        //求數組元素a[i]地址
        int addrt = varaddr(midcode[ mi ].var2);//addrt = &i
        if ( isglob ) {
            rsT << "\t\tlw\t$t1\t" << addrt << "($t9)" << endl;    //t1 = i
        }else
            rsT << "\t\tlw\t$t1\t" << addrt << "($fp)" << endl;    //t1 = i
        rsT << "\t\tmul\t$t1\t$t1\t4\n";    //t1 = t1 * 4 (t1 = offset)
        rsT << "\t\taddi\t$t1\t$t1\t" << addr1 << endl;    //t1 = &a[i] - $fp
        rsT << "\t\tadd\t$t1\t$t1\t$fp" << endl;
        rsT << "\t\tlw\t$t1\t0($t1)\n";    //t1 = a[i]
        addr2 = varaddr(midcode[ mi ].var3);    //addr2 = &b
        if (isglob)
            rsT << "\t\tsw\t$t1\t" << addr2 << "($t9)" << endl;
        else
            rsT << "\t\tsw\t$t1\t" << addr2 << "($fp)" << endl;
    }
}

//scf ,   ,   , a
void scfasm() {
    int addr = varaddr(midcode[ mi ].var3);
    int ti = findvartable(midcode[ mi ].var3);
    int kind = addrtable[ ti ].kind;
    if ( kind == INT ) {
        rsT << "\t\tli\t$v0\t5" << endl;
        rsT << "\t\tsyscall" << endl;
        //rsT << "\t\tsubi\t$v0\t$v0\t" << ( int )'0' << endl;
        if (isglob)
            rsT << "\t\tsw\t$v0\t" << addr << "($t9)" << endl;
        else
            rsT << "\t\tsw\t$v0\t" << addr << "($fp)" << endl;
    } else {
        rsT << "\t\tli\t$v0\t12" << endl;
        rsT << "\t\tsyscall" << endl;
        if ( isglob )
            rsT << "\t\tsw\t$v0\t" << addr << "($t9)" << endl;
        else
            rsT << "\t\tsw\t$v0\t" << addr << "($fp)" << endl;
    }
}

//prt, a, b, symb
void prtasm() {
    int addr;
    if ( midcode[ mi ].var1[ 0 ] != '\0' ) {
        int len = strlen(midcode[ mi ].var1);
        for ( int i = 0; i < len; i++ ) {
            rsT << "\t\tli\t$v0\t11" << endl;
            rsT << "\t\tli\t$a0\t" << int(midcode[ mi ].var1[i]) << endl;
            rsT << "\t\tsyscall" << endl;
        }
    }
    if ( midcode[ mi ].var2[ 0 ] != ' ' && midcode[ mi ].var2[ 0 ] != '\0' ) {
        if ( isdigit(midcode[mi].var2[0]) && strcmp(midcode[mi].var3, "char") == 0 ) {
            rsT << "\t\tli\t$v0\t11" << endl;
            rsT << "\t\tli\t$a0\t" << midcode[ mi ].var2 << endl;
            rsT << "\t\tsyscall" << endl;
            return;
        } else if ( isdigit(midcode[ mi ].var2[ 0 ]) || midcode[ mi ].var2[ 0 ] == '-' || midcode[ mi ].var2[ 0 ] == '+' ) {
            rsT << "\t\tli\t$v0\t1" << endl;
            rsT << "\t\tli\t$a0\t" << midcode[ mi ].var2 << endl;
            rsT << "\t\tsyscall" << endl;
            return;
        }
        addr = varaddr(midcode[ mi ].var2);
        int ti = findvartable(midcode[ mi ].var2);
        int kind = addrtable[ ti ].kind;
        if ( kind == INT || kind == WINT) {
            rsT << "\t\tli\t$v0\t1" << endl;
            if ( isglob ) {
                rsT << "\t\tlw\t$a0\t" << addr << "($t9)" << endl;
            }else
            rsT << "\t\tlw\t$a0\t" << addr << "($fp)" << endl;
            rsT << "\t\tsyscall" << endl;
        } else {
            rsT << "\t\tli\t$v0\t11" << endl;
            if ( isglob )    rsT << "\t\tlw\t$a0\t" << addr << "($t9)" << endl;
            else    rsT << "\t\tlw\t$a0\t" << addr << "($fp)" << endl;
            rsT << "\t\tsyscall" << endl;
        }
    }
}

//fupa,   ,   , a     ==> a is a function parameter
void fupaasm() {
    if ( isdigit(midcode[mi].var3[0]) ) {
        rsT << "\t\tli\t$t0\t" << midcode[ mi ].var3 << endl;
    } else {
        rsT << "\t\tlw\t$t0\t" << varaddr(midcode[ mi ].var3); //li    $t0 item
        if(isglob){
            rsT << "($t9)" << endl;
        }else{
            rsT << "($fp)" << endl;
        }
    }
    rsT << "\t\tsw\t$t0\t($sp)" << endl;      //sw    $t0 $sp
    sp -= 4;
    rsT << "\t\tsubi\t$sp\t$sp\t4" << endl; //subi  $sp $sp 4  
}

//ret ,   ,   , (a)   ==> return a / return
void retasm() {
    if ( midcode[ mi ].var3[ 0 ] != ' ' && midcode[ mi ].var3[ 0 ] != '\0' ) {
        if ( isdigit(midcode[ mi ].var3[ 0 ]) || midcode[ mi ].var2[ 0 ] == '-' || midcode[ mi ].var2[ 0 ] == '+' ) {
            rsT << "\t\tli\t$v0\t" << midcode[ mi ].var3 << endl;
        } else {
            int addr2 = varaddr(midcode[ mi ].var3);
            if ( isglob )
                rsT << "\t\tlw\t$v0\t" << addr2 << "($t9)" << endl;
            else
                rsT << "\t\tlw\t$v0\t" << addr2 << "($fp)" << endl;
        }
    }
    rsT << "\t\tj\t__FEND_LAB_" << funcnum << endl;//跳至結束
}

//para, int, , a == > f(int a, ...)
void paraasm() {
    paranum = 0;
    for ( int i = mi; i < midcodeiter; i++ ) {
        if ( strcmp(midcode[ i ].op, "para") == 0 )
            paranum++;
        else
            break;
    }
    for ( int i = 0; i < paranum; i++ ) {
        int kind = (strcmp(midcode[ mi ].var1, "int") == 0) ? INT : CHAR;
        insertaddress(kind, 4 * ( paranum - i ));
        mi++;
    }
    mi--;
}

void intcharasm() {
    if ( isdigit(midcode[ mi ].var2[0]) ) {
        pushstack(midcode[ mi ].var2);
    } else {
        pushstack("0");
    }
    if ( strcmp(midcode[ mi ].op, "int") == 0 ) {
        insertaddress(INT);
    } else {
        insertaddress(CHAR);
    }
}

void constdefasm() {
    //常量定義
    while ( strcmp(midcode[ mi ].op, "const") == 0 ) {
        pushstack(midcode[ mi ].var2);
        if ( strcmp(midcode[ mi ].var1, "int") == 0 ) {
            insertaddress(INT);
        } else {
            insertaddress(CHAR);
        }
        mi++;
    }
    mi--;
}

void intcharaasm() {
    //數組定義
    while ( strcmp(midcode[ mi ].op, "inta") == 0 || strcmp(midcode[ mi ].op, "chara") == 0 ) {
        pushstack("0", atoi(midcode[ mi ].var2));
        if ( strcmp(midcode[ mi ].op, "inta") == 0 ) {
            insertaddress(INT);
        } else {
            insertaddress(CHAR);
        }
        mi++;
    }
    mi--;
    
}

void cntopt() {
    //引用計數
    int tmi;
    if ( OPTFLAG ) {
        tmi = mi;
        while ( strcmp(midcode[ tmi ].op, "end") != 0 ) {
            if ( !strcmp(midcode[ tmi ].op, "=") || !strcmp(midcode[ tmi ].op, "+") || !strcmp(midcode[ tmi ].op, "-") || !strcmp(midcode[ tmi ].op, "*") || !strcmp(midcode[ tmi ].op, "/") ) {
                cnt(midcode[ tmi ].var1);
                cnt(midcode[ tmi ].var2);
                cnt(midcode[ tmi ].var3);
            }
            tmi++;
        }
        sort(cnttable, cnttable + cntindex, cmpcnt);
        for ( int i = 0; i < 8; i++ ) {
            varreg[ cnttable[ i ].symbnum ] = i;
            int addr = addrtable[ cnttable[ i ].symbnum ].address;
            rsT << "\t\tlw\t$s" << i << "\t" << addr << "($fp)" << endl;
        }
    }
}

void savesreg() {
    if ( OPTFLAG ) {
        for ( int i = 0; i < 8; i++ ) {
            rsT << "\t\tsw\t$t" << i << "\t" << 4 * i << "($t8)" << endl;
        }
    }
}

void loadsreg() {
    if ( OPTFLAG ) {
        for ( int i = 0; i < 8; i++ ) {
            rsT << "\t\tlw\t$t" << i << "\t" << 4 * i << "($t8)" << endl;
        }
    }
}

void cnt(char* name) {
    int t = ap - 1;
    isglob = 0;
    if ( name[ 0 ] == '+' || name[ 0 ] == '-' || ( name[ 0 ] >= '0'&& name[ 0 ] <= '9' ) || name[ 0 ] == ' ' || name[ 0 ] == '\t' || name[ 0 ] == '\0' )
        return ;
    while ( t >= constedge) {
        if ( strcmp(addrtable[ t ].name, name) == 0 ) {
            addrtable[ t ].cnt++;
            for ( int q = 0; q <= cntindex; q++ ) {
                if ( q == cntindex ) {
                    cnttable[ cntindex ].cnt = 1;
                    cnttable[ cntindex ].symbnum = t;
                    cntindex++;
                    break;
                }
                if ( cnttable[q].symbnum == t ) {
                    cnttable[ q ].cnt++;
                    break;
                }
            }
        }
        t--;
    }
}

 

 

 

參考資料

1. 《高級編譯器設計與實現》 （美）Steven S. Muchnick著  趙克佳，沈志宇譯  機械工與出版社
2. 《編譯原理及編譯程序構造》 金茂忠，高仲儀編  北京航空航天大學出版社
3. 《計算機組成與設計 –硬件/軟件接口》（美）Pattersom，Hennessy著 鄭緯民等譯  機械工業出版社