org.aspectj/weaver/src/org/aspectj/weaver/bcel/BcelWeaver.java

/* *******************************************************************
 * Copyright (c) 2002 Palo Alto Research Center, Incorporated (PARC).
 * 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:
 *     PARC     initial implementation
 *     Alexandre Vasseur    support for @AJ aspects
 * ******************************************************************/


package org.aspectj.weaver.bcel;


import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileFilter;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.jar.Attributes;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
import java.util.jar.Manifest;
import java.util.jar.Attributes.Name;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;
import java.util.zip.ZipOutputStream;

import org.aspectj.apache.bcel.classfile.ClassParser;
import org.aspectj.apache.bcel.classfile.JavaClass;
import org.aspectj.bridge.IMessage;
import org.aspectj.bridge.IProgressListener;
import org.aspectj.bridge.ISourceLocation;
import org.aspectj.bridge.Message;
import org.aspectj.bridge.MessageUtil;
import org.aspectj.bridge.SourceLocation;
import org.aspectj.bridge.WeaveMessage;
import org.aspectj.util.FileUtil;
import org.aspectj.util.FuzzyBoolean;
import org.aspectj.weaver.Advice;
import org.aspectj.weaver.AnnotationOnTypeMunger;
import org.aspectj.weaver.AnnotationX;
import org.aspectj.weaver.AsmRelationshipProvider;
import org.aspectj.weaver.ConcreteTypeMunger;
import org.aspectj.weaver.CrosscuttingMembersSet;
import org.aspectj.weaver.IClassFileProvider;
import org.aspectj.weaver.IWeaveRequestor;
import org.aspectj.weaver.IWeaver;
import org.aspectj.weaver.NewParentTypeMunger;
import org.aspectj.weaver.ResolvedTypeMunger;
import org.aspectj.weaver.ResolvedTypeX;
import org.aspectj.weaver.ShadowMunger;
import org.aspectj.weaver.TypeX;
import org.aspectj.weaver.WeaverMessages;
import org.aspectj.weaver.WeaverMetrics;
import org.aspectj.weaver.WeaverStateInfo;
import org.aspectj.weaver.World;
import org.aspectj.weaver.patterns.AndPointcut;
import org.aspectj.weaver.patterns.BindingAnnotationTypePattern;
import org.aspectj.weaver.patterns.BindingTypePattern;
import org.aspectj.weaver.patterns.CflowPointcut;
import org.aspectj.weaver.patterns.ConcreteCflowPointcut;
import org.aspectj.weaver.patterns.DeclareAnnotation;
import org.aspectj.weaver.patterns.DeclareParents;
import org.aspectj.weaver.patterns.FastMatchInfo;
import org.aspectj.weaver.patterns.IfPointcut;
import org.aspectj.weaver.patterns.KindedPointcut;
import org.aspectj.weaver.patterns.NameBindingPointcut;
import org.aspectj.weaver.patterns.NotPointcut;
import org.aspectj.weaver.patterns.OrPointcut;
import org.aspectj.weaver.patterns.Pointcut;
import org.aspectj.weaver.patterns.PointcutRewriter;
import org.aspectj.weaver.patterns.WithinPointcut;


public class BcelWeaver implements IWeaver {
    private BcelWorld world;
    private CrosscuttingMembersSet xcutSet;
    private IProgressListener progressListener = null;
    private double progressMade;
    private double progressPerClassFile;

    private boolean inReweavableMode = false;
    
    public BcelWeaver(BcelWorld world) {
        super();
        WeaverMetrics.reset();
        this.world = world;
        this.xcutSet = world.getCrosscuttingMembersSet();
    }
        
    public BcelWeaver() {
    	this(new BcelWorld());
    }

	// ---- fields	
//    private Map  sourceJavaClasses = new HashMap();   /* String -> UnwovenClassFile */
    private List addedClasses      = new ArrayList(); /* List<UnovenClassFile> */
    private List deletedTypenames  = new ArrayList(); /* List<String> */
//	private Map  resources         = new HashMap(); /* String -> UnwovenClassFile */ 
	private Manifest manifest = null;
    private boolean needToReweaveWorld = false;

    private List shadowMungerList = null; // setup by prepareForWeave
	private List typeMungerList = null; // setup by prepareForWeave 
	private List declareParentsList = null; // setup by prepareForWeave 

    private ZipOutputStream zipOutputStream;

	// ----
    
	// only called for testing
    public void setShadowMungers(List l) {
        shadowMungerList = l;
    }


    /**
     * Add the given aspect to the weaver.
     * The type is resolved to support DOT for static inner classes as well as DOLLAR
     *
     * @param aspectName
     */
    public void addLibraryAspect(String aspectName) {
        // 1 - resolve as is
        ResolvedTypeX type = world.resolve(TypeX.forName(aspectName), true);
        if (type.equals(ResolvedTypeX.MISSING)) {
            // fallback on inner class lookup mechanism
            String fixedName = aspectName;
            int hasDot = fixedName.lastIndexOf('.');
            while (hasDot > 0) {
                //System.out.println("BcelWeaver.addLibraryAspect " + fixedName);
                char[] fixedNameChars = fixedName.toCharArray();
                fixedNameChars[hasDot] = '$';
                fixedName = new String(fixedNameChars);
                hasDot = fixedName.lastIndexOf('.');
                type = world.resolve(TypeX.forName(fixedName), true);
                if (!type.equals(ResolvedTypeX.MISSING)) {
                    break;
                }
            }
        }

    	//System.out.println("type: " + type + " for " + aspectName);
		if (type.isAspect()) {
			xcutSet.addOrReplaceAspect(type);
		} else {
            // FIXME : Alex: better warning upon no such aspect from aop.xml
			throw new RuntimeException("Cannot register non aspect: " + type.getName() + " , " + aspectName);
		}
    }
    


	public void addLibraryJarFile(File inFile) throws IOException  {
		List addedAspects = null;
		if (inFile.isDirectory()) {
			addedAspects = addAspectsFromDirectory(inFile);
		} else {
			addedAspects = addAspectsFromJarFile(inFile);
		}
		
		for (Iterator i = addedAspects.iterator(); i.hasNext();) {
			ResolvedTypeX aspectX = (ResolvedTypeX) i.next();
			xcutSet.addOrReplaceAspect(aspectX);
		}
	}

	private List addAspectsFromJarFile(File inFile) throws FileNotFoundException, IOException {
		ZipInputStream inStream = new ZipInputStream(new FileInputStream(inFile)); //??? buffered
		List addedAspects = new ArrayList();
		while (true) {
			ZipEntry entry = inStream.getNextEntry();
			if (entry == null) break;
			
			if (entry.isDirectory() || !entry.getName().endsWith(".class")) {
				continue;
			}
			
			// FIXME ASC performance? of this alternative soln.
			ClassParser parser = new ClassParser(new ByteArrayInputStream(FileUtil.readAsByteArray(inStream)), entry.getName());
	        JavaClass jc = parser.parse();
			inStream.closeEntry();
			
			ResolvedTypeX type = world.addSourceObjectType(jc).getResolvedTypeX();
    		if (type.isAspect()) {
    			addedAspects.add(type);
    		}
			
		}
		
		inStream.close();
		return addedAspects;
	}

	private List addAspectsFromDirectory(File dir) throws FileNotFoundException, IOException{
		List addedAspects = new ArrayList();
		File[] classFiles = FileUtil.listFiles(dir,new FileFilter(){
		
			public boolean accept(File pathname) {
				return pathname.getName().endsWith(".class");
			}
		
		});
		for (int i = 0; i < classFiles.length; i++) {
			FileInputStream fis = new FileInputStream(classFiles[i]);
			byte[] bytes = FileUtil.readAsByteArray(fis);
			addIfAspect(bytes,classFiles[i].getAbsolutePath(),addedAspects);
		}
		return addedAspects;
	}
	
	private void addIfAspect(byte[] bytes, String name, List toList) throws IOException {
		ClassParser parser = new ClassParser(new ByteArrayInputStream(bytes),name);
		JavaClass jc = parser.parse();
		ResolvedTypeX type = world.addSourceObjectType(jc).getResolvedTypeX();
		if (type.isAspect()) {
			toList.add(type);
		}		
	}


//	// The ANT copy task should be used to copy resources across.
//	private final static boolean CopyResourcesFromInpathDirectoriesToOutput=false;
	private Set alreadyConfirmedReweavableState;
	
	/**
	 * Add any .class files in the directory to the outdir.  Anything other than .class files in
	 * the directory (or its subdirectories) are considered resources and are also copied. 
	 *  
	 */
	public List addDirectoryContents(File inFile,File outDir) throws IOException {
		List addedClassFiles = new ArrayList();
		
		// Get a list of all files (i.e. everything that isnt a directory)
		File[] files = FileUtil.listFiles(inFile,new FileFilter() {
			public boolean accept(File f) {
				boolean accept = !f.isDirectory();
				return accept;
			}
		});
		
		// For each file, add it either as a real .class file or as a resource
		for (int i = 0; i < files.length; i++) {
			addedClassFiles.add(addClassFile(files[i],inFile,outDir));
		}
		
		return addedClassFiles;
	}


	/** Adds all class files in the jar
	 */
	public List addJarFile(File inFile, File outDir, boolean canBeDirectory){
//		System.err.println("? addJarFile(" + inFile + ", " + outDir + ")");
		List addedClassFiles = new ArrayList();
		needToReweaveWorld = true;
		JarFile inJar = null;
		
		try {
			// Is this a directory we are looking at?
			if (inFile.isDirectory() && canBeDirectory) {
				addedClassFiles.addAll(addDirectoryContents(inFile,outDir));
			} else {
			
				inJar = new JarFile(inFile);
				addManifest(inJar.getManifest());
				Enumeration entries = inJar.entries();
			
				while (entries.hasMoreElements()) {
					JarEntry entry = (JarEntry)entries.nextElement();
					InputStream inStream = inJar.getInputStream(entry);
					
					byte[] bytes = FileUtil.readAsByteArray(inStream);
					String filename = entry.getName();
//					System.out.println("? addJarFile() filename='" + filename + "'");
					UnwovenClassFile classFile = new UnwovenClassFile(new File(outDir, filename).getAbsolutePath(), bytes);

					if (filename.endsWith(".class")) {
						this.addClassFile(classFile);
						addedClassFiles.add(classFile);
					}
//					else if (!entry.isDirectory()) {
//
//						/* bug-44190 Copy meta-data */
//						addResource(filename,classFile);
//					}

					inStream.close();
				}
				inJar.close();
			}
		} catch (FileNotFoundException ex) {
			IMessage message = new Message(
					"Could not find input jar file " + inFile.getPath() + ", ignoring",
					new SourceLocation(inFile,0),
					false);
			world.getMessageHandler().handleMessage(message);
		} catch (IOException ex) {
			IMessage message = new Message(
					"Could not read input jar file " + inFile.getPath() + "(" + ex.getMessage() + ")",
					new SourceLocation(inFile,0),
					true);
			world.getMessageHandler().handleMessage(message);
		} finally {
			if (inJar != null) {
				try {inJar.close();}
				catch (IOException ex) {
					IMessage message = new Message(
							"Could not close input jar file " + inFile.getPath() + "(" + ex.getMessage() + ")",
							new SourceLocation(inFile,0),
							true);					
					world.getMessageHandler().handleMessage(message);					
				}
			}
		}
		
		return addedClassFiles;
	}

//	public void addResource(String name, File inPath, File outDir) throws IOException {
//
//		/* Eliminate CVS files. Relative paths use "/" */
//		if (!name.startsWith("CVS/") && (-1 == name.indexOf("/CVS/")) && !name.endsWith("/CVS")) {
////			System.err.println("? addResource('" + name + "')");
////			BufferedInputStream inStream = new BufferedInputStream(new FileInputStream(inPath));
////			byte[] bytes = new byte[(int)inPath.length()];
////			inStream.read(bytes);
////			inStream.close();
//			byte[] bytes = FileUtil.readAsByteArray(inPath);
//			UnwovenClassFile resourceFile = new UnwovenClassFile(new File(outDir, name).getAbsolutePath(), bytes);
//			addResource(name,resourceFile);
//		}
//	}

	public boolean needToReweaveWorld() {
		return needToReweaveWorld;
	}
	
    /** Should be addOrReplace
     */
    public void addClassFile(UnwovenClassFile classFile) {
    	addedClasses.add(classFile);
//    	if (null != sourceJavaClasses.put(classFile.getClassName(), classFile)) {
////    		throw new RuntimeException(classFile.getClassName());
//    	}
    	world.addSourceObjectType(classFile.getJavaClass());
    }
    
    public UnwovenClassFile addClassFile(File classFile, File inPathDir, File outDir) throws IOException {
		FileInputStream fis = new FileInputStream(classFile);
		byte[] bytes = FileUtil.readAsByteArray(fis);
		// String relativePath = files[i].getPath();
		
		// ASSERT: files[i].getAbsolutePath().startsWith(inFile.getAbsolutePath()
		// or we are in trouble...
		String filename = classFile.getAbsolutePath().substring(
		                    inPathDir.getAbsolutePath().length()+1);
		UnwovenClassFile ucf = new UnwovenClassFile(new File(outDir,filename).getAbsolutePath(),bytes);
		if (filename.endsWith(".class")) {
			// System.err.println("BCELWeaver: processing class from input directory "+classFile);
			this.addClassFile(ucf);
		}
		fis.close();
		return ucf;
    }


    public void deleteClassFile(String typename) {
    	deletedTypenames.add(typename);
//    	sourceJavaClasses.remove(typename);
    	world.deleteSourceObjectType(TypeX.forName(typename));
    }

//	public void addResource (String name, UnwovenClassFile resourceFile) {
//		/* bug-44190 Change error to warning and copy first resource */
//		if (!resources.containsKey(name)) {
//			resources.put(name, resourceFile);
//		}
//		else {
//			world.showMessage(IMessage.WARNING, "duplicate resource: '" + name + "'",
//				null, null);
//		}
//	}

	// ---- weave preparation

    public void prepareForWeave() {
    	needToReweaveWorld = false;

    	CflowPointcut.clearCaches();
    	
    	// update mungers
    	for (Iterator i = addedClasses.iterator(); i.hasNext(); ) { 
    		UnwovenClassFile jc = (UnwovenClassFile)i.next();
    		String name = jc.getClassName();
    		ResolvedTypeX type = world.resolve(name);
    		//System.err.println("added: " + type + " aspect? " + type.isAspect());
    		if (type.isAspect()) {
    			needToReweaveWorld |= xcutSet.addOrReplaceAspect(type);
    		}
    	}

    	for (Iterator i = deletedTypenames.iterator(); i.hasNext(); ) { 
    		String name = (String)i.next();
    		if (xcutSet.deleteAspect(TypeX.forName(name))) needToReweaveWorld = true;
    	}

		shadowMungerList = xcutSet.getShadowMungers();
		rewritePointcuts(shadowMungerList);
		typeMungerList = xcutSet.getTypeMungers();
		declareParentsList = xcutSet.getDeclareParents();
    	
		// The ordering here used to be based on a string compare on toString() for the two mungers - 
		// that breaks for the @AJ style where advice names aren't programmatically generated.  So we
		// have changed the sorting to be based on source location in the file - this is reliable, in
		// the case of source locations missing, we assume they are 'sorted' - i.e. the order in
		// which they were added to the collection is correct, this enables the @AJ stuff to work properly.
		
		// When @AJ processing starts filling in source locations for mungers, this code may need
		// a bit of alteration...
				
		Collections.sort(
			shadowMungerList,
			new Comparator() {
				public int compare(Object o1, Object o2) {
					ShadowMunger sm1 = (ShadowMunger)o1;
					ShadowMunger sm2 = (ShadowMunger)o2;
					if (sm1.getSourceLocation()==null) return (sm2.getSourceLocation()==null?0:1);
					if (sm2.getSourceLocation()==null) return -1;
					
					return (sm2.getSourceLocation().getOffset()-sm1.getSourceLocation().getOffset());
				}
			});
    }
    
    /*
     * Rewrite all of the pointcuts in the world into their most efficient
     * form for subsequent matching. Also ensure that if pc1.equals(pc2)
     * then pc1 == pc2 (for non-binding pcds) by making references all 
     * point to the same instance.
     * Since pointcuts remember their match decision on the last shadow, 
     * this makes matching faster when many pointcuts share common elements,
     * or even when one single pointcut has one common element (which can
     * be a side-effect of DNF rewriting).
     */
    private void rewritePointcuts(List/*ShadowMunger*/ shadowMungers) {
    	PointcutRewriter rewriter = new PointcutRewriter();
    	for (Iterator iter = shadowMungers.iterator(); iter.hasNext();) {
			ShadowMunger munger = (ShadowMunger) iter.next();
			Pointcut p = munger.getPointcut();
			Pointcut newP = rewriter.rewrite(p);
			// validateBindings now whilst we still have around the pointcut
			// that resembles what the user actually wrote in their program
		    // text.
			if (munger instanceof Advice) {
				Advice advice = (Advice) munger;
				if (advice.getSignature() != null) {
					final int numFormals;
                    final String names[];
                    //ATAJ for @AJ aspect, the formal have to be checked according to the argument number
                    // since xxxJoinPoint presence or not have side effects
                    if (advice.getConcreteAspect().isAnnotationStyleAspect()) {
                        numFormals = advice.getBaseParameterCount();
                        int numArgs = advice.getSignature().getParameterTypes().length;
                        if (numFormals > 0) {
                            names = advice.getSignature().getParameterNames(world);
                            validateBindings(newP,p,numArgs,names);
                        }
                    } else {
                        numFormals = advice.getBaseParameterCount();
                        if (numFormals > 0) {
                            names = advice.getBaseParameterNames(world);
                            validateBindings(newP,p,numFormals,names);
                        }
                    }
				}
			}
			munger.setPointcut(newP);
		}
    	// now that we have optimized individual pointcuts, optimize
    	// across the set of pointcuts....
    	// Use a map from key based on pc equality, to value based on
    	// pc identity.
    	Map/*<Pointcut,Pointcut>*/ pcMap = new HashMap();
    	for (Iterator iter = shadowMungers.iterator(); iter.hasNext();) {
			ShadowMunger munger = (ShadowMunger) iter.next();
			Pointcut p = munger.getPointcut();
			munger.setPointcut(shareEntriesFromMap(p,pcMap));
		}    	
    }
    
    private Pointcut shareEntriesFromMap(Pointcut p,Map pcMap) {
    	// some things cant be shared...
    	if (p instanceof NameBindingPointcut) return p;
    	if (p instanceof IfPointcut) return p;
    	if (p instanceof ConcreteCflowPointcut) return p;
    	if (p instanceof AndPointcut) {
    		AndPointcut apc = (AndPointcut) p;
    		Pointcut left = shareEntriesFromMap(apc.getLeft(),pcMap);
    		Pointcut right = shareEntriesFromMap(apc.getRight(),pcMap);
    		return new AndPointcut(left,right);
    	} else if (p instanceof OrPointcut) {
    		OrPointcut opc = (OrPointcut) p;
    		Pointcut left = shareEntriesFromMap(opc.getLeft(),pcMap);
    		Pointcut right = shareEntriesFromMap(opc.getRight(),pcMap);
    		return new OrPointcut(left,right);
    	} else if (p instanceof NotPointcut) {
    		NotPointcut npc = (NotPointcut) p;
    		Pointcut not = shareEntriesFromMap(npc.getNegatedPointcut(),pcMap);
    		return new NotPointcut(not);
    	} else {
    		// primitive pcd
    		if (pcMap.containsKey(p)) { // based on equality
    			return (Pointcut) pcMap.get(p);  // same instance (identity)
    		} else {
    			pcMap.put(p,p);
    			return p;
    		}
    	}
    }
    
    // userPointcut is the pointcut that the user wrote in the program text.
    // dnfPointcut is the same pointcut rewritten in DNF 
    // numFormals is the number of formal parameters in the pointcut
    // if numFormals > 0 then every branch of a disjunction must bind each formal once and only once.
    // in addition, the left and right branches of a disjunction must hold on join point kinds in 
    // common.
    private void validateBindings(Pointcut dnfPointcut, Pointcut userPointcut, int numFormals, String[] names) {
    	if (numFormals == 0) return; // nothing to check
    	if (dnfPointcut.couldMatchKinds().isEmpty()) return; // cant have problems if you dont match!
    	if (dnfPointcut instanceof OrPointcut) {
    		OrPointcut orBasedDNFPointcut = (OrPointcut) dnfPointcut;
    		Pointcut[] leftBindings = new Pointcut[numFormals];
    		Pointcut[] rightBindings = new Pointcut[numFormals];
    		validateOrBranch(orBasedDNFPointcut,userPointcut,numFormals,names,leftBindings,rightBindings);
    	} else {
    		Pointcut[] bindings = new Pointcut[numFormals];
    		validateSingleBranch(dnfPointcut, userPointcut, numFormals, names,bindings);
    	}
    }
    
    private void validateOrBranch(OrPointcut pc, Pointcut userPointcut, int numFormals, 
    		String[] names, Pointcut[] leftBindings, Pointcut[] rightBindings) {
    	Pointcut left = pc.getLeft();
    	Pointcut right = pc.getRight();
    	if (left instanceof OrPointcut) {
    		Pointcut[] newRightBindings = new Pointcut[numFormals];
    		validateOrBranch((OrPointcut)left,userPointcut,numFormals,names,leftBindings,newRightBindings);    		
    	} else {
    		if (left.couldMatchKinds().size() > 0)
    			validateSingleBranch(left, userPointcut, numFormals, names, leftBindings);
    	}
    	if (right instanceof OrPointcut) {
    		Pointcut[] newLeftBindings = new Pointcut[numFormals];
    		validateOrBranch((OrPointcut)right,userPointcut,numFormals,names,newLeftBindings,rightBindings);
    	} else {
    		if (right.couldMatchKinds().size() > 0)
    			validateSingleBranch(right, userPointcut, numFormals, names, rightBindings);    		
    	}
		Set kindsInCommon = left.couldMatchKinds();
		kindsInCommon.retainAll(right.couldMatchKinds());
		if (!kindsInCommon.isEmpty() && couldEverMatchSameJoinPoints(left,right)) {
			// we know that every branch binds every formal, so there is no ambiguity
			// if each branch binds it in exactly the same way...
			List ambiguousNames = new ArrayList();
			for (int i = 0; i < numFormals; i++) {
				if (!leftBindings[i].equals(rightBindings[i])) {
					ambiguousNames.add(names[i]);
				}
			}
			if (!ambiguousNames.isEmpty())
				raiseAmbiguityInDisjunctionError(userPointcut,ambiguousNames);
		}    	
    }
    
	// pc is a pointcut that does not contain any disjunctions
    // check that every formal is bound (negation doesn't count).
    // we know that numFormals > 0 or else we would not be called
    private void validateSingleBranch(Pointcut pc, Pointcut userPointcut, int numFormals, String[] names, Pointcut[] bindings) {
    	boolean[] foundFormals = new boolean[numFormals];
    	for (int i = 0; i < foundFormals.length; i++) {
			foundFormals[i] = false;
		}
    	validateSingleBranchRecursion(pc, userPointcut, foundFormals, names, bindings);
    	for (int i = 0; i < foundFormals.length; i++) {
			if (!foundFormals[i]) {
                boolean ignore = false;
                // ATAJ soften the unbound error for implicit bindings like JoinPoint in @AJ style
                for (int j = 0; j < userPointcut.m_ignoreUnboundBindingForNames.length; j++) {
                    if (names[i] != null && names[i].equals(userPointcut.m_ignoreUnboundBindingForNames[j])) {
                        ignore = true;
                        break;
                    }
                }
                if (!ignore) {
                    raiseUnboundFormalError(names[i],userPointcut);
                }
			}
		}
    }
    
	// each formal must appear exactly once
    private void validateSingleBranchRecursion(Pointcut pc, Pointcut userPointcut, boolean[] foundFormals, String[] names, Pointcut[] bindings) {
    	if (pc instanceof NotPointcut) {
    		// nots can only appear at leaves in DNF
    		NotPointcut not = (NotPointcut) pc;
    		if (not.getNegatedPointcut() instanceof NameBindingPointcut) {
    			NameBindingPointcut nnbp = (NameBindingPointcut) not.getNegatedPointcut();
    			if (!nnbp.getBindingAnnotationTypePatterns().isEmpty() && !nnbp.getBindingTypePatterns().isEmpty())
    				raiseNegationBindingError(userPointcut);
    		}
    	} else if (pc instanceof AndPointcut) {
    		AndPointcut and = (AndPointcut) pc;
    		validateSingleBranchRecursion(and.getLeft(), userPointcut,foundFormals,names,bindings);
    		validateSingleBranchRecursion(and.getRight(),userPointcut,foundFormals,names,bindings);
    	} else if (pc instanceof NameBindingPointcut) {
    		List/*BindingTypePattern*/ btps = ((NameBindingPointcut)pc).getBindingTypePatterns();
    		for (Iterator iter = btps.iterator(); iter.hasNext();) {
				BindingTypePattern btp = (BindingTypePattern) iter.next();
				int index = btp.getFormalIndex();
				bindings[index] = pc; 
				if (foundFormals[index]) {
					raiseAmbiguousBindingError(names[index],userPointcut);
				} else {
					foundFormals[index] = true;
				}
			}
    		List/*BindingAnnotationTypePattern*/ baps = ((NameBindingPointcut)pc).getBindingAnnotationTypePatterns();
    		for (Iterator iter = baps.iterator(); iter.hasNext();) {
				BindingAnnotationTypePattern bap = (BindingAnnotationTypePattern) iter.next();
				int index = bap.getFormalIndex();
				bindings[index] = pc;
				if (foundFormals[index]) {
					raiseAmbiguousBindingError(names[index],userPointcut);
				} else {
					foundFormals[index] = true;
				}
			}
    	} else if (pc instanceof ConcreteCflowPointcut) {
    		ConcreteCflowPointcut cfp = (ConcreteCflowPointcut) pc;
    		int[] slots = cfp.getUsedFormalSlots();
    		for (int i = 0; i < slots.length; i++) {
    			bindings[slots[i]] = cfp;
				if (foundFormals[slots[i]]) {
					raiseAmbiguousBindingError(names[slots[i]],userPointcut);
				} else {
					foundFormals[slots[i]] = true;
				}				
			}
    	}
    }
    
    
    // By returning false from this method, we are allowing binding of the same
    // variable on either side of an or.
    // Be conservative :- have to consider overriding, varargs, autoboxing,
    // the effects of itds (on within for example), interfaces, the fact that
    // join points can have multiple signatures and so on.
    private boolean couldEverMatchSameJoinPoints(Pointcut left, Pointcut right) {
    	if ((left instanceof OrPointcut) || (right instanceof OrPointcut)) return true;
    	// look for withins
    	WithinPointcut leftWithin = (WithinPointcut) findFirstPointcutIn(left,WithinPointcut.class);
    	WithinPointcut rightWithin = (WithinPointcut) findFirstPointcutIn(right,WithinPointcut.class);
    	if ((leftWithin != null) && (rightWithin != null)) {
    		if (!leftWithin.couldEverMatchSameJoinPointsAs(rightWithin)) return false;
    	}
    	// look for kinded
    	KindedPointcut leftKind = (KindedPointcut) findFirstPointcutIn(left,KindedPointcut.class);
    	KindedPointcut rightKind = (KindedPointcut) findFirstPointcutIn(right,KindedPointcut.class);
    	if ((leftKind != null) && (rightKind != null)) {
    		if (!leftKind.couldEverMatchSameJoinPointsAs(rightKind)) return false;
    	}
    	return true;
    }
    
    private Pointcut findFirstPointcutIn(Pointcut toSearch, Class toLookFor) {
    	if (toSearch instanceof NotPointcut) return null;
    	if (toLookFor.isInstance(toSearch)) return toSearch;
    	if (toSearch instanceof AndPointcut) {
    		AndPointcut apc = (AndPointcut) toSearch;
    		Pointcut left = findFirstPointcutIn(apc.getLeft(),toLookFor);
    		if (left != null) return left;
    		return findFirstPointcutIn(apc.getRight(),toLookFor);
    	}
    	return null;
    }
    
    /**
	 * @param userPointcut
	 */
	private void raiseNegationBindingError(Pointcut userPointcut) {
		world.showMessage(IMessage.ERROR,
				WeaverMessages.format(WeaverMessages.NEGATION_DOESNT_ALLOW_BINDING),
				userPointcut.getSourceContext().makeSourceLocation(userPointcut),null);
	}

	/**
	 * @param name
	 * @param userPointcut
	 */
	private void raiseAmbiguousBindingError(String name, Pointcut userPointcut) {
		world.showMessage(IMessage.ERROR,
				WeaverMessages.format(WeaverMessages.AMBIGUOUS_BINDING,
										name),
				userPointcut.getSourceContext().makeSourceLocation(userPointcut),null);
	}

	/**
	 * @param userPointcut
	 */
	private void raiseAmbiguityInDisjunctionError(Pointcut userPointcut, List names) {
		StringBuffer formalNames = new StringBuffer(names.get(0).toString());
		for (int i = 1; i < names.size(); i++) {
			formalNames.append(", ");
			formalNames.append(names.get(i));
		}
		world.showMessage(IMessage.ERROR,
				WeaverMessages.format(WeaverMessages.AMBIGUOUS_BINDING_IN_OR,formalNames),
				userPointcut.getSourceContext().makeSourceLocation(userPointcut),null);
	}

    /**
	 * @param name
	 * @param userPointcut
	 */
	private void raiseUnboundFormalError(String name, Pointcut userPointcut) {
		world.showMessage(IMessage.ERROR,
				WeaverMessages.format(WeaverMessages.UNBOUND_FORMAL,
										name),
				userPointcut.getSourceContext().makeSourceLocation(userPointcut),null);
	}


//    public void dumpUnwoven(File file) throws IOException {
//    	BufferedOutputStream os = FileUtil.makeOutputStream(file);
//    	this.zipOutputStream = new ZipOutputStream(os);
//    	dumpUnwoven();
//		/* BUG 40943*/
//		dumpResourcesToOutJar();
//    	zipOutputStream.close();  //this flushes and closes the acutal file
//    }
//    
//    
//    public void dumpUnwoven() throws IOException {
//    	Collection filesToDump = new HashSet(sourceJavaClasses.values());
//    	for (Iterator i = filesToDump.iterator(); i.hasNext(); ) {
//            UnwovenClassFile classFile = (UnwovenClassFile)i.next();
//            dumpUnchanged(classFile);
//       	}
//    }
    
//	public void dumpResourcesToOutPath() throws IOException {
////		System.err.println("? dumpResourcesToOutPath() resources=" + resources.keySet());
//		Iterator i = resources.keySet().iterator();
//		while (i.hasNext()) {
//			UnwovenClassFile res = (UnwovenClassFile)resources.get(i.next());
//			dumpUnchanged(res);
//		}
//		//resources = new HashMap();
//	}
//
	/* BUG #40943 */
//    public void dumpResourcesToOutJar() throws IOException {
////		System.err.println("? dumpResourcesToOutJar() resources=" + resources.keySet());
//		Iterator i = resources.keySet().iterator();
//		while (i.hasNext()) {
//			String name = (String)i.next();
//			UnwovenClassFile res = (UnwovenClassFile)resources.get(name);
//			writeZipEntry(name,res.getBytes());
//		}
//		resources = new HashMap();
//    }
//    
//    // halfway house for when the jar is managed outside of the weaver, but the resources
//    // to be copied are known in the weaver.
//    public void dumpResourcesToOutJar(ZipOutputStream zos) throws IOException {
//    	this.zipOutputStream = zos;
//    	dumpResourcesToOutJar();
//    }
    
	public void addManifest (Manifest newManifest) {
//		System.out.println("? addManifest() newManifest=" + newManifest);
		if (manifest == null) {
			manifest = newManifest;
		}
	}
	
	public static final String MANIFEST_NAME = "META-INF/MANIFEST.MF";
	
	private static final String WEAVER_MANIFEST_VERSION = "1.0";
	private static final Attributes.Name CREATED_BY = new Name("Created-By");
	private static final String WEAVER_CREATED_BY = "AspectJ Compiler";
    
    public Manifest getManifest (boolean shouldCreate) {
		
		if (manifest == null && shouldCreate) {
			manifest = new Manifest();

			Attributes attributes = manifest.getMainAttributes();
			attributes.put(Name.MANIFEST_VERSION,WEAVER_MANIFEST_VERSION);
			attributes.put(CREATED_BY,WEAVER_CREATED_BY);
		}
		
		return manifest;
    }
    
    // ---- weaving

    // Used by some test cases only...
    public Collection weave(File file) throws IOException {
    	OutputStream os = FileUtil.makeOutputStream(file);
    	this.zipOutputStream = new ZipOutputStream(os);
    	prepareForWeave();
    	Collection c = weave( new IClassFileProvider() {

			public Iterator getClassFileIterator() {
				return addedClasses.iterator();
			}

			public IWeaveRequestor getRequestor() {
				return new IWeaveRequestor() {
					public void acceptResult(UnwovenClassFile result) {
						try {
							writeZipEntry(result.filename, result.bytes);
						} catch(IOException ex) {}
					}
					public void processingReweavableState() {}
					public void addingTypeMungers() {}
					public void weavingAspects() {}
					public void weavingClasses() {}
					public void weaveCompleted() {}
				};
			}
		});
//    	/* BUG 40943*/
//    	dumpResourcesToOutJar();
    	zipOutputStream.close();  //this flushes and closes the acutal file
    	return c;
    }
    
//    public Collection weave() throws IOException {
//    	prepareForWeave();
//    	Collection filesToWeave;
//    	
//    	if (needToReweaveWorld) {
//    		filesToWeave = sourceJavaClasses.values();
//    	} else {
//    		filesToWeave = addedClasses;
//    	}
//    	
//    	Collection wovenClassNames = new ArrayList();
//    	world.showMessage(IMessage.INFO, "might need to weave " + filesToWeave + 
//    					"(world=" + needToReweaveWorld + ")", null, null);
//    	
//    	
//    	//System.err.println("typeMungers: " + typeMungerList);
//    	
//    	prepareToProcessReweavableState();
//		// clear all state from files we'll be reweaving
//        for (Iterator i = filesToWeave.iterator(); i.hasNext(); ) {
//            UnwovenClassFile classFile = (UnwovenClassFile)i.next();
//	    	String className = classFile.getClassName();
//            BcelObjectType classType = getClassType(className);			            
//			processReweavableStateIfPresent(className, classType);
//        }
//    	
//    	
//    	
//    	//XXX this isn't quite the right place for this...
//    	for (Iterator i = filesToWeave.iterator(); i.hasNext(); ) {
//            UnwovenClassFile classFile = (UnwovenClassFile)i.next();
//            String className = classFile.getClassName();
//            addTypeMungers(className);
//        }
//    	
//		// first weave into aspects
//        for (Iterator i = filesToWeave.iterator(); i.hasNext(); ) {
//            UnwovenClassFile classFile = (UnwovenClassFile)i.next();
//	    	String className = classFile.getClassName();
//            BcelObjectType classType = BcelWorld.getBcelObjectType(world.resolve(className));
//            if (classType.isAspect()) {
//	            weave(classFile, classType);
//	            wovenClassNames.add(className);
//            }
//        }
//
//		// then weave into non-aspects
//		for (Iterator i = filesToWeave.iterator(); i.hasNext(); ) {
//            UnwovenClassFile classFile = (UnwovenClassFile)i.next();
//	    	String className = classFile.getClassName();
//            BcelObjectType classType = BcelWorld.getBcelObjectType(world.resolve(className));
//            if (! classType.isAspect()) {
//	            weave(classFile, classType);
//	            wovenClassNames.add(className);
//            }
//        }
//        
//        if (zipOutputStream != null && !needToReweaveWorld) {
//        	Collection filesToDump = new HashSet(sourceJavaClasses.values());
//        	filesToDump.removeAll(filesToWeave);
//        	for (Iterator i = filesToDump.iterator(); i.hasNext(); ) {
//                UnwovenClassFile classFile = (UnwovenClassFile)i.next();
//                dumpUnchanged(classFile);
//        	}
//        }
//        
//        addedClasses = new ArrayList();
//    	deletedTypenames = new ArrayList();
//		
//        return wovenClassNames;
//    }
    
    // variation of "weave" that sources class files from an external source.
    public Collection weave(IClassFileProvider input) throws IOException {
    	Collection wovenClassNames = new ArrayList();
    	IWeaveRequestor requestor = input.getRequestor();

    	requestor.processingReweavableState();
		prepareToProcessReweavableState();
		// clear all state from files we'll be reweaving
		for (Iterator i = input.getClassFileIterator(); i.hasNext(); ) {
		    UnwovenClassFile classFile = (UnwovenClassFile)i.next();
			String className = classFile.getClassName();
		    BcelObjectType classType = getClassType(className);			            
			processReweavableStateIfPresent(className, classType);
		}
								
		requestor.addingTypeMungers();
        
        // We process type mungers in two groups, first mungers that change the type
        // hierarchy, then 'normal' ITD type mungers.
        
        
        // Process the types in a predictable order (rather than the order encountered).
        // For class A, the order is superclasses of A then superinterfaces of A
        // (and this mechanism is applied recursively)
        List typesToProcess = new ArrayList();
        for (Iterator iter = input.getClassFileIterator(); iter.hasNext();) {
			UnwovenClassFile clf = (UnwovenClassFile) iter.next();
            typesToProcess.add(clf.getClassName());
        }
        while (typesToProcess.size()>0) {
            weaveParentsFor(typesToProcess,(String)typesToProcess.get(0));
        }  
        
        for (Iterator i = input.getClassFileIterator(); i.hasNext(); ) {
            UnwovenClassFile classFile = (UnwovenClassFile)i.next();
            String className = classFile.getClassName();
            addNormalTypeMungers(className);
        }

		requestor.weavingAspects();
		// first weave into aspects
		for (Iterator i = input.getClassFileIterator(); i.hasNext(); ) {
		    UnwovenClassFile classFile = (UnwovenClassFile)i.next();
			String className = classFile.getClassName();
		    BcelObjectType classType = BcelWorld.getBcelObjectType(world.resolve(className));
		    if (classType.isAspect()) {
		        weaveAndNotify(classFile, classType,requestor);
		        wovenClassNames.add(className);
		    }
		}

		requestor.weavingClasses();
		// then weave into non-aspects
		for (Iterator i = input.getClassFileIterator(); i.hasNext(); ) {
		    UnwovenClassFile classFile = (UnwovenClassFile)i.next();
			String className = classFile.getClassName();
		    BcelObjectType classType = BcelWorld.getBcelObjectType(world.resolve(className));
		    if (! classType.isAspect()) {
		        weaveAndNotify(classFile, classType, requestor);
		        wovenClassNames.add(className);
		    }
		}
		
		addedClasses = new ArrayList();
		deletedTypenames = new ArrayList();
		
        
		// FIXME asc Should be factored out into Xlint code and done automatically for all xlint messages, ideally.
        // if a piece of advice hasn't matched anywhere and we are in -1.5 mode, put out a warning
        if (world.behaveInJava5Way && 
            world.getLint().adviceDidNotMatch.isEnabled()) {
        	List l = world.getCrosscuttingMembersSet().getShadowMungers();
        	for (Iterator iter = l.iterator(); iter.hasNext();) {
        		ShadowMunger element = (ShadowMunger) iter.next();
        		if (element instanceof BcelAdvice) { // This will stop us incorrectly reporting deow Checkers
                  BcelAdvice ba = (BcelAdvice)element;
                  if (!ba.hasMatchedSomething()) { 
					 // Because we implement some features of AJ itself by creating our own kind of mungers, you sometimes
 				     // find that ba.getSignature() is not a BcelMethod - for example it might be a cflow entry munger.
	                 if (ba.getSignature()!=null) {
					   if (!(ba.getSignature() instanceof BcelMethod)
					       || !Utility.isSuppressing((AnnotationX[])ba.getSignature().getAnnotations(),"adviceDidNotMatch")) {
					        world.getLint().adviceDidNotMatch.signal(ba.getDeclaringAspect().toString(),element.getSourceLocation());
					   }							  
                     }
                  }
        		}
        	}
        }

        requestor.weaveCompleted();
    	return wovenClassNames;
    }
    
    /**
     * 'typeToWeave' is one from the 'typesForWeaving' list.  This routine ensures we process
     * supertypes (classes/interfaces) of 'typeToWeave' that are in the 
     * 'typesForWeaving' list before 'typeToWeave' itself.  'typesToWeave' is then removed from
     * the 'typesForWeaving' list.
     * 
     * Note: Future gotcha in here ... when supplying partial hierarchies, this algorithm may
     * break down.  If you have a hierarchy A>B>C and only give A and C to the weaver, it 
     * may choose to weave them in either order - but you'll probably have other problems if
     * you are supplying partial hierarchies like that !
     */
    private void weaveParentsFor(List typesForWeaving,String typeToWeave) {
        // Look at the supertype first
    	ResolvedTypeX rtx = world.resolve(typeToWeave);
        ResolvedTypeX superType = rtx.getSuperclass();
        if (superType!=null && typesForWeaving.contains(superType.getClassName())) {
            weaveParentsFor(typesForWeaving,superType.getClassName());
        }
        
        // Then look at the superinterface list
        ResolvedTypeX[] interfaceTypes = rtx.getDeclaredInterfaces();
        for (int i = 0; i < interfaceTypes.length; i++) {
            ResolvedTypeX rtxI = interfaceTypes[i];
            if (typesForWeaving.contains(rtxI.getClassName())) {
                weaveParentsFor(typesForWeaving,rtxI.getClassName());
            }
        }
        weaveParentTypeMungers(rtx); // Now do this type
        typesForWeaving.remove(typeToWeave); // and remove it from the list of those to process
    }
    
    public void prepareToProcessReweavableState() {
		if (inReweavableMode)
			world.showMessage(IMessage.INFO,
					WeaverMessages.format(WeaverMessages.REWEAVABLE_MODE),
					null, null);
    	 	    	
    	alreadyConfirmedReweavableState = new HashSet();
    }
    
    public void processReweavableStateIfPresent(String className, BcelObjectType classType) {
		// If the class is marked reweavable, check any aspects around when it was built are in this world
		WeaverStateInfo wsi = classType.getWeaverState();		
		if (wsi!=null && wsi.isReweavable()) { // Check all necessary types are around!
			world.showMessage(IMessage.INFO,
					WeaverMessages.format(WeaverMessages.PROCESSING_REWEAVABLE,className,classType.getSourceLocation().getSourceFile()),
					null,null);
			Set aspectsPreviouslyInWorld = wsi.getAspectsAffectingType();
			if (aspectsPreviouslyInWorld!=null) {
				for (Iterator iter = aspectsPreviouslyInWorld.iterator(); iter.hasNext();) {
					String requiredTypeName = (String) iter.next();
					if (!alreadyConfirmedReweavableState.contains(requiredTypeName)) {
						ResolvedTypeX rtx = world.resolve(TypeX.forName(requiredTypeName),true);
						boolean exists = rtx!=ResolvedTypeX.MISSING;
						if (!exists) {
							world.showMessage(IMessage.ERROR, 
									WeaverMessages.format(WeaverMessages.MISSING_REWEAVABLE_TYPE,requiredTypeName,className),
								    classType.getSourceLocation(), null);
						} else {
							if (!world.getMessageHandler().isIgnoring(IMessage.INFO))
							  world.showMessage(IMessage.INFO,
							  		WeaverMessages.format(WeaverMessages.VERIFIED_REWEAVABLE_TYPE,requiredTypeName,rtx.getSourceLocation().getSourceFile()),
									null,null);
							alreadyConfirmedReweavableState.add(requiredTypeName);
						}
					}		
				}
			}
			classType.setJavaClass(Utility.makeJavaClass(classType.getJavaClass().getFileName(), wsi.getUnwovenClassFileData()));
		} else {
			classType.resetState();
		}
	}

    private void weaveAndNotify(UnwovenClassFile classFile, BcelObjectType classType,
    		                    IWeaveRequestor requestor) throws IOException {
    	LazyClassGen clazz = weaveWithoutDump(classFile,classType);
    	classType.finishedWith();
		//clazz is null if the classfile was unchanged by weaving...
		if (clazz != null) {
			UnwovenClassFile[] newClasses = getClassFilesFor(clazz);
			for (int i = 0; i < newClasses.length; i++) {
				requestor.acceptResult(newClasses[i]);
			}
		} else {
			requestor.acceptResult(classFile);
		}
    }
    
	// helper method
    public BcelObjectType getClassType(String forClass) {
        return BcelWorld.getBcelObjectType(world.resolve(forClass));    	
    }
 
    
    public void addParentTypeMungers(String typeName) {
    	weaveParentTypeMungers(world.resolve(typeName));
    }
    
    public void addNormalTypeMungers(String typeName) {
        weaveNormalTypeMungers(world.resolve(typeName));
    }

    public UnwovenClassFile[] getClassFilesFor(LazyClassGen clazz) {
    	List childClasses = clazz.getChildClasses(world);
    	UnwovenClassFile[] ret = new UnwovenClassFile[1 + childClasses.size()];    	
    	ret[0] = new UnwovenClassFile(clazz.getFileName(),clazz.getJavaClass(world).getBytes());
    	int index = 1;
    	for (Iterator iter = childClasses.iterator(); iter.hasNext();) {
			UnwovenClassFile.ChildClass element = (UnwovenClassFile.ChildClass) iter.next();
			UnwovenClassFile childClass = new UnwovenClassFile(clazz.getFileName() + "$" + element.name, element.bytes);
			ret[index++] = childClass;
		}
    	return ret;
    }
    
    /**
     * Weaves new parents and annotations onto a type ("declare parents" and "declare @type")
     * 
     * Algorithm:
     *   1. First pass, do parents then do annotations.  During this pass record:
     *      - any parent mungers that don't match but have a non-wild annotation type pattern
     *      - any annotation mungers that don't match
     *   2. Multiple subsequent passes which go over the munger lists constructed in the first
     *      pass, repeatedly applying them until nothing changes.
     * FIXME asc confirm that algorithm is optimal ??
     */
	public void weaveParentTypeMungers(ResolvedTypeX onType) {
		onType.clearInterTypeMungers();
		
		List decpToRepeat = new ArrayList();
		List decaToRepeat = new ArrayList();
		
		boolean aParentChangeOccurred      = false;
		boolean anAnnotationChangeOccurred = false;
		// First pass - apply all decp mungers
		for (Iterator i = declareParentsList.iterator(); i.hasNext(); ) {
			DeclareParents decp = (DeclareParents)i.next();
			boolean typeChanged = applyDeclareParents(decp,onType);
			if (typeChanged) {
				aParentChangeOccurred = true;
			} else { // Perhaps it would have matched if a 'dec @type' had modified the type
				if (!decp.getChild().isStarAnnotation()) decpToRepeat.add(decp);
			}
		}

		// Still first pass - apply all dec @type mungers
		for (Iterator i = xcutSet.getDeclareAnnotationOnTypes().iterator();i.hasNext();) {
			DeclareAnnotation decA = (DeclareAnnotation)i.next();
			boolean typeChanged = applyDeclareAtType(decA,onType,true);
			if (typeChanged) {
				anAnnotationChangeOccurred = true;
			}
		}
		
		while ((aParentChangeOccurred || anAnnotationChangeOccurred) && !decpToRepeat.isEmpty()) {
			anAnnotationChangeOccurred = aParentChangeOccurred = false;
			List decpToRepeatNextTime = new ArrayList();
			for (Iterator iter = decpToRepeat.iterator(); iter.hasNext();) {
				DeclareParents decp = (DeclareParents) iter.next();
				boolean typeChanged = applyDeclareParents(decp,onType);
				if (typeChanged) {
					aParentChangeOccurred = true;
				} else {
					decpToRepeatNextTime.add(decp);
				}
			}
			
			for (Iterator iter = xcutSet.getDeclareAnnotationOnTypes().iterator(); iter.hasNext();) {
				DeclareAnnotation decA = (DeclareAnnotation) iter.next();
				boolean typeChanged = applyDeclareAtType(decA,onType,false);
				if (typeChanged) {
					anAnnotationChangeOccurred = true;
				}
			}
			decpToRepeat = decpToRepeatNextTime;
		}
    }

	
	/**
	 * Apply a declare @type - return true if we change the type
	 */
	private boolean applyDeclareAtType(DeclareAnnotation decA, ResolvedTypeX onType,boolean reportProblems) {
		boolean didSomething = false;
		if (decA.matches(onType)) {
			
			// FIXME asc important this should be guarded by the 'already has annotation' check below but isn't since the compiler is producing classfiles with deca affected things in...
			AsmRelationshipProvider.getDefault().addDeclareAnnotationRelationship(decA.getSourceLocation(),onType.getSourceLocation());
			
			// FIXME asc same comment above applies here
			// TAG: WeavingMessage 
			if (!getWorld().getMessageHandler().isIgnoring(IMessage.WEAVEINFO)){
			  getWorld().getMessageHandler().handleMessage(
		              WeaveMessage.constructWeavingMessage(WeaveMessage.WEAVEMESSAGE_ANNOTATES,
			                  new String[]{
							    onType.toString(),
							    Utility.beautifyLocation(onType.getSourceLocation()),
							    decA.getAnnotationString(),
							    "type",
							    decA.getAspect().toString(),
							    Utility.beautifyLocation(decA.getSourceLocation())
							    }));
			}
			
			
		    if (onType.hasAnnotation(decA.getAnnotationX().getSignature())) {
// FIXME asc Could put out a lint here for an already annotated type - the problem is that it may have
// picked up the annotation during 'source weaving' in which case the message is misleading.  Leaving it
// off for now...
//		      if (reportProblems) {
//		      	world.getLint().elementAlreadyAnnotated.signal(
//      		      new String[]{onType.toString(),decA.getAnnotationTypeX().toString()},
//      		      onType.getSourceLocation(),new ISourceLocation[]{decA.getSourceLocation()});
//		      }
		      return false;
		    }
			
			AnnotationX annoX = decA.getAnnotationX();
			
			// check the annotation is suitable for the target
			boolean problemReported = verifyTargetIsOK(decA, onType, annoX,reportProblems);
			
			if (!problemReported) {
				didSomething = true;
				ResolvedTypeMunger newAnnotationTM = new AnnotationOnTypeMunger(annoX);
				newAnnotationTM.setSourceLocation(decA.getSourceLocation());
				onType.addInterTypeMunger(new BcelTypeMunger(newAnnotationTM,decA.getAspect().resolve(world)));
				decA.copyAnnotationTo(onType);
			}
		}
		return didSomething;
	}

	/**
	 * Checks for an @target() on the annotation and if found ensures it allows the annotation
	 * to be attached to the target type that matched.
	 */
	private boolean verifyTargetIsOK(DeclareAnnotation decA, ResolvedTypeX onType, AnnotationX annoX,boolean outputProblems) {
		boolean problemReported = false;
		if (annoX.specifiesTarget()) {
		  if (  (onType.isAnnotation() && !annoX.allowedOnAnnotationType()) ||
		  		(!annoX.allowedOnRegularType())) {
		  	if (outputProblems) {
			if (decA.isExactPattern()) {
				world.getMessageHandler().handleMessage(MessageUtil.error(
						WeaverMessages.format(WeaverMessages.INCORRECT_TARGET_FOR_DECLARE_ANNOTATION,
								onType.getName(),annoX.stringify(),annoX.getValidTargets()),decA.getSourceLocation()));
			} else {
				if (world.getLint().invalidTargetForAnnotation.isEnabled()) {
					world.getLint().invalidTargetForAnnotation.signal(
							new String[]{onType.getName(),annoX.stringify(),annoX.getValidTargets()},decA.getSourceLocation(),new ISourceLocation[]{onType.getSourceLocation()});
				}
			}
		  	}
			problemReported = true;				
		  }
		}
		return problemReported;
	}
		
	/**
	 * Apply a single declare parents - return true if we change the type
	 */
	private boolean applyDeclareParents(DeclareParents p, ResolvedTypeX onType) {
		boolean didSomething = false;
		List newParents = p.findMatchingNewParents(onType,true);
		if (!newParents.isEmpty()) {
			didSomething=true;
			BcelObjectType classType = BcelWorld.getBcelObjectType(onType);
			//System.err.println("need to do declare parents for: " + onType);
			for (Iterator j = newParents.iterator(); j.hasNext(); ) {
				ResolvedTypeX newParent = (ResolvedTypeX)j.next();
				                                        
				// We set it here so that the imminent matching for ITDs can succeed - we 
		        // still haven't done the necessary changes to the class file itself 
		        // (like transform super calls) - that is done in BcelTypeMunger.mungeNewParent()
				classType.addParent(newParent);
				ResolvedTypeMunger newParentMunger = new NewParentTypeMunger(newParent);
		        newParentMunger.setSourceLocation(p.getSourceLocation());
				onType.addInterTypeMunger(new BcelTypeMunger(newParentMunger, xcutSet.findAspectDeclaringParents(p)));
			}
		}
		return didSomething;
	}
    
    public void weaveNormalTypeMungers(ResolvedTypeX onType) {
		for (Iterator i = typeMungerList.iterator(); i.hasNext(); ) {
			ConcreteTypeMunger m = (ConcreteTypeMunger)i.next();
			if (m.matches(onType)) {
				onType.addInterTypeMunger(m);
			}
		}
	}


	// exposed for ClassLoader dynamic weaving
	public LazyClassGen weaveWithoutDump(UnwovenClassFile classFile, BcelObjectType classType) throws IOException {
		return weave(classFile, classType, false);
	}

	// non-private for testing
	LazyClassGen weave(UnwovenClassFile classFile, BcelObjectType classType) throws IOException {
		LazyClassGen ret = weave(classFile, classType, true);
		
		if (progressListener != null) {
			progressMade += progressPerClassFile;
			progressListener.setProgress(progressMade);
			progressListener.setText("woven: " + classFile.getFilename());
		}
		
		return ret;
	}

	
	private LazyClassGen weave(UnwovenClassFile classFile, BcelObjectType classType, boolean dump) throws IOException {		
		if (classType.isSynthetic()) {
			if (dump) dumpUnchanged(classFile);
			return null;
		}
		
//		JavaClass javaClass = classType.getJavaClass();
		List shadowMungers = fastMatch(shadowMungerList, classType.getResolvedTypeX());
		List typeMungers = classType.getResolvedTypeX().getInterTypeMungers();
        
        classType.getResolvedTypeX().checkInterTypeMungers();

		LazyClassGen clazz = null;
		if (shadowMungers.size() > 0 || typeMungers.size() > 0 || classType.isAspect() || 
			world.getDeclareAnnotationOnMethods().size()>0 || world.getDeclareAnnotationOnFields().size()>0 ) {
			clazz = classType.getLazyClassGen();
			//System.err.println("got lazy gen: " + clazz + ", " + clazz.getWeaverState());
			try {
				boolean isChanged = BcelClassWeaver.weave(world, clazz, shadowMungers, typeMungers);
				if (isChanged) {
					if (dump) dump(classFile, clazz);
					return clazz;
				}
			} catch (RuntimeException re) {
				System.err.println("trouble in: ");
                clazz.print(System.err);
                re.printStackTrace();
				throw re;
			} catch (Error re) {
				System.err.println("trouble in: ");
				clazz.print(System.err);
				throw re;
			}
		}
		
		// this is very odd return behavior trying to keep everyone happy
		if (dump) {
			dumpUnchanged(classFile);
			return clazz;
		} else {
            // ATAJ: the class was not weaved, but since it gets there early it may have new generated inner classes
            // attached to it to support LTW perX aspectOf support (see BcelPerClauseAspectAdder)
            // that aggressively defines the inner <aspect>$mayHaveAspect interface.
            if (clazz != null && !clazz.getChildClasses(world).isEmpty()) {
                return clazz;
            }
			return null;
		}
	}



	// ---- writing

	private void dumpUnchanged(UnwovenClassFile classFile) throws IOException {
		if (zipOutputStream != null) {
			writeZipEntry(getEntryName(classFile.getJavaClass().getClassName()), classFile.getBytes());
		} else {
			classFile.writeUnchangedBytes();
		}
	}

	private String getEntryName(String className) {
		//XXX what does bcel's getClassName do for inner names
		return className.replace('.', '/') + ".class";
	}

	private void dump(UnwovenClassFile classFile, LazyClassGen clazz) throws IOException {
		if (zipOutputStream != null) {
			String mainClassName = classFile.getJavaClass().getClassName();
			writeZipEntry(getEntryName(mainClassName),
							clazz.getJavaClass(world).getBytes());
			if (!clazz.getChildClasses(world).isEmpty()) {
				for (Iterator i = clazz.getChildClasses(world).iterator(); i.hasNext();) {
					UnwovenClassFile.ChildClass c = (UnwovenClassFile.ChildClass) i.next();
					writeZipEntry(getEntryName(mainClassName + "$" + c.name), c.bytes);
				}
			}
		} else {
			classFile.writeWovenBytes(
				clazz.getJavaClass(world).getBytes(), 
				clazz.getChildClasses(world)
			);
		}
	}
	
	private void writeZipEntry(String name, byte[] bytes) throws IOException {
		ZipEntry newEntry = new ZipEntry(name);  //??? get compression scheme right
		
		zipOutputStream.putNextEntry(newEntry);
		zipOutputStream.write(bytes);
		zipOutputStream.closeEntry();
	}

	private List fastMatch(List list, ResolvedTypeX type) {
		if (list == null) return Collections.EMPTY_LIST;

		// here we do the coarsest grained fast match with no kind constraints
		// this will remove all obvious non-matches and see if we need to do any weaving
		FastMatchInfo info = new FastMatchInfo(type, null);

		List result = new ArrayList();
		Iterator iter = list.iterator();
		while (iter.hasNext()) {
			ShadowMunger munger = (ShadowMunger)iter.next();
			FuzzyBoolean fb = munger.getPointcut().fastMatch(info);
			WeaverMetrics.recordFastMatchTypeResult(fb); // Could pass: munger.getPointcut().toString(),info
			if (fb.maybeTrue()) {
				result.add(munger);
			}
		}
		return result;
	}

	public void setProgressListener(IProgressListener listener, double previousProgress, double progressPerClassFile) {
		progressListener = listener;
		this.progressMade = previousProgress;
		this.progressPerClassFile = progressPerClassFile;
	}

	public void setReweavableMode(boolean mode,boolean compress) {
		inReweavableMode = mode;
		WeaverStateInfo.setReweavableModeDefaults(mode,compress);
		BcelClassWeaver.setReweavableMode(mode,compress);
	}

	public boolean isReweavable() {
		return inReweavableMode;
	}

    public World getWorld() {
        return world;
    }
}