diff options
Diffstat (limited to 'org.aspectj.lib/src')
3 files changed, 392 insertions, 0 deletions
diff --git a/org.aspectj.lib/src/org/aspectj/lib/pointcuts/Pointcuts.java b/org.aspectj.lib/src/org/aspectj/lib/pointcuts/Pointcuts.java new file mode 100644 index 000000000..e37c6663b --- /dev/null +++ b/org.aspectj.lib/src/org/aspectj/lib/pointcuts/Pointcuts.java @@ -0,0 +1,180 @@ +/* ******************************************************************* + * Copyright (c) 2003-2005 Contributors. + * All rights reserved. + * This program and the accompanying materials are made available + * under the terms of the Common Public License v1.0 + * which accompanies this distribution and is available at + * http://www.eclipse.org/legal/cpl-v10.html + * + * Contributors: + * Wes Isberg initial implementation + * ******************************************************************/ + +// START-SAMPLE library-pointcutIdioms Standard pointcut idioms +package org.aspectj.lib.pointcuts; + +import java.util.Collection; +import java.io.PrintStream; + +/** + * Library of pointcut idioms to use in combination with + * other pointcuts. + * + * @author Wes Isberg + */ +public final class Pointcuts { + + // ------- not staticly-determinable + public pointcut adviceCflow() : cflow(adviceexecution()); + + public pointcut notInAdviceCflow() : !adviceCflow(); + + public pointcut cflowMainExecution() : + cflow(mainExecution()); + + // ------- staticly-determinable + + public pointcut mainExecution() : + execution(public static void main(String[])); + + /** staticly-determinable to never match any join point */ + public pointcut never(); + + public pointcut afterAdviceSupported() : !handler(*); + + public pointcut aroundAdviceSupported() : !handler(*) + && !initialization(new(..)) && !preinitialization(new(..)); + + public pointcut anyMethodExecution() : + execution(* *(..)); + + public pointcut anyPublicMethodExecution() : + execution(public * *(..)); + + public pointcut anyNonPrivateMethodExecution() : + execution(!private * *(..)); + + public pointcut anyConstructorExecution() : + execution(new(..)); + + public pointcut anyPublicConstructorExecution() : + execution(public new(..)); + + public pointcut anyNonPrivateConstructorExecution() : + execution(!private new(..)); + + public pointcut anyPublicFieldGet() : + get(public * *); + + public pointcut anyNonPrivateFieldGet() : + get(!private * *); + + public pointcut anyPublicFieldSet() : + set(public * *); + + public pointcut anyNonPrivateFieldSet() : + set(!private * *); // also !transient? + + public pointcut withinSetter() : // require !static? + withincode(void set*(*)); // use any return type? multiple parms? + + public pointcut withinGetter() : + withincode(!void get*()); // permit parms? require !static? + + public pointcut anyNonPublicFieldSetOutsideConstructorOrSetter() : + set(!public * *) && !withincode(new(..)) + && !withinSetter(); + + public pointcut anyRunnableImplementation() : + staticinitialization(Runnable+); + + public pointcut anyGetSystemErrOut() : + get(PrintStream System.err) || get(PrintStream System.out); + + public pointcut anySetSystemErrOut() : + call(void System.setOut(..)) || call(void System.setErr(..)); + + public pointcut withinAnyJavaCode() : + within(java..*) || within(javax..*); + + public pointcut notWithinJavaCode() : + !withinAnyJavaCode(); + + public pointcut toStringExecution() : + execution(String toString()) && !within(String); + + /** call or execution of any Thread constructor, including subclasses */ + public pointcut anyThreadConstruction() : + call(Thread+.new(..)) || execution(Thread+.new(..)); + + /** + * Any calls to java.io classes + * (but not methods declared only on their subclasses). + */ + public pointcut anyJavaIOCalls() : + call(* java.io..*.*(..)) || call(java.io..*.new(..)); + + /** + * Any calls to java.awt or javax.swing methods or constructors + * (but not methods declared only on their subclasses). + */ + public pointcut anyJavaAWTOrSwingCalls() : + call(* java.awt..*.*(..)) || call(java.awt..*.new(..)) + || call(* javax.swing..*.*(..)) || call(javax.swing..*.new(..)); + + public pointcut cloneImplementationsInNonCloneable() : + execution(Object !Cloneable+.clone()); + + public pointcut runImplementationsInNonRunnable() : + execution(void !Runnable+.run()); + + /** any calls to java.lang.reflect or Class.get* (except getName()) */ + public pointcut anySystemReflectiveCalls() : + call(* java.lang.reflect..*.*(..)) + || (!call(* Class.getName()) + && call(* Class.get*(..))); + + /** standard class-loading calls by Class and ClassLoader + * Note that `Foo.class` in bytecode is `Class.forName("Foo")`, + * so 'Foo.class' will also be picked out by this pointcut. + */ + public pointcut anySystemClassLoadingCalls() : + call(Class Class.forName(..)) + || call(Class ClassLoader.loadClass(..)); + + public pointcut anySystemProcessSpawningCalls() : + call(Process Runtime.exec(..)) + || call(Class ClassLoader.loadClass(..)); + + /** Write methods on Collection + * Warning: Does not pick out <code>iterator()</code>, even though + * an Iterator can remove elements. + */ + public pointcut anyCollectionWriteCalls() : + call(boolean Collection+.add(Object)) + || call(boolean Collection+.addAll(Collection)) + || call(void Collection+.clear()) + || call(boolean Collection+.remove(Object)) + || call(boolean Collection+.removeAll(Collection)) + || call(boolean Collection+.retainAll(Collection)); + + public pointcut mostThrowableReadCalls() : + call(* Throwable+.get*(..)) + || call(* Throwable+.print*(..)) + || call(String Throwable+.toString(..)); + + public pointcut exceptionWrappingCalls() : + (args(Throwable+,..) || args(.., Throwable+)) + && (set(Throwable+ Throwable+.*) + || (call(* Throwable+.*(..)) + || call(Throwable+.new(..)))); + + public pointcut anyCodeThrowingException() : + execution(* *(..) throws Exception+) + || execution(new(..) throws Exception+); + + private Pointcuts() {} +} +//END-SAMPLE library-pointcutIdioms + + diff --git a/org.aspectj.lib/src/org/aspectj/lib/tracing/TraceJoinPoints.java b/org.aspectj.lib/src/org/aspectj/lib/tracing/TraceJoinPoints.java new file mode 100644 index 000000000..6d6f592df --- /dev/null +++ b/org.aspectj.lib/src/org/aspectj/lib/tracing/TraceJoinPoints.java @@ -0,0 +1,142 @@ +/* ******************************************************************* + * 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: + * Wes Isberg initial implementation + * ******************************************************************/ + +// START-SAMPLE tracing-traceJoinPoints Trace join points executed to log + +package org.aspectj.lib.tracing; + +import org.aspectj.lang.*; +import org.aspectj.lang.reflect.*; +import java.io.*; + +/** + * Print join points being executed in context to a log.xml file. + * To use this, define the abstract pointcuts in a subaspect. + * @author Jim Hugunin, Wes Isberg + */ +public abstract aspect TraceJoinPoints + extends TraceJoinPointsBase { + + // abstract protected pointcut entry(); + + PrintStream out; + int logs = 0; + int depth = 0; + boolean terminal = false; + + /** + * Emit a message in the log, e.g., + * <pre>TraceJoinPoints tjp = TraceJoinPoints.aspectOf(); + * if (null != tjp) tjp.message("Hello, World!");</pre> + */ + public void message(String s) { + out.println("<message>" + prepareMessage(s) + "</message>"); + } + + protected void startLog() { + makeLogStream(); + } + + protected void completeLog() { + closeLogStream(); + } + + protected void logEnter(JoinPoint.StaticPart jp) { + if (terminal) out.println(">"); + indent(depth); + out.print("<" + jp.getKind()); + writeSig(jp); + writePos(jp); + + depth += 1; + terminal = true; + } + + protected void logExit(JoinPoint.StaticPart jp) { + depth -= 1; + if (terminal) { + getOut().println("/>"); + } else { + indent(depth); + getOut().println("</" + jp.getKind() + ">"); + } + terminal = false; + } + + protected PrintStream getOut() { + if (null == out) { + String m = "not in the control flow of entry()"; + throw new IllegalStateException(m); + } + return out; + } + + protected void makeLogStream() { + try { + String name = "log" + logs++ + ".xml"; + out = new PrintStream(new FileOutputStream(name)); + } catch (IOException ioe) { + out = System.err; + } + } + + protected void closeLogStream() { + PrintStream out = this.out; + if (null != out) { + out.close(); + // this.out = null; + } + } + + /** @return input String formatted for XML */ + protected String prepareMessage(String s) { // XXX unimplemented + return s; + } + + void message(String sink, String s) { + if (null == sink) { + message(s); + } else { + getOut().println("<message sink=" + quoteXml(sink) + + " >" + prepareMessage(s) + "</message>"); + } + } + + void writeSig(JoinPoint.StaticPart jp) { + PrintStream out = getOut(); + out.print(" sig="); + out.print(quoteXml(jp.getSignature().toShortString())); + } + + void writePos(JoinPoint.StaticPart jp) { + SourceLocation loc = jp.getSourceLocation(); + if (loc == null) return; + PrintStream out = getOut(); + + out.print(" pos="); + out.print(quoteXml(loc.getFileName() + + ":" + loc.getLine() + + ":" + loc.getColumn())); + } + + protected String quoteXml(String s) { // XXX weak + return "\"" + s.replace('<', '_').replace('>', '_') + "\""; + } + + protected void indent(int i) { + PrintStream out = getOut(); + while (i-- > 0) out.print(" "); + } +} +// END-SAMPLE tracing-traceJoinPoints + +
\ No newline at end of file diff --git a/org.aspectj.lib/src/org/aspectj/lib/tracing/TraceJoinPointsBase.java b/org.aspectj.lib/src/org/aspectj/lib/tracing/TraceJoinPointsBase.java new file mode 100644 index 000000000..989c298e7 --- /dev/null +++ b/org.aspectj.lib/src/org/aspectj/lib/tracing/TraceJoinPointsBase.java @@ -0,0 +1,70 @@ +/* ******************************************************************* + * 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: + * Wes Isberg initial implementation + * ******************************************************************/ + +// START-SAMPLE tracing-traceJoinPoints Trace join points executed + +package org.aspectj.lib.tracing; + +import org.aspectj.lang.JoinPoint; + +/** + * Trace join points being executed in context. + * To use this, define the abstract members in a subaspect. + * <b>Warning</b>: this does not trace join points that do not + * support after advice. + * @author Jim Hugunin, Wes Isberg + */ +abstract aspect TraceJoinPointsBase { + + declare precedence : TraceJoinPointsBase, *; + + abstract protected pointcut entry(); + + /** ignore join points outside this scope - use within(..) */ + abstract protected pointcut withinScope(); + + protected pointcut exit(): withinScope() && call(* java..*.*(..)); + + final pointcut start(): withinScope() && entry() && !cflowbelow(entry()); + + final pointcut trace(): withinScope() && cflow(entry()) + && !cflowbelow(exit()) && !within(TraceJoinPointsBase+); + + private pointcut supportsAfterAdvice() : !handler(*) + && !preinitialization(new(..)); + + before(): start() { startLog(); } + + before(): trace() && supportsAfterAdvice(){ + logEnter(thisJoinPointStaticPart); + } + + after(): trace() && supportsAfterAdvice() { + logExit(thisJoinPointStaticPart); + } + + after(): start() { completeLog(); } + + abstract protected void logEnter(JoinPoint.StaticPart jp); + + abstract protected void logExit(JoinPoint.StaticPart jp); + + /** called before any logging */ + abstract protected void startLog(); + + /** called after any logging */ + abstract protected void completeLog(); +} + +// END-SAMPLE tracing-traceJoinPoints + +
\ No newline at end of file |