hao707822882
hao707822882

自制编译器：后端代码生成

所谓的编译器后端的作用就是将语法树翻译成目标机器码。所谓目标机器码，考虑到直接翻译成具体平台（如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.     }  
  15.     public void WriteClassFile(String path)  
  16.     {  
  17.         try {  
  18.             PrintWriter pw=new PrintWriter(new FileOutputStream(path));  
  19.             pw.println(name);  
  20.             pw.println(fields.size());  
  21.             for(field f:fields)  
  22.             {  
  23.                 pw.println(f.toString());  
  24.             }  
  25.             pw.println(functions.size());  
  26.             for(function f:functions)  
  27.             {  
  28.                 pw.println(f.toString());  
  29.             }  
  30.         } catch (FileNotFoundException e) {  
  31.             // TODO Auto-generated catch block  
  32.             e.printStackTrace();  
  33.         }  
  34.     }  
  35. }  
其中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.           
  7.     }  
依然很简单，如果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.           
  4.         field fd=new field();  
  5.           
  6.         ArrayList<field> fs=BackendClassManager.cc.fields;  
  7.         if(af.toString().equals("public"))  
  8.         {  
  9.         fd.head+=ClassOfClass.isPublic;  
  10.         }  
  11.         if(isstatic==true)  
  12.         {  
  13.             fd.head+=ClassOfClass.isStatic;  
  14.         }  
  15.         fd.type=tp.toString();  
  16.         fd.fieldname=ID.toString();  
  17.         fs.add(fd);  
  18.     }  
依然没有任何代码生成，只是将成员变量的信息放到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.           
  18.         for(type tp:al)  
  19.         {  
  20.             func.args.add(tp.toString());  
  21.         }  
  22.         ArrayList<id> tal=da.getidlist();  
  23.         BackendClassManager.nameSlot.put("this", 0);  
  24.         for(int i=0;i<=tal.size()-1;i++)  
  25.         {  
  26.             BackendClassManager.nameSlot.put(tal.get(i).toString(), i+1);  
  27.         }  
  28.         }  
  29.         else  
  30.         {  
  31.             func.argnum=0;  
  32.         }  
  33.         fb.genCode();  
  34.       
  35.     }  
成员函数的稍微有点复杂。

首先建立一个新的function对象，并把该对象设置为BackendClassManager.tFun，说明之后所有genCode都为这个函数生成的代码，并把这个函数加到classofClass对象的functions域中；判断该函数的返回值类型、是否是public、是否是静态，并把相关信息记录到function对象中重置nameslot，将函数所有参数压入nameslot表中，并注意this也当做参数放入表中，然后调用functionbody的genCode，为该函数生成代码。

（6）constructor

[java]  view plain copy
  1. public void genCode() {  
  2.           
  3.         function func=new function();  
  4.         BackendClassManager.tFunc=func;  
  5.         BackendClassManager.ct=this;  
  6.         BackendClassManager.nameSlot=new HashMap<String,Integer>();  
  7.         if(af.toString().equals("public"))  
  8.         {  
  9.         func.head+=ClassOfClass.isPublic;  
  10.         }  
  11.         func.rettype="NULL";  
  12.         if(da!=null)  
  13.         {  
  14.         ArrayList<type> al=da.gettypelist();  
  15.         func.argnum=al.size();  
  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.         ss.genCode();  
  33.           
  34.     }  

(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.               
  47.         //  code.Operands.add(String.valueOf(end));//表达式回填  
  48.               
  49.             Code code1=new Code(0x01);  
  50.             code1.Operands.add(String.valueOf(0));  
  51.             BackendClassManager.tFunc.codes.add(code1);//压入0  
  52.               
  53.             Code code2=new Code(0x18);  
  54.             code2.Operands.add(String.valueOf(pos));  
  55.             BackendClassManager.tFunc.codes.add(code2);//跳转到循环入口  
  56.               
  57.             int end=BackendClassManager.tFunc.codes.size();  
  58.             code.Operands.add(String.valueOf(end));//表达式回填  
  59.               
  60.             for(Code c:albreak)  
  61.             {  
  62.                 c.Operands.add(String.valueOf(end));  
  63.             }  
  64.             for(Code c:alcontinue)  
  65.             {  
  66.                c.Operands.add(String.valueOf(pos));  
  67.             }  
  68.             BackendClassManager.loopbreak.pop();  
  69.             BackendClassManager.loopcontinue.pop();  
  70.             stmts3.genCode();  
  71.         }  
  72.           
  73.     }  
对于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.           
  7.         Code code2=new Code(0x18);  
  8.         code2.Operands.add(String.valueOf(pos));  
  9.         BackendClassManager.tFunc.codes.add(code2);//跳转  
  10.     }  

（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.               
  30.             CodeGenHelper.CodePutField(al, is.getLastID().toString());  
  31.             }  
  32.             else  
  33.             {  
  34.                 int value=CodeGenHelper.StoreToLocalTable(al);  
  35.                 CodeGenHelper.PutObjectToStack(al, is);  
  36.                 CodeGenHelper.CodeGetField(al, is.getLastID().toString());  
  37.                 int array=CodeGenHelper.StoreToLocalTable(al);  
  38.                 is.getLastIDS().EXPR.genCode();  
  39.                 CodeGenHelper.LoadToStack(al, array);  
  40.   
  41.                 CodeGenHelper.LoadToStack(al, value);  
  42.                 Code code=new Code(0x26);  
  43.                 al.add(code);  
  44.             }  
  45.         }  
  46.         if(is.type==3)  
  47.         {  
  48.             int slot=CodeGenHelper.StoreToLocalTable(al);  
  49.             is.EXPR.genCode();  
  50.             CodeGenHelper.LoadToStackByName(al, is.ID.toString());  
  51.             CodeGenHelper.LoadToStack(al, slot);  
  52.             Code code=new Code(0x26);  
  53.             al.add(code);  
  54.         }  
  55.     }  
首先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.           
  9.           
  10.     }  
可以看到，在变量声明时并没有生成任何实际代码，只是在局部变量表中给其开辟了一个存储位置而已。


（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.               
  18.             CodeGenHelper.CodePutField(al, is.getLastID().toString());  
  19.             }  
  20.             else  
  21.             {  
  22.                 int value=CodeGenHelper.StoreToLocalTable(al);  
  23.                 CodeGenHelper.PutObjectToStack(al, is);  
  24.                 CodeGenHelper.CodeGetField(al, is.getLastID().toString());  
  25.                 int array=CodeGenHelper.StoreToLocalTable(al);  
  26.                 is.getLastIDS().EXPR.genCode();  
  27.                 CodeGenHelper.LoadToStack(al, array);  
  28.   
  29.                 CodeGenHelper.LoadToStack(al, value);  
  30.                 Code code=new Code(0x26);  
  31.                 al.add(code);  
  32.             }  
  33.         }  
  34.         if(is.type==3)  
  35.         {  
  36.             int slot=CodeGenHelper.StoreToLocalTable(al);  
  37.             is.EXPR.genCode();  
  38.             CodeGenHelper.LoadToStackByName(al, is.ID.toString());  
  39.             CodeGenHelper.LoadToStack(al, slot);  
  40.             Code code=new Code(0x26);  
  41.             al.add(code);  
  42.         }  
  43.           
  44.     }  
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.               
  33.             code=new Code(0x04);  
  34.             al.add(code);//读取数组元素  
  35.               
  36.               
  37.               
  38.         }  
  39.         if(type==4)  
  40.         {  
  41.             int slot=BackendClassManager.nameSlot.get("this");  
  42.             Code code=new Code(0x01);  
  43.             code.Operands.add(String.valueOf(slot));  
  44.         }  
  45.     }  
  46.       
  47.       
  48.     public void genCode2nd() {  
  49.         ArrayList<Code> al=BackendClassManager.tFunc.codes;  
  50.         if(type==1)  
  51.         {  
  52.             Code code=new Code(0x20);  
  53.             code.Operands.add(ID.toString());  
  54.             al.add(code);  
  55.         }  
  56.         if(type==2)  
  57.         {  
  58.             Code code=new Code(0x20);  
  59.             code.Operands.add(ID.toString());  
  60.             al.add(code);  
  61.             IDS.genCode2nd();  
  62.         }  
  63.         if(type==3)  
  64.         {  
  65.             EXPR.genCode();//压入expr值  
  66.             Code code=new Code(0x20);  
  67.             code.Operands.add(ID.toString());  
  68.             al.add(code);//压入数组  
  69.             code=new Code(0x04);  
  70.             al.add(code);//读取数组元素  
  71.         }  
  72.         if(type==4)  
  73.         {  
  74.          //error  
  75.         }  
  76.     }  

由于ids的结构不对称，所以不能使用递归的方式来获得其值。举例：id.id，第一个id的处理方式是通过局部变量表中拿到其句柄，第二个id的处理方式要通过getfield来拿到其值。因此这两种处理方式对应的是genCode和genCode2nd。

只有当第一次调用的时候（也就是其它节点调用）调用genCode，ids节点调用均调用genCode2nd。

（14）expr

/*                         Type
* expr -->  (expr)           0
                ids|             1
              number|           2
              literal|           3
             func-call|         4
            expr  ops expr|      5
*/

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

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.         }  
  23.         else  
  24.         {  
  25.             IDS.genCode();  
  26.             Code code=new Code(0x1A);  
  27.             code.Operands.add(fn.toString());  
  28.             al.add(code);  
  29.         }  
  30.     }  
函数调用的过程如下：

首先所有参数压栈，然后虚拟机执行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.           
  19.     }  

根据不同的类型调用不同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.         }  
  21.         if(expr1.tp.toString().equals("double") && expr2.tp.toString().equals("int"))  
  22.         {  
  23.             int pos=CodeGenHelper.StoreToLocalTable(al);  
  24.             Code code=new Code(0x23);  
  25.             al.add(code);  
  26.             CodeGenHelper.i2d(al);  
  27.             CodeGenHelper.LoadToStack(al, pos);  
  28.             intint=false;  
  29.               
  30.         }  
  31.         if(value.equals(">"))  
  32.         {  
  33.             if(intint==true)  
  34.             {  
  35.                 Code code=new Code(0x16);//比较  
  36.                 al.add(code);  
  37.                 code=new Code(0x01);  
  38.                 code.Operands.add("1");//压入1  
  39.                 al.add(code);  
  40.                 code=new Code(0x16);//和1比较  
  41.                 al.add(code);  
  42.                 code=new Code(0x24);//取非  
  43.                 al.add(code);  
  44.             }  
  45.             else  
  46.             {  
  47.                 Code code=new Code(0x17);//比较  
  48.                 al.add(code);  
  49.                 code=new Code(0x02);  
  50.                 code.Operands.add("1");//压入1  
  51.                 al.add(code);  
  52.                 code=new Code(0x17);//和1比较  
  53.                 al.add(code);  
  54.                 code=new Code(0x24);//取非  
  55.                 al.add(code);  
  56.             }  
  57.         }  
  58.         if(value.equals("<"))  
  59.         {  
  60.             if(intint==true)  
  61.             {  
  62.                 Code code=new Code(0x16);//比较  
  63.                 al.add(code);  
  64.                 code=new Code(0x01);  
  65.                 code.Operands.add("-1");//压入1  
  66.                 al.add(code);  
  67.                 code=new Code(0x16);//和1比较  
  68.                 al.add(code);  
  69.                 code=new Code(0x24);//取非  
  70.                 al.add(code);  
  71.             }  
  72.             else  
  73.             {  
  74.                 Code code=new Code(0x17);//比较  
  75.                 al.add(code);  
  76.                 code=new Code(0x02);  
  77.                 code.Operands.add("-1");//压入1  
  78.                 al.add(code);  
  79.                 code=new Code(0x17);//和1比较  
  80.                 al.add(code);  
  81.                 code=new Code(0x24);//取非  
  82.                 al.add(code);  
  83.             }  
  84.         }  
  85.         if(value.equals(">="))  
  86.         {  
  87.             if(intint==true)  
  88.             {  
  89.                 Code code=new Code(0x16);//比较  
  90.                 al.add(code);  
  91.                 code=new Code(0x01);  
  92.                 code.Operands.add("-1");//压入1  
  93.                 al.add(code);  
  94.                 code=new Code(0x16);//和1比较  
  95.                 al.add(code);  
  96.                   
  97.             }  
  98.             else  
  99.             {  
  100.                 Code code=new Code(0x17);//比较  
  101.                 al.add(code);  
  102.                 code=new Code(0x02);  
  103.                 code.Operands.add("-1");//压入1  
  104.                 al.add(code);  
  105.                 code=new Code(0x17);//和1比较  
  106.                 al.add(code);  
  107.                 code=new Code(0x24);//取非  
  108.                 al.add(code);  
  109.             }  
  110.         }  
  111.         if(value.equals("<="))  
  112.         {  
  113.             if(intint==true)  
  114.             {  
  115.                 Code code=new Code(0x16);//比较  
  116.                 al.add(code);  
  117.                 code=new Code(0x01);  
  118.                 code.Operands.add("1");//压入1  
  119.                 al.add(code);  
  120.                 code=new Code(0x16);//和1比较  
  121.                 al.add(code);  
  122.                   
  123.             }  
  124.             else  
  125.             {  
  126.                 Code code=new Code(0x17);//比较  
  127.                 al.add(code);  
  128.                 code=new Code(0x02);  
  129.                 code.Operands.add("1");//压入1  
  130.                 al.add(code);  
  131.                 code=new Code(0x17);//和1比较  
  132.                 al.add(code);  
  133.                   
  134.             }  
  135.         }  
  136.         if(value.equals("=="))  
  137.         {  
  138.             if(intint==true)  
  139.             {  
  140.                 Code code=new Code(0x16);//比较  
  141.                 al.add(code);  
  142.                 code=new Code(0x01);  
  143.                 code.Operands.add("0");//压入1  
  144.                 al.add(code);  
  145.                 code=new Code(0x16);//和0比较  
  146.                 al.add(code);  
  147.                 code=new Code(0x24);//取非  
  148.                 al.add(code);  
  149.             }  
  150.             else  
  151.             {  
  152.                 Code code=new Code(0x17);//比较  
  153.                 al.add(code);  
  154.                 code=new Code(0x02);  
  155.                 code.Operands.add("0");//压入1  
  156.                 al.add(code);  
  157.                 code=new Code(0x17);//和0比较  
  158.                 al.add(code);  
  159.                 code=new Code(0x24);//取非  
  160.                 al.add(code);  
  161.             }  
  162.         }  
  163.         if(value.equals("!="))  
  164.         {  
  165.             if(intint==true)  
  166.             {  
  167.                 Code code=new Code(0x16);//比较  
  168.                 al.add(code);  
  169.                 code=new Code(0x01);  
  170.                 code.Operands.add("0");//压入1  
  171.                 al.add(code);  
  172.                 code=new Code(0x16);//和0比较  
  173.                 al.add(code);  
  174.               
  175.             }  
  176.             else  
  177.             {  
  178.                 Code code=new Code(0x17);//比较  
  179.                 al.add(code);  
  180.                 code=new Code(0x02);  
  181.                 code.Operands.add("0");//压入1  
  182.                 al.add(code);  
  183.                 code=new Code(0x17);//和0比较  
  184.                 al.add(code);  
  185.               
  186.             }  
  187.         }  
  188.           
  189.     }  
比较运算符的genCode虽然代码比较长但是逻辑很简单。

首先需要根据待比较的expr来决定是否进行类型转换，目前在语言的设计中，只有double和int是可比的，其它类型的比较虽然在编译器不会报错但在运行时中会进行报错。

其次根据类型来调用不同的比较指令，再次根据逻辑需要进行二次比较（因为比较指令会根据大于小于等于返回1、0或-1，和运算符并不等价，需要通过比较两次使之和运算符等价）。


大体上代码就这么多，目前的编译器已经可以编译出正确的字节码了，但目前代码还无法执行，需要等到Runtime写好之后才能运行。


因此本系列博客到这里暂时告一段落，若给语言再添加一些高级点的特性，也需要等到我把Runtime写好再说了。


你可能感兴趣的:(自制编译器)

  • C++核心编程手册 易方达蓝筹 Cor计算机网络c++开发语言后端
    C++核心编程本阶段主要针对C++面向对象编程技术做详细讲解，探讨C++中的核心和精髓。1内存分区模型C++程序在执行时，将内存大方向划分为4个区域代码区：存放函数体的二进制代码，由操作系统进行管理的全局区：存放全局变量和静态变量以及常量栈区：由编译器自动分配释放,存放函数的参数值,局部变量等堆区：由程序员分配和释放,若程序员不释放,程序结束时由操作系统回收内存四区意义：不同区域存放的数据，赋予不
  • C++ 预处理器 阳光向日葵向阳 c++开发语言
    预处理器是一些指令，指示编译器在实际编译之前所需完成的预处理。所有的预处理器指令都是以井号（#）开头，只有空格字符可以出现在预处理指令之前。预处理指令不是C++语句，所以它们不会以分号（;）结尾。我们已经看到，之前所有的实例中都有#include指令。这个宏用于把头文件包含到源文件中。C++还支持很多预处理指令，比如#include、#define、#if、#else、#line等，让我们一起看看
  • 使用静态库动态库也要头文件 m0_55576290 c++c++
    是的，即使你使用了QCustomPlot的导入库（例如.lib文件）和动态链接库（.dll文件），仍然需要包含qcustomplot.h头文件。原因如下：1.头文件的作用qcustomplot.h是QCustomPlot的主要头文件，它定义了所有与QCustomPlot相关的类、方法和属性。头文件的作用是为编译器提供类的声明和接口信息，以便编译器知道如何正确地调用这些类和方法。2.导入库的作用导入
  • QT中的宏 m0_55576290 qtqt开发语言
    Q_UNUSED(event);是Qt提供的一个宏，用于标记某个变量或参数在当前作用域中未被使用。它的主要作用是避免编译器发出“未使用变量”的警告。背景在C++中，如果一个函数参数或变量在代码中没有被使用，编译器会发出警告，例如：voidsomeFunction(intunusedParam){//参数unusedParam没有被使用}编译器可能会报出类似以下警告：warning:unusedpa
  • electron 源码下载与编译构 五一编程 学习交流electronjavascript前端webrtcc语言c++
    electron源码下载与编译构建预先安装安装nodejs下载eletron构建工具：安装python构建Electron基本要求环境依赖交叉编译构建故障排查高级提示使用clang之外的其它编译器electron的depot_tools工具下载构建源码。这个工具是用nodejs写的，封装了chromium自身的depot_tools工具。非常方便易用。主要是electron在下载完chromium
  • Java注解 陈陈爱java java开发语言
    java基本注解注解注解与注释的区别注释：增强代码的可阅读性，并不会对程序的执行产生任何影响。注解：给编译器或运行时环境提供额外的信息，能够影响程序的编译或运行行为。常见注解@Override明确标记一个方法是覆盖（重写）了父类中的方法。classAnimal{voidmakeSound(){System.out.println("Animalmakesasound");}}classDogext
  • 鸿蒙Next开发与未来发展的变革：全场景操作系统的全新纪元 北辰alk 鸿蒙harmonyos华为
    文章目录引言：从兼容到自主的跨越式进化一、鸿蒙Next技术架构解析1.1系统架构全景图1.1.1微内核架构优势1.2与OpenHarmony的关系二、开发范式革命2.1应用开发模式对比2.1.1元服务（MetaService）定义2.2开发工具链升级（DevEcoStudio4.0）2.2.1核心功能增强2.2.2工程结构变革三、关键技术突破3.1方舟编译器深度优化3.2分布式能力增强3.2.1设
  • 1.1Vue 3 核心优势与架构革新 北辰alk vue.js架构前端
    文章目录**1.1Vue3核心优势与架构革新****一、设计哲学演进****二、响应式系统革命****三、组合式API范式****四、编译器架构升级****五、类型系统集成****六、生态融合能力****七、性能基准对比****八、架构升级路线****本章深度总结**1.1Vue3核心优势与架构革新一、设计哲学演进渐进式框架的终极形态模块化架构：通过@vue/reactivity、@vue/run
  • JVM、MySQL常见面试题(尽力局) 多敲代码防脱发 jvmmysql数据库
    JVM篇一.谈一谈JDK、JRE、JVM分别是什么，有什么联系？1.JDK是Java工具包，里面包含了JRE、Javac编译器等。2.JRE是java运行环境，里面包含了JVM、JavaSE标准库类等。3.JVM是Java虚拟机，运行编译后的.class的文件，调用系统API运行。JDK=JRE+Javac编译器JRE=JVM+JavaSE标准库二.JVM运行时数据区由哪几部分构成，分别有什么作用
  • GoLand for Mac v2024.1 GO语言集成开发工具环境 qwevwwd macosgolang开发语言
    GoLand是一款由JetBrains公司开发的集成开发环境（IDE），专为Go语言设计。这款软件为Go语言开发者提供了全面、专业、灵活且易用的开发环境，适用于各种规模和类型的项目与团队。前往Mac香蕉下载GoLandforMacv2024.1GO语言集成开发工具环境免激活下载-马克香蕉(macxj.com)GoLand具有强大的编译器和运行时，能够显著提高Go语言应用程序的性能。它支持多种框架和
  • 保证你能懂！听我说啥是C语言中的静态断言！ 新手懒羊哥 c语言培训班c语言算法开发语言
    好的，接下来我用“说人话”的方式给你解释C语言中的静态断言，保证一听就懂！一句话总结：静态断言（StaticAssert）就是“在代码编译时，强制检查某个条件是否成立”。如果不成立，编译器会直接报错，告诉你哪里出了问题，代码根本没法生成可执行文件。举个现实例子：假设你写代码时，假设int类型在电脑上一定是4字节（比如你用它存文件头），但你不确定这个假设是否成立。这时候可以用静态断言：static_
  • 上位机数据可视化：使用QtCharts绘制波形图 下里巴人hywing Qt应用开发Qt5QtCharts绘图
    工程配置CMake文件find_package(Qt5COMPONENTSChartsREQUIRED)target_link_libraries(zhd-desktopPRIVATEQt5::Charts)包含头文件以及名称空间（这个很重要，没有包含名称空间编译器会提示找不到相关的类型）#includeusingnamespaceQtCharts;初始化初始化Chart//创建图表QChart*
  • C# 分部类 详解 千亦学不会编程 c#开发语言
    从C#2.0起支持分部类。分部类：是一个类的多个部分，编译器可把它们合并成一个完整的类。分部类的目的：将一个类的定义划分到多个文件中。通过分部类，由工具处理的文件可独立于开发者手动编码的文件。1.1定义分部类使用class前的上下文关键字partial来声明分部类。例子：partialclassProgram{}1.2分部方法从C#3.0引入分部方法概念，对C#2.0的分部类进行了扩展。分部方法只
  • Kotlin-inline函数特效 左少华 kotlinkotlin开发语言android
    在Kotlin里，inline关键字主要用于内联函数与内联属性。下面为你详细介绍：内联函数使用inline关键字修饰的函数，在编译时，编译器会把函数调用处替换成函数体本身，而不是常规的函数调用过程。这样做的好处是能减少函数调用的开销，特别是在使用高阶函数时效果显著。和C语言的宏替换有殊途同归。@Testfunmain3(){inlineFun{println("hello")}}privatein
  • 为什么很多人喷 Java 开发者离了 spring 框架就不会写代码了 getapi javaspring开发语言
    很多人批评Java开发者离开Spring框架后难以独立开发的原因可从技术特性与开发者习惯两方面分析：Java语言的历史设计局限Java的泛型实现存在缺陷，其原始值包装类（如Integer与int）的自动装拆箱机制出现较晚（Java5引入），且编译器无法彻底解决原始值与包装类的隐式转换问题[[1]][[2]]。这种设计导致开发者在处理基础类型与对象时需要额外关注类型转换，而Spring框架通过封装（
  • 2018 Kotlin中的model Shigq-droid Kotlinkotlinmodel
    数据类我们经常创建主要用于保存数据的类。在这样的类中，一些标准功能和效用函数通常可以从数据中机械地导出。在Kotlin中，这称为数据类，标记为data：dataclassUser(valname:String,valage:Int)编译器自动从主构造函数中声明的所有属性派生以下成员：equals()/hashCode()pair;toString()形式”User(name=John,age=42
  • CMake 保姆级教程 爱吃巧克力的程序媛 CMakec++
    CMake是一个跨平台的构建工具，用于生成适合不同平台和编译器的构建系统文件（如Makefile或VisualStudio项目文件）。在Windows下使用CMake构建项目时，CMake会根据CMakeLists.txt文件生成适合Windows的构建系统文件（如VisualStudio项目文件）。以下是Windows下使用CMake的基本规则和步骤：https://subingwen.cn/c
  • 2、3ds Max的界面（3DMAX基础自学系列） weixin_34409703
    一、3dsMax2012中文版的操作界面二、各功能区的介绍1、菜单栏菜单栏位于软件界面顶部，共13个，分别是文件、编辑(E)、工具(T)、组(G)、视图(V)、创建(C)、修改器、动画、图标编译器、渲染(R)、自定义(U)、MAXScript(M)、帮助(H)。可以使用ALT+菜单的字母来打开菜单。①文件左上角的Max图标为文件操作入口，旁边为文件操作的快捷按钮，包含用于管理文件的命令，包括创建、
  • 方舟字节码原理剖析：架构、特性与实践应用 轻口味 HarmonyOSNextharmonyos深度学习pytorchharmonyosnextarkts
    方舟字节码原理剖析：架构、特性与实践应用一、引言在当今软件行业高速发展的大背景下，应用程序的性能、开发效率以及跨平台兼容性成为了开发者们关注的核心要素。编译器作为软件开发流程中的关键工具，其性能和特性直接影响着软件的质量和开发周期。华为推出的方舟编译器正是为了满足这些需求而诞生的创新成果。方舟字节码（ArkBytecode）作为方舟编译器的核心产物，在整个编译和运行过程中扮演着至关重要的角色。它不
  • 关于py不能导入pyw文件内的class的问题 Auspemak-Derafru python
    我有一个window类，调了另外一个py文件里面自己写的class有一天去朋友家玩，顺便想跑一下那个代码，由于他没有编译器，我也没有打包成可执行程序，就安了一个idle。由于我的window类是用qt写的，懒得再pip下载了，就直接在原文件后面加了个main函数，改后缀名为pyw直接跑了回去之后用我的pycham打开，window类直接跑不了了，提示导包错误看了一下竟然是我之前改了的那个文件的问题
  • 第5章 构造、析构、拷贝语义学3：对象复制语意学 qq_40178082 深入探索C++对象模型java开发语言
    重点：编译器生成构造函数的四种情况，如何避免copyconstructor在子类多个调用当我们指定一个classobject给另一个classobject时,通常有三种选择：什么都不做，实施默认的行为。提供一个explicitcopyassignmentoperator。显式地拒绝指定一个classobject给另一个classobject,声明为private(并且此时不同函数的定义，一旦某个m
  • 第5章 构造、析构、拷贝语义学4：析构函数语义学 qq_40178082 深入探索C++对象模型c++
    析构函数也是根据编译器的需要才会合成出来，两种情况：class中有某个object拥有析构函数；继承自某个baseclass,该baseclass含有析构函数。定义了constructor后不一定要定义destructor，决定class是否需要destructor是程序层面的事。与构造函数相比，即使拥有虚函数或者虚拟继承，不满足上述两个条件，编译器是不会合成析构函数的。在继承体系中，由我们定义的
  • FASM源代码分析01 VOgai
    全汇编操作系统Kolibri0.7.7基于MenuetOS使用fasm汇编编译器第2个光盘安装的，肯定不用下的第1个软盘镜像是我们需要的第3个是源代码第4个是APP开发包在其官网http://kolibrios.org/可以下到的文件有kolibri_0.7.7.0_img_en.7z------------软盘镜像文件kolibri_0.7.7.0_sdk.7z-----------------
  • VUE3中defineExpose的使用方法 云隙阳光i vue.jsjavascript前端
    使用的组件是默认关闭的——即通过模板引用或者$parent链获取到的组件的公开实例，不会暴露任何在中声明的绑定。可以通过defineExpose编译器宏来显式指定在组件中要暴露出去的属性官网传送门在vue3的setup中，组件默认是关闭的，对一个子组件使用ref，不能获取任何在中声明的绑定。defineExpose是编译宏，用于显式地指定在组件中要暴露出去的属性。如下示例父组件import{ref
  • 第2章 Vue核心架构解析 道不尽世间的沧桑 vue深入理解前端javascriptvue.js
    2.1双版本设计：运行时vs编译器2.1.1版本差异对比//完整版（包含编译器）构建过程newVue({template:'{{message}}'//需要编译模板})//运行时版（需预编译）构建过程newVue({render(h){//直接使用预编译的render函数returnh('div',this.message)}})关键差异说明表：特性完整版运行时版体积大小较大(~30KB)较小(~
  • RISC-V与ARM IT_Beijing_BIT ARM系列小知识嵌入式
    RISC-V与ARMRISC-V架构RISC-V架构特点ARM架构RISC-V与ARM指令集架构(ISA)基本上是汇编级程序员，或编译器编写者可见的机器部分。ISA是软件与硬件相遇的地方。ISA定义了机器及其微架构本身可以理解的命令/指令，它还定义了如何存储、访问和实施指令。我们使用计算机可以理解的语言向计算机的硬件发出指令。计算机语言由称为指令的词组成，词汇表称为指令集。指令集告诉我们每条指令的
  • 每天10道Java基础面试题，涵盖核心知识点，附简洁代码示例，掌握快速记忆的方法 小小鸭程序员 springbootjava后端开发语言springcloud
    1.JDK、JRE、JVM区别JDK：开发工具包（含JRE+编译器）JRE：运行环境（含JVM+类库）JVM：执行字节码的虚拟机2.==与equals()区别Stringa="abc",b=newString("abc");System.out.println(a==b);//false（地址不同）System.out.println(a.equals(b));//true（内容相同）3.Stri
  • Exception in thread “main“ java.lang.NoSuchMethodError: Awesome Baron javajavavscode
    在VScode中运行代码调试力扣程序报错：Exceptioninthread“main”java.lang.NoSuchMethodError:‘intSolution.subarraySum(int[],int)’attest_560.main(test_560.java:9)原因是因为在不同的.java程序中使用了同名的Solution类，导致编译器和运行时选择的类不一致。解决方案：只保留一个
  • 如何编写vscode的配置文件c_cpp_properties.json 小秋slam实战 从零开始学SLAMvscode
    文章目录配置`c_cpp_properties.json`文件改变VScode中空格长度VSCode中C/C++无法跳转到定义c_cpp_properties.json安装插件配置c_cpp_properties.json文件假设你已经安装了GCC和G++编译器，{"configurations":[{"name":"Linux","includePath":
  • 如何自己做奶茶，从此告别奶茶店 wmq163 生活奶茶生活
    自制大白兔奶茶，奶香与茶香激情碰撞，每一口都是香浓与甜蜜的双重诱惑，好喝到跺脚！丝滑口感在舌尖舞动，仿佛味蕾在开派对。简单几步就能复刻，成本超低，轻松在家享受奶茶自由。材料:大白兔奶糖，红茶叶，牛奶做法:锅里加入适量的水，放入奶糖和茶叶小火炒至奶糖融化，再加入牛奶搅拌均匀倒出过滤就完成啦。（水15ml，茶叶5g，牛奶400ml左右，大家可根据个人口味加入适量的材料）
  • Linux的Initrd机制 被触发 linux
    Linux 的 initrd 技术是一个非常普遍使用的机制，linux2.6 内核的 initrd 的文件格式由原来的文件系统镜像文件转变成了 cpio 格式，变化不仅反映在文件格式上， linux 内核对这两种格式的 initrd 的处理有着截然的不同。本文首先介绍了什么是 initrd 技术，然后分别介绍了 Linux2.4 内核和 2.6 内核的 initrd 的处理流程。最后通过对 Lin
  • maven本地仓库路径修改 bitcarter maven
    默认maven本地仓库路径：C:\Users\Administrator\.m2 修改maven本地仓库路径方法：     1.打开E:\maven\apache-maven-2.2.1\conf\settings.xml     2.找到        
  • XSD和XML中的命名空间 darrenzhu xmlxsdschemanamespace命名空间
    http://www.360doc.com/content/12/0418/10/9437165_204585479.shtml http://blog.csdn.net/wanghuan203/article/details/9203621 http://blog.csdn.net/wanghuan203/article/details/9204337 http://www.cn
  • Java 求素数运算 周凡杨 java算法素数
    网络上对求素数之解数不胜数，我在此总结归纳一下，同时对一些编码，加以改进，效率有成倍热提高。 第一种：   原理: 6N(+-)1法         任何一个自然数，总可以表示成为如下的形式之一： 6N，6N+1，6N+2，6N+3，6N+4，6N+5 (N=0，1，2，…)   
  • java 单例模式 g21121 java
    想必单例模式大家都不会陌生，有如下两种方式来实现单例模式：   class Singleton { private static Singleton instance=new Singleton(); private Singleton(){} static Singleton getInstance() { return instance; }
  • Linux下Mysql源码安装 510888780 mysql
    1.假设已经有mysql-5.6.23-linux-glibc2.5-x86_64.tar.gz (1)创建mysql的安装目录及数据库存放目录       解压缩下载的源码包，目录结构，特殊指定的目录除外：           
  • 32位和64位操作系统 墙头上一根草 32位和64位操作系统
    32位和64位操作系统是指：CPU一次处理数据的能力是32位还是64位。现在市场上的CPU一般都是64位的，但是这些CPU并不是真正意义上的64 位CPU，里面依然保留了大部分32位的技术，只是进行了部分64位的改进。32位和64位的区别还涉及了内存的寻址方面，32位系统的最大寻址空间是2 的32次方= 4294967296（bit）= 4（GB）左右，而64位系统的最大寻址空间的寻址空间则达到了
  • 我的spring学习笔记10-轻量级_Spring框架 aijuans Spring 3
    一、问题提问：     → 请简单介绍一下什么是轻量级？     轻量级（Leightweight）是相对于一些重量级的容器来说的，比如Spring的核心是一个轻量级的容器，Spring的核心包在文件容量上只有不到1M大小，使用Spring核心包所需要的资源也是很少的，您甚至可以在小型设备中使用Spring。  
  • mongodb 环境搭建及简单CURD antlove WebInstallcurdNoSQLmongo
    一 搭建mongodb环境 1. 在mongo官网下载mongodb 2. 在本地创建目录 "D:\Program Files\mongodb-win32-i386-2.6.4\data\db" 3. 运行mongodb服务 [mongod.exe --dbpath "D:\Program Files\mongodb-win32-i386-2.6.4\data\
  • 数据字典和动态视图 百合不是茶 oracle数据字典动态视图系统和对象权限
    数据字典（data dictionary）是 Oracle 数据库的一个重要组成部分，这是一组用于记录数据库信息的只读（read-only）表。随着数据库的启动而启动,数据库关闭时数据字典也关闭   数据字典中包含   数据库中所有方案对象（schema object）的定义(包括表，视图，索引，簇，同义词，序列，过程，函数，包，触发器等等) 数据库为一
  • 多线程编程一般规则 bijian1013 javathread多线程java多线程
           如果两个工两个以上的线程都修改一个对象，那么把执行修改的方法定义为被同步的，如果对象更新影响到只读方法，那么只读方法也要定义成同步的。        不要滥用同步。如果在一个对象内的不同的方法访问的不是同一个数据，就不要将方法设置为synchronized的。
  • 将文件或目录拷贝到另一个Linux系统的命令scp bijian1013 linuxunixscp
    一.功能说明        scp就是security copy，用于将文件或者目录从一个Linux系统拷贝到另一个Linux系统下。scp传输数据用的是SSH协议，保证了数据传输的安全，其格式如下：        scp 远程用户名@IP地址：文件的绝对路径
  • 【持久化框架MyBatis3五】MyBatis3一对多关联查询 bit1129 Mybatis3
    以教员和课程为例介绍一对多关联关系，在这里认为一个教员可以叫多门课程，而一门课程只有1个教员教，这种关系在实际中不太常见，通过教员和课程是多对多的关系。   示例数据：   地址表：   CREATE TABLE ADDRESSES ( ADDR_ID INT(11) NOT NULL AUTO_INCREMENT, STREET VAR
  • cookie状态判断引发的查找问题 bitcarter formcgi
    先说一下我们的业务背景： 1.前台将图片和文本通过form表单提交到后台，图片我们都做了base64的编码，并且前台图片进行了压缩 2.form中action是一个cgi服务 3.后台cgi服务同时供PC，H5，APP 4.后台cgi中调用公共的cookie状态判断方法（公共的，大家都用，几年了没有问题） 问题：（折腾两天。。。。） 1.PC端cgi服务正常调用，cookie判断没
  • 通过Nginx,Tomcat访问日志(access log)记录请求耗时 ronin47
    一、Nginx通过$upstream_response_time $request_time统计请求和后台服务响应时间 nginx.conf使用配置方式： log_format main '$remote_addr - $remote_user [$time_local] "$request" ''$status $body_bytes_sent "$http_r
  • java-67- n个骰子的点数。 把n个骰子扔在地上，所有骰子朝上一面的点数之和为S。输入n，打印出S的所有可能的值出现的概率。 bylijinnan java
    public class ProbabilityOfDice { /** * Q67 n个骰子的点数 * 把n个骰子扔在地上，所有骰子朝上一面的点数之和为S。输入n，打印出S的所有可能的值出现的概率。 * 在以下求解过程中，我们把骰子看作是有序的。 * 例如当n=2时，我们认为（1，2）和（2，1）是两种不同的情况 */ private stati
  • 看别人的博客，觉得心情很好 Cb123456 博客心情
       以为写博客，就是总结，就和日记一样吧，同时也在督促自己。今天看了好长时间博客:    职业规划:    http://www.iteye.com/blogs/subjects/zhiyeguihua      android学习:    1.http://byandby.i
  • [JWFD开源工作流]尝试用原生代码引擎实现循环反馈拓扑分析 comsci 工作流
        我们已经不满足于仅仅跳跃一次，通过对引擎的升级，今天我测试了一下循环反馈模式，大概跑了200圈，引擎报一个溢出错误      在一个流程图的结束节点中嵌入一段方程，每次引擎运行到这个节点的时候，通过实时编译器GM模块，计算这个方程，计算结果与预设值进行比较，符合条件则跳跃到开始节点，继续新一轮拓扑分析，直到遇到
  • JS常用的事件及方法 cwqcwqmax9 js
    事件 描述 onactivate 当对象设置为活动元素时触发。 onafterupdate 当成功更新数据源对象中的关联对象后在数据绑定对象上触发。 onbeforeactivate 对象要被设置为当前元素前立即触发。 onbeforecut 当选中区从文档中删除之前在源对象触发。 onbeforedeactivate 在 activeElement 从当前对象变为父文档其它对象之前立即
  • 正则表达式验证日期格式 dashuaifu 正则表达式IT其它java其它
    正则表达式验证日期格式 function isDate(d){ var v = d.match(/^(\d{4})-(\d{1,2})-(\d{1,2})$/i); if(!v) { this.focus(); return false; } } <input value="2000-8-8" onblu
  • Yii CModel.rules() 方法 、validate预定义完整列表、以及说说验证 dcj3sjt126com yii
    public array rules () {return} array 要调用 validate() 时应用的有效性规则。 返回属性的有效性规则。声明验证规则，应重写此方法。 每个规则是数组具有以下结构：array('attribute list', 'validator name', 'on'=>'scenario name', ...validation
  • UITextAttributeTextColor = deprecated in iOS 7.0 dcj3sjt126com ios
    In this lesson we used the key "UITextAttributeTextColor" to change the color of the UINavigationBar appearance to white. This prompts a warning "first deprecated in iOS 7.0." Ins
  • 判断一个数是质数的几种方法 EmmaZhao Mathpython
    质数也叫素数，是只能被1和它本身整除的正整数，最小的质数是2，目前发现的最大的质数是p=2^57885161-1【注1】。 判断一个数是质数的最简单的方法如下： def isPrime1(n): for i in range(2, n): if n % i == 0: return False return True 但是在上面的方法中有一些冗余的计算，所以
  • SpringSecurity工作原理小解读 坏我一锅粥 SpringSecurity
      SecurityContextPersistenceFilter   ConcurrentSessionFilter   WebAsyncManagerIntegrationFilter   HeaderWriterFilter   CsrfFilter   LogoutFilter   Use
  • JS实现自适应宽度的Tag切换 ini JavaScripthtmlWebcsshtml5
    效果体验：http://hovertree.com/texiao/js/3.htm   该效果使用纯JavaScript代码，实现TAB页切换效果，TAB标签根据内容自适应宽度，点击TAB标签切换内容页。 HTML文件代码： <!DOCTYPE html> <html xmlns="http://www.w3.org/1999/xhtml"
  • Hbase Rest API : 数据查询 kane_xie RESThbase
    hbase（hadoop）是用java编写的，有些语言（例如python）能够对它提供良好的支持，但也有很多语言使用起来并不是那么方便，比如c#只能通过thrift访问。Rest就能很好的解决这个问题。Hbase的org.apache.hadoop.hbase.rest包提供了rest接口，它内嵌了jetty作为servlet容器。   启动命令：./bin/hbase rest s
  • JQuery实现鼠标拖动元素移动位置（源码+注释） 明子健 jqueryjs源码拖动鼠标
    欢迎讨论指正！   print.html代码： <!DOCTYPE html> <html> <head> <meta http-equiv=Content-Type content="text/html;charset=utf-8"> <title>发票打印</title> &l
  • Postgresql 连表更新字段语法 update qifeifei PostgreSQL
    下面这段sql本来目的是想更新条件下的数据，可是这段sql却更新了整个表的数据。sql如下： UPDATE tops_visa.visa_order SET op_audit_abort_pass_date = now() FROM tops_visa.visa_order as t1 INNER JOIN tops_visa.visa_visitor as t2 ON t1.
  • 将redis,memcache结合使用的方案? tcrct rediscache
    公司架构上使用了阿里云的服务，由于阿里的kvstore收费相当高，打算自建，自建后就需要自己维护，所以就有了一个想法，针对kvstore(redis)及ocs(memcache)的特点，想自己开发一个cache层，将需要用到list，set，map等redis方法的继续使用redis来完成，将整条记录放在memcache下，即findbyid，save等时就memcache，其它就对应使用redi
  • 开发中遇到的诡异的bug wudixiaotie bug
    今天我们服务器组遇到个问题： 我们的服务是从Kafka里面取出数据，然后把offset存储到ssdb中，每个topic和partition都对应ssdb中不同的key，服务启动之后，每次kafka数据更新我们这边收到消息，然后存储之后就发现ssdb的值偶尔是-2,这就奇怪了，最开始我们是在代码中打印存储的日志，发现没什么问题，后来去查看ssdb的日志，才发现里面每次set的时候都会对同一个key
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他