(基于Java)编写编译器和解释器第9章：解析声明第三部分(连载)

续 第二部分

图9-6 展示了这两个同等类型定义所生成的符号表项和类型说明。此图展示了数组元素类型是怎样通过与数组类型说明的ARRAY_ELEMENT_TYPE属性值联系在一起的。

两种定义格式不一样，但是生成同样的符号表项与类型说明配置。遵照图9-3的惯例，SymTabEntry对象以亮灰色而TypeSepc对象以暗灰显示。属性值ARRAY_ELEMENT_TYPE是带加粗箭头的连线。在Pascal中，字符'a'和'z'的序数值分别是97和122。

清单9-26 展示了类型说明解析子类ArrayTypeParser中的parse方法。

//数组 左方括号之后的同步集
   private static final EnumSet<PascalTokenType> LEFT_BRACKET_SET =
       SimpleTypeParser.SIMPLE_TYPE_START_SET.clone();
   static {
       LEFT_BRACKET_SET.add(LEFT_BRACKET);
       LEFT_BRACKET_SET.add(RIGHT_BRACKET);
   }

   // 右方括号之后的同步集
   private static final EnumSet<PascalTokenType> RIGHT_BRACKET_SET =
       EnumSet.of(RIGHT_BRACKET, OF, SEMICOLON);

   // 相当于元素类型的同步集
   private static final EnumSet<PascalTokenType> OF_SET =
       TypeSpecificationParser.TYPE_START_SET.clone();
   static {
       OF_SET.add(OF);
       OF_SET.add(SEMICOLON);
   }

   public TypeSpec parse(Token token)
       throws Exception
   {
       TypeSpec arrayType = TypeFactory.createType(ARRAY);
       token = nextToken();  //剔掉ARRAY关键字

       //在左括号出同步一下
       token = synchronize(LEFT_BRACKET_SET);
       if (token.getType() != LEFT_BRACKET) {
           errorHandler.flag(token, MISSING_LEFT_BRACKET, this);
       }

       // 解析索引类型
       TypeSpec elementType = parseIndexTypeList(token, arrayType);

       // 在右括号出同步一下
       token = synchronize(RIGHT_BRACKET_SET);
       if (token.getType() == RIGHT_BRACKET) {
           token = nextToken();
       }
       else {
           errorHandler.flag(token, MISSING_RIGHT_BRACKET, this);
       }

       // 在OF处同步一下
       token = synchronize(OF_SET);
       if (token.getType() == OF) {
           token = nextToken();
       }
       else {
           errorHandler.flag(token, MISSING_OF, this);
       }

       // 然后是元素类型
       elementType.setAttribute(ARRAY_ELEMENT_TYPE, parseElementType(token));

       return arrayType;
   }

方法parse()首先调用 TypeFactory.createType()创建一个数组TypeSpec对象，接着调用parseIndexTypeList()解析逗号分割的一个或多个索引类型说明。在吞噬掉OF关键字后，parse()调用parseElementType()解析元素类型说明。

清单9-27 展示了方法parseIndexTypeList()和parseIndexType()

//索引同步集
   private static final EnumSet<PascalTokenType> INDEX_START_SET =
       SimpleTypeParser.SIMPLE_TYPE_START_SET.clone();
   static {
       INDEX_START_SET.add(COMMA);
   }

   // 索引结束后的同步集
   private static final EnumSet<PascalTokenType> INDEX_END_SET =
       EnumSet.of(RIGHT_BRACKET, OF, SEMICOLON);

   // 索引之后的同步集
   private static final EnumSet<PascalTokenType> INDEX_FOLLOW_SET =
       INDEX_START_SET.clone();
   static {
       INDEX_FOLLOW_SET.addAll(INDEX_END_SET);
   }

   /**
    * 解析索引类型说明列表，比如 ARRAY [1..3] 里面的 1..3
    * @param token 当前Token，即左括号
    * @param arrayType 父的数组类型说明
    * @return 元素类型说明
    * @throws Exception
    */
   private TypeSpec parseIndexTypeList(Token token, TypeSpec arrayType)
       throws Exception
   {
       TypeSpec elementType = arrayType;
       boolean anotherIndex = false;

       token = nextToken();  // 剔掉左括号

       // 解析索引类型说明列表，多维如 ARRAY [1..3, 'a'..'z'] 等
       do {
           anotherIndex = false;

           //索引类型
           token = synchronize(INDEX_START_SET);
           parseIndexType(token, elementType);

           //索引结束同步一下
           token = synchronize(INDEX_FOLLOW_SET);
           TokenType tokenType = token.getType();
           if ((tokenType != COMMA) && (tokenType != RIGHT_BRACKET)) {
               if (INDEX_START_SET.contains(tokenType)) {
                   errorHandler.flag(token, MISSING_COMMA, this);
                   anotherIndex = true;
               }
           }else if (tokenType == COMMA) { //一个逗号以为这多维索引
               TypeSpec newElementType = TypeFactory.createType(ARRAY);
               elementType.setAttribute(ARRAY_ELEMENT_TYPE, newElementType);
               elementType = newElementType;

               token = nextToken(); //吞掉逗号
               anotherIndex = true;
           }
       } while (anotherIndex);

       return elementType;
   }

   /**
    * 解析索引类型说明，这个是单个的 []包含的，一定是个简单类型，不包含嵌套。
    * @param token
    * @param 传入的数组类型说明，解析过程会加上一些属性
    * @throws Exception
    */
   private void parseIndexType(Token token, TypeSpec arrayType)
       throws Exception
   {
       SimpleTypeParser simpleTypeParser = new SimpleTypeParser(this);
       TypeSpec indexType = simpleTypeParser.parse(token);
       arrayType.setAttribute(ARRAY_INDEX_TYPE, indexType);

       if (indexType == null) {
           return;
       }

       TypeForm form = indexType.getForm();
       int count = 0;

       // 如果是子界类型
       if (form == SUBRANGE) {
           Integer minValue =
               (Integer) indexType.getAttribute(SUBRANGE_MIN_VALUE);
           Integer maxValue =
               (Integer) indexType.getAttribute(SUBRANGE_MAX_VALUE);

           if ((minValue != null) && (maxValue != null)) {
               count = maxValue - minValue + 1;
           }
       }//枚举类型
       else if (form == ENUMERATION) {
           ArrayList<SymTabEntry> constants = (ArrayList<SymTabEntry>)
               indexType.getAttribute(ENUMERATION_CONSTANTS);
           count = constants.size();
       }
       else {
           errorHandler.flag(token, INVALID_INDEX_TYPE, this);
       }
       arrayType.setAttribute(ARRAY_ELEMENT_COUNT, count);
   }

方法parseIndexTypeList()用来解析索引类型说明列表。它初始化变量elementType为parse()创建的数组TypeSpec对象（即最外围的那个）。在循环中，它调用parseIndexType()解析每一个索引类型说明。在第一个索引类型之后（意味着有多维出现），parseIndexTypeList()必须调用TypeFactory.createType()创建一个新的数组TypeSpec对象作为新的元素TypeSpec。方法设置嗲一个elementType的ARRAY_ELEMENT_TYPE属性为新的元素TypeSpec对象，并马上将elementType指向新的元素TypeSpec对象（见51,52,53行)。在循环中，这将会创建一个数组TypeSpec对象的ARRAY_ELEMENT_TYPE链，就如图9-6展示的那样。方法返在链条最末端的数组TypeSpec对象（也就是最里层的数组对象）。

最终，parseElementType()方法返回typeSpecificationParser.parse()所解析到的结果，我们知道，typeSpecificationParser.parse()是用来解析一般类型说明的。

/**
  * 数组元素可以是另外一个数组，也可是个简单类型，交给TypeSpec来决定吧。
  * @param token 当前token， OF之后的第一个
  * @return 元素类型说明
  * @throws Exception
  */
 private TypeSpec parseElementType(Token token)
     throws Exception
 {
     TypeSpecificationParser typeSpecificationParser =
         new TypeSpecificationParser(this);
     return typeSpecificationParser.parse(token);
 }

记录类型(Record Types)

余下的Pascal类型就是记录类型了。清单9-29 展示了类型说明解析子类RecordTypeParser的parse()方法。

class RecordTypeParser extends TypeSpecificationParser
{
    protected RecordTypeParser(PascalParserTD parent)
    {
        super(parent);
    }

    // END处的同步集
    private static final EnumSet<PascalTokenType> END_SET =
        DeclarationsParser.VAR_START_SET.clone();
    static {
        END_SET.add(END);
        END_SET.add(SEMICOLON);
    }

    public TypeSpec parse(Token token)
        throws Exception
    {
        TypeSpec recordType = TypeFactory.createType(RECORD);
        token = nextToken(); //吞掉RECORD关键字
        //每个RECORD是一个作用域，需要加入新的符号表
        recordType.setAttribute(RECORD_SYMTAB, symTabStack.push());

        // 记录中的字段申明，一个或多个
        VariableDeclarationsParser variableDeclarationsParser =
            new VariableDeclarationsParser(this);
        variableDeclarationsParser.setDefinition(FIELD);
        variableDeclarationsParser.parse(token);

        // 退出record作用域
        symTabStack.pop();

        // 同步在end处
        token = synchronize(END_SET);

        if (token.getType() == END) {
            token = nextToken();
        }
        else {
            errorHandler.flag(token, MISSING_END, this);
        }

        return recordType;
    }
}

就如图9-1 所示，记录类型定义中的字段申明和变量申明有同样的语法，因此这个parse()方法相对简单些。它调用TypeFactory.createType()创建一个记录TypeSpec对象来开始。因为一个记录类型说明得创建一个新的作用域用来包含它的字段申明，所以语句

recordType.setAttribute(RECORD_SYMTAB, symTabStack.push());

往符号表堆栈推入一个新表并设置它为记录TypeSpec对象的RECORD_SYMTAB的值。接着parse()设置variableDeclarationsParser的定义为FIELD并调用variableDeclarationsParser.parseFields()解析字段申明。完事后弹出记录的符号表。马上你就会看到类VariableDeclarationsParser

解析变量申明

现在是解析变量申明的时候了。前面讲过，这个变量申明解析器同样会解析记录字段申明。清单9-16和9-29 展示了它的调用者首先设置definition域。清单9-30 展示了 申明解析器子类VariableDeclarationsParser的parse()方法。

// 标识符怎么定义的？同是变量申明，上下文不一样，定义不一样
    private Definition definition;
    public VariableDeclarationsParser(PascalParserTD parent)
    {
        super(parent);
    }
    // 变量申明的同步集
    static final EnumSet<PascalTokenType> IDENTIFIER_SET =
        DeclarationsParser.VAR_START_SET.clone();
    static {
        IDENTIFIER_SET.add(IDENTIFIER);
        IDENTIFIER_SET.add(END);
        IDENTIFIER_SET.add(SEMICOLON);
    }

    // 下一个定义或申明的同步集
    static final EnumSet<PascalTokenType> NEXT_START_SET =
        DeclarationsParser.ROUTINE_START_SET.clone();
    static {
        NEXT_START_SET.add(IDENTIFIER);
        NEXT_START_SET.add(SEMICOLON);
    }

    public void parse(Token token)
        throws Exception
    {
        token = synchronize(IDENTIFIER_SET);

        // 遍历由分号分割的一系列变量申明
        while (token.getType() == IDENTIFIER) {

            //解析每一个子表标识申明，比如 a,b,c : int
            parseIdentifierSublist(token);

            token = currentToken();
            TokenType tokenType = token.getType();

            // 一个定义由分号结束
            if (tokenType == SEMICOLON) {
                while (token.getType() == SEMICOLON) {
                    token = nextToken();  // consume the ;
                }
            }else if (NEXT_START_SET.contains(tokenType)) {
                //没有分号便开始下一个了。
                errorHandler.flag(token, MISSING_SEMICOLON, this);
            }

            token = synchronize(IDENTIFIER_SET);
        }
    }

方法parse()循环的解析由分号; 连接起来的符号申明。它调用parseIdentifierSublist()解析任意一个或用逗号隔开的多个标识符形成的子表以及它们的类型说明。参见清单9-31：

// 子表标识同步集，这里a,b,c: int 中的a,b,c算作子表
  static final EnumSet<PascalTokenType> IDENTIFIER_START_SET =
      EnumSet.of(IDENTIFIER, COMMA);

  // 标识符后的同步集
  private static final EnumSet<PascalTokenType> IDENTIFIER_FOLLOW_SET =
      EnumSet.of(COLON, SEMICOLON);
  static {
      IDENTIFIER_FOLLOW_SET.addAll(DeclarationsParser.VAR_START_SET);
  }

  // 逗号的同步集
  private static final EnumSet<PascalTokenType> COMMA_SET =
      EnumSet.of(COMMA, COLON, IDENTIFIER, SEMICOLON);

  /**
   * 解析标识符子表及类型说明
   * @param token the current token.
   * @return 一个申明中的子表标识符列表
   * @throws Exception
   */
  protected ArrayList<SymTabEntry> parseIdentifierSublist(Token token)
      throws Exception
  {
      ArrayList<SymTabEntry> sublist = new ArrayList<SymTabEntry>();

      do {
          token = synchronize(IDENTIFIER_START_SET);
          SymTabEntry id = parseIdentifier(token);

          if (id != null) {
              sublist.add(id);
          }

          token = synchronize(COMMA_SET);
          TokenType tokenType = token.getType();

          // 找逗号
          if (tokenType == COMMA) {
              token = nextToken(); //有逗号吞掉以便下一个

              if (IDENTIFIER_FOLLOW_SET.contains(token.getType())) {
                  errorHandler.flag(token, MISSING_IDENTIFIER, this);
              }
          }else if (IDENTIFIER_START_SET.contains(tokenType)) {
              errorHandler.flag(token, MISSING_COMMA, this);
          }
      } while (!IDENTIFIER_FOLLOW_SET.contains(token.getType()));

      //冒号后面的类型
      TypeSpec type = parseTypeSpec(token);

      //将子表中的每个变量的类型设置上，比如a,b,c:int，先解析了a,b,c，然后解析了int类型
      //那么这儿就会给a,b,c设置上int类型
      for (SymTabEntry variableId : sublist) {
          variableId.setTypeSpec(type);
      }

      return sublist;
  }

方法parseIndentifierSublist()遍历冒号:之前以逗号隔开的变量标识子表（比如 a,b,c : int)，接着调用parseIndentifier()解析每个标识符。然后它调用parseTypeSpec解析类型说明。代码55行处的for循环遍历子表中的符号表项并设置类型说明。清单9-32 展示了parseIndentifier()和parseTypeSpec()。

/**
 * 解析标识符
 * @param token
 * @return 对应符号表项
 * @throws Exception
 */
private SymTabEntry parseIdentifier(Token token)
    throws Exception
{
    SymTabEntry id = null;

    if (token.getType() == IDENTIFIER) {
        String name = token.getText().toLowerCase();
        id = symTabStack.lookupLocal(name);

        //申明必须得没有，否则重定义了
        if (id == null) {
            id = symTabStack.enterLocal(name);
            id.setDefinition(definition);
            id.appendLineNumber(token.getLineNumber());
        }
        else {
            errorHandler.flag(token, IDENTIFIER_REDEFINED, this);
        }

        token = nextToken();
    }
    else {
        errorHandler.flag(token, MISSING_IDENTIFIER, this);
    }

    return id;
}

// 类型冒号处的同步集
private static final EnumSet<PascalTokenType> COLON_SET =
    EnumSet.of(COLON, SEMICOLON);

/**
 * 解析变量申明里的类型
 * @param token 当前token
 * @return 类型说明
 * @throws Exception
 */
protected TypeSpec parseTypeSpec(Token token)
    throws Exception
{
    // 同步在:处
    token = synchronize(COLON_SET);
    if (token.getType() == COLON) {
        token = nextToken(); // 吞掉 :
    }
    else {
        errorHandler.flag(token, MISSING_COLON, this);
    }

    // 解析类型说明
    TypeSpecificationParser typeSpecificationParser =
        new TypeSpecificationParser(this);
    TypeSpec type = typeSpecificationParser.parse(token);

    return type;
}

方法parseIndentifier()解析每个变量标识并将其放入符号表中。它检查此变量在当前作用域中是否被重定义。最后设置表项的定义并附加当前代码行数。

方法parseTypeSpec()调用typeSpecificationParser.parse()解析并返回类型说明（当然是变量的）。

设计笔记

你已经去掉了第6章所使用的前三个hack技巧。源程序中的每个变量现在都有一个数据类型，此为#1；每个被申明的变量都被放到了符号表，此为#2；第三条hack技巧再也不需要了，因为现在栈上有了不止一个符号表。

程序 9：Pascal交叉引用II

现在让我们来分别扩展一下在第4，5章开发的交叉引用和分析树打印程序。不过首先得改一下主类Pascal的构造函数，如清单9-33所显示。中间码变量iCode来自于主程序函数标识符的符号表项的ROUTINE_ICODE属性值。

if (parser.getErrorCount() == 0) {
        stack = parser.getSymTabStack();

        SymTabEntry programId = stack.getProgramId();
        iCode = (ICode) programId.getAttribute(SymTabKeyImpl.ROUTINE_ICODE);

        if (xref) {
            CrossReferencer crossReferencer = new CrossReferencer();
            crossReferencer.print(stack);
        }

        if (intermediate) {
            ParseTreePrinter treePrinter =
                                 new ParseTreePrinter(System.out);
            treePrinter.print(stack);
        }
        //后端处理
        backend.process(iCode, stack);
    }

（这儿的代码参考SVN源代码第68行-86行）

设计笔记

这儿的交叉引用工具不是仅本身有用，更有用的是它的完整版本，它为主程序、记录类型定义、每个过程和函数，对符号表内容执行关键验证。
本章开发所需要的代码和数据结构跟符号表一样复杂，这意味着交叉引用工具得确保所有数据和引用正确，那样你才有信心认为后端依赖符号表的执行器和生成器能够正常工作。

清单9-34 展示了工具类CrossReferencer中的print()，printColumnHeadings()以及printSymTab()方法，还有一个新增的printRoutine()。（请参考工程源代码，这里不再展示）

方法print()调用symTabStack.getProgramId()得到Pascal程序标识符对应的符号表项，接着调用printRoutine()。

方法printRoutine()先获得 程式标识表项的ROUTINE_SYMTAB属性值，这个值是符号表，存有此程式中定义的所有标识符。方法接着调用printSymTab答应符号表内容并创建一个程式中定义的所有记录类型数组列表。方法printRecords()答应出这些记录类型的详细信息。最后，方法printRoutine()调用自身递归的处理所有嵌套过程和函数定义。

除了简单打印每个符号表项的标识符名称和所在行数之外，方法printSymTab同时还得调用printEntry()打印每个项的类容。

清单9-35展示了方法printEntry()和valueToString()。（请参考工程源代码，这里不再展示）

方法printEntry()调用printType()答应标识符的类型说明。接着打印符号表中与此标识符定义有关的信息。对于常量标识符和枚举常量，它打印出常量值；对于类型，在其被首次定义的时候，调用printTypeDetail打印此类型标识符的详细信息；对于标量标识符，它仅在变量类型是匿名的情况下才调用printTypeDetails。（这个很容易理解，因为如果不是匿名的，肯定在前面的类型定义中首次定义的时候被打印过了，再打印多余，只有匿名才每次都是一个新类型）。

清单9-36 展示了方法printType和printTypeDetail。（请参考工程源代码，这里不再展示）

printTypeDetail()方法答应的类型信息取决于类型格式。对于枚举类型，它打印出枚举常量和它们的值。对于子界(Subrange)类型，它打印基类型以及上限和下限值。对于数组类型，它打印的信息有索引类型和元素类型。最后，对于记录类型来说，方法简单将此记录类型说明放到参数记录类型列表中。

对于列表中的每个记录类型说明，方法printRecords()取得RECORD_SYMTAB属性值，这个值是包含记录类型的所有字段的符号表。方法printSymTab打印字段交叉引用清单。此方法还递归调用自己打印所有嵌套的记录类型定义。

/**
    * 打印程式中定义的记录类型
    */
   private void printRecords(ArrayList<TypeSpec> recordTypes)
   {
       for (TypeSpec recordType : recordTypes) {
           SymTabEntry recordId = recordType.getIdentifier();
           String name = recordId != null ? recordId.getName() : "<匿名>";

           System.out.println("\n--- 记录类型  " + name + " ---");
           printColumnHeadings();

           // 打印记录所对应符号表中的项
           SymTab symTab = (SymTab) recordType.getAttribute(TypeKeyImpl.RECORD_SYMTAB);
           ArrayList<TypeSpec> newRecordTypes = new ArrayList<TypeSpec>();
           printSymTab(symTab, newRecordTypes);

           // 记录定义里面嵌套的记录
           if (newRecordTypes.size() > 0) {
               printRecords(newRecordTypes);
           }
       }
   }

方法printEntry，printType()和printTypeDetails一起为每个标识符打印出交叉引用以及类型信息。下面是每种各种类型表示的样例输出。（这里纯属作者凑字数，我这里省略，请读者自己运行Pascal程序查看各种输出）。

清单9-38 展示了源程序文件declarations.txt的交叉应用输出。命令行为

java -classpath classes Pascal execute -x declarations.txt

因为你还有修改任何语句解析器，此源文件仅仅包含一个“空”的复合语句。(这个输出有500多行，省略，请自己生成看看结果，这儿输出一些片段)

001 CONST
002     ten = 10;
003     epsilon = 1.0E-6;
004     x = 'x';
005     limit = -epsilon;
006     hello = 'Hello, world!';
007
008 TYPE
009     range1 = 0..ten;
010     range2 = 'a'..'q';
011     range3 = range1;
012
...............
省略
...............
048
049     var10 : rec1;
050     var11 : RECORD
051                 b : boolean;
052                 r : RECORD
053                         aa : ar1;
054                         bb : boolean;
055                         r  : real;
056                         v1 : ar6;
057                         v2 : ARRAY [enum1, range1] OF ar7;
058                     END;
059                 a : ARRAY [1..5] OF boolean;
060             END;
061
...............
省略
...............
068
069 BEGIN
070 END.

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

============ 交叉引用列表  ========

*** PROGRAM dummyprogramname ***

标识符           所在行位置      类型说明
----------   ------------    ------------------
a            013
                             定义: 枚举常量
                             嵌套层级: 1
                             类型格式 = 枚举, 类型ID = enum1
                             值为 0
alpha        022
                             定义: 枚举常量
                             嵌套层级: 1
                             类型格式 = 枚举, 类型ID = <匿名>
                             值为 0
ar1          021 023 053 062
                             定义: 类型
                             嵌套层级: 1
                             类型格式 = 数组, 类型ID = ar1
                             --- 索引类型  ---
                             类型格式 = 子界, 类型ID = range1
                             --- 元素类型 ---
                             类型格式 = 标量, 类型ID = integer
                             共有11 个元素
ar2          022
                             定义: 类型
                             嵌套层级: 1
                             类型格式 = 数组, 类型ID = ar2
                             --- 索引类型  ---
                             类型格式 = 枚举, 类型ID = <匿名>
                             --- 枚举常量 ---
                                    alpha = 0
                                     beta = 1
                                    gamma = 2
                             --- 元素类型 ---
                             类型格式 = 子界, 类型ID = range2
                             共有3 个元素
...............
省略
...............
x            004
                             定义: 常量
                             嵌套层级: 1
                             类型格式 = 标量, 类型ID = char
                             值为 'x'

--- 记录类型  <匿名> ---

标识符           所在行位置      类型说明
----------   ------------    ------------------
a            038
                             定义: 记录域
                             嵌套层级: 2
                             类型格式 = 数组, 类型ID = <匿名>
r            037
                             定义: 记录域
                             嵌套层级: 2
                             类型格式 = 记录, 类型ID = rec1
ten          036
                             定义: 记录域
                             嵌套层级: 2
                             类型格式 = 标量, 类型ID = integer

--- 记录类型  rec1 ---

标识符           所在行位置      类型说明
----------   ------------    ------------------
b1           031
                             定义: 记录域
                             嵌套层级: 2
                             类型格式 = 枚举, 类型ID = boolean
b2           031
                             定义: 记录域
                             嵌套层级: 2
                             类型格式 = 枚举, 类型ID = boolean
c            032
                             定义: 记录域
                             嵌套层级: 2
                             类型格式 = 标量, 类型ID = char
i            029
                             定义: 记录域
                             嵌套层级: 2
                             类型格式 = 标量, 类型ID = integer
r            030
                             定义: 记录域
                             嵌套层级: 2
                             类型格式 = 标量, 类型ID = real
...............
省略
...............

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

清单9-39 展示了申明解析过程中的语法检查输出，请执行 java -classpath classes Pascal execute -x declerrors.txt (请自己运行查看结果，这里不再展示输出)

清单9-40 列出了ParseTreePrinter的print()和printRountine()方法。

/**
    * 打印中间码
    * @param symTabStack 符号表堆栈
    */
   public void print(SymTabStack symTabStack)
   {
       ps.println("\n===== INTERMEDIATE CODE =====");

       SymTabEntry programId = symTabStack.getProgramId();
       printRoutine(programId);
   }
   /**
    * 打印程式
    * @param routineId 程式所对应的符号表项
    */
   private void printRoutine(SymTabEntry routineId)
   {
       Definition definition = routineId.getDefinition();
       System.out.println("\n*** " + definition.toString() +
                          " " + routineId.getName() + " ***\n");

       // 表项上的中间码
       ICode iCode = (ICode) routineId.getAttribute(SymTabKeyImpl.ROUTINE_ICODE);
       if (iCode.getRoot() != null) {
           printNode((ICodeNodeImpl) iCode.getRoot());
       }

       // 打印在程式中定义的过程和函数
       ArrayList<SymTabEntry> routineIds =
           (ArrayList<SymTabEntry>) routineId.getAttribute(SymTabKeyImpl.ROUTINE_ROUTINES);
       if (routineIds != null) {
           for (SymTabEntry rtnId : routineIds) {
               printRoutine(rtnId);
           }
       }
   }

方法print()现在用一个符号表栈作为参数，因为你把每个程式的中间码存放在程式名称对用的符号表项上（即23行处的ROUTINE_ICODE属性)。

在第十章中，你将修改Pascal语句解析器，用来处理数组变量，记录变量，还有完善类型检查。