protected Statement synchronizedStatement(AST syncNode) { AST node = syncNode.getFirstChild(); Expression expression = expression(node); Statement code = statement(node.getNextSibling()); SynchronizedStatement synchronizedStatement = new SynchronizedStatement(expression, code); configureAST(synchronizedStatement, syncNode); return synchronizedStatement; }
private static Statement lazyBody(ClassNode classNode, FieldNode fieldNode) { final Expression instanceExpression = varX(fieldNode); return ifElseS( notNullX(instanceExpression), returnS(instanceExpression), new SynchronizedStatement( classX(classNode), ifElseS( notNullX(instanceExpression), returnS(instanceExpression), returnS(assignX(instanceExpression, ctorX(classNode))) ) ) ); }
public void visit(ASTNode[] nodes, SourceUnit source) { init(nodes, source); AnnotatedNode parent = (AnnotatedNode) nodes[1]; AnnotationNode node = (AnnotationNode) nodes[0]; if (!MY_TYPE.equals(node.getClassNode())) return; String value = getMemberStringValue(node, "value"); if (parent instanceof MethodNode) { MethodNode mNode = (MethodNode) parent; if (mNode.isAbstract()) { addError("Error during " + MY_TYPE_NAME + " processing: annotation not allowed on abstract method '" + mNode.getName() + "'", mNode); return; } ClassNode cNode = mNode.getDeclaringClass(); String lockExpr = determineLock(value, cNode, mNode); if (lockExpr == null) return; Statement origCode = mNode.getCode(); Statement newCode = new SynchronizedStatement(varX(lockExpr), origCode); mNode.setCode(newCode); } }
private static void addDoubleCheckedLockingBody(BlockStatement body, FieldNode fieldNode, Expression initExpr) { final Expression fieldExpr = varX(fieldNode); final VariableExpression localVar = varX(fieldNode.getName() + "_local"); body.addStatement(declS(localVar, fieldExpr)); body.addStatement(ifElseS( notNullX(localVar), returnS(localVar), new SynchronizedStatement( syncTarget(fieldNode), ifElseS( notNullX(fieldExpr), returnS(fieldExpr), returnS(assignX(fieldExpr, initExpr)) ) ) )); }
private static void createSoftGetter(FieldNode fieldNode, Expression initExpr, ClassNode type) { final BlockStatement body = new BlockStatement(); final Expression fieldExpr = varX(fieldNode); final Expression resExpr = varX("res", type); final MethodCallExpression callExpression = callX(fieldExpr, "get"); callExpression.setSafe(true); body.addStatement(declS(resExpr, callExpression)); final Statement mainIf = ifElseS(notNullX(resExpr), stmt(resExpr), block( assignS(resExpr, initExpr), assignS(fieldExpr, ctorX(SOFT_REF, resExpr)), stmt(resExpr))); if (fieldNode.isVolatile()) { body.addStatement(ifElseS( notNullX(resExpr), stmt(resExpr), new SynchronizedStatement(syncTarget(fieldNode), block( assignS(resExpr, callExpression), mainIf) ) )); } else { body.addStatement(mainIf); } addMethod(fieldNode, body, type); }
protected Statement synchronizedStatement(AST syncNode) { AST node = syncNode.getFirstChild(); Expression expression = expression(node); Statement code = statement(node.getNextSibling()); SynchronizedStatement synchronizedStatement = new SynchronizedStatement(expression, code); configureAST(synchronizedStatement, syncNode); return synchronizedStatement; }
protected Statement synchronizedStatement(AST syncNode) { AST node = syncNode.getFirstChild(); Expression expression = expression(node); Statement code = statement(node.getNextSibling()); SynchronizedStatement synchronizedStatement = new SynchronizedStatement(expression, code); configureAST(synchronizedStatement, syncNode); return synchronizedStatement; }
protected Statement synchronizedStatement(AST syncNode) { AST node = syncNode.getFirstChild(); Expression expression = expression(node); Statement code = statement(node.getNextSibling()); SynchronizedStatement synchronizedStatement = new SynchronizedStatement(expression, code); configureAST(synchronizedStatement, syncNode); return synchronizedStatement; }
protected Statement synchronizedStatement(AST syncNode) { AST node = syncNode.getFirstChild(); Expression expression = expression(node); Statement code = statement(node.getNextSibling()); SynchronizedStatement synchronizedStatement = new SynchronizedStatement(expression, code); configureAST(synchronizedStatement, syncNode); return synchronizedStatement; }
public void visit(ASTNode[] nodes, SourceUnit source) { if (nodes.length != 2 || !(nodes[0] instanceof AnnotationNode) || !(nodes[1] instanceof AnnotatedNode)) { throw new RuntimeException("Internal error: expecting [AnnotationNode, AnnotatedNode] but got: " + Arrays.asList(nodes)); } AnnotatedNode parent = (AnnotatedNode) nodes[1]; AnnotationNode node = (AnnotationNode) nodes[0]; if (!MY_TYPE.equals(node.getClassNode())) return; Expression valueExpr = node.getMember("value"); String value = null; if (valueExpr instanceof ConstantExpression) { ConstantExpression ce = (ConstantExpression) valueExpr; Object valueObject = ce.getValue(); if (valueObject != null) value = valueObject.toString(); } if (parent instanceof MethodNode) { MethodNode mNode = (MethodNode) parent; ClassNode cNode = mNode.getDeclaringClass(); String lockExpr = determineLock(value, cNode, mNode.isStatic()); Statement origCode = mNode.getCode(); Statement newCode = new SynchronizedStatement(new VariableExpression(lockExpr), origCode); mNode.setCode(newCode); } }
private void addDoubleCheckedLockingBody(BlockStatement body, FieldNode fieldNode, Expression initExpr) { final Expression fieldExpr = new VariableExpression(fieldNode); final VariableExpression localVar = new VariableExpression(fieldNode.getName() + "_local"); body.addStatement(declStatement(localVar, fieldExpr)); body.addStatement(new IfStatement( notNullExpr(localVar), new ReturnStatement(localVar), new SynchronizedStatement( syncTarget(fieldNode), new IfStatement( notNullExpr(fieldExpr), new ReturnStatement(fieldExpr), new ReturnStatement(new BinaryExpression(fieldExpr, ASSIGN, initExpr)) ) ) )); }
private void createSoftGetter(FieldNode fieldNode, Expression initExpr, ClassNode type) { final BlockStatement body = new BlockStatement(); final Expression fieldExpr = new VariableExpression(fieldNode); final Expression resExpr = new VariableExpression("res", type); final MethodCallExpression callExpression = new MethodCallExpression(fieldExpr, "get", new ArgumentListExpression()); callExpression.setSafe(true); body.addStatement(declStatement(resExpr, callExpression)); final BlockStatement elseBlock = new BlockStatement(); elseBlock.addStatement(assignStatement(resExpr, initExpr)); elseBlock.addStatement(assignStatement(fieldExpr, new ConstructorCallExpression(SOFT_REF, resExpr))); elseBlock.addStatement(new ExpressionStatement(resExpr)); final Statement mainIf = new IfStatement(notNullExpr(resExpr), new ExpressionStatement(resExpr), elseBlock); if (notVolatile(fieldNode)) { body.addStatement(mainIf); } else { body.addStatement(new IfStatement( notNullExpr(resExpr), new ExpressionStatement(resExpr), new SynchronizedStatement(syncTarget(fieldNode), mainIf) )); } addMethod(fieldNode, body, type); }
new BooleanExpression(new BinaryExpression(resExpr, Token.newSymbol("!=",-1,-1), ConstantExpression.NULL)), new ExpressionStatement(resExpr), new SynchronizedStatement( VariableExpression.THIS_EXPRESSION, mainIf
private void create(FieldNode fieldNode, final Expression initExpr) { BlockStatement body = new BlockStatement(); final FieldExpression fieldExpr = new FieldExpression(fieldNode); if ((fieldNode.getModifiers() & ACC_VOLATILE) == 0) { body.addStatement(new IfStatement( new BooleanExpression(new BinaryExpression(fieldExpr, Token.newSymbol("!=",-1,-1), ConstantExpression.NULL)), new ExpressionStatement(fieldExpr), new ExpressionStatement(new BinaryExpression(fieldExpr, Token.newSymbol("=",-1,-1), initExpr)) )); } else { body.addStatement(new IfStatement( new BooleanExpression(new BinaryExpression(fieldExpr, Token.newSymbol("!=",-1,-1), ConstantExpression.NULL)), new ReturnStatement(fieldExpr), new SynchronizedStatement( VariableExpression.THIS_EXPRESSION, new IfStatement( new BooleanExpression(new BinaryExpression(fieldExpr, Token.newSymbol("!=",-1,-1), ConstantExpression.NULL)), new ReturnStatement(fieldExpr), new ReturnStatement(new BinaryExpression(fieldExpr,Token.newSymbol("=",-1,-1), initExpr)) ) ) )); } final String name = "get" + MetaClassHelper.capitalize(fieldNode.getName().substring(1)); fieldNode.getDeclaringClass().addMethod(name, ACC_PUBLIC, fieldNode.getType(), Parameter.EMPTY_ARRAY, ClassNode.EMPTY_ARRAY, body); }
new BooleanExpression(new BinaryExpression(resExpr, Token.newSymbol("!=",-1,-1), ConstantExpression.NULL)), new ExpressionStatement(resExpr), new SynchronizedStatement( VariableExpression.THIS_EXPRESSION, mainIf
private void create(FieldNode fieldNode, final Expression initExpr) { BlockStatement body = new BlockStatement(); final FieldExpression fieldExpr = new FieldExpression(fieldNode); if ((fieldNode.getModifiers() & ACC_VOLATILE) == 0) { body.addStatement(new IfStatement( new BooleanExpression(new BinaryExpression(fieldExpr, Token.newSymbol("!=",-1,-1), ConstantExpression.NULL)), new ExpressionStatement(fieldExpr), new ExpressionStatement(new BinaryExpression(fieldExpr, Token.newSymbol("=",-1,-1), initExpr)) )); } else { body.addStatement(new IfStatement( new BooleanExpression(new BinaryExpression(fieldExpr, Token.newSymbol("!=",-1,-1), ConstantExpression.NULL)), new ReturnStatement(fieldExpr), new SynchronizedStatement( VariableExpression.THIS_EXPRESSION, new IfStatement( new BooleanExpression(new BinaryExpression(fieldExpr, Token.newSymbol("!=",-1,-1), ConstantExpression.NULL)), new ReturnStatement(fieldExpr), new ReturnStatement(new BinaryExpression(fieldExpr,Token.newSymbol("=",-1,-1), initExpr)) ) ) )); } final String name = "get" + MetaClassHelper.capitalize(fieldNode.getName().substring(1)); fieldNode.getDeclaringClass().addMethod(name, ACC_PUBLIC, fieldNode.getType(), Parameter.EMPTY_ARRAY, ClassNode.EMPTY_ARRAY, body); }
private void createLazy(ClassNode classNode) { final FieldNode fieldNode = classNode.addField("instance", ACC_PRIVATE|ACC_STATIC|ACC_VOLATILE, classNode, null); createConstructor(classNode, fieldNode); final BlockStatement body = new BlockStatement(); final FieldExpression instanceExpression = new FieldExpression(fieldNode); body.addStatement(new IfStatement( new BooleanExpression(new BinaryExpression(instanceExpression, Token.newSymbol("!=",-1,-1), ConstantExpression.NULL)), new ReturnStatement(instanceExpression), new SynchronizedStatement( new ClassExpression(classNode), new IfStatement( new BooleanExpression(new BinaryExpression(instanceExpression, Token.newSymbol("!=",-1,-1), ConstantExpression.NULL)), new ReturnStatement(instanceExpression), new ReturnStatement(new BinaryExpression(instanceExpression,Token.newSymbol("=",-1,-1), new ConstructorCallExpression(classNode, new ArgumentListExpression()))) ) ) )); classNode.addMethod("getInstance", ACC_STATIC|ACC_PUBLIC, classNode, Parameter.EMPTY_ARRAY, ClassNode.EMPTY_ARRAY, body); }
private void createLazy(ClassNode classNode) { final FieldNode fieldNode = classNode.addField("instance", ACC_PRIVATE|ACC_STATIC|ACC_VOLATILE, classNode, null); createConstructor(classNode, fieldNode); final BlockStatement body = new BlockStatement(); final FieldExpression instanceExpression = new FieldExpression(fieldNode); body.addStatement(new IfStatement( new BooleanExpression(new BinaryExpression(instanceExpression, Token.newSymbol("!=",-1,-1), ConstantExpression.NULL)), new ReturnStatement(instanceExpression), new SynchronizedStatement( new ClassExpression(classNode), new IfStatement( new BooleanExpression(new BinaryExpression(instanceExpression, Token.newSymbol("!=",-1,-1), ConstantExpression.NULL)), new ReturnStatement(instanceExpression), new ReturnStatement(new BinaryExpression(instanceExpression,Token.newSymbol("=",-1,-1), new ConstructorCallExpression(classNode, new ArgumentListExpression()))) ) ) )); classNode.addMethod("getInstance", ACC_STATIC|ACC_PUBLIC, classNode, Parameter.EMPTY_ARRAY, ClassNode.EMPTY_ARRAY, body); }
private void createLazy(ClassNode classNode) { final FieldNode fieldNode = classNode.addField("instance", ACC_PRIVATE|ACC_STATIC|ACC_VOLATILE, classNode.getPlainNodeReference(), null); createConstructor(classNode, fieldNode); final BlockStatement body = new BlockStatement(); final Expression instanceExpression = new VariableExpression(fieldNode); body.addStatement(new IfStatement( new BooleanExpression(new BinaryExpression(instanceExpression, Token.newSymbol("!=",-1,-1), ConstantExpression.NULL)), new ReturnStatement(instanceExpression), new SynchronizedStatement( new ClassExpression(classNode), new IfStatement( new BooleanExpression(new BinaryExpression(instanceExpression, Token.newSymbol("!=",-1,-1), ConstantExpression.NULL)), new ReturnStatement(instanceExpression), new ReturnStatement(new BinaryExpression(instanceExpression,Token.newSymbol("=",-1,-1), new ConstructorCallExpression(classNode, new ArgumentListExpression()))) ) ) )); classNode.addMethod("getInstance", ACC_STATIC|ACC_PUBLIC, classNode.getPlainNodeReference(), Parameter.EMPTY_ARRAY, ClassNode.EMPTY_ARRAY, body); }