Attachment #15623 for bug #77163

View | Details | Raw Unified | Return to bug 77163
Collapse All | Expand All





import java.io.File;
import java.io.IOException;
import java.io.PrintWriter;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.StringTokenizer;

import org.aspectj.bridge.AbortException;
import org.aspectj.bridge.IMessage;
import org.aspectj.bridge.IMessageHandler;
import org.aspectj.bridge.MessageUtil;
import org.aspectj.bridge.MessageWriter;
import org.aspectj.bridge.IMessage.Kind;
import org.aspectj.util.FileUtil;
import org.aspectj.weaver.IClassFileProvider;

	 * System property used to turn on verbose weaving messages 
	 */
	public static final String WEAVING_ADAPTOR_VERBOSE = "aj.weaving.verbose"; 
	public static final String SHOW_WEAVE_INFO_PROPERTY = "org.aspectj.weaver.showWeaveInfo"; 

	private boolean enabled = true;
	private boolean verbose = getVerbose();
	private BcelWorld bcelWorld = null;
	private BcelWeaver weaver = null;
	private WeavingAdaptorMessageHandler messageHandler = null;
	private GeneratedClassHandler generatedClassHandler;
	private Map generatedClasses = new HashMap(); /* String -> UnwovenClassFile */ 


				list.addAll(0,FileUtil.makeClasspath(urls));
			}
			else {
				warn("cannot determine classpath"); 
			}
		}


	}
	
	private void init(List classPath, List aspectPath) {
		messageHandler = new WeavingAdaptorMessageHandler(new PrintWriter(System.err));
		if (verbose) messageHandler.dontIgnore(IMessage.INFO);
		else messageHandler.ignore(IMessage.INFO);
		if (Boolean.getBoolean(SHOW_WEAVE_INFO_PROPERTY)) messageHandler.dontIgnore(IMessage.WEAVEINFO);
		
		info("using classpath: " + classPath); 
		info("using aspectpath: " + aspectPath); 
		
		// make sure the weaver can find all types...
		messageHandler = new MessageHandler();
		bcelWorld = new BcelWorld(classPath,messageHandler,null);
		bcelWorld.setXnoInline(false);
		bcelWorld.getLint().loadDefaultProperties();

	 * @param url to be appended to search path
	 */
	public void addURL(URL url) {
		File libFile = new File(url.getPath());
		try {
			weaver.addLibraryJarFile(libFile);
		}
		catch (IOException ex) {
			warn("bad library: '" + libFile + "'");
		}
	}


	 */
	public byte[] weaveClass (String name, byte[] bytes) throws IOException {
		if (shouldWeave(name)) {
			info("weaving '" + name + "'");
			bytes = getWovenBytes(name, bytes);
		}
		return bytes;

	private boolean shouldWeave (String name) {
		name = name.replace('/','.');
		boolean b = (enabled && !generatedClasses.containsKey(name) && shouldWeaveName(name) && shouldWeaveAspect(name));
		if (verbose) System.out.println("WeavingAdaptor: shouldWeave('" + name + "') " + b);
		return b;
	}
	

	private void registerAspectLibraries(List aspectPath) {
//		System.err.println("? WeavingAdaptor.registerAspectLibraries(" + aspectPath + ")");
		for (Iterator i = aspectPath.iterator(); i.hasNext();) {
			String libName = (String)i.next();
			addAspectLibrary(libName);
			if (libFile.isFile() && lib.endsWith(".jar")) {
				try {
					if (verbose) System.out.println("WeavingAdaptor: adding aspect '" + lib + "' to weaver");
					addAspectLibrary(new File(lib));
				} catch (IOException ioEx) {
					if (verbose) System.err.println(
						"WeavingAdaptor: Warning - could not load aspect path entry " 
						+ lib + " : " + ioEx);
				}
			} else {
				if (verbose) System.err.println(
					"WeavingAdaptor: Warning - ignoring aspect path entry: " + lib);
			}
		}
		
		weaver.prepareForWeave();

	 * @param aspectLibraryJarFile a jar file representing an aspect library
	 * @throws IOException
	 */
	private void addAspectLibrary(String aspectLibraryName) {
		File aspectLibrary = new File(aspectLibraryName);
		if (aspectLibrary.isFile() && aspectLibraryName.endsWith(".jar")) {
			try {
				info("adding aspect library: '" + aspectLibrary + "'");
				weaver.addLibraryJarFile(aspectLibrary);
			} catch (IOException ex) {
				error("exception adding aspect library: '" + ex + "'");
			}
		} else {
			error("bad aspect library: '" + aspectLibrary + "'");
		}
	}
	
	private static List makeClasspath(String cp) {

		}
		return ret;
	}
	
	private boolean info (String message) {
		return MessageUtil.info(messageHandler,message);
	}
	
	private boolean warn (String message) {
		return MessageUtil.warn(messageHandler,message);
	}
	
	private boolean error (String message) {
		return MessageUtil.error(messageHandler,message);
	}

	/**
	 * Processes messages arising from weaver operations. 
	 * Tell weaver to abort on any message more severe than warning.
	 */
	private class WeavingAdaptorMessageHandler extends MessageWriter {

		private Set ignoring = new HashSet();
		private IMessage.Kind failKind;

		public WeavingAdaptorMessageHandler (PrintWriter writer) {
			super(writer,true);
			
			ignore(IMessage.WEAVEINFO);
			this.failKind = IMessage.ERROR;

		}

		public boolean handleMessage(IMessage message) throws AbortException {
			boolean result = super.handleMessage(message);
			if (0 <= message.getKind().compareTo(failKind)) {
				throw new AbortException(message);
			}
			return true;	
		}

		public boolean isIgnoring (Kind kind) {
			return ((null != kind) && (ignoring.contains(kind)));
		}

		/**
		 * Set a message kind to be ignored from now on
		 */
		public void ignore (IMessage.Kind kind) { 
			if ((null != kind) && (!ignoring.contains(kind))) {
				ignoring.add(kind);
			}
			return true;
		}

		/**
		 * Remove a message kind from the list of those ignored from now on.
		 */
		public void dontIgnore (IMessage.Kind kind) {
			if (null != kind) {
				ignoring.remove(kind);
			}
		}
	}


Lines 16-21 Link Here

(-)testsrc/org/aspectj/weaver/WeavingURLClassLoaderTest.java (-19 / +99 lines)
16	import java.lang.reflect.InvocationTargetException;	16	import java.lang.reflect.InvocationTargetException;
17	import java.lang.reflect.Method;	17	import java.lang.reflect.Method;
18	import java.net.URL;	18	import java.net.URL;
		19	import java.util.Enumeration;
		20	import java.util.Properties;
19		21
20	import junit.framework.TestCase;	22	import junit.framework.TestCase;
21		23
Lines 41-55 Link Here
41	private final static String ITD_ASPECTS = BcweaverTests.TESTDATA_PATH + "/ltw-itdaspects.jar";	43	private final static String ITD_ASPECTS = BcweaverTests.TESTDATA_PATH + "/ltw-itdaspects.jar";
42	private final static String PER_ASPECTS = BcweaverTests.TESTDATA_PATH + "/ltw-peraspects.jar";	44	private final static String PER_ASPECTS = BcweaverTests.TESTDATA_PATH + "/ltw-peraspects.jar";
43		45
		46	private final static String NULL = "null";
		47
		48	private Properties savedProperties;
44		49
45	public WeavingURLClassLoaderTest(String name) {	50	public WeavingURLClassLoaderTest(String name) {
46	super(name);	51	super(name);
47	System.setProperty(WeavingAdaptor.WEAVING_ADAPTOR_VERBOSE,"true");
48	}	52	}
49		53
50	public void testLoadClass () {	54	public void testLoadClass () {
51	System.setProperty(WeavingURLClassLoader.WEAVING_ASPECT_PATH,"");	55	setSystemProperty(WeavingURLClassLoader.WEAVING_ASPECT_PATH,"");
52	System.setProperty(WeavingURLClassLoader.WEAVING_CLASS_PATH,CLASSES_JAR);	56	setSystemProperty(WeavingURLClassLoader.WEAVING_CLASS_PATH,CLASSES_JAR);
53	WeavingURLClassLoader loader = new WeavingURLClassLoader(getClass().getClassLoader());	57	WeavingURLClassLoader loader = new WeavingURLClassLoader(getClass().getClassLoader());
54		58
55	try {	59	try {
Lines 62-69 Link Here
62	}	66	}
63		67
64	public void testLoadWovenClass () {	68	public void testLoadWovenClass () {
65	System.setProperty(WeavingURLClassLoader.WEAVING_ASPECT_PATH,"");	69	setSystemProperty(WeavingURLClassLoader.WEAVING_ASPECT_PATH,"");
66	System.setProperty(WeavingURLClassLoader.WEAVING_CLASS_PATH,WOVEN_JAR);	70	setSystemProperty(WeavingURLClassLoader.WEAVING_CLASS_PATH,WOVEN_JAR);
67	WeavingURLClassLoader loader = new WeavingURLClassLoader(getClass().getClassLoader());	71	WeavingURLClassLoader loader = new WeavingURLClassLoader(getClass().getClassLoader());
68		72
69	try {	73	try {
Lines 76-83 Link Here
76	}	80	}
77		81
78	public void testWeaveWovenClass () {	82	public void testWeaveWovenClass () {
79	System.setProperty(WeavingURLClassLoader.WEAVING_ASPECT_PATH,ADVICE_ASPECTS);	83	setSystemProperty(WeavingURLClassLoader.WEAVING_ASPECT_PATH,ADVICE_ASPECTS);
80	System.setProperty(WeavingURLClassLoader.WEAVING_CLASS_PATH,ADVICE_ASPECTS + File.pathSeparator + WOVEN_JAR);	84	setSystemProperty(WeavingURLClassLoader.WEAVING_CLASS_PATH,ADVICE_ASPECTS + File.pathSeparator + WOVEN_JAR);
81	WeavingURLClassLoader loader = new WeavingURLClassLoader(getClass().getClassLoader());	85	WeavingURLClassLoader loader = new WeavingURLClassLoader(getClass().getClassLoader());
82		86
83	try {	87	try {
Lines 106-113 Link Here
106	}	110	}
107		111
108	public void testWeaveAdvice () {	112	public void testWeaveAdvice () {
109	System.setProperty(WeavingURLClassLoader.WEAVING_ASPECT_PATH,ADVICE_ASPECTS);	113	setSystemProperty(WeavingURLClassLoader.WEAVING_ASPECT_PATH,ADVICE_ASPECTS);
110	System.setProperty(WeavingURLClassLoader.WEAVING_CLASS_PATH,ADVICE_ASPECTS + File.pathSeparator + CLASSES_JAR);	114	setSystemProperty(WeavingURLClassLoader.WEAVING_CLASS_PATH,ADVICE_ASPECTS + File.pathSeparator + CLASSES_JAR);
		115	WeavingURLClassLoader loader = new WeavingURLClassLoader(getClass().getClassLoader());
		116
		117	try {
		118	Class clazz = loader.loadClass("LTWHelloWorld");
		119	invokeMain(clazz,new String[] { "LTWAspect" });
		120	}
		121	catch (Exception ex) {
		122	fail(ex.toString());
		123	}
		124	}
		125
		126	public void testWeaveAdviceWithVerbose () {
		127	setSystemProperty(WeavingURLClassLoader.WEAVING_ASPECT_PATH,ADVICE_ASPECTS);
		128	setSystemProperty(WeavingURLClassLoader.WEAVING_CLASS_PATH,ADVICE_ASPECTS + File.pathSeparator + CLASSES_JAR);
		129	setSystemProperty(WeavingAdaptor.WEAVING_ADAPTOR_VERBOSE,"true");
		130	WeavingURLClassLoader loader = new WeavingURLClassLoader(getClass().getClassLoader());
		131
		132	try {
		133	Class clazz = loader.loadClass("LTWHelloWorld");
		134	invokeMain(clazz,new String[] { "LTWAspect" });
		135	}
		136	catch (Exception ex) {
		137	fail(ex.toString());
		138	}
		139	}
		140
		141	public void testWeaveAdviceWithWeaveInfo () {
		142	setSystemProperty(WeavingURLClassLoader.WEAVING_ASPECT_PATH,ADVICE_ASPECTS);
		143	setSystemProperty(WeavingURLClassLoader.WEAVING_CLASS_PATH,ADVICE_ASPECTS + File.pathSeparator + CLASSES_JAR);
		144	setSystemProperty(WeavingAdaptor.SHOW_WEAVE_INFO_PROPERTY,"true");
111	WeavingURLClassLoader loader = new WeavingURLClassLoader(getClass().getClassLoader());	145	WeavingURLClassLoader loader = new WeavingURLClassLoader(getClass().getClassLoader());
112		146
113	try {	147	try {
Lines 120-127 Link Here
120	}	154	}
121		155
122	public void testWeaveDeclareWarningAdvice () {	156	public void testWeaveDeclareWarningAdvice () {
123	System.setProperty(WeavingURLClassLoader.WEAVING_ASPECT_PATH,DW_ADVICE_ASPECTS);	157	setSystemProperty(WeavingURLClassLoader.WEAVING_ASPECT_PATH,DW_ADVICE_ASPECTS);
124	System.setProperty(WeavingURLClassLoader.WEAVING_CLASS_PATH,DW_ADVICE_ASPECTS + File.pathSeparator + CLASSES_JAR);	158	setSystemProperty(WeavingURLClassLoader.WEAVING_CLASS_PATH,DW_ADVICE_ASPECTS + File.pathSeparator + CLASSES_JAR);
125	WeavingURLClassLoader loader = new WeavingURLClassLoader(getClass().getClassLoader());	159	WeavingURLClassLoader loader = new WeavingURLClassLoader(getClass().getClassLoader());
126		160
127	try {	161	try {
Lines 134-141 Link Here
134	}	168	}
135		169
136	public void testWeaveDeclareErrorAdvice () {	170	public void testWeaveDeclareErrorAdvice () {
137	System.setProperty(WeavingURLClassLoader.WEAVING_ASPECT_PATH,DE_ADVICE_ASPECTS);	171	setSystemProperty(WeavingURLClassLoader.WEAVING_ASPECT_PATH,DE_ADVICE_ASPECTS);
138	System.setProperty(WeavingURLClassLoader.WEAVING_CLASS_PATH,DE_ADVICE_ASPECTS + File.pathSeparator + CLASSES_JAR);	172	setSystemProperty(WeavingURLClassLoader.WEAVING_CLASS_PATH,DE_ADVICE_ASPECTS + File.pathSeparator + CLASSES_JAR);
139	WeavingURLClassLoader loader = new WeavingURLClassLoader(getClass().getClassLoader());	173	WeavingURLClassLoader loader = new WeavingURLClassLoader(getClass().getClassLoader());
140		174
141	try {	175	try {
Lines 149-156 Link Here
149	}	183	}
150		184
151	public void testWeaveAroundClosure () {	185	public void testWeaveAroundClosure () {
152	System.setProperty(WeavingURLClassLoader.WEAVING_ASPECT_PATH,AROUNDCLOSURE_ASPECTS);	186	setSystemProperty(WeavingURLClassLoader.WEAVING_ASPECT_PATH,AROUNDCLOSURE_ASPECTS);
153	System.setProperty(WeavingURLClassLoader.WEAVING_CLASS_PATH,AROUNDCLOSURE_ASPECTS + File.pathSeparator + CLASSES_JAR);	187	setSystemProperty(WeavingURLClassLoader.WEAVING_CLASS_PATH,AROUNDCLOSURE_ASPECTS + File.pathSeparator + CLASSES_JAR);
154	WeavingURLClassLoader loader = new WeavingURLClassLoader(getClass().getClassLoader());	188	WeavingURLClassLoader loader = new WeavingURLClassLoader(getClass().getClassLoader());
155		189
156	try {	190	try {
Lines 231-236 Link Here
231	}	265	}
232	}	266	}
233		267
		268	public void testJunkAspectJar () {
		269	File junkJar = new File(JUNK_JAR);
		270	assertFalse(junkJar + " should not exist",junkJar.exists());
		271
		272	URL aspects = FileUtil.getFileURL(junkJar);
		273	URL[] classURLs = new URL[] { aspects };
		274	URL[] aspectURLs = new URL[] { aspects };
		275
		276	try {
		277	WeavingURLClassLoader loader = new WeavingURLClassLoader(classURLs,aspectURLs,getClass().getClassLoader());
		278	fail("Expecting org.aspectj.bridge.AbortException");
		279	}
		280	catch (Exception ex) {
		281	assertTrue("Expecting org.aspectj.bridge.AbortException caught " + ex,(ex instanceof org.aspectj.bridge.AbortException));
		282	}
		283	}
		284
234	public void testAddURL () {	285	public void testAddURL () {
235	URL classes = FileUtil.getFileURL(new File(CLASSES_JAR));	286	URL classes = FileUtil.getFileURL(new File(CLASSES_JAR));
236	URL aspects = FileUtil.getFileURL(new File(ADVICE_ASPECTS));	287	URL aspects = FileUtil.getFileURL(new File(ADVICE_ASPECTS));
Lines 274-281 Link Here
274	* Aspects on ASPECTPATH but missing from CLASSPATH	325	* Aspects on ASPECTPATH but missing from CLASSPATH
275	*/	326	*/
276	public void testIncompletePath () {	327	public void testIncompletePath () {
277	System.setProperty(WeavingURLClassLoader.WEAVING_ASPECT_PATH,ADVICE_ASPECTS);	328	setSystemProperty(WeavingURLClassLoader.WEAVING_ASPECT_PATH,ADVICE_ASPECTS);
278	System.setProperty(WeavingURLClassLoader.WEAVING_CLASS_PATH,CLASSES_JAR);	329	setSystemProperty(WeavingURLClassLoader.WEAVING_CLASS_PATH,CLASSES_JAR);
279	WeavingURLClassLoader loader = new WeavingURLClassLoader(getClass().getClassLoader());	330	WeavingURLClassLoader loader = new WeavingURLClassLoader(getClass().getClassLoader());
280		331
281	try {	332	try {
Lines 291-298 Link Here
291	* Ensure package object is correct	342	* Ensure package object is correct
292	*/	343	*/
293	public void testPackage () {	344	public void testPackage () {
294	System.setProperty(WeavingURLClassLoader.WEAVING_ASPECT_PATH,"");	345	setSystemProperty(WeavingURLClassLoader.WEAVING_ASPECT_PATH,"");
295	System.setProperty(WeavingURLClassLoader.WEAVING_CLASS_PATH,CLASSES_JAR);	346	setSystemProperty(WeavingURLClassLoader.WEAVING_CLASS_PATH,CLASSES_JAR);
296	WeavingURLClassLoader loader = new WeavingURLClassLoader(getClass().getClassLoader());	347	WeavingURLClassLoader loader = new WeavingURLClassLoader(getClass().getClassLoader());
297		348
298	try {	349	try {
Lines 322-327 Link Here
322	}	373	}
323	catch (Exception ex) {	374	catch (Exception ex) {
324	throw new RuntimeException(ex.toString());	375	throw new RuntimeException(ex.toString());
		376	}
		377	}
		378
		379	private void setSystemProperty (String key, String value) {
		380	Properties systemProperties = System.getProperties();
		381	copyProperty(key,systemProperties,savedProperties);
		382	systemProperties.setProperty(key,value);
		383	}
		384
		385	private static void copyProperty (String key, Properties from, Properties to) {
		386	String value = from.getProperty(key,NULL);
		387	to.setProperty(key,value);
		388	}
		389
		390	protected void setUp() throws Exception {
		391	super.setUp();
		392	savedProperties = new Properties();
		393	}
		394
		395	protected void tearDown() throws Exception {
		396	super.tearDown();
		397
		398	/* Restore system properties */
		399	Properties systemProperties = System.getProperties();
		400	for (Enumeration enum = savedProperties.keys(); enum.hasMoreElements(); ) {
		401	String key = (String)enum.nextElement();
		402	String value = savedProperties.getProperty(key);
		403	if (value == NULL) systemProperties.remove(key);
		404	else systemProperties.setProperty(key,value);
325	}	405	}
326	}	406	}
327		407

Return to bug 77163

Lines 15-33 Link Here

(-)src/org/aspectj/weaver/tools/WeavingAdaptor.java (-34 / +83 lines)
15		15
16	import java.io.File;	16	import java.io.File;
17	import java.io.IOException;	17	import java.io.IOException;
		18	import java.io.PrintWriter;
18	import java.net.URL;	19	import java.net.URL;
19	import java.net.URLClassLoader;	20	import java.net.URLClassLoader;
20	import java.util.ArrayList;	21	import java.util.ArrayList;
		22	import java.util.Comparator;
21	import java.util.HashMap;	23	import java.util.HashMap;
		24	import java.util.HashSet;
22	import java.util.Iterator;	25	import java.util.Iterator;
23	import java.util.LinkedList;	26	import java.util.LinkedList;
24	import java.util.List;	27	import java.util.List;
25	import java.util.Map;	28	import java.util.Map;
		29	import java.util.Set;
26	import java.util.StringTokenizer;	30	import java.util.StringTokenizer;
27		31
28	import org.aspectj.bridge.AbortException;	32	import org.aspectj.bridge.AbortException;
29	import org.aspectj.bridge.IMessage;	33	import org.aspectj.bridge.IMessage;
30	import org.aspectj.bridge.IMessageHandler;	34	import org.aspectj.bridge.IMessageHandler;
		35	import org.aspectj.bridge.MessageUtil;
		36	import org.aspectj.bridge.MessageWriter;
31	import org.aspectj.bridge.IMessage.Kind;	37	import org.aspectj.bridge.IMessage.Kind;
32	import org.aspectj.util.FileUtil;	38	import org.aspectj.util.FileUtil;
33	import org.aspectj.weaver.IClassFileProvider;	39	import org.aspectj.weaver.IClassFileProvider;
Lines 57-68 Link Here
57	* System property used to turn on verbose weaving messages	63	* System property used to turn on verbose weaving messages
58	*/	64	*/
59	public static final String WEAVING_ADAPTOR_VERBOSE = "aj.weaving.verbose";	65	public static final String WEAVING_ADAPTOR_VERBOSE = "aj.weaving.verbose";
		66	public static final String SHOW_WEAVE_INFO_PROPERTY = "org.aspectj.weaver.showWeaveInfo";
60		67
61	private boolean enabled = true;	68	private boolean enabled = true;
62	private boolean verbose = getVerbose();	69	private boolean verbose = getVerbose();
63	private BcelWorld bcelWorld = null;	70	private BcelWorld bcelWorld = null;
64	private BcelWeaver weaver = null;	71	private BcelWeaver weaver = null;
65	private IMessageHandler messageHandler = null;	72	private WeavingAdaptorMessageHandler messageHandler = null;
66	private GeneratedClassHandler generatedClassHandler;	73	private GeneratedClassHandler generatedClassHandler;
67	private Map generatedClasses = new HashMap(); /* String -> UnwovenClassFile */	74	private Map generatedClasses = new HashMap(); /* String -> UnwovenClassFile */
68		75
Lines 103-109 Link Here
103	list.addAll(0,FileUtil.makeClasspath(urls));	110	list.addAll(0,FileUtil.makeClasspath(urls));
104	}	111	}
105	else {	112	else {
106	if (verbose) System.err.println("WeavingAdaptor: Warning - could not determine classpath for " + loader);	113	warn("cannot determine classpath");
107	}	114	}
108	}	115	}
109		116
Lines 129-138 Link Here
129	}	136	}
130		137
131	private void init(List classPath, List aspectPath) {	138	private void init(List classPath, List aspectPath) {
132	if (verbose) System.out.println("WeavingAdaptor: classPath='" + classPath + "'");	139	messageHandler = new WeavingAdaptorMessageHandler(new PrintWriter(System.err));
		140	if (verbose) messageHandler.dontIgnore(IMessage.INFO);
		141	else messageHandler.ignore(IMessage.INFO);
		142	if (Boolean.getBoolean(SHOW_WEAVE_INFO_PROPERTY)) messageHandler.dontIgnore(IMessage.WEAVEINFO);
		143
		144	info("using classpath: " + classPath);
		145	info("using aspectpath: " + aspectPath);
133		146
134	// make sure the weaver can find all types...
135	messageHandler = new MessageHandler();
136	bcelWorld = new BcelWorld(classPath,messageHandler,null);	147	bcelWorld = new BcelWorld(classPath,messageHandler,null);
137	bcelWorld.setXnoInline(false);	148	bcelWorld.setXnoInline(false);
138	bcelWorld.getLint().loadDefaultProperties();	149	bcelWorld.getLint().loadDefaultProperties();
Lines 146-155 Link Here
146	* @param url to be appended to search path	157	* @param url to be appended to search path
147	*/	158	*/
148	public void addURL(URL url) {	159	public void addURL(URL url) {
		160	File libFile = new File(url.getPath());
149	try {	161	try {
150	weaver.addLibraryJarFile(new File(url.getPath()));	162	weaver.addLibraryJarFile(libFile);
151	}	163	}
152	catch (IOException ex) {	164	catch (IOException ex) {
		165	warn("bad library: '" + libFile + "'");
153	}	166	}
154	}	167	}
155		168
Lines 162-167 Link Here
162	*/	175	*/
163	public byte[] weaveClass (String name, byte[] bytes) throws IOException {	176	public byte[] weaveClass (String name, byte[] bytes) throws IOException {
164	if (shouldWeave(name)) {	177	if (shouldWeave(name)) {
		178	info("weaving '" + name + "'");
165	bytes = getWovenBytes(name, bytes);	179	bytes = getWovenBytes(name, bytes);
166	}	180	}
167	return bytes;	181	return bytes;
Lines 170-176 Link Here
170	private boolean shouldWeave (String name) {	184	private boolean shouldWeave (String name) {
171	name = name.replace('/','.');	185	name = name.replace('/','.');
172	boolean b = (enabled && !generatedClasses.containsKey(name) && shouldWeaveName(name) && shouldWeaveAspect(name));	186	boolean b = (enabled && !generatedClasses.containsKey(name) && shouldWeaveName(name) && shouldWeaveAspect(name));
173	if (verbose) System.out.println("WeavingAdaptor: shouldWeave('" + name + "') " + b);
174	return b;	187	return b;
175	}	188	}
176		189
Lines 209-229 Link Here
209	private void registerAspectLibraries(List aspectPath) {	222	private void registerAspectLibraries(List aspectPath) {
210	// System.err.println("? WeavingAdaptor.registerAspectLibraries(" + aspectPath + ")");	223	// System.err.println("? WeavingAdaptor.registerAspectLibraries(" + aspectPath + ")");
211	for (Iterator i = aspectPath.iterator(); i.hasNext();) {	224	for (Iterator i = aspectPath.iterator(); i.hasNext();) {
212	String lib = (String)i.next();	225	String libName = (String)i.next();
213	File libFile = new File(lib);	226	addAspectLibrary(libName);
214	if (libFile.isFile() && lib.endsWith(".jar")) {
215	try {
216	if (verbose) System.out.println("WeavingAdaptor: adding aspect '" + lib + "' to weaver");
217	addAspectLibrary(new File(lib));
218	} catch (IOException ioEx) {
219	if (verbose) System.err.println(
220	"WeavingAdaptor: Warning - could not load aspect path entry "
221	+ lib + " : " + ioEx);
222	}
223	} else {
224	if (verbose) System.err.println(
225	"WeavingAdaptor: Warning - ignoring aspect path entry: " + lib);
226	}
227	}	227	}
228		228
229	weaver.prepareForWeave();	229	weaver.prepareForWeave();
Lines 238-246 Link Here
238	* @param aspectLibraryJarFile a jar file representing an aspect library	238	* @param aspectLibraryJarFile a jar file representing an aspect library
239	* @throws IOException	239	* @throws IOException
240	*/	240	*/
241	private void addAspectLibrary(File aspectLibraryJarFile) throws IOException {	241	private void addAspectLibrary(String aspectLibraryName) {
242	weaver.addLibraryJarFile(aspectLibraryJarFile);	242	File aspectLibrary = new File(aspectLibraryName);
243	// weaver.prepareForWeave();	243	if (aspectLibrary.isFile() && aspectLibraryName.endsWith(".jar")) {
		244	try {
		245	info("adding aspect library: '" + aspectLibrary + "'");
		246	weaver.addLibraryJarFile(aspectLibrary);
		247	} catch (IOException ex) {
		248	error("exception adding aspect library: '" + ex + "'");
		249	}
		250	} else {
		251	error("bad aspect library: '" + aspectLibrary + "'");
		252	}
244	}	253	}
245		254
246	private static List makeClasspath(String cp) {	255	private static List makeClasspath(String cp) {
Lines 253-276 Link Here
253	}	262	}
254	return ret;	263	return ret;
255	}	264	}
		265
		266	private boolean info (String message) {
		267	return MessageUtil.info(messageHandler,message);
		268	}
		269
		270	private boolean warn (String message) {
		271	return MessageUtil.warn(messageHandler,message);
		272	}
		273
		274	private boolean error (String message) {
		275	return MessageUtil.error(messageHandler,message);
		276	}
256		277
257	/**	278	/**
258	* Processes messages arising from weaver operations.	279	* Processes messages arising from weaver operations.
259	* Tell weaver to abort on any non-informational error.	280	* Tell weaver to abort on any message more severe than warning.
260	*/	281	*/
261	private class MessageHandler implements IMessageHandler {	282	private class WeavingAdaptorMessageHandler extends MessageWriter {
		283
		284	private Set ignoring = new HashSet();
		285	private IMessage.Kind failKind;
		286
		287	public WeavingAdaptorMessageHandler (PrintWriter writer) {
		288	super(writer,true);
		289
		290	ignore(IMessage.WEAVEINFO);
		291	this.failKind = IMessage.ERROR;
		292
		293	}
262		294
263	public boolean handleMessage(IMessage message) throws AbortException {	295	public boolean handleMessage(IMessage message) throws AbortException {
264	if (!isIgnoring(message.getKind())) {	296	boolean result = super.handleMessage(message);
265	System.err.println(message.getSourceLocation()+": "+message.getKind()+" "+message.getMessage());	297	if (0 <= message.getKind().compareTo(failKind)) {
266	if (message.getKind() == IMessage.ERROR) throw new AbortException(message);	298	throw new AbortException(message);
		299	}
		300	return true;
		301	}
		302
		303	public boolean isIgnoring (Kind kind) {
		304	return ((null != kind) && (ignoring.contains(kind)));
		305	}
		306
		307	/**
		308	* Set a message kind to be ignored from now on
		309	*/
		310	public void ignore (IMessage.Kind kind) {
		311	if ((null != kind) && (!ignoring.contains(kind))) {
		312	ignoring.add(kind);
267	}	313	}
268	return true;
269	}	314	}
270		315
271	public boolean isIgnoring(Kind kind) {	316	/**
272	if (verbose) return false;	317	* Remove a message kind from the list of those ignored from now on.
273	else return ((kind == IMessage.INFO) \|\| (kind == IMessage.DEBUG));	318	*/
		319	public void dontIgnore (IMessage.Kind kind) {
		320	if (null != kind) {
		321	ignoring.remove(kind);
		322	}
274	}	323	}
275	}	324	}
276		325