续 第一部分
控制语句中的类型检查
因为Pascal控制语句中有表达式，所以它们的解析器同样需要做类型检查。
清单10-2 展示了语句解析子类AssignmentStatementParser新版本的parse()方法。（留意加粗部分）
1: /**
2: * 解析如 a = xx+yy; 之类的赋值语句
3: * 会有左值/右值两个子节点，并且节点类型与左值类型保持一致
4: * @param token
5: * 第一个token，肯定是identifier了。
6: * @return 语句子树根节点
7: * @throws Exception
8: */
9: public ICodeNode parse(Token token) throws Exception {
10: ICodeNode assignNode = ICodeFactory.createICodeNode(ASSIGN);11: //交由变量解析左边的变量
12: VariableParser variableParser = new VariableParser(this);
13: ICodeNode targetNode = variableParser.parse(token); 14: TypeSpec targetType = targetNode != null ? targetNode.getTypeSpec() 15: : Predefined.undefinedType; 16: assignNode.addChild(targetNode);17: //等号处同步
18: token = synchronize(COLON_EQUALS_SET);19: // 找不到赋值:=就报错，找到就吞噬
20: if (token.getType() == COLON_EQUALS) {
21: token = nextToken();22: } else {
23: errorHandler.flag(token, MISSING_COLON_EQUALS, this);
24: }25: // 解析赋值语句右边的表达式，将其子树作为赋值节点的第二个孩子
26: ExpressionParser expressionParser = new ExpressionParser(this);
27: ICodeNode exprNode = expressionParser.parse(token); 28: assignNode.addChild(exprNode);29: //左值变量，右值表达式，是否能赋值兼容。
30: TypeSpec exprType = exprNode != null ? exprNode.getTypeSpec() 31: : Predefined.undefinedType;32: if (!TypeChecker.areAssignmentCompatible(targetType, exprType)) {
33: errorHandler.flag(token, PascalErrorCode.INCOMPATIBLE_TYPES, this);
34: } 35: assignNode.setTypeSpec(targetType);36: return assignNode;
37: }parse()方法调用variableParser.parse()解析目标类型，并调用TypeChecker.areAssignmentCompatible()检查目标变量的类型是否与表达式返回类型保持赋值兼容。它设置ASSIGN节点的类型为目标变量的类型（第35行）。
类class RepeatStatementParser中的新parse()方法同样加了类型检查。它调用s TypeChecker.isBoolean()确保标识是布尔类型。
清单10-13 RepeatStatementParser中parse()方法的类型检查（参见工程源代码 46行处）
1: ExpressionParser expressionParser = new ExpressionParser(this);
2: ICodeNode exprNode = expressionParser.parse(token); 3: testNode.addChild(exprNode);4: loopNode.addChild(testNode);//最后一个子节点
5: 6: TypeSpec exprType = exprNode != null ? exprNode.getTypeSpec() 7: : Predefined.undefinedType;8: if (!TypeChecker.isBoolean(exprType)) {
9: errorHandler.flag(token, INCOMPATIBLE_TYPES, this);
10: }WhileStatementParser类中的parse()方法做了类似的更新。它也调用了TypeChecker.isBoolean()确保表达式是布尔类型。参见下面的清单10-14（参见工程源代码53行处）
1: ExpressionParser expressionParser = new ExpressionParser(this);
2: ICodeNode exprNode = expressionParser.parse(token); 3: notNode.addChild(exprNode); 4: 5: TypeSpec exprType = exprNode != null ? exprNode.getTypeSpec() 6: : Predefined.undefinedType;7: if (!TypeChecker.isBoolean(exprType)) {
8: errorHandler.flag(token, INCOMPATIBLE_TYPES, this);
9: }用类似的搞法，清单10-15、10-16、10-17分别展示ForStatementParser、IfStatementParse和CaseStatementParser中的新版本parse()方法。
清单10-15 类ForStatementParser中parse()方法的类型检查（为省空间，我只贴改变的部分，详细请参考工程源代码）
1: //第77-84行
2: TypeSpec controlType = initAssignNode != null 3: ? initAssignNode.getTypeSpec() 4: : Predefined.undefinedType;5: //for语句的初始变量一定得是一个整数或者枚举
6: if (!TypeChecker.isInteger(controlType)
7: && (controlType.getForm() != TypeFormImpl.ENUMERATION)) {8: errorHandler.flag(token, PascalErrorCode.INCOMPATIBLE_TYPES, this);
9: }10: //第101行
11: relOpNode.setTypeSpec(Predefined.booleanType); //关系默认为布尔类型
12: //第109-114行
13: TypeSpec exprType = exprNode != null ? exprNode.getTypeSpec() 14: : Predefined.undefinedType;15: //控制变量能够与表达式类型赋值兼容，不然无法复制
16: if (!TypeChecker.areAssignmentCompatible(controlType, exprType)) {
17: errorHandler.flag(token, PascalErrorCode.INCOMPATIBLE_TYPES, this);
18: }19: //第131行
20: nextAssignNode.setTypeSpec(controlType);21: //第135行
22: arithOpNode.setTypeSpec(Predefined.integerType);23: //第140行
24: 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行处)
1: ExpressionParser expressionParser = new ExpressionParser(this);
2: ICodeNode exprNode = expressionParser.parse(token); 3: ifNode.addChild(exprNode); 4: 5: // Type check: The expression type must be boolean.
6: TypeSpec exprType = exprNode != null ? exprNode.getTypeSpec() 7: : Predefined.undefinedType;8: if (!TypeChecker.isBoolean(exprType)) {
9: errorHandler.flag(token, INCOMPATIBLE_TYPES, this);
10: }CaseStatementParser中改进过的parse()方法必须保证case表达式类型一定是整形，字符或者枚举类型。
1: ExpressionParser expressionParser = new ExpressionParser(this);
2: ICodeNode exprNode = expressionParser.parse(token); 3: selectNode.addChild(exprNode); 4: TypeSpec exprType = exprNode != null ? exprNode.getTypeSpec() 5: : Predefined.undefinedType;6: if (!TypeChecker.isInteger(exprType)
7: && !TypeChecker.isChar(exprType) 8: && (exprType.getForm() != TypeFormImpl.ENUMERATION)) 9: {10: errorHandler.flag(token, INCOMPATIBLE_TYPES, this);
11: }方法parseConstant()现在要设置常量节点的类型。它调用TypeChecker.areComparisonCompatible()检查每个常量值是否与case表达式的类型达到比较兼容。参见清单10-18
1: switch ((PascalTokenType) token.getType()) {
2: 3: case IDENTIFIER: {//未实现
4: constantNode = parseIdentifierConstant(token, sign);5: if (constantNode != null) {
6: constantType = constantNode.getTypeSpec(); 7: }8: break;
9: } 10: 11: case INTEGER: {
12: constantNode = parseIntegerConstant(token.getText(), sign); 13: constantType = Predefined.integerType;14: break;
15: } 16: 17: case STRING: {
18: constantNode = 19: parseCharacterConstant(token, (String) token.getValue(), 20: sign); 21: constantType = Predefined.charType;22: break;
23: } 24: 25: default: {
26: errorHandler.flag(token, INVALID_CONSTANT, this);
27: break;
28: } 29: }30: if (!TypeChecker.areComparisonCompatible(exprType,
31: constantType)) {32: errorHandler.flag(token, INCOMPATIBLE_TYPES, this);
33: } 34: constantNode.setTypeSpec(constantType);清单10-19 展示了parseIdentifierConstant()方法，现在它解析每一个是标识符的分支常量。
1: /**
2: * 解析标识符常量，并判断类型是否与整数兼容
3: * @param token 常量token
4: * @param sign 符号token
5: * @return 常量节点
6: */
7: private ICodeNode parseIdentifierConstant(Token token, TokenType sign)
8: throws Exception
9: { 10: ICodeNode constantNode = null; 11: TypeSpec constantType = null; 12: 13: // 符号表堆栈中查找此常量标识符
14: String name = token.getText().toLowerCase(); 15: SymTabEntry id = symTabStack.lookup(name); 16: 17: //如果未定义，直接结束
18: if (id == null) {
19: id = symTabStack.enterLocal(name); 20: id.setDefinition(DefinitionImpl.UNDEFINED); 21: id.setTypeSpec(Predefined.undefinedType);22: errorHandler.flag(token, PascalErrorCode.IDENTIFIER_UNDEFINED, this);
23: return null;
24: } 25: 26: Definition defnCode = id.getDefinition(); 27: 28: // 常量标识符是否符合定义
29: if ((defnCode == DefinitionImpl.CONSTANT) || (defnCode == DefinitionImpl.ENUMERATION_CONSTANT)) {
30: Object constantValue = id.getAttribute(SymTabKeyImpl.CONSTANT_VALUE); 31: constantType = id.getTypeSpec(); 32: 33: // 与整数兼容才行
34: if ((sign != null) && !TypeChecker.isInteger(constantType)) {
35: errorHandler.flag(token, INVALID_CONSTANT, this);
36: } 37: 38: constantNode = ICodeFactory.createICodeNode(INTEGER_CONSTANT); 39: constantNode.setAttribute(VALUE, constantValue); 40: } 41: 42: id.appendLineNumber(token.getLineNumber()); 43: 44: if (constantNode != null) {
45: constantNode.setTypeSpec(constantType); 46: } 47: 48: return constantNode;
49: }方法parseIdentifierConstant()验证标识符是一个常量或枚举常量，并检测在标识符钱是否有+或-，还有确保标识符必须是整数类型（或整数兼容）。
CASE语句的另一个改变这次在解释器后端。清单10-20 展示了SelectExecutor中新版本的createJumpTable()方法。对于CASE语句中表达式值为字符的情况，此方法将每个CASE分支常量值在作为键放入跳转表之前，从一个字符串（它仅包含一个字符）转换成一个字符。（改动参见加粗部分）
1: /**
2: * 为某一个SELECT节点根据CASE情况创建静态查找表
3: * @param node SELECT节点
4: * @return 查找表
5: */
6: private HashMap<Object, ICodeNode> createJumpTable(ICodeNode node)
7: {8: HashMap<Object, ICodeNode> jumpTable = new HashMap<Object, ICodeNode>();
9: 10: // 遍历分支，将常量和语句变成查找表的某一项
11: List<ICodeNode> selectChildren = node.getChildren();12: for (int i = 1; i < selectChildren.size(); ++i) {
13: ICodeNode branchNode = selectChildren.get(i); 14: ICodeNode constantsNode = branchNode.getChildren().get(0); 15: ICodeNode statementNode = branchNode.getChildren().get(1);16: //将如1,2,3: xx的三个常量变成三个查找项
17: List<ICodeNode> constantsList = constantsNode.getChildren();18: for (ICodeNode constantNode : constantsList) {
19: Object value = constantNode.getAttribute(VALUE);20: if (constantNode.getType() == ICodeNodeTypeImpl.STRING_CONSTANT) {
21: value = ((String) value).charAt(0); 22: } 23: jumpTable.put(value, statementNode); 24: } 25: }26: return jumpTable;
27: }程序10：Pascal语法检查器III
语法检查现在包含了类型检查，且解析器能为带下标和字段的变量生成分析树。清单10-21 是下面命令行的输出
java -classpath classes Pascal compile -i block.txt
这个命令用“编译”而不是解析执行，那是因为你还没有为变量编写执行器（executor)。你将在第12章完成这个功能。
清单10-21 带类型检查的Pascal语法检查器的输出。（输出比较庞大，建议自己实验，这里输出一些样例）
1: 001 CONST 2: 002 seven = 7; 3: 003 ten = 10; 4: 004 5: //.......省略 6: 053 BEGIN 7: 054 var1[5] := 3.14; 8: 055 var1[var7.i] := var9.rec.flda[e, ten]['q'].fldi; 9: 056 10: 057 IF var9.a[seven-3] THEN var2[beta] := 'x'; 11: 058 12: //.......省略 13: 080 var9.rec.flda[b][0, 'm'].flda[d] := 'p'; 14: 081 END. 15: 16: ----------代码解析统计信息-------------- 17: 源文件共有 81行。 18: 有 0个语法错误. 19: 解析共耗费 0.07秒. 20: 21: ===== 中间码XML展示 ===== 22: 23: *** PROGRAM dummyprogramname *** 24: 25: <COMPOUND line="53">
26: <ASSIGN line="54" type_id="real">
27: <VARIABLE id="var1" level="1" type_id="real">
28: <SUBSCRIPTS type_id="real">
29: <INTEGER_CONSTANT value="5" type_id="integer" />
30: </SUBSCRIPTS>
31: </VARIABLE>
32: <REAL_CONSTANT value="3.14" type_id="real" />
33: </ASSIGN>
34: //.......省略35: <ASSIGN line="80" type_id="range2">
36: <VARIABLE id="var9" level="1" type_id="range2">
37: <FIELD id="rec" level="2" type_id="$anon_2adab05" />
38: <FIELD id="flda" level="3" type_id="$anon_51a0a458" />
39: <SUBSCRIPTS type_id="$anon_cf7e46b">
40: <INTEGER_CONSTANT value="1" type_id="enum1" />
41: </SUBSCRIPTS>
42: <SUBSCRIPTS type_id="$anon_28da9e1">
43: <INTEGER_CONSTANT value="0" type_id="integer" />
44: <STRING_CONSTANT value="m" type_id="char" />
45: </SUBSCRIPTS>
46: <FIELD id="flda" level="2" type_id="$anon_480ec542" />
47: <SUBSCRIPTS type_id="range2">
48: <INTEGER_CONSTANT value="3" type_id="enum1" />
49: </SUBSCRIPTS>
50: </VARIABLE>
51: <STRING_CONSTANT value="p" type_id="char" />
52: </ASSIGN>
53: </COMPOUND>
54: 55: ----------编译统计信-------------- 56: 共生成 0 条指令 57: 代码生成共耗费 0.00秒
上面分析树的输出现在包含了每个有类型说明的类型标识。清单10-22 展示了类ParseTreePrinter(在包util中)的新printTypeSpec()方法。
1: /**
2: * 打印分析树节点的类型说明
3: * @param node 某一节点
4: */
5: private void printTypeSpec(ICodeNodeImpl node)
6: { 7: TypeSpec typeSpec = node.getTypeSpec(); 8: 9: if (typeSpec != null) {
10: String saveMargin = indentation; 11: indentation += indent; 12: 13: String typeName; 14: SymTabEntry typeId = typeSpec.getIdentifier(); 15: 16: //有名字
17: if (typeId != null) {
18: typeName = typeId.getName(); 19: } 20: 21: // 匿名
22: else {
23: int code = typeSpec.hashCode() + typeSpec.getForm().hashCode();
24: typeName = "$anon_" + Integer.toHexString(code);
25: } 26: 27: printAttribute("TYPE_ID", typeName);
28: indentation = saveMargin; 29: } 30: }清单10-23 展示了语法检查器中类型检查错误的输出。使用 java -classpath classes Pascal compile -i blockerrors.txt
1: 001 CONST 2: 002 Seven = 7; 3: 003 Ten = 10; 4: 004 5: 005 TYPE 6: 006 range1 = 0..ten; 7: 007 range2 = 'a'..'q'; 8: 008 range3 = range1; 9: 009 10: 010 enum1 = (a, b, c, d, e); 11: 011 enum2 = enum1; 12: 012 13: 013 range4 = b..d; 14: 014 15: 015 arr1 = ARRAY [range1] OF real; 16: 016 arr2 = ARRAY [(alpha, beta, gamma)] OF range2; 17: 017 arr3 = ARRAY [enum2] OF arr1; 18: 018 arr4 = ARRAY [range3] OF (foo, bar, baz); 19: 019 arr5 = ARRAY [range1] OF ARRAY[range2] OF ARRAY[c..e] OF enum2; 20: 020 arr6 = ARRAY [range1, range2, c..e] OF enum2; 21: 021 22: 022 rec7 = RECORD 23: 023 i : integer; 24: 024 r : real; 25: 025 b1, b2 : boolean; 26: 026 c : char 27: 027 END; 28: 028 29: 029 arr8 = ARRAY [range2] OF RECORD 30: 030 fldi : integer; 31: 031 fldr : rec7; 32: 032 flda : ARRAY[range4] OF range2; 33: 033 END; 34: 034 35: 035 VAR 36: 036 var1 : arr1; var5 : arr5; 37: 037 var2 : arr2; var6 : arr6; 38: 038 var3 : arr3; var7 : rec7; 39: 039 var4 : arr4; var8 : arr8; 40: 040 41: 041 var9 : RECORD 42: 042 b : boolean; 43: 043 rec : RECORD 44: 044 fld1 : arr1; 45: 045 fldb : boolean; 46: 046 fldr : real; 47: 047 fld6 : arr6; 48: 048 flda : ARRAY [enum1, range1] OF arr8; 49: 049 END; 50: 050 a : ARRAY [1..5] OF boolean; 51: 051 END; 52: 052 53: 053 BEGIN 54: 054 var2[a] := 3.14; 55: ^ 56: *** 不兼容的类型 [在 "a" 处] 57: ^ 58: *** 不兼容的类型 [在 "3.14" 处] 59: 055 var1[var7.i] := var9.rec.flda['e', ten]['q'].fldr; 60: ^ 61: *** 不兼容的类型 [在 "'e'" 处] 62: ^ 63: *** 不兼容的类型 [在 "var9" 处] 64: 056 65: 057 IF var9.rec.fldr THEN var2[beta] := seven; 66: ^ 67: *** 不兼容的类型 [在 "var9" 处] 68: ^ 69: *** 不兼容的类型 [在 "seven" 处] 70: 058 71: 059 CASE var5[seven, 'm', d] OF 72: 060 foo: var3[e] := 12; 73: ^ 74: *** 不兼容的类型 [在 "foo" 处] 75: ^ 76: *** 不兼容的类型 [在 "12" 处] 77: 061 bar, baz: var3[b] := var1.rec.fldb; 78: ^ 79: *** 不兼容的类型 [在 "bar" 处] 80: ^ 81: *** 不兼容的类型 [在 "baz" 处] 82: ^ 83: *** 非法域(field) [在 "rec" 处] 84: ^ 85: *** 非法域(field) [在 "fldb" 处] 86: 062 END; 87: 063 88: 064 REPEAT 89: 065 var7[3] := a; 90: ^ 91: *** 太多下标 [在 "3" 处] 92: ^ 93: *** 不兼容的类型 [在 "a" 处] 94: 066 UNTIL var6[3, 'a', c] + var5[4]['f', d]; 95: ^ 96: *** 不兼容的类型 [在 "var5" 处] 97: ^ 98: *** 不兼容的类型 [在 "var6" 处] 99: 067 100: 068 var9.rec.flda[b][0, 'm', foo].flda[d] := 'p'; 101: ^ 102: *** 太多下标 [在 "foo" 处] 103: 069 END. 104: 105: ----------代码解析统计信息-------------- 106: 源文件共有 69行。 107: 有 17个语法错误. 108: 解析共耗费 0.07秒.因为实现了类型检查，我们不再用第6章描述的Hack#4技巧（也就是第六章是的前端是跳过了类型检查的，这里补上了）。
接下来一张，你将会继续完善解析器，可以处理过程，函数，和复杂的Pascal程序。
