📄 verifier.java
字号:
this.methodNode = node;
Statement statement = node.getCode();
if (!node.isVoidMethod()) {
if (statement instanceof ExpressionStatement) {
ExpressionStatement expStmt = (ExpressionStatement) statement;
node.setCode(new ReturnStatement(expStmt.getExpression()));
}
else if (statement instanceof BlockStatement) {
BlockStatement block = (BlockStatement) statement;
// lets copy the list so we create a new block
List list = new ArrayList(block.getStatements());
if (!list.isEmpty()) {
int idx = list.size() - 1;
Statement last = (Statement) list.get(idx);
if (last instanceof ExpressionStatement) {
ExpressionStatement expStmt = (ExpressionStatement) last;
list.set(idx, new ReturnStatement(expStmt));
}
else if (!(last instanceof ReturnStatement)) {
list.add(new ReturnStatement(ConstantExpression.NULL));
}
}
else {
list.add(new ReturnStatement(ConstantExpression.NULL));
}
node.setCode(new BlockStatement(filterStatements(list),block.getVariableScope()));
}
}
else if (!node.isAbstract()) {
BlockStatement newBlock = new BlockStatement();
if (statement instanceof BlockStatement) {
newBlock.addStatements(filterStatements(((BlockStatement)statement).getStatements()));
}
else {
newBlock.addStatement(filterStatement(statement));
}
newBlock.addStatement(ReturnStatement.RETURN_NULL_OR_VOID);
node.setCode(newBlock);
}
if (node.getName().equals("main") && node.isStatic()) {
Parameter[] params = node.getParameters();
if (params.length == 1) {
Parameter param = params[0];
if (param.getType() == null || param.getType()==ClassHelper.OBJECT_TYPE) {
param.setType(ClassHelper.STRING_TYPE.makeArray());
}
}
}
statement = node.getCode();
if (statement!=null) statement.visit(new VerifierCodeVisitor(this));
}
public void visitField(FieldNode node) {
}
public void visitProperty(PropertyNode node) {
String name = node.getName();
FieldNode field = node.getField();
String getterName = "get" + capitalize(name);
String setterName = "set" + capitalize(name);
Statement getterBlock = node.getGetterBlock();
if (getterBlock == null) {
if (!node.isPrivate() && classNode.getGetterMethod(getterName) == null) {
getterBlock = createGetterBlock(node, field);
}
}
Statement setterBlock = node.getSetterBlock();
if (setterBlock == null) {
if (!node.isPrivate() && (node.getModifiers()&ACC_FINAL)==0 && classNode.getSetterMethod(setterName) == null) {
setterBlock = createSetterBlock(node, field);
}
}
if (getterBlock != null) {
MethodNode getter =
new MethodNode(getterName, node.getModifiers(), node.getType(), Parameter.EMPTY_ARRAY, ClassNode.EMPTY_ARRAY, getterBlock);
getter.setSynthetic(true);
classNode.addMethod(getter);
visitMethod(getter);
if (ClassHelper.boolean_TYPE==node.getType() || ClassHelper.Boolean_TYPE==node.getType()) {
String secondGetterName = "is" + capitalize(name);
MethodNode secondGetter =
new MethodNode(secondGetterName, node.getModifiers(), node.getType(), Parameter.EMPTY_ARRAY, ClassNode.EMPTY_ARRAY, getterBlock);
secondGetter.setSynthetic(true);
classNode.addMethod(secondGetter);
visitMethod(secondGetter);
}
}
if (setterBlock != null) {
Parameter[] setterParameterTypes = { new Parameter(node.getType(), "value")};
MethodNode setter =
new MethodNode(setterName, node.getModifiers(), ClassHelper.VOID_TYPE, setterParameterTypes, ClassNode.EMPTY_ARRAY, setterBlock);
setter.setSynthetic(true);
classNode.addMethod(setter);
visitMethod(setter);
}
}
// Implementation methods
//-------------------------------------------------------------------------
private interface DefaultArgsAction {
public void call(ArgumentListExpression arguments, Parameter[] newParams, MethodNode method);
}
/**
* Creates a new helper method for each combination of default parameter expressions
*/
protected void addDefaultParameterMethods(final ClassNode node) {
List methods = new ArrayList(node.getMethods());
addDefaultParameters(methods, new DefaultArgsAction(){
public void call(ArgumentListExpression arguments, Parameter[] newParams, MethodNode method) {
MethodCallExpression expression = new MethodCallExpression(VariableExpression.THIS_EXPRESSION, method.getName(), arguments);
expression.setImplicitThis(true);
Statement code = null;
if (method.isVoidMethod()) {
code = new ExpressionStatement(expression);
} else {
code = new ReturnStatement(expression);
}
node.addMethod(method.getName(), method.getModifiers(), method.getReturnType(), newParams, method.getExceptions(), code);
}
});
}
protected void addDefaultParameterConstructors(final ClassNode node) {
List methods = new ArrayList(node.getDeclaredConstructors());
addDefaultParameters(methods, new DefaultArgsAction(){
public void call(ArgumentListExpression arguments, Parameter[] newParams, MethodNode method) {
ConstructorNode ctor = (ConstructorNode) method;
ConstructorCallExpression expression = new ConstructorCallExpression(ClassNode.THIS, arguments);
Statement code = new ExpressionStatement(expression);
node.addConstructor(ctor.getModifiers(), newParams, ctor.getExceptions(), code);
}
});
}
/**
* Creates a new helper method for each combination of default parameter expressions
*/
protected void addDefaultParameters(List methods, DefaultArgsAction action) {
for (Iterator iter = methods.iterator(); iter.hasNext();) {
MethodNode method = (MethodNode) iter.next();
if (method.hasDefaultValue()) {
Parameter[] parameters = method.getParameters();
int counter = 0;
ArrayList paramValues = new ArrayList();
int size = parameters.length;
for (int i = size - 1; i >= 0; i--) {
Parameter parameter = parameters[i];
if (parameter != null && parameter.hasInitialExpression()) {
paramValues.add(new Integer(i));
paramValues.add(parameter.getInitialExpression());
counter++;
}
}
for (int j = 1; j <= counter; j++) {
Parameter[] newParams = new Parameter[parameters.length - j];
ArgumentListExpression arguments = new ArgumentListExpression();
int index = 0;
int k = 1;
for (int i = 0; i < parameters.length; i++) {
if (k > counter - j && parameters[i] != null && parameters[i].hasInitialExpression()) {
arguments.addExpression(parameters[i].getInitialExpression());
k++;
}
else if (parameters[i] != null && parameters[i].hasInitialExpression()) {
newParams[index++] = parameters[i];
arguments.addExpression(new VariableExpression(parameters[i].getName()));
k++;
}
else {
newParams[index++] = parameters[i];
arguments.addExpression(new VariableExpression(parameters[i].getName()));
}
}
action.call(arguments,newParams,method);
}
}
}
}
protected void addClosureCode(InnerClassNode node) {
// add a new invoke
}
protected void addInitialization(ClassNode node) {
for (Iterator iter = node.getDeclaredConstructors().iterator(); iter.hasNext();) {
addInitialization(node, (ConstructorNode) iter.next());
}
}
protected void addInitialization(ClassNode node, ConstructorNode constructorNode) {
Statement firstStatement = constructorNode.getFirstStatement();
ConstructorCallExpression first = getFirstIfSpecialConstructorCall(firstStatement);
// in case of this(...) let the other constructor do the intit
if (first!=null && first.isThisCall()) return;
List statements = new ArrayList();
List staticStatements = new ArrayList();
for (Iterator iter = node.getFields().iterator(); iter.hasNext();) {
addFieldInitialization(statements, staticStatements, (FieldNode) iter.next());
}
statements.addAll(node.getObjectInitializerStatements());
if (!statements.isEmpty()) {
Statement code = constructorNode.getCode();
BlockStatement block = new BlockStatement();
List otherStatements = block.getStatements();
if (code instanceof BlockStatement) {
block = (BlockStatement) code;
otherStatements=block.getStatements();
}
else if (code != null) {
otherStatements.add(code);
}
if (!otherStatements.isEmpty()) {
if (first!=null) {
// it is super(..) since this(..) is already covered
otherStatements.remove(0);
statements.add(0, firstStatement);
}
statements.addAll(otherStatements);
}
constructorNode.setCode(new BlockStatement(statements, block.getVariableScope()));
}
if (!staticStatements.isEmpty()) {
node.addStaticInitializerStatements(staticStatements,true);
}
}
private ConstructorCallExpression getFirstIfSpecialConstructorCall(Statement code) {
if (code == null || !(code instanceof ExpressionStatement)) return null;
Expression expression = ((ExpressionStatement)code).getExpression();
if (!(expression instanceof ConstructorCallExpression)) return null;
ConstructorCallExpression cce = (ConstructorCallExpression) expression;
if (cce.isSpecialCall()) return cce;
return null;
}
protected void addFieldInitialization(
List list,
List staticList,
FieldNode fieldNode) {
Expression expression = fieldNode.getInitialExpression();
if (expression != null) {
ExpressionStatement statement =
new ExpressionStatement(
new BinaryExpression(
new FieldExpression(fieldNode),
Token.newSymbol(Types.EQUAL, fieldNode.getLineNumber(), fieldNode.getColumnNumber()),
expression));
if (fieldNode.isStatic()) {
staticList.add(statement);
}
else {
list.add(statement);
}
}
}
/**
* Capitalizes the start of the given bean property name
*/
public static String capitalize(String name) {
return name.substring(0, 1).toUpperCase() + name.substring(1, name.length());
}
protected Statement createGetterBlock(PropertyNode propertyNode, FieldNode field) {
Expression expression = new FieldExpression(field);
return new ReturnStatement(expression);
}
protected Statement createSetterBlock(PropertyNode propertyNode, FieldNode field) {
Expression expression = new FieldExpression(field);
return new ExpressionStatement(
new BinaryExpression(expression, Token.newSymbol(Types.EQUAL, 0, 0), new VariableExpression("value")));
}
/**
* Filters the given statements
*/
protected List filterStatements(List list) {
List answer = new ArrayList(list.size());
for (Iterator iter = list.iterator(); iter.hasNext();) {
answer.add(filterStatement((Statement) iter.next()));
}
return answer;
}
protected Statement filterStatement(Statement statement) {
if (statement instanceof ExpressionStatement) {
ExpressionStatement expStmt = (ExpressionStatement) statement;
Expression expression = expStmt.getExpression();
if (expression instanceof ClosureExpression) {
ClosureExpression closureExp = (ClosureExpression) expression;
if (!closureExp.isParameterSpecified()) {
return closureExp.getCode();
}
}
}
return statement;
}
}
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -