Java TokenTypes.LITERAL_FINALLY属性代码示例

@Override
public int[] getDefaultTokens() {
    return new int[] {
        TokenTypes.LITERAL_WHILE,
        TokenTypes.LITERAL_TRY,
        TokenTypes.LITERAL_FINALLY,
        TokenTypes.LITERAL_DO,
        TokenTypes.LITERAL_IF,
        TokenTypes.LITERAL_ELSE,
        TokenTypes.LITERAL_FOR,
        TokenTypes.INSTANCE_INIT,
        TokenTypes.STATIC_INIT,
        TokenTypes.LITERAL_SWITCH,
        TokenTypes.LITERAL_SYNCHRONIZED,
    };
}
 

@Override
public int[] getAcceptableTokens() {
    return new int[] {
        TokenTypes.LITERAL_WHILE,
        TokenTypes.LITERAL_TRY,
        TokenTypes.LITERAL_CATCH,
        TokenTypes.LITERAL_FINALLY,
        TokenTypes.LITERAL_DO,
        TokenTypes.LITERAL_IF,
        TokenTypes.LITERAL_ELSE,
        TokenTypes.LITERAL_FOR,
        TokenTypes.INSTANCE_INIT,
        TokenTypes.STATIC_INIT,
        TokenTypes.LITERAL_SWITCH,
        TokenTypes.LITERAL_SYNCHRONIZED,
        TokenTypes.LITERAL_CASE,
        TokenTypes.LITERAL_DEFAULT,
        TokenTypes.ARRAY_INIT,
    };
}
 

@Override
public int[] getAcceptableTokens() {
    return new int[] {
        TokenTypes.INTERFACE_DEF,
        TokenTypes.CLASS_DEF,
        TokenTypes.ANNOTATION_DEF,
        TokenTypes.ENUM_DEF,
        TokenTypes.CTOR_DEF,
        TokenTypes.METHOD_DEF,
        TokenTypes.ENUM_CONSTANT_DEF,
        TokenTypes.LITERAL_WHILE,
        TokenTypes.LITERAL_TRY,
        TokenTypes.LITERAL_CATCH,
        TokenTypes.LITERAL_FINALLY,
        TokenTypes.LITERAL_SYNCHRONIZED,
        TokenTypes.LITERAL_SWITCH,
        TokenTypes.LITERAL_DO,
        TokenTypes.LITERAL_IF,
        TokenTypes.LITERAL_ELSE,
        TokenTypes.LITERAL_FOR,
        TokenTypes.STATIC_INIT,
        TokenTypes.OBJBLOCK,
        TokenTypes.LAMBDA,
    };
}
 

@Override
public int[] getAcceptableTokens() {
    return new int[] {
        TokenTypes.LITERAL_TRY,
        TokenTypes.LITERAL_CATCH,
        TokenTypes.LITERAL_FINALLY,
        TokenTypes.LITERAL_IF,
        TokenTypes.LITERAL_ELSE,
        TokenTypes.CLASS_DEF,
        TokenTypes.METHOD_DEF,
        TokenTypes.CTOR_DEF,
        TokenTypes.LITERAL_FOR,
        TokenTypes.LITERAL_WHILE,
        TokenTypes.LITERAL_DO,
        TokenTypes.STATIC_INIT,
        TokenTypes.INSTANCE_INIT,
        TokenTypes.LAMBDA,
    };
}
 

@Override
public int[] getRequiredTokens() {
    return new int[] {
        TokenTypes.CLASS_DEF,
        TokenTypes.INTERFACE_DEF,
        TokenTypes.METHOD_DEF,
        TokenTypes.CTOR_DEF,
        TokenTypes.INSTANCE_INIT,
        TokenTypes.STATIC_INIT,
        TokenTypes.PACKAGE_DEF,
        TokenTypes.IMPORT,
        TokenTypes.VARIABLE_DEF,
        TokenTypes.CTOR_CALL,
        TokenTypes.SUPER_CTOR_CALL,
        TokenTypes.LITERAL_IF,
        TokenTypes.LITERAL_ELSE,
        TokenTypes.LITERAL_WHILE,
        TokenTypes.LITERAL_DO,
        TokenTypes.LITERAL_FOR,
        TokenTypes.LITERAL_SWITCH,
        TokenTypes.LITERAL_BREAK,
        TokenTypes.LITERAL_CONTINUE,
        TokenTypes.LITERAL_RETURN,
        TokenTypes.LITERAL_THROW,
        TokenTypes.LITERAL_SYNCHRONIZED,
        TokenTypes.LITERAL_CATCH,
        TokenTypes.LITERAL_FINALLY,
        TokenTypes.EXPR,
        TokenTypes.LABELED_STAT,
        TokenTypes.LITERAL_CASE,
        TokenTypes.LITERAL_DEFAULT,
    };
}
 

/**
 * Checks if a given try/catch/finally block terminated by return, throw or,
 * if allowed break, continue.
 * @param ast loop to check
 * @param useBreak should we consider break as terminator.
 * @param useContinue should we consider continue as terminator.
 * @return true if try/catch/finally block is terminated.
 */
private boolean checkTry(final DetailAST ast, boolean useBreak,
                         boolean useContinue) {
    final DetailAST finalStmt = ast.getLastChild();
    boolean isTerminated = false;
    if (finalStmt.getType() == TokenTypes.LITERAL_FINALLY) {
        isTerminated = isTerminated(finalStmt.findFirstToken(TokenTypes.SLIST),
                            useBreak, useContinue);
    }

    if (!isTerminated) {
        DetailAST firstChild = ast.getFirstChild();

        if (firstChild.getType() == TokenTypes.RESOURCE_SPECIFICATION) {
            firstChild = firstChild.getNextSibling();
        }

        isTerminated = isTerminated(firstChild,
                useBreak, useContinue);

        DetailAST catchStmt = ast.findFirstToken(TokenTypes.LITERAL_CATCH);
        while (catchStmt != null
                && isTerminated
                && catchStmt.getType() == TokenTypes.LITERAL_CATCH) {
            final DetailAST catchBody =
                    catchStmt.findFirstToken(TokenTypes.SLIST);
            isTerminated = isTerminated(catchBody, useBreak, useContinue);
            catchStmt = catchStmt.getNextSibling();
        }
    }
    return isTerminated;
}
 

@Override
public int[] getDefaultTokens() {
    return new int[] {
        TokenTypes.LITERAL_TRY,
        TokenTypes.LITERAL_CATCH,
        TokenTypes.LITERAL_FINALLY,
        TokenTypes.LITERAL_IF,
        TokenTypes.LITERAL_ELSE,
    };
}
 

/**
 * Collects validation Details.
 * @param ast a {@code DetailAST} value
 * @return object containing all details to make a validation
 */
private static Details getDetails(DetailAST ast) {
    final Details details;
    switch (ast.getType()) {
        case TokenTypes.LITERAL_TRY:
        case TokenTypes.LITERAL_CATCH:
        case TokenTypes.LITERAL_FINALLY:
            details = getDetailsForTryCatchFinally(ast);
            break;
        case TokenTypes.LITERAL_IF:
        case TokenTypes.LITERAL_ELSE:
            details = getDetailsForIfElse(ast);
            break;
        case TokenTypes.LITERAL_DO:
        case TokenTypes.LITERAL_WHILE:
        case TokenTypes.LITERAL_FOR:
            details = getDetailsForLoops(ast);
            break;
        case TokenTypes.LAMBDA:
            details = getDetailsForLambda(ast);
            break;
        default:
            details = getDetailsForOthers(ast);
            break;
    }
    return details;
}
 

@Test
public void testGetAcceptableTokens() {
    final JavaNCSSCheck javaNcssCheckObj = new JavaNCSSCheck();
    final int[] actual = javaNcssCheckObj.getAcceptableTokens();
    final int[] expected = {
        TokenTypes.CLASS_DEF,
        TokenTypes.INTERFACE_DEF,
        TokenTypes.METHOD_DEF,
        TokenTypes.CTOR_DEF,
        TokenTypes.INSTANCE_INIT,
        TokenTypes.STATIC_INIT,
        TokenTypes.PACKAGE_DEF,
        TokenTypes.IMPORT,
        TokenTypes.VARIABLE_DEF,
        TokenTypes.CTOR_CALL,
        TokenTypes.SUPER_CTOR_CALL,
        TokenTypes.LITERAL_IF,
        TokenTypes.LITERAL_ELSE,
        TokenTypes.LITERAL_WHILE,
        TokenTypes.LITERAL_DO,
        TokenTypes.LITERAL_FOR,
        TokenTypes.LITERAL_SWITCH,
        TokenTypes.LITERAL_BREAK,
        TokenTypes.LITERAL_CONTINUE,
        TokenTypes.LITERAL_RETURN,
        TokenTypes.LITERAL_THROW,
        TokenTypes.LITERAL_SYNCHRONIZED,
        TokenTypes.LITERAL_CATCH,
        TokenTypes.LITERAL_FINALLY,
        TokenTypes.EXPR,
        TokenTypes.LABELED_STAT,
        TokenTypes.LITERAL_CASE,
        TokenTypes.LITERAL_DEFAULT,
    };
    Assert.assertNotNull("Acceptable tokens should not be null", actual);
    Assert.assertArrayEquals("Invalid acceptable tokens", expected, actual);
}
 

@Test
public void testGetRequiredTokens() {
    final JavaNCSSCheck javaNcssCheckObj = new JavaNCSSCheck();
    final int[] actual = javaNcssCheckObj.getRequiredTokens();
    final int[] expected = {
        TokenTypes.CLASS_DEF,
        TokenTypes.INTERFACE_DEF,
        TokenTypes.METHOD_DEF,
        TokenTypes.CTOR_DEF,
        TokenTypes.INSTANCE_INIT,
        TokenTypes.STATIC_INIT,
        TokenTypes.PACKAGE_DEF,
        TokenTypes.IMPORT,
        TokenTypes.VARIABLE_DEF,
        TokenTypes.CTOR_CALL,
        TokenTypes.SUPER_CTOR_CALL,
        TokenTypes.LITERAL_IF,
        TokenTypes.LITERAL_ELSE,
        TokenTypes.LITERAL_WHILE,
        TokenTypes.LITERAL_DO,
        TokenTypes.LITERAL_FOR,
        TokenTypes.LITERAL_SWITCH,
        TokenTypes.LITERAL_BREAK,
        TokenTypes.LITERAL_CONTINUE,
        TokenTypes.LITERAL_RETURN,
        TokenTypes.LITERAL_THROW,
        TokenTypes.LITERAL_SYNCHRONIZED,
        TokenTypes.LITERAL_CATCH,
        TokenTypes.LITERAL_FINALLY,
        TokenTypes.EXPR,
        TokenTypes.LABELED_STAT,
        TokenTypes.LITERAL_CASE,
        TokenTypes.LITERAL_DEFAULT,
    };
    Assert.assertNotNull("Required tokens should not be null", actual);
    Assert.assertArrayEquals("Invalid required tokens", expected, actual);
}
 

@Test
public void testGetAcceptableTokens() {
    final LeftCurlyCheck check = new LeftCurlyCheck();
    final int[] actual = check.getAcceptableTokens();
    final int[] expected = {
        TokenTypes.INTERFACE_DEF,
        TokenTypes.CLASS_DEF,
        TokenTypes.ANNOTATION_DEF,
        TokenTypes.ENUM_DEF,
        TokenTypes.CTOR_DEF,
        TokenTypes.METHOD_DEF,
        TokenTypes.ENUM_CONSTANT_DEF,
        TokenTypes.LITERAL_WHILE,
        TokenTypes.LITERAL_TRY,
        TokenTypes.LITERAL_CATCH,
        TokenTypes.LITERAL_FINALLY,
        TokenTypes.LITERAL_SYNCHRONIZED,
        TokenTypes.LITERAL_SWITCH,
        TokenTypes.LITERAL_DO,
        TokenTypes.LITERAL_IF,
        TokenTypes.LITERAL_ELSE,
        TokenTypes.LITERAL_FOR,
        TokenTypes.STATIC_INIT,
        TokenTypes.OBJBLOCK,
        TokenTypes.LAMBDA, };
    assertArrayEquals("Default acceptable tokens are invalid", expected, actual);
}
 

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

    switch (node.getType()) {

        case TokenTypes.LITERAL_FOR :
            handleFor(block);
            break;

        case TokenTypes.LITERAL_IF :
            handleIf(block);
            break;

        case TokenTypes.LITERAL_WHILE :
            handleWhileAndSynchronized(block);
            break;

        case TokenTypes.LITERAL_DO :
            handleDoWhile(block);
            break;

        case TokenTypes.LITERAL_TRY :
        case TokenTypes.LITERAL_FINALLY :
            SymTabAST slist = node.findFirstToken(TokenTypes.SLIST);

            handleSList(slist, block);
            break;

        case TokenTypes.LITERAL_CATCH :
            handleCatch(block);
            break;

        case TokenTypes.LITERAL_SWITCH :
            handleSwitch(block);
            break;

        case TokenTypes.SLIST :
            handleSList(node, block);
            break;

        case TokenTypes.EXPR :
            resolveExpression(node, block, null, true);
            break;

        case TokenTypes.INSTANCE_INIT :
        case TokenTypes.STATIC_INIT :
            handleSList((SymTabAST) node.getFirstChild(), block);
            break;

        case TokenTypes.LITERAL_SYNCHRONIZED :
            handleWhileAndSynchronized(block);
            break;

        case TokenTypes.LITERAL_ASSERT :
            handleAssert(block);
            break;

        default :
            if (mInitialized) {
                final Log log = mLogFactory.getInstance(this.getClass());
                log.error(
                    "Unhandled block "
                        + block
                        + " of type "
                        + node.getType());
            }
    }
}
 

@Override
public void visitToken(DetailAST ast) {
    final DetailAST startToken;
    DetailAST brace;

    switch (ast.getType()) {
        case TokenTypes.CTOR_DEF:
        case TokenTypes.METHOD_DEF:
            startToken = skipAnnotationOnlyLines(ast);
            brace = ast.findFirstToken(TokenTypes.SLIST);
            break;
        case TokenTypes.INTERFACE_DEF:
        case TokenTypes.CLASS_DEF:
        case TokenTypes.ANNOTATION_DEF:
        case TokenTypes.ENUM_DEF:
        case TokenTypes.ENUM_CONSTANT_DEF:
            startToken = skipAnnotationOnlyLines(ast);
            final DetailAST objBlock = ast.findFirstToken(TokenTypes.OBJBLOCK);
            brace = objBlock;

            if (objBlock != null) {
                brace = objBlock.getFirstChild();
            }
            break;
        case TokenTypes.LITERAL_WHILE:
        case TokenTypes.LITERAL_CATCH:
        case TokenTypes.LITERAL_SYNCHRONIZED:
        case TokenTypes.LITERAL_FOR:
        case TokenTypes.LITERAL_TRY:
        case TokenTypes.LITERAL_FINALLY:
        case TokenTypes.LITERAL_DO:
        case TokenTypes.LITERAL_IF:
        case TokenTypes.STATIC_INIT:
        case TokenTypes.LAMBDA:
            startToken = ast;
            brace = ast.findFirstToken(TokenTypes.SLIST);
            break;
        case TokenTypes.LITERAL_ELSE:
            startToken = ast;
            final DetailAST candidate = ast.getFirstChild();
            brace = null;

            if (candidate.getType() == TokenTypes.SLIST) {
                brace = candidate;
            }
            break;
        default:
            // ATTENTION! We have default here, but we expect case TokenTypes.METHOD_DEF,
            // TokenTypes.LITERAL_FOR, TokenTypes.LITERAL_WHILE, TokenTypes.LITERAL_DO only.
            // It has been done to improve coverage to 100%. I couldn't replace it with
            // if-else-if block because code was ugly and didn't pass pmd check.

            startToken = ast;
            brace = ast.findFirstToken(TokenTypes.LCURLY);
            break;
    }

    if (brace != null) {
        verifyBrace(brace, startToken);
    }
}
 

@Override
public int[] getDefaultTokens() {
    return new int[] {
        TokenTypes.ASSIGN,
        TokenTypes.BAND,
        TokenTypes.BAND_ASSIGN,
        TokenTypes.BOR,
        TokenTypes.BOR_ASSIGN,
        TokenTypes.BSR,
        TokenTypes.BSR_ASSIGN,
        TokenTypes.BXOR,
        TokenTypes.BXOR_ASSIGN,
        TokenTypes.COLON,
        TokenTypes.DIV,
        TokenTypes.DIV_ASSIGN,
        TokenTypes.DO_WHILE,
        TokenTypes.EQUAL,
        TokenTypes.GE,
        TokenTypes.GT,
        TokenTypes.LAMBDA,
        TokenTypes.LAND,
        TokenTypes.LCURLY,
        TokenTypes.LE,
        TokenTypes.LITERAL_CATCH,
        TokenTypes.LITERAL_DO,
        TokenTypes.LITERAL_ELSE,
        TokenTypes.LITERAL_FINALLY,
        TokenTypes.LITERAL_FOR,
        TokenTypes.LITERAL_IF,
        TokenTypes.LITERAL_RETURN,
        TokenTypes.LITERAL_SWITCH,
        TokenTypes.LITERAL_SYNCHRONIZED,
        TokenTypes.LITERAL_TRY,
        TokenTypes.LITERAL_WHILE,
        TokenTypes.LOR,
        TokenTypes.LT,
        TokenTypes.MINUS,
        TokenTypes.MINUS_ASSIGN,
        TokenTypes.MOD,
        TokenTypes.MOD_ASSIGN,
        TokenTypes.NOT_EQUAL,
        TokenTypes.PLUS,
        TokenTypes.PLUS_ASSIGN,
        TokenTypes.QUESTION,
        TokenTypes.RCURLY,
        TokenTypes.SL,
        TokenTypes.SLIST,
        TokenTypes.SL_ASSIGN,
        TokenTypes.SR,
        TokenTypes.SR_ASSIGN,
        TokenTypes.STAR,
        TokenTypes.STAR_ASSIGN,
        TokenTypes.LITERAL_ASSERT,
        TokenTypes.TYPE_EXTENSION_AND,
    };
}
 

@Override
public int[] getAcceptableTokens() {
    return new int[] {
        TokenTypes.ASSIGN,
        TokenTypes.ARRAY_INIT,
        TokenTypes.BAND,
        TokenTypes.BAND_ASSIGN,
        TokenTypes.BOR,
        TokenTypes.BOR_ASSIGN,
        TokenTypes.BSR,
        TokenTypes.BSR_ASSIGN,
        TokenTypes.BXOR,
        TokenTypes.BXOR_ASSIGN,
        TokenTypes.COLON,
        TokenTypes.DIV,
        TokenTypes.DIV_ASSIGN,
        TokenTypes.DO_WHILE,
        TokenTypes.EQUAL,
        TokenTypes.GE,
        TokenTypes.GT,
        TokenTypes.LAMBDA,
        TokenTypes.LAND,
        TokenTypes.LCURLY,
        TokenTypes.LE,
        TokenTypes.LITERAL_CATCH,
        TokenTypes.LITERAL_DO,
        TokenTypes.LITERAL_ELSE,
        TokenTypes.LITERAL_FINALLY,
        TokenTypes.LITERAL_FOR,
        TokenTypes.LITERAL_IF,
        TokenTypes.LITERAL_RETURN,
        TokenTypes.LITERAL_SWITCH,
        TokenTypes.LITERAL_SYNCHRONIZED,
        TokenTypes.LITERAL_TRY,
        TokenTypes.LITERAL_WHILE,
        TokenTypes.LOR,
        TokenTypes.LT,
        TokenTypes.MINUS,
        TokenTypes.MINUS_ASSIGN,
        TokenTypes.MOD,
        TokenTypes.MOD_ASSIGN,
        TokenTypes.NOT_EQUAL,
        TokenTypes.PLUS,
        TokenTypes.PLUS_ASSIGN,
        TokenTypes.QUESTION,
        TokenTypes.RCURLY,
        TokenTypes.SL,
        TokenTypes.SLIST,
        TokenTypes.SL_ASSIGN,
        TokenTypes.SR,
        TokenTypes.SR_ASSIGN,
        TokenTypes.STAR,
        TokenTypes.STAR_ASSIGN,
        TokenTypes.LITERAL_ASSERT,
        TokenTypes.TYPE_EXTENSION_AND,
        TokenTypes.WILDCARD_TYPE,
        TokenTypes.GENERIC_START,
        TokenTypes.GENERIC_END,
        TokenTypes.ELLIPSIS,
    };
}