import japa.parser.ast.stmt.Statement; //导入依赖的package包/类
private ArrayList<FixtureCall> extractFixtureCalls(UseCase useCase,MethodDeclaration methodDeclaration) {
    ArrayList<FixtureCall> fixtureCalls = new ArrayList<FixtureCall>();
    if( methodDeclaration.getBody().getStmts() == null){
        System.err.println("In class "+javaClass.getCanonicalName()+" method " + methodDeclaration.getName() + " don't have any fixture call.");
        return fixtureCalls;
    }
    int line = methodDeclaration.getBody().getBeginLine();
    for (Statement stmt : methodDeclaration.getBody().getStmts()) {
        if (stmt instanceof ExpressionStmt) {
            Expression expr = ((ExpressionStmt) stmt).getExpression();
            if (expr instanceof MethodCallExpr) {
                final int emptyLines = stmt.getBeginLine() - 1 - line;
                fixtureCalls.add(extractFixtureCall(useCase, (MethodCallExpr) expr,emptyLines));
                line= stmt.getBeginLine();
            }
        }
    }
    return fixtureCalls;
}
 

import japa.parser.ast.stmt.Statement; //导入依赖的package包/类
private boolean isGetterMethod(MethodDeclaration method)
{
    if ((method.getBody() != null) && (method.getBody().getStmts() != null))
    {
        LinkedList<String> attNames = getAttributesNames();
        
        if (attNames.size() == 0)
            return false;
        
        List<Statement> stmts = method.getBody().getStmts();        

        for (Statement stmt : stmts)
            for (String name : attNames)
                if ((stmt.toString().matches("(.*)return(\\s+)" + name + "(\\s*);")) && (method.getModifiers() == ModifierSet.PUBLIC) && (method.getParameters() == null))
                    return true;
    }
    
    return false;
}
 

import japa.parser.ast.stmt.Statement; //导入依赖的package包/类
private boolean isSetterMethod(MethodDeclaration method)
{
    if ((method.getBody() != null) && (method.getBody().getStmts() != null))
    {
        LinkedList<String> attNames = getAttributesNames();
        
        if (attNames.size() == 0)
            return false;
        
        List<Statement> stmts = method.getBody().getStmts();        

        for (Statement stmt : stmts)
            for (String name : attNames)
                if ((method.getModifiers() == ModifierSet.PUBLIC) && (method.getParameters() != null) && (method.getParameters().size() == 1) && (method.getType().equals(new VoidType())) && (stmt.toString().matches("(.*)"+name+"(\\s*)=(.*)"+method.getParameters().get(0).getId().getName()+"(.*);")))
                    return true;
    }
    
    return false;
}
 

import japa.parser.ast.stmt.Statement; //导入依赖的package包/类
@Override
public Boolean visit(BlockStmt n, Void arg) {
    boolean needsProcessing = false;

    if (n.getStmts() != null) {
        for (Statement s : n.getStmts()) {
            needsProcessing = s.accept(this, arg) || needsProcessing;
        }
    }
    if (needsProcessing) {
        NodeAnnotation nodeAnnotation = new NodeAnnotation(true);
        n.setData(nodeAnnotation);
    }
    return needsProcessing;

}
 

import japa.parser.ast.stmt.Statement; //导入依赖的package包/类
/**
 * Add a statement to the given state.
 */
void addStatement(int state, Statement stmt) {
    List<Statement> stmts = this.states.get(state).getStmts();

    if (stmts.size() > 0) {
        Statement lastStmt = stmts.get(stmts.size() - 1);
        // Preemptively eliminate dead code.
        if (lastStmt.getClass().equals(ReturnStmt.class) ||
            lastStmt.getClass().equals(ThrowStmt.class) ||
            lastStmt.getClass().equals(BreakStmt.class) ||
            lastStmt.getClass().equals(ContinueStmt.class)) {
            return;
        }
    }

    stmts.add(stmt);
}
 

import japa.parser.ast.stmt.Statement; //导入依赖的package包/类
public void visit(SwitchEntryStmt n, Object arg) {
    if (n.getLabel() != null) {
        printer.print("case ");
        n.getLabel().accept(this, arg);
        printer.print(":");
    } else {
        printer.print("default:");
    }
    printer.printLn();
    printer.indent();
    if (n.getStmts() != null) {
        for (Statement s : n.getStmts()) {
            s.accept(this, arg);
            printer.printLn();
        }
    }
    printer.unindent();
}
 

import japa.parser.ast.stmt.Statement; //导入依赖的package包/类
public Node visit(ForStmt n, A arg) {
    List<Expression> init = n.getInit();
    if (init != null) {
        for (int i = 0; i < init.size(); i++) {
            init.set(i, (Expression) init.get(i).accept(this, arg));
        }
        removeNulls(init);
    }
    if (n.getCompare() != null) {
        n.setCompare((Expression) n.getCompare().accept(this, arg));
    }
    List<Expression> update = n.getUpdate();
    if (update != null) {
        for (int i = 0; i < update.size(); i++) {
            update.set(i, (Expression) update.get(i).accept(this, arg));
        }
        removeNulls(update);
    }
    n.setBody((Statement) n.getBody().accept(this, arg));
    return n;
}
 

import japa.parser.ast.stmt.Statement; //导入依赖的package包/类
private static AssignExpr findRootAssignExpr(BlockStmt body) {
    if (body.getStmts() != null) {
        for (Statement s : body.getStmts()) {
            if (s instanceof ExpressionStmt) {
                ExpressionStmt est = (ExpressionStmt) s;
                if (est.getExpression() instanceof AssignExpr) {
                    AssignExpr ass = (AssignExpr) est.getExpression();
                    if (ass.getTarget() instanceof FieldAccessExpr) {
                        FieldAccessExpr fae = (FieldAccessExpr) ass.getTarget();
                        if ("root".equals(fae.getField())) {
                            return ass;
                        }
                    }
                }
            }
        }
    }
    return null;
}
 

import japa.parser.ast.stmt.Statement; //导入依赖的package包/类
private void addAttachSkeleton() {
	List<Parameter> params = Collections.emptyList();
	MethodDeclaration method = new MethodDeclaration(
			ModifierSet.PUBLIC, new VoidType(), "attach", params);
	AnnotationExpr override = new MarkerAnnotationExpr(new NameExpr("Override"));
	method.setAnnotations(Collections.singletonList(override));
	
	BlockStmt block = new BlockStmt();
	Expression e = new MethodCallExpr(new SuperExpr(), "attach");
	List<Statement> sts = Collections.singletonList((Statement)new ExpressionStmt(e));
	block.setStmts(sts);
	method.setBody(block);
	
	if (getType().getMembers()==null) {
		getType().setMembers(new LinkedList<BodyDeclaration>());
	}
	getType().getMembers().add(method);
}
 

import japa.parser.ast.stmt.Statement; //导入依赖的package包/类
@SuppressWarnings("unused")
private void addOnBecomingVisibleMethod() {
	List<Parameter> params = Collections.emptyList();
	MethodDeclaration method = new MethodDeclaration(
			ModifierSet.PUBLIC, new VoidType(), "onBecomingVisible", params);
	AnnotationExpr override = new MarkerAnnotationExpr(new NameExpr("Override"));
	method.setAnnotations(Collections.singletonList(override));
	
	BlockStmt block = new BlockStmt();
	Expression e = new MethodCallExpr(new SuperExpr(), "onBecomingVisible");
	List<Statement> sts = Collections.singletonList((Statement)new ExpressionStmt(e));
	block.setStmts(sts);
	method.setBody(block);
	
	if (getType().getMembers()==null) {
		getType().setMembers(new LinkedList<BodyDeclaration>());
	}
	getType().getMembers().add(method);
}
 

import japa.parser.ast.stmt.Statement; //导入依赖的package包/类
@Override
public void visit(DoStmt n, Object arg)
{	Statement statement = n.getBody();
	checkBlock(statement);
	statement.accept(this, arg);
       n.getCondition().accept(this, arg);
   }
 

import japa.parser.ast.stmt.Statement; //导入依赖的package包/类
@Override
public void visit(SwitchEntryStmt n, Generator arg) {
    if (n.getStmts() == null) {
        // We need to generate an implicit jump to the next state.
        // XXX: I'm not sure if this is safe...
        arg.addStatement(Generator.generateDeferredJump(arg.getCurrentState() + 1));
    } else {
        for (Statement stmt : n.getStmts()) {
            stmt.accept(this, arg);
        }
    }
}
 

import japa.parser.ast.stmt.Statement; //导入依赖的package包/类
/**
 * Make a loop condition enforced.
 */
private static Statement makeLoopCondition(Expression cond) {
    if (cond == null) return null;

    return new IfStmt(new UnaryExpr(cond, UnaryExpr.Operator.not),
                      new BreakStmt(null), null);
}
 

import japa.parser.ast.stmt.Statement; //导入依赖的package包/类
@Override
public Node visit(DoStmt n, Void arg) {
    super.visit(n, arg);

    // Reword the loop.
    List<Statement> stmts = new ArrayList<Statement>();
    stmts.add(n.getBody());
    stmts.add(makeLoopCondition(n.getCondition()));
    BlockStmt b = new BlockStmt(stmts);
    return makeLoopStmt(b);
}
 

import japa.parser.ast.stmt.Statement; //导入依赖的package包/类
/**
 * Generate an immediate jump.
 */
public static Statement generateJump(int state) {
    List<Statement> stmts = new ArrayList<Statement>();
    stmts.add(generateDeferredJump(state));
    stmts.add(new BreakStmt(null));
    return new BlockStmt(stmts);
}
 

import japa.parser.ast.stmt.Statement; //导入依赖的package包/类
/**
 * Generate the statements for the generator.
 */
public List<Statement> generate() {
    List<Statement> stmts = new ArrayList<Statement>();
    Statement innerLoop = LoopDesugarTransform.makeLoopStmt(new SwitchStmt(STATE_VAR,
                                                            this.states));
    stmts.add(innerLoop);
    return stmts;
}
 

import japa.parser.ast.stmt.Statement; //导入依赖的package包/类
@Override
public Node visit(ExpressionStmt n, Map<String, TypedVariableDeclarator> arg) {
    Node r = n.getExpression().accept(this, arg);

    if (n.getExpression() instanceof VariableDeclarationExpr) {
        // Rewrite variable declarations -- we have to turn them into
        // sepcial things.
        VariableDeclarationExpr expr = (VariableDeclarationExpr) n.getExpression();
        List<Statement> assigns = new ArrayList<Statement>();

        for (VariableDeclarator d : expr.getVars()) {
            if (d.getInit() != null){
                assigns.add(new ExpressionStmt(new AssignExpr(new NameExpr(this.block.getScopePrefix() + d.getId().getName()),
                                                              d.getInit(),
                                                              AssignExpr.Operator.assign)));
            }
        }

        if (assigns.size() == 0) {
            return null;
        }

        if (assigns.size() == 1) {
            return assigns.get(0);
        }
        return new BlockStmt(assigns);
    }

    if (r == null) {
        return null;
    }

    return new ExpressionStmt((Expression) r);
}
 

import japa.parser.ast.stmt.Statement; //导入依赖的package包/类
public R visit(BlockStmt n, A arg) {
    if (n.getStmts() != null) {
        for (Statement s : n.getStmts()) {
            s.accept(this, arg);
        }
    }
    return null;

}