java编写编译器和解释器

on 2012-07-14 21:24 Bang 阅读(102) 评论(0) 编辑收藏

初始后端实现

框架后端支持编译器和解释器。现在框架抽象类Backend有两个极简版实现，一个为编译器另一个为解释器。图2-7 展示了它们的UML类图。

图2-7 子类CodeGenerator和Executor分别是后端的编译器和解析器实现。

编译器

编译器后端做代码生成。backend.compiler包中的类CodeGenerator实现框架抽象类Backend。现在它被最大简化了。清单2-20 展示了它的父类方法process的实现。方法参数引用自中间码和符号表，它产生一条消息指出生成器生成了多少条机器语言指令（目前0条，因为没有实际生成过程）以及代码生成耗用时间。它调用sendMessage()方法发送编译摘要消息。

编译器约定摘要格式为：

instructionCount：指令生成条数。
elapsedTime：代码生成耗用时间。

所有COMILER_SUMMARY消息必须遵循这种约定。

清单2-20：类CodeGenerator的初级版实现

   1: /**

   2:  * <p>编译器的后端代码生成器</p>

   3:  */

   4: public class CodeGenerator extends Backend

   5: {

   6:     public void process(ICode iCode, SymTab symTab)

   7:         throws Exception

   8:     {

   9:         long startTime = System.currentTimeMillis();

  10:         float elapsedTime = (System.currentTimeMillis() - startTime)/1000f;

  11:         int instructionCount = 0;

12:

  13:         // 发送编译摘要消息

  14:         sendMessage(new Message(COMPILER_SUMMARY,

  15:                                 new Number[] {instructionCount,

  16:                                               elapsedTime}));

  17:     }

  18: }

解释器

解释器后端做程序执行。包backend.interpreter中的类Executor实现框架抽象类Backend。现在它也被最大简化了。清单2-21 展示了它的父类方法process的实现。它产生一条解释状态消息表明它执行了多少条语句，运行错误数（目前都是0）以及执行程序所耗费的时间。它调用sendMessage()发送消息。

解释器约定摘要消息格式为：

executionCount：执行语句数
runtimeErrors：运行期错误数
elapsedTime：耗费时间

所有INTERPRETER_SUMMARY消息的监听器必须遵循此种约定。

清单2-21：Executor类process()方法的初级实现

   1: /**

   2:  * <p>解释器后端执行器</p>

   3:  */

   4: public class Executor extends Backend

   5: {

   6:     public void process(ICode iCode, SymTab symTab)

   7:         throws Exception

   8:     {

   9:         long startTime = System.currentTimeMillis();

  10:         float elapsedTime = (System.currentTimeMillis() - startTime)/1000f;

  11:         int executionCount = 0;

  12:         int runtimeErrors = 0;

13:

  14:         // 发送解释摘要消息

  15:         sendMessage(new Message(INTERPRETER_SUMMARY,

  16:                                 new Number[] {executionCount,

  17:                                               runtimeErrors,

  18:                                               elapsedTime}));

  19:     }

  20: }

后端工厂

如前端一样，后端工厂类创建合适的后端组件。

清单2-22 工厂类BackEndFactory

   1: /**

   2:  * <p>产生编译器或解释器后端的工厂</p>

   3:  */

   4: public class BackendFactory

   5: {

   6:     /**

   7:      * 视参数产生编译器或解释器后端

   8:      * @param operation "compile"或者"execute"

   9:      * @return 后端组件

  10:      * @throws Exception if an error occurred.

  11:      */

  12:     public static Backend createBackend(String operation)

  13:         throws Exception

  14:     {

  15:         if (operation.equalsIgnoreCase("compile")) {

  16:             return new CodeGenerator();

  17:         }

  18:         else if (operation.equalsIgnoreCase("execute")) {

  19:             return new Executor();

  20:         }

  21:         else {

  22:             throw new Exception("后端工厂: 不支持的操作 '" +

  23:                                 operation + "'");

  24:         }

  25:     }

  26: }

静态方法createBackend()验证标识是创建一个编译器后端（"compiler")还是一个解释器后端（"execute")的字符串参数。如果参数正确，方法创建且返回对应的后端组件。

目前你已搞定本章的第二和第三目标，即将初级Pascal相关组件集成进框架前端以及将编译器和解释器组件集成进后端。

程序 2：程序清单

框架组件以及初级具体实现组件已就绪并集成完毕。一些简单的端对端（前端对后端）测试将验证你是否正确的设计和开发了这些组件。编译器测试将调用前端解析Pascal源程序，产生一个代码清单以及打印编译后端产生的消息。类似地，解析器测试调用前端解析Pascal源程序，产生一个代码清单以及打印解释器后端产生的消息。

清单2-23 展示了Pascal主类。这个测试背后的意思是你可以编译或执行Pascal源程序。

   1: /**

   2:  *

   3:  * Pascal外壳程序，根据参数选择性的调用编译器或者解释器

   4:  *

   5:  * <p>Copyright (c) 2009 by Ronald Mak</p>

   6:  * <p>For instructional purposes only.  No warranties.</p>

   7:  */

   8: public class Pascal

   9: {

  10:     private Parser parser;    // 语言无关的 parser

  11:     private Source source;    // 语言无关的 scanner

  12:     private ICode iCode;      // 抽象语法树

  13:     private SymTab symTab;    // 符号表

  14:     private Backend backend;  // 后端

15:

  16:     /**

  17:      * 编译或者解释源程序

  18:      * @param operation compile 或者 execute

  19:      * @param filePath 源文件路径

  20:      * @param flags 命令行参数标记

  21:      */

  22:     public Pascal(String operation, String filePath, String flags)

  23:     {

  24:         try {

  25:             //显示中间码结构

  26:             boolean intermediate = flags.indexOf('i') > -1;

  27:             //显示符号引用

  28:             boolean xref         = flags.indexOf('x') > -1;

29:

  30:             source = new Source(new BufferedReader(new FileReader(filePath)));

  31:             source.addMessageListener(new SourceMessageListener());

  32:             //top-down是Parser的一种，还有一种本书没有实现的bottom-up。

  33:             parser = FrontendFactory.createParser("Pascal", "top-down", source);

  34:             parser.addMessageListener(new ParserMessageListener());

35:

  36:             backend = BackendFactory.createBackend(operation);

  37:             backend.addMessageListener(new BackendMessageListener());

38:

  39:             parser.parse();

  40:             source.close();

  41:             //生成中间码和符号表

  42:             iCode = parser.getICode();

  43:             symTab = parser.getSymTab();

  44:             //交由后端处理

  45:             backend.process(iCode, symTab);

  46:         }

  47:         catch (Exception ex) {

  48:             System.out.println("***** 翻译器出现错误 *****");

  49:             ex.printStackTrace();

  50:         }

  51:     }

52:

  53:     private static final String FLAGS = "[-ix]";

  54:     private static final String USAGE =

  55:         "使用方式: Pascal execute|compile " + FLAGS + " <源文件路径>";

56:

  57:     /**

  58:      * 入口程序，参考Pascal构造函数的参数接受过程。<br>

  59:      * 例如：compile -i hello.pas

  60:      */

  61:     public static void main(String args[])

  62:     {

  63:         try {

  64:             String operation = args[0];

65:

  66:             // 翻译操作类型，compile或execute

  67:             if (!(   operation.equalsIgnoreCase("compile")

  68:                   || operation.equalsIgnoreCase("execute"))) {

  69:                 throw new Exception();

  70:             }

71:

  72:             int i = 0;

  73:             String flags = "";

74:

  75:             // 参数标识

  76:             while ((++i < args.length) && (args[i].charAt(0) == '-')) {

  77:                 flags += args[i].substring(1);

  78:             }

79:

  80:             // 源文件

  81:             if (i < args.length) {

  82:                 String path = args[i];

  83:                 new Pascal(operation, path, flags);

  84:             }

  85:             else {

  86:                 throw new Exception();

  87:             }

  88:         }

  89:         catch (Exception ex) {

  90:             System.out.println(USAGE);

  91:         }

  92:     }

93:

  94:     private static final String SOURCE_LINE_FORMAT = "%03d %s";

95:

  96:     /**

  97:      * 源（也就是源文件)的监听器，用于监听源文件的读取情况，如果注册了监听器，源每产生一条消息比如<br>

  98:      * 读取了一行等，将会调用相应的监听器处理。典型的Observe模式

  99:      */

 100:     private class SourceMessageListener implements MessageListener

 101:     {

 102:         public void messageReceived(Message message)

 103:         {

 104:             MessageType type = message.getType();

 105:             Object body[] = (Object []) message.getBody();

 106:

 107:             switch (type) {

 108:                 //源读取了一行

 109:                 case SOURCE_LINE: {

 110:                     int lineNumber = (Integer) body[0];

 111:                     String lineText = (String) body[1];

 112:

 113:                     System.out.println(String.format(SOURCE_LINE_FORMAT,

 114:                                                      lineNumber, lineText));

 115:                     break;

 116:                 }

 117:             }

 118:         }

 119:     }

 120:

 121:     private static final String PARSER_SUMMARY_FORMAT =

 122:         "源文件共有\t%d行。" +

 123:         "\n有\t%d个语法错误." +

 124:         "\n解析共耗费\t%.2f秒.\n";

 125:

 126:     /**

 127:      * Parser的监听器，监听来自Parser解析过程中产生的消息，还是Observe模式

 128:      */

 129:     private class ParserMessageListener implements MessageListener

 130:     {

 131:         public void messageReceived(Message message)

 132:         {

 133:             MessageType type = message.getType();

 134:

 135:             switch (type) {

 136:

 137:                 case PARSER_SUMMARY: {

 138:                     Number body[] = (Number[]) message.getBody();

 139:                     int statementCount = (Integer) body[0];

 140:                     int syntaxErrors = (Integer) body[1];

 141:                     float elapsedTime = (Float) body[2];

 142:                     System.out.println("\n----------代码解析统计信--------------");

 143:                     System.out.printf(PARSER_SUMMARY_FORMAT,

 144:                                       statementCount, syntaxErrors,

 145:                                       elapsedTime);

 146:                     break;

 147:                 }

 148:             }

 149:         }

 150:     }

 151:

 152:     private static final String INTERPRETER_SUMMARY_FORMAT =

 153:         "共执行\t%d 条语句。" +

 154:         "\n运行中发生了\t%d 个错误。" +

 155:         "\n执行共耗费\t%.2f 秒。\n";

 156:

 157:     private static final String COMPILER_SUMMARY_FORMAT =

 158:         "共生成\t\t%d 条指令" +

 159:         "\n代码生成共耗费\t%.2f秒\n";

 160:

 161:     /**

 162:      * Listener for back end messages.

 163:      */

 164:     private class BackendMessageListener implements MessageListener

 165:     {

 166:         /**

 167:          * Called by the back end whenever it produces a message.

 168:          * @param message the message.

 169:          */

 170:         public void messageReceived(Message message)

 171:         {

 172:             MessageType type = message.getType();

 173:

 174:             switch (type) {

 175:

 176:                 case INTERPRETER_SUMMARY: {

 177:                     Number body[] = (Number[]) message.getBody();

 178:                     int executionCount = (Integer) body[0];

 179:                     int runtimeErrors = (Integer) body[1];

 180:                     float elapsedTime = (Float) body[2];

 181:                     System.out.println("\n----------解释统计信息------------");

 182:                     System.out.printf(INTERPRETER_SUMMARY_FORMAT,

 183:                                       executionCount, runtimeErrors,

 184:                                       elapsedTime);

 185:                     break;

 186:                 }

 187:

 188:                 case COMPILER_SUMMARY: {

 189:                     Number body[] = (Number[]) message.getBody();

 190:                     int instructionCount = (Integer) body[0];

 191:                     float elapsedTime = (Float) body[1];

 192:                     System.out.println("\n----------编译统计信--------------");

 193:                     System.out.printf(COMPILER_SUMMARY_FORMAT,

 194:                                       instructionCount, elapsedTime);

 195:                     break;

 196:                 }

 197:             }

 198:         }

 199:     }

 200: }

如果classes目录包含相应的class文件且当前目录包含Pascal源文件hello.pas，使用类似如下的命令行去编译文件。

java –classpath classes Pascal compile hello.pas

解释源文件类似如下命令行

java –classpath classes Pascal execute hello.pas

在Eclipse更简单，因为hello.pas在根目录下，直接创建两个如下的Java Application，一个编译，一个解释，非常happy。

构造函数根据源文件路径创建一个Source对象，接着根据命令行参数调用前端和后端工厂创建相应组件。构造函数调用parser的parse()方法解析源文件，得到生成的中间码和符号表并将它们传给后端的process方法。

注意构造函数调用前端工厂为Pascal源语言创建top-down解析器但不依赖具体源语言或使用的解析器类型。源语言和解析器(parser)类型已传给命令行。同样地，Pascal类也不需要知道到底后端工厂创建的是编译器还是解释器（因为是公共的Backend抽象类）。

三个内部类分别是parser，Source和Backend的监听器。类SourceMessageListener，ParserMessageListener和BackendMessageListener分别遵循source，Parser以及Backend的消息格式约定。它们使用格式串SOURCE_LINE_FORMAT，PARSER_SUMMARY_FORMAT，INTERPRETER_SUMMARY_FORMAT以及COMPILER_SUMMARY_FORMAT，正确地输入格式化后的文本给System.out。

假设文件hello.pas包含清单2-24里的Pascal程序。

清单2-24 Pascal程序hello.pas

PROGRAM hello (output);

{Write 'Hello, world.' ten times.}

VAR
i : integer;

BEGIN {hello}
FOR i := TO DO BEGIN
writeln('Hello, world.');
END;
END {hello}.

则初级编译器将输出如清单2-25所示的内容。

001 PROGRAM hello (output);
002 
003 {Write 'Hello, world.' ten times.}
004 
005 VAR
006     i : integer;
007 
008 BEGIN {hello}
009     FOR i := 1 TO 10 DO BEGIN
010         writeln('Hello, world.');
011     END;
012 END {hello}.

----------代码解析统计信--------------
源文件共有    12行。
有    0个语法错误.
解析共耗费    0.03秒.

----------编译统计信--------------
共生成        0 条指令
代码生成共耗费    0.00秒

设计笔记

本章有很多烦人事是确保框架是源语言无关且能支持任何编译器或解释器。即使Pascal类相当不可知你也将Pascal相关组件加到前端以及编译或解释相关组件加到后端。

软件工程的一个主要挑战是管理变更。你能更改源语言，解析类型，或要一个编译器还是一个解释器。因为框架被设计成可伸缩，它将是可靠的，并不需要什么改动。而你仅需要实现子类时做些改动。

如果说你想要一个bottom-up而不是top-down解析器（parser，也称语法分析器，以后都称为解析器），那么使用同样的前端ParserScanner类，增加一个新的Parser实现如PascalParserBU。或者更改源语言为Java，实现一个Parser子类JavaParserTD，不过这个子类需要一个新的Scanner比如JavaScanner。

因此为管理变更，应用此条软件工程法则，那就是封装多变的代码使其与不变的代码隔离开来。在前端，Parser和Scanner可能有变化，则把它们封装在子类实现中。后端的编译器和解释器同样是子类。变化的子类与不变的框架类隔离开来。

因为我们所有的解析器，其中PascalParserTD是一个例子，它继承自Parser基类，所有解析器组成一个可互换的类族。其它类族有Scanner的子类（比如PascalScanner，Token子类（比如EofToken)以及Backend子类(比如CodeGenerator和Executor)。在每个类族中，你能增加和交换族成员而不需修改框架代码。

策略模式(Strategy Design Pattern)详细说明了此等类族的用法。早点实现这种设计模式去管理变更会让你在接下来章节的进一步开发中获益更多。

初级解释器将生成如清单2-26的输出。

清单2-26： Pascal 解释器输出

001 PROGRAM hello (output);
002 
003 {Write 'Hello, world.' ten times.}
004 
005 VAR
006     i : integer;
007 
008 BEGIN {hello}
009     FOR i := 1 TO 10 DO BEGIN
010         writeln('Hello, world.');
011     END;
012 END {hello}.

----------代码解析统计信--------------
源文件共有    12行。
有    0个语法错误.
解析共耗费    0.03秒.

----------解释统计信息------------
共执行    0 条语句。
运行中发生了    0 个错误。
执行共耗费    0.00 秒。

这些端对端测试运行满足本章的第四和最后一个目标。

分类: 底层技术, java

标签: 编译器解释器 Java AST 语法树