mirrors
/
org.aspectj
mirror of https://github.com/eclipse/org.aspectj.git
Watch 1
Star 0
Fork 0
Code Issues 0 Releases 139 Wiki Activity
Browse Source

89009: added getId() to joinpoint.staticpart

tags/V1_6_4
aclement 15 years ago
parent
752f895d26
commit
e40367cb1d
3 changed files with 577 additions and 498 deletions
Split View Show Diff Stats
  1. 21
    1
      runtime/src/org/aspectj/lang/JoinPoint.java
  2. 355
    343
      runtime/src/org/aspectj/runtime/reflect/Factory.java
  3. 201
    154
      runtime/src/org/aspectj/runtime/reflect/JoinPointImpl.java

+ 21
- 1
runtime/src/org/aspectj/lang/JoinPoint.java View File

@@ -99,7 +99,6 @@ public interface JoinPoint {
*/
String getKind();


/**
* <p>This helper object contains only the static information about a join point.
* It is available from the <code>JoinPoint.getStaticPart()</code> method, and
@@ -141,6 +140,27 @@ public interface JoinPoint {
* is guaranteed to be interned</p>
*/
String getKind();
/**
* Return the id for this JoinPoint.StaticPart. All JoinPoint.StaticPart
* instances are assigned an id number upon creation. For each advised type
* the id numbers start at 0.
* <br>
* The id is guaranteed to remain constant across repeated executions
* of a program but may change if the code is recompiled.
* <br>
* The benefit of having an id is that it can be used for array index
* purposes which can be quicker than using the JoinPoint.StaticPart
* object itself in a map lookup.
* <br>
* Since two JoinPoint.StaticPart instances in different advised types may have
* the same id, then if the id is being used to index some joinpoint specific
* state then that state must be maintained on a pertype basis - either by
* using pertypewithin() or an ITD.
*
* @return the id of this joinpoint
*/
int getId();

String toString();


+ 355
- 343
runtime/src/org/aspectj/runtime/reflect/Factory.java View File

@@ -12,7 +12,6 @@
* Alex Vasseur new factory methods for variants of JP
* ******************************************************************/


package org.aspectj.runtime.reflect;

import java.lang.reflect.Constructor;
@@ -21,363 +20,376 @@ import java.lang.reflect.Method;
import java.util.Hashtable;
import java.util.StringTokenizer;

import org.aspectj.lang.*;
import org.aspectj.lang.reflect.*;

public final class Factory {
Class lexicalClass;
ClassLoader lookupClassLoader;
String filename;

static Hashtable prims = new Hashtable();
static {
prims.put("void", Void.TYPE);
prims.put("boolean", Boolean.TYPE);
prims.put("byte", Byte.TYPE);
prims.put("char", Character.TYPE);
prims.put("short", Short.TYPE);
prims.put("int", Integer.TYPE);
prims.put("long", Long.TYPE);
prims.put("float", Float.TYPE);
prims.put("double", Double.TYPE);
}
static Class makeClass(String s, ClassLoader loader) {
if (s.equals("*")) return null;
Class ret = (Class)prims.get(s);
if (ret != null) return ret;
try {
/* The documentation of Class.forName explains why this is the right thing
* better than I could here.
*/
if (loader == null) {
return Class.forName(s);
} else {
// used to be 'return loader.loadClass(s)' but that didn't cause
// array types to be created and loaded correctly. (pr70404)
return Class.forName(s,false,loader);
}
} catch (ClassNotFoundException e) {
//System.out.println("null for: " + s);
//XXX there should be a better return value for this
return ClassNotFoundException.class;
}
}
public Factory(String filename, Class lexicalClass) {
//System.out.println("making
this.filename = filename;
this.lexicalClass = lexicalClass;
lookupClassLoader = lexicalClass.getClassLoader();
}
public JoinPoint.StaticPart makeSJP(String kind, Signature sig, SourceLocation loc) {
return new JoinPointImpl.StaticPartImpl(kind, sig, loc);
}
public JoinPoint.StaticPart makeSJP(String kind, Signature sig, int l, int c) {
return new JoinPointImpl.StaticPartImpl(kind, sig, makeSourceLoc(l, c));
}
public JoinPoint.StaticPart makeSJP(String kind, Signature sig, int l) {
return new JoinPointImpl.StaticPartImpl(kind, sig, makeSourceLoc(l, -1));
}

public JoinPoint.EnclosingStaticPart makeESJP(String kind, Signature sig, SourceLocation loc) {
return new JoinPointImpl.EnclosingStaticPartImpl(kind, sig, loc);
}

public JoinPoint.EnclosingStaticPart makeESJP(String kind, Signature sig, int l, int c) {
return new JoinPointImpl.EnclosingStaticPartImpl(kind, sig, makeSourceLoc(l, c));
}

public JoinPoint.EnclosingStaticPart makeESJP(String kind, Signature sig, int l) {
return new JoinPointImpl.EnclosingStaticPartImpl(kind, sig, makeSourceLoc(l, -1));
}

public static JoinPoint.StaticPart makeEncSJP(Member member) {
Signature sig = null;
String kind = null;
if (member instanceof Method) {
Method method = (Method) member;
sig = new MethodSignatureImpl(method.getModifiers(),method.getName(),
method.getDeclaringClass(),method.getParameterTypes(),
new String[method.getParameterTypes().length],
method.getExceptionTypes(),method.getReturnType());
kind = JoinPoint.METHOD_EXECUTION;
} else if (member instanceof Constructor) {
Constructor cons = (Constructor) member;
sig = new ConstructorSignatureImpl(cons.getModifiers(),cons.getDeclaringClass(),
cons.getParameterTypes(),
new String[cons.getParameterTypes().length],
cons.getExceptionTypes());
kind = JoinPoint.CONSTRUCTOR_EXECUTION;
} else {
throw new IllegalArgumentException("member must be either a method or constructor");
}
return new JoinPointImpl.EnclosingStaticPartImpl(kind,sig,null);
}
private static Object[] NO_ARGS = new Object[0];
public static JoinPoint makeJP(JoinPoint.StaticPart staticPart,
Object _this, Object target)
{
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.reflect.AdviceSignature;
import org.aspectj.lang.reflect.CatchClauseSignature;
import org.aspectj.lang.reflect.ConstructorSignature;
import org.aspectj.lang.reflect.FieldSignature;
import org.aspectj.lang.reflect.InitializerSignature;
import org.aspectj.lang.reflect.LockSignature;
import org.aspectj.lang.reflect.MethodSignature;
import org.aspectj.lang.reflect.SourceLocation;
import org.aspectj.lang.reflect.UnlockSignature;

public final class Factory {
Class lexicalClass;
ClassLoader lookupClassLoader;
String filename;
int count;

static Hashtable prims = new Hashtable();
static {
prims.put("void", Void.TYPE);
prims.put("boolean", Boolean.TYPE);
prims.put("byte", Byte.TYPE);
prims.put("char", Character.TYPE);
prims.put("short", Short.TYPE);
prims.put("int", Integer.TYPE);
prims.put("long", Long.TYPE);
prims.put("float", Float.TYPE);
prims.put("double", Double.TYPE);
}

static Class makeClass(String s, ClassLoader loader) {
if (s.equals("*"))
return null;
Class ret = (Class) prims.get(s);
if (ret != null)
return ret;
try {
/*
* The documentation of Class.forName explains why this is the right thing better than I could here.
*/
if (loader == null) {
return Class.forName(s);
} else {
// used to be 'return loader.loadClass(s)' but that didn't cause
// array types to be created and loaded correctly. (pr70404)
return Class.forName(s, false, loader);
}
} catch (ClassNotFoundException e) {
// System.out.println("null for: " + s);
// XXX there should be a better return value for this
return ClassNotFoundException.class;
}
}

public Factory(String filename, Class lexicalClass) {
// System.out.println("making
this.filename = filename;
this.lexicalClass = lexicalClass;
this.count = 0;
lookupClassLoader = lexicalClass.getClassLoader();
}

public JoinPoint.StaticPart makeSJP(String kind, Signature sig, SourceLocation loc) {
return new JoinPointImpl.StaticPartImpl(count++, kind, sig, loc);
}

public JoinPoint.StaticPart makeSJP(String kind, Signature sig, int l, int c) {
return new JoinPointImpl.StaticPartImpl(count++, kind, sig, makeSourceLoc(l, c));
}

public JoinPoint.StaticPart makeSJP(String kind, Signature sig, int l) {
return new JoinPointImpl.StaticPartImpl(count++, kind, sig, makeSourceLoc(l, -1));
}

public JoinPoint.EnclosingStaticPart makeESJP(String kind, Signature sig, SourceLocation loc) {
return new JoinPointImpl.EnclosingStaticPartImpl(count++, kind, sig, loc);
}

public JoinPoint.EnclosingStaticPart makeESJP(String kind, Signature sig, int l, int c) {
return new JoinPointImpl.EnclosingStaticPartImpl(count++, kind, sig, makeSourceLoc(l, c));
}

public JoinPoint.EnclosingStaticPart makeESJP(String kind, Signature sig, int l) {
return new JoinPointImpl.EnclosingStaticPartImpl(count++, kind, sig, makeSourceLoc(l, -1));
}

public static JoinPoint.StaticPart makeEncSJP(Member member) {
Signature sig = null;
String kind = null;
if (member instanceof Method) {
Method method = (Method) member;
sig = new MethodSignatureImpl(method.getModifiers(), method.getName(), method.getDeclaringClass(), method
.getParameterTypes(), new String[method.getParameterTypes().length], method.getExceptionTypes(), method
.getReturnType());
kind = JoinPoint.METHOD_EXECUTION;
} else if (member instanceof Constructor) {
Constructor cons = (Constructor) member;
sig = new ConstructorSignatureImpl(cons.getModifiers(), cons.getDeclaringClass(), cons.getParameterTypes(),
new String[cons.getParameterTypes().length], cons.getExceptionTypes());
kind = JoinPoint.CONSTRUCTOR_EXECUTION;
} else {
throw new IllegalArgumentException("member must be either a method or constructor");
}
return new JoinPointImpl.EnclosingStaticPartImpl(-1, kind, sig, null);
}

private static Object[] NO_ARGS = new Object[0];

public static JoinPoint makeJP(JoinPoint.StaticPart staticPart, Object _this, Object target) {
return new JoinPointImpl(staticPart, _this, target, NO_ARGS);
}
public static JoinPoint makeJP(JoinPoint.StaticPart staticPart,
Object _this, Object target, Object arg0)
{
return new JoinPointImpl(staticPart, _this, target, new Object[] {arg0});
}
public static JoinPoint makeJP(JoinPoint.StaticPart staticPart,
Object _this, Object target, Object arg0, Object arg1)
{
return new JoinPointImpl(staticPart, _this, target, new Object[] {arg0, arg1});
}
public static JoinPoint makeJP(JoinPoint.StaticPart staticPart,
Object _this, Object target, Object[] args)
{

public static JoinPoint makeJP(JoinPoint.StaticPart staticPart, Object _this, Object target, Object arg0) {
return new JoinPointImpl(staticPart, _this, target, new Object[] { arg0 });
}

public static JoinPoint makeJP(JoinPoint.StaticPart staticPart, Object _this, Object target, Object arg0, Object arg1) {
return new JoinPointImpl(staticPart, _this, target, new Object[] { arg0, arg1 });
}

public static JoinPoint makeJP(JoinPoint.StaticPart staticPart, Object _this, Object target, Object[] args) {
return new JoinPointImpl(staticPart, _this, target, args);
}
public MethodSignature makeMethodSig(String stringRep) {
MethodSignatureImpl ret = new MethodSignatureImpl(stringRep);
ret.setLookupClassLoader(lookupClassLoader);
return ret;
}
public MethodSignature makeMethodSig(String modifiers, String methodName, String declaringType, String paramTypes, String paramNames, String exceptionTypes, String returnType) {
int modifiersAsInt = Integer.parseInt(modifiers, 16);
Class declaringTypeClass = makeClass(declaringType,lookupClassLoader);
StringTokenizer st = new StringTokenizer(paramTypes, ":");
int numParams = st.countTokens();
Class[] paramTypeClasses = new Class[numParams];
for(int i = 0; i < numParams; i++) paramTypeClasses[i] = makeClass(st.nextToken(),lookupClassLoader);
st = new StringTokenizer(paramNames, ":");
numParams = st.countTokens();
String[] paramNamesArray = new String[numParams];
for(int i = 0; i < numParams; i++) paramNamesArray[i] = st.nextToken();
st = new StringTokenizer(exceptionTypes, ":");
numParams = st.countTokens();
Class[] exceptionTypeClasses = new Class[numParams];
for(int i = 0; i < numParams; i++) exceptionTypeClasses[i] = makeClass(st.nextToken(),lookupClassLoader);
Class returnTypeClass = makeClass(returnType,lookupClassLoader);
MethodSignatureImpl ret =
new MethodSignatureImpl(modifiersAsInt, methodName, declaringTypeClass, paramTypeClasses, paramNamesArray, exceptionTypeClasses, returnTypeClass);
return ret;
}
public MethodSignature makeMethodSig(int modifiers, String name, Class declaringType,
Class[] parameterTypes, String[] parameterNames, Class[] exceptionTypes,
Class returnType) {
MethodSignatureImpl ret = new MethodSignatureImpl(modifiers,name,declaringType,parameterTypes,parameterNames,exceptionTypes,returnType);
ret.setLookupClassLoader(lookupClassLoader);
return ret;
}

public ConstructorSignature makeConstructorSig(String stringRep) {
ConstructorSignatureImpl ret = new ConstructorSignatureImpl(stringRep);
ret.setLookupClassLoader(lookupClassLoader);
return ret;
}
public ConstructorSignature makeConstructorSig(String modifiers, String declaringType, String paramTypes, String paramNames, String exceptionTypes) {

public MethodSignature makeMethodSig(String stringRep) {
MethodSignatureImpl ret = new MethodSignatureImpl(stringRep);
ret.setLookupClassLoader(lookupClassLoader);
return ret;
}

public MethodSignature makeMethodSig(String modifiers, String methodName, String declaringType, String paramTypes,
String paramNames, String exceptionTypes, String returnType) {
int modifiersAsInt = Integer.parseInt(modifiers, 16);

Class declaringTypeClass = makeClass(declaringType, lookupClassLoader);

StringTokenizer st = new StringTokenizer(paramTypes, ":");
int numParams = st.countTokens();
Class[] paramTypeClasses = new Class[numParams];
for (int i = 0; i < numParams; i++)
paramTypeClasses[i] = makeClass(st.nextToken(), lookupClassLoader);

st = new StringTokenizer(paramNames, ":");
numParams = st.countTokens();
String[] paramNamesArray = new String[numParams];
for (int i = 0; i < numParams; i++)
paramNamesArray[i] = st.nextToken();

st = new StringTokenizer(exceptionTypes, ":");
numParams = st.countTokens();
Class[] exceptionTypeClasses = new Class[numParams];
for (int i = 0; i < numParams; i++)
exceptionTypeClasses[i] = makeClass(st.nextToken(), lookupClassLoader);

Class returnTypeClass = makeClass(returnType, lookupClassLoader);

MethodSignatureImpl ret = new MethodSignatureImpl(modifiersAsInt, methodName, declaringTypeClass, paramTypeClasses,
paramNamesArray, exceptionTypeClasses, returnTypeClass);

return ret;
}

public MethodSignature makeMethodSig(int modifiers, String name, Class declaringType, Class[] parameterTypes,
String[] parameterNames, Class[] exceptionTypes, Class returnType) {
MethodSignatureImpl ret = new MethodSignatureImpl(modifiers, name, declaringType, parameterTypes, parameterNames,
exceptionTypes, returnType);
ret.setLookupClassLoader(lookupClassLoader);
return ret;
}

public ConstructorSignature makeConstructorSig(String stringRep) {
ConstructorSignatureImpl ret = new ConstructorSignatureImpl(stringRep);
ret.setLookupClassLoader(lookupClassLoader);
return ret;
}

public ConstructorSignature makeConstructorSig(String modifiers, String declaringType, String paramTypes, String paramNames,
String exceptionTypes) {
int modifiersAsInt = Integer.parseInt(modifiers, 16);

Class declaringTypeClass = makeClass(declaringType,lookupClassLoader);
Class declaringTypeClass = makeClass(declaringType, lookupClassLoader);

StringTokenizer st = new StringTokenizer(paramTypes, ":");
int numParams = st.countTokens();
Class[] paramTypeClasses = new Class[numParams];
for(int i = 0; i < numParams; i++) paramTypeClasses[i] = makeClass(st.nextToken(),lookupClassLoader);
for (int i = 0; i < numParams; i++)
paramTypeClasses[i] = makeClass(st.nextToken(), lookupClassLoader);

st = new StringTokenizer(paramNames, ":");
numParams = st.countTokens();
String[] paramNamesArray = new String[numParams];
for(int i = 0; i < numParams; i++) paramNamesArray[i] = st.nextToken();
for (int i = 0; i < numParams; i++)
paramNamesArray[i] = st.nextToken();

st = new StringTokenizer(exceptionTypes, ":");
numParams = st.countTokens();
Class[] exceptionTypeClasses = new Class[numParams];
for(int i = 0; i < numParams; i++) exceptionTypeClasses[i] = makeClass(st.nextToken(),lookupClassLoader);
ConstructorSignatureImpl ret = new ConstructorSignatureImpl(modifiersAsInt, declaringTypeClass, paramTypeClasses, paramNamesArray, exceptionTypeClasses);
ret.setLookupClassLoader(lookupClassLoader);
return ret;
}
public ConstructorSignature makeConstructorSig(int modifiers, Class declaringType,
Class[] parameterTypes, String[] parameterNames, Class[] exceptionTypes) {
ConstructorSignatureImpl ret = new ConstructorSignatureImpl(modifiers,declaringType,parameterTypes,parameterNames,exceptionTypes);
ret.setLookupClassLoader(lookupClassLoader);
return ret;
}

public FieldSignature makeFieldSig(String stringRep) {
FieldSignatureImpl ret = new FieldSignatureImpl(stringRep);
ret.setLookupClassLoader(lookupClassLoader);
return ret;
}
public FieldSignature makeFieldSig(String modifiers, String name, String declaringType, String fieldType) {
int modifiersAsInt = Integer.parseInt(modifiers, 16);
Class declaringTypeClass = makeClass(declaringType,lookupClassLoader);
Class fieldTypeClass = makeClass(fieldType,lookupClassLoader);
FieldSignatureImpl ret = new FieldSignatureImpl(modifiersAsInt, name, declaringTypeClass, fieldTypeClass);
ret.setLookupClassLoader(lookupClassLoader);
return ret;
}
public FieldSignature makeFieldSig(int modifiers, String name, Class declaringType,
Class fieldType) {
FieldSignatureImpl ret = new FieldSignatureImpl(modifiers,name,declaringType,fieldType);
ret.setLookupClassLoader(lookupClassLoader);
return ret;
}

public AdviceSignature makeAdviceSig(String stringRep) {
AdviceSignatureImpl ret = new AdviceSignatureImpl(stringRep);
ret.setLookupClassLoader(lookupClassLoader);
return ret;
}

public AdviceSignature makeAdviceSig(String modifiers, String name, String declaringType, String paramTypes, String paramNames, String exceptionTypes, String returnType) {
int modifiersAsInt = Integer.parseInt(modifiers, 16);
Class declaringTypeClass = makeClass(declaringType,lookupClassLoader);
StringTokenizer st = new StringTokenizer(paramTypes, ":");
int numParams = st.countTokens();
Class[] paramTypeClasses = new Class[numParams];
for(int i = 0; i < numParams; i++) paramTypeClasses[i] = makeClass(st.nextToken(),lookupClassLoader);
st = new StringTokenizer(paramNames, ":");
numParams = st.countTokens();
String[] paramNamesArray = new String[numParams];
for(int i = 0; i < numParams; i++) paramNamesArray[i] = st.nextToken();
st = new StringTokenizer(exceptionTypes, ":");
numParams = st.countTokens();
Class[] exceptionTypeClasses = new Class[numParams];
for(int i = 0; i < numParams; i++) exceptionTypeClasses[i] = makeClass(st.nextToken(),lookupClassLoader);;
Class returnTypeClass = makeClass(returnType,lookupClassLoader);
AdviceSignatureImpl ret = new AdviceSignatureImpl(modifiersAsInt, name, declaringTypeClass, paramTypeClasses, paramNamesArray, exceptionTypeClasses, returnTypeClass);
ret.setLookupClassLoader(lookupClassLoader);
return ret;
}
public AdviceSignature makeAdviceSig(int modifiers, String name, Class declaringType,
Class[] parameterTypes, String[] parameterNames, Class[] exceptionTypes,
Class returnType) {
AdviceSignatureImpl ret = new AdviceSignatureImpl(modifiers,name,declaringType,parameterTypes,parameterNames,exceptionTypes,returnType);
ret.setLookupClassLoader(lookupClassLoader);
return ret;
}

public InitializerSignature makeInitializerSig(String stringRep) {
InitializerSignatureImpl ret = new InitializerSignatureImpl(stringRep);
ret.setLookupClassLoader(lookupClassLoader);
return ret;
}

public InitializerSignature makeInitializerSig(String modifiers, String declaringType) {
int modifiersAsInt = Integer.parseInt(modifiers, 16);
Class declaringTypeClass = makeClass(declaringType,lookupClassLoader);
InitializerSignatureImpl ret = new InitializerSignatureImpl(modifiersAsInt, declaringTypeClass);
ret.setLookupClassLoader(lookupClassLoader);
return ret;
}
public InitializerSignature makeInitializerSig(int modifiers, Class declaringType) {
InitializerSignatureImpl ret = new InitializerSignatureImpl(modifiers,declaringType);
ret.setLookupClassLoader(lookupClassLoader);
return ret;
}
public CatchClauseSignature makeCatchClauseSig(String stringRep) {
CatchClauseSignatureImpl ret = new CatchClauseSignatureImpl(stringRep);
ret.setLookupClassLoader(lookupClassLoader);
return ret;
}
public CatchClauseSignature makeCatchClauseSig(String declaringType, String parameterType, String parameterName) {
Class declaringTypeClass = makeClass(declaringType,lookupClassLoader);
StringTokenizer st = new StringTokenizer(parameterType, ":");
Class parameterTypeClass = makeClass(st.nextToken(),lookupClassLoader);
st = new StringTokenizer(parameterName, ":");
String parameterNameForReturn = st.nextToken();
CatchClauseSignatureImpl ret = new CatchClauseSignatureImpl(declaringTypeClass, parameterTypeClass, parameterNameForReturn);
ret.setLookupClassLoader(lookupClassLoader);
return ret;
}
public CatchClauseSignature makeCatchClauseSig(Class declaringType,
Class parameterType, String parameterName) {
CatchClauseSignatureImpl ret = new CatchClauseSignatureImpl(declaringType,parameterType,parameterName);
ret.setLookupClassLoader(lookupClassLoader);
return ret;
}
public LockSignature makeLockSig(String stringRep) {
LockSignatureImpl ret = new LockSignatureImpl(stringRep);
ret.setLookupClassLoader(lookupClassLoader);
return ret;
}
public LockSignature makeLockSig() {
Class declaringTypeClass = makeClass("Ljava/lang/Object;",lookupClassLoader);
LockSignatureImpl ret = new LockSignatureImpl(declaringTypeClass);
ret.setLookupClassLoader(lookupClassLoader);
return ret;
}
public LockSignature makeLockSig(Class declaringType) {
LockSignatureImpl ret = new LockSignatureImpl(declaringType);
ret.setLookupClassLoader(lookupClassLoader);
return ret;
}
public UnlockSignature makeUnlockSig(String stringRep) {
UnlockSignatureImpl ret = new UnlockSignatureImpl(stringRep);
ret.setLookupClassLoader(lookupClassLoader);
return ret;
}
public UnlockSignature makeUnlockSig() {
Class declaringTypeClass = makeClass("Ljava/lang/Object;",lookupClassLoader);
UnlockSignatureImpl ret = new UnlockSignatureImpl(declaringTypeClass);
ret.setLookupClassLoader(lookupClassLoader);
return ret;
}
public UnlockSignature makeUnlockSig(Class declaringType) {
UnlockSignatureImpl ret = new UnlockSignatureImpl(declaringType);
ret.setLookupClassLoader(lookupClassLoader);
return ret;
}

public SourceLocation makeSourceLoc(int line, int col)
{
return new SourceLocationImpl(lexicalClass, this.filename, line);
}
for (int i = 0; i < numParams; i++)
exceptionTypeClasses[i] = makeClass(st.nextToken(), lookupClassLoader);

ConstructorSignatureImpl ret = new ConstructorSignatureImpl(modifiersAsInt, declaringTypeClass, paramTypeClasses,
paramNamesArray, exceptionTypeClasses);
ret.setLookupClassLoader(lookupClassLoader);
return ret;
}

public ConstructorSignature makeConstructorSig(int modifiers, Class declaringType, Class[] parameterTypes,
String[] parameterNames, Class[] exceptionTypes) {
ConstructorSignatureImpl ret = new ConstructorSignatureImpl(modifiers, declaringType, parameterTypes, parameterNames,
exceptionTypes);
ret.setLookupClassLoader(lookupClassLoader);
return ret;
}

public FieldSignature makeFieldSig(String stringRep) {
FieldSignatureImpl ret = new FieldSignatureImpl(stringRep);
ret.setLookupClassLoader(lookupClassLoader);
return ret;
}

public FieldSignature makeFieldSig(String modifiers, String name, String declaringType, String fieldType) {
int modifiersAsInt = Integer.parseInt(modifiers, 16);
Class declaringTypeClass = makeClass(declaringType, lookupClassLoader);
Class fieldTypeClass = makeClass(fieldType, lookupClassLoader);

FieldSignatureImpl ret = new FieldSignatureImpl(modifiersAsInt, name, declaringTypeClass, fieldTypeClass);
ret.setLookupClassLoader(lookupClassLoader);
return ret;
}

public FieldSignature makeFieldSig(int modifiers, String name, Class declaringType, Class fieldType) {
FieldSignatureImpl ret = new FieldSignatureImpl(modifiers, name, declaringType, fieldType);
ret.setLookupClassLoader(lookupClassLoader);
return ret;
}

public AdviceSignature makeAdviceSig(String stringRep) {
AdviceSignatureImpl ret = new AdviceSignatureImpl(stringRep);
ret.setLookupClassLoader(lookupClassLoader);
return ret;
}

public AdviceSignature makeAdviceSig(String modifiers, String name, String declaringType, String paramTypes, String paramNames,
String exceptionTypes, String returnType) {
int modifiersAsInt = Integer.parseInt(modifiers, 16);

Class declaringTypeClass = makeClass(declaringType, lookupClassLoader);

StringTokenizer st = new StringTokenizer(paramTypes, ":");
int numParams = st.countTokens();
Class[] paramTypeClasses = new Class[numParams];
for (int i = 0; i < numParams; i++)
paramTypeClasses[i] = makeClass(st.nextToken(), lookupClassLoader);

st = new StringTokenizer(paramNames, ":");
numParams = st.countTokens();
String[] paramNamesArray = new String[numParams];
for (int i = 0; i < numParams; i++)
paramNamesArray[i] = st.nextToken();

st = new StringTokenizer(exceptionTypes, ":");
numParams = st.countTokens();
Class[] exceptionTypeClasses = new Class[numParams];
for (int i = 0; i < numParams; i++)
exceptionTypeClasses[i] = makeClass(st.nextToken(), lookupClassLoader);
;

Class returnTypeClass = makeClass(returnType, lookupClassLoader);

AdviceSignatureImpl ret = new AdviceSignatureImpl(modifiersAsInt, name, declaringTypeClass, paramTypeClasses,
paramNamesArray, exceptionTypeClasses, returnTypeClass);
ret.setLookupClassLoader(lookupClassLoader);
return ret;
}

public AdviceSignature makeAdviceSig(int modifiers, String name, Class declaringType, Class[] parameterTypes,
String[] parameterNames, Class[] exceptionTypes, Class returnType) {
AdviceSignatureImpl ret = new AdviceSignatureImpl(modifiers, name, declaringType, parameterTypes, parameterNames,
exceptionTypes, returnType);
ret.setLookupClassLoader(lookupClassLoader);
return ret;
}

public InitializerSignature makeInitializerSig(String stringRep) {
InitializerSignatureImpl ret = new InitializerSignatureImpl(stringRep);
ret.setLookupClassLoader(lookupClassLoader);
return ret;
}

public InitializerSignature makeInitializerSig(String modifiers, String declaringType) {
int modifiersAsInt = Integer.parseInt(modifiers, 16);
Class declaringTypeClass = makeClass(declaringType, lookupClassLoader);

InitializerSignatureImpl ret = new InitializerSignatureImpl(modifiersAsInt, declaringTypeClass);
ret.setLookupClassLoader(lookupClassLoader);
return ret;
}

public InitializerSignature makeInitializerSig(int modifiers, Class declaringType) {
InitializerSignatureImpl ret = new InitializerSignatureImpl(modifiers, declaringType);
ret.setLookupClassLoader(lookupClassLoader);
return ret;
}

public CatchClauseSignature makeCatchClauseSig(String stringRep) {
CatchClauseSignatureImpl ret = new CatchClauseSignatureImpl(stringRep);
ret.setLookupClassLoader(lookupClassLoader);
return ret;
}

public CatchClauseSignature makeCatchClauseSig(String declaringType, String parameterType, String parameterName) {
Class declaringTypeClass = makeClass(declaringType, lookupClassLoader);

StringTokenizer st = new StringTokenizer(parameterType, ":");
Class parameterTypeClass = makeClass(st.nextToken(), lookupClassLoader);

st = new StringTokenizer(parameterName, ":");
String parameterNameForReturn = st.nextToken();

CatchClauseSignatureImpl ret = new CatchClauseSignatureImpl(declaringTypeClass, parameterTypeClass, parameterNameForReturn);
ret.setLookupClassLoader(lookupClassLoader);
return ret;
}

public CatchClauseSignature makeCatchClauseSig(Class declaringType, Class parameterType, String parameterName) {
CatchClauseSignatureImpl ret = new CatchClauseSignatureImpl(declaringType, parameterType, parameterName);
ret.setLookupClassLoader(lookupClassLoader);
return ret;
}

public LockSignature makeLockSig(String stringRep) {
LockSignatureImpl ret = new LockSignatureImpl(stringRep);
ret.setLookupClassLoader(lookupClassLoader);
return ret;
}

public LockSignature makeLockSig() {
Class declaringTypeClass = makeClass("Ljava/lang/Object;", lookupClassLoader);
LockSignatureImpl ret = new LockSignatureImpl(declaringTypeClass);
ret.setLookupClassLoader(lookupClassLoader);
return ret;
}

public LockSignature makeLockSig(Class declaringType) {
LockSignatureImpl ret = new LockSignatureImpl(declaringType);
ret.setLookupClassLoader(lookupClassLoader);
return ret;
}

public UnlockSignature makeUnlockSig(String stringRep) {
UnlockSignatureImpl ret = new UnlockSignatureImpl(stringRep);
ret.setLookupClassLoader(lookupClassLoader);
return ret;
}

public UnlockSignature makeUnlockSig() {
Class declaringTypeClass = makeClass("Ljava/lang/Object;", lookupClassLoader);
UnlockSignatureImpl ret = new UnlockSignatureImpl(declaringTypeClass);
ret.setLookupClassLoader(lookupClassLoader);
return ret;
}

public UnlockSignature makeUnlockSig(Class declaringType) {
UnlockSignatureImpl ret = new UnlockSignatureImpl(declaringType);
ret.setLookupClassLoader(lookupClassLoader);
return ret;
}

public SourceLocation makeSourceLoc(int line, int col) {
return new SourceLocationImpl(lexicalClass, this.filename, line);
}
}

+ 201
- 154
runtime/src/org/aspectj/runtime/reflect/JoinPointImpl.java View File

@@ -11,7 +11,6 @@
* Xerox/PARC initial implementation
* ******************************************************************/


package org.aspectj.runtime.reflect;

import org.aspectj.lang.JoinPoint;
@@ -21,158 +20,206 @@ import org.aspectj.lang.reflect.SourceLocation;
import org.aspectj.runtime.internal.AroundClosure;

class JoinPointImpl implements ProceedingJoinPoint {
static class StaticPartImpl implements JoinPoint.StaticPart {
String kind;
Signature signature;
SourceLocation sourceLocation;

public StaticPartImpl(String kind, Signature signature, SourceLocation sourceLocation) {
this.kind = kind;
this.signature = signature;
this.sourceLocation = sourceLocation;
}

public String getKind() { return kind; }
public Signature getSignature() { return signature; }
public SourceLocation getSourceLocation() { return sourceLocation; }

String toString(StringMaker sm) {
StringBuffer buf = new StringBuffer();
buf.append(sm.makeKindName(getKind()));
buf.append("(");
buf.append(((SignatureImpl)getSignature()).toString(sm));
buf.append(")");
return buf.toString();
}

public final String toString() { return toString(StringMaker.middleStringMaker); }
public final String toShortString() { return toString(StringMaker.shortStringMaker); }
public final String toLongString() { return toString(StringMaker.longStringMaker); }
}

static class EnclosingStaticPartImpl extends StaticPartImpl implements EnclosingStaticPart {
public EnclosingStaticPartImpl(String kind, Signature signature, SourceLocation sourceLocation) {
super(kind, signature, sourceLocation);
}
}

Object _this;
Object target;
Object[] args;
org.aspectj.lang.JoinPoint.StaticPart staticPart;

public JoinPointImpl(org.aspectj.lang.JoinPoint.StaticPart staticPart, Object _this, Object target, Object[] args) {
this.staticPart = staticPart;
this._this = _this;
this.target = target;
this.args = args;
}

public Object getThis() { return _this; }
public Object getTarget() { return target; }
public Object[] getArgs() {
if (args == null) { args = new Object[0]; }
Object[] argsCopy = new Object[args.length];
System.arraycopy(args,0,argsCopy,0,args.length);
return argsCopy;
}

public org.aspectj.lang.JoinPoint.StaticPart getStaticPart() { return staticPart; }

public String getKind() { return staticPart.getKind(); }
public Signature getSignature() { return staticPart.getSignature(); }
public SourceLocation getSourceLocation() { return staticPart.getSourceLocation(); }

public final String toString() { return staticPart.toString(); }
public final String toShortString() { return staticPart.toShortString(); }
public final String toLongString() { return staticPart.toLongString(); }

// To proceed we need a closure to proceed on
private AroundClosure arc;
public void set$AroundClosure(AroundClosure arc) {
this.arc = arc;
}

public Object proceed() throws Throwable {
// when called from a before advice, but be a no-op
if (arc == null)
return null;
else
return arc.run(arc.getState());
}

public Object proceed(Object[] adviceBindings) throws Throwable {
// when called from a before advice, but be a no-op
if (arc == null)
return null;
else {

// Based on the bit flags in the AroundClosure we can determine what to
// expect in the adviceBindings array. We may or may not be expecting
// the first value to be a new this or a new target... (see pr126167)
int flags = arc.getFlags();
boolean unset = (flags &0x100000)!=0;
boolean thisTargetTheSame = (flags &0x010000)!=0;
boolean hasThis = (flags &0x001000)!=0;
boolean bindsThis = (flags &0x000100)!=0;
boolean hasTarget = (flags &0x000010)!=0;
boolean bindsTarget = (flags &0x000001)!=0;
// state is always consistent with caller?,callee?,formals...,jp
Object[] state = arc.getState();
// these next two numbers can differ because some join points have a this and
// target that are the same (eg. call) - and yet you can bind this and target
// separately.
// In the state array, [0] may be this, [1] may be target
int firstArgumentIndexIntoAdviceBindings = 0;
int firstArgumentIndexIntoState = 0;
firstArgumentIndexIntoState+=(hasThis?1:0);
firstArgumentIndexIntoState+=(hasTarget&&!thisTargetTheSame?1:0);
if (hasThis) {
if (bindsThis) {
// replace [0] (this)
firstArgumentIndexIntoAdviceBindings=1;
state[0]=adviceBindings[0];
} else {
// leave state[0] alone, its OK
}
}
if (hasTarget) {
if (bindsTarget) {
if (thisTargetTheSame) {
// this and target are the same so replace state[0]
firstArgumentIndexIntoAdviceBindings=1+(bindsThis?1:0);
state[0]=adviceBindings[(bindsThis?1:0)];
} else {
// need to replace the target, and it is different to this, whether
// that means replacing state[0] or state[1] depends on whether
// the join point has a this
firstArgumentIndexIntoAdviceBindings=(hasThis?1:0)+1;
state[hasThis?1:0]=adviceBindings[hasThis?1:0];
}
} else {
// leave state[0]/state[1] alone, they are OK
}
}
// copy the rest across
for (int i=firstArgumentIndexIntoAdviceBindings;i<adviceBindings.length;i++) {
state[firstArgumentIndexIntoState+(i-firstArgumentIndexIntoAdviceBindings)]=adviceBindings[i];
}
// old code that did this, didnt allow this/target overriding
// for (int i = state.length-2; i >= 0; i--) {
// int formalIndex = (adviceBindings.length - 1) - (state.length-2) + i;
// if (formalIndex >= 0 && formalIndex < adviceBindings.length) {
// state[i] = adviceBindings[formalIndex];
// }
// }
return arc.run(state);
}
}
static class StaticPartImpl implements JoinPoint.StaticPart {
String kind;
Signature signature;
SourceLocation sourceLocation;
private int id;

public StaticPartImpl(int id, String kind, Signature signature, SourceLocation sourceLocation) {
this.kind = kind;
this.signature = signature;
this.sourceLocation = sourceLocation;
this.id = id;
}

public int getId() {
return id;
}

public String getKind() {
return kind;
}

public Signature getSignature() {
return signature;
}

public SourceLocation getSourceLocation() {
return sourceLocation;
}

String toString(StringMaker sm) {
StringBuffer buf = new StringBuffer();
buf.append(sm.makeKindName(getKind()));
buf.append("(");
buf.append(((SignatureImpl) getSignature()).toString(sm));
buf.append(")");
return buf.toString();
}

public final String toString() {
return toString(StringMaker.middleStringMaker);
}

public final String toShortString() {
return toString(StringMaker.shortStringMaker);
}

public final String toLongString() {
return toString(StringMaker.longStringMaker);
}
}

static class EnclosingStaticPartImpl extends StaticPartImpl implements EnclosingStaticPart {
public EnclosingStaticPartImpl(int count, String kind, Signature signature, SourceLocation sourceLocation) {
super(count, kind, signature, sourceLocation);
}
}

Object _this;
Object target;
Object[] args;
org.aspectj.lang.JoinPoint.StaticPart staticPart;

public JoinPointImpl(org.aspectj.lang.JoinPoint.StaticPart staticPart, Object _this, Object target, Object[] args) {
this.staticPart = staticPart;
this._this = _this;
this.target = target;
this.args = args;
}

public Object getThis() {
return _this;
}

public Object getTarget() {
return target;
}

public Object[] getArgs() {
if (args == null) {
args = new Object[0];
}
Object[] argsCopy = new Object[args.length];
System.arraycopy(args, 0, argsCopy, 0, args.length);
return argsCopy;
}

public org.aspectj.lang.JoinPoint.StaticPart getStaticPart() {
return staticPart;
}

public String getKind() {
return staticPart.getKind();
}

public Signature getSignature() {
return staticPart.getSignature();
}

public SourceLocation getSourceLocation() {
return staticPart.getSourceLocation();
}

public final String toString() {
return staticPart.toString();
}

public final String toShortString() {
return staticPart.toShortString();
}

public final String toLongString() {
return staticPart.toLongString();
}

// To proceed we need a closure to proceed on
private AroundClosure arc;

public void set$AroundClosure(AroundClosure arc) {
this.arc = arc;
}

public Object proceed() throws Throwable {
// when called from a before advice, but be a no-op
if (arc == null)
return null;
else
return arc.run(arc.getState());
}

public Object proceed(Object[] adviceBindings) throws Throwable {
// when called from a before advice, but be a no-op
if (arc == null)
return null;
else {

// Based on the bit flags in the AroundClosure we can determine what to
// expect in the adviceBindings array. We may or may not be expecting
// the first value to be a new this or a new target... (see pr126167)
int flags = arc.getFlags();
boolean unset = (flags & 0x100000) != 0;
boolean thisTargetTheSame = (flags & 0x010000) != 0;
boolean hasThis = (flags & 0x001000) != 0;
boolean bindsThis = (flags & 0x000100) != 0;
boolean hasTarget = (flags & 0x000010) != 0;
boolean bindsTarget = (flags & 0x000001) != 0;

// state is always consistent with caller?,callee?,formals...,jp
Object[] state = arc.getState();

// these next two numbers can differ because some join points have a this and
// target that are the same (eg. call) - and yet you can bind this and target
// separately.

// In the state array, [0] may be this, [1] may be target

int firstArgumentIndexIntoAdviceBindings = 0;
int firstArgumentIndexIntoState = 0;
firstArgumentIndexIntoState += (hasThis ? 1 : 0);
firstArgumentIndexIntoState += (hasTarget && !thisTargetTheSame ? 1 : 0);
if (hasThis) {
if (bindsThis) {
// replace [0] (this)
firstArgumentIndexIntoAdviceBindings = 1;
state[0] = adviceBindings[0];
} else {
// leave state[0] alone, its OK
}
}
if (hasTarget) {
if (bindsTarget) {
if (thisTargetTheSame) {
// this and target are the same so replace state[0]
firstArgumentIndexIntoAdviceBindings = 1 + (bindsThis ? 1 : 0);
state[0] = adviceBindings[(bindsThis ? 1 : 0)];
} else {
// need to replace the target, and it is different to this, whether
// that means replacing state[0] or state[1] depends on whether
// the join point has a this
firstArgumentIndexIntoAdviceBindings = (hasThis ? 1 : 0) + 1;
state[hasThis ? 1 : 0] = adviceBindings[hasThis ? 1 : 0];
}
} else {
// leave state[0]/state[1] alone, they are OK
}
}

// copy the rest across
for (int i = firstArgumentIndexIntoAdviceBindings; i < adviceBindings.length; i++) {
state[firstArgumentIndexIntoState + (i - firstArgumentIndexIntoAdviceBindings)] = adviceBindings[i];
}

// old code that did this, didnt allow this/target overriding
// for (int i = state.length-2; i >= 0; i--) {
// int formalIndex = (adviceBindings.length - 1) - (state.length-2) + i;
// if (formalIndex >= 0 && formalIndex < adviceBindings.length) {
// state[i] = adviceBindings[formalIndex];
// }
// }
return arc.run(state);
}
}

}

Write Preview
Loading…
Cancel
Save