项目的完整代码在 C2j-Compiler

前言

在上一篇完成对JVM指令的生成，下面就可以真正进入代码生成部分了。通常现代编译器都是先把生成IR，再经过代码优化等等，最后才编译成目标平台代码。但是时间水平有限，我们没有IR也没有代码优化，就直接利用AST生成Java字节码

入口

进行代码生成的入口在CodeGen，和之前解释器一样：先获取main函数的头节点，从这个节点开始，先进入函数定义，再进入代码块

函数定义节点

在进入函数定义节点的时候，就要生成一个函数定义对应的Java字节码，即一个静态方法（因为我们对整个C语言文件生成为一个类，main方法为public static main，其它的则是对应的静态方法，结构体则是另外的类）

  • 对于函数定义先从节点中拿到对应的函数命和参数
  • emitArgs是用来处理参数的，根据参数生成相应的Java字节码
  • 如果这个函数是main的话已经是交由前面处理了，逻辑差不多（具体在start.Start中）
  1. case SyntaxProductionInit.NewName_LP_RP_TO_FunctDecl:
  2.     root.reverseChildren();
  3.     AstNode n = root.getChildren().get(0);
  4.     String name = (String) n.getAttribute(NodeKey.TEXT);
  5.     symbol = (Symbol) root.getAttribute(NodeKey.SYMBOL);
  6.     generator.setCurrentFuncName(name);
  7.     if (name != null && !name.equals("main")) {
  8.         String declaration = name + emitArgs(symbol);
  9.         generator.emitDirective(Directive.METHOD_PUBBLIC_STATIC, declaration);
  10.         generator.setNameAndDeclaration(name, declaration);
  11.     }
  12.     copyChild(root, root.getChildren().get(0));
  13.     break;
  15. case SyntaxProductionInit.NewName_LP_VarList_RP_TO_FunctDecl:
  16.     n = root.getChildren().get(0);
  17.     name = (String) n.getAttribute(NodeKey.TEXT);
  18.     symbol = (Symbol) root.getAttribute(NodeKey.SYMBOL);
  19.     generator.setCurrentFuncName(name);
  20.     if (name != null && !name.equals("main")) {
  21.         String declaration = name + emitArgs(symbol);
  22.         generator.emitDirective(Directive.METHOD_PUBBLIC_STATIC, declaration);
  23.         generator.setNameAndDeclaration(name, declaration);
  24.     }
  26.     Symbol args = symbol.getArgList();
  28.     if (args == null || argsList == null || argsList.isEmpty()) {
  29.         System.err.println("generate function with arg list but arg list is null");
  30.         System.exit(1);
  31.     }
  32.     break;

创建结构体和数组

数组

创建结构体和数组的节点在DefGenerate里，可以看到在这里只处理了数组和普通变量，有关结构体的处理是在对结构体第一次使用的时候。顺便提一下代码生成对于赋初值操作是没有进行处理的。

  • 如果是个数组，酒直接调用ProgramGenerator直接生成创建数组的指令
  • 如果是个普通变量，就直接找到它并且赋值为0（这里变量在队列里的位置是根据符号表来计算的，具体可以看上一篇的getLocalVariableIndex方法）
  1. public class DefGenerate extends BaseGenerate {
  2.     @Override
  3.     public Object generate(AstNode root) {
  4.         int production = (int) root.getAttribute(NodeKey.PRODUCTION);
  5.         ProgramGenerator generator = ProgramGenerator.getInstance();
  6.         Symbol symbol = (Symbol) root.getAttribute(NodeKey.SYMBOL);
  8.         switch (production) {
  9.             case SyntaxProductionInit.Specifiers_DeclList_Semi_TO_Def:
  10.                 Declarator declarator = symbol.getDeclarator(Declarator.ARRAY);
  11.                 if (declarator != null) {
  12.                     if (symbol.getSpecifierByType(Specifier.STRUCTURE) == null) {
  13.                         generator.createArray(symbol);
  14.                     }
  15.                 } else {
  16.                     int i = generator.getLocalVariableIndex(symbol);
  17.                     generator.emit(Instruction.SIPUSH, "" + 0);
  18.                     generator.emit(Instruction.ISTORE, "" + i);
  19.                 }
  21.                 break;
  23.             default:
  24.                 break;
  25.         }
  27.         return root;
  28.     }
  29. }

结构体

处理结构体定义的代码在UnaryNodeGenerate，也就是只有在使用到结构体定义时才会进行定义

  • 先拿到当前UNARY的符号，如果instanceof ArrayValueSetter就说明是一个结构体数组，就进入getStructSymbolFromStructArray方法创建一个结构体数组，并返回当前下标的结构体对象
  • 设置当前结构体的作用域范围
  • 对结构体作为类进行定义
  • 然后对读取结构体的域
  • 其实可以忽略指针部分，因为代码生成并没有对指针进行模拟
  1. case SyntaxProductionInit.Unary_StructOP_Name_TO_Unary:
  2.     child = root.getChildren().get(0);
  3.     String fieldName = (String) root.getAttribute(NodeKey.TEXT);
  4.     Object object = child.getAttribute(NodeKey.SYMBOL);
  5.     boolean isStructArray = false;
  7.     if (object instanceof ArrayValueSetter) {
  8.         symbol = getStructSymbolFromStructArray(object);
  9.         symbol.addValueSetter(object);
  10.         isStructArray = true;
  11.     } else {
  12.         symbol = (Symbol) child.getAttribute(NodeKey.SYMBOL);
  13.     }
  15.     if (isStructArray) {
  16.         ArrayValueSetter vs = (ArrayValueSetter) object;
  17.         Symbol structArray = vs.getSymbol();
  18.         structArray.addScope(ProgramGenerator.getInstance().getCurrentFuncName());
  19.     } else {
  20.         symbol.addScope(ProgramGenerator.getInstance().getCurrentFuncName());
  21.     }
  23.     ProgramGenerator.getInstance().putStructToClassDeclaration(symbol);
  25.     if (isSymbolStructPointer(symbol)) {
  26.         copyBetweenStructAndMem(symbol, false);
  27.     }
  29.     Symbol args = symbol.getArgList();
  30.     while (args != null) {
  31.         if (args.getName().equals(fieldName)) {
  32.             args.setStructParent(symbol);
  33.             break;
  34.         }
  36.         args = args.getNextSymbol();
  37.     }
  39.     if (args == null) {
  40.         System.err.println("access a filed not in struct object!");
  41.         System.exit(1);
  42.     }
  44.     if (args.getValue() != null) {
  45.         ProgramGenerator.getInstance().readValueFromStructMember(symbol, args);
  46.     }
  48.     root.setAttribute(NodeKey.SYMBOL, args);
  49.     root.setAttribute(NodeKey.VALUE, args.getValue());
  51.     if (isSymbolStructPointer(symbol)) {
  52.         checkValidPointer(symbol);
  53.         structObjSymbol = symbol;
  54.         monitorSymbol = args;
  56.         GenerateBrocasterImpl.getInstance().registerReceiverForAfterExe(this);
  57.     } else {
  58.         structObjSymbol = null;
  59.     }
  60.     break;

一元操作节点

这个节点和在解释器的有很多相同，除了有对结构体的操作，其它的也是有非常重要的作用

  • 像数字、字符串或者是变量和之前的操作都是把信息传递到父节点，交由父节点处理
  1. case SyntaxProductionInit.Number_TO_Unary:
  2.     text = (String) root.getAttribute(NodeKey.TEXT);
  3.     boolean isFloat = text.indexOf('.') != -1;
  4.     if (isFloat) {
  5.         value = Float.valueOf(text);
  6.         root.setAttribute(NodeKey.VALUE, value);
  7.     } else {
  8.         value = Integer.valueOf(text);
  9.         root.setAttribute(NodeKey.VALUE, value);
  10.     }
  11.     break;
  13. case SyntaxProductionInit.Name_TO_Unary:
  14.     symbol = (Symbol) root.getAttribute(NodeKey.SYMBOL);
  15.     if (symbol != null) {
  16.         root.setAttribute(NodeKey.VALUE, symbol.getValue());
  17.         root.setAttribute(NodeKey.TEXT, symbol.getName());
  18.     }
  19.     break;
  21. case SyntaxProductionInit.String_TO_Unary:
  22.     text = (String) root.getAttribute(NodeKey.TEXT);
  23.     root.setAttribute(NodeKey.VALUE, text);
  24.     break;
  26. case SyntaxProductionInit.Unary_LB_Expr_RB_TO_Unary:
  27.     child = root.getChildren().get(0);
  28.     symbol = (Symbol) child.getAttribute(NodeKey.SYMBOL);
  30.     child = root.getChildren().get(1);
  31.     int index = 0;
  32.     if (child.getAttribute(NodeKey.VALUE) != null) {
  33.         index = (Integer) child.getAttribute(NodeKey.VALUE);
  34.     }
  35.     Object idxObj = child.getAttribute(NodeKey.SYMBOL);
  37.     try {
  38.         Declarator declarator = symbol.getDeclarator(Declarator.ARRAY);
  39.         if (declarator != null) {
  40.             Object val = declarator.getElement((int) index);
  41.             root.setAttribute(NodeKey.VALUE, val);
  42.             ArrayValueSetter setter;
  43.             if (idxObj == null) {
  44.                 setter = new ArrayValueSetter(symbol, index);
  45.             } else {
  46.                 setter = new ArrayValueSetter(symbol, idxObj);
  47.             }
  49.             root.setAttribute(NodeKey.SYMBOL, setter);
  50.             root.setAttribute(NodeKey.TEXT, symbol.getName());
  52.         }
  53.         Declarator pointer = symbol.getDeclarator(Declarator.POINTER);
  54.         if (pointer != null) {
  55.             setPointerValue(root, symbol, index);
  56.             PointerValueSetter pv = new PointerValueSetter(symbol, index);
  57.             root.setAttribute(NodeKey.SYMBOL, pv);
  58.             root.setAttribute(NodeKey.TEXT, symbol.getName());
  59.         }
  60.     } catch (Exception e) {
  61.         e.printStackTrace();
  62.         System.exit(1);
  63.     }
  64.     break;

赋值操作

  • 如果当前是一个数组，先拿到它的符号和下标
  • 如果不是结构体数组，那么拿到下标直接用readArrayElement生成读取数组元素的指令
  • 如果是一个符号则用getLocalVariableIndex读取这个符号的值
  • 如果是一个常数，则直接生成IPUSH指令
  • 最后进行赋值操作，如果不是对结构体的域进行赋值就直接用getLocalVariableIndex拿到队列位置然后生成ISTORE
  • 如果是对结构体数组的元素的域的赋值，就调用assignValueToStructMemberFromArray生成代码，如果只是结构体就直接调用assignValueToStructMember生成代码
  1. ProgramGenerator generator = ProgramGenerator.getInstance();
  3. if (BaseGenerate.resultOnStack) {
  4.     this.value = obj;
  5.     BaseGenerate.resultOnStack = false;
  6. } else if (obj instanceof ArrayValueSetter) {
  7.     ArrayValueSetter setter = (ArrayValueSetter) obj;
  8.     Symbol symbol = setter.getSymbol();
  9.     Object index = setter.getIndex();
  10.     if (symbol.getSpecifierByType(Specifier.STRUCTURE) == null) {
  11.         if (index instanceof Symbol) {
  12.             ProgramGenerator.getInstance().readArrayElement(symbol, index);
  13.             if (((Symbol) index).getValue() != null) {
  14.                 int i = (int) ((Symbol) index).getValue();
  15.                 try {
  16.                     this.value = symbol.getDeclarator(Declarator.ARRAY).getElement(i);
  17.                 } catch (Exception e) {
  18.                     e.printStackTrace();
  19.                 }
  20.             }
  21.         } else {
  22.             int i = (int) index;
  23.             try {
  24.                 this.value = symbol.getDeclarator(Declarator.ARRAY).getElement(i);
  25.             } catch (Exception e) {
  26.                 e.printStackTrace();
  27.             }
  29.             ProgramGenerator.getInstance().readArrayElement(symbol, index);
  30.         }
  31.     }
  32. } else if (obj instanceof Symbol) {
  33.     Symbol symbol = (Symbol) obj;
  34.     this.value = symbol.value;
  35.     int i = generator.getLocalVariableIndex(symbol);
  36.     generator.emit(Instruction.ILOAD, "" + i);
  37. } else if (obj instanceof Integer) {
  38.     Integer val = (Integer) obj;
  39.     generator.emit(Instruction.SIPUSH, "" + val);
  40.     this.value = obj;
  41. }
  43. if (!this.isStructMember()) {
  44.     int idx = generator.getLocalVariableIndex(this);
  45.     if (!generator.isPassingArguments()) {
  46.         generator.emit(Instruction.ISTORE, "" + idx);
  47.     }
  48. } else {
  49.     if (this.getStructSymbol().getValueSetter() != null) {
  50.         generator.assignValueToStructMemberFromArray(this.getStructSymbol().getValueSetter(), this, this.value);
  51.     } else {
  52.         generator.assignValueToStructMember(this.getStructSymbol(), this, this.value);
  53.     }
  54. }

最后

完成这部分后，对下面的代码

  1. void quicksort(int A[10], int p, int r) {
  2.     int x;
  3.     int i;
  4.     i = p - 1;
  5.     int j;
  6.     int t;
  7.     int v;
  8.     v = r - 1;
  9.     if (p < r) {
  10.         x = A[r];
  11.         for (j = p; j <= v; j++) {
  12.             if (A[j] <= x) {
  13.                 i++;
  14.                 t = A[i];
  15.                 A[i] = A[j];
  16.                 A[j] = t;
  17.             }
  18.         }
  19.         v = i + 1;
  20.         t = A[v];
  21.         A[v] = A[r];
  22.         A[r] = t;
  23.         t = v - 1;
  24.         quicksort(A, p, t);
  25.         t = v + 1;
  26.         quicksort(A, t, r);
  27.     }
  28. }
  30. void main () {
  31.     int a[10];
  32.     int i;
  33.     int t;
  34.     printf("before quick sort:");
  35.     for(i = 0; i < 10; i++) {
  36.         t = (10 - i);
  37.         a[i] = t;
  38.         printf("value of a[%d] is %d", i, a[i]);
  39.     }
  40.     quicksort(a, 0, 9);
  41.     printf("after quick sort:");
  42.     for (i = 0; i < 10; i++) {
  43.         printf("value of a[%d] is %d", i, a[i]);
  44.     }
  45. }

则会生成下面的Java字节码

  1. .class public C2Bytecode
  2. .super java/lang/Object
  4. .method public static main([Ljava/lang/String;)V
  5. 	sipush	10
  6. 	newarray	int
  7. 	astore	0
  8. 	sipush	0
  9. 	istore	1
  10. 	sipush	0
  11. 	istore	2
  12. 	getstatic	java/lang/System/out Ljava/io/PrintStream;
  13. 	ldc	"before quick sort:"
  14. 	invokevirtual	java/io/PrintStream/print(Ljava/lang/String;)V
  15. 	getstatic	java/lang/System/out Ljava/io/PrintStream;
  16. 	ldc	"
  17. "
  18. 	invokevirtual	java/io/PrintStream/print(Ljava/lang/String;)V
  19. 	sipush	0
  20. 	istore	1
  22. loop0:
  23. 	iload	1
  24. 	sipush	10
  25. if_icmpge branch0
  26. 	sipush	10
  27. 	iload	1
  28. 	isub
  29. 	istore	2
  30. 	aload	0
  31. 	iload	1
  32. 	iload	2
  33. 	iastore
  34. 	aload	0
  35. 	iload	1
  36. 	iaload
  37. 	istore	3
  38. 	iload	1
  39. 	istore	4
  40. 	getstatic	java/lang/System/out Ljava/io/PrintStream;
  41. 	ldc	"value of a["
  42. 	invokevirtual	java/io/PrintStream/print(Ljava/lang/String;)V
  43. 	getstatic	java/lang/System/out Ljava/io/PrintStream;
  44. 	iload	4
  45. 	invokevirtual	java/io/PrintStream/print(I)V
  46. 	getstatic	java/lang/System/out Ljava/io/PrintStream;
  47. 	ldc	"] is "
  48. 	invokevirtual	java/io/PrintStream/print(Ljava/lang/String;)V
  49. 	getstatic	java/lang/System/out Ljava/io/PrintStream;
  50. 	iload	3
  51. 	invokevirtual	java/io/PrintStream/print(I)V
  52. 	getstatic	java/lang/System/out Ljava/io/PrintStream;
  53. 	ldc	"
  54. "
  55. 	invokevirtual	java/io/PrintStream/print(Ljava/lang/String;)V
  56. 	iload	1
  57. 	sipush	1
  58. 	iadd
  59. 	istore	1
  60. goto loop0
  61. branch0:
  62. 	aload	0
  63. 	sipush	0
  64. 	sipush	9
  65. 	invokestatic	C2Bytecode/quicksort([III)V
  66. 	getstatic	java/lang/System/out Ljava/io/PrintStream;
  67. 	ldc	"after quick sort:"
  68. 	invokevirtual	java/io/PrintStream/print(Ljava/lang/String;)V
  69. 	getstatic	java/lang/System/out Ljava/io/PrintStream;
  70. 	ldc	"
  71. "
  72. 	invokevirtual	java/io/PrintStream/print(Ljava/lang/String;)V
  73. 	sipush	0
  74. 	istore	1
  76. loop2:
  77. 	iload	1
  78. 	sipush	10
  79. if_icmpge branch4
  80. 	aload	0
  81. 	iload	1
  82. 	iaload
  83. 	istore	3
  84. 	iload	1
  85. 	istore	4
  86. 	getstatic	java/lang/System/out Ljava/io/PrintStream;
  87. 	ldc	"value of a["
  88. 	invokevirtual	java/io/PrintStream/print(Ljava/lang/String;)V
  89. 	getstatic	java/lang/System/out Ljava/io/PrintStream;
  90. 	iload	4
  91. 	invokevirtual	java/io/PrintStream/print(I)V
  92. 	getstatic	java/lang/System/out Ljava/io/PrintStream;
  93. 	ldc	"] is "
  94. 	invokevirtual	java/io/PrintStream/print(Ljava/lang/String;)V
  95. 	getstatic	java/lang/System/out Ljava/io/PrintStream;
  96. 	iload	3
  97. 	invokevirtual	java/io/PrintStream/print(I)V
  98. 	getstatic	java/lang/System/out Ljava/io/PrintStream;
  99. 	ldc	"
  100. "
  101. 	invokevirtual	java/io/PrintStream/print(Ljava/lang/String;)V
  102. 	iload	1
  103. 	sipush	1
  104. 	iadd
  105. 	istore	1
  106. goto loop2
  107. branch4:
  108. 	return
  109. .end method
  110. .method public static quicksort([III)V
  111. 	sipush	2
  112. 	newarray	int
  113. 	astore	6
  114. 	sipush	0
  115. 	istore	5
  116. 	sipush	1
  117. 	istore	5
  118. 	aload	6
  119. 	iload	5
  120. 	sipush	1
  121. 	iastore
  122. 	aload	6
  123. 	sipush	1
  124. 	iaload
  125. 	istore	10
  126. 	getstatic	java/lang/System/out Ljava/io/PrintStream;
  127. 	ldc	"before quick sort: "
  128. 	invokevirtual	java/io/PrintStream/print(Ljava/lang/String;)V
  129. 	getstatic	java/lang/System/out Ljava/io/PrintStream;
  130. 	iload	10
  131. 	invokevirtual	java/io/PrintStream/print(I)V
  132. 	getstatic	java/lang/System/out Ljava/io/PrintStream;
  133. 	ldc	"
  134. "
  135. 	invokevirtual	java/io/PrintStream/print(Ljava/lang/String;)V
  136. 	sipush	0
  137. 	istore	9
  138. 	sipush	0
  139. 	istore	3
  140. 	iload	1
  141. 	sipush	1
  142. 	isub
  143. 	istore	3
  144. 	sipush	0
  145. 	istore	4
  146. 	sipush	0
  147. 	istore	7
  148. 	sipush	0
  149. 	istore	8
  150. 	iload	2
  151. 	sipush	1
  152. 	isub
  153. 	istore	8
  154. 	iload	1
  155. 	iload	2
  156. if_icmpge branch1
  158. 	aload	0
  159. 	iload	2
  160. 	iaload
  161. 	istore	9
  162. 	iload	1
  163. 	istore	4
  165. loop1:
  167. 	iload	4
  168. 	iload	8
  169. if_icmpgt ibranch1
  171. 	aload	0
  172. 	iload	4
  173. 	iaload
  174. 	iload	9
  175. if_icmpgt ibranch2
  177. 	iload	3
  178. 	sipush	1
  179. 	iadd
  180. 	istore	3
  181. 	aload	0
  182. 	iload	3
  183. 	iaload
  184. 	istore	7
  185. 	aload	0
  186. 	iload	3
  187. 	aload	0
  188. 	iload	4
  189. 	iaload
  190. 	iastore
  191. 	aload	0
  192. 	iload	4
  193. 	iload	7
  194. 	iastore
  195. ibranch2:
  197. 	iload	4
  198. 	sipush	1
  199. 	iadd
  200. 	istore	4
  201. goto loop1
  203. ibranch1:
  205. 	iload	3
  206. 	sipush	1
  207. 	iadd
  208. 	istore	8
  209. 	aload	0
  210. 	iload	8
  211. 	iaload
  212. 	istore	7
  213. 	aload	0
  214. 	iload	8
  215. 	aload	0
  216. 	iload	2
  217. 	iaload
  218. 	iastore
  219. 	aload	0
  220. 	iload	2
  221. 	iload	7
  222. 	iastore
  223. 	iload	8
  224. 	sipush	1
  225. 	isub
  226. 	istore	7
  227. 	aload	0
  228. 	iload	1
  229. 	iload	7
  230. 	invokestatic	C2Bytecode/quicksort([III)V
  231. 	iload	8
  232. 	sipush	1
  233. 	iadd
  234. 	istore	7
  235. 	aload	0
  236. 	iload	7
  237. 	iload	2
  238. 	invokestatic	C2Bytecode/quicksort([III)V
  239. branch1:
  241. 	return
  242. .end method
  244. .end class

小结

这篇的代码生成和之前解释器的思路很相似，都是根据AST和对应的产生式来执行或者生成代码。

其实主要的思路是很清晰的，只是其中有太多细节容易让人太过纠结。这个系列算作是我自己的学习笔记，到这也有十三篇了，下一篇可能写写总结就正式结束了。

欢迎Star!

从零写一个编译器（十三）：代码生成之遍历AST的更多相关文章

  1. 从零写一个编译器（九）：语义分析之构造抽象语法树(AST)

    项目的完整代码在 C2j-Compiler 前言 在上一篇完成了符号表的构建,下一步就是输出抽象语法树(Abstract Syntax Tree,AST) 抽象语法树(abstract syntax ...

  2. 从零写一个编译器（十一）：代码生成之Java字节码基础

    项目的完整代码在 C2j-Compiler 前言 第十一篇,终于要进入代码生成部分了,但是但是在此之前,因为我们要做的是C语言到字节码的编译,所以自然要了解一些字节码,但是由于C语言比较简单,所以只需 ...

  3. 手把手教你从零写一个简单的 VUE

    本系列是一个教程,下面贴下目录~1.手把手教你从零写一个简单的 VUE2.手把手教你从零写一个简单的 VUE--模板篇 今天给大家带来的是实现一个简单的类似 VUE 一样的前端框架,VUE 框架现在应 ...

  4. 手把手教你从零写一个简单的 VUE--模板篇

    教程目录1.手把手教你从零写一个简单的 VUE2.手把手教你从零写一个简单的 VUE--模板篇 Hello,我又回来了,上一次的文章教会了大家如何书写一个简单 VUE,里面实现了VUE 的数据驱动视图 ...

  5. 学了编译原理能否用 Java 写一个编译器或解释器？

    16 个回答 默认排序​ RednaxelaFX JavaScript.编译原理.编程 等 7 个话题的优秀回答者 282 人赞同了该回答 能.我一开始学编译原理的时候就是用Java写了好多小编译器和 ...

  6. 从零写一个Asp.net core手脚架（模型验证）

    一个asp.net core项目,一定包含了各种的实体,在RESTful api里面,有很多的参数传递,不建立实体则大量的参数需要自定验证正确性,并且Action上面会写的密密麻麻的参数 在asp.n ...

  7. 从零写一个Asp.net core手脚架 （异常处理）

    既然是手脚架,那么肯定得明白,手脚架是有限资源的一个整合,我们尽可能完善它,并保留可扩展性才是最终目的,尽可能减少硬编码,让业务不满足的情况下,可以自行修改 我们把解决方案取名Asp.netCoreT ...

  8. 自己动手写一个编译器Tiny语言解析器实现

    然后,上一篇文章简介Tiny词法分析,实现语言.本文将介绍Tiny的语法分析器的实现. 1 Tiny语言的语法 下图是Tiny在BNF中的文法. 文法的定义能够看出.INNY语言有以下特点: 1 程序 ...

  9. 怎样写一个webpack loader

    div{display:table-cell;vertical-align:middle}#crayon-theme-info .content *{float:left}#crayon-theme- ...

随机推荐

  1. 算法学习笔记，几个简单的Demo

    算法初学的一些心得 前言:现在工作也快一年多了,有时间下班回家会学学算法,陆陆续续也接触了一些 貌似我知道的就冒泡排序其他的都不是很了解 最近买了一本书,边学边记录吧! 一些常用的方法 暴力破解 下面 ...

  2. 【原】深度学习的一些经验总结和建议 | To do v.s Not To Do

    前言:本文同步发布于公众号:Charlotte数据挖掘,欢迎关注,获得最新干货- 昨天看到几篇不同的文章写关于机器学习的to do & not to do,有些观点赞同,有些不赞同,是现在算法 ...

  3. LiteDB源码解析系列（1）LiteDB介绍

    最近利用端午假期,我把LiteDB的源码仔细的阅读了一遍,酣畅淋漓,确实收获了不少.后面将编写一系列关于LteDB的文章分享给大家,希望这么好的源码不要被埋没. 1.LiteDB是什么 这是一个小型的 ...

  4. springboot启动不设置端口

    非web工程 在服务架构中,有些springboot工程只是简单的作为服务,并不提供web服务 这个时候不需要依赖 <dependency> <groupId>org.spri ...

  5. 常用socket函数详解

    常用socket函数详解 关于socket函数,每个的意义和基本功能都知道,但每次使用都会去百度,参数到底是什么,返回值代表什么意义,就是说用的少,也记得不够精确.每次都查半天,经常烦恼于此.索性都弄 ...

  6. wp伪静态网页打开慢之提速方案1s内打开 wp的静态化插件测试

    自上篇文章,我做了伪静态话.可是伪静态访问还是php动态页面,还需要服务端分析如何处理,访问页面时会发现有一个漫长的等待响应的时间.这是打开速度在4s左右.而静态页面则是直接打开,不需要服务器操作,不 ...

  7. 关于keil警告/错误问题的解释和修正

    - 版权声明:本文为博主 **乔勇刚-** 一字一句敲出来的原创作品,未经博主允许不得转载,多谢支持.- 本系列博客仅做经验交流分享,不能用作任何商业用途.本文中如有不足之处,请您留言,本人将及时更改 ...

  8. RabbitMQ（三）：RabbitMQ与Spring Boot简单整合

    RabbitMQ是目前非常热门的一款消息中间件,不管是互联网大厂还是中小企业都在大量使用.Spring Boot的兴起,极大地简化了Spring的开发,本文将使用Spring Boot与RabbitM ...

  9. JNDI总结（一）

    一.数据源的由来 在Java开发中,使用JDBC操作数据库的四个步骤如下:   ①加载数据库驱动程序(Class.forName("数据库驱动类");)   ②连接数据库(Conn ...

  10. 比特币and区块链

    比特币简介 比特币(Bitcoin:比特金)最早是一种网络虚拟货币,可以购买现实生活当中的物品.它的特点是分散化.匿名.只能在数字世界使用,不属于任何国家和金融机构,并且不受地域的限制,可以在世界上的 ...