resolver.java

Checkstyle 可寻找：·不能使用的或者多余的输入 ·空格更好的地方不使用跳格符

            resolveExpression(
                (forEach.findFirstToken(TokenTypes.EXPR)),
                block,
                null,
                true);
            body = (SymTabAST) (forEach.getNextSibling());
        }
        //could be an SLIST, EXPR or an EMPTY_STAT
        if (body.getType() == TokenTypes.RPAREN) {
            body = (SymTabAST) body.getNextSibling();
        }
        if (body.getType() == TokenTypes.SLIST) {
            handleSList(body, block);
        }
        else {
            resolveExpression(body, block, null, true);
        }

    }

    /**
     * processes an if statement and resolves references in it
     *
     * @param block the <code>BlockDef</code> to process
     */
    private void handleIf(BlockDef block) {
        SymTabAST node = block.getTreeNode();

        SymTabAST conditional =
            (node.findFirstToken(TokenTypes.EXPR));
        resolveExpression(conditional, block, null, true);

        SymTabAST body = (SymTabAST) conditional.getNextSibling();
        // Handle Checkstyle grammar
        if (body.getType() == TokenTypes.RPAREN) {
            body = (SymTabAST) body.getNextSibling();
        }
        if (body != null) {
        	if (body.getType() == TokenTypes.SLIST) {
            	handleSList(body, block);
        	}
        	else {
            	resolveExpression(body, block, null, true);
        	}

	        SymTabAST elseBody = (SymTabAST) body.getNextSibling();
	        //handle Checkstyle grammar
	        while ((elseBody != null)
	            && (elseBody.getType() != TokenTypes.LITERAL_ELSE)) {
	            elseBody = (SymTabAST) elseBody.getNextSibling();
	        }
	        /*
	         if (elseBody != null && elseBody.getType() == TokenTypes.SLIST) {
	             handleSList(elseBody, block);
	         }else{
	             resolveExpression(elseBody, block, null, true);
	         }
	         */
	        if (elseBody != null) {
	            elseBody = (SymTabAST) elseBody.getFirstChild();
	        }
	        if (elseBody != null) {
	            resolveExpression(elseBody, block.getParentScope(), null, true);
	        }
	    }
    }

    /**
     * processes a while loop and resolves references in it
     *
     * @param block the <code>BlockDef</code> to process
     */
    private void handleWhileAndSynchronized(BlockDef block) {
        SymTabAST node = block.getTreeNode();

        SymTabAST condition =
            (node.findFirstToken(TokenTypes.EXPR));
        SymTabAST slist = (SymTabAST) (condition.getNextSibling());
        // handle Checkstyle grammar
        if (slist.getType() == TokenTypes.RPAREN) {
            slist = (SymTabAST) slist.getNextSibling();
        }

        resolveExpression(condition, block, null, true);
        handleSList(slist, block);
    }

    private void handleDoWhile(BlockDef block) {
        SymTabAST node = block.getTreeNode();

        SymTabAST slist = (SymTabAST) node.getFirstChild();
        SymTabAST condition =
            node.findFirstToken(TokenTypes.EXPR);

        handleSList(slist, block);
        resolveExpression(condition, block, null, true);
    }

    /**
     * processes a variable definition and resolves references in it
     *
     * @param variable the <code>VariableDef</code> to process
     */
    protected void handleVariable(VariableDef variable) {
        SymTabAST node = variable.getTreeNode();
        Scope location = variable.getParentScope();

        SymTabAST nameNode = node.findFirstToken(TokenTypes.IDENT);
        nameNode.setDefinition(variable, location, true);

        SymTabAST typeNode = node.findFirstToken(TokenTypes.TYPE);
        resolveType(typeNode, location, null, true);

        SymTabAST assignmentNode = node.findFirstToken(TokenTypes.ASSIGN);
        if (assignmentNode != null) {
            resolveExpression(
                (SymTabAST) (assignmentNode.getFirstChild()),
                variable.getParentScope(),
                null,
                true);
        }
    }

    /**
     * processes a label and resolves references in it
     *
     * @param label the <code>LabelDef</code> to process
     */
    protected void handleLabel(LabelDef label) {
        SymTabAST node = label.getTreeNode();
        ((SymTabAST) node.getFirstChild()).setDefinition(
            label,
            label.getParentScope(),
            true);
    }

    /**
     * Resolves Java expressions, returning the type to which the expression
     * evalutes.  If this is the reference creation phase, any references found during resolution are created and
     * resolved.
     *
     * @param expression the <code>SymTabAST</code> representing the expression
     * @param location the <code>Scope</code> in which the expression occours.
     * @param context the <code>Scope</code> in which the search for the
     *                definition will start
     * @param referencePhase whether or not this is the reference phase of
     *                       table construction
     *
     * @return the <code>ClassDef</code> representing the type to which the
     *         expression evalutes.
     */
    public IClass resolveExpression(
        SymTabAST expression,
        Scope location,
        IClass context,
        boolean referencePhase) {
        IClass result = null;

        try {

            switch (expression.getType()) {

                case TokenTypes.TYPECAST :
                    result =
                        resolveTypecast(
                            expression,
                            location,
                            context,
                            referencePhase);
                    break;
                case TokenTypes.EXPR :
                case TokenTypes.LITERAL_RETURN :
                    if (expression.getFirstChild() != null) {
                        result =
                            resolveExpression(
                                (SymTabAST) expression.getFirstChild(),
                                location,
                                context,
                                referencePhase);
                    }
                    else {
                        // YOU WRITE BAD CODE!
                    }
                    break;

                case TokenTypes.ELIST :

                    SymTabAST child = (SymTabAST) (expression.getFirstChild());
                    while (child != null) {
                        if (child.getType() != TokenTypes.COMMA) {
                            resolveExpression(
                                child,
                                location,
                                context,
                                referencePhase);
                        }
                        child = (SymTabAST) (child.getNextSibling());
                    }
                    break;

                case TokenTypes.IDENT :
                    result =
                        resolveIdent(
                            expression,
                            location,
                            context,
                            referencePhase);
                    break;

                case TokenTypes.TYPE :
                    result =
                        resolveType(
                            expression,
                            location,
                            context,
                            referencePhase);
                    break;

                case TokenTypes.METHOD_CALL :
                //case TokenTypes.SUPER_CTOR_CALL :
                    result =
                        resolveMethod(
                            expression,
                            location,
                            context,
                            referencePhase);
                    break;

                case TokenTypes.LITERAL_THIS :
                    result = resolveLiteralThis(expression, location, context);
                    break;

                case TokenTypes.LITERAL_SUPER :
                    result = resolveLiteralSuper(expression, location, context);
                    break;

                case TokenTypes.DOT :
                    result =
                        resolveDottedName(
                            expression,
                            location,
                            context,
                            referencePhase);
                    break;

                case TokenTypes.LITERAL_NEW :
                case TokenTypes.CTOR_CALL :
                case TokenTypes.SUPER_CTOR_CALL :
                    result =
                        resolveNew(
                            expression,
                            location,
                            context,
                            referencePhase);
                    break;

                case TokenTypes.LITERAL_BOOLEAN :
                case TokenTypes.LITERAL_DOUBLE :
                case TokenTypes.LITERAL_FLOAT :
                case TokenTypes.LITERAL_LONG :
                case TokenTypes.LITERAL_INT :
                case TokenTypes.LITERAL_SHORT :
                case TokenTypes.LITERAL_BYTE :
                case TokenTypes.LITERAL_CHAR :
                    result =
                        resolvePrimitiveType(
                            expression,
                            location,
                            context,
                            referencePhase);
                    break;

                case TokenTypes.NUM_INT :
                case TokenTypes.NUM_LONG :
                    result = resolveNumInt(expression, location, context);
                    break;

                case TokenTypes.NUM_FLOAT :
                case TokenTypes.NUM_DOUBLE :
                    result = resolveNumFloat(expression, location, context);
                    break;

                case TokenTypes.STRING_LITERAL :
                    result =
                        resolveStringLiteral(expression, location, context);
                    break;

                case TokenTypes.CHAR_LITERAL :
                    result = resolveCharLiteral(expression, location, context);
                    break;

                case TokenTypes.ASSIGN :
                case TokenTypes.PLUS_ASSIGN :
                case TokenTypes.MINUS_ASSIGN :
                case TokenTypes.STAR_ASSIGN :
                case TokenTypes.DIV_ASSIGN :
                case TokenTypes.MOD_ASSIGN :
                case TokenTypes.SR_ASSIGN :
                case TokenTypes.BSR_ASSIGN :
                case TokenTypes.SL_ASSIGN :
                case TokenTypes.BAND_ASSIGN :
                case TokenTypes.BXOR_ASSIGN :
                case TokenTypes.BOR_ASSIGN :
                    resolveAssignment(
                        expression,
                        location,
                        context,
                        referencePhase);
                    break;

                case TokenTypes.LOR :
                case TokenTypes.LAND :
                case TokenTypes.NOT_EQUAL :
                case TokenTypes.EQUAL :
                case TokenTypes.LT :
                case TokenTypes.GT :
                case TokenTypes.LE :
                case TokenTypes.GE :
                    result =
                        resolveBooleanExpression(
                            expression,
                            location,
                            context,
                            referencePhase);
                    break;

                case TokenTypes.LITERAL_INSTANCEOF :
                    result =
                        resolveInstanceOf(
                            expression,
                            location,
                            context,
                            referencePhase);
                    break;

                case TokenTypes.LITERAL_TRUE :
                case TokenTypes.LITERAL_FALSE :
                    result =
                        resolveBooleanLiteral(expression, location, context);
                    break;

                case TokenTypes.LNOT :
                    result =
                        resolveBooleanUnary(
                            expression,
                            location,
                            context,
                            referencePhase);
                    break;

                case TokenTypes.INC :
                case TokenTypes.POST_INC :
                case TokenTypes.DEC :
                case TokenTypes.POST_DEC :
                case TokenTypes.UNARY_PLUS :
                case TokenTypes.UNARY_MINUS :
                    result =
                        resolveUnaryExpression(
                            expression,
                            location,
                            context,
                            referencePhase);
                    break;

                case TokenTypes.PLUS :
                case TokenTypes.MINUS :
                case TokenTypes.DIV :