All Downloads are FREE. Search and download functionalities are using the official Maven repository.
Search JAR files by class name

Source code of the class Factory.java part of aspectjweaver version 1.8.9

Go to download Show more of this group Show artifacts with the name aspectjweaver
        /* *******************************************************************
 * Copyright (c) 1999-2001 Xerox Corporation, 
 *               2002 Palo Alto Research Center, Incorporated (PARC).
 * 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://www.eclipse.org/legal/epl-v10.html 
 *  
 * Contributors: 
 *     Xerox/PARC     initial implementation 
 *    Alex Vasseur    new factory methods for variants of JP
 *    Abraham Nevado  new factory methods for collapsed SJPs
 * ******************************************************************/

package org.aspectj.runtime.reflect;

import java.lang.reflect.Constructor;
import java.lang.reflect.Member;
import java.lang.reflect.Method;
import java.util.Hashtable;
import java.util.StringTokenizer;

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();
	}

	
	/**
	 * Create a signature and build a JoinPoint in one step.  Prior to 1.6.10 this was done as a two step operation in the generated
	 * code but merging these methods in the runtime library enables the generated code to be shorter.  Generating code that
	 * uses this method requires the weaver to be invoked with -Xset:targetRuntime1_6_10=true.
	 * 
	 * @since 1.6.10
	 */
	public JoinPoint.StaticPart makeSJP(String kind, String modifiers, String methodName, String declaringType, String paramTypes,
			String paramNames, String exceptionTypes, String returnType, int l) {
		Signature sig = this.makeMethodSig(modifiers, methodName, declaringType, paramTypes, paramNames, exceptionTypes, returnType);
		return new JoinPointImpl.StaticPartImpl(count++, kind, sig, makeSourceLoc(l, -1));
	}
	
	/**
	 * Create a signature and build a JoinPoint in one step.  Prior to 1.6.10 this was done as a two step operation in the generated
	 * code but merging these methods in the runtime library enables the generated code to be shorter.  Generating code that
	 * uses this method requires the weaver to be invoked with -Xset:targetRuntime1_6_10=true.
	 * 

* This method differs from the previous one in that it includes no exceptionTypes parameter - it is an optimization for the * case where there are no exceptions. The generated code won't build an empty string and will not pass it into here. * * @since 1.6.10 */ public JoinPoint.StaticPart makeSJP(String kind, String modifiers, String methodName, String declaringType, String paramTypes, String paramNames, String returnType, int l) { Signature sig = this.makeMethodSig(modifiers, methodName, declaringType, paramTypes, paramNames, "", returnType); return new JoinPointImpl.StaticPartImpl(count++, kind, sig, makeSourceLoc(l, -1)); } 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) { 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) { 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); 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); } }





© 2018 Weber Informatics LLC