From f4f22c7c085ab97a0453d973bab7912abaa82f2e Mon Sep 17 00:00:00 2001
From: avasseur <avasseur>
Date: Tue, 7 Jun 2005 09:53:54 +0000
Subject: [PATCH] test case for pattern visitor, issue with varargs so test
 case for Adrian to fix it

---
 .../weaver/patterns/PatternParser.java        |   38 +-
 .../weaver/patterns/PointcutVisitor.java      |   30 +-
 weaver/testdata/visitor.pointcuts.txt         | 2342 +++++++++++++++++
 weaver/testdata/visitor.typepatterns.txt      |   31 +
 .../weaver/patterns/PatternsTests.java        |    2 +
 .../weaver/patterns/VisitorTestCase.java      |   79 +
 6 files changed, 2509 insertions(+), 13 deletions(-)
 create mode 100644 weaver/testdata/visitor.pointcuts.txt
 create mode 100644 weaver/testdata/visitor.typepatterns.txt
 create mode 100644 weaver/testsrc/org/aspectj/weaver/patterns/VisitorTestCase.java

diff --git a/weaver/src/org/aspectj/weaver/patterns/PatternParser.java b/weaver/src/org/aspectj/weaver/patterns/PatternParser.java
index 0f00b5ab7..211fdbb58 100644
--- a/weaver/src/org/aspectj/weaver/patterns/PatternParser.java
+++ b/weaver/src/org/aspectj/weaver/patterns/PatternParser.java
@@ -638,8 +638,24 @@ public class PatternParser {
 			eat("]");
 			dim++;
 		}
-		boolean isVarArgs = maybeEat("...");
-					
+
+        // FIXME AV for Adrian - varargs need special handling since Token are 3x"." and not "..."
+        // the following works for 'call(* *(int, Integer...))' but not in the general case (see testAJDKExamples test f.e.)
+        // and the current code does not work for 'call(* *(int, Integer...))'
+//        int varargDot = 0;
+//        while (maybeEat(".")) {
+//            varargDot++;
+//        }
+//        boolean isVarArgs = false;
+//        if (varargDot > 0) {
+//            if (varargDot == 3) {
+//                isVarArgs = true;
+//            } else {
+//                throw new ParserException("Invalid varargs", tokenSource.peek());
+//            }
+//        }
+        boolean isVarArgs = maybeEat("...");
+
 		boolean includeSubtypes = maybeEat("+");
 		int endPos = tokenSource.peek(-1).getEnd();
 		
@@ -757,6 +773,7 @@ public class PatternParser {
 		boolean justProcessedEllipsis = false; // Remember if we just dealt with an ellipsis (PR61536)
 		boolean justProcessedDot = false; 
 		boolean onADot = false;
+
 		while (true) {
 			IToken tok = null;
 			int startPos = tokenSource.peek().getStart();
@@ -812,7 +829,22 @@ public class PatternParser {
 			
 			if (afterDot == null) {
 				buf.setLength(0);
-				if (!maybeEat(".")) break;
+//                //FIXME AV for Adrian - the following does not works in the general case
+//                //varargs lookahead
+//                IToken next_1 = tokenSource.peek();
+//                if (!IToken.EOF.equals(next_1) && next_1.getString().equals(".")) {
+//                    IToken next_2 = tokenSource.peek(1);
+//                    if (!IToken.EOF.equals(next_2) && next_2.getString().equals(".")) {
+//                        IToken next_3 = tokenSource.peek(2);
+//                        if (!IToken.EOF.equals(next_3) && next_3.getString().equals(".")) {
+//                            // happens to be a varargs
+//                            break;
+//                        }
+//                    }
+//                }
+				// no elipsis or dotted name part
+                if (!maybeEat(".")) break;
+                // go on
 				else previous = tokenSource.peek(-1);
 			} else {
 				buf.setLength(0);
diff --git a/weaver/src/org/aspectj/weaver/patterns/PointcutVisitor.java b/weaver/src/org/aspectj/weaver/patterns/PointcutVisitor.java
index 9faba4a27..31d16ee85 100644
--- a/weaver/src/org/aspectj/weaver/patterns/PointcutVisitor.java
+++ b/weaver/src/org/aspectj/weaver/patterns/PointcutVisitor.java
@@ -189,6 +189,7 @@ public interface PointcutVisitor {
 
         public Object visit(AnyAnnotationTypePattern node, Object data) {
             //@ANY : ignore
+            p('*');
             return null;
         }
 
@@ -198,11 +199,12 @@ public interface PointcutVisitor {
         }
 
         public Object visit(AndAnnotationTypePattern node, Object data) {
-            p('(');
+            //p('(');
             node.getLeft().accept(this, data);
-            p(" && ");
+            //p(" && ");
+            p(' ');
             node.getRight().accept(this, data);
-            p(')');
+            //p(')');
             return null;
         }
 
@@ -227,8 +229,8 @@ public interface PointcutVisitor {
         public Object visit(AnnotationPatternList node, Object data) {
             AnnotationTypePattern[] annotations = node.getAnnotationPatterns();
             for (int i = 0; i < annotations.length; i++) {
+                if (i>0) p(", ");//FIXME AV should that be here?
                 annotations[i].accept(this, data);
-                p(' ');
             }
             return null;
         }
@@ -272,7 +274,7 @@ public interface PointcutVisitor {
         }
 
         public Object visit(ExactAnnotationTypePattern node, Object data) {
-            p('@');
+            //p('@'); // since @annotation(@someAnno) cannot be parsed anymore
             p(node.annotationType.getName());
             return null;
         }
@@ -314,9 +316,8 @@ public interface PointcutVisitor {
         }
 
         public Object visit(NotAnnotationTypePattern node, Object data) {
-            p("!(");
+            p("!");
             node.negatedPattern.accept(this, data);
-            p(')');
             return null;
         }
 
@@ -379,7 +380,7 @@ public interface PointcutVisitor {
 
             if (node.getKind() == Member.STATIC_INITIALIZATION) {
                 node.getDeclaringType().accept(this, data);
-                p(".<clinit>()");
+                //p(".<clinit>()");
             } else if (node.getKind() == Member.HANDLER) {
                 p("handler(");
                 node.getParameterTypes().get(0).accept(this, data);//Note: we know we have 1 child
@@ -614,8 +615,17 @@ public interface PointcutVisitor {
         }
 
         public static void main(String args[]) throws Throwable {
-            String s = "execution(* foo.bar.do() throws !(@An Waza), !Bla)";
-            check(s);
+            String[] s = new String[]{
+                //"@args(Foo, Goo, *, .., Moo)",
+                //"execution(* *())",
+                //"call(* *(int, Integer...))",
+                //"staticinitialization(@(Foo) @(Boo) @(Goo) Moo)",
+                "staticinitialization(!@(Immutable) *)"
+
+            };
+            for (int i = 0; i < s.length; i++) {
+                check(s[i]);
+            }
         }
 
     }
diff --git a/weaver/testdata/visitor.pointcuts.txt b/weaver/testdata/visitor.pointcuts.txt
new file mode 100644
index 000000000..f75db3d5c
--- /dev/null
+++ b/weaver/testdata/visitor.pointcuts.txt
@@ -0,0 +1,2342 @@
+(execution(* *(..)) && !execution(* main(..)))
+methodRunning()
+execution(* *())
+execution(* *(..))
+execution(* main(..))
+call(SolidPoint.new(int, int, int))
+(call(Point.new(int, int)) || call(SolidPoint.new(int, int, int)))
+call(void SolidPoint.setZ(int))
+(call(void Point.setY(int)) || call(void SolidPoint.setZ(int)))
+(call(void Point.setX(int)) || (call(void Point.setY(int)) || call(void SolidPoint.setZ(int))))
+(call(void FigureElement.incrXY(int, int)) || (call(void Point.setX(int)) || (call(void Point.setY(int)) || call(void SolidPoint.setZ(int)))))
+(call(String Point.getName()) || (call(void FigureElement.incrXY(int, int)) || (call(void Point.setX(int)) || (call(void Point.setY(int)) || call(void SolidPoint.setZ(int))))))
+(target(fe) && (call(String Point.getName()) || (call(void FigureElement.incrXY(int, int)) || (call(void Point.setX(int)) || (call(void Point.setY(int)) || call(void SolidPoint.setZ(int)))))))
+execution(int main(*))
+handler(RuntimeException)
+(mainExecution() || handler(RuntimeException))
+runtimeHandlers()
+(set(int *.*) && args(newValue))
+get(int *.*)
+constructions()
+moves(fe)
+staticinitialization(Point)
+mumble()
+(target(fe) && (call(void FigureElement.incrXY(int, int)) || (call(void Point.setX(int)) || (call(void Point.setY(int)) || call(void SolidPoint.setZ(int))))))
+call(void Point.setY(int))
+(call(void Point.setX(int)) || call(void Point.setY(int)))
+(call(void Line.setP2(Point)) || (call(void Point.setX(int)) || call(void Point.setY(int))))
+(call(void Line.setP1(Point)) || (call(void Line.setP2(Point)) || (call(void Point.setX(int)) || call(void Point.setY(int)))))
+(call(void FigureElement.incrXY(int, int)) || (call(void Line.setP1(Point)) || (call(void Line.setP2(Point)) || (call(void Point.setX(int)) || call(void Point.setY(int))))))
+(target(fe) && (call(void FigureElement.incrXY(int, int)) || (call(void Line.setP1(Point)) || (call(void Line.setP2(Point)) || (call(void Point.setX(int)) || call(void Point.setY(int)))))))
+(call(FigureElement+.new(..)) && !withincode(* Main.main(..)))
+illegalNewFigElt()
+call(* *.*(..))
+args(newval)
+(target(p) && (set(int Point.xx) && args(newval)))
+(set(int Point.*) && args(newValue))
+call(* *.init(..))
+set(* SomeClass.*)
+execution(void Point.setX(int))
+methodExecutionP()
+execution(Point.new())
+constructorExecutionP()
+call(* Point.setX(int))
+callMethodP()
+call(Point.new())
+callConstructorP()
+getP()
+(set(int *.*) && !set(int *.xxx))
+setP()
+initialization(Point.new(..))
+initializationP()
+staticinitializationP()
+handler(IOException)
+handlerP()
+call(* *.mumble())
+(call(int Point.changeX(int)) && args(i))
+(set(int Point.x) && args(i, j))
+named()
+namedWithArgs(i, j)
+namedWithOneArg(i)
+(call(* *.mumble()) && (named() && namedWithOneArg(i)))
+(named() && (call(* *.mumble()) && namedWithOneArg(i)))
+(call(Point.new(..)) && !withincode(* *.doIt(..)))
+call(* Point.setX(..))
+call(* Point.getX())
+call(Point.new(..))
+(a() && within(Point))
+usesA()
+usesUsesA()
+call(* say(..))
+sayCalls()
+call(* approximate(..))
+(this(Demo) && execution(void go()))
+cflow((this(Demo) && execution(void go())))
+(within(Demo) && execution(* *(..)))
+goCut()
+(demoExecs() && (!execution(* go()) && goCut()))
+(execution(* *..*(..)) && !within(Logging))
+methods()
+m1()
+call(* *print*(..))
+execution(* m())
+execution(* n())
+(foo(args) && execution(void Hello.*(..)))
+execution(* Hello.*(..))
+args(i)
+this(String)
+execution(void Hello.*ai*(..))
+target(thisObject)
+target(o2)
+(target(o1) || target(o2))
+(target(o1) && target(o2))
+(target(o1) && target(o1))
+!target(o1)
+target(o1)
+(target(thisObject) && execution(public * Hello.*(..)))
+(this(thisObject) && execution(* Hello.*(..)))
+y()
+cflow(y())
+withincode(int m())
+execution(void m())
+handler(Foo)
+initialization(Object.new(..))
+this(NotFoundType)
+within(*)
+execution(* *.toString())
+!toStringMethod()
+(rasScope() && (execution(public * *(..)) && !toStringMethod()))
+publicMethods()
+withincode(new(..))
+within(client..*)
+(cflow(within(client..*)) && call(* println(..)))
+call(* java.io.PrintStream.println(*))
+(scope() && (within(Marker+) && call(* java.io.PrintStream.println(*))))
+(this(m) && execution(new(..)))
+within(client.*)
+execution(void main(..))
+(args(i, b) && foo())
+(args(a) && foo())
+fun(o2)
+(execution(void IfPcd.main(..)) && (args(o1) && fun(o2)))
+(execution(void IfPcd.main(..)) && fun(Object))
+pc()
+(this(PerObject) && execution(* m(..)))
+get(* *)
+foo()
+(handler(Throwable) && args(t))
+call(int main(..))
+(target(o) && (args(i, *, b) && foo()))
+traced()
+execution(* LazyTjp.doit0(..))
+traced2()
+traced3()
+execution(* *.sayHello(..))
+firstPC()
+call(* *elephant*(..))
+call(* *abc*(..))
+this(current)
+(execution(Traced+.new(..)) && (!execution(Traced.new()) && this(current)))
+execution(void main(String))
+(main() && within(HelloWorld))
+(call(* *(..)) && !within(A1))
+execution(void CompileWarning.run())
+handler(Error)
+(withincode(void WarningTest.ok()) && handler(Error))
+execution(static void main(String))
+execution(public static * *(..))
+execution(public static void main(String))
+runB()
+call(void B.run())
+call(*.new(..))
+execution(* *.*(..))
+execution(*.new(..))
+get(* *.*)
+call(int *.*(..))
+get(* *.out)
+execution(*.new(*, ..))
+(call(*.new(*, ..)) || execution(*.new(*, ..)))
+(execution(* *.*(*, ..)) || (call(*.new(*, ..)) || execution(*.new(*, ..))))
+(call(* *.*(*, ..)) || (execution(* *.*(*, ..)) || (call(*.new(*, ..)) || execution(*.new(*, ..)))))
+(call(public * add(..)) && target(list))
+call(* *.println(..))
+(call(*.new(..)) || execution(*.new(..)))
+(execution(* *.*(..)) || (call(*.new(..)) || execution(*.new(..))))
+(call(* *.*(..)) || (execution(* *.*(..)) || (call(*.new(..)) || execution(*.new(..)))))
+(get(* *.*) || (call(* *.*(..)) || (execution(* *.*(..)) || (call(*.new(..)) || execution(*.new(..))))))
+call(* println(..))
+execution(public * *(..))
+(call(* *(java.lang.Object, java.lang.Object)) && args(java.lang.String, java.lang.String))
+(call(* *(java.lang.Object, java.lang.Object)) && args(.., java.lang.String))
+(call(* *(java.lang.Object, java.lang.Object)) && args(java.lang.String, ..))
+(call(* *(java.lang.Object, java.lang.Object)) && args(s, ..))
+(call(* *(java.lang.Object, java.lang.Object)) && args(s, *))
+(call(public * add(..)) && target(java.util.ArrayList))
+target(java.lang.String)
+(target(java.util.ArrayList) || target(java.lang.String))
+(call(public * add(..)) && (target(java.util.ArrayList) || target(java.lang.String)))
+(target(java.util.ArrayList) && !this(java.lang.Integer))
+(call(public * add(..)) && (this(java.io.Serializable) && (target(java.util.ArrayList) && !this(java.lang.Integer))))
+(call(public * add(..)) && !target(java.util.ArrayList))
+(call(public * add(..)) && !(target(java.util.ArrayList) || target(java.lang.String)))
+!target(java.util.ArrayList)
+(call(public * add(..)) && (target(java.lang.Object) && !target(java.util.ArrayList)))
+call(public * add(..))
+(target(foo) && (!target(java.lang.Integer) && call(public * add(..))))
+(call(public * add(..)) && args(java.lang.Object))
+(call(public * add(..)) && args(*))
+(cflow((call(public * add(..)) && target(list))) && execution(public void main(..)))
+this(*)
+this(Foo)
+this(Bar)
+this(C)
+(this(Foo) && this(Bar))
+(this(Foo) && (this(Bar) && this(C)))
+(this(Foo) || this(Bar))
+(this(Bar) || this(C))
+(this(Foo) || (this(Bar) || this(C)))
+((this(Foo) && this(Bar)) || this(C))
+(this(Bar) && this(C))
+(this(Foo) || (this(Bar) && this(C)))
+((this(Foo) || this(Bar)) && this(C))
+!this(Foo)
+(!this(Foo) && this(Bar))
+(!(this(Foo) && this(Bar)) || this(C))
+!!this(Foo)
+this(org.aspectj.weaver.patterns.AndOrNotTestCase.Foo)
+this(org.aspectj.weaver.patterns.AndOrNotTestCase.Bar)
+this(org.aspectj.weaver.patterns.AndOrNotTestCase.C)
+this(b)
+this(java.lang.String)
+this(a)
+args(.., a, .., b)
+args(a, .., b)
+args(b)
+args()
+(this(a) && this(b))
+(this(a) && this(a))
+(this(a) || this(b))
+(this(java.lang.String) || this(b))
+(this(a) || this(java.lang.String))
+(this(a) || this(a))
+!this(java.lang.String)
+(!this(java.lang.String) && this(a))
+!this(a)
+cflow(this(a))
+(cflow(this(a)) && this(b))
+(cflow(this(a)) || this(b))
+(cflow(this(a)) && this(a))
+!cflow(this(a))
+call(void foo())
+(bar() && baz())
+execution(void Hello.*(..))
+execution(@(SimpleAnnotation) void Hello.*(..))
+execution(@(SimpleAnnotation) (@(Foo) Integer) (@(Goo) Hello).*(..))
+call(@(SimpleAnnotation) (@(Foo) Integer) (@(Goo) Hello).*(..))
+get(@(Foo) (@(SimpleAnnotation) ReturnType) (@(Foo) @(Goo) Hello).*)
+get(@(Foo) @(SimpleAnnotation) ReturnType (@(Foo) @(Goo) Hello).*)
+set(@(Foo) (@(SimpleAnnotation) ReturnType) (@(Foo) @(Goo) Hello).*)
+handler((@(Critical) Exception+))
+initialization(@(Foo) (@(Goo) Hello).new((@(Foo) Integer)))
+preinitialization(@(Foo) (@(Goo) Hello).new((@(Foo) Integer)))
+staticinitialization((@(Foo) @(Boo) @(Goo) Moo))
+within((@(Foo) *))
+withincode(@(Foo) * *.*(..))
+@annotation(Foo)
+@annotation(foo)
+@within(foo)
+@withincode(foo)
+@this(foo)
+@target(foo)
+@args(Foo, Goo, ANY, .., Moo)
+this(Exception)
+this(java.io.IOException)
+target(Exception)
+target(java.io.IOException)
+within(java.util.*)
+within(java.lang.*)
+within(java.util.List+)
+within(java.uti*.List+)
+within(java.uti*..*)
+within(java.util.*List)
+within(java.util.List*)
+within(java.util.Map.*)
+within(java.util..*)
+within(java.util.Map..*)
+within(java.util.Map+)
+within(java.lang.Object+)
+within(String)
+within(Object)
+within(Object+)
+args(..)
+args(org.aspectj.weaver.patterns.ArgsTestCase.A)
+args(org.aspectj.weaver.patterns.ArgsTestCase.A, org.aspectj.weaver.patterns.ArgsTestCase.C)
+args(org.aspectj.weaver.patterns.ArgsTestCase.B, ..)
+args(*)
+args(int)
+args(Integer)
+handler(Exception)
+handler(Exception+)
+handler(java.io.IOException)
+call(* main(..))
+execution(void org.aspectj.weaver.patterns.KindedTestCase.Hello.sayHi(String))
+execution(void Object+.sayHi(String))
+execution(org.aspectj.weaver.patterns.KindedTestCase.Hello.new(..))
+initialization(new(..))
+preinitialization(*..H*.new(int, int))
+staticinitialization(org.aspectj.weaver.patterns.KindedTestCase.Hello)
+withincode(String Object.toString())
+withincode(String.new(..))
+!!!this(Foo)
+(this(Foo) && this(Goo))
+!(this(Foo) && this(Goo))
+this(Goo)
+(this(Foo) || this(Goo))
+!(this(Foo) || this(Goo))
+(this(Foo) && !this(Goo))
+!(this(Foo) && !this(Goo))
+this(Moo)
+(this(Foo) || this(Moo))
+(this(Goo) && this(Boo))
+(this(Foo) || (this(Goo) && this(Boo)))
+((this(Goo) && this(Boo)) || this(Foo))
+this(Boo)
+(this(Goo) || this(Boo))
+(this(Foo) && (this(Goo) || this(Boo)))
+((this(Goo) || this(Boo)) && this(Foo))
+(this(Foo) || (this(Goo) || this(Boo)))
+(this(Goo) || this(Moo))
+(this(Boo) && (this(Goo) || this(Moo)))
+(this(Foo) && (this(Boo) && (this(Goo) || this(Moo))))
+(this(Foo) && this(Foo))
+(this(Foo) && target(Boo))
+((this(Foo) && target(Boo)) && this(Foo))
+(this(Object+) && this(Object))
+(this(Foo) && !this(Foo))
+(this(Foo) && (execution(* *.*(..)) && !this(Foo)))
+this(A)
+(call(* *(..)) && execution(* *(..)))
+(call(* *(..)) && this(Foo))
+(execution(* foo(..)) && this(Boo))
+execution(* foo(..))
+execution(new(..))
+call(* foo(..))
+call(new(..))
+set(* *)
+handler(*)
+preinitialization(new(..))
+staticinitialization(*)
+@this(Foo)
+target(Foo)
+@target(Foo)
+@args(..)
+@within(Foo)
+withincode(* foo(..))
+@withincode(Foo)
+cflow(this(Foo))
+cflowbelow(this(Foo))
+!execution(new(..))
+(execution(new(..)) || get(* *))
+within(Foo)
+(set(* *) && (@within(Foo) && within(Foo)))
+within(abc)
+((execution(new(..)) || get(* *)) || within(abc))
+(execution(new(..)) && within(abc))
+(get(* *) || (execution(new(..)) && within(abc)))
+staticinitialization(org.xzy.abc..*)
+this(t)
+cflow(this(t))
+cflowbelow(this(t))
+bananas(x)
+args(x)
+within(x)
+this(X)
+target(X)
+(this(X) && target(Y))
+target(Y)
+(this(X) || target(Y))
+!this(X)
+staticinitialization(T)
+call(* *..A.a*(..))
+call(* *..A.a*(int))
+(call(void aaa(..)) && this(org.aspectj.weaver.tools.PointcutExpressionTest.Client))
+(call(void aaa(..)) && this(org.aspectj.weaver.tools.PointcutExpressionTest.B))
+this(org.aspectj.weaver.tools.PointcutExpressionTest.Client)
+this(org.aspectj.weaver.tools.PointcutExpressionTest.B)
+target(org.aspectj.weaver.tools.PointcutExpressionTest.Client)
+target(org.aspectj.weaver.tools.PointcutExpressionTest.A)
+target(org.aspectj.weaver.tools.PointcutExpressionTest.B)
+args(.., int)
+within(*..A)
+withincode(* a*(..))
+execution(* *..A.aa(..))
+this(org.aspectj.weaver.tools.PointcutExpressionTest.A)
+call(new(String))
+call(*..A.new(String))
+args(String)
+execution(new(String))
+execution(*..A.new(String))
+args(Exception)
+within(*..Client)
+initialization(new(String))
+initialization(*..A.new(String))
+preinitialization(new(String))
+preinitialization(*..A.new(String))
+staticinitialization(*..A+)
+set(* *..A+.*)
+get(* *..A+.*)
+args(*, *, *, *)
+args(*, *, *, ..)
+args(*, .., *)
+args(String, int, Number)
+args(String, int, Double)
+args(String, Integer, Number)
+(within(Y) && withincode(* *.*(..)))
+(staticinitialization(X) && (execution(* *()) && (within(Y) && withincode(* *.*(..)))))
+args(a, b)
+(args(b, a) || args(a, b))
+(execution(* foo(*, *)) && (args(b, a) || args(a, b)))
+(execution(* doCommand(..)) && this(command))
+call(void test())
+p1()
+p2()
+p3()
+p4()
+foo(i)
+withincode(void main(..))
+withincode(A.new(String))
+call(* ILib.*(..))
+runCall()
+(call(String clone(String)) || runCall())
+monitor()
+call(int foo(int))
+call(private * foo(..))
+call(* foo*(..))
+call(Main.Foo.new(..))
+call(Main.Foo*.new(..))
+startRecording1(n)
+startRecording2(n)
+startRecording3(n)
+call(* JoinPointInAroundAdvice.privateMethod(..))
+call(* JoinPointInAroundAdvice.publicMethod(..))
+execution(* JoinPointInAroundAdvice.test())
+execTest()
+execution(* FieldJoinPointsInAroundAdvice.test())
+execution(* FieldGetJoinPointsInAroundAdvice.test())
+this(x)
+(target(x) || this(x))
+(call(void *.*(..)) && (target(x) || this(x)))
+target(x)
+(this(x) || target(x))
+(call(void *.*(..)) && (this(x) || target(x)))
+(this(x) || args(x))
+(call(void *.*(..)) && (this(x) || args(x)))
+(args(x) || target(x))
+(call(void *.*(..)) && (args(x) || target(x)))
+execution(void C.Nested.method())
+get(* C.*)
+(set(* C.*) && args(x))
+set(* C.*)
+(call(* WarningSample.method()) && within(WarningSample))
+illegalCall()
+execution(* e1(..))
+execution(* e2(..))
+execution(* e3(..))
+execution(* e4())
+execution(* e5())
+execution(* e6())
+execution(* PrivateCall.test())
+execution(* test())
+(execution(* PrivateCallInstance.test()) && target(s))
+execTest(s)
+(execution(* PrivateCall_Instance_Package2.test()) && target(o))
+execTest(o)
+(within(*) && !within(pr62642))
+(call(* doStuff(..)) && target(f))
+execution(* TestSourceLines.*(..))
+execution(TestSourceLines.new(..))
+initialization(*.new(..))
+preinitialization(*.new(..))
+!within(HelloWorldAspect)
+execution(public * de..*(..))
+call(* java.lang.Object.clone())
+(method() && hello())
+method()
+hello()
+(cflow(method()) && (cloning() && hello()))
+execution(* test*(..))
+testcall()
+(call(* java.lang.Object.clone()) && within(ArrayCloning))
+within(SCE2)
+within(Goo)
+execution(* I.*(..))
+(execution(* print(..)) && cflow(execution(* main(..))))
+(execution(* main(..)) && target(o))
+(execution(* print(..)) && cflow((execution(* main(..)) && target(o))))
+cflow(execution(* main(..)))
+(call(* print(..)) && p1())
+(execution(* main(..)) && args(o))
+(call(* print(..)) && cflow((execution(* main(..)) && args(o))))
+cflow((execution(* main(..)) && args(o)))
+(call(* print(..)) && p1(o))
+abs()
+(call(* print(..)) && cflow(abs()))
+p()
+execution(* below1(..))
+within(Trace*)
+!cflow(within(Trace*))
+within(TraceClass)
+scope()
+(execution(* Base.trigger(..)) && args(argument))
+call2trigger(base)
+(execution(* BaseTarget.trigger(..)) && args(arg))
+call2trigger_samePackage(base)
+call(* *(..))
+(call(* *(..)) && target(s))
+(call(* *(..)) && target(sb))
+(target(r) && call(void run()))
+pc(r)
+pc(Runnable)
+pc(SubRunnable)
+pc(*)
+execution(* SofteningTooMuch.*(..))
+execution(void run())
+ref()
+(call(* *.*(..)) && !within(ExceptionLoggerAspectV2))
+exceptionLogMethods()
+call(void SampleClass.foo(..))
+traceCall()
+call(void TestSoftening.perform())
+execution(* fred(x))
+(call(void PrivilegedParsing.doSomething()) && target(capsule))
+call2doSomething(capsule)
+execution(Foo*.new(..))
+(execution(int getInt()) && target(I))
+(call(int getInt()) && target(I))
+(target(targ) && call(void run()))
+initialization(ErroneousExceptionConversion.new(..))
+myConstructor()
+(execution(Runnable+.new(..)) && !execution(new(String, ..)))
+handler(Throwable+)
+problemHandling()
+call(* goInteger(*))
+(call(* goNumber(*)) || call(* goInteger(*)))
+(call(* goObject(*)) || (call(* goNumber(*)) || call(* goInteger(*))))
+(call(* goLong(*)) || (call(* goObject(*)) || (call(* goNumber(*)) || call(* goInteger(*)))))
+(call(* goInt(*)) || (call(* goLong(*)) || (call(* goObject(*)) || (call(* goNumber(*)) || call(* goInteger(*))))))
+(call(* goByte(*)) || (call(* goInt(*)) || (call(* goLong(*)) || (call(* goObject(*)) || (call(* goNumber(*)) || call(* goInteger(*)))))))
+(call(* goBoolean(*)) || (call(* goByte(*)) || (call(* goInt(*)) || (call(* goLong(*)) || (call(* goObject(*)) || (call(* goNumber(*)) || call(* goInteger(*))))))))
+methodsInQuestion()
+execution(void doit(..))
+execution(* noMatch(..))
+execution(* Driver.doStuff())
+execution(* Driver.doOtherStuff())
+pc2()
+cflowbelow(execution(* main(..)))
+this(Object)
+target(Object)
+p5()
+args(Object)
+p6()
+crun()
+initialization(HW.new(String, A))
+!call(java.lang..new(..))
+(call(*..new(..)) && (!within(ConstructorAspects) && !call(java.lang..new(..))))
+(execution(*..new(..)) && !within(ConstructorAspects))
+(initialization(*..new(..)) && !within(ConstructorAspects))
+(preinitialization(*..new(..)) && !within(ConstructorAspects))
+(!within(ConstructorAspects) && allconstrpreinitializations())
+allconstrexecutions()
+(allconstrinitializations() || allconstrexecutions())
+(allconstrpreinitializations() || (allconstrinitializations() || allconstrexecutions()))
+(!within(ConstructorAspects) && (allconstrpreinitializations() || (allconstrinitializations() || allconstrexecutions())))
+execution(I.new(..))
+execution(I+.new(..))
+within(WeaveLocal)
+(withinTest() && call(* handleOrder(..)))
+callToHandleOrder()
+(target(i) && initialization(I.new()))
+withincode(static void SourceLocationWithinExpr.main(String))
+(filter() && call(C.new()))
+(filter() && call(D C.getD()))
+(filter() && call(E D.getE()))
+(filter() && call(F E.getF()))
+(this(i) && initialization(I.new(..)))
+initialization(I.new(..))
+execution(I.new())
+call(static void foo())
+call(static void method1())
+(cflow(execution(static void main(String))) && set(int field))
+module()
+(initialization(new(..)) && !within(A))
+call(void C.run())
+(target(CircularDominates) && call(static void foo(..)))
+cflowbelow(execution(static void main(String)))
+layerEntryMethods()
+execution(public * com.example.businessFacade.*.*(..))
+layerMethods()
+(layerMethods() && !cflowbelow(layerMethods()))
+call(* Connection.open(..))
+cflow(layerEntryMethods())
+(openedConnection() && layerBoundary())
+layerBoundary()
+!within(TraceAspect)
+within(DeclareSoftCf)
+(execution(* *Method(int)) && args(i))
+(target(C) && call(* r*(..)))
+within(SoftWithin)
+execution(void foo())
+(this(Object+) && (this(o) && execution(void foo())))
+finalizeCall(o)
+target(targ)
+(set(* test..*) && (args(newval) && target(targ)))
+assign(newval, targ)
+(call(* test..*(..)) && !within(Log))
+tracedCall()
+execution(* AdviceExec.*(..))
+(execution(* *()) && !within(Aspect2))
+execution(void finalize())
+(this(Object+) && (this(o) && execution(void finalize())))
+args(a)
+within(InnerPointcut)
+execution(public void mai*(..))
+(testcut() && testcutOuter())
+logged_method()
+(target(targ) && (target(B) && call(* *(..))))
+staticinitialization(DeclareWarningEmpty)
+initialization(DeclareWarningEmpty.new(..))
+staticinitialization(DeclareWarning)
+initialization(DeclareWarning.new(..))
+get(int staticInt)
+get(int instanceInt)
+set(int staticInt)
+set(int instanceInt)
+call(void run())
+call(void irun())
+call(DeclareWarning.new())
+execution(void irun())
+execution(DeclareWarning.new())
+(handler(OutOfMemoryError) && within(DeclareWarning))
+(handler(RuntimeException) && withincode(DeclareWarning.new()))
+(execution(* *()) && within(A))
+(execution(void bar(int)) && (this(o) && args(i)))
+cflow((execution(void bar(int)) && (this(o) && args(i))))
+(call(void m()) && flow(int, Object))
+(call(void m()) && flow(i, Object))
+(call(void m()) && flow(int, o))
+(call(void m()) && flow(i, o))
+within(Thread)
+(execution(void run()) && (this(thread) && within(Thread)))
+cflow((execution(void run()) && (this(thread) && within(Thread))))
+(call(* DummyConfiguration.createRootApplicationModule(..)) && testFlow(Thread))
+call(* *())
+execution(void C.bar())
+call(void go())
+call(java.io.*.new(..))
+(exceptionMethods() && !within(Exceptions))
+!within(EqualsContract)
+(call(public boolean equals(Object+)) && (args(otherOne) && !within(EqualsContract)))
+(target(Object+) && (target(thisOne) && (call(public boolean equals(Object+)) && (args(otherOne) && !within(EqualsContract)))))
+equalsCall(thisOne, otherOne)
+!within(Trace+)
+(call(new(..)) || execution(new(..)))
+(scope() && (call(new(..)) || execution(new(..))))
+(call(* *(..)) || execution(* *(..)))
+(scope() && (call(* *(..)) || execution(* *(..))))
+(scope() && (args(e) && handler(Exception+)))
+execution(void Trace.trace*(.., (JoinPoint || JoinPoint.StaticPart), ..))
+internalMethods()
+(methodTrace() && !cflowbelow(internalMethods()))
+(constructorTrace() && !cflowbelow(internalMethods()))
+methodTrace()
+(constructorTrace() || methodTrace())
+((constructorTrace() || methodTrace()) && !cflowbelow(internalMethods()))
+(handlerTrace(e) && !cflowbelow(internalMethods()))
+within(cap.OptionList)
+within(A)
+!initialization(new(..))
+(!handler(*) && (!preinitialization(new(..)) && !initialization(new(..))))
+(within(C) && (!cflow(within(A)) && (!handler(*) && (!preinitialization(new(..)) && !initialization(new(..))))))
+within(LoggedType+)
+staticinitialization(LoggedType)
+within(TestAjc)
+(!within(TestAjc) && !cflow(within(TestAjc)))
+(notMySelf() && call(* *.*(..)))
+(notMySelf() && execution(* *.*(..)))
+eachCall()
+eachExecution()
+call(void f(i))
+(where() && args(i, d))
+where()
+call(* *..C.*(..))
+execution(* LongFile.doit())
+withincode(* get*Name(..))
+(call(* *(..)) && !within(ImposterProcessing+))
+(staticinitialization(*) || initialization(*.new(..)))
+(execution(* *(..)) || execution(new(..)))
+methodsAndConstructors()
+(initializers() || methodsAndConstructors())
+this(o)
+(guarded() && nonStaticContext(o))
+(args(index) && call(String doit(int)))
+execution(void Test.sayHello(..))
+(execution(void Test.doSayHello(..)) && cflow(execution(void Test.sayHello(..))))
+(call(void Test.doSayHello(..)) && withincode(void Test.sayHello(..)))
+directCall()
+badCall()
+(call(public * *(..)) && !adviceCflow())
+publicCalls()
+(call(public * *(..)) && !within(AA+))
+(pc() && !call(void println(..)))
+call(Object ICanGetSomething.getSomething())
+call(Object getSomething())
+execution(public * ExceptionBugTest.*(..))
+exceptionThrower()
+execution(void D.m())
+execution(void C.m())
+within(NoSoftener)
+(call(* *(..)) && scope())
+callsThrowingChecked()
+execution(ContainerLoader+.new(..))
+containerLoads(*, key)
+execution(ActiveContainer ContainerLoader.createContainer(ContainerDescriptor))
+(this(loader) && (args(containerDesc) && execution(ActiveContainer ContainerLoader.createContainer(ContainerDescriptor))))
+(this(c) && execution(void m1()))
+exec1(c)
+execs(*)
+execs(c)
+(this(c) && execution(void m2()))
+exec2(c)
+execs2(c)
+execs2(*)
+args(arg)
+(this(JoinPointFields) && (execution(String foo(String)) && args(arg)))
+call(void LocalFile.sendHeader())
+sendHeader()
+(args(n) && execution(int foo(int)))
+(within(AdviceOnIntroduced) && (args(n) && execution(int foo(int))))
+(within(Foo) && execution(new(..)))
+args(n)
+(target(Foo) && (call(int foo(int)) && args(n)))
+fooCut(n)
+(within(AroundAdvice) && call(String bar()))
+args(s)
+(this(Foo) && (call(String b(String)) && args(s)))
+ccut(methodString)
+(target(i1) && call(String process()))
+target(packagevisibility.testPackage.Class2)
+(target(packagevisibility.testPackage.Class1) || target(packagevisibility.testPackage.Class2))
+(call(String doIt(String)) && (args(s) && (target(packagevisibility.testPackage.Class1) || target(packagevisibility.testPackage.Class2))))
+call(C.new())
+call(C1.new())
+(this(Foo) && call(void m(..)))
+(target(m) && execution(new(..)))
+(target(Foo) && call(int bar(int, int, int)))
+cut()
+(target(b) && call(int bar(int, int, int)))
+cut(b)
+execution(void bar())
+(target(foo) && (within(Foo) && execution(void bar())))
+(target(foo) && call(void bar()))
+(execution(new()) && within(C))
+install()
+(within(Driver) && execution(String doIt()))
+staticMeth()
+execution(int *(..))
+entries(Client)
+call(void Server.doService2())
+(call(void Server.doService1(Object)) || call(void Server.doService2()))
+(this(c) && (call(void Server.doService1(Object)) || call(void Server.doService2())))
+entries(c)
+(this(ServiceWorker1) && call(void doWorkItemA()))
+(this(ServiceWorker2) && call(void doWorkItemB()))
+(this(ServiceWorker3) && call(void doWorkItemC()))
+(this(ServiceWorker4) && call(void doWorkItemD()))
+((this(ServiceWorker3) && call(void doWorkItemC())) || (this(ServiceWorker4) && call(void doWorkItemD())))
+((this(ServiceWorker2) && call(void doWorkItemB())) || ((this(ServiceWorker3) && call(void doWorkItemC())) || (this(ServiceWorker4) && call(void doWorkItemD()))))
+((this(ServiceWorker1) && call(void doWorkItemA())) || ((this(ServiceWorker2) && call(void doWorkItemB())) || ((this(ServiceWorker3) && call(void doWorkItemC())) || (this(ServiceWorker4) && call(void doWorkItemD())))))
+workPoints()
+(within(ComputedThrows) && call(* ComputedThrows.bar(..)))
+Foo()
+(within(StaticCalls) && (call(String StaticCalls.lookup(String)) && args(s)))
+call(Class Class.forName(String))
+classForName()
+(within(NewSiteAdvice) && call(NewSiteAdvice.new()))
+makeNewSiteAdvice()
+!within(A)
+(args(i) && (call(Integer.new(int)) && !within(A)))
+(within(AfterThrowing) && execution(* *(boolean)))
+throwerCut()
+(within(AfterThrowing) && call(* AfterThrowing.*(boolean)))
+catchThrowsFrom()
+execution(String get*())
+execution(String *Getter())
+execution(String prefix*Suffix())
+(this(s) && target(c))
+(target(c) && within(Simple))
+(this(s) && call(* C+.*(..)))
+call(* C.*(..))
+call(* SubC.*(..))
+(call(* SubC.*(..)) && target(C))
+(call(* C.*(..)) && target(SubC))
+(args(.., s) && call(* C+.*(..)))
+(within(Driver) && call(void Driver.bind()))
+bind()
+(call(* CallsFrom.b(..)) && within(CallsTo))
+call1()
+within(SourcePane)
+(target(loc) && (call(int Location.lineNumber()) && within(SourcePane)))
+locationLineNumber(loc)
+(this(Test) && execution(* go(..)))
+(call(int Math.*(..)) && !call(* Test.go()))
+(call(* init(..)) && this(tc))
+init(tc)
+call(String CP.parse(String))
+(args(cmd) && (target(cp) && call(String CP.parse(String))))
+((args(cmd) && (target(cp) && call(String CP.parse(String)))) && within(CL))
+parseCalls(cp, cmd)
+target(c)
+(target(c) && call(* *(..)))
+call(* equals(..))
+call(* toString(..))
+call(* hashCode(..))
+call(* clone(..))
+(call(* hashCode(..)) || call(* clone(..)))
+(call(* toString(..)) || (call(* hashCode(..)) || call(* clone(..))))
+(call(* equals(..)) || (call(* toString(..)) || (call(* hashCode(..)) || call(* clone(..)))))
+(call(* *(..)) && !excludes())
+(allCalls() && target(MyObject))
+contexts()
+(target(Foo) && call(void bar()))
+!this(A)
+(this(*) && (execution(new(..)) && !this(A)))
+call(Foo.new(..))
+nimboCut()
+call(int Foo.*(..))
+execution(A0+.new())
+execution(A1.new())
+execution(B.new())
+execution(* mousePressed(..))
+(this(InnerClassNaming.MyListener) && (target(ls) && execution(* mousePressed(..))))
+pressed(ls)
+(target(c1) && call(public void a()))
+a(c1)
+(call(public void Class1.b()) && within(Aspect1))
+b()
+(call(* getName(..)) && this(Class1))
+(call(void f()) && this(a1))
+call(* Integer.*(..))
+(get(* *.*) && within(Counting3))
+g()
+(set(* *.*) && within(Counting3))
+s()
+(g() || s())
+gs()
+!call(* Testing.*())
+(call(* *.*(..)) && (within(Counting3) && !call(* Testing.*())))
+c()
+(execution(* *.*(..)) && within(Counting3))
+e()
+(c() || gs())
+cgs()
+(e() || gs())
+egs()
+(c() || (e() || gs()))
+cegs()
+(call(void *(..)) && target(C+))
+(call(void C+.*(String)) && args(s))
+(call(void *(..)) && target(SubC))
+allcall()
+callInC(s)
+callInSubC()
+(call(void C.*(..)) && target(SubC))
+call(C+.new(..))
+call(String foo())
+(fooCut() && within(*))
+(target(Foo) && call( !abstract String *(..)))
+allMethodsCut()
+target(d)
+(call(String D.m1(String, int)) && (args(as, ax) && target(d)))
+(call(String m1(String, int)) && args(as, ax))
+(within(C) && (target(d1) && (call(String m1(String, int)) && args(as, ax))))
+(this(t) && execution(!* _*()))
+execution(!* _*())
+(this(t) && (!this(NotCharInPointcut) && execution(!* _*())))
+pcut2(t)
+(pcut1(t) || pcut2(t))
+pcut1(t)
+pcut2(*)
+pcut3(t)
+(target(Test) && call(void go()))
+(within(Test) && call(void Object+.*(..)))
+call(void CP.parse(String))
+(target(cp) && (args(cmd) && call(void CP.parse(String))))
+((target(cp) && (args(cmd) && call(void CP.parse(String)))) && within(CL))
+(call(* run(..)) && target(A))
+run()
+(call(* run(..)) && target(Runnable+))
+(call(* run(..)) && target(ExtendsA))
+(call(* run(..)) && target(r))
+run(r)
+(within(C) && call(* C.*(..)))
+(target(o) && call(void g()))
+(target(o) && call(void a()))
+call(void C.c())
+(target(c) && execution(new(..)))
+(target(d) && execution(new(..)))
+(target(C) && call(void c()))
+call(void C.d())
+(target(C) && execution(void c()))
+d()
+x()
+target(C)
+(i() && execution(* f(..)))
+execution(* c(..))
+staticinitialization(C)
+execution(C.new(..))
+call(public Object f(String))
+call(* jp(..))
+call(void Runnable.run())
+call(int compareTo(Object))
+call(String Object.toString())
+call(void C.m*())
+execution(* C.throwIt())
+call(* C.pretendsToThrow())
+execution(* C.*(..))
+execution(void C.m3())
+call(*.new())
+(within(Driver) && execution(void test()))
+innerPoints()
+set(int FieldInitializerJoinPoints.j)
+set(int FieldInitializerJoinPoints.k)
+set(int FieldInitializerJoinPoints.l)
+set(int FieldInitializerJoinPoints.m)
+set(int FieldInitializerJoinPoints.n)
+set(int FieldInitializerJoinPoints.o)
+set(int FieldInitializerJoinPoints.p)
+set(int FieldInitializerJoinPoints.q)
+call(int FieldInitializerJoinPoints.n())
+call(int FieldInitializerJoinPoints.o())
+call(int FieldInitializerJoinPoints.p())
+call(int FieldInitializerJoinPoints.q())
+(call(void PrivateClass.goo()) && target(obj))
+(call(void fish.PrivateClass.goo()) && target(obj))
+!within(C)
+(get(int C.x) && (target(c) && !within(C)))
+(call(void Runnable.run()) && target(r))
+call(Runnable+.new())
+set(int x)
+staticinitialization(SubC)
+(initialization(C.new(..)) && this(c))
+(execution(C.new(..)) && this(c))
+(initialization(SubC.new(..)) && this(subc))
+(execution(SubC.new(..)) && this(subc))
+(initialization(I.new()) && this(i))
+staticinitialization(Foo)
+initialization(Foo.new(..))
+call(String SubC.getMyPackage())
+(!args(Marker, ..) && call(String C.getMyPackage()))
+(!target(Marker) && (!this(Marker) && (!args(Marker, ..) && call(String C.getMyPackage()))))
+(this(i) && execution(void foo()))
+(this(i) && execution(void foo(..)))
+(this(i) && execution(void foo(int)))
+(this(i) && execution(void foo(.., ..)))
+(this(i) && execution(void foo(int, ..)))
+(this(i) && execution(void foo(.., int)))
+(this(i) && execution(void foo(int, int)))
+(this(i) && execution(void foo(.., .., ..)))
+(this(i) && execution(void foo(.., .., int)))
+(this(i) && execution(void foo(.., int, ..)))
+(this(i) && execution(void foo(.., int, int)))
+(this(i) && execution(void foo(int, .., ..)))
+(this(i) && execution(void foo(int, .., int)))
+(this(i) && execution(void foo(int, int, ..)))
+(this(i) && execution(void foo(int, int, int)))
+(this(i) && execution(void foo(.., .., .., ..)))
+(this(i) && execution(void foo(.., .., .., int)))
+(this(i) && execution(void foo(.., .., int, ..)))
+(this(i) && execution(void foo(.., .., int, int)))
+(this(i) && execution(void foo(.., int, .., ..)))
+(this(i) && execution(void foo(.., int, .., int)))
+(this(i) && execution(void foo(.., int, int, ..)))
+(this(i) && execution(void foo(.., int, int, int)))
+(this(i) && execution(void foo(int, .., .., ..)))
+(this(i) && execution(void foo(int, .., .., int)))
+(this(i) && execution(void foo(int, .., int, ..)))
+(this(i) && execution(void foo(int, .., int, int)))
+(this(i) && execution(void foo(int, int, .., ..)))
+(this(i) && execution(void foo(int, int, .., int)))
+(this(i) && execution(void foo(int, int, int, ..)))
+(this(i) && execution(void foo(int, int, int, int)))
+(get(String SuperC.name) && target(sc))
+(get(String C.name) && target(c))
+set(String C.name)
+(call(* call*()) && target(o))
+args(i0)
+(call(* call*(int)) && (target(o) && args(i0)))
+args(i0, i1)
+(call(* call*(int, int)) && (target(o) && args(i0, i1)))
+args0(o)
+args1(o, i0)
+args2(o, i0, i1)
+(call(* *(.., A, ..)) && target(Params))
+intParams()
+call(Object Object.clone())
+get(* System.in)
+(handler(Exception) && args(e))
+call(int Super.m(int))
+(call(double StrictFPAdvice.m(double)) && args(d))
+points(d)
+(call(void ASTObject.voidMethod()) && target(ast))
+args(msg)
+(call(void ASTObject.voidMethod(String)) && (target(ast) && args(msg)))
+args(msg1, msg2)
+(call(void ASTObject.voidMethod(String, String)) && (target(ast) && args(msg1, msg2)))
+(call(int ASTObject.intMethod()) && target(ast))
+(call(int ASTObject.intMethod(String)) && (target(ast) && args(msg)))
+(call(int ASTObject.intMethod(String, String)) && (target(ast) && args(msg1, msg2)))
+(this(ClassWithStaticMethods) && execution(void staticMethod()))
+(this(c) && execution(void staticMethod()))
+(target(ClassWithStaticMethods) && call(void staticMethod()))
+(target(c) && call(void staticMethod()))
+(target(*) && call(void ClassWithStaticMethods.staticMethod()))
+bad0()
+bad1(c)
+bad2()
+bad3(c)
+bad4()
+bad5(c)
+execution(void ClassWithStaticMethods.staticMethod())
+good0()
+!within(Aspect)
+(get(String PrintService.string) && (target(ps) && !within(Aspect)))
+needPrinter(ps)
+execution(int m1(..))
+execution(int m2(..))
+execution(int m3(..))
+execution(int m4(..))
+(call(void write(String)) && args(s))
+withincode(C.new())
+(call(void write(String)) && (args(s) && withincode(C.new())))
+within(C)
+(execution(void Runnable.run()) && (target(runnable) && within(C)))
+(execution(void run()) && withincode(Runnable C.getRunnable()))
+(call(* *(..)) && !within(A))
+(this(caller) && (target(callee) && (call(* *(..)) && !within(A))))
+(call(void go(..)) && target(Finals))
+target(Finals)
+(call(void go(String)) && (args(argss) && target(Finals)))
+p2(argss)
+call(void C.f())
+(target(s) && execution(new(..)))
+(target(FTPConnection) && call(* *(..)))
+target(TheObject)
+this(Caller)
+call(String.new(String))
+stringCtors()
+cCtors()
+(call(void go()) && target(caller))
+goCalls(caller)
+call(void Caller.staticGo())
+goStaticCalls()
+(target(s) && call(public * *(..)))
+service(s)
+testCut()
+call(void EmptyStack.test(..))
+target(EachObjectTarget)
+call(void foo(..))
+within(Binkley)
+call(new())
+(cflow(pc()) && (!call(new()) && !within(A)))
+(within(C) && call(void I.foo(*)))
+call(void I.foo(*))
+call(* I.foo(*))
+pc3()
+pc1()
+target(Product1)
+target(p)
+instance(p)
+targets(i, c)
+(target(c) && (call(void C.m(int)) && args(i)))
+entries()
+execution(void C.m(..))
+target(MemberInitSet)
+set(String MemberInitSet.s)
+target(test.Test)
+runs()
+get(String C.str0)
+get(String C.str1)
+get(String C.str2)
+get(String C.str3)
+set(String C.str0)
+set(String C.str1)
+set(String C.str2)
+set(String C.str3)
+gets_String_str0()
+gets_String_str1()
+gets_String_str2()
+gets_String_str3()
+gets_String_str0b()
+gets_String_str1b()
+gets_String_str2b()
+gets_String_str3b()
+sets_String_str0()
+sets_String_str1()
+sets_String_str2()
+sets_String_str3()
+sets_String_str0b()
+sets_String_str1b()
+sets_String_str2b()
+sets_String_str3b()
+sets_String_str0c()
+sets_String_str1c()
+sets_String_str2c()
+sets_String_str3c()
+gets_String_sstr0()
+gets_String_sstr1()
+gets_String_sstr2()
+gets_String_sstr3()
+gets_String_sstr0b()
+gets_String_sstr1b()
+gets_String_sstr2b()
+gets_String_sstr3b()
+sets_String_sstr0()
+sets_String_sstr1()
+sets_String_sstr2()
+sets_String_sstr3()
+sets_String_sstr0b()
+sets_String_sstr1b()
+sets_String_sstr2b()
+sets_String_sstr3b()
+sets_String_sstr0c()
+sets_String_sstr1c()
+sets_String_sstr2c()
+sets_String_sstr3c()
+get(int C.int0)
+get(int C.int1)
+get(int C.int2)
+get(int C.int3)
+set(int C.int0)
+set(int C.int1)
+set(int C.int2)
+set(int C.int3)
+gets_int_int0()
+gets_int_int1()
+gets_int_int2()
+gets_int_int3()
+gets_int_int0b()
+gets_int_int1b()
+gets_int_int2b()
+gets_int_int3b()
+sets_int_int0()
+sets_int_int1()
+sets_int_int2()
+sets_int_int3()
+sets_int_int0b()
+sets_int_int1b()
+sets_int_int2b()
+sets_int_int3b()
+sets_int_int0c()
+sets_int_int1c()
+sets_int_int2c()
+sets_int_int3c()
+gets_int_sint0()
+gets_int_sint1()
+gets_int_sint2()
+gets_int_sint3()
+gets_int_sint0b()
+gets_int_sint1b()
+gets_int_sint2b()
+gets_int_sint3b()
+sets_int_sint0()
+sets_int_sint1()
+sets_int_sint2()
+sets_int_sint3()
+sets_int_sint0b()
+sets_int_sint1b()
+sets_int_sint2b()
+sets_int_sint3b()
+sets_int_sint0c()
+sets_int_sint1c()
+sets_int_sint2c()
+sets_int_sint3c()
+(target(Test) && (call(void go(int)) && args(x)))
+root(x)
+cflow(root(x))
+root(int)
+(root(int) && !cflow(root(int)))
+args(s1, s2)
+(target(Object) && (call(void *(String, String)) && args(s1, s2)))
+(flow(y) && (target(Test) && (target(Object) && (call(void *(String, String)) && args(s1, s2)))))
+flowCut()
+(target(Test) && call(void go(int)))
+(call(void set*(..)) && target(ArrayCasts))
+callstoSets()
+call(* realMain(..))
+(pc() && !cflowbelow(pc()))
+(target(*) && (call(String packageDoIt(String)) && args(a)))
+(target(SubC) && (call(String doIt(String)) && args(a)))
+(target(SuperC) && (call(String doIt1(String)) && args(a)))
+(target(a) && call(void bar()))
+m(a)
+((this(*) && execution(* *(..))) || execution(new(..)))
+(((this(*) && execution(* *(..))) || execution(new(..))) && !within(A))
+(this(*) && call(* *(..)))
+(target(C) && call(void m()))
+(target(C) && call(void recur(int)))
+(cut() && !cflow(cut()))
+(cut() && !cflowbelow(cut()))
+(cut() && cflow((cut() && !cflow(cut()))))
+(target(C) && call(void a()))
+target(I)
+(i() && initialization(I.new(..)))
+j()
+call(* Test.go(..))
+(call(* *(..)) && target(r))
+(!this(SeqCut) && (this(s) && (call(* *(..)) && target(r))))
+call(* *..*.*(..))
+(!this(SeqCut) && (this(s) && call(* *..*.*(..))))
+call(void f*(*))
+(target(Test) && (args(i) && call(void f*(*))))
+fooCut(o)
+call(void NonexistentInitializers.foo())
+get(int Gets.*)
+get(int Gets.nums0)
+get(int Gets.nums1)
+get(int Gets.nums2)
+get(int Gets.nums3)
+get(int Gets.nums4)
+get(int Gets.nums5)
+get(int Gets.nums6)
+get(int Gets.nums7)
+get(int Gets.nums8)
+get(int Gets.nums9)
+set(int Gets.*)
+set(int Gets.nums0)
+set(int Gets.nums1)
+set(int Gets.nums2)
+set(int Gets.nums3)
+set(int Gets.nums4)
+set(int Gets.nums5)
+set(int Gets.nums6)
+set(int Gets.nums7)
+set(int Gets.nums8)
+set(int Gets.nums9)
+(call(* *.*(..)) || execution(* *.*(..)))
+(points() && !within(JoinPointCounting))
+(call(void FigureElement.translate(int, int)) || (call(void Line.setP1(Point)) || (call(void Line.setP2(Point)) || (call(void Point.setX(int)) || call(void Point.setY(int))))))
+moves()
+(args(i) && call(void *gaoijbal()))
+execution(strictfp * *(..))
+call(strictfp * *.*(..))
+r_strict()
+c_strict()
+!target(E)
+(this(C) && (call(* foo()) && !target(E)))
+call(void m())
+call(String toString())
+(target(C) && call(String m2()))
+testpoint()
+(target(C) && call(String m1()))
+call(String C.*(..))
+this(TheObject)
+execution(new())
+call(void C.mThrowsCheckedExc())
+call(void C.mNoThrows())
+uncheckedCut()
+(checkedCut() || uncheckedCut())
+allCut()
+checkedCut()
+(target(NotAndPointcut) && call(* NotAndPointcut.*(..)))
+(execution(* NotAndPointcut.showBug(..)) && !(target(NotAndPointcut) && call(* NotAndPointcut.*(..))))
+(within(IfPCDExprJoinPointVisibleCE) && errorAccessingThisJoinPoint())
+(within(IfPCDExprJoinPointVisibleCE) && errorAccessingThisJoinPointStaticPart())
+args(args)
+target(target)
+this(thisItem)
+call(void IfPCDExprVisibility())
+(args(args) && call(static void *..main(String)))
+call(void IfPCDExprJoinPointVisibleCE.main(..))
+callMain(args)
+withincode(static void IfPCDDupMethod.main(String))
+call(boolean *..executedNamedIfNever(..))
+errorIfCalled()
+within(BaseApp)
+execution(void *(int))
+(namedIf() && set(int BaseApp.i))
+(namedIf() && get(int BaseApp.i))
+(namedIf() && (call(void *.call(int)) && within(BaseApp)))
+(namedIf() && (call(void BaseApp.call(int)) && within(BaseApp)))
+(namedIf() && execution(void *(int)))
+(namedIf() && initialization(BaseApp.new(..)))
+set_pc()
+get_pc()
+call_pc()
+callType_pc()
+execution_pc()
+initialization_pc()
+named_set_pc()
+named_get_pc()
+named_call_pc()
+named_callType_pc()
+named_execution_pc()
+named_initialization_pc()
+(call(void NotThis.foo(Object)) && within(A))
+(call(void NotThis.foo(Object)) && this(A))
+(call(void NotThis.foo(Object)) && !within(B))
+(call(void NotThis.foo(Object)) && !this(B))
+(target(i) && call(* *(..)))
+!preinitialization(new(..))
+(!call(* A.*(..)) && (!initialization(new(..)) && !preinitialization(new(..))))
+set(int value)
+(call(int Num.fact(int)) && args(x3))
+cflowbelow((call(int Num.fact(int)) && args(x3)))
+(call(int Num.fact(int)) && (args(x2) && cflowbelow((call(int Num.fact(int)) && args(x3)))))
+cflowbelow((call(int Num.fact(int)) && (args(x2) && cflowbelow((call(int Num.fact(int)) && args(x3))))))
+(call(int Num.fact(int)) && (args(x1) && cflowbelow((call(int Num.fact(int)) && (args(x2) && cflowbelow((call(int Num.fact(int)) && args(x3))))))))
+call(void m1())
+call(void *1())
+execution(void *1())
+initialization(*1.new())
+staticinitialization(*1)
+withincode(void C1.*1())
+set(int C*1.fi1)
+get(int *.*1)
+execution(void *1.m1())
+(cflowbelow(execution(void *1.m1())) && !within(B))
+(cflow(execution(void *1.m1())) && !within(B))
+execution(public int TargetClass.getField())
+(within(Test) && call(* bar()))
+(this(I) && (target(Test) && (within(Test) && call(* bar()))))
+(call(void handleCollision(Object)) && args(so))
+(call(void Ship.inflictDamage(int)) && args(d))
+(this(s) && (cflow((call(void handleCollision(Object)) && args(so))) && (call(void Ship.inflictDamage(int)) && args(d))))
+collisionDamage(s, so, d)
+(call(void handleCollision(int)) && args(so))
+(this(s) && (cflow((call(void handleCollision(int)) && args(so))) && (call(void Ship.inflictDamage(int)) && args(d))))
+collisionDamage2(s, so, d)
+(this(s) && (withincode(void handleCollision()) && (call(void Ship.inflictDamage(int)) && args(d))))
+collisionDamage3(s, d)
+target(i)
+(!within((I || A*)) && (set(String I.*) && target(i)))
+(within(I) && (set(String I.*) && target(i)))
+(within(A*) && (set(String I.*) && target(i)))
+(initialization(I.new(..)) && target(i))
+execution(void C.a())
+(safety() && cflow(pc()))
+(safety() && cflow(execution(void C.a())))
+(safety() && cflowbelow(pc()))
+(safety() && cflowbelow(execution(void C.a())))
+execution(void TargetClass.callInt(int))
+(call(void TargetClass.callInt(int)) || execution(void TargetClass.callInt(int)))
+!target(StringBuffer)
+(!target(Aspect) && (args(i) && !target(StringBuffer)))
+(target(c) && execution(public void C.run()))
+within(B)
+!cflow(within(B))
+(target(i) && (execution(public void I.trigger()) && !cflow(within(B))))
+!cflow(within(A))
+execution(public void C.foo())
+(execution(public void C.bar()) && outside())
+(cflow(execution(public void C.foo())) && (target(c) && (execution(public void C.bar()) && outside())))
+(within(Parent+) && execution(* *(..)))
+(!within(PR519) && call(void A.bar(..)))
+args(problem)
+(!within(PR519) && (call(void A.bar(..)) && args(problem)))
+call(public void Logger.log(..))
+allLoggingCalls()
+(target(t) && execution(void TargetClassWithoutImplementation.run()))
+execution(public void Inner.*())
+(within(Protected+) && execution(* *(..)))
+within(Protected)
+(!call(StringBuffer.new(..)) && !call(* String.valueOf(Object)))
+(within(TargetClass) && (!call(* StringBuffer.*(..)) && (!call(StringBuffer.new(..)) && !call(* String.valueOf(Object)))))
+call(public void TargetClass.run())
+noEnclosingJoinPoint()
+(allTargetJoinPoints() && !noEnclosingJoinPoint())
+(call(* TargetClass.*(..)) || handler(Error))
+(set(* TargetClass.*) || (call(* TargetClass.*(..)) || handler(Error)))
+(get(* TargetClass.*) || (set(* TargetClass.*) || (call(* TargetClass.*(..)) || handler(Error))))
+initialization(TargetClass.new(UnknownConstructor))
+(staticinitialization(TargetClass) || initialization(TargetClass.new(UnknownConstructor)))
+!syntheticJoinPoints()
+(allTargetJoinPoints() && !syntheticJoinPoints())
+(hasEnclosingJoinPoint() && !syntheticJoinPoints())
+allTargetJoinPoints()
+hasEnclosingJoinPoint()
+joinPointHasValidSourceLocation()
+enclosingJoinPointHasValidSourceLocation()
+staticinitialization(AnotherTargetClass)
+(call(* C.m*(*)) && args(p))
+target(o)
+(call(* C.m*(*)) && (args(p) && target(o)))
+call(* C.m3())
+(call(* C.m1()) || call(* C.m3()))
+call(* C.m*())
+canThrowChecked()
+canThrowChecked1()
+canThrowUnchecked()
+execution(void AspectOf.run())
+execution(void AspectOf.subrun())
+(call(void mumble()) && this(t))
+within(testclass1)
+(!preinitialization(new(..)) && !initialization(new(..)))
+(!within(Filteraspect) && (cflow(within(testclass1)) && (!preinitialization(new(..)) && !initialization(new(..)))))
+get(int AssignOps.staticInt)
+set(int AssignOps.staticInt)
+get(int AssignOps.instanceInt)
+set(int AssignOps.instanceInt)
+get(boolean AssignOps.bool)
+set(boolean AssignOps.bool)
+(execution(* *(..)) && within(AfterFinally))
+(call( !static String PR590a.*(..)) && args(s))
+target(Byte)
+pc(s)
+pc(e)
+(acid() && base())
+within(AbstractDeclare)
+call(* C.*())
+target(TargetClass)
+execution(String TargetClass.toString())
+!call(String TargetClass.toString())
+(!within(A) && (!cflow(execution(String TargetClass.toString())) && !call(String TargetClass.toString())))
+call(int TargetClass.publicIntMethod(int))
+execution(void TargetClass.run())
+(execution(public String toString()) && target(TargetClass))
+call(int TargetClass.privateIntMethod(int))
+intMethod()
+execution(int TargetClass.privateIntMethod(int))
+execution(TargetClass.new(..))
+initialization(TargetClass+.new(..))
+execution(int TargetClass.publicIntMethod(int))
+(cflow(execution(int TargetClass.publicIntMethod(int))) && safety())
+(cflowbelow(execution(int TargetClass.publicIntMethod(int))) && safety())
+(set(int TargetClass.index) && safety())
+(get(int TargetClass.index) && safety())
+(within(TargetClass+) && safety())
+(withincode(int TargetClass+.publicIntMethod(int)) && safety())
+(this(t) && safety())
+(target(t) && safety())
+(args(i) && safety())
+safety()
+call(TargetClass.new(..))
+target(t)
+(cflow(call(int TargetClass.privateIntMethod(int))) && !cflowbelow(call(int TargetClass.privateIntMethod(int))))
+(initialization(TargetClass.new()) || (cflow(call(int TargetClass.privateIntMethod(int))) && !cflowbelow(call(int TargetClass.privateIntMethod(int)))))
+(execution(int TargetClass.privateIntMethod(int)) || (initialization(TargetClass.new()) || (cflow(call(int TargetClass.privateIntMethod(int))) && !cflowbelow(call(int TargetClass.privateIntMethod(int))))))
+(call(int TargetClass.privateIntMethod(int)) || (execution(int TargetClass.privateIntMethod(int)) || (initialization(TargetClass.new()) || (cflow(call(int TargetClass.privateIntMethod(int))) && !cflowbelow(call(int TargetClass.privateIntMethod(int)))))))
+call(void TargetClass.catchThrows())
+!cflow(call(void TargetClass.catchThrows()))
+!call(void TargetClass.run())
+!set(int TargetClass.index)
+!get(int TargetClass.index)
+(within(TryOffEnd) && handler(Throwable))
+within(Test)
+withinAspects()
+!withinAspects()
+define()
+call(public void Runnable.run())
+call(public void Target.run())
+definePrivate()
+definePackagePrivate()
+defineProtected()
+definePublic()
+execution(void SubAspectVisibility.main(..))
+execution(void OuterChild.main(..))
+execution(void ForeignChildAspect.main(..))
+execution(void PrivatePointcut.main(..))
+execution(void PrivatePointcutOuterClass.main(..))
+execution(void AroundCasting.main(String))
+pointcutTarget()
+call(int Target.targetMethod())
+execution(void Target.method())
+(call(long m(long)) && args(l))
+(call(String C.doit(Object)) && args(s))
+t1(s)
+t1(o)
+(call(String C.doit(Object)) && args(o))
+m(s)
+m(i)
+m(d)
+(this(o) && execution(new(..)))
+make(i)
+(m() && args(s))
+(m() && args(i))
+(m() && args(d))
+execution(void C.m*(..))
+(execution(void Base+.foo(..)) && target(o))
+(call(void Base+.foo(..)) && target(o))
+call(void Derived+.foo(..))
+execution(void Derived+.foo(..))
+call(* IBase.*(..))
+call(* IBase+.*(..))
+call(* Base.*(..))
+execution(* Base+.*(..))
+(call(void Target.resize(..)) && target(buffer))
+target(buffer)
+(call(void Target.resize(..)) && (args(i) && target(buffer)))
+(call(void Target.resize(..)) && args(i))
+(target(Lib) && call(* *(..)))
+entry()
+(entry() && !cflowbelow(entry()))
+topEntry()
+execution(AfterReturningParam.new())
+execution(int AfterReturningParam.mInt())
+execution(Object AfterReturningParam.mObject())
+execution(void AfterReturningParam.mVoid())
+(call(int Rectangle.getSurface()) && !call(int Square.getSurface()))
+(withincode(void someMethod(String)) && args(s))
+(call(* java.util.List.add(Object)) && args(o))
+(top(s) && method(o))
+(execution(void someMethod(String)) && args(s))
+cflow((execution(void someMethod(String)) && args(s)))
+(call(* List.add(Object)) && args(o))
+(flow(s) && some(o))
+args(arg1, arg2)
+(target(C) && (call(public void doSomething(String, String)) && args(arg1, arg2)))
+execution(static void Target.main(..))
+q()
+(call(String Object.toString()) && target(t))
+(p() && execution(static void C1.main(String)))
+within(p..*)
+(!within(AspectMarker+) && (!preinitialization(new(..)) && !initialization(new(..))))
+execution(* Target.*(..))
+allTarget()
+cflow(allTarget())
+(notInAspect() && allTarget())
+(notInAspect() && allTargetFlow())
+notInAspect()
+(within(Target) && (execution(* *(..)) && notInAspect()))
+(within(Target) && execution(* *(..)))
+(cflow((within(Target) && execution(* *(..)))) && notInAspect())
+inTarget()
+inTargetFlow()
+TargetRun()
+TargetRunFlow()
+TargetSubRunFlow()
+entry(x)
+cflow(entry(x))
+call(* body())
+(body() && flow(i))
+(args(*, y) && call(void enter(int, int)))
+(args(x, *) && call(void enter(int, int)))
+(args(i) && call(void enter1(int)))
+entry(int)
+body()
+callcflow()
+(cflow(call(public void Target.run())) && !within(Base+))
+within(Target)
+target(Interface)
+(target(Object) && !target(A))
+(call(* MailerTest.run(TestResult)) && target(testCase))
+inThisTestCase(testCase)
+cflow(inThisTestCase(testCase))
+call(void Mailer.sendTextMail(..))
+(call(void Transport.send(Message)) && args(msg))
+sendMailCall()
+transportSend(msg)
+(flowOfTestCase(testCase) && (cflow(sendMailCall()) && transportSend(msg)))
+execution(* StaticSet.*())
+(within(FieldInit) && execution(* *()))
+execution(* FieldSet.*())
+staticinitialization(StaticInit)
+args(argC)
+(execution(void m*(*)) && (this(thisC) && args(argC)))
+(call(void m*(*)) && (target(thisC) && args(argC)))
+get(int C.*)
+(execution(* C.*(..)) || get(int C.*))
+pc_reference()
+execution(void TargetClass.doit())
+pc_notfound()
+(!within(I) && cflow(pc_notfound()))
+(!within(Aspect) && (!within(DebugAspect) && (!within(I) && cflow(pc_notfound()))))
+someCallCflow()
+pc_reference2()
+pc_notfound2()
+anotherRef()
+abstractPointcut()
+call(void SourceLocationCall.maincall(..))
+trace1()
+call(void SourceLocationCall.main(..))
+call(void I.go())
+(pc() && !target(A))
+(pc() && !target(Aspect))
+(execution(void AroundCall.a(int)) && args(n))
+(cflow((execution(void AroundCall.a(int)) && args(n))) && (target(AroundCall) && !initialization(new(..))))
+(call(int foo(int)) && args(x))
+args(y)
+(cflow((call(int foo(int)) && args(x))) && (call(int bar(int)) && args(y)))
+(call(int fact(int)) && args(i))
+f(j)
+(f(i) && cflowbelow(f(j)))
+f(int)
+(cflow(f(j)) && !cflowbelow(f(int)))
+(f(i) && cflowbelow((cflow(f(j)) && !cflowbelow(f(int)))))
+(target(foo) && call(void m()))
+(target(foo) && execution(void n()))
+(this(foo) && execution(void o()))
+(target(foo) && (get(String Foo.idhat) && within(Foo)))
+(execution(*.new(..)) && (target(target) && !within(A)))
+(initialization(new(..)) && !this(A))
+(execution(*.new(..)) && target(target))
+(call(int fact(int)) && args(n))
+factCall(dummy)
+(factCall(firstN) && !cflowbelow(factCall(dummy)))
+(factCall(n) && cflow((factCall(firstN) && !cflowbelow(factCall(dummy)))))
+call(public String toString())
+(target(targ) && (!withincode(void Aspect.aspectMethod(AnotherClass.InnerClass)) && call(public String toString())))
+!within(ThreadTracer)
+(safe() && cflow(call(void Runnable.run())))
+(safe() && cflowbelow(call(void Runnable.run())))
+execution(void Runnable.run())
+(safe() && cflow(execution(void Runnable.run())))
+(safe() && cflowbelow(execution(void Runnable.run())))
+foo(c)
+args(d)
+call(void CFCommand.handleResponse(..))
+(within(CFCommandProcessor) && (target(cmd) && call(void CFCommand.handleResponse(..))))
+response(cmd)
+call(* Inner.*(..))
+!within(TypePat.*)
+(call(* TypePat.*.*(..)) && (within(TypePat) && !within(TypePat.*)))
+(call(* *(..)) && !call(* Tester.*(..)))
+!within(*.InnerA)
+(checkCall() && (within(TypePat.*) && !within(*.InnerA)))
+(checkCall() && target(Map.Entry))
+(within(C) && !set(* *))
+(within(D) && !set(* *))
+(call(new(..)) || call(* *(..)))
+(target(C) && (call(new(..)) || call(* *(..))))
+args(Object, Object)
+args(Object, ..)
+args(.., Object)
+args(Object, Object, ..)
+args(.., Object, Object)
+args(String, String)
+args(String, ..)
+args(.., String)
+args(String, String, ..)
+args(.., String, String)
+args(o1)
+args(o1, o2)
+args(o1, ..)
+args(.., o1)
+args(o1, o2, ..)
+args(.., o1, o2)
+args(s1)
+args(s1, ..)
+args(.., s1)
+args(s1, s2, ..)
+args(.., s1, s2)
+(safe() && o1())
+(safe() && o2())
+(safe() && o1Start())
+(safe() && o1End())
+(safe() && o2Start())
+(safe() && o2End())
+(safe() && s1())
+(safe() && s2())
+(safe() && s1Start())
+(safe() && s1End())
+(safe() && s2Start())
+(safe() && s2End())
+(safe() && bo1(o1))
+(safe() && bo2(o1, o2))
+(safe() && bo1Start(o1))
+(safe() && bo1End(o1))
+(safe() && bo2Start(o1, o2))
+(safe() && bo2End(o1, o2))
+(safe() && bs1(s1))
+(safe() && bs2(s1, s2))
+(safe() && bs1Start(s1))
+(safe() && bs1End(s1))
+(safe() && bs2Start(s1, s2))
+(safe() && bs2End(s1, s2))
+call(Safe+.new(..))
+(call(* *.*(..)) && target(Safe))
+(call(Safe+.new(..)) || (call(* *.*(..)) && target(Safe)))
+(call(* *.*(..)) && target(C))
+(call(C+.new(..)) || (call(* *.*(..)) && target(C)))
+args(Object, Object, Object)
+args(Object, *)
+args(*, Object)
+args(Object, Object, *)
+args(*, Object, Object)
+args(String, String, String)
+args(String, *)
+args(*, String)
+args(String, String, *)
+args(*, String, String)
+args(o1, o2, o3)
+args(o1, *)
+args(*, o1)
+args(o1, o2, *)
+args(*, o1, o2)
+args(s1, s2, s3)
+args(s1, *)
+args(*, s1)
+args(s1, s2, *)
+args(*, s1, s2)
+(safe() && none())
+(safe() && o3())
+(safe() && s3())
+(safe() && bo3(o1, o2, o3))
+(safe() && bs3(s1, s2, s3))
+(withincode(static void main(..)) && handler(*))
+(hd() && args(t))
+(hd() && args(Throwable))
+(hd() && args(Error))
+(hd() && args(Throwable, ..))
+(hd() && args(.., Throwable))
+(hd() && args(Error, ..))
+(hd() && args(.., Error))
+(hd() && args(t, ..))
+(hd() && args(.., t))
+(hd() && args(Throwable, *))
+(hd() && args(*, Throwable))
+(hd() && args(Error, *))
+(hd() && args(*, Error))
+(hd() && args(t, *))
+(hd() && args(*, t))
+call(C C.make())
+(target(o) && get(String s))
+args(v)
+(target(o) && (set(String s) && args(v)))
+(!within(A1+) && (!preinitialization(new(..)) && !initialization(new(..))))
+!within(A2+)
+(within(Target) && (execution(* *(..)) && !within(A2+)))
+get(int C.x)
+set(int C.x)
+(canThrowUnchecked() || set(int C.x))
+execution(public static void Main.main(..))
+targetJoinPoints()
+topOfFlow()
+entryPoint()
+(entryPoint() && !cflowbelow(entryPoint()))
+execution(public void PerCFlowTestHelper.startNewPerCFlow())
+execution(void Main.main(..))
+staticinitialization(Main)
+initialization(Main.new())
+execution(void Main.go(String))
+call(Main.new())
+call(void Main.go(String))
+(call(void app.D.go()) && withincode(void Main.stop()))
+(call(void app.D.go()) && withincode(void Main.go(String)))
+(call(void Main.stop()) && withincode(void Main.go(String)))
+get(String Main.s)
+set(String Main.s)
+get(String Main.staticString)
+set(String Main.staticString)
+(handler(RuntimeException) && within(Main))
+preinitialization(app.C.new())
+(execution(* *(..)) && within(Big))
+call(void Throwable.printStackTrace(..))
+(get(java.io.PrintStream System.out) || call(void Throwable.printStackTrace(..)))
+(within(Joinpoints101) && get(int *))
+target(Pos)
+call(* move(..))
+(call(* getY(..)) || call(* move(..)))
+(call(* getX(..)) || (call(* getY(..)) || call(* move(..))))
+(target(Pos) && (call(* getX(..)) || (call(* getY(..)) || call(* move(..)))))
+target(Driver)
+(target(d) && call(* doit(..)))
+(target(Point) && execution(new(..)))
+(target(Line) && execution(new(..)))
+(target(*) && (target(Circle) && execution(new())))
+(target(Foo) && (call(void m1(String)) && args(x)))
+(target(Foo) && (call(void m2(int)) && args(x)))
+(target(Foo) && (call(void m3(String)) && args(x)))
+(target(Foo) && (call(void m3(int)) && args(x)))
+(target(Obj) && execution(int m()))
+target(C2)
+(target(C1) || target(C2))
+((target(C1) || target(C2)) && call(int m()))
+(target(b) && call(* m(..)))
+(target(f) && call(* foo(..)))
+(target(pClass.Class) && call(* foo(..)))
+(target(s) && call(* getX(..)))
+call(SuperClass+.new(..))
+target(Class)
+args(z)
+(target(c) && (call(* foo(int)) && args(z)))
+(target(Class) && call(void *(..)))
+(target(Class) && (call(void *(int)) && args(x)))
+(target(Class) && (call(public void *(int)) && args(x)))
+initialization(I1.new(..))
+(within(Driver) && execution(static void test(..)))
+(target(Foo) && call(void m(..)))
+call(new(int))
+(initialization(new(..)) && !within(A0_8beta1))
+(within(Foo) && execution(static * Foo.*(..)))
+(within(A) && execution(static * Foo.*(..)))
+(within(A) && execution( !static * Foo.*(..)))
+(within(Foo) && execution( !static * Foo.*(..)))
+call(new(String, ..))
+execution(* m(..))
+(execution(void test()) || execution(* m(..)))
+(within(Driver) && (execution(void test()) || execution(* m(..))))
+call(void setY(int))
+(call(void setX(int)) || call(void setY(int)))
+(target(p) && (args(newvalue) && (call(void setX(int)) || call(void setY(int)))))
+args(str)
+(target(C) && (call(void foo(String)) && args(str)))
+(target(C) && call(int basic()))
+(target(C) && call(int exceptional()))
+(call(new(String)) && args(aspectName))
+(target(*) && call(int *(..)))
+target(*)
+!within(JoinPointFields+)
+(call( !static * *(..)) && (onTypes() && !within(JoinPointFields+)))
+target(test135.pack.PackFoo)
+(target(C0+) && call(void m1(int, double)))
+(target(C0+) && call(* m2(..)))
+(target(C0+) && call(* m3(..)))
+(target(c2) && call(new()))
+(target(Foo) && call(void foo()))
+onFoo()
+(target(c2) && call(int foo()))
+call(String C1.getString())
+!call(void finalize())
+(target(C1) && (call(* *()) && !call(void finalize())))
+call(void OneArgCallsIsOkay.foo(int, int))
+(this(SuperStaticCallJoinPoint) && call(void Sup.m()))
+(execution(* I.*(..)) && within(C))
+(execution(* I.*(..)) && within(I))
+(execution(* I.*(..)) && within(A1))
+(execution(* I.*(..)) && within(A2))
+(execution(* I.*(..)) && this(C))
+(execution(* I.*(..)) && this(I))
+(execution(* I.*(..)) && this(A1))
+(execution(* I.*(..)) && this(A2))
+(execution(void *.*oo(String)) && args(s))
+execution(void *.foo(String))
+execution(void *.goo(String))
+target(SubC)
+call(void SubC.*())
+targets()
+(target(c) && execution(* *(..)))
+execution(void m1())
+call(C.new(..))
+(handler(*) && !within(JoinPoints))
+(target(c) && initialization(new(..)))
+target(SubC2)
+execution(* Main.main(..))
+(call(* *(..)) && !within(X))
+handler(Throwable)
+handlers()
+call(* m1(..))
+m1call()
+call(* m2(..))
+m2call()
+calls()
+(this(*) && call(int *(..)))
+iCut()
+noSuchCut()
+(initialization(TargetClass.new()) && this(c))
+(within(AroundReturnType) && call(Integer AroundReturnType.s()))
+(within(AroundReturnType) && execution(* *(..)))
+(target(t) && call(int m()))
+setFile(f)
+call(void noargs())
+noargs(b)
+execution(void OverloadedPointcuts.foo(int))
+(execution(void OverloadedPointcuts.foo(int)) && args(i))
+call(void main(..))
+call(void *.call(n))
+call(void *.call(..))
+execution(void *(n))
+calls_pc()
+executions_pc()
+execution(void *.m(.., n, ..))
+call(void System.out.println(..))
+(call(void SubC.m(double)) && (target(subc) && args(i)))
+(call(void C.m(int)) && (target(c) && args(i)))
+targets(int, C)
+(target(C) && execution(void a()))
+(target(*) && call(* go(..)))
+(set(int C._int) && args(int))
+crash(_new)
+pc4()
+(i() && (!this(StaticAdviceOnAbstract) && call(new(..))))
+i()
+get(void i)
+(this(MissingReturns) && call(int baz(int)))
+ocut()
+get(int BaseApp.i)
+(call(void C.bad()) && !within(C))
+execution(void Inner.*())
+(this(tc) && execution(void TargetClass.walk()))
+(execution(public void run()) && this(test))
+run(test)
+execution(public void run())
+execution(public void *.run())
+call(public void *.run())
+write()
+get(int i)
+getI()
+set(int i)
+setI()
+staticinitialization(*Test)
+staticInit()
+this(Test)
+args(UnknownType)
+target(UnknownType)
+this(UnknownType)
+execution(Object C.get())
+(call(void B.test()) && withincode(void B.test2()))
+call(Class B.findClass())
+(call(Class B.findClass()) && withincode(B.new()))
+staticinitialization(UnknownType)
+within(GetCauseOnSoftException)
+call(int B.run())
+call(void C.m0())
+call(void C.m1())
+call(void C.m2())
+call(void D0.m0())
+call(void D0.m1())
+call(void D0.m2())
+call(void D1.m0())
+call(void D1.m1())
+call(void D1.m2())
+call(void I.m2())
+execution(void C.m0())
+execution(void C.m1())
+execution(void C.m2())
+execution(void D0.m0())
+execution(void D0.m1())
+execution(void D0.m2())
+execution(void D1.m0())
+execution(void D1.m1())
+execution(void D1.m2())
+execution(void I.m2())
+(target(c) && call(void C.foo()))
+(target(c1) && call(void C1.foo()))
+(target(c2) && call(void C2.foo()))
+(target(c) && call(void foo()))
+(target(c1) && call(void foo()))
+(target(c2) && call(void foo()))
+(target(c) && call(void C.foo*()))
+(target(c1) && call(void C1.foo*()))
+(target(c2) && call(void C2.foo*()))
+(target(c) && call(void foo*()))
+(target(c1) && call(void foo*()))
+(target(c2) && call(void foo*()))
+call(void C0.mC())
+call(void C1a.mI())
+(call(void C1a.mC()) || call(void C1a.mI()))
+call(void C1b.mI())
+(call(void C1b.mC()) || call(void C1b.mI()))
+call(void I0.mI())
+call(void I1a.mI())
+call(void I1b.mI())
+(target(C0) && call(* *(..)))
+(target(C1a) && call(* *(..)))
+(target(C1b) && call(* *(..)))
+(target(I0) && call(* *(..)))
+(target(I1a) && call(* *(..)))
+(target(I1b) && call(* *(..)))
+(target(*) && call(int *()))
+call(int p1.*.*())
+call(int p1..*.*())
+call(void AssertInAdvice.call1())
+call(void AssertInAdvice.call2())
+call(void AssertInAdvice.call3())
+call(void AssertInAdvice.call4())
+call(void AssertInAdvice.call5())
+call(void AssertInAdvice.call6())
+execution(void AssertInAdvice.execution1())
+execution(void AssertInAdvice.execution2())
+execution(void AssertInAdvice.execution3())
+execution(void AssertInAdvice.execution4())
+execution(void AssertInAdvice.execution5())
+execution(void AssertInAdvice.execution6())
+call(static void AssertInAdviceBug.call())
+call(static void call1())
+mustExtend()
+(execution(void Base+.lockResource(..)) && !within(Base))
+(mustExtend() && target(a))
+target(b)
+(cflow((mustExtend() && target(a))) && (execution(void Base.lockResource(..)) && target(b)))
+execution(void MyMain.sayHello(..))
+!get(* x)
+(within(ClassLiteralField) && (get(* *) && !get(* x)))
+!set(* x)
+(within(ClassLiteralField) && (set(* *) && !set(* x)))
+(call(* *(..)) && this(foo))
+(execution(* *(..)) && args(foo))
+((call(* *(..)) && this(foo)) || (execution(* *(..)) && args(foo)))
+(call(* m(..)) && this(foo))
+(call(* n(..)) && args(foo))
+((call(* m(..)) && this(foo)) || (call(* n(..)) && args(foo)))
+(execution(* *(int, int)) && this(foo))
+(execution(* *(int)) && this(foo))
+((execution(* *(int, int)) && this(foo)) || (execution(* *(int)) && this(foo)))
+(get(int a) && this(foo))
+(get(int b) && target(foo))
+((get(int a) && this(foo)) || (get(int b) && target(foo)))
+(set(int a) && args(x))
+(set(int b) && args(x))
+((set(int a) && args(x)) || (set(int b) && args(x)))
+(within(Foo) && this(foo))
+(within(AmbiguousBindings) && args(foo))
+((within(Foo) && this(foo)) || (within(AmbiguousBindings) && args(foo)))
+(call(* m*(..)) && args(foo))
+((call(* m(..)) && this(foo)) || (call(* m*(..)) && args(foo)))
+(execution(* *(int, *)) && args(foo))
+((execution(* *(int, int)) && this(foo)) || (execution(* *(int, *)) && args(foo)))
+(get(int a) && target(foo))
+((get(int a) && this(foo)) || (get(int a) && target(foo)))
+(set(* *) && this(x))
+((set(int a) && args(x)) || (set(* *) && this(x)))
+(within(F*) && args(foo))
+((within(Foo) && this(foo)) || (within(F*) && args(foo)))
+p1(foo)
+p2(foo)
+p3(foo)
+p4(foo)
+p5(z)
+p6(foo)
+q1(foo)
+q2(foo)
+q3(foo)
+q4(x)
+q5(foo)
+(call(* foo(*, *)) && (args(b, a) || args(a, b)))
+call(* PR78021+.commit(..))
+commitOperation()
+main()
+call(* m(..))
+execution(void throwMyExceptionButNotReally())
+call(* foo())
+call(Touple.new(..))
+PC()
+call(* compareTo(..))
+execution(* compareTo(..))
+call(* getCar())
+call(* Super.getCar())
+call(Car getCar())
+call(Car Super.getCar())
+call(Car Sub.getCar())
+call(Car+ Sub.getCar())
+call(FastCar getCar())
+call(FastCar Sub.getCar())
+call(FastCar Super.getCar())
+call(Car+ getCar())
+call(* whoAreYou())
+call(* A.whoAreYou())
+call(A whoAreYou())
+call(A B.whoAreYou())
+call(A+ B.whoAreYou())
+call(B A.whoAreYou())
+call(B whoAreYou())
+call(B B.whoAreYou())
+call(@(SimpleAnnotation) * *(..))
+(execution(* *.*(..)) && @annotation(SimpleAnnotation))
+(execution(* doSomething(..)) && @within(MyAnnotation))
+(execution(* doSomething(..)) && @within(MyInheritableAnnotation))
+(call(* doSomething(..)) && @withincode(MyClassRetentionAnnotation))
+(execution(* foo()) && within((@(MyAnnotation) *)))
+(execution(* foo()) && !within((@(MyAnnotation) *)))
+call(* org.xyz.*.*(int, String...))
+execution(* org.xyz.*.*(Integer...))
+initialization(org.xyz.*.new((Foo... || Goo...)))
+execution(* *.*(String...))
+execution(* *.*(String))
+(call(* foo(int, String...)) && args(i, ss))
+call(* *(Integer))
+execution(* *(Integer))
+initialization(new(Integer))
+(withincode(* *(Integer)) && call(* *(..)))
+call(* *(Integer...))
+call(* *(int, Integer...))
+execution(* *(.., *...))
+(execution(* *(..)) && @annotation(a))
+execution(* doSomething())
+call(* doSomething())
+(doSomethingExecution() && @this(MyAnnotation))
+(doSomethingExecution() && @this(MyInheritableAnnotation))
+(doSomethingCall() && @target(MyAnnotation))
+(doSomethingCall() && @target(MyInheritableAnnotation))
+execution(* main(String))
+@this(MyAnnotation)
+@target(MyAnnotation)
+execution(* myMethod(..))
+(myMethod() && @args(ANY, ANY, ANY, ANY, ANY))
+@args(MyAnnotation)
+(execution(new(..)) && this(o))
+execution(* sayhi(..))
+execution(* runA(..))
+execution(* runB(..))
+within(U)
+(within(SimpleAutoboxing) && (call(* met*(..)) && args(i)))
+(within(AutoboxingI) && (call(* met*(..)) && args(i)))
+(within(AutoboxingC) && (call(* met*(..)) && args(i)))
+(within(AutoboxingD) && (call(* met*(..)) && args(i)))
+(within(AutoboxingF) && (call(* met*(..)) && args(i)))
+(within(AutoboxingS) && (call(* met*(..)) && args(i)))
+(within(AutoboxingJ) && (call(* met*(..)) && args(i)))
+(within(AutoboxingZ) && (call(* met*(..)) && args(i)))
+(within(AutoboxingB) && (call(* met*(..)) && args(i)))
+call(* ret*(..))
+(call(* *(..)) && @target(MyAnnotation))
+set(@(FieldAnnotation) * *)
+execution(@(MethodAnnotation) * *(..))
+execution(@(ConstructorAnnotation) new(..))
+staticinitialization((@(TypeAnnotation) *))
+observedEvent(subject)
+execution(* AnInterface.*(..))
+anInterfaceOperation()
+execution(@(Immutable) * *(..))
+execution(!@(Persistent) * *(..))
+staticinitialization((@(Immutable) *))
+staticinitialization((!@(Immutable) *))
+staticinitialization(((@(Immutable) org.xyz.*) || (@(Immutable) org.abc.*)))
+staticinitialization(((@(Immutable) Foo+) || Goo))
+staticinitialization((@((Immutable || NonPersistent)) org.xyz..*))
+staticinitialization((@(Immutable) @(NonPersistent) org.xyz..*))
+staticinitialization((@((@(Inherited) *)) org.xyz..*))
+set(@(SensitiveData) * *)
+set(@(SensitiveData) List org.xyz..*.*)
+set((@(SensitiveData) *) org.xyz..*.*)
+set(@(Foo) (@(Goo) *) (@(Hoo) *).*)
+execution(@(Oneway) * *(..))
+execution(@(Transaction) * (@(Persisted) org.xyz..*).*(..))
+execution(* *.*((@(Immutable) *), ..))
+within((@(Secure) *))
+staticinitialization((@(Persisted) *))
+call(@(Oneway) * *(..))
+execution(public (@(Immutable) *) org.xyz..*.*(..))
+set(@(Cachable) * *)
+handler((!@(Catastrophic) *))
+(@this(Foo) && execution(* A+.*(..)))
+txRequiredMethod(Tx)
+@args(ANY, ANY, untrustedDataSource)
+untrustedData(source)
+execution(* callA(..))
+(@within(Foo) && execution(* *(..)))
+@withincode(c)
+insideCriticalMethod(c)
+insideCriticalMethod(Critical)
+@within(Goo)
+@within(goo)
+@withincode(Goo)
+@withincode(goo)
+@annotation(Goo)
+@annotation(goo)
+call(@(SomeAnnotation) * C1.aMethod())
+call(* C1.aMethod())
+annotatedMethodCall()
+c1MethodCall()
+(withincode(@(PerformanceCritical) * *(..)) && call(@(ExpensiveOperation) * *(..)))
+(call(* org.xyz.model.*.*(..)) && !@within(Trusted))
+execution(* foo())
+staticinitialization((@(BusinessDomain) *))
+execution(@(Secured) * *(..))
+set(@(Persisted) * *)
+initialization(@(Secured) *.new(..))
+execution(@(SomeAnnotation) * *(..))
+execution(@(SomeAnnotation) new(..))
+set(@(SomeAnnotation) * *)
+staticinitialization((@(SomeAnnotation) *))
+(execution(public ITDMe.new(String)) && @annotation(sa))
+(execution(private ITDMe.new(int)) && @annotation(sa))
+(execution(public void ITDMe.bar(int)) && @annotation(sa))
+(set(public Double ITDMe.d) && @annotation(sa))
+(set(private Float ITDMe.f) && @annotation(sa))
+(staticinitialization((@(SomeAnnotation) *)) && @annotation(sa))
+(execution(public ITDMe2.new(String)) && @annotation(sa))
+(execution(private ITDMe2.new(int)) && @annotation(sa))
+(execution(public void ITDMe2.bar(int)) && @annotation(sa))
+(set(public Double ITDMe2.d) && @annotation(sa))
+(set(private Float ITDMe2.f) && @annotation(sa))
+@annotation(c)
+p(c)
+@target(c)
+(@target(c) && @target(m))
+(set(public String test.MyClass._myField) && @target(ma))
+@this(c)
+(@this(c) && @this(m))
+(@this(cThis) && @target(cTarg))
+@args(c1, c2, c3)
+@args(c)
+@args(Colored)
+@args(c1, f, c2)
+execution(* m1())
+execution(* m2())
+execution(* m3())
+@within(c)
+(@withincode(c) && call(* println(..)))
+(call(* *(..)) && @annotation(Color))
+(execution(* *(..)) && @annotation(Color))
+(call(* *(..)) && @annotation(c))
+(execution(* *(..)) && @annotation(c))
+(execution(@(Color) * A+.*(..)) && this(a))
+(call(* m*(..)) && @annotation(c))
+(execution(* m*(..)) && @annotation(c))
+(execution(* *(..)) && @annotation(f))
+(set(* *) && @annotation(f))
+(execution(new(..)) && @annotation(f))
+(call(* *(..)) && @annotation(f))
+(set(* *) && @annotation(d))
+(call(* Test3.*(..)) && @args(ann))
+cflow(execution(* *(..)))
+a()
+(call(* println(..)) && @this(MyAnnotation))
+(execution(* *(..)) && @this(Colored))
+(execution(* *(..)) && @this(ComplexAnnotation))
+(execution(* *(..)) && @this(Color))
+(execution(* *(..)) && @this(Fruit))
+(execution(* *(..)) && this(Marker))
+(execution(* *(..)) && @this(ColorT))
+(execution(* *(..)) && @this(ColorM))
+(execution(* *(..)) && @this(ColorC))
+(execution(* *(..)) && @this(ColorA))
+(execution(* *(..)) && @this(ColorF))
+(execution(* *(..)) && @this(ColorP))
+(execution(* *(..)) && @this(ColorL))
+(execution(* *(..)) && @this(ColorPkg))
+(execution(* *(..)) && @this(Chocolate))
+(execution(* *(..)) && target(M1))
+(execution(* *(..)) && target(M2))
+(execution(* *(..)) && target(M3))
+(call(* *(..)) && @target(aee))
+(call(* *(..)) && @target(ace))
+set(@(Colored) * *)
+set(@(Fruit) * *)
+set(@(MethodColoring) * *)
+set(@(TypeColoring) * *)
+set(@(FieldColoring) * *)
+(call(new(..)) && @annotation(Colored))
+(call(* *(..)) && @annotation(MethodColoring))
+(call(new(..)) && @annotation(CtorColoring))
+(call(* *(..)) && @annotation(Colored))
+(call(* *(..)) && @annotation(Fruit))
+(call(new(..)) && @annotation(Fruit))
+execution(* ataspectj.SingletonAspectBindingsTest.hello())
+(execution(* ataspectj.SingletonAspectBindingsTest.hello()) && this(t))
+(execution(* ataspectj.SingletonAspectBindingsTest.hello(String)) && args(s))
+execution(* SimpleBefore.m())
+execution(* SimpleAfter.m())
+execution(* ataspectj.CflowTest.startCflow(..))
+cflow(execution(* ataspectj.CflowTest.startCflow(..)))
+(execution(* ataspectj.CflowTest.hello(..)) && (this(t) && cflow(execution(* ataspectj.CflowTest.startCflow(..)))))
+execution(* ataspectj.PointcutReferenceTest.hello(..))
+pcRef()
+pcRef2()
+(execution(* ataspectj.PointcutReferenceTest.helloWithRef(..)) && pcRefObjectBinding(t))
+pcRefBinding(ttt)
+this(obj)
+(call(* ataspectj.XXJoinPointTest.hello()) && within(ataspectj.XXJoinPointTest))
+execution(* ataspectj.PrecedenceTest.hello())
+(execution(int ataspectj.AfterXTest.dupPos(..)) && args(arg))
+execution(int ataspectj.AfterXTest.dupPos(..))
+(call(int substract(int, int)) && (within(ataspectj.BindingTest) && args(arg1, arg2)))
+(pc(argAdvice2, argAdvice1) && target(t))
+args(arg1)
+(call(int dup(int)) && (within(ataspectj.BindingTest) && args(arg1)))
+pc2(argAdvice1)
+(call(int echo(int)) && (withincode(void ataspectj.BindingTest.testProceedInInner()) && args(i)))
+(call(int echo(int)) && (withincode(void ataspectj.BindingTest.testNoProceed()) && args(i)))
+(call(int echo(int)) && (withincode(void ataspectj.BindingTest.testDoubleProceed()) && args(i)))
+(call(int echo(int)) && (withincode(void ataspectj.BindingTest.testDoubleProceedOneInner()) && args(i)))
+(call(int echo(int)) && (withincode(void ataspectj.BindingTest.testAccessAspectState()) && args(i)))
+(call(int echo(int)) && (withincode(void ataspectj.BindingTest.testTryCatch()) && args(i)))
+execution(* ataspectj.PerClauseTest.perTarget())
+execution(* ataspectj.PerClauseTest.perCflowEntry())
+(execution(* ataspectj.PerClauseTest.perTarget()) && target(t))
+execution(* ataspectj.PerClauseTest.PTW*.foo())
+execution(* ataspectj.PerClauseTest.perCflow())
+(execution(* ataspectj.PerClauseTest.perSingleton()) && target(t))
+execution(* ataspectj.AroundInlineMungerTest.target())
+set(int ataspectj.AroundInlineMungerTestAspects.Open.I)
+(get(int ataspectj.AroundInlineMungerTestAspects.Open.I) || set(int ataspectj.AroundInlineMungerTestAspects.Open.I))
+(set(int ataspectj.AroundInlineMungerTestAspects.Open.i) || (get(int ataspectj.AroundInlineMungerTestAspects.Open.I) || set(int ataspectj.AroundInlineMungerTestAspects.Open.I)))
+(get(int ataspectj.AroundInlineMungerTestAspects.Open.i) || (set(int ataspectj.AroundInlineMungerTestAspects.Open.i) || (get(int ataspectj.AroundInlineMungerTestAspects.Open.I) || set(int ataspectj.AroundInlineMungerTestAspects.Open.I))))
+(call(* ataspectj.AroundInlineMungerTestAspects.Open.priv(..)) || (get(int ataspectj.AroundInlineMungerTestAspects.Open.i) || (set(int ataspectj.AroundInlineMungerTestAspects.Open.i) || (get(int ataspectj.AroundInlineMungerTestAspects.Open.I) || set(int ataspectj.AroundInlineMungerTestAspects.Open.I)))))
+((call(* ataspectj.AroundInlineMungerTestAspects.Open.priv(..)) || (get(int ataspectj.AroundInlineMungerTestAspects.Open.i) || (set(int ataspectj.AroundInlineMungerTestAspects.Open.i) || (get(int ataspectj.AroundInlineMungerTestAspects.Open.I) || set(int ataspectj.AroundInlineMungerTestAspects.Open.I))))) && this(ataspectj.AroundInlineMungerTestAspects.Open))
+execution(* ataspectj.AroundInlineMungerTest2.target())
+set(int ataspectj.AroundInlineMungerTestAspects2.Open.I)
+(get(int ataspectj.AroundInlineMungerTestAspects2.Open.I) || set(int ataspectj.AroundInlineMungerTestAspects2.Open.I))
+(set(int ataspectj.AroundInlineMungerTestAspects2.Open.i) || (get(int ataspectj.AroundInlineMungerTestAspects2.Open.I) || set(int ataspectj.AroundInlineMungerTestAspects2.Open.I)))
+(get(int ataspectj.AroundInlineMungerTestAspects2.Open.i) || (set(int ataspectj.AroundInlineMungerTestAspects2.Open.i) || (get(int ataspectj.AroundInlineMungerTestAspects2.Open.I) || set(int ataspectj.AroundInlineMungerTestAspects2.Open.I))))
+(call(* ataspectj.AroundInlineMungerTestAspects2.Open.priv(..)) || (get(int ataspectj.AroundInlineMungerTestAspects2.Open.i) || (set(int ataspectj.AroundInlineMungerTestAspects2.Open.i) || (get(int ataspectj.AroundInlineMungerTestAspects2.Open.I) || set(int ataspectj.AroundInlineMungerTestAspects2.Open.I)))))
+((call(* ataspectj.AroundInlineMungerTestAspects2.Open.priv(..)) || (get(int ataspectj.AroundInlineMungerTestAspects2.Open.i) || (set(int ataspectj.AroundInlineMungerTestAspects2.Open.i) || (get(int ataspectj.AroundInlineMungerTestAspects2.Open.I) || set(int ataspectj.AroundInlineMungerTestAspects2.Open.I))))) && this(ataspectj.AroundInlineMungerTestAspects2.Open))
+(call(* hello()) && within(ataspectj.DeowTest))
+(call(* hi()) && within(ataspectj.DeowTest))
+execution(* ataspectj.SingletonInheritanceTest.hello2())
+execution(* ataspectj.SingletonInheritanceTest.hello())
+execution(* ataspectj.PerClauseInheritanceTest.hello())
+fhfh()
+call(* *..*(..))
+call(* org..*(..))
+execution(* ataspectj.misuse.Test100.target())
+(execution(* ataspectj.SingletonAspectBindingsTest.hello(String)) && args(s))
+execution(* ataspectj.SingletonAspectBindingsTest.hello())
+(execution(* ataspectj.SingletonAspectBindingsTest.hello()) && this(t))
+execution(* ataspectj.CflowTest.startCflow(..))
+cflow(execution(* ataspectj.CflowTest.startCflow(..)))
+(execution(* ataspectj.CflowTest.hello(..)) && (this(t) && cflow(execution(* ataspectj.CflowTest.startCflow(..)))))
+execution(* ataspectj.PointcutReferenceTest.hello(..))
+pcRef()
+(execution(* ataspectj.PointcutReferenceTest.helloWithRef(..)) && pcRefObjectBinding(t))
+pcRefBinding(ttt)
+pcRef2()
+this(obj)
+execution(int ataspectj.AfterXTest.dupPos(..))
+(execution(int ataspectj.AfterXTest.dupPos(..)) && args(arg))
+(call(* ataspectj.XXJoinPointTest.hello()) && within(ataspectj.XXJoinPointTest))
+pc()
+execution(* ataspectj.PrecedenceTest.hello())
+args(arg1, arg2)
+(call(int substract(int, int)) && (within(ataspectj.BindingTest) && args(arg1, arg2)))
+args(arg1)
+(call(int dup(int)) && (within(ataspectj.BindingTest) && args(arg1)))
+args(i)
+(call(int echo(int)) && (withincode(void ataspectj.BindingTest.testTryCatch()) && args(i)))
+(call(int echo(int)) && (withincode(void ataspectj.BindingTest.testAccessAspectState()) && args(i)))
+(call(int echo(int)) && (withincode(void ataspectj.BindingTest.testDoubleProceedOneInner()) && args(i)))
+(call(int echo(int)) && (withincode(void ataspectj.BindingTest.testDoubleProceed()) && args(i)))
+(call(int echo(int)) && (withincode(void ataspectj.BindingTest.testNoProceed()) && args(i)))
+(call(int echo(int)) && (withincode(void ataspectj.BindingTest.testProceedInInner()) && args(i)))
+pc2(argAdvice1)
+(pc(argAdvice2, argAdvice1) && target(t))
+(execution(* ataspectj.PerClauseTest.perSingleton()) && target(t))
+execution(* ataspectj.PerClauseTest.perTarget())
+(execution(* ataspectj.PerClauseTest.perTarget()) && target(t))
+execution(* ataspectj.PerClauseTest.perCflowEntry())
+execution(* ataspectj.PerClauseTest.perCflow())
+execution(* ataspectj.PerClauseTest.PTW*.foo())
+execution(* ataspectj.AroundInlineMungerTest.target())
+set(int ataspectj.AroundInlineMungerTestAspects.Open.I)
+(get(int ataspectj.AroundInlineMungerTestAspects.Open.I) || set(int ataspectj.AroundInlineMungerTestAspects.Open.I))
+(set(int ataspectj.AroundInlineMungerTestAspects.Open.i) || (get(int ataspectj.AroundInlineMungerTestAspects.Open.I) || set(int ataspectj.AroundInlineMungerTestAspects.Open.I)))
+(get(int ataspectj.AroundInlineMungerTestAspects.Open.i) || (set(int ataspectj.AroundInlineMungerTestAspects.Open.i) || (get(int ataspectj.AroundInlineMungerTestAspects.Open.I) || set(int ataspectj.AroundInlineMungerTestAspects.Open.I))))
+(call(* ataspectj.AroundInlineMungerTestAspects.Open.priv(..)) || (get(int ataspectj.AroundInlineMungerTestAspects.Open.i) || (set(int ataspectj.AroundInlineMungerTestAspects.Open.i) || (get(int ataspectj.AroundInlineMungerTestAspects.Open.I) || set(int ataspectj.AroundInlineMungerTestAspects.Open.I)))))
+((call(* ataspectj.AroundInlineMungerTestAspects.Open.priv(..)) || (get(int ataspectj.AroundInlineMungerTestAspects.Open.i) || (set(int ataspectj.AroundInlineMungerTestAspects.Open.i) || (get(int ataspectj.AroundInlineMungerTestAspects.Open.I) || set(int ataspectj.AroundInlineMungerTestAspects.Open.I))))) && this(ataspectj.AroundInlineMungerTestAspects.Open))
+execution(* ataspectj.SingletonInheritanceTest.hello())
+pc2()
+execution(* ataspectj.SingletonInheritanceTest.hello2())
+execution(* ataspectj.PerClauseInheritanceTest.hello())
+execution(* ataspectj.PerClauseTest.perTarget())
+execution(* ataspectj.PerClauseTest.perCflowEntry())
+get(String *)
+set(* foo)
+execution(* Foo.foo(..))
+fooCall()
+call(* Foo.foo(..))
+call(* String.*(..))
+get(String s)
+set(String s)
+args(i, d, s)
+(pc1() || execution(* *.*(..)))
+(execution(* *(..)) && this(bpb))
+call(* TheUnknownType.*(..))
+execution(* PointcutAssortment.*(..))
+call(* PointcutAssortment.*(..))
+(pc1() || pc2())
+this(Integer)
+this(i)
+(intSet() && pc6(myInt))
+target(foo)
+set(Integer *)
+call(* System.*(..))
diff --git a/weaver/testdata/visitor.typepatterns.txt b/weaver/testdata/visitor.typepatterns.txt
new file mode 100644
index 000000000..7ead98b22
--- /dev/null
+++ b/weaver/testdata/visitor.typepatterns.txt
@@ -0,0 +1,31 @@
+(PerObject+ && *)
+LTWHelloWorld+
+*
+D
+ContainerLoader+
+C+
+TheObject+
+Caller+
+p.EachObjectTarget+
+Product1+
+MemberInitSet+
+test.Test+
+(C+ && *)
+AspectOf
+Interface+
+(java.lang.Object+ && !A+)
+Pos+
+Driver+
+Foo+
+Class+
+SubC+
+SubC
+SubC2+
+Test+
+(Base+ && *)
+ataspectj.PerClauseTest
+ataspectj.PerClauseInheritanceTest
+ataspectj.PerClauseInheritanceTest
+ataspectj.PerClauseTest
+ataspectj.PerClauseTest
+Foo
diff --git a/weaver/testsrc/org/aspectj/weaver/patterns/PatternsTests.java b/weaver/testsrc/org/aspectj/weaver/patterns/PatternsTests.java
index f093740d9..db80087ef 100644
--- a/weaver/testsrc/org/aspectj/weaver/patterns/PatternsTests.java
+++ b/weaver/testsrc/org/aspectj/weaver/patterns/PatternsTests.java
@@ -40,6 +40,8 @@ public class PatternsTests extends TestCase {
         suite.addTestSuite(AnnotationPatternTestCase.class);
         suite.addTestSuite(AnnotationPatternMatchingTestCase.class);
         suite.addTestSuite(PointcutRewriterTest.class);
+
+        suite.addTestSuite(VisitorTestCase.class);
         //$JUnit-END$
         return suite;
     }
diff --git a/weaver/testsrc/org/aspectj/weaver/patterns/VisitorTestCase.java b/weaver/testsrc/org/aspectj/weaver/patterns/VisitorTestCase.java
new file mode 100644
index 000000000..8206635f6
--- /dev/null
+++ b/weaver/testsrc/org/aspectj/weaver/patterns/VisitorTestCase.java
@@ -0,0 +1,79 @@
+/*******************************************************************************
+ * Copyright (c) 2005 Contributors.
+ * All rights reserved. 
+ * This program and the accompanying materials are made available 
+ * under the terms of the Eclipse Public License v1.0 
+ * which accompanies this distribution and is available at 
+ * http://eclipse.org/legal/epl-v10.html 
+ * 
+ * Contributors:
+ *   Alexandre Vasseur         initial implementation
+ *******************************************************************************/
+package org.aspectj.weaver.patterns;
+
+import junit.framework.TestCase;
+
+import java.util.HashSet;
+import java.util.Set;
+import java.util.Iterator;
+import java.io.LineNumberReader;
+import java.io.FileReader;
+
+/**
+ * @author <a href="mailto:alex AT gnilux DOT com">Alexandre Vasseur</a>
+ */
+public class VisitorTestCase extends TestCase {
+
+    private Set pointcuts = new HashSet();
+    private Set typePatterns = new HashSet();
+
+    protected void setUp() throws Exception {
+        super.setUp();
+        LineNumberReader rp = new LineNumberReader(new FileReader("../weaver/testdata/visitor.pointcuts.txt"));
+        feed(rp, pointcuts);
+        rp.close();
+        LineNumberReader rt = new LineNumberReader(new FileReader("../weaver/testdata/visitor.typepatterns.txt"));
+        feed(rt, typePatterns);
+        rt.close();
+    }
+
+    private void feed(LineNumberReader r, Set set) throws Exception {
+        for (String line = r.readLine(); line != null; line = r.readLine()) {
+            set.add(line);
+        }
+    }
+
+//    public void testTemp() {
+//        Pointcut.fromString("call(* *(int, Integer...))");
+//    }
+
+//    public void testPointcuts() {
+//        if (pointcuts.isEmpty()) {
+//            fail("Empty pointcuts file!");
+//        }
+//        for (Iterator iterator = pointcuts.iterator(); iterator.hasNext();) {
+//            String pointcut = (String) iterator.next();
+//            try  {
+//                PointcutVisitor.DumpPointcutVisitor.check(pointcut);
+//            } catch (Throwable t) {
+//                t.printStackTrace();
+//                fail("Failed on '"+pointcut+"': " +t.toString());
+//            }
+//        }
+//    }
+//
+//    public void testTypePatterns() {
+//        if (typePatterns.isEmpty()) {
+//            fail("Empty typePatterns file!");
+//        }
+//        for (Iterator iterator = typePatterns.iterator(); iterator.hasNext();) {
+//            String tp = (String) iterator.next();
+//            try  {
+//                TypePattern p = new PatternParser(tp).parseTypePattern();
+//                PointcutVisitor.DumpPointcutVisitor.check(p, true);
+//            } catch (Throwable t) {
+//                fail("Failed on '"+tp+"': " +t.toString());
+//            }
+//        }
+//    }
+}
-- 
2.39.5