(基于Java)编写编译器和解释器-第11章：解析程序、过程和函数-第二部分

续 第一部分

(因为BlockParser的parse()方法里面只改了一行，即在第41行增加了一个routineId参数，所以代码我就不贴了，自己看吧）

新版本的parse方法多传了一个参数，即父程式名字对应的符号比表项，此参数接着被传给了declarationsParser.parse()。

解析过程和函数调用

图11-6 展示了作为语句的过程调用以及作为因子的函数调用对应的语法图，这些图扩展了图5-2 中关于因子的部分，以及图7-1中语句的部分。

（可以看到，多了一个procedure call语句，在右边的factor(因子）部分，多了一个function all）

 

左边的图11-7展示了语句解析子类的UML类图，它们被用来解析针申明或标准（内置）过程和函数的调用。

语句解析子类CallParser有两个子类， CallDeclaredParser 和 CallStandardParser。两个都用到了parseActualParameters()方法。

针对申明过的程式调用和Pascal标准程式的调用，你需要不同的类处理。标准程式某些情况下意味着调用不标准（因为标准是约定的，而申明是解析的，解析的你很定知道程式的每一个细节，而约定的不是，规定了什么就什么，这个规定就是不标准）。比如，过程read有一个可变实参表（是否想起了C的 ... ？）。过程writer和writeln的每个参数后面可以有一个可选并用冒号隔开的域宽数和精度值。函数诸如abs的参数可为整数或实数，其返回值与参数类型一致。基于这些原因，类CallStandardParser针对这些调用有特别的方法来处理。

清单11-10 展示了包intermediate.symtabimpl中的类Predefined附加的东西，即把Pascal标准过程和函数的名称放入全局符号表中。

//预定义过程和函数
   public static SymTabEntry readId;
   public static SymTabEntry readlnId;
   public static SymTabEntry writeId;
   public static SymTabEntry writelnId;
   public static SymTabEntry absId;
   public static SymTabEntry arctanId;
   public static SymTabEntry chrId;
   public static SymTabEntry cosId;
   public static SymTabEntry eofId;
   public static SymTabEntry eolnId;
   public static SymTabEntry expId;
   public static SymTabEntry lnId;
   public static SymTabEntry oddId;
   public static SymTabEntry ordId;
   public static SymTabEntry predId;
   public static SymTabEntry roundId;
   public static SymTabEntry sinId;
   public static SymTabEntry sqrId;
   public static SymTabEntry sqrtId;
   public static SymTabEntry succId;
   public static SymTabEntry truncId;

   /**
    * 初始化预定义到符号表堆栈
    * @param symTab 堆栈
    */
   public static void initialize(SymTabStack symTabStack)
   {
       initializeTypes(symTabStack);
       initializeConstants(symTabStack);
       initializeStandardRoutines(symTabStack);
   }
   //初始化标准程式到全局符号表中
   private static void initializeStandardRoutines(SymTabStack symTabStack) {
        readId    = enterStandard(symTabStack, PROCEDURE, "read",    READ);
        readlnId  = enterStandard(symTabStack, PROCEDURE, "readln",  READLN);
        writeId   = enterStandard(symTabStack, PROCEDURE, "write",   WRITE);
        writelnId = enterStandard(symTabStack, PROCEDURE, "writeln", WRITELN);

        absId    = enterStandard(symTabStack, FUNCTION, "abs",    ABS);
        arctanId = enterStandard(symTabStack, FUNCTION, "arctan", ARCTAN);
        chrId    = enterStandard(symTabStack, FUNCTION, "chr",    CHR);
        cosId    = enterStandard(symTabStack, FUNCTION, "cos",    COS);
        eofId    = enterStandard(symTabStack, FUNCTION, "eof",    EOF);
        eolnId   = enterStandard(symTabStack, FUNCTION, "eoln",   EOLN);
        expId    = enterStandard(symTabStack, FUNCTION, "exp",    EXP);
        lnId     = enterStandard(symTabStack, FUNCTION, "ln",     LN);
        oddId    = enterStandard(symTabStack, FUNCTION, "odd",    ODD);
        ordId    = enterStandard(symTabStack, FUNCTION, "ord",    ORD);
        predId   = enterStandard(symTabStack, FUNCTION, "pred",   PRED);
        roundId  = enterStandard(symTabStack, FUNCTION, "round",  ROUND);
        sinId    = enterStandard(symTabStack, FUNCTION, "sin",    SIN);
        sqrId    = enterStandard(symTabStack, FUNCTION, "sqr",    SQR);
        sqrtId   = enterStandard(symTabStack, FUNCTION, "sqrt",   SQRT);
        succId   = enterStandard(symTabStack, FUNCTION, "succ",   SUCC);
        truncId  = enterStandard(symTabStack, FUNCTION, "trunc",  TRUNC);
   }
   //录入标准程式
   private static SymTabEntry enterStandard(SymTabStack symTabStack,
                                            Definition defn, String name,
                                            RoutineCode routineCode)
   {
       SymTabEntry procId = symTabStack.enterLocal(name);
       procId.setDefinition(defn);
       procId.setAttribute(SymTabKeyImpl.ROUTINE_CODE, routineCode);
       return procId;
   }

清单11-11 展示了语句解析子类CallParser的parse方法

public ICodeNode parse(Token token)
    throws Exception
{
    //视情况调用申明解析或标准解析
    SymTabEntry pfId = symTabStack.lookup(token.getText().toLowerCase());
    RoutineCode routineCode = (RoutineCode) pfId.getAttribute(ROUTINE_CODE);
    StatementParser callParser = (routineCode == DECLARED) ||
                                 (routineCode == FORWARD)
                                     ? new CallDeclaredParser(this)
                                     : new CallStandardParser(this);

    return callParser.parse(token);
}

parse()方法在符号表中搜寻被调用的程式名称，看是否是申明的、前向的还是预定义的，对于申明与前向调用CallDeclaredParser解析；对于预定义的，调用CallStandardParser解析。

调用申明（过）过程和函数

清单11-12 展示了类CallDeclaredParser的parse方法

public ICodeNode parse(Token token)
    throws Exception
{
    // 创建CALL节点
    ICodeNode callNode = ICodeFactory.createICodeNode(CALL);
    SymTabEntry pfId = symTabStack.lookup(token.getText().toLowerCase());
    callNode.setAttribute(ID, pfId);
    callNode.setTypeSpec(pfId.getTypeSpec());

    token = nextToken();  //跳过程式名称

    //解析参数
    ICodeNode parmsNode = parseActualParameters(token, pfId,
                                                true, false, false);
    //参数作为子节点
    callNode.addChild(parmsNode);
    return callNode;
}

parse（）调用parseActualParameters()来解析实参并返回一个PARAMETERS节点，如果没有参数值为null。CALL节点收纳PARAMETERS为子节点。

举个例子，假设你有如下的Pascal申明

 

TYPE
    arr = ARRAY [1..5] OF real;
 
VAR
    i, m : integer;
    a : arr;
    v, y : real;
    t : boolean;
 
PROCEDURE proc(j, k : integer; VAR x, y, z : real; VAR v : arr;
               VAR p : boolean; ch : char);
    BEGIN
        ...
    END; 
那么过程调用proc(i, -7 + m, a[m], v, y, a, t, 'r'); 将会生成如清单11-13所示的分析树

<CALL id="proc" level="1" line="81">
       <PARAMETERS>
           <VARIABLE id="i" level="1" type_id="integer" />
           <ADD type_id="integer">
               <NEGATE>
                   <INTEGER_CONSTANT value="7" type_id="integer" />
               </NEGATE>
               <VARIABLE id="m" level="1" type_id="integer" />
           </ADD>
           <VARIABLE id="a" level="1" type_id="real">
               <SUBSCRIPTS type_id="real">
                   <VARIABLE id="m" level="1" type_id="integer" />
               </SUBSCRIPTS>
           </VARIABLE>
           <VARIABLE id="v" level="1" type_id="real" />
           <VARIABLE id="y" level="1" type_id="real" />
           <VARIABLE id="a" level="1" type_id="arr" />
           <VARIABLE id="t" level="1" type_id="boolean" />
           <STRING_CONSTANT value="r" type_id="char" />
       </PARAMETERS>
</CALL>

调用标准过程和函数

清单11-14 展示了类CallStandardParser的parse()方法。它调用适当的私有方法解析每一个标准过程或函数的调用。

public ICodeNode parse(Token token)
    throws Exception
{
    ICodeNode callNode = ICodeFactory.createICodeNode(CALL);
    SymTabEntry pfId = symTabStack.lookup(token.getText().toLowerCase());
    RoutineCode routineCode = (RoutineCode) pfId.getAttribute(ROUTINE_CODE);
    callNode.setAttribute(ID, pfId);

    token = nextToken(); // 跳过程式名称
    //不同的程式，不同的解析
    switch ((RoutineCodeImpl) routineCode) {
        case READ:
        case READLN:  return parseReadReadln(token, callNode, pfId);

        case WRITE:
        case WRITELN: return parseWriteWriteln(token, callNode, pfId);

        case EOF:
        case EOLN:    return parseEofEoln(token, callNode, pfId);

        case ABS:
        case SQR:     return parseAbsSqr(token, callNode, pfId);

        case ARCTAN:
        case COS:
        case EXP:
        case LN:
        case SIN:
        case SQRT:    return parseArctanCosExpLnSinSqrt(token, callNode,
                                                        pfId);

        case PRED:
        case SUCC:    return parsePredSucc(token, callNode, pfId);

        case CHR:     return parseChr(token, callNode, pfId);
        case ODD:     return parseOdd(token, callNode, pfId);
        case ORD:     return parseOrd(token, callNode, pfId);

        case ROUND:
        case TRUNC:   return parseRoundTrunc(token, callNode, pfId);

        default:      new UnsupportedOperationException("No such routine "+token.getText());
    }
    return null;
}

清单11-15 展示了CallStandardParser的各种私有方法（细节请参看源代码，这里不贴了）

调用标准过程如read、readln、write、writeln可有任意个实参；每个对read和write的调用必须至少有一个参数。标准函数eof和eoln调用没有实参，而调用其它标准函数必须有且仅有一个实参。

在每一个解析方法里（即parseXXX），都会调用parseActualParameters()解析实参并返回一个PARAMETERS节点，没有参数返回null。CALL节点将PARAMETERS加为子节点。方法checkParmCount()用来验证调用中的实参数目是否正确。

函数eof和eoln返回布尔值。函数abs和sqr接受整数或实数参数并返回同类型的值。函数arctan、cos、exp、ln、sin和sqrt每个都接受一个整数或实数参数且它的返回值类型一定是实数。函数pred和succ可接受整数或枚举常量参数，其返回值与参数同类型。函数chr接受整数参数返回字符。函数odd接受整数参数返回布尔类型。函数ord有一个字符或枚举常量参数，返回整数值。函数round和trunc接受实数参数并返回整数值。

实参列表

如果被调用的申明/标准程式有实参，则用类CallParser的parseActualParameters()解析。布尔参数isDeclared, isReadReadln, isWriteWriteln用来分别说明调用的是否是一个申明程式，或者是标准过程read/readln，异或是标准过程write/writeln。这三个布尔值异或，也就是一个调用只可能有一个为真。参见清单11-16

protected ICodeNode parseActualParameters(Token token, SymTabEntry pfId,
                                             boolean isDeclared,
                                             boolean isReadReadln,
                                             boolean isWriteWriteln)
       throws Exception
   {
       ExpressionParser expressionParser = new ExpressionParser(this);
       ICodeNode parmsNode = ICodeFactory.createICodeNode(PARAMETERS);
       ArrayList<SymTabEntry> formalParms = null;
       int parmCount = 0;
       int parmIndex = -1;
       //如果是申明程式，很容易取得参数个数
       if (isDeclared) {
           formalParms =
               (ArrayList<SymTabEntry>) pfId.getAttribute(ROUTINE_PARMS);
           parmCount = formalParms != null ? formalParms.size() : 0;
       }

       if (token.getType() != LEFT_PAREN) {
           if (parmCount != 0) {
               errorHandler.flag(token, WRONG_NUMBER_OF_PARMS, this);
           }

           return null;
       }

       token = nextToken();  // 跳过左口号XX(y,z)

       // 遍历每一个实参
       while (token.getType() != RIGHT_PAREN) {
           ICodeNode actualNode = expressionParser.parse(token);

           //如果是申明程式，需要检查形参和实参的匹配
           if (isDeclared) {
               if (++parmIndex < parmCount) {
                   SymTabEntry formalId = formalParms.get(parmIndex);
                   checkActualParameter(token, formalId, actualNode);
               }
               else if (parmIndex == parmCount) {
                   errorHandler.flag(token, WRONG_NUMBER_OF_PARMS, this);
               }
           }

           // 对于read/readln来说，实参必须为标量/布尔还有整数子界
           else if (isReadReadln) {
               TypeSpec type = actualNode.getTypeSpec();
               TypeForm form = type.getForm();

               if (! (   (actualNode.getType() == ICodeNodeTypeImpl.VARIABLE)
                      && ( (form == SCALAR) ||
                           (type == Predefined.booleanType) ||
                           ( (form == SUBRANGE) &&
                             (type.baseType() == Predefined.integerType) ) )
                     )
                  )
               {
                   errorHandler.flag(token, INVALID_VAR_PARM, this);
               }
           }

           // 对于write/writeln，除了参数要求外，还有可选的宽度和精度
           else if (isWriteWriteln) {

               // Create a WRITE_PARM node which adopts the expression node.
               ICodeNode exprNode = actualNode;
               actualNode = ICodeFactory.createICodeNode(WRITE_PARM);
               actualNode.addChild(exprNode);

               TypeSpec type = exprNode.getTypeSpec().baseType();
               TypeForm form = type.getForm();

               if (! ( (form == SCALAR) || (type == Predefined.booleanType) ||
                       (type.isPascalString())
                     )
                  )
               {
                   errorHandler.flag(token, INCOMPATIBLE_TYPES, this);
               }

               //可选的宽度
               token = currentToken();
               actualNode.addChild(parseWriteSpec(token));

               //可选的精度
               token = currentToken();
               actualNode.addChild(parseWriteSpec(token));
           }

           parmsNode.addChild(actualNode);
           token = synchronize(COMMA_SET);
           TokenType tokenType = token.getType();

           // 是否分割实参的逗号？
           if (tokenType == COMMA) {
               token = nextToken();
           }
           else if (ExpressionParser.EXPR_START_SET.contains(tokenType)) {
               errorHandler.flag(token, MISSING_COMMA, this);
           }
           else if (tokenType != RIGHT_PAREN) {
               token = synchronize(ExpressionParser.EXPR_START_SET);
           }
       }

       token = nextToken();  // 跳过右括号

       if ((parmsNode.getChildren().size() == 0) ||
           (isDeclared && (parmIndex != parmCount-1)))
       {
           errorHandler.flag(token, WRONG_NUMBER_OF_PARMS, this);
       }

       return parmsNode;
   }

方法parseActualParameters()创建并返回一个PARAMETERS节点，在没有参数的情况下返回null。它遍历解析每个实参，然后PARAMETERS将每个实参的分析树收纳为子节点。

如果调用的是申明程式，方法将调用checkActualParameter()检查每个实参-形参的匹配，个数是否相等。对于标准过程read/readln的调用，此方法检查它的每个实参是否是一个类型为标量/布尔/整数子界的变量。

调用标准过程write/writeln有些特殊。每个实参必须是一个类型为标量/布尔/Pascal字符串的表达式。每个参数可跟着一个用冒号，然后是一个表示输出字符宽度的整数常量。宽度之后还可有第二个冒号，紧接着是一个表示输出实数值的精度值的整数常量（也就是小数个数）。例如：

writeln('The square root of ', number:5, ' is ', sqrt(number):10:6);

因此，对于每个实参，方法parseActualParameters()创建一个WRITE_PARM节点，它将实参表达式分析树加为第一个子节点。如果有宽度值，宽度值为WRITE_PARAM节点的第二个子节点；如果有精度，则精度将会是WRITE_PARAM的第三个子节点。清单11-17 展示了上面writeln调用解析产生的分析树。

<CALL line="11" id="writeln" level="0">
     <PARAMETERS>
         <WRITE_PARM>
             <STRING_CONSTANT value="The square root of " 
                 type_id="$anon_4cb088b" />
         </WRITE_PARM>
         <WRITE_PARM>
             <VARIABLE id="number" level="1" type_id="integer" />
             <INTEGER_CONSTANT value="5" type_id="integer" />
         </WRITE_PARM>
         <WRITE_PARM>
             <STRING_CONSTANT value=" is " type_id="$anon_4cb0887" />
         </WRITE_PARM>
         <WRITE_PARM>
             <CALL id="sqrt" level="0" type_id="real">
                 <PARAMETERS>
                     <VARIABLE id="number" level="1" type_id="integer" />
                 </PARAMETERS>
             </CALL>
             <INTEGER_CONSTANT value="10" type_id="integer" />
             <INTEGER_CONSTANT value="6" type_id="integer" />
         </WRITE_PARM>
     </PARAMETERS>
 </CALL>

清单11-18 展示了CallParser的checkActualParameter()方法。

//检测实参/形参的匹配
    private void checkActualParameter(Token token, SymTabEntry formalId,
                                      ICodeNode actualNode)
    {
        Definition formalDefn = formalId.getDefinition();
        TypeSpec formalType = formalId.getTypeSpec();
        TypeSpec actualType = actualNode.getTypeSpec();

        // VAR参数(引用传递): 实参类型必须与形参类型保持一致
        if (formalDefn == VAR_PARM) {
            if ((actualNode.getType() != ICodeNodeTypeImpl.VARIABLE) ||
                (actualType != formalType))
            {
                errorHandler.flag(token, INVALID_VAR_PARM, this);
            }
        }

        // VALUE参数(值传递): 检查实参能否与形参赋值兼容？
        else if (!TypeChecker.areAssignmentCompatible(formalType, actualType)) {
            errorHandler.flag(token, INCOMPATIBLE_TYPES, this);
        }
    }

方法checkActualParameter()检查与形参对应的每个实参（按照参数位置）。如果参数是VAR参数（引用传递），则实参必须是一个类型与形参相同的变量；如果参数通过值传递，那么实参必须能够与形参类型达到赋值兼容（比如形参为real，而实参为int，而real := int是可以赋值兼容的）
清单11-19 展示了parseWriteSpec()方法，用来解析write/writeln实参中额外的宽度和精度值。

//解析write/writeln实参额外的宽度/精度 比如 writeln(xx:50:2)
   private ICodeNode parseWriteSpec(Token token)
       throws Exception
   {
       if (token.getType() == COLON) {
           token = nextToken();  // 跳过冒号

           ExpressionParser expressionParser = new ExpressionParser(this);
           ICodeNode specNode = expressionParser.parse(token);
           //必须是整数
           if (specNode.getType() == INTEGER_CONSTANT) {
               return specNode;
           }
           else {
               errorHandler.flag(token, INVALID_NUMBER, this);
               return null;
           }
       }
       else {
           return null;
       }
   }

方法parseWriteSpec()先搜寻冒号，接着解析后面的整数常量。

修改类StatementParser，使之可以处理过程调用、赋值到形参以及函数标识符。清单11-20展示了其parse()方法中switch语句部分，新版本的case IDENTIFIER。

case IDENTIFIER: {
            String name = token.getText().toLowerCase();
            SymTabEntry id = symTabStack.lookup(name);
            Definition idDefn = id != null ? id.getDefinition()
                                           : DefinitionImpl.UNDEFINED;

            // 赋值语句或是程式
            switch ((DefinitionImpl) idDefn) {

                case VARIABLE:
                case VALUE_PARM:
                case VAR_PARM:
                case UNDEFINED: {
                    AssignmentStatementParser assignmentParser =
                        new AssignmentStatementParser(this);
                    statementNode = assignmentParser.parse(token);
                    break;
                }

                case FUNCTION: {
                    AssignmentStatementParser assignmentParser =
                        new AssignmentStatementParser(this);
                    statementNode =
                        assignmentParser.parseFunctionNameAssignment(token);
                    break;
                }

                case PROCEDURE: {
                    CallParser callParser = new CallParser(this);
                    statementNode = callParser.parse(token);
                    break;
                }

                default: {
                    errorHandler.flag(token, UNEXPECTED_TOKEN, this);
                    token = nextToken();  //跳过标识符
                }
            }
        }

如果当前token是一个函数名称，方法parse()会调用assignmentParser.parseFunctionNameAssignment()；如果是过程名称，则调用callParser.parse()。

清单11-21 展示了AssignmentStatementParser额外的处理代码。

//是否是一个函数为赋值目标
private boolean isFunctionTarget = false;

//函数式的赋值
public ICodeNode parseFunctionNameAssignment(Token token)
        throws Exception
{
        isFunctionTarget = true;
        return parse(token);
}

方法parseFunctionNameAssignment()在调用parse之前设置私有isFunctionTarget为真。方法parse()同样需要个小改动。（第54行）

ICodeNode targetNode =isFunctionTarget
               ? variableParser.parseFunctionNameTarget(token)
               : variableParser.parse(token);
TypeSpec targetType = targetNode != null ? targetNode.getTypeSpec()
                                    : Predefined.undefinedType;

这需要修改类VariableParser，参见下面清单11-22