(基于Java)编写编译器和解释器第7章：解析(Parsing)控制语句第二部分(连载)

续 第一部分

  解析FOR语句

Pascal FOR语句稍微有些麻烦。语句解析器子类ForStatementParser的parse()方法解析如下语句：

FOR k := j TO 5 DO n := k

会产生如图7-5展示的分析树。

这个分析树的根是一个COMPOUND节点。此COMPOUND节点的第一个孩子是嵌套的赋值语句子树，用来初始化控制变量；第二个孩子是一个LOOP节点。

LOOP节点的第一个孩子是一个TEST节点。TEST节点的孩子视FOR语句是TO或DOWNTO类型分别对应GT或LT关系表达式子树，这个子树对照限值(这里是5）测试控制变量的值。LOOP节点的第二个孩子是嵌套的语句子树。如果是TO，控制变量按单位1递增，第三个孩子将是一个ADD算术表达式节点；否则控制变量递减，第三个孩子是一个SUBSTRACT(减)节点。

清单7-11 展示了ForStatementParser中的parse()方法（这个代码多了起来)。

// TO和DOWNTO同步集合 for expr ->to|downto CONST do stmt
  private static final EnumSet<PascalTokenType> TO_DOWNTO_SET =
      ExpressionParser.EXPR_START_SET.clone();
  static {
      TO_DOWNTO_SET.add(TO);
      TO_DOWNTO_SET.add(DOWNTO);
      TO_DOWNTO_SET.addAll(StatementParser.STMT_FOLLOW_SET);
  }
  // DO同步集合for expr to|downto CONST ->do stmt
  private static final EnumSet<PascalTokenType> DO_SET =
      StatementParser.STMT_START_SET.clone();
  static {
      DO_SET.add(DO);
      DO_SET.addAll(StatementParser.STMT_FOLLOW_SET);
  }
  //发生的变量节点拷贝可以认为是源节点和拷贝节点树中关系不一样，但是一些属性
  //比如对应的符号表项还是一样的引用。
  public ICodeNode parse(Token token)
      throws Exception
  {
      token = nextToken();
      Token targetToken = token;
      //参见图7-11
      ICodeNode compoundNode = ICodeFactory.createICodeNode(COMPOUND);
      ICodeNode loopNode = ICodeFactory.createICodeNode(LOOP);
      ICodeNode testNode = ICodeFactory.createICodeNode(TEST);
      // 初始赋值语句，调用一次
      AssignmentStatementParser assignmentParser =
          new AssignmentStatementParser(this);
      ICodeNode initAssignNode = assignmentParser.parse(token);
      setLineNumber(initAssignNode, targetToken);
      compoundNode.addChild(initAssignNode);
      //循环主体的复合节点
      compoundNode.addChild(loopNode);
      //同步在TO/DOWNTO处
      token = synchronize(TO_DOWNTO_SET);
      TokenType direction = token.getType();
      if ((direction == TO) || (direction == DOWNTO)) {
          token = nextToken();
      }
      else {
          direction = TO;
          errorHandler.flag(token, MISSING_TO_DOWNTO, this);
      }
      //根据TO/DOWNTO创建判断表达式GT或LT
      ICodeNode relOpNode = ICodeFactory.createICodeNode(direction == TO
                                                         ? GT : LT);
      //拷贝初始变量语句中的左边变量成为关系表达式的左边
      ICodeNode controlVarNode = initAssignNode.getChildren().get(0);
      relOpNode.addChild(controlVarNode.copy());
      //TO或DOWNTO的限值表达式，成为关系表达式的右边
      ExpressionParser expressionParser = new ExpressionParser(this);
      relOpNode.addChild(expressionParser.parse(token));
      //loop-->test-->relop三层
      testNode.addChild(relOpNode);
      loopNode.addChild(testNode);
      // 在DO处同步
      token = synchronize(DO_SET);
      if (token.getType() == DO) {
          token = nextToken();
      }
      else {
          errorHandler.flag(token, MISSING_DO, this);
      }
      //循环的主体语句
      StatementParser statementParser = new StatementParser(this);
      loopNode.addChild(statementParser.parse(token));
      //创建一个根据TO|DOWNTO来递增或递减控制变量的表达式。控制变量:=控制变量+/- 1;
      ICodeNode nextAssignNode = ICodeFactory.createICodeNode(ASSIGN);
      nextAssignNode.addChild(controlVarNode.copy());
      ICodeNode arithOpNode = ICodeFactory.createICodeNode(direction == TO
                                                           ? ADD : SUBTRACT);
      //递减发生在控制变量上，要拷贝。
      arithOpNode.addChild(controlVarNode.copy());
      ICodeNode oneNode = ICodeFactory.createICodeNode(INTEGER_CONSTANT);
      oneNode.setAttribute(VALUE, 1);
      arithOpNode.addChild(oneNode);
      //将递增/递减后的值付给控制变量
      nextAssignNode.addChild(arithOpNode);
      loopNode.addChild(nextAssignNode);
      setLineNumber(nextAssignNode, targetToken);
      return compoundNode;
  }

parse()方法创建COMPOUND，LOOP和TEST节点并构建如图7-5所示的分析树。它使用同步集合TO_DOWNTO_SET在TO或DOWNTO token处同步自己，用同步集合DO_SET在DO处同步自己。此方法为"initial"和"next" ASSIGN节点都设置了源代码行位置信息。

这个方法记得TO或DOWNTO设置。如果是TO，它生成一个GT(大于)关系操作符节点和一个ADD算术符节点；否则生成相反的LT和SUBTRACT节点。

在Eclipse中运行Pascal，使用参数"compile -i for.txt"，查看正确的输出结果。使用参数"compile -i forerrors.txt"，查看带错误的输出结果。这里省略输出结果。

设计笔记

LOOP节点容许中间码以一种语言无关的方式匹配各种不同花样的循环结构(WHILE/DO WHILE/REPEAT/FOR)

解析IF语句

语句分析器子类IfStatementParser解析Pascal IF语句并生成它的分析树。比如语句：

IF (i = j) THEN 
    t := 200
ELSE 
    f := -200;

类的parse()方法将生成如图7-6所示的分析树

IF节点有两个或三个孩子节点。第一个是比较表达式子树，第二个是THEN后的嵌套语句子树。如果还有一个ELSE部分，第三个将会是ELSE嵌套语句的子树。

清单7-14展示了IfStatementParser的parse()方法

// THEN的同步集合
   private static final EnumSet<PascalTokenType> THEN_SET =
       StatementParser.STMT_START_SET.clone();
   static {
       THEN_SET.add(THEN);
       THEN_SET.addAll(StatementParser.STMT_FOLLOW_SET);
   }

   public ICodeNode parse(Token token)
       throws Exception
   {
       token = nextToken();
       ICodeNode ifNode = ICodeFactory.createICodeNode(ICodeNodeTypeImpl.IF);
       //IF语句的条件表达式
       ExpressionParser expressionParser = new ExpressionParser(this);
       ifNode.addChild(expressionParser.parse(token));
       // THEN处同步一下
       token = synchronize(THEN_SET);
       if (token.getType() == THEN) {
           token = nextToken();
       }
       else {
           errorHandler.flag(token, MISSING_THEN, this);
       }
       //THEN后的语句
       StatementParser statementParser = new StatementParser(this);
       ifNode.addChild(statementParser.parse(token));
       token = currentToken();
       //试探后没有ELSE语句
       if (token.getType() == ELSE) {
           token = nextToken();
           ifNode.addChild(statementParser.parse(token));
       }
       return ifNode;
   }

在Eclipse中运行Pascal，使用参数"compile -i if.txt"，查看正确的输出结果。使用参数"compile -i iferrors.txt"，查看带错误的输出结果。这里省略输出结果。做个补充演示：

按照左边图设置之后看运行输出，留意级联的IF THEN ELSE语句。在每个ELSE IF 分支处，嵌套的IF语句被当做另一个语句。(这个特性跟Java的一样)。

著名的"dangling ELSE"很容易出问题(dangling else意思说如果if xxx then yyy if mmm then nnn else kkk，这儿出现了else到底是被解释成第一个if语句的一部分还是第二个if语句的一部分？摇摆不定啊，通用的做法是紧贴近最里层的if，即第二个if）。在源文件(if.txt)第17行处，ELSE可以跟第一个和第二个THEN配对。遵照语法图7-1，IF语句

IF (j = 2) THEN t := 500 ELSE f := -500

是THEN语句的嵌套子句，即 IF (i = 1) THEN 嵌套子句。因此，ELSE与第二个THEN配对。

 

  解析CASE语句

CASE语句是Pascal控制语句解析中最有挑战的一个。语句解析器子类CaseStatementParser解析CASE语句并生成它的分析树，比如语句：

CASE i+1 OF
    1:       j := i;
    4:       j := 4*i;
    5, 2, 3: j := 523*i;
END

类的parse()方法生成如图7-7所示的分析树。

我们看看类的parse()方法

//一个CASE条件分支的起始同步集合
   private static final EnumSet<PascalTokenType> CONSTANT_START_SET =
       EnumSet.of(IDENTIFIER, INTEGER, PLUS, MINUS, STRING);

   // OF同步集合
   private static final EnumSet<PascalTokenType> OF_SET =
       CONSTANT_START_SET.clone();
   static {
       OF_SET.add(OF);
       OF_SET.addAll(StatementParser.STMT_FOLLOW_SET);
   }
   public ICodeNode parse(Token token)
       throws Exception
   {
       //干掉开头的CASE
       token = nextToken();
       ICodeNode selectNode = ICodeFactory.createICodeNode(SELECT);
       //CASE表达式
       ExpressionParser expressionParser = new ExpressionParser(this);
       selectNode.addChild(expressionParser.parse(token));
       //同步OF
       token = synchronize(OF_SET);
       if (token.getType() == OF) {
           token = nextToken();  // consume the OF
       }
       else {
           errorHandler.flag(token, MISSING_OF, this);
       }
       //分支选项集合
       HashSet<Object> constantSet = new HashSet<Object>();
       while (!(token instanceof EofToken) && (token.getType() != END)) {
           selectNode.addChild(parseBranch(token, constantSet));
           token = currentToken();
           TokenType tokenType = token.getType();
           // 一个分支以分号';'结束
           if (tokenType == SEMICOLON) {
               token = nextToken();
           }
           else if (CONSTANT_START_SET.contains(tokenType)) {
               errorHandler.flag(token, MISSING_SEMICOLON, this);
           }
       }
       //CASE expr OF branches END
       if (token.getType() == END) {
           token = nextToken();
       }
       else {
           errorHandler.flag(token, MISSING_END, this);
       }

       return selectNode;
   }

同步集合CONSTANT_START_SET包含所有能开始一个CASE常量的token类型(比如CASE xxx OF 1: dosomething; 2: doanything; end中的1，2处的同步检测)。parse()方法创建一个SELECT节点，在解析过CASE的表达式后，它用同步集合OF_SET将自己同步在OF token处。while循环调用parseBranch解析每一个CASE分支，接着寻找分号(结束一个分支)。循环在遇到END token退出。此方法返回这个SELECT节点。

清单7-18 展示了CaseStatementParser中的parseBranch()方法

private ICodeNode parseBranch(Token token, HashSet<Object> constantSet)
    throws Exception
{
    //每个分支都有一个SELECT_BRANCH节点，constantsNode是第一个孩子
    ICodeNode branchNode = ICodeFactory.createICodeNode(SELECT_BRANCH);
    ICodeNode constantsNode =ICodeFactory.createICodeNode(SELECT_CONSTANTS);
    branchNode.addChild(constantsNode);
    //解析常量列表，每个常量节点是是constantNode的子节点)
    parseConstantList(token, constantsNode, constantSet);
    //查找分支冒号
    token = currentToken();
    if (token.getType() == COLON) {
        token = nextToken();
    }
    else {
        errorHandler.flag(token, MISSING_COLON, this);
    }
    //冒号:后面的语句
    StatementParser statementParser = new StatementParser(this);
    branchNode.addChild(statementParser.parse(token));
    return branchNode;
}

parseBranch()方法在调用parseConstantList()方法之前，创建一个SELECT_BRANCH和一个SELECT_CONSTANTS节点。解析完常量列表后，查找后面的冒号。SELECT_CONSTANTS节点收纳这些常量节点，它本身变成SELECT_BRANCH节点的第一个孩子。接着调用一次statementParser().parse()解析分支语句，这个分支语句的子树根节点成为SELECT_BRANCH节点的第二个子节点。

清单7-19 展示了parseConstantList()方法

private void parseConstantList(Token token, ICodeNode constantsNode,
                                  HashSet<Object> constantSet)
       throws Exception
   {
       // 遍历每一个常量
       while (CONSTANT_START_SET.contains(token.getType())) {
           constantsNode.addChild(parseConstant(token, constantSet));
           token = synchronize(COMMA_SET);
           // 常量以','隔开
           if (token.getType() == COMMA) {
               token = nextToken();
           }
           else if (CONSTANT_START_SET.contains(token.getType())) {
               errorHandler.flag(token, MISSING_COMMA, this);
           }
       }
   }

parseConstantList()方法解析被逗号分隔的常量列表(1,2,3,4等)，它调用parseConstant()解析每一个常量。在本章中，parseConstant()能通过调用parseIntegerConstant()解析整数常量（常量前可能有+或-的符号位)，还有通过调用parseCharacterConstant()解析字符常量。因为你还是没有解析常量声明，名称常量(标识符token)是不被允许的，后面会解决（引入常量声明之后，比如const a :=1，可以在第9章之后)。
解析常量的代码过于简单，跟解析常量token类似，这里不演示了，有兴趣可以看源代码的第153到268行

这里对CASE分支常量要强调的2点是：

• 一个分支常量可以是一个整数或者单个的字符，比如1,2,3: 或 'a','b','c:
• CASE语句中的分支常量不能被使用多次，只能使用一次。

在Eclipse中运行Pascal，使用参数"compile -i case.txt"，查看正确的输出结果。使用参数"compile -i caseerrors.txt"，查看带错误的输出结果。这里省略输出结果。

本章完.