自制編譯器：後端代碼生成

所謂的編譯器後端的作用就是将文法樹翻譯成目标機器碼。所謂目标機器碼，考慮到直接翻譯成具體平台（如X86，ARM等）過于複雜，是以先設計一個虛拟機，并翻譯成這個虛拟機的機器碼。

對于虛拟機以及其指令格式可參考這篇文章http://blog.csdn.net/roger__wong/article/details/8947720，如何去嘗試實作這個虛拟機是在我的另外一個系列的部落格裡進行論述。

本篇文章從以下是那個方面來論述：後端架構與關鍵資料結構、節點翻譯方式。

1、後端架構和關鍵資料結構

後端接受前端的文法樹作為輸入，對于其每一個節點根據節點類型的不同産生不同的代碼。但在實作過程中為了簡單友善，我并沒有把後端抽象出一個單獨的子產品，而是在文法樹每一個節點的基礎上增加了一個genCode方法，通過調用這個方法來生成該節點及其所有孩子節點（通過遞歸）的代碼。

其次編譯器後端直接生成Class檔案（檔案結構也在上文提到的部落格中有說明），程式中後端首先構造一個ClassOfClass的實體，然後再調用此類的方法生成Class檔案：

[java]  view plain copy

1. public class ClassOfClass {  
2.     public static int isPublic=1;  
3.     public static int isStatic=2;  
4.     public ArrayList<field> fields;  
5.     public ArrayList<function> functions;  
6.     public ArrayList<String> constPool;  
7.     public String name;  
8.     public ClassOfClass()  
9.     {  
10.         constPool=new ArrayList<String>();  
11.         fields=new ArrayList<field>();  
12.         functions=new ArrayList<function>();  
13.     }  
14.     public void WriteClassFile(String path)  
15.     {  
16.         try {  
17.             PrintWriter pw=new PrintWriter(new FileOutputStream(path));  
18.             pw.println(name);  
19.             pw.println(fields.size());  
20.             for(field f:fields)  
21.             {  
22.                 pw.println(f.toString());  
23.             }  
24.             pw.println(functions.size());  
25.             for(function f:functions)  
26.             {  
27.                 pw.println(f.toString());  
28.             }  
29.         } catch (FileNotFoundException e) {  
30.             // TODO Auto-generated catch block  
31.             e.printStackTrace();  
32.         }  
33.     }  
34. }  

其中field結構：

[java]  view plain copy

1. public class field {  
2.     public int head;  
3.     public String type;  
4.     public String fieldname;  
5.     @Override  
6.     public String toString()  
7.     {  
8.         StringBuffer sb=new StringBuffer();  
9.         sb.append(head);  
10.         sb.append(" ");  
11.         sb.append(type);  
12.         sb.append(" ");  
13.         sb.append(fieldname);  
14.         return sb.toString();  
15.     }  
16. }  

其中Function結構

[java]  view plain copy

1. public class function {  
2.     public int head;  
3.     public String rettype;  
4.     public int argnum;  
5.     public ArrayList<String> args;  
6.     public ArrayList<Code> codes;  
7.     public function()  
8.     {  
9.         args=new ArrayList<String>();  
10.         codes=new ArrayList<Code>();  
11.     }  
12.      @Override  
13.         public String toString()  
14.         {  
15.             StringBuffer sb=new StringBuffer();  
16.             sb.append(head);  
17.             sb.append(" ");  
18.             sb.append(rettype);  
19.             sb.append(" ");  
20.             sb.append(args.size());  
21.             sb.append(" ");  
22.             for(String s:args)  
23.             {  
24.                 sb.append(s+" ");  
25.             }  
26.             sb.append("\r\n");  
27.             sb.append("{");  
28.             for(int i=0;i<=codes.size()-1;i++)  
29.             {  
30.                 sb.append(i+":"+codes.get(i).toString()+"\r\n");  
31.             }  
32.             sb.append("\r\n");  
33.             sb.append("}");  
34.             return sb.toString();  
35.         }  
36. }  

其中Code結構

[java]  view plain copy

1. public class Code {  
2.     public int Opcode;//操作碼  
3.     public ArrayList<String> Operands;  
4.     public Code(int op)  
5.     {  
6.         Operands=new ArrayList<String>();  
7.         Opcode=op;  
8.     }  
9.      @Override  
10.         public String toString()  
11.         {  
12.             StringBuffer sb=new StringBuffer();  
13.             sb.append(Opcode);  
14.             sb.append(" ");  
15.             for(String s:Operands)  
16.             {  
17.                 sb.append(s+" ");  
18.             }  
19.             return sb.toString();  
20.         }  

[java]  view plain copy

1. }  

完成一個Class的後端代碼的生成工作，隻需要調用文法樹根節點（classdef）的genCode即可完成，因為根節點會不斷的遞歸調用其子樹的genCode方法，是以在遞歸調用的時候需要某些機制進行各方法之間資訊的傳遞，這裡建立新類BackendClassManager來進行資訊的傳遞，消除耦合。

[java]  view plain copy

1. public class BackendClassManager {  
2.     public static ClassOfClass cc=new ClassOfClass();//正在生成的class對象  
3.     public static function tFunc;//正在生成代碼的函數  
4.     public static memberfuncdeclare mfc;//正在生成代碼的文法樹中的memberfuncdeclare節點  
5.     public static constructor ct;//正在生成代碼的構造函數節點  
6.     public static HashMap<String,Integer> nameSlot=new HashMap<String,Integer>();//局部變量和局部變量表槽的對應hash  
7.     public static expr expr1,expr2;//正在翻譯的 expr  
8.     public static Stack<ArrayList<Code>> loopcontinue=new Stack<ArrayList<Code>>();//在循環語句中出現的continue語句，用于回填位址  
9.     public static Stack<ArrayList<Code>> loopbreak=new Stack<ArrayList<Code>>();//在循環語句中出現的break語句，用于回填位址  
10.     public static void WriteToClassFile()  
11.     {  
12.         String path="E:/test.class";  
13.         cc.WriteClassFile(path);  
14.     }  
15.     public static void genCode(classdef cd)  
16.     {  
17.         cd.genCode();  
18.     }  
19. }  

cc代表目前正在編譯的class。

tFunc代表正在生成代碼的函數，也就是所有genCode的方法都要把生成的代碼填充到tFunc的codes域中。

memberfuncdeclare代表文法樹中正在生成後端代碼的memberfuncdeclare節點，該節點和其子樹包含此函數的所有代碼。

nameSlot對應源碼中出現的局部變量與目标代碼中的局部變量表槽的一個關系，因為目标代碼将不再會出現局部變量名這個概念，是以需要一個hash在編譯時進行對應。

expr1和expr2對應正在翻譯的expr，在某些運算符需要進行類型轉換時需要用到正在翻譯的表達式的資訊。

loopcontinue和loopbreak用于循環語句的位址回填，因為一個循環在翻譯的過程中，其break需要跳轉到的位址是還未确定的，需要整個循環翻譯完之後對目标位址進行回填。continue雖然可以确定目标位址，但是在continue對應的語句stmt節點無法知道循環的開始位址，需要通過某些機制讓stmt節點知道此循環的開始位址，是以也把continue語句進行回填處理。

除此之外還是用了一個類CodeGenHelper來封裝一些常用的代碼序列，比如i2d,jmp等，目的是為了簡化之後的目标代碼的生成。

2、節點代碼生成

按照從頂至低的方式依次分析。

（1）classdef節點

[java]  view plain copy

1. public void genCode() {  
2.         BackendClassManager.cc.name=cn.toString();  
3.         cb.genCode();  
4.     }  

代碼很簡單，首先把正在編譯的類名設定成classdef中出現的類名，然後調用classbody的genCode方法。

（2）classbody

[java]  view plain copy

1. public void genCode() {  
2.         if(cb!=null)  
3.         {  
4.             cb.genCode();  
5.         }  
6.     }  

依然很簡單，如果classmembers不為空，則調用classmembers的genCode方法。

值得注意的是，這些方法本身并沒有生成目标代碼乃是因為一個類的定義本身并不包含任何邏輯，而代碼本身是對邏輯的闡述，是以在類聲明、函數聲明、成員變量聲明等沒有生成任何有意義的代碼也就不值得奇怪了。

（3）classmembers

[java]  view plain copy

1. public void genCode() {  
2.         if(type==0)  
3.         {  
4.             ((membervardeclare)declare).genCode();  
5.         }  
6.         else if(type==1)  
7.         {  
8.             ((memberfuncdeclare)declare).genCode();  
9.         }  
10.         else if(type==2)  
11.         {  
12.             ct.genCode();  
13.         }  
14.         if(cm!=null)  
15.         {  
16.             cm.genCode();  
17.         }  
18.     }  

根據此classmembers的類型，對membervardeclare、memberfuncdeclare、constructor調用genCode方法，最後對下一個classmemebers調用genCode方法，這和本系列第一篇部落格中的遞推式是對應的。

（4）membervardeclare

[java]  view plain copy

1. public void genCode() {  
2.         // TODO Auto-generated method stub  
3.         field fd=new field();  
4.         ArrayList<field> fs=BackendClassManager.cc.fields;  
5.         if(af.toString().equals("public"))  
6.         {  
7.         fd.head+=ClassOfClass.isPublic;  
8.         }  
9.         if(isstatic==true)  
10.         {  
11.             fd.head+=ClassOfClass.isStatic;  
12.         }  
13.         fd.type=tp.toString();  
14.         fd.fieldname=ID.toString();  
15.         fs.add(fd);  
16.     }  

依然沒有任何代碼生成，隻是将成員變量的資訊放到ClassOfClass對象的fields域中。

（5）memberfundeclare

[java]  view plain copy

1. public void genCode() {  
2.         function func=new function();  
3.         BackendClassManager.tFunc=func;  
4.         BackendClassManager.cc.functions.add(func);  
5.         BackendClassManager.ct=null;  
6.         BackendClassManager.mfc=this;  
7.         BackendClassManager.nameSlot=new HashMap<String,Integer>();  
8.         if(af.toString().equals("public"))  
9.         {  
10.         func.head+=ClassOfClass.isPublic;  
11.         }  
12.         func.rettype=tp.toString();  
13.         if(da!=null)  
14.         {  
15.         ArrayList<type> al=da.gettypelist();  
16.         func.argnum=al.size();  
17.         for(type tp:al)  
18.         {  
19.             func.args.add(tp.toString());  
20.         }  
21.         ArrayList<id> tal=da.getidlist();  
22.         BackendClassManager.nameSlot.put("this", 0);  
23.         for(int i=0;i<=tal.size()-1;i++)  
24.         {  
25.             BackendClassManager.nameSlot.put(tal.get(i).toString(), i+1);  
26.         }  
27.         }  
28.         else  
29.         {  
30.             func.argnum=0;  
31.         }  
32.         fb.genCode();  
33.     }  

成員函數的稍微有點複雜。

首先建立一個新的function對象，并把該對象設定為BackendClassManager.tFun，說明之後所有genCode都為這個函數生成的代碼，并把這個函數加到classofClass對象的functions域中；判斷該函數的傳回值類型、是否是public、是否是靜态，并把相關資訊記錄到function對象中重置nameslot，将函數所有參數壓入nameslot表中，并注意this也當做參數放入表中，然後調用functionbody的genCode，為該函數生成代碼。

（6）constructor

[java]  view plain copy

1. public void genCode() {  
2.         function func=new function();  
3.         BackendClassManager.tFunc=func;  
4.         BackendClassManager.ct=this;  
5.         BackendClassManager.nameSlot=new HashMap<String,Integer>();  
6.         if(af.toString().equals("public"))  
7.         {  
8.         func.head+=ClassOfClass.isPublic;  
9.         }  
10.         func.rettype="NULL";  
11.         if(da!=null)  
12.         {  
13.         ArrayList<type> al=da.gettypelist();  
14.         func.argnum=al.size();  
15.         func.argnum=al.size();  
16.         for(type tp:al)  
17.         {  
18.             func.args.add(tp.toString());  
19.         }  
20.         ArrayList<id> tal=da.getidlist();  
21.         BackendClassManager.nameSlot.put("this", 0);  
22.         for(int i=0;i<=tal.size()-1;i++)  
23.         {  
24.             BackendClassManager.nameSlot.put(tal.get(i).toString(), i+1);  
25.         }  
26.         }  
27.         else  
28.         {  
29.             func.argnum=0;  
30.         }  
31.         ss.genCode();  
32.     }  

(7)funcbody

[java]  view plain copy

1. public void genCode() {  
2.     // TODO Auto-generated method stub  
3.     ss.genCode();  
4.     returnexpr.genCode();  
5.     ArrayList<Code> al=BackendClassManager.tFunc.codes;  
6.     Code code=new Code(0x19);  
7.     al.add(code);  
8. }  

首先stmts生成代碼，然後為傳回表達式生成代碼，最後在codes中加入Code(0x19)，也就是傳回指令。

值得注意的是，這裡做了一個約定，在expr的genCode中，總是把該expr的結果放在expr代碼執行後的棧頂，是以函數傳回時實際上傳回的是棧頂元素的值。

（8）stmts

stmts邏輯上代表一個語句塊或一組語句塊，對應的生成式和在節點中使用的type如下：

stmts --> NUL|            type-->0

                  stmt stmts|        type-->1

                  if(expr) { stmts} stmts|   type-->2

                  if(expr) {stmts} else {stmts}  stmts|       type-->3

                  while(expr) { stmts}     stmts|    type-->4

接下來給出生成後端代碼的代碼：

[html]  view plain copy

1. public void genCode() {  
2.         if(type==1)  
3.         {  
4.             st.genCode();  
5.             stmts1.genCode();  
6.         }  
7.         else if(type==2)  
8.         {  
9.             condition.genCode();  
10.             Code code=new Code(0x18);  
11.             BackendClassManager.tFunc.codes.add(code);  
12.             stmts1.genCode();  
13.             code.Operands.add(String.valueOf(BackendClassManager.tFunc.codes.size()));  
14.             stmts3.genCode();  
15.         }  
16.         else if(type==3)  
17.         {  
18.             condition.genCode();  
19.             Code code=new Code(0x18);  
20.             code.Opcode=0x18;  
21.             BackendClassManager.tFunc.codes.add(code);  
22.             stmts1.genCode();  
23.             Code code1=new Code(0x01);  
24.             code1.Operands.add(String.valueOf(0));  
25.             BackendClassManager.tFunc.codes.add(code1);  
26.             Code code2=new Code(0x18);  
27.             BackendClassManager.tFunc.codes.add(code2);  
28.             code.Operands.add(String.valueOf(BackendClassManager.tFunc.codes.size()));  
29.             stmts2.genCode();  
30.             code2.Operands.add(String.valueOf(BackendClassManager.tFunc.codes.size()));  
31.             stmts3.genCode();  
32.         }  
33.         else if(type==4)  
34.         {  
35.             ArrayList<Code> albreak=new ArrayList<Code>();  
36.             ArrayList<Code> alcontinue=new ArrayList<Code>();  
37.             BackendClassManager.loopbreak.add(albreak);  
38.             BackendClassManager.loopcontinue.add(alcontinue);//循環入口，首先判斷expr  
39.             int pos=BackendClassManager.tFunc.codes.size();  
40.             condition.genCode();  
41.             //跳轉指令  
42.             Code code=new Code(0x18);  
43.             BackendClassManager.tFunc.codes.add(code);  
44.             //循環體  
45.             stmts1.genCode();  
46.         //  code.Operands.add(String.valueOf(end));//表達式回填  
47.             Code code1=new Code(0x01);  
48.             code1.Operands.add(String.valueOf(0));  
49.             BackendClassManager.tFunc.codes.add(code1);//壓入0  
50.             Code code2=new Code(0x18);  
51.             code2.Operands.add(String.valueOf(pos));  
52.             BackendClassManager.tFunc.codes.add(code2);//跳轉到循環入口  
53.             int end=BackendClassManager.tFunc.codes.size();  
54.             code.Operands.add(String.valueOf(end));//表達式回填  
55.             for(Code c:albreak)  
56.             {  
57.                 c.Operands.add(String.valueOf(end));  
58.             }  
59.             for(Code c:alcontinue)  
60.             {  
61.                c.Operands.add(String.valueOf(pos));  
62.             }  
63.             BackendClassManager.loopbreak.pop();  
64.             BackendClassManager.loopcontinue.pop();  
65.             stmts3.genCode();  
66.         }  
67.     }  

對于type=0，沒必要生成任何代碼；對于type=1，生成stmt的代碼然後遞歸再生成stmts的代碼；對于type=2，首先生成條件expr的代碼，在這段代碼執行過後，會将結果放在堆棧頂，然後加入code(0x18)進行跳轉，但此刻的跳轉位址還不能确定，是以先要生成stmts1的代碼，之後回填跳轉位址，再生成stmts3的代碼；對于type=3，和type=2類似，但要在stmts1代碼之後加入無條件跳轉指令，跳轉到else塊後面，無條件跳轉的方法是首先壓入0，再使用0x18也就是ifz進行跳轉;對于type=4要稍微複雜些，首先要計算循環開始的位址（包括判斷expr），然後生成循環體代碼，得到循環結束位址，再回填循環判斷的相關代碼，除此之外，還要回填此循環體内出現的所有break和continue語句的位址。

(9)stmt

首先給出語句stmt的生成式：

 stmt -->   continue;|   type=0

                break;|    type=1

                var-declare;|   type=2

               class-init;|    type=3

               setvalue;|   type=4

               expr;|       type=5

接下來給出代碼：

[java]  view plain copy

1. public void genCode() {  
2.         ArrayList<Code> al=BackendClassManager.tFunc.codes;  
3.         if(type==0)  
4.         {  
5.             CodeGenHelper.JMP(al, 0);  
6.             BackendClassManager.loopcontinue.peek().add(al.get(al.size()-1));  
7.         }  
8.         if(type==1)  
9.         {  
10.             CodeGenHelper.JMP(al, 0);  
11.             BackendClassManager.loopbreak.peek().add(al.get(al.size()-1));  
12.         }  
13.         if(type==5)  
14.         {  
15.             ep.genCode();  
16.         }  
17.         if(type==2)  
18.         {  
19.             vc.genCode();  
20.         }  
21.         if(type==3)  
22.         {  
23.             ci.genCode();  
24.         }  
25.         if(type==4)  
26.         {  
27.             sv.genCode();  
28.         }  
29.     }  

stmt代碼比較簡單，對于break和continue，隻需要加入一個跳轉語句，然後把此跳轉語句加入到相應的清單裡（因為循環是嵌套的，是以使用堆棧來表示這一關系），由外層循環體進行位址回填即可，使用了CodeGenHelper的JMP方法作為輔助函數；對于其它類型則調用其相應節點的genCode方法。

另外給出CodeGenHelper的JMP方法，封裝了壓入0和ifz兩條指令：

[java]  view plain copy

1. public static void JMP(ArrayList<Code> al,int pos)  
2.     {  
3.         Code code1=new Code(0x01);  
4.         code1.Operands.add(String.valueOf(0));  
5.         BackendClassManager.tFunc.codes.add(code1);//壓入0  
6.         Code code2=new Code(0x18);  
7.         code2.Operands.add(String.valueOf(pos));  
8.         BackendClassManager.tFunc.codes.add(code2);//跳轉  
9.     }  

（10）classinit

遞推式：class-init --> ids = new 

            type ( args )| type[expr]

        type:     0            1              

代碼：

[java]  view plain copy

1. public void genCode() {  
2.         ArrayList<Code> al=BackendClassManager.tFunc.codes;  
3.         ag.genCode();  
4.         if(type==0)  
5.         {  
6.             Code code=new Code(0x1C);  
7.             code.Operands.add(tp.toString());  
8.             al.add(code);  
9.         }  
10.         else  
11.         {  
12.             Code code=new Code(0x1D);  
13.             code.Operands.add(tp.toString());  
14.             al.add(code);  
15.         }  
16.         if(is.type==1)  
17.         {  
18.             int slot=CodeGenHelper.SearchByName(is.ID.toString());  
19.             Code code=new Code(0x05);  
20.             code.Operands.add(String.valueOf(slot));  
21.             al.add(code);  
22.         }  
23.         if(is.type==2)  
24.         {  
25.             if(is.getLastIDS().type!=3)  
26.             {  
27.             CodeGenHelper.PutObjectToStack(al, is);  
28.             CodeGenHelper.ChangeStackTopEle(al);  
29.             CodeGenHelper.CodePutField(al, is.getLastID().toString());  
30.             }  
31.             else  
32.             {  
33.                 int value=CodeGenHelper.StoreToLocalTable(al);  
34.                 CodeGenHelper.PutObjectToStack(al, is);  
35.                 CodeGenHelper.CodeGetField(al, is.getLastID().toString());  
36.                 int array=CodeGenHelper.StoreToLocalTable(al);  
37.                 is.getLastIDS().EXPR.genCode();  
38.                 CodeGenHelper.LoadToStack(al, array);  
39.                 CodeGenHelper.LoadToStack(al, value);  
40.                 Code code=new Code(0x26);  
41.                 al.add(code);  
42.             }  
43.         }  
44.         if(is.type==3)  
45.         {  
46.             int slot=CodeGenHelper.StoreToLocalTable(al);  
47.             is.EXPR.genCode();  
48.             CodeGenHelper.LoadToStackByName(al, is.ID.toString());  
49.             CodeGenHelper.LoadToStack(al, slot);  
50.             Code code=new Code(0x26);  
51.             al.add(code);  
52.         }  
53.     }  

首先ag.genCode()把所有參數壓棧，然後根據類别判斷是初始化對象還是數組來使用0x1C或者0x1D指令并把類型作為操作數，當此條指令執行完之後，堆棧頂此時放着傳回的對象或數組的句柄，接下來的任務是将該句柄指派給ids。

接着判斷ids的類型，ids的推導式如下：

ids-> 

*       id|       type 1

          id.ids|      type  2

         id[expr]     type 3

          this|       type=4

如果type=1，則說明是一個局部變量，從nameSlot中找到該局部變量在局部變量表裡的位置（相關操作封裝到了CodeGenHelper的searchByName中），指派給這個槽即可。

如果type=2，說明是某個對象的成員變量，則需要先把這個對象壓入堆棧，再通過putfield指令給此對象指派，若是某個對象的成員變量中的某個元素（即該成員變量是個數組），則需要使用給數組指派的指令。

如果type=3，說明給數組某個元素指派，需要先把下标計算出來，然後通過相應指令給數組指派。

其中的很多操作都封裝在了CodeGenHelper中。

（11）vardeclare

遞推式：

var-declare --> type args|type[] args

代碼：

[java]  view plain copy

1. public void genCode() {  
2.         ArrayList<Code> al=BackendClassManager.tFunc.codes;  
3.         ArrayList<ids> idlist=ags.getidsList();  
4.         for(ids id:idlist)  
5.         {  
6.         BackendClassManager.nameSlot.put(id.getLastID().toString(), BackendClassManager.nameSlot.size());  
7.         }  
8.     }  

可以看到，在變量聲明時并沒有生成任何實際代碼，隻是在局部變量表中給其開辟了一個存儲位置而已。

（12）setvalue

setvalue--> ids = expr   

[java]  view plain copy

1. public void genCode() {  
2.         ArrayList<Code> al=BackendClassManager.tFunc.codes;  
3.           ep.genCode();  
4.         if(is.type==1)  
5.         {  
6.             int slot=CodeGenHelper.SearchByName(is.ID.toString());  
7.             Code code=new Code(0x05);  
8.             code.Operands.add(String.valueOf(slot));  
9.             al.add(code);  
10.         }  
11.         if(is.type==2)  
12.         {  
13.             if(is.getLastIDS().type!=3)  
14.             {  
15.             CodeGenHelper.PutObjectToStack(al, is);  
16.             CodeGenHelper.ChangeStackTopEle(al);  
17.             CodeGenHelper.CodePutField(al, is.getLastID().toString());  
18.             }  
19.             else  
20.             {  
21.                 int value=CodeGenHelper.StoreToLocalTable(al);  
22.                 CodeGenHelper.PutObjectToStack(al, is);  
23.                 CodeGenHelper.CodeGetField(al, is.getLastID().toString());  
24.                 int array=CodeGenHelper.StoreToLocalTable(al);  
25.                 is.getLastIDS().EXPR.genCode();  
26.                 CodeGenHelper.LoadToStack(al, array);  
27.                 CodeGenHelper.LoadToStack(al, value);  
28.                 Code code=new Code(0x26);  
29.                 al.add(code);  
30.             }  
31.         }  
32.         if(is.type==3)  
33.         {  
34.             int slot=CodeGenHelper.StoreToLocalTable(al);  
35.             is.EXPR.genCode();  
36.             CodeGenHelper.LoadToStackByName(al, is.ID.toString());  
37.             CodeGenHelper.LoadToStack(al, slot);  
38.             Code code=new Code(0x26);  
39.             al.add(code);  
40.         }  
41.     }  

setvalue和classinit的代碼幾乎一樣，唯一的差別是classinit中需要調用new和newarray指令得到需要給ids賦的值，而setvalue則是通過計算expr來得到，即使用ep.genCode();

(13)ids

ids的genCode邏輯是指将此ids的值放到堆棧頂，此值或許是個int、double，也可能是個對象的句柄。

遞推式：

[java]  view plain copy

1. ids->   
2.      *       id|       type 1  
3.           id.ids|      type  2  
4.          id[expr]     type 3  
5.           this|       type=4  

代碼：

[java]  view plain copy

1. public void genCode() {  
2.         ArrayList<Code> al=BackendClassManager.tFunc.codes;  
3.         if(type==1)  
4.         {  
5.             Integer slot=BackendClassManager.nameSlot.get(ID.toString());  
6.             if(slot!=null)  
7.             {  
8.             Code code=new Code(0x03);  
9.             code.Operands.add(String.valueOf(slot));  
10.             al.add(code);  
11.             }  
12.             else  
13.             {  
14.                 //error  
15.             }  
16.         }  
17.         if(type==2)  
18.         {  
19.             int slot=BackendClassManager.nameSlot.get(ID.toString());  
20.             Code code=new Code(0x03);  
21.             code.Operands.add(String.valueOf(slot));  
22.             al.add(code);  
23.             IDS.genCode2nd();  
24.         }  
25.         if(type==3)  
26.         {  
27.             EXPR.genCode();//壓入expr值  
28.             int slot=BackendClassManager.nameSlot.get(ID.toString());  
29.             Code code=new Code(0x03);  
30.             code.Operands.add(String.valueOf(slot));  
31.             al.add(code);//壓入array  
32.             code=new Code(0x04);  
33.             al.add(code);//讀取數組元素  
34.         }  
35.         if(type==4)  
36.         {  
37.             int slot=BackendClassManager.nameSlot.get("this");  
38.             Code code=new Code(0x01);  
39.             code.Operands.add(String.valueOf(slot));  
40.         }  
41.     }  
42.     public void genCode2nd() {  
43.         ArrayList<Code> al=BackendClassManager.tFunc.codes;  
44.         if(type==1)  
45.         {  
46.             Code code=new Code(0x20);  
47.             code.Operands.add(ID.toString());  
48.             al.add(code);  
49.         }  
50.         if(type==2)  
51.         {  
52.             Code code=new Code(0x20);  
53.             code.Operands.add(ID.toString());  
54.             al.add(code);  
55.             IDS.genCode2nd();  
56.         }  
57.         if(type==3)  
58.         {  
59.             EXPR.genCode();//壓入expr值  
60.             Code code=new Code(0x20);  
61.             code.Operands.add(ID.toString());  
62.             al.add(code);//壓入數組  
63.             code=new Code(0x04);  
64.             al.add(code);//讀取數組元素  
65.         }  
66.         if(type==4)  
67.         {  
68.          //error  
69.         }  
70.     }  

由于ids的結構不對稱，是以不能使用遞歸的方式來獲得其值。舉例：id.id，第一個id的處理方式是通過局部變量表中拿到其句柄，第二個id的處理方式要通過getfield來拿到其值。是以這兩種處理方式對應的是genCode和genCode2nd。

隻有當第一次調用的時候（也就是其它節點調用）調用genCode，ids節點調用均調用genCode2nd。

（14）expr

[java]  view plain copy

1. public void genCode() {  
2.         ArrayList<Code> al=BackendClassManager.tFunc.codes;  
3.         if(Type==0)  
4.         {  
5.             expr1.genCode();  
6.         }  
7.         else if(Type==1)  
8.         {  
9.             ids.genCode();  
10.         }  
11.         else if(Type==2)  
12.         {  
13.             Code code;  
14.             if(number.isInt==true)  
15.             {  
16.                 code=new Code(0x01);  
17.                 code.Operands.add(number.toString());  
18.             }  
19.             else  
20.             {  
21.                 code=new Code(0x02);  
22.                 code.Operands.add(number.toString());  
23.             }  
24.             al.add(code);  
25.         }  
26.         else if(Type==3)  
27.         {  
28.             literal.genCode();  
29.         }  
30.         else if(Type==4)  
31.         {  
32.             fc.genCode();  
33.         }  
34.         else if(Type==5)  
35.         {  
36.             expr1.genCode();  
37.             Code code=new Code(0x05);  
38.             int pos=BackendClassManager.nameSlot.keySet().size();  
39.             BackendClassManager.nameSlot.put(this.toString(), pos);  
40.             code.Operands.add(String.valueOf(pos));  
41.             al.add(code);  
42.             expr2.genCode();  
43.             code=new Code(0x03);  
44.             code.Operands.add(String.valueOf(pos));  
45.             al.add(code);  
46.             BackendClassManager.expr1=expr1;  
47.             BackendClassManager.expr2=expr2;  
48.             op.genCode();  
49.         }  
50.     }  

expr的genCode方法産生的效果是把此expr的值放到棧頂。

如果type=0，則遞歸調用括号裡的expr的genCode；如果type=1，則把ids的值放到棧頂；如果type=2，先判斷立即數的類型之後再壓入立即數；如果type=3，把字元串的句柄壓入棧頂；type=4調用funccall的genCode；type=5，先生成expr1的位元組碼，然後将結果暫存到局部變量表，之後生成expr2的位元組碼，再把之前的結果壓棧，調用op的genCode代碼為運算符生成位元組碼。

值得注意的是，調用op的genCode之前首先要把參與運算的expr放到全局變量裡，op的位元組碼生成過程需要使用這兩個expr的資訊。

（15）funccall

func-call --> ids . func-name(NUL|args)

[java]  view plain copy

1. public void genCode() {  
2.         // TODO Auto-generated method stub  
3.         ArrayList<Code> al=BackendClassManager.tFunc.codes;  
4.         memberfuncdeclare mfc=(memberfuncdeclare)SyntaxTreeGenerator.getFunctions().get(fn.toString()).value;  
5.         ArrayList<ids> ags=ag.getidsList();  
6.         ArrayList<Integer> poses=new ArrayList<Integer>();  
7.         for(int i=0;i<=ags.size()-1;i++)  
8.         {  
9.             ags.get(i).genCode();  
10.             poses.add(CodeGenHelper.StoreToLocalTable(al));  
11.         }  
12.         for(int i=0;i<=poses.size()-1;i++)  
13.         {  
14.             CodeGenHelper.LoadToStack(al, poses.get(i));  
15.         }  
16.         if(mfc.isstatic==true)  
17.         {  
18.             Code code=new Code(0x1B);  
19.             code.Operands.add(IDS.toString()+"."+fn.toString());  
20.             al.add(code);  
21.         }  
22.         else  
23.         {  
24.             IDS.genCode();  
25.             Code code=new Code(0x1A);  
26.             code.Operands.add(fn.toString());  
27.             al.add(code);  
28.         }  
29.     }  

函數調用的過程如下：

首先所有參數壓棧，然後虛拟機執行call指令，給新函數配置設定執行環境（棧幀），把之前壓棧的參數放到局部變量表中（如果有this參數的話this也要以參數的形式放到局部變量表中）；函數執行完之後虛拟機釋放資源，并把堆棧頂元素（傳回值）放到其調用者的堆棧頂。

首先先從符号表中找到這個函數（封裝在了SyntaxTreeGenerator中），然後得到所有參數，并存儲到局部變量表中（之是以這麼做因為參數的擷取過程可能會把堆棧順序打亂），接着把之前存過的所有參數壓入堆棧，再判斷該函數是否是個靜态函數來使用不同的位元組碼進行調用。

（16）ops

ops --> bitop | logiop | artmop | cprop

[java]  view plain copy

1. public void genCode() {  
2.         if(type==TYPE_BITOP)  
3.         {  
4.             bo.genCode();  
5.         }  
6.         else if(type==TYPE_LOGIOP)  
7.         {  
8.             lo.genCode();  
9.         }  
10.         else if(type==TYPE_ARMTOP)  
11.         {  
12.             ao.genCode();  
13.         }  
14.         else if(type==TYPE_CPROP)  
15.         {  
16.             co.genCode();  
17.         }  
18.     }  

根據不同的類型調用不同op的genCode方法。

（17）cprop

[java]  view plain copy

1. public void genCode() {  
2.         expr expr1,expr2;  
3.         ArrayList<Code> al=BackendClassManager.tFunc.codes;  
4.         expr1=BackendClassManager.expr1;  
5.         expr2=BackendClassManager.expr2;  
6.         boolean intint=true;  
7.         if(expr1.tp.toString().equals("int") && expr2.tp.toString().equals("int"))  
8.         {  
9.             intint=true;  
10.         }  
11.         if(expr1.tp.toString().equals("double") && expr2.tp.toString().equals("double"))  
12.         {  
13.             intint=false;  
14.         }  
15.         if(expr1.tp.toString().equals("int") && expr2.tp.toString().equals("double"))  
16.         {  
17.             CodeGenHelper.i2d(al);  
18.             intint=false;  
19.         }  
20.         if(expr1.tp.toString().equals("double") && expr2.tp.toString().equals("int"))  
21.         {  
22.             int pos=CodeGenHelper.StoreToLocalTable(al);  
23.             Code code=new Code(0x23);  
24.             al.add(code);  
25.             CodeGenHelper.i2d(al);  
26.             CodeGenHelper.LoadToStack(al, pos);  
27.             intint=false;  
28.         }  
29.         if(value.equals(">"))  
30.         {  
31.             if(intint==true)  
32.             {  
33.                 Code code=new Code(0x16);//比較  
34.                 al.add(code);  
35.                 code=new Code(0x01);  
36.                 code.Operands.add("1");//壓入1  
37.                 al.add(code);  
38.                 code=new Code(0x16);//和1比較  
39.                 al.add(code);  
40.                 code=new Code(0x24);//取非  
41.                 al.add(code);  
42.             }  
43.             else  
44.             {  
45.                 Code code=new Code(0x17);//比較  
46.                 al.add(code);  
47.                 code=new Code(0x02);  
48.                 code.Operands.add("1");//壓入1  
49.                 al.add(code);  
50.                 code=new Code(0x17);//和1比較  
51.                 al.add(code);  
52.                 code=new Code(0x24);//取非  
53.                 al.add(code);  
54.             }  
55.         }  
56.         if(value.equals("<"))  
57.         {  
58.             if(intint==true)  
59.             {  
60.                 Code code=new Code(0x16);//比較  
61.                 al.add(code);  
62.                 code=new Code(0x01);  
63.                 code.Operands.add("-1");//壓入1  
64.                 al.add(code);  
65.                 code=new Code(0x16);//和1比較  
66.                 al.add(code);  
67.                 code=new Code(0x24);//取非  
68.                 al.add(code);  
69.             }  
70.             else  
71.             {  
72.                 Code code=new Code(0x17);//比較  
73.                 al.add(code);  
74.                 code=new Code(0x02);  
75.                 code.Operands.add("-1");//壓入1  
76.                 al.add(code);  
77.                 code=new Code(0x17);//和1比較  
78.                 al.add(code);  
79.                 code=new Code(0x24);//取非  
80.                 al.add(code);  
81.             }  
82.         }  
83.         if(value.equals(">="))  
84.         {  
85.             if(intint==true)  
86.             {  
87.                 Code code=new Code(0x16);//比較  
88.                 al.add(code);  
89.                 code=new Code(0x01);  
90.                 code.Operands.add("-1");//壓入1  
91.                 al.add(code);  
92.                 code=new Code(0x16);//和1比較  
93.                 al.add(code);  
94.             }  
95.             else  
96.             {  
97.                 Code code=new Code(0x17);//比較  
98.                 al.add(code);  
99.                 code=new Code(0x02);  
100.                 code.Operands.add("-1");//壓入1  
101.                 al.add(code);  
102.                 code=new Code(0x17);//和1比較  
103.                 al.add(code);  
104.                 code=new Code(0x24);//取非  
105.                 al.add(code);  
106.             }  
107.         }  
108.         if(value.equals("<="))  
109.         {  
110.             if(intint==true)  
111.             {  
112.                 Code code=new Code(0x16);//比較  
113.                 al.add(code);  
114.                 code=new Code(0x01);  
115.                 code.Operands.add("1");//壓入1  
116.                 al.add(code);  
117.                 code=new Code(0x16);//和1比較  
118.                 al.add(code);  
119.             }  
120.             else  
121.             {  
122.                 Code code=new Code(0x17);//比較  
123.                 al.add(code);  
124.                 code=new Code(0x02);  
125.                 code.Operands.add("1");//壓入1  
126.                 al.add(code);  
127.                 code=new Code(0x17);//和1比較  
128.                 al.add(code);  
129.             }  
130.         }  
131.         if(value.equals("=="))  
132.         {  
133.             if(intint==true)  
134.             {  
135.                 Code code=new Code(0x16);//比較  
136.                 al.add(code);  
137.                 code=new Code(0x01);  
138.                 code.Operands.add("0");//壓入1  
139.                 al.add(code);  
140.                 code=new Code(0x16);//和0比較  
141.                 al.add(code);  
142.                 code=new Code(0x24);//取非  
143.                 al.add(code);  
144.             }  
145.             else  
146.             {  
147.                 Code code=new Code(0x17);//比較  
148.                 al.add(code);  
149.                 code=new Code(0x02);  
150.                 code.Operands.add("0");//壓入1  
151.                 al.add(code);  
152.                 code=new Code(0x17);//和0比較  
153.                 al.add(code);  
154.                 code=new Code(0x24);//取非  
155.                 al.add(code);  
156.             }  
157.         }  
158.         if(value.equals("!="))  
159.         {  
160.             if(intint==true)  
161.             {  
162.                 Code code=new Code(0x16);//比較  
163.                 al.add(code);  
164.                 code=new Code(0x01);  
165.                 code.Operands.add("0");//壓入1  
166.                 al.add(code);  
167.                 code=new Code(0x16);//和0比較  
168.                 al.add(code);  
169.             }  
170.             else  
171.             {  
172.                 Code code=new Code(0x17);//比較  
173.                 al.add(code);  
174.                 code=new Code(0x02);  
175.                 code.Operands.add("0");//壓入1  
176.                 al.add(code);  
177.                 code=new Code(0x17);//和0比較  
178.                 al.add(code);  
179.             }  
180.         }  
181.     }  

比較運算符的genCode雖然代碼比較長但是邏輯很簡單。

首先需要根據待比較的expr來決定是否進行類型轉換，目前在語言的設計中，隻有double和int是可比的，其它類型的比較雖然在編譯器不會報錯但在運作時中會進行報錯。

其次根據類型來調用不同的比較指令，再次根據邏輯需要進行二次比較（因為比較指令會根據大于小于等于傳回1、0或-1，和運算符并不等價，需要通過比較兩次使之和運算符等價）。

大體上代碼就這麼多，目前的編譯器已經可以編譯出正确的位元組碼了，但目前代碼還無法執行，需要等到Runtime寫好之後才能運作。

是以本系列部落格到這裡暫時告一段落，若給語言再添加一些進階點的特性，也需要等到我把Runtime寫好再說了。