* Copyright (c) 2002-2010 Contributors

* All rights reserved.

* This program and the accompanying materials are made available

* under the terms of the Eclipse Public License v1.0

* which accompanies this distribution and is available at

* http://www.eclipse.org/legal/epl-v10.html

* ******************************************************************/

*

* @author PARC

* @author Andy Clement

* @author Alexandre Vasseur

*/

  public static final String CLOSURE_CLASS_PREFIX = "$Ajc";

  public static final String SYNTHETIC_CLASS_POSTFIX = "$ajc";

  private static Trace trace = TraceFactory.getTraceFactory().getTrace(BcelWeaver.class);

  private transient final BcelWorld world;

  private final CrosscuttingMembersSet xcutSet;

  private boolean inReweavableMode = false;

  private transient List<UnwovenClassFile> addedClasses = new ArrayList<UnwovenClassFile>();

  private transient List<String> deletedTypenames = new ArrayList<String>();

  // These four are setup by prepareForWeave

  private transient List<ShadowMunger> shadowMungerList = null;

  private transient List<ConcreteTypeMunger> typeMungerList = null;

  private transient List<ConcreteTypeMunger> lateTypeMungerList = null;

  private transient List<DeclareParents> declareParentsList = null;

  private Manifest manifest = null;

  private boolean needToReweaveWorld = false;

  private boolean isBatchWeave = true;

  private ZipOutputStream zipOutputStream;

  private CustomMungerFactory customMungerFactory;

  public BcelWeaver(BcelWorld world) {

    super();

    if (trace.isTraceEnabled()) {

      trace.enter("<init>", this, world);

    }

    this.world = world;

    this.xcutSet = world.getCrosscuttingMembersSet();

    if (trace.isTraceEnabled()) {

      trace.exit("<init>");

    }

  }

  /**

   * Add the given aspect to the weaver. The type is resolved to support DOT for static inner classes as well as DOLLAR

   *

   * @param aspectName

   * @return aspect

   */

  public ResolvedType addLibraryAspect(String aspectName) {

    if (trace.isTraceEnabled()) {

      trace.enter("addLibraryAspect", this, aspectName);

    }

    // 1 - resolve as is

    UnresolvedType unresolvedT = UnresolvedType.forName(aspectName);

    unresolvedT.setNeedsModifiableDelegate(true);

    ResolvedType type = world.resolve(unresolvedT, true);

    if (type.isMissing()) {

      // 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('.');

        UnresolvedType ut = UnresolvedType.forName(fixedName);

        ut.setNeedsModifiableDelegate(true);

        type = world.resolve(ut, true);

        if (!type.isMissing()) {

          break;

        }

      }

    }

    // System.out.println("type: " + type + " for " + aspectName);

    if (type.isAspect()) {

      // Bug 119657 ensure we use the unwoven aspect

      WeaverStateInfo wsi = type.getWeaverState();

      if (wsi != null && wsi.isReweavable()) {

        BcelObjectType classType = getClassType(type.getName());

        JavaClass wovenJavaClass = classType.getJavaClass();

        byte[] bytes = wsi.getUnwovenClassFileData(wovenJavaClass.getBytes());

        JavaClass unwovenJavaClass = Utility.makeJavaClass(wovenJavaClass.getFileName(), bytes);

        world.storeClass(unwovenJavaClass);

        classType.setJavaClass(unwovenJavaClass, true);

        // classType.setJavaClass(Utility.makeJavaClass(classType.

        // getJavaClass().getFileName(),

        // wsi.getUnwovenClassFileData(classType.getJavaClass().getBytes(

        // ))));

      }

      // TODO AV - happens to reach that a lot of time: for each type

      // flagged reweavable X for each aspect in the weaverstate

      // => mainly for nothing for LTW - pbly for something in incremental

      // build...

      xcutSet.addOrReplaceAspect(type);

      if (trace.isTraceEnabled()) {

        trace.exit("addLibraryAspect", type);

      }

      if (type.getSuperclass().isAspect()) {

        // If the supertype includes ITDs and the user has not included

        // that aspect in the aop.xml, they will

        // not get picked up, which can give unusual behaviour! See bug

        // 223094

        // This change causes us to pick up the super aspect regardless

        // of what was said in the aop.xml - giving

        // predictable behaviour. If the user also supplied it, there

        // will be no problem other than the second

        // addition overriding the first

        addLibraryAspect(type.getSuperclass().getName());

      }

      return type;

    } else {

      // FIXME AV - better warning upon no such aspect from aop.xml

      RuntimeException ex = new RuntimeException("Cannot register non aspect: " + type.getName() + " , " + aspectName);

      if (trace.isTraceEnabled()) {

        trace.exit("addLibraryAspect", ex);

      }

      throw ex;

    }

  }

  /**

   *

   * @param inFile directory containing classes or zip/jar class archive

   */

  public void addLibraryJarFile(File inFile) throws IOException {

    List<ResolvedType> addedAspects = null;

    if (inFile.isDirectory()) {

      addedAspects = addAspectsFromDirectory(inFile);

    } else {

      addedAspects = addAspectsFromJarFile(inFile);

    }

    if (world.isOverWeaving()) {

      return;

    }

    for (ResolvedType addedAspect : addedAspects) {

      xcutSet.addOrReplaceAspect(addedAspect);

    }

  }

  private List<ResolvedType> addAspectsFromJarFile(File inFile) throws FileNotFoundException, IOException {

    ZipInputStream inStream = new ZipInputStream(new FileInputStream(inFile)); // ??? buffered

    List<ResolvedType> addedAspects = new ArrayList<ResolvedType>();

    try {

      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.

        int size = (int) entry.getSize();

        ClassParser parser = new ClassParser(new ByteArrayInputStream(FileUtil.readAsByteArray(inStream)), entry.getName());

        JavaClass jc = parser.parse();

        inStream.closeEntry();

        ResolvedType type = world.addSourceObjectType(jc, false).getResolvedTypeX();

        type.setBinaryPath(inFile.getAbsolutePath());

        if (type.isAspect()) {

          addedAspects.add(type);

        }

      }

    } finally {

      inStream.close();

    }

    return addedAspects;

  }

  /**

   * Look for .class files that represent aspects in the supplied directory - return the list of accumulated aspects.

   *

   * @param directory the directory in which to look for Aspect .class files

   * @return the list of discovered aspects

   * @throws FileNotFoundException

   * @throws IOException

   */

  private List<ResolvedType> addAspectsFromDirectory(File directory) throws FileNotFoundException, IOException {

    List<ResolvedType> addedAspects = new ArrayList<ResolvedType>();

    File[] classFiles = FileUtil.listFiles(directory, new FileFilter() {

      public boolean accept(File pathname) {

        return pathname.getName().endsWith(".class");

      }

    });

    for (File classFile : classFiles) {

      FileInputStream fis = new FileInputStream(classFile);

      byte[] classBytes = FileUtil.readAsByteArray(fis);

      ResolvedType aspectType = isAspect(classBytes, classFile.getAbsolutePath(), directory);

      if (aspectType != null) {

        addedAspects.add(aspectType);

      }

      fis.close();

    }

    return addedAspects;

  }

  /**

   * Determine if the supplied bytes represent an aspect, if they do then create a ResolvedType instance for the aspect and return

   * it, otherwise return null

   *

   * @param classbytes the classbytes that might represent an aspect

   * @param name the name of the class

   * @param directory directory which contained the class file

   * @return a ResolvedType if the classbytes represent an aspect, otherwise null

   */

  private ResolvedType isAspect(byte[] classbytes, String name, File dir) throws IOException {

    ClassParser parser = new ClassParser(new ByteArrayInputStream(classbytes), name);

    JavaClass jc = parser.parse();

    ResolvedType type = world.addSourceObjectType(jc, false).getResolvedTypeX();

    String typeName = type.getName().replace('.', File.separatorChar);

    int end = name.lastIndexOf(typeName + ".class");

    String binaryPath = null;

    // if end is -1 then something weird happened, the class file is not in

    // the correct place, something like

    // bin/A.class when the declaration for A specifies it is in a package.

    if (end == -1) {

      binaryPath = dir.getAbsolutePath();

    } else {

      binaryPath = name.substring(0, end - 1);

    }

    type.setBinaryPath(binaryPath);

    return (type.isAspect() ? type : null);

  }

  // // The ANT copy task should be used to copy resources across.

  // private final static boolean

  // CopyResourcesFromInpathDirectoriesToOutput=false;

  /**

   * 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<UnwovenClassFile> addDirectoryContents(File inFile, File outDir) throws IOException {

    List<UnwovenClassFile> addedClassFiles = new ArrayList<UnwovenClassFile>();

    // 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<UnwovenClassFile> addJarFile(File inFile, File outDir, boolean canBeDirectory) {

    // System.err.println("? addJarFile(" + inFile + ", " + outDir + ")");

    List<UnwovenClassFile> addedClassFiles = new ArrayList<UnwovenClassFile>();

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

        try {

          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")) {

              ReferenceType type = this.addClassFile(classFile, false);

              StringBuffer sb = new StringBuffer();

              sb.append(inFile.getAbsolutePath());

              sb.append("!");

              sb.append(entry.getName());

              type.setBinaryPath(sb.toString());

              addedClassFiles.add(classFile);

            }

            // else if (!entry.isDirectory()) {

            //

            // /* bug-44190 Copy meta-data */

            // addResource(filename,classFile);

            // }

            inStream.close();

          }

        } finally {

          inJar.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 boolean needToReweaveWorld() {

    return needToReweaveWorld;

  }

  /**

   * Should be addOrReplace

   */

  public ReferenceType addClassFile(UnwovenClassFile classFile, boolean fromInpath) {

    addedClasses.add(classFile);

    ReferenceType type = world.addSourceObjectType(classFile.getJavaClass(), false).getResolvedTypeX();

    if (fromInpath) {

      type.setBinaryPath(classFile.getFilename());

    }

    return type;

  }

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

      StringBuffer sb = new StringBuffer();

      sb.append(inPathDir.getAbsolutePath());

      sb.append("!");

      sb.append(filename);

      ReferenceType type = this.addClassFile(ucf, false);

      type.setBinaryPath(sb.toString());

    }

    fis.close();

    return ucf;

  }

  public void deleteClassFile(String typename) {

    deletedTypenames.add(typename);

    world.deleteSourceObjectType(UnresolvedType.forName(typename));

  }

  // ---- weave preparation

  public void setIsBatchWeave(boolean b) {

    isBatchWeave = b;

  }

  public void prepareForWeave() {

    if (trace.isTraceEnabled()) {

      trace.enter("prepareForWeave", this);

    }

    needToReweaveWorld = xcutSet.hasChangedSinceLastReset();

    // update mungers

    for (Iterator<UnwovenClassFile> i = addedClasses.iterator(); i.hasNext();) {

      UnwovenClassFile jc = i.next();

      String name = jc.getClassName();

      ResolvedType type = world.resolve(name);

      if (type.isAspect() && !world.isOverWeaving()) {

        needToReweaveWorld |= xcutSet.addOrReplaceAspect(type);

      }

    }

    for (Iterator<String> i = deletedTypenames.iterator(); i.hasNext();) {

      String name = i.next();

      if (xcutSet.deleteAspect(UnresolvedType.forName(name))) {

        needToReweaveWorld = true;

      }

    }

    shadowMungerList = xcutSet.getShadowMungers();

    // world.debug("shadow mungers=" + shadowMungerList);

    rewritePointcuts(shadowMungerList);

    // Sometimes an error occurs during rewriting pointcuts (for example, if

    // ambiguous bindings

    // are detected) - we ought to fail the prepare when this happens

    // because continuing with

    // inconsistent pointcuts could lead to problems

    typeMungerList = xcutSet.getTypeMungers();

    lateTypeMungerList = xcutSet.getLateTypeMungers();

    declareParentsList = xcutSet.getDeclareParents();

    addCustomMungers();

    // 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<ShadowMunger>() {

      public int compare(ShadowMunger sm1, ShadowMunger sm2) {

        if (sm1.getSourceLocation() == null) {

          return (sm2.getSourceLocation() == null ? 0 : 1);

        }

        if (sm2.getSourceLocation() == null) {

          return -1;

        }

        return (sm2.getSourceLocation().getOffset() - sm1.getSourceLocation().getOffset());

      }

    });

    if (inReweavableMode) {

      world.showMessage(IMessage.INFO, WeaverMessages.format(WeaverMessages.REWEAVABLE_MODE), null, null);

    }

    if (trace.isTraceEnabled()) {

      trace.exit("prepareForWeave");

    }

  }

  private void addCustomMungers() {

    if (customMungerFactory != null) {

      for (Iterator<UnwovenClassFile> i = addedClasses.iterator(); i.hasNext();) {

        UnwovenClassFile jc = i.next();

        String name = jc.getClassName();

        ResolvedType type = world.resolve(name);

        if (type.isAspect()) {

          Collection<ShadowMunger> shadowMungers = customMungerFactory.createCustomShadowMungers(type);

          if (shadowMungers != null) {

            shadowMungerList.addAll(shadowMungers);

          }

          Collection<ConcreteTypeMunger> typeMungers = customMungerFactory.createCustomTypeMungers(type);

          if (typeMungers != null) {

            typeMungerList.addAll(typeMungers);

          }

        }

      }

    }

  }

  public void setCustomMungerFactory(CustomMungerFactory factory) {

    customMungerFactory = factory;

  }

  /*

   * 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 (ShadowMunger munger : shadowMungers) {

      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[];

          // If the advice is being concretized in a @AJ aspect *and*

          // the advice was declared in

          // an @AJ aspect (it could have been inherited from a code

          // style aspect) then

          // evaluate the alternative set of formals. pr125699

          if ((advice.getConcreteAspect().isAnnotationStyleAspect() && advice.getDeclaringAspect() != null && advice

              .getDeclaringAspect().resolve(world).isAnnotationStyleAspect())

              || advice.isAnnotationStyle()) {

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

            }

          }

        }

      }

      newP.m_ignoreUnboundBindingForNames = p.m_ignoreUnboundBindingForNames;

      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> */<Pointcut, Pointcut> pcMap = new HashMap<Pointcut, Pointcut>();

    for (Iterator iter = shadowMungers.iterator(); iter.hasNext();) {

      ShadowMunger munger = (ShadowMunger) iter.next();

      Pointcut p = munger.getPointcut();

      Pointcut newP = shareEntriesFromMap(p, pcMap);

      newP.m_ignoreUnboundBindingForNames = p.m_ignoreUnboundBindingForNames;

      munger.setPointcut(newP);

    }

  }

  private Pointcut shareEntriesFromMap(Pointcut p, Map<Pointcut, Pointcut> 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 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() == Shadow.NO_SHADOW_KINDS_BITS) {

      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() != Shadow.NO_SHADOW_KINDS_BITS) {

        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() != Shadow.NO_SHADOW_KINDS_BITS) {

        validateSingleBranch(right, userPointcut, numFormals, names, rightBindings);

      }

    }

    int kindsInCommon = left.couldMatchKinds() & right.couldMatchKinds();

    if (kindsInCommon != Shadow.NO_SHADOW_KINDS_BITS && 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<String> ambiguousNames = new ArrayList<String>();

      for (int i = 0; i < numFormals; i++) {

        if (leftBindings[i] == null) {

          if (rightBindings[i] != null) {

            ambiguousNames.add(names[i]);

          }

        } else 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/* BindingPattern */baps = ((NameBindingPointcut) pc).getBindingAnnotationTypePatterns();

      for (Iterator iter = baps.iterator(); iter.hasNext();) {

        BindingPattern bap = (BindingPattern) 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) {

      OrPointcut leftOrPointcut = (OrPointcut) left;

      if (couldEverMatchSameJoinPoints(leftOrPointcut.getLeft(), right)) {

        return true;

      }

      if (couldEverMatchSameJoinPoints(leftOrPointcut.getRight(), right)) {

        return true;

      }

      return false;

    }

    if (right instanceof OrPointcut) {

      OrPointcut rightOrPointcut = (OrPointcut) right;

      if (couldEverMatchSameJoinPoints(left, rightOrPointcut.getLeft())) {

        return true;

      }

      if (couldEverMatchSameJoinPoints(left, rightOrPointcut.getRight())) {

        return true;

      }

      return false;

    }

    // 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<String> 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.getSourceLocation(), null);

  }

  public void addManifest(Manifest newManifest) {

    // System.out.println("? addManifest() newManifest=" + newManifest);

    if (manifest == null) {

      manifest = newManifest;

    }

  }

  public Manifest getManifest(boolean shouldCreate) {

    if (manifest == null && shouldCreate) {

      String WEAVER_MANIFEST_VERSION = "1.0";

      Attributes.Name CREATED_BY = new Name("Created-By");

      String WEAVER_CREATED_BY = "AspectJ Compiler";

      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

  // FOR TESTING

  public Collection<String> weave(File file) throws IOException {

    OutputStream os = FileUtil.makeOutputStream(file);