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

在本章，你将会包含类型检查，完成第9张工作。如今你可以把Pascal变量申明为各种类型，你必须确保当这些变量出现在语句中的时候，它们的类型必须与它们的操作符兼容。如第1章所说的那样，语法检查是语义分析的一部分。

==>> 本章中文版源代码下载：svn co http://wci.googlecode.com/svn/branches/ch10/ 源代码使用了UTF-8编码，下载到本地请修改！

方法和目标

本章的目标是在前端集成类型检查。方法是将类型检查加到语句解析器中，以便在解析语句过程中可以用到。针对第5章开发的语法检查器搞了个新的版本，用来验证你的成果。

类型检查

让我们从intermediate.typeimpl包中的TypeChecker类开始。这个类附带的静态方法实现了类型兼容规则，可以被语句解析器用来执行语法检查。清单10-1 展示了检查具体类型的各种方法。

/**
 * 检查类型是否一个整数
 * @param type 被检查类型说明
 * @return true/false
 */
public static boolean isInteger(TypeSpec type)
{
    return (type != null) && (type.baseType() == Predefined.integerType);
}

/**
 *  检查二元操作符的两个类型都是否是整数
 * @param type1 第一个被检查的类型
 * @param type2 第二个被检查的类型
 * @return true/false
 */
public static boolean areBothInteger(TypeSpec type1, TypeSpec type2)
{
    return isInteger(type1) && isInteger(type2);
}

/**
 * 检查类型是否一个实数，即计算机里面的浮点数
 * @param type 被检查类型
 * @return true/false
 */
public static boolean isReal(TypeSpec type)
{
    return (type != null) && (type.baseType() == Predefined.realType);
}

/**
 * 检查类型是否是整数或者实数，也就是一个实数系内的数
 * @param type 被检查类型
 * @return true/false
 */
public static boolean isIntegerOrReal(TypeSpec type)
{
    return isInteger(type) || isReal(type);
}

/**
 * 检查两个类型中至少有一个是实数，这个即计算机里面的数系扩大。比如INT+DOUBLE=DOUBLE
 * @param type1 第一个被检查类型
 * @param type2 第二个被检查类型
 * @return true/false
 */
public static boolean isAtLeastOneReal(TypeSpec type1, TypeSpec type2)
{
    return (isReal(type1) && isReal(type2)) ||
           (isReal(type1) && isInteger(type2)) ||
           (isInteger(type1) && isReal(type2));
}

/**
 * 检查类型是否布尔类型
 * @param type 被检查类型
 * @return true/false
 */
public static boolean isBoolean(TypeSpec type)
{
    return (type != null) && (type.baseType() == Predefined.booleanType);
}

/**
 * 检查参加布尔二元运算如&&,|| 的两个类型是否都是布尔数。
 * @param type1 第一个被检查类型
 * @param type2 第二个被检查类型
 * @return true/false
 */
public static boolean areBothBoolean(TypeSpec type1, TypeSpec type2)
{
    return isBoolean(type1) && isBoolean(type2);
}

/**
 * 检查类型是否一个字符类型
 * @param type 被检查类型
 * @return true/false
 */
public static boolean isChar(TypeSpec type)
{
    return (type != null) && (type.baseType() == Predefined.charType);
}

清单10-2 展示了TypeChecker类中的两个兼容方法

/**
 * 检查赋值两端的类型是否兼容，即左值是否能被右值兼容
 * @param targetType 左值类型
 * @param valueType 右值类型
 * @return true可以赋值/false不能赋值
 */
public static boolean areAssignmentCompatible(TypeSpec targetType,
                                              TypeSpec valueType)
{
    if ((targetType == null) || (valueType == null)) {
        return false;
    }

    targetType = targetType.baseType();
    valueType  = valueType.baseType();

    boolean compatible = false;

    // 类型一样，ok
    if (targetType == valueType) {
        compatible = true;
    }

    // 左实数，右整数，ok
    else if (isReal(targetType) && isInteger(valueType)) {
        compatible = true;
    }

    // 字符串对字符串，赋值没问题
    else {
        compatible =
            targetType.isPascalString() && valueType.isPascalString();
    }

    return compatible;
}

/**
 * 检查两个类型是否能做到比较兼容，即a < b中的a/b可以兼容，如果a是INT，而b是String，这个就是不兼容的。
 * @param type1 比较操作符左端的类型
 * @param type2 比较操作符右端的类型
 * @return true/false
 */
public static boolean areComparisonCompatible(TypeSpec type1,
                                              TypeSpec type2)
{
    if ((type1 == null) || (type2 == null)) {
        return false;
    }

    type1 = type1.baseType();
    type2 = type2.baseType();
    TypeForm form = type1.getForm();

    boolean compatible = false;

    // 两个标量或者枚举类型
    if ((type1 == type2) && ((form == SCALAR) || (form == ENUMERATION))) {
        compatible = true;
    }

    // 至少有一个是实数，另一个整数，没问题
    else if (isAtLeastOneReal(type1, type2)) {
        compatible = true;
    }

    // 两个字符串也可以比较
    else {
        compatible = type1.isPascalString() && type2.isPascalString();
    }

    return compatible;
}

areAssignmentCompatible()方法用来检查赋值语句中的目标（左边）和值（右边）类型（通用的说法是a = b;，则a是左值，b是右值）。赋值语句只能在两个类型相等、都是字符串类型、还有一个是实数另一个是整数的情况下才被容许。

areComparisonCompatible()方法检查比较操作符两端的类型。比较只有在以下情况下被容许：

• 它们的基类型(base type)相等且其格式为标量或枚举
• 它们的基类型都是字符串类型
• 它们的基类型中至少有一个为实数（另一个为整数）

表达式类型检查

在有了变量类型之后，包含变量的表达式同样有了类型。在解析表达式或子表达式时，把类型信息记在生成的分析树上。就如你在前面章节把类型信息放在SymTabEntry对象类似，我们把类型信息放在ICodeNode对象上。（为啥分两个地方存储？因为SymTabEntry上的类型信息是语法的，单元的，而ICodeNode上的类型信息是语义的，复合的。举个例子，如果定义了a=1;b=1; c=a+b ；在解析过程中a,b的类型信息会被放在对应的符号表项上，而a+b的类型肯定符号表中没有，这个只有放在a+b的二叉树上才可以）

清单10-3 展示了 intermediate包中的接口ICodeNode新增的get和set方法。

/**
 * 设置此节点的类型说明
 * @param typeSpec 类型
 */
public void setTypeSpec(TypeSpec typeSpec);

/**
 * 返回此节点的类型说明
 * @return 绑定的类型
 */
public TypeSpec getTypeSpec();

设计笔记

新方法getTypeSpec和setTypeSpec的实现使得解析器可在分析树上“雕刻”类型信息。正如你所见，这可以让语义分析过程带上语法检查。

这两个新方法在包intermediate.icodeimpl的类ICodeNodeImpl中实现的比较直接，必须得加一个新的域：

private TypeSpec typeSpec; //节点类型

此时语句解析子类ExpressionParser得有新版本的parseExpression(), parseSimpleExpression(), parseTerm(), andparseFactor()等方法，还有一个新增的parseIdentifier()。每个方法执行类型检查，并将类型信息放在生成的分析树上的根节点上。

清单10-4 展示了新版本的parseExpression()方法（请留意加粗部分为新增的类型检查）。

/**
    * @param token 初始token
    * @return 表达式分析子树根节点
    * @throws Exception if an error occurred.
    */
   private ICodeNode parseExpression(Token token)
       throws Exception
   {
       //参见语法图5-2的语法规则，首先是一个simpleExpression，如果有关系
       //操作符，还有一个用来比较的simpleExpression
       ICodeNode rootNode = parseSimpleExpression(token);
       //检测类型
       TypeSpec resultType = rootNode != null ? rootNode.getTypeSpec()
               : Predefined.undefinedType;
       token = currentToken();
       TokenType tokenType = token.getType();

       // 有比较
       if (REL_OPS.contains(tokenType)) {

           // 如果有比较操作符，则比较符是根节点，两个simpleExpression分别作为左右子节点
           //比如 a > b，那么分析树为  >
           //                 / \
           //                a   b
           ICodeNodeType nodeType = REL_OPS_MAP.get(tokenType);
           ICodeNode opNode = ICodeFactory.createICodeNode(nodeType);
           opNode.addChild(rootNode);
           //跳过比较符
           token = nextToken();
           ICodeNode simExprNode = parseSimpleExpression(token);
           opNode.addChild(simExprNode);
           rootNode = opNode;

           TypeSpec simExprType = simExprNode != null
                   ? simExprNode.getTypeSpec()
                   : Predefined.undefinedType;
           //加入类型检查，比较操作符的两端是否类型兼容
           if (TypeChecker.areComparisonCompatible(resultType, simExprType)) {
                   resultType = Predefined.booleanType;
           }else {
               errorHandler.flag(token, PascalErrorCode.INCOMPATIBLE_TYPES, this);
               resultType = Predefined.undefinedType;
           }
       }
       if (rootNode != null) {
           rootNode.setTypeSpec(resultType);
       }
       return rootNode;
   }

方法parseExpression()调用parseSimpleExpression()并设置变量resultType为第一个简单表达式的TypeSpec对象。如果还有一个关系操作符和另一个简单表达式，方法会调用TypeChecker.areComparisonCompatible()验证两个操作数（即两个简单表达式的返回值）是否可以比较。如果一切OK，方法设置rootNode的类型说明为预定义的布尔类型（第39行），否则为未定义(第42行)类型。

清单10-5 展示了带类型检查的新版本parseSimpleExpression()方法（请留意加粗部分为新增的类型检查）。

private ICodeNode parseSimpleExpression(Token token)
       throws Exception
   {
       //参见语法图5-2 的语法规则
       TokenType signType = null;
       Token signToken = null;
       //探测前面可选的正/负 符号
       TokenType tokenType = token.getType();
       if ((tokenType == PLUS) || (tokenType == MINUS)) {
           signType = tokenType;
           signToken = token;
           token = nextToken();
       }
       // 紧接着的一个term
       ICodeNode rootNode = parseTerm(token);
       TypeSpec resultType = rootNode != null ? rootNode.getTypeSpec() : Predefined.undefinedType;
       //既然都有符号位+-了，那么后面的必须是数字才行
       if (null != signType && !TypeChecker.isIntegerOrReal(resultType)){
           errorHandler.flag(signToken, PascalErrorCode.INCOMPATIBLE_TYPES,this);
       }
       // 正号忽略掉，负号须创建一个表示反值运算的"NEGATE”节点
       if (signType == MINUS) {
           ICodeNode negateNode = ICodeFactory.createICodeNode(NEGATE);
           negateNode.addChild(rootNode);
           negateNode.setTypeSpec(rootNode.getTypeSpec()); //负号不改变类型
           rootNode = negateNode;
       }

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

       // 探测有没有加法类运算，如果有，加法类运算符后面还有另一个term,并以运算符作为根节点。
       // 如果类似于EBNF语法 (OP TERM)+的多个，请留意它根节点的变化，是从右到左的。
       while (ADD_OPS.contains(tokenType)) {
           TokenType operator = tokenType;
           ICodeNodeType nodeType = ADD_OPS_OPS_MAP.get(tokenType);
           ICodeNode opNode = ICodeFactory.createICodeNode(nodeType);
           opNode.addChild(rootNode);
           //跳过运算符
           token = nextToken();
           // 另一个term
           ICodeNode termNode = parseTerm(token);
           opNode.addChild(termNode);
           TypeSpec termType = null != termNode ? termNode.getTypeSpec() : Predefined.undefinedType;
           rootNode = opNode;
           switch ((PascalTokenType)operator){
           //加减号的语法检查一样
           case PLUS:
           case MINUS:
               //两个都是整数，结果还是整数
               if (TypeChecker.areBothInteger(resultType, termType)){
                   resultType = Predefined.integerType;
               }else if (TypeChecker.isAtLeastOneReal(resultType, termType)){ //有一个实数，结果肯定是实数，数系扩充
                   resultType = Predefined.realType;
               }else{
                   errorHandler.flag(token, PascalErrorCode.INCOMPATIBLE_TYPES, this);
               }
               break;
           case OR: //OR是加法类操作符，我吐血啊
               if(TypeChecker.areBothBoolean(resultType, termType)){
                   resultType = Predefined.booleanType;
               }else{
                   errorHandler.flag(token, PascalErrorCode.INCOMPATIBLE_TYPES, this);
               }
               break;
           }
           rootNode.setTypeSpec(resultType);

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

       return rootNode;
   }

如果表达式前面有一个+或-符号，parseSimpleExpression()调用TypeChecker.isIntegerOrReal()检查表达式的类型。对于switch语句中解析的二元的加或者减操作符，分别调用TypeChecker.areBothInteger()和TypeChecker.isAtLeastOneReal决定结果类型。一个TypeChecker.areBothBoolean()的调用检查OR操作符的两个操作符（是否都是布尔数）。此方法将结果类型说明存入表达式分析树的根节点上。

清单10-6 展示了新版本方法parseTerm()对应的switch语句。

//判断结果类型
switch ((PascalTokenType) operator) {

    case STAR: {
        // 两个操作数都是整数
        if (TypeChecker.areBothInteger(resultType, factorType)) {
            resultType = Predefined.integerType;
        }else if (TypeChecker.isAtLeastOneReal(resultType,
                                              factorType)) {
            resultType = Predefined.realType;
        }else {
            errorHandler.flag(token, PascalErrorCode.INCOMPATIBLE_TYPES, this);
        }
        break;
    }

    case SLASH: {
        // 两个整数，或者有个实数，结果为实数
        if (TypeChecker.areBothInteger(resultType, factorType) ||
            TypeChecker.isAtLeastOneReal(resultType, factorType))
        {
            resultType = Predefined.realType;
        }else {
            errorHandler.flag(token,  PascalErrorCode.INCOMPATIBLE_TYPES, this);
        }
        break;
    }
    case DIV:
    case MOD: {
        //两个为整数取模相除，结果为整数
        if (TypeChecker.areBothInteger(resultType, factorType)) {
            resultType = Predefined.integerType;
        }else {
            errorHandler.flag(token,  PascalErrorCode.INCOMPATIBLE_TYPES, this);
        }
        break;
    }

    case AND: {
        // 并操作符要求两边都是boolean，结果一定是boolean
        if (TypeChecker.areBothBoolean(resultType, factorType)) {
            resultType = Predefined.booleanType;
        }else {
            errorHandler.flag(token,  PascalErrorCode.INCOMPATIBLE_TYPES, this);
        }
        break;
    }
}

对于*（即乘法)操作符，分别调用TypeChecker.areBothInteger()或者TypeChecker.isAtLeastOneReal()断定结果类型是否是整数或者实数。类似针对 /(除法) 操作符的结果永远是实数。对于DIV和MOD操作符，调用TypeChecker.areBothInteger()验证两个操作数都是整数，则其结果一定是整数。最后，如果操作符是AND，TypeChecker.areBothBoolean()被调用，它的结果一定是布尔类型。

新版本的parseFactor方法在switch语句处也有一些改变，参见清单10-7。（请留意加粗部分为新增的类型检查）

case IDENTIFIER: { //变量
    return parseIdentifier(token);
}
case INTEGER: { //整数
    rootNode = ICodeFactory.createICodeNode(INTEGER_CONSTANT);
    rootNode.setAttribute(VALUE, token.getValue());
    token = nextToken();
    rootNode.setTypeSpec(Predefined.integerType);
    break;
}

case STRING: {//字符串
    String value = (String) token.getValue();
    rootNode = ICodeFactory.createICodeNode(STRING_CONSTANT);
    rootNode.setAttribute(VALUE, value);
    //长度为1则是char，大于1是字符串
    TypeSpec resultType = value.length() == 1
            ? Predefined.charType
            : TypeFactory.createStringType(value);
    token = nextToken();
    rootNode.setTypeSpec(resultType);
    break;
}
case NOT: {//反值 !FACTOR
    //跳过NOT
    token = nextToken();
    rootNode = ICodeFactory.createICodeNode(ICodeNodeTypeImpl.NOT);
    //解析NOT后面的Factor
    ICodeNode factorNode = parseFactor(token);
    rootNode.addChild(factorNode);
    TypeSpec factorType = factorNode != null
            ? factorNode.getTypeSpec()
            : Predefined.undefinedType;
    //NOT的右边一定得是个布尔值
    if (!TypeChecker.isBoolean(factorType)) {
      errorHandler.flag(token, PascalErrorCode.INCOMPATIBLE_TYPES, this);
    }
    rootNode.setTypeSpec(Predefined.booleanType);
    break;
}

处理IDENTIFIER时调用了一个新的方法parseIdentifier()。对于INTEGER，设置INTEGER_CONSTANT节点的类型说明为预定义的整数类型。（REAL情形类似，没有展示）如果是STRING，必须得决定节点到底是一个字符类型还是一个字符串类型。处理NOT时调用TypeChecker.isBoolean()验证表达式的返回类型是一个布尔类型并设置NOT节点的类型说明为预定义的布尔类型。LEFT_PAREN(表达式左括号，没有显示）简单的用到了嵌套表达式的类型。

清单10-8 展示了新增的parseIdentifier方法

private ICodeNode parseIdentifier(Token token)
    throws Exception
{
    ICodeNode rootNode = null;

    //在栈中找这个标识符
    String name = token.getText().toLowerCase();
    SymTabEntry id = symTabStack.lookup(name);

    //未定义
    if (id == null) {
        errorHandler.flag(token, IDENTIFIER_UNDEFINED, this);
        id = symTabStack.enterLocal(name);
        id.setDefinition(DefinitionImpl.UNDEFINED);
        id.setTypeSpec(Predefined.undefinedType);
    }

    Definition defnCode = id.getDefinition();

    switch ((DefinitionImpl) defnCode) {

        case CONSTANT: {
            Object value = id.getAttribute(SymTabKeyImpl.CONSTANT_VALUE);
            TypeSpec type = id.getTypeSpec();

            if (value instanceof Integer) {
                rootNode = ICodeFactory.createICodeNode(INTEGER_CONSTANT);
                rootNode.setAttribute(VALUE, value);
            }
            else if (value instanceof Float) {
                rootNode = ICodeFactory.createICodeNode(REAL_CONSTANT);
                rootNode.setAttribute(VALUE, value);
            }
            else if (value instanceof String) {
                rootNode = ICodeFactory.createICodeNode(STRING_CONSTANT);
                rootNode.setAttribute(VALUE, value);
            }

            id.appendLineNumber(token.getLineNumber());
            token = nextToken();

            if (rootNode != null) {
                rootNode.setTypeSpec(type);
            }

            break;
        }
        //枚举常量
        case ENUMERATION_CONSTANT: {
            Object value = id.getAttribute(SymTabKeyImpl.CONSTANT_VALUE);
            TypeSpec type = id.getTypeSpec();

            rootNode = ICodeFactory.createICodeNode(INTEGER_CONSTANT);
            rootNode.setAttribute(VALUE, value);

            id.appendLineNumber(token.getLineNumber());
            token = nextToken();

            rootNode.setTypeSpec(type);
            break;
        }
        //默认变量
        default: {
            VariableParser variableParser = new VariableParser(this);
            rootNode = variableParser.parse(token, id);
            break;
        }
    }

    return rootNode;
}

parseIdentifier方法首先检验标识符是否在局部或者外层（即嵌套层级数字越小知道全局0）被定义。如果没有的话，将此标识符作为一个类型是未定义的未定义标识符存入局部符号表（这里是为了纠错，不要误会了，不影响后续的编译解析）。

如果标识符是一个常量，那么parseIdentifier()将会根据常量值的类型创建相应的INTEGER_CONSTANT、REAL_CONSTANT或STRING_CONSTANT节点，并设置节点的VALUE属性为常量值。此方法对待枚举常量标识符类似，唯一不同的是总是创建一个INTEGER_CONSTANT节点。

如果标识符既不是一个常量，也不是一个枚举常量，那么parseIdentifier将调用variableParser.parse()去按照变量模式解析。

变量(Variables)

图10-1 展示了一个Pascal变量的完整语法图，变量它可以是一个赋值语句的目标，也可以出现在表达式中。此图扩展了图5-1 的变量定义。一个变量可包含多个下标和字段（下标是a[10]，而字段是a.b)。
清单10-9 展示了包frontend.pascal.parsers中的新语句解析子类VariableParser的parse()方法

// 在下标[]或字段a.b处的同步集
private static final EnumSet<PascalTokenType> SUBSCRIPT_FIELD_START_SET =
    EnumSet.of(LEFT_BRACKET, DOT);


public ICodeNode parse(Token token)
    throws Exception
{
    // 在栈中查找此变量
    String name = token.getText().toLowerCase();
    SymTabEntry variableId = symTabStack.lookup(name);

    // 如果没有找到，报错，且补偿一个未定义
    if (variableId == null) {
        errorHandler.flag(token, IDENTIFIER_UNDEFINED, this);
        variableId = symTabStack.enterLocal(name);
        variableId.setDefinition(UNDEFINED);
        variableId.setTypeSpec(Predefined.undefinedType);
    }

    return parse(token, variableId);
}

/**
 * 解析一个变量
 * @param token 当前token
 * @param variableId 变量符号表项
 * @return 分析生成树的根节点
 * @throws Exception
 */
public ICodeNode parse(Token token, SymTabEntry variableId)
    throws Exception
{
    // 检查变量是怎样被定义的，有三种可能
    Definition defnCode = variableId.getDefinition();
    if ((defnCode != VARIABLE) && (defnCode != VALUE_PARM) &&
        (defnCode != VAR_PARM))
    {
        errorHandler.flag(token, INVALID_IDENTIFIER_USAGE, this);
    }
    variableId.appendLineNumber(token.getLineNumber());
    //变量根节点
    ICodeNode variableNode =
        ICodeFactory.createICodeNode(ICodeNodeTypeImpl.VARIABLE);
    variableNode.setAttribute(ID, variableId);

    token = nextToken();
    //看是否是有下标或字段[或者.
    TypeSpec variableType = variableId.getTypeSpec();
    while (SUBSCRIPT_FIELD_START_SET.contains(token.getType())) {
        ICodeNode subFldNode = token.getType() == LEFT_BRACKET
                                      ? parseSubscripts(variableType)
                                      : parseField(variableType);
        token = currentToken();

        //更新变量节点的类型，比如a是个对象，那么a.b有可能就是一个整数
        variableType = subFldNode.getTypeSpec();
        variableNode.addChild(subFldNode);
    }

    variableNode.setTypeSpec(variableType);
    return variableNode;
}

第一个parse()方法是父类StatementParser方法parse()的一个重写。它在符号表堆栈中搜索此标识符，如果找不到，则将这个标识符以未定义类型的未定义标识符存入局部符号表。接着调用第二个parse()方法，将token和标识符对应的符号表项作为参数传入。

第二个parse()方法在创建一个VARIABLE分析树节点之前检查此标识符是怎样定义的。while 循环的每趟迭代会根据当前token是一个左方括号[ 还是一个句号 . ，来调用parseSubscripts()或parseField()方法分别用来解析任意下标或记录字段。每趟迭代更新变量variableType为当前TypeSpec对象。最后一个variableType的值将会使最后一维数组元素或最后一个记录字段的TypeSpec对象（即类型）。其中的VARIABLE节点(43行)吸收这些方法产生的SUBSCRIPTS或FIELD作为子节点。（58行)

清单10-10 展示了parseSubscripts()方法

// 下标结束符的同步集
   private static final EnumSet<PascalTokenType> RIGHT_BRACKET_SET =
       EnumSet.of(RIGHT_BRACKET, EQUALS, SEMICOLON);

   /**
    * 解析一个逗号隔开的下标集，注意Pascal支持a[1,2]这种下标格式，类似C语言的a[1][2]
    * @param variableType 数组变量类型
    * @return 生成分析树的根节点
    * @throws Exception
    */
   private ICodeNode parseSubscripts(TypeSpec variableType)
       throws Exception
   {
       Token token;
       ExpressionParser expressionParser = new ExpressionParser(this);
       TypeSpec currentVarType = variableType;
       //创建一个下标节点
       ICodeNode subscriptsNode = ICodeFactory.createICodeNode(SUBSCRIPTS);

       do {
           token = nextToken(); //吞掉第一个的[或后续的,

           //传入的变量格式一定是数组才行
           if (currentVarType.getForm() == ARRAY) {

               // 解析下标表达式，这儿只有1个
               ICodeNode exprNode = expressionParser.parse(token);
               TypeSpec exprType = exprNode != null ? exprNode.getTypeSpec()
                                                    : Predefined.undefinedType;

               // 下标表达式必须与数组变量的索引类型可以赋值兼容
               TypeSpec indexType =
                   (TypeSpec) currentVarType.getAttribute(ARRAY_INDEX_TYPE);
               if (!TypeChecker.areAssignmentCompatible(indexType, exprType)) {
                   errorHandler.flag(token, INCOMPATIBLE_TYPES, this);
               }

               // 下标包含表达下标的表达式节点作为子几点，即arr[1+2]，那么1+2将作为arr的子节点
               subscriptsNode.addChild(exprNode);

               // 更新当前变量的类型，以便下标的下标，如[1,2]。
               currentVarType =
                   (TypeSpec) currentVarType.getAttribute(ARRAY_ELEMENT_TYPE);
           }

           //不是一个数组，用下标就不对了
           else {
               errorHandler.flag(token, TOO_MANY_SUBSCRIPTS, this);
               expressionParser.parse(token);
           }

           token = currentToken();
       } while (token.getType() == COMMA);

       // 同步在下标结束符]
       token = synchronize(RIGHT_BRACKET_SET);
       if (token.getType() == RIGHT_BRACKET) {
           token = nextToken();
       }
       else {
           errorHandler.flag(token, MISSING_RIGHT_BRACKET, this);
       }

       subscriptsNode.setTypeSpec(currentVarType);
       return subscriptsNode;
   }

parseSubscripts()解析方括号中由逗号隔开的一个或多个下标。初始的currentVarType是目前被解析的变量的TypeSpec对象（第16行)。此方法创建一个SUBSCRIPTS节点并验证当前类型是否是一个数组。它循环的调用expressionParser.parse()解析每个下标表达式并将其分析子树作加为子节点。方法继续调用TypeChecker.areAssignmentCompatible()判断每个下标表达式是否能与对应的索引类型达到赋值兼容，并且检查对数组类型使用了太多下标（就是本来数组只有1维，你却用了a[1][1]，超出了维数）。它解析每个下标后更新currentVarType（第42行），并设置SUBSCRIPTS节点的类型说明为currentVarType的值。（第64行）。

清单10-11 展示了parseField()方法

/**
   * 解析一个记录字段，比如a.b，那么b就是record a里面的一个字段，这个解析每次只能解析一个字段，比如嵌套的<br>
   * a.b.c，a是一个记录,a.b也是一个记录，那么会有两次调用。
   * @param variableType 记录类型的变量
   * @return 分析树的根节点
   * @throws Exception
   */
  private ICodeNode parseField(TypeSpec variableType)
      throws Exception
  {
      //创建一个Field节点
      ICodeNode fieldNode = ICodeFactory.createICodeNode(FIELD);
      TypeSpec currentVarType = variableType;
      Token token = nextToken();  //a.b处的.被吞掉，到b处
      TokenType tokenType = token.getType();
      TypeForm variableForm = currentVarType.getForm();
      //必须是作用在记录上的字段标识符才有意义
      if ((tokenType == IDENTIFIER) && (variableForm == RECORD)) {
          SymTab symTab = (SymTab) currentVarType.getAttribute(RECORD_SYMTAB);
          String fieldName = token.getText().toLowerCase();
          //在记录中的符号表中去查找
          SymTabEntry fieldId = symTab.lookup(fieldName);

          if (fieldId != null) {
              currentVarType = fieldId.getTypeSpec();
              fieldId.appendLineNumber(token.getLineNumber());

              // 设置节点的ID属性为字段表项
              fieldNode.setAttribute(ID, fieldId);
          }
          else {
              errorHandler.flag(token, INVALID_FIELD, this);
          }
      }
      else {
          errorHandler.flag(token, INVALID_FIELD, this);
      }

      token = nextToken();  //吞掉字段

      fieldNode.setTypeSpec(currentVarType);
      return fieldNode;
  }

方法parseField()解析单个记录字段（参见注释）。它同样有一个currentVarType参数，其初始值为当前被解析变量的TypeSpec对象值（即类型）。此方法创建一个FIELD节点，确保当前类型是一个记录并在记录类型的符号表中搜寻此字段标识符。如果找到此标识符，将字段标识符的名字存入FIELD节点上（第29行）。最后设置FIELD节点的类型说明为记录标识符的类型。

图10-2 展示了一个赋值语句且其目标标量带下标和字段的分析树。

标识符b是一个枚举常量，其值是1

标识符d是一个枚举常量，其值为3

>> 继续第10章