Initial library module

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