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写好再说了。


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

  • 加密授权——获取计算机CPUID序列号（32位 64位 均可以） 程序猿小泽 CC++获取CPU的ID号加密授权
    最近项目要用到加密授权，考虑了一下打算采用CPUID加密，上网找了资料整合如下，代码适合windows环境下32位和64位的均可。首先说下cmd下查看CPUID命令：wmiccpugetProcessorId在32位模式下，我们可以使用内嵌汇编来调用cpuid指令。但在64位模式下，VC编译器不支持内嵌汇编。于是微软提供了Intrinsics函数——编译器会将Intrinsics函数编译为对应的机
  • Keil MDK Armcc6 总是全编译项目的问题 喵喵锤锤你小可爱 STM32Keilstm32
    我碰到的问题是因为使用lib库待代替原本的源码引起的，把lib库去除，使用源码编译就不会出现全编译的问题了。但是至于一定要使用LIB库但是又不想全编译暂时不知道怎么弄，具体为什么会这样暂不清楚。但是可以确定的是编译器参数可能选的不对，因为用EIDE还是使用Armcc6.19编译就没有这个问题EIDE编译就没问题
  • Flink同步数据mysql到doris问题合集 土豆沒加 常用工具flinkmysql大数据
    Flink同步数据mysql到doris官方同步流程Doris安装下载地址导入镜像启动配置Flink-cdc安装（自制）下载地址导入镜像启动命令启动问题修复Flink报错Couldnotacquiretheminimumrequiredresources.作业报错Mysql8.0PublicKeyRetrievalisnotallowed作业报错Connectto127.0.0.1:8040[/1
  • CANoe_trace介绍以及如何使用C#仿制trace方案介绍 99乘法口诀万物皆可变 C#CANoec#开发语言测试工具
    C#UI界面仿制trace界面介绍--初次制作，后续待完善在汽车电子开发中，DBC（DatabaseContainer）文件对于定义和描述CAN（ControllerAreaNetwork）通信协议至关重要。随着项目的迭代和功能的扩展，手动管理和比较多个版本的DBC文件变得愈加复杂且容易出错。为了解决这一问题，本文将详细介绍如何使用自制的DBC读取工具实现拖放导入DBC文件，并根据DBC中的信号特
  • 函数重载(overload) 默认参数 schedule___ cpp
    函数重载规则函数名相同参数个数、类型、顺序不同注意返回值类型与函数重载无关调用函数时，实参的隐式类型转换可能会产生二义性。本质采用了namemangling或者叫namedecoration的技术c++编译器会对符号名（函数名）进行改变、修饰不同编译器（MSVC,g++）有不同的生成规则通过ida打开[vs_release_禁止优化]可以看到默认参数规则默认参数只能按照从右到左的顺序函数同时有声明
  • 北风下的电子田野 Jack2025ad idea
    北风下的电子田野北风呼呼地吹着，黄昏时分的天色慢慢染上了一层暮色。这是冬末春初的季节，寒冷的气息在田间流动，玉米碎撒满已耕的田地，吸引了一群麻雀和鸽子。许先生站在田边，沉思着，手里捏着一把玉米碎，看着飞来飞去的鸟儿。他的心却并不在田地上，而是在另一个世界里——电子的世界。许先生是一名电子工程师，年轻时因热爱电子学，常在家中绕制谐振线圈，自制收音机。他的母亲和胞弟当年总在厨房忙碌，瓦斯炉上炒着面，电
  • 单片机程序死机跑飞查找原因 maskmoo 存档STM32STM32程序跑飞程序死机
    单片机程序死机，跑飞了可以从以下几个方面查找原因：1.意外中断。是否打开了某个中断，但是没有响应和清除中端标志，导致程序一直进入中断，造成死机假象2.中断变量处理不妥。若定义某些会在中断中修改的全局变量，这时要注意两个问题：首先为了防止编译器优化中断变量，要在这些变量定义时前加volatile，其次在主循环中读取中断变量前应该首先关闭全局中断，防止读到一半被中断给修改了，读完之后再打开全局中断;否
  • 本地大模型编程实战(09)自制聊天机器人(3) 火云牌神 AI编程实战pythonlangchainllamadeepseek
    文章目录准备自动裁剪聊天历史聊天机器人定义提示词模板定义state构建app测试流式输出总结代码本文将实现一个比较完善的聊天机器人的主要功能。包括：使用LangGraph构建聊天机器人自动裁剪聊天历史管理聊天会话的方法以流的方式输出回复我们将同时使用llama3.1和deepseek做演示。由于langchain可能对不同大模型支持程度不同以及其它限制，所以这个对比并不能说明哪个模型更好。准备在正
  • 【RA-Eco-RA2L1-48PIN】电容触摸按键 无垠的广袤 单片机单片机物联网嵌入式硬件
    【RA-Eco-RA2L1-48PIN】电容触摸按键工程目标：触摸按键控制板载LED操作流程介绍项目实现的具体操作步骤。硬件连接使用自制JLink-OB连接开发板与电脑。新建工程1.新建工程，配置板载LED引脚为输出模式；触摸驱动2.Stacks-NewStack-CapTouch-Touch(rm_touch)；3.更改CTSU(r_ctsu)属性SupportforusingDTC使能Enab
  • golang安装与使用 燎原君 gogolang开发语言后端
    目录环境准备windows安装环境配置GoModulesgo命令行工具gomod命令行工具开发工具go语法基础数据类型字符串类型数组和切片映射类型（字典）结构体与接口常量枚举指针环境准备windows安装下载地址：https://studygolang.com/dl下载：go1.18.10.windows-amd64.msi环境配置GOROOT：Go的安装目录，表示Go编译器和工具的路径。这个路径
  • pyenv+virtualenv+virtualenvwrapper+VSCode+Jupyter notebook+Spyder的安装（python版本管理+环境管理+编译器解释器设置） norah2 pythonvirtualenvvscode
    关于Python的思考流程和一些废话（可以略过）最近想要再次开始学习关于python之类的东西，但是之前电脑因为硬盘坏了所以重装了系统，导致之前用的python环境都没有了，因此现在需要重新安装。用了这么久的pyhton，很明显可以知道很多项目会依赖不同的python版本，要么是代码语法格式略有差异，要么是依赖的第三方库兼容的python版本不同，这就会经常出现在上一个项目运行的好好的包，在下一个
  • Python与C进行混合编程 程序员AlbertTu PythonPython开发者Python的C++扩展
    目录写在前面在vs中建立一个工程设置调整step1选择输出目录step2改变目标文件拓展名step3添加附加目录step4添加附加库目录step5添加附加依赖项知识储备条件编译简单例程程序测试补充说明写在前面  阅读这篇文章需要一定的C/C++和Python基础，阅读完这篇文章，你将能够开发简单的Python的库。  笔者所使用的C++编译器是vs2017，所使用的Python版本是Python3
  • Rust 错误处理（下） m0_74824044 面试学习路线阿里巴巴rustjava算法
    目录1、用Result处理可恢复的错误1.1?传播错误的简写：?运算符1.2哪里可以使用?运算符2、要不要panic!2.1?示例、代码原型和测试都非常适合panic2.2?当我们比编译器知道更多的情况2.3?错误处理指导原则2.4?创建自定义类型进行有效性验证2.5总结1、用Result处理可恢复的错误1.1传播错误的简写：运算符先看下如下示例：fnmain(){fnread_file()->R
  • C++高级教程——C++ 预处理器 joker-wt C++学习c++开发语言
    C++高级教程——C++预处理器C++预处理器#define预处理函数宏条件编译#和##运算符运算符用于连接两个令牌。下面是一个实例：C++中的预定义宏C++预处理器预处理器是一些指令，指示编译器在实际编译之前所需完成的预处理。所有的预处理器指令都是以井号（#）开头，只有空格字符可以出现在预处理指令之前。预处理指令不是C++语句，所以它们不会以分号（;）结尾。我们已经看到，之前所有的实例中都有#i
  • 学懂C++ （十八）：高级教程——C++预处理器及宏定义深入详解 猿享天开 c++开发语言预处理器宏定义
    目录1.文件包含2.宏定义2.1简单宏定义2.2参数宏2.3宏定义注意点（重点）3.条件编译4.#和##运算符5.预定义宏6.文件包含保护总结C++预处理器是编译器在实际编译之前所执行的一个步骤，它处理代码中的预处理指令，并生成一个已预处理的源文件供编译器使用。预处理器指令都是以井号（#）开头，这些指令不是C++语句，因此它们不以分号（;）结尾。以下是对C++预处理器及其指令的深入详解。1.文件包
  • Java环境变量Classpath iteye_3382 javajava
    Classpath是一个参数，它的值可以通过命令行指定，或者通过环境变量来指定。Classpath这个参数的值，被Java虚拟机或者Java编译器所使用，它告诉Java虚拟机机，Java编译器，去哪里寻找用户定义的类和包。AD：51CTO云计算架构师峰会抢票进行中！Classpath是一个参数，它的值可以通过命令行指定，或者通过环境变量来指定。Classpath这个参数的值，被Java虚拟机或者J
  • 深入理解 Java 的 Classpath 环境变量：多种配置方法与实战案例 egzosn java开发语言
    一：概述在Java开发中，classpath是一个非常重要的概念。它告诉Java虚拟机(JVM)和编译器(javac)在哪里查找用户定义的类和包。正确配置classpath是确保Java程序能够顺利运行的关键。本文将详细介绍classpath的作用，并通过多种方法展示如何配置classpath，同时结合实际案例帮助读者更好地理解和应用。二：具体说明一、什么是Classpath？在Java中，cla
  • JavaSE : 注解 Annotation Edenyt java-eejava
    注解Java中的注解（Annotation）是一种元数据形式，用于向编译器或JVM提供有关程序元素（如类、方法、变量、参数和包）的附加信息。注解不会直接影响程序的行为或结构，但它们可以被编译器、开发工具或运行时环境用于生成代码、进行验证、执行处理或提供信息。以下是关于Java注解的几个关键点：1.注解的种类1.1.内置标准注解：@Override：指示一个方法覆盖了超类中的方法。@Deprecat
  • 【Python专栏】Python的发展历程 雾岛心情 Python入门到精通python开发语言
    Python的创始人为吉多·范罗苏姆（GuidovanRossum），人称龟叔1989年，为了打发圣诞节假期，Guido开始写Python语言的编译器。Python这个名字，来自Guido所挚爱的电视剧MontyPython’sFlyingCircus。他希望这个新的叫做Python的语言，能符合他的理想：创造一种C和shell之间，功能全面，易学易用，可拓展的语言。Python的具体发展历史和版
  • 利用DSPy优化LangChain RAG系统的实战指南 scaFHIO langchainpython
    利用DSPy优化LangChainRAG系统的实战指南技术背景介绍DSPy是一个用于大语言模型（LLMs）的出色框架，它引入了一个自动编译器，能够教会模型如何执行你程序中的声明性步骤。具体来说，DSPy编译器会在内部追踪你的程序，然后为大型语言模型（LLMs）创建高质量的提示（或为小型LLMs训练自动微调），以教会它们任务的步骤。感谢OmarKhattab的努力，现在DSPy可以与LangChai
  • Linux 的 C 语言环境中实现与 C++ 中 `release` 和 `acquire` 等效的内存顺序控制 最后一个bug 高质量嵌入式Linux应用开发linux单片机arm开发stm32c语言
    首先，C11标准引入了原子操作和内存模型，一、用户空间C程序（C11标准）如果使用支持C11标准的编译器（如GCC或Clang），可以通过头文件直接使用类似C++的原子操作和内存顺序参数。对应release和acquire的语法cincludeatomic_boolready=ATOMIC_VAR_INIT(false);//原子变量structDatac;//共享结构体//线程A：写入数据后发布
  • 【Linux基础】Linux下的C编程指南 Nebula嵌入式 #Linux基础linux嵌入式
    目录一、前言二、Vim的使用2.1普通模式2.2插入模式2.3命令行模式2.4可视模式三、GCC编译器3.1预处理阶段3.2编译阶段3.3汇编阶段3.4链接阶段3.5静态库和动态库四、Gdb调试器五、总结一、前言在Linux环境下使用C语言进行编程是一项基础且重要的技能。本文将详细介绍在Linux下使用C语言编程的完整流程，包括代码编辑（使用vim）、编译（使用gcc）、调试（使用gdb）。对于大
  • C语言链接过程中的重定位 czme c语言
    在C语言程序的编译链接过程中，重定位是一个重要环节，以下是关于它的介绍：重定位的概念在C语言编译时，编译器会把源程序转换为目标文件，其中的指令和数据都有相对地址。链接器将多个目标文件和库文件组合成可执行文件时，需调整这些地址，使程序能在内存中正确运行，这个调整地址的过程就是重定位。重定位的原因-分离编译：大型C程序常由多个源文件组成，每个源文件独立编译成目标文件，此时无法确定全局变量、函数等在最终
  • Java 编程基础：开启编程世界的大门 安年CJ JAVAjava开发语言算法
    一、Java环境搭建在开始编写Java代码之前，我们需要先搭建Java开发环境。1.安装JDK（JavaDevelopmentKit）JDK是Java开发的核心工具包，它包含了编译Java源文件所需的编译器（javac）以及运行Java程序的虚拟机（JavaVirtualMachine，JVM）等工具。你可以从Oracle官方网站下载适合你操作系统的JDK版本。下载完成后，按照安装向导进行安装。安
  • 深入解析 Vue 3 编译宏：揭开 `＜script setup＞` 的魔法面纱 斯~内克 vue知识点前端vue.js前端javascript
    一、编译宏的本质与设计哲学1.1什么是编译宏在Vue3的CompositionAPI生态中，编译宏（CompilerMacros）是一组特殊的语法结构，它们在代码编译阶段被Vue编译器处理，最终转换为标准的JavaScript代码。这些宏函数是Vue3语法糖的核心组成部分，主要包含：defineProps：声明组件propsdefineEmits：定义自定义事件defineExpose：暴露组件公
  • 解决每次 Maven Rebuild 后 Java 编译器版本变为 1.5 大吱佬 javamaven开发语言
    解决方法明确指定Java编译版本在pom.xml中添加maven-compiler-plugin配置，明确指定Java编译版本为1.8。可以在标签内添加以下内容：org.apache.maven.pluginsmaven-compiler-plugin3.8.11.81.8通过以上步骤，你应该能够确保Maven项目使用Java1.8进行编译，避免每次Rebuild后Java编译器版本变为1.5的问
  • lua学习（一） 笨鸟先飞的橘猫 lua学习开发语言
    lua学习（一）版本：5.3官方文档：lua在线文档在线编辑器：luaos在线模拟介绍Lua是一种轻量级、可扩展的脚本语言，设计目标是为了嵌入到其他应用程序中，以提供灵活的脚本功能。特点简洁易学的语法：Lua的语法简洁明了，易于学习和掌握。它采用类似C语言的语法风格，但更加简洁和灵活。高效的执行速度：Lua是一种解释型语言，但它的执行速度非常快。这得益于其高效的虚拟机和优化的编译器。可扩展性强：L
  • 50周学习go语言：第五周 复合类型与词频统计 PyAIGCMaster 50周学习go语言学习golang服务器
    以下是第五周复合类型（数组、切片与映射）的详细学习内容，按照第四周的深度要求设计：第五周：复合类型与词频统计一、复合类型详解1.数组（Array）//声明与初始化vararr1[3]int//声明：[000]arr2:=[3]string{"A","B","C"}//显式初始化arr3:=[...]int{1,2,3}//编译器推断长度//特性：//-固定长度（长度是类型的一部分）//-值传递（赋
  • C++八股（面试题、手撕题）自用版 为了找工作开始抱佛脚 c++开发语言面试
    目录面试题：1.defineinline在编译的哪个阶段2.conststatic3.子函数返回结构体有什么问题，返回对象调用了哪些函数4.volatile关键字5.编译器基本原理6.预处理、编译、汇编、链接以及他们在操作系统上如何运作的7.数组和指针（二维）8.指针和引用9.new和malloc10.万能引用和右值引用11.解释中断，以及底层发生的操作细节12.C++多线程在操作系统上如何运作的
  • Linux 常用工具（yum、vim、gcc、gdb、git） 东区东区！ Linuxlinux服务器
    目录1.yum:软件包管理工具2.vim:linux下最受欢迎的命令行下的编辑器底行模式下的常见操作:普通模式下的常见操作:文本操作:其他操作：3.gcc/g++:编译器库4.gdb:调试器调试过程:5.项目的自动化构建工具make的解释执行规则:6.git项目的版本管理工具编辑1.yum:软件包管理工具查看搜索软件包:yumlistyumsearchkeyword安装软件包:yuminstall
  • 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其他