(基于Java)编写编译器和解释器-第10章：类型检查-第二部分

续 第一部分

控制语句中的类型检查

因为Pascal控制语句中有表达式，所以它们的解析器同样需要做类型检查。

清单10-2 展示了语句解析子类AssignmentStatementParser新版本的parse()方法。（留意加粗部分）

/**
 * 解析如 a = xx+yy; 之类的赋值语句
 * 会有左值/右值两个子节点，并且节点类型与左值类型保持一致
 * @param token
 *            第一个token，肯定是identifier了。
 * @return 语句子树根节点
 * @throws Exception
 */
public ICodeNode parse(Token token) throws Exception {
    ICodeNode assignNode = ICodeFactory.createICodeNode(ASSIGN);
    //交由变量解析左边的变量
    VariableParser variableParser = new VariableParser(this);
    ICodeNode targetNode = variableParser.parse(token);
    TypeSpec targetType = targetNode != null ? targetNode.getTypeSpec()
                                             : Predefined.undefinedType;
    assignNode.addChild(targetNode);
    //等号处同步
    token = synchronize(COLON_EQUALS_SET);
    // 找不到赋值:=就报错，找到就吞噬
    if (token.getType() == COLON_EQUALS) {
        token = nextToken();
    } else {
        errorHandler.flag(token, MISSING_COLON_EQUALS, this);
    }
    // 解析赋值语句右边的表达式，将其子树作为赋值节点的第二个孩子
    ExpressionParser expressionParser = new ExpressionParser(this);
    ICodeNode exprNode = expressionParser.parse(token);
    assignNode.addChild(exprNode);
    //左值变量，右值表达式，是否能赋值兼容。
     TypeSpec exprType = exprNode != null ? exprNode.getTypeSpec()
             : Predefined.undefinedType;
     if (!TypeChecker.areAssignmentCompatible(targetType, exprType)) {
        errorHandler.flag(token, PascalErrorCode.INCOMPATIBLE_TYPES, this);
    }
    assignNode.setTypeSpec(targetType);
    return assignNode;
}

parse()方法调用variableParser.parse()解析目标类型，并调用TypeChecker.areAssignmentCompatible()检查目标变量的类型是否与表达式返回类型保持赋值兼容。它设置ASSIGN节点的类型为目标变量的类型（第35行）。

类class RepeatStatementParser中的新parse()方法同样加了类型检查。它调用s TypeChecker.isBoolean()确保标识是布尔类型。

清单10-13 RepeatStatementParser中parse()方法的类型检查（参见工程源代码 46行处）

ExpressionParser expressionParser = new ExpressionParser(this);
ICodeNode exprNode = expressionParser.parse(token);
testNode.addChild(exprNode);
loopNode.addChild(testNode);//最后一个子节点

TypeSpec exprType = exprNode != null ? exprNode.getTypeSpec()
        : Predefined.undefinedType;
if (!TypeChecker.isBoolean(exprType)) {
    errorHandler.flag(token, INCOMPATIBLE_TYPES, this);
}

WhileStatementParser类中的parse()方法做了类似的更新。它也调用了TypeChecker.isBoolean()确保表达式是布尔类型。参见下面的清单10-14（参见工程源代码53行处）

ExpressionParser expressionParser = new ExpressionParser(this);
ICodeNode exprNode = expressionParser.parse(token);
notNode.addChild(exprNode);

 TypeSpec exprType = exprNode != null ? exprNode.getTypeSpec()
         : Predefined.undefinedType;
if (!TypeChecker.isBoolean(exprType)) {
    errorHandler.flag(token, INCOMPATIBLE_TYPES, this);
}

用类似的搞法，清单10-15、10-16、10-17分别展示ForStatementParser、IfStatementParse和CaseStatementParser中的新版本parse()方法。

清单10-15 类ForStatementParser中parse()方法的类型检查（为省空间，我只贴改变的部分，详细请参考工程源代码）

//第77-84行
TypeSpec controlType = initAssignNode != null
                ? initAssignNode.getTypeSpec()
                : Predefined.undefinedType;
//for语句的初始变量一定得是一个整数或者枚举
if (!TypeChecker.isInteger(controlType)
       && (controlType.getForm() != TypeFormImpl.ENUMERATION)) {
     errorHandler.flag(token, PascalErrorCode.INCOMPATIBLE_TYPES, this);
}
//第101行
relOpNode.setTypeSpec(Predefined.booleanType); //关系默认为布尔类型
//第109-114行
TypeSpec exprType = exprNode != null ? exprNode.getTypeSpec()
                 : Predefined.undefinedType;
//控制变量能够与表达式类型赋值兼容，不然无法复制
if (!TypeChecker.areAssignmentCompatible(controlType, exprType)) {
    errorHandler.flag(token, PascalErrorCode.INCOMPATIBLE_TYPES, this);
}
//第131行
nextAssignNode.setTypeSpec(controlType);
//第135行
arithOpNode.setTypeSpec(Predefined.integerType);
//第140行
oneNode.setTypeSpec(Predefined.integerType);

FOR语句的变量类型必须是整数，字符或枚举。parse()方法调用assignmentParser.parse()，赋值语句的parse()为控制变量和初始表达式执行类型检查。此方法调用TypeChecker.areAssignmentCompatible()验证结束表达式(Pascal表达式 FOR i = 0 to 5 DO expr; 中的红色部分为结束表达式，在TO|DOWNTO 和DO之间）。

清单10-16 类IfStatementParser方法parse()中的类型检查（工程源代码46行处)

ExpressionParser expressionParser = new ExpressionParser(this);
ICodeNode exprNode = expressionParser.parse(token);
ifNode.addChild(exprNode);

// Type check: The expression type must be boolean.
TypeSpec exprType = exprNode != null ? exprNode.getTypeSpec()
                                     : Predefined.undefinedType;
if (!TypeChecker.isBoolean(exprType)) {
    errorHandler.flag(token, INCOMPATIBLE_TYPES, this);
}

CaseStatementParser中改进过的parse()方法必须保证case表达式类型一定是整形，字符或者枚举类型。

ExpressionParser expressionParser = new ExpressionParser(this);
        ICodeNode exprNode = expressionParser.parse(token);
        selectNode.addChild(exprNode);
        TypeSpec exprType = exprNode != null ? exprNode.getTypeSpec()
                : Predefined.undefinedType;
if (!TypeChecker.isInteger(exprType)
        && !TypeChecker.isChar(exprType)
        && (exprType.getForm() != TypeFormImpl.ENUMERATION))
{
    errorHandler.flag(token, INCOMPATIBLE_TYPES, this);
}

方法parseConstant()现在要设置常量节点的类型。它调用TypeChecker.areComparisonCompatible()检查每个常量值是否与case表达式的类型达到比较兼容。参见清单10-18

switch ((PascalTokenType) token.getType()) {

          case IDENTIFIER: {//未实现
              constantNode = parseIdentifierConstant(token, sign);
              if (constantNode != null) {
                  constantType = constantNode.getTypeSpec();
              }
              break;
          }

          case INTEGER: {
              constantNode = parseIntegerConstant(token.getText(), sign);
              constantType = Predefined.integerType;
              break;
          }

          case STRING: {
              constantNode =
                  parseCharacterConstant(token, (String) token.getValue(),
                                         sign);
              constantType = Predefined.charType;
              break;
          }

          default: {
              errorHandler.flag(token, INVALID_CONSTANT, this);
              break;
          }
      }
if (!TypeChecker.areComparisonCompatible(exprType,
              constantType)) {
          errorHandler.flag(token, INCOMPATIBLE_TYPES, this);
      }
constantNode.setTypeSpec(constantType);

清单10-19 展示了parseIdentifierConstant()方法，现在它解析每一个是标识符的分支常量。

/**
 * 解析标识符常量，并判断类型是否与整数兼容
 * @param token 常量token
 * @param sign 符号token
 * @return 常量节点
 */
private ICodeNode parseIdentifierConstant(Token token, TokenType sign)
    throws Exception
{
    ICodeNode constantNode = null;
    TypeSpec constantType = null;

    // 符号表堆栈中查找此常量标识符
    String name = token.getText().toLowerCase();
    SymTabEntry id = symTabStack.lookup(name);

    //如果未定义，直接结束
    if (id == null) {
        id = symTabStack.enterLocal(name);
        id.setDefinition(DefinitionImpl.UNDEFINED);
        id.setTypeSpec(Predefined.undefinedType);
        errorHandler.flag(token, PascalErrorCode.IDENTIFIER_UNDEFINED, this);
        return null;
    }

    Definition defnCode = id.getDefinition();

    // 常量标识符是否符合定义
    if ((defnCode == DefinitionImpl.CONSTANT) || (defnCode == DefinitionImpl.ENUMERATION_CONSTANT)) {
        Object constantValue = id.getAttribute(SymTabKeyImpl.CONSTANT_VALUE);
        constantType = id.getTypeSpec();

        // 与整数兼容才行
        if ((sign != null) && !TypeChecker.isInteger(constantType)) {
            errorHandler.flag(token, INVALID_CONSTANT, this);
        }

        constantNode = ICodeFactory.createICodeNode(INTEGER_CONSTANT);
        constantNode.setAttribute(VALUE, constantValue);
    }

    id.appendLineNumber(token.getLineNumber());

    if (constantNode != null) {
        constantNode.setTypeSpec(constantType);
    }

    return constantNode;
}

方法parseIdentifierConstant()验证标识符是一个常量或枚举常量，并检测在标识符钱是否有+或-，还有确保标识符必须是整数类型（或整数兼容）。

CASE语句的另一个改变这次在解释器后端。清单10-20 展示了SelectExecutor中新版本的createJumpTable()方法。对于CASE语句中表达式值为字符的情况，此方法将每个CASE分支常量值在作为键放入跳转表之前，从一个字符串（它仅包含一个字符）转换成一个字符。（改动参见加粗部分）

/**
 * 为某一个SELECT节点根据CASE情况创建静态查找表
 * @param node SELECT节点
 * @return 查找表
 */
private HashMap<Object, ICodeNode> createJumpTable(ICodeNode node)
{
    HashMap<Object, ICodeNode> jumpTable = new HashMap<Object, ICodeNode>();

    // 遍历分支，将常量和语句变成查找表的某一项
    List<ICodeNode> selectChildren = node.getChildren();
    for (int i = 1; i < selectChildren.size(); ++i) {
        ICodeNode branchNode = selectChildren.get(i);
        ICodeNode constantsNode = branchNode.getChildren().get(0);
        ICodeNode statementNode = branchNode.getChildren().get(1);
        //将如1,2,3: xx的三个常量变成三个查找项
        List<ICodeNode> constantsList = constantsNode.getChildren();
        for (ICodeNode constantNode : constantsList) {
            Object value = constantNode.getAttribute(VALUE);
            if (constantNode.getType() == ICodeNodeTypeImpl.STRING_CONSTANT) {
                value = ((String) value).charAt(0);
            }
            jumpTable.put(value, statementNode);
        }
    }
    return jumpTable;
}

程序10：Pascal语法检查器III

语法检查现在包含了类型检查，且解析器能为带下标和字段的变量生成分析树。清单10-21 是下面命令行的输出

java -classpath classes Pascal compile -i block.txt

这个命令用“编译”而不是解析执行，那是因为你还没有为变量编写执行器（executor)。你将在第12章完成这个功能。

清单10-21 带类型检查的Pascal语法检查器的输出。（输出比较庞大，建议自己实验，这里输出一些样例）

001 CONST
002     seven =  7;
003     ten   = 10;
004
//.......省略
053 BEGIN
054     var1[5] := 3.14;
055     var1[var7.i] := var9.rec.flda[e, ten]['q'].fldi;
056
057     IF var9.a[seven-3] THEN var2[beta] := 'x';
058
//.......省略
080     var9.rec.flda[b][0, 'm'].flda[d] := 'p';
081 END.

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

===== 中间码XML展示 =====

*** PROGRAM dummyprogramname ***

<COMPOUND line="53">
    <ASSIGN line="54" type_id="real">
        <VARIABLE id="var1" level="1" type_id="real">
            <SUBSCRIPTS type_id="real">
                <INTEGER_CONSTANT value="5" type_id="integer" />
            </SUBSCRIPTS>
        </VARIABLE>
        <REAL_CONSTANT value="3.14" type_id="real" />
    </ASSIGN>
    //.......省略
    <ASSIGN line="80" type_id="range2">
        <VARIABLE id="var9" level="1" type_id="range2">
            <FIELD id="rec" level="2" type_id="$anon_2adab05" />
            <FIELD id="flda" level="3" type_id="$anon_51a0a458" />
            <SUBSCRIPTS type_id="$anon_cf7e46b">
                <INTEGER_CONSTANT value="1" type_id="enum1" />
            </SUBSCRIPTS>
            <SUBSCRIPTS type_id="$anon_28da9e1">
                <INTEGER_CONSTANT value="0" type_id="integer" />
                <STRING_CONSTANT value="m" type_id="char" />
            </SUBSCRIPTS>
            <FIELD id="flda" level="2" type_id="$anon_480ec542" />
            <SUBSCRIPTS type_id="range2">
                <INTEGER_CONSTANT value="3" type_id="enum1" />
            </SUBSCRIPTS>
        </VARIABLE>
        <STRING_CONSTANT value="p" type_id="char" />
    </ASSIGN>
</COMPOUND>

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

 

上面分析树的输出现在包含了每个有类型说明的类型标识。清单10-22 展示了类ParseTreePrinter(在包util中)的新printTypeSpec()方法。

/**
    * 打印分析树节点的类型说明
    * @param node 某一节点
    */
   private void printTypeSpec(ICodeNodeImpl node)
   {
         TypeSpec typeSpec = node.getTypeSpec();

         if (typeSpec != null) {
             String saveMargin = indentation;
             indentation += indent;

             String typeName;
             SymTabEntry typeId = typeSpec.getIdentifier();

             //有名字
             if (typeId != null) {
                 typeName = typeId.getName();
             }

             // 匿名
             else {
                 int code = typeSpec.hashCode() + typeSpec.getForm().hashCode();
                 typeName = "$anon_" + Integer.toHexString(code);
             }

             printAttribute("TYPE_ID", typeName);
             indentation = saveMargin;
         }
   }

清单10-23 展示了语法检查器中类型检查错误的输出。使用 java -classpath classes Pascal compile -i blockerrors.txt

001 CONST
002     Seven =  7;
003     Ten   = 10;
004
005 TYPE
006     range1 = 0..ten;
007     range2 = 'a'..'q';
008     range3 = range1;
009
010     enum1 = (a, b, c, d, e);
011     enum2 = enum1;
012
013     range4 = b..d;
014
015     arr1 = ARRAY [range1] OF real;
016     arr2 = ARRAY [(alpha, beta, gamma)] OF range2;
017     arr3 = ARRAY [enum2] OF arr1;
018     arr4 = ARRAY [range3] OF (foo, bar, baz);
019     arr5 = ARRAY [range1] OF ARRAY[range2] OF ARRAY[c..e] OF enum2;
020     arr6 = ARRAY [range1, range2, c..e] OF enum2;
021
022     rec7 = RECORD
023                i : integer;
024                r : real;
025                b1, b2 : boolean;
026                c : char
027            END;
028
029     arr8 = ARRAY [range2] OF RECORD
030                                  fldi  : integer;
031                                  fldr : rec7;
032                                  flda : ARRAY[range4] OF range2;
033                              END;
034
035 VAR
036     var1 : arr1;  var5 : arr5;
037     var2 : arr2;  var6 : arr6;
038     var3 : arr3;  var7 : rec7;
039     var4 : arr4;  var8 : arr8;
040
041     var9 : RECORD
042                b   : boolean;
043                rec : RECORD
044                          fld1 : arr1;
045                          fldb : boolean;
046                          fldr : real;
047                          fld6 : arr6;
048                          flda : ARRAY [enum1, range1] OF arr8;
049                      END;
050                a : ARRAY [1..5] OF boolean;
051            END;
052
053 BEGIN
054     var2[a] := 3.14;
             ^
*** 不兼容的类型 [在 "a" 处]
                   ^
*** 不兼容的类型 [在 "3.14" 处]
055     var1[var7.i] := var9.rec.flda['e', ten]['q'].fldr;
                                      ^
*** 不兼容的类型 [在 "'e'" 处]
                        ^
*** 不兼容的类型 [在 "var9" 处]
056
057     IF var9.rec.fldr THEN var2[beta] := seven;
           ^
*** 不兼容的类型 [在 "var9" 处]
                                            ^
*** 不兼容的类型 [在 "seven" 处]
058
059     CASE var5[seven, 'm', d]  OF
060         foo:      var3[e] := 12;
            ^
*** 不兼容的类型 [在 "foo" 处]
                                 ^
*** 不兼容的类型 [在 "12" 处]
061         bar, baz: var3[b] := var1.rec.fldb;
            ^
*** 不兼容的类型 [在 "bar" 处]
                 ^
*** 不兼容的类型 [在 "baz" 处]
                                      ^
*** 非法域(field) [在 "rec" 处]
                                          ^
*** 非法域(field) [在 "fldb" 处]
062     END;
063
064     REPEAT
065         var7[3] := a;
                 ^
*** 太多下标 [在 "3" 处]
                       ^
*** 不兼容的类型 [在 "a" 处]
066     UNTIL var6[3, 'a', c] + var5[4]['f', d];
                                ^
*** 不兼容的类型 [在 "var5" 处]
              ^
*** 不兼容的类型 [在 "var6" 处]
067
068     var9.rec.flda[b][0, 'm', foo].flda[d] := 'p';
                                 ^
*** 太多下标 [在 "foo" 处]
069 END.

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

因为实现了类型检查，我们不再用第6章描述的Hack#4技巧（也就是第六章是的前端是跳过了类型检查的，这里补上了）。

接下来一张，你将会继续完善解析器，可以处理过程，函数，和复杂的Pascal程序。