Java BlockStatement.getStatements方法代码示例

import org.codehaus.groovy.ast.stmt.BlockStatement; //导入方法依赖的package包/类
@Override
public void call(SourceUnit source) throws CompilationFailedException {
    BlockStatement statementBlock = source.getAST().getStatementBlock();
    List<Statement> statements = statementBlock.getStatements();
    for (Statement statement : statements) {
        if (!AstUtils.mayHaveAnEffect(statement)) {
            continue;
        }
        ScriptBlock scriptBlock = AstUtils.detectScriptBlock(statement);
        if (scriptBlock != null && scriptBlock.getName().equals(ModelBlockTransformer.MODEL)) {
            continue;
        }
        imperativeStatementDetected = true;
        break;
    }
}
 

import org.codehaus.groovy.ast.stmt.BlockStatement; //导入方法依赖的package包/类
@Override
public void visitClosureExpression(final ClosureExpression expression) {
    super.visitClosureExpression(expression);
    if (inBuilderMethod) {
        Statement oldCode = expression.getCode();
        BlockStatement block = oldCode instanceof BlockStatement?
                ((BlockStatement)oldCode):
                new BlockStatement(Arrays.asList(oldCode), new VariableScope());
        List<Statement> statements = block.getStatements();
        if (!statements.isEmpty()) {
            Statement first = statements.get(0);
            Statement last = statements.get(statements.size()-1);
            if (expression.getLineNumber()<first.getLineNumber()) {
                // there's a new line between { -> ... and the first statement
                statements.add(0,createNewLine(expression));
            }
            if (expression.getLastLineNumber()>last.getLastLineNumber()) {
                // there's a new line between { -> ... and the first statement
                statements.add(createNewLine(expression));
            }
        }
        expression.setCode(block);
    }
}
 

import org.codehaus.groovy.ast.stmt.BlockStatement; //导入方法依赖的package包/类
private ConstructorCallExpression checkThisAndSuperConstructorCall(Statement statement) {
    if (!(statement instanceof BlockStatement)) { // method code must be a BlockStatement
        return null;
    }

    BlockStatement blockStatement = (BlockStatement) statement;
    List<Statement> statementList = blockStatement.getStatements();

    for (int i = 0, n = statementList.size(); i < n; i++) {
        Statement s = statementList.get(i);
        if (s instanceof ExpressionStatement) {
            Expression expression = ((ExpressionStatement) s).getExpression();
            if ((expression instanceof ConstructorCallExpression) && 0 != i) {
                return (ConstructorCallExpression) expression;
            }
        }
    }

    return null;
}
 

import org.codehaus.groovy.ast.stmt.BlockStatement; //导入方法依赖的package包/类
public void positionStmtsAfterEnumInitStmts(List<Statement> staticFieldStatements) {
    MethodNode method = getOrAddStaticConstructorNode();
    Statement statement = method.getCode();
    if (statement instanceof BlockStatement) {
        BlockStatement block = (BlockStatement) statement;
        // add given statements for explicitly declared static fields just after enum-special fields
        // are found - the $VALUES binary expression marks the end of such fields.
        List<Statement> blockStatements = block.getStatements();
        ListIterator<Statement> litr = blockStatements.listIterator();
        while (litr.hasNext()) {
            Statement stmt = litr.next();
            if (stmt instanceof ExpressionStatement &&
                    ((ExpressionStatement) stmt).getExpression() instanceof BinaryExpression) {
                BinaryExpression bExp = (BinaryExpression) ((ExpressionStatement) stmt).getExpression();
                if (bExp.getLeftExpression() instanceof FieldExpression) {
                    FieldExpression fExp = (FieldExpression) bExp.getLeftExpression();
                    if (fExp.getFieldName().equals("$VALUES")) {
                        for (Statement tmpStmt : staticFieldStatements) {
                            litr.add(tmpStmt);
                        }
                    }
                }
            }
        }
    }
}
 

import org.codehaus.groovy.ast.stmt.BlockStatement; //导入方法依赖的package包/类
public static boolean copyStatementsWithSuperAdjustment(ClosureExpression pre, BlockStatement body) {
    Statement preCode = pre.getCode();
    boolean changed = false;
    if (preCode instanceof BlockStatement) {
        BlockStatement block = (BlockStatement) preCode;
        List<Statement> statements = block.getStatements();
        for (int i = 0; i < statements.size(); i++) {
            Statement statement = statements.get(i);
            // adjust the first statement if it's a super call
            if (i == 0 && statement instanceof ExpressionStatement) {
                ExpressionStatement es = (ExpressionStatement) statement;
                Expression preExp = es.getExpression();
                if (preExp instanceof MethodCallExpression) {
                    MethodCallExpression mce = (MethodCallExpression) preExp;
                    String name = mce.getMethodAsString();
                    if ("super".equals(name)) {
                        es.setExpression(new ConstructorCallExpression(ClassNode.SUPER, mce.getArguments()));
                        changed = true;
                    }
                }
            }
            body.addStatement(statement);
        }
    }
    return changed;
}
 

import org.codehaus.groovy.ast.stmt.BlockStatement; //导入方法依赖的package包/类
@Override
public void visitBlockStatement(BlockStatement block) {
    opt.push();
    boolean optAll = true;
    for (Statement statement : block.getStatements()) {
        opt.push();
        statement.visit(this);
        optAll = optAll && opt.canOptimize();
        opt.pop(true);
    }
    if (block.isEmpty()) {
        opt.chainCanOptimize(true);
        opt.pop(true);
    } else {
        opt.chainShouldOptimize(optAll);
        if (optAll) addMeta(block,opt);
        opt.pop(optAll);
    }
}
 

import org.codehaus.groovy.ast.stmt.BlockStatement; //导入方法依赖的package包/类
private static ConstructorCallExpression getConstructorCallExpression(ConstructorNode constructorNode) {
    Statement code = constructorNode.getCode();
    if (!(code instanceof BlockStatement))
        return null;

    BlockStatement block = (BlockStatement) code;
    List stats = block.getStatements();
    if (stats == null || stats.isEmpty())
        return null;

    Statement stat = (Statement) stats.get(0);
    if (!(stat instanceof ExpressionStatement))
        return null;

    Expression expr = ((ExpressionStatement) stat).getExpression();
    if (!(expr instanceof ConstructorCallExpression))
        return null;

    return (ConstructorCallExpression) expr;
}
 

import org.codehaus.groovy.ast.stmt.BlockStatement; //导入方法依赖的package包/类
@Override
public void visitBlockStatement(BlockStatement block) {
    block.setNodeMetaData(AST_NODE_METADATA_KEY, true);

    for (Statement statement : block.getStatements()) {
        statement.visit(this);
    }
}
 

import org.codehaus.groovy.ast.stmt.BlockStatement; //导入方法依赖的package包/类
protected void completeFutureByResults(CompletableFuture<EGradleBuildscriptResult> future, List<ASTNode> result) {
	for (ASTNode node : result) {
		BlockStatement bs = (BlockStatement) node;
		for (org.codehaus.groovy.ast.stmt.Statement st : bs.getStatements()) {
			if (st instanceof ReturnStatement) {
				ReturnStatement rs = (ReturnStatement) st;
				Expression expression = rs.getExpression();
				if (expression instanceof DeclarationExpression) {
					DeclarationExpression de = (DeclarationExpression) expression;
					String name = de.getVariableExpression().getName();
					if (! "buildscript".equals(name)){
						continue;
					}
					Expression right = de.getRightExpression();
					if (right instanceof ClosureExpression) {
						ClosureExpression ce = (ClosureExpression) right;
						Statement buildCode = ce.getCode();
						
						future.complete(new EGradleBuildscriptResult(buildCode));
						return;
					}else{
						future.complete(new EGradleBuildscriptResult(new EGradleBuildScriptException("Did not found expected buildscript closure ,but:"+right)));
						return;
					}
				}
			}
		}
	}
}
 

import org.codehaus.groovy.ast.stmt.BlockStatement; //导入方法依赖的package包/类
private static List<ExpressionStatement> getExpressionStatements(
		BlockStatement block) {
	ArrayList<ExpressionStatement> statements = new ArrayList<ExpressionStatement>();
	for (Statement statement : block.getStatements()) {
		if (statement instanceof ExpressionStatement) {
			statements.add((ExpressionStatement) statement);
		}
	}
	return statements;
}
 

import org.codehaus.groovy.ast.stmt.BlockStatement; //导入方法依赖的package包/类
private void extractModelTypesFromStatement(final Statement code, final Map<String, ClassNode> model) {
    if (code instanceof BlockStatement) {
        BlockStatement block = (BlockStatement) code;
        for (Statement statement : block.getStatements()) {
            extractModelTypesFromStatement(statement, model);
        }
    } else if (code instanceof ExpressionStatement) {
        Expression expression = ((ExpressionStatement) code).getExpression();
        if (expression instanceof DeclarationExpression) {
            VariableExpression var = ((DeclarationExpression) expression).getVariableExpression();
            model.put(var.getName(), var.getOriginType());
        }
    }
}
 

import org.codehaus.groovy.ast.stmt.BlockStatement; //导入方法依赖的package包/类
private static ConstructorCallExpression getFirstIfSpecialConstructorCall(BlockStatement code) {
    if (code == null) return null;

    final List<Statement> statementList = code.getStatements();
    if (statementList.isEmpty()) return null;

    final Statement statement = statementList.get(0);
    if (!(statement instanceof ExpressionStatement)) return null;

    Expression expression = ((ExpressionStatement) statement).getExpression();
    if (!(expression instanceof ConstructorCallExpression)) return null;
    ConstructorCallExpression cce = (ConstructorCallExpression) expression;
    if (cce.isSpecialCall()) return cce;
    return null;
}
 

import org.codehaus.groovy.ast.stmt.BlockStatement; //导入方法依赖的package包/类
public void writeBlockStatement(BlockStatement block) {
    CompileStack compileStack = controller.getCompileStack();

    //GROOVY-4505 use no line number information for the block
    writeStatementLabel(block);
    
    int mark = controller.getOperandStack().getStackLength();
    compileStack.pushVariableScope(block.getVariableScope());
    for (Statement statement : block.getStatements()) {
        statement.visit(controller.getAcg());
    }
    compileStack.pop();

    controller.getOperandStack().popDownTo(mark);
}
 

import org.codehaus.groovy.ast.stmt.BlockStatement; //导入方法依赖的package包/类
private void inspectBlockStatement(int childIndent, BlockStatement blockStatement) {
	List<Statement> children = blockStatement.getStatements();
	for (Statement child : children) {
		inspect(child, childIndent);
	}
}
 

import org.codehaus.groovy.ast.stmt.BlockStatement; //导入方法依赖的package包/类
public void visitBlockStatement(final BlockStatement block) {
    assertStatementAuthorized(block);
    for (Statement statement : block.getStatements()) {
        statement.visit(this);
    }
}