* 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 Eclipse Public License v1.0

* which accompanies this distribution and is available at

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

* 

* Contributors:

*     PARC     initial implementation

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

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

  public static boolean weave(BcelWorld world, LazyClassGen clazz, List<ShadowMunger> shadowMungers,

      List<ConcreteTypeMunger> typeMungers, List<ConcreteTypeMunger> lateTypeMungers, boolean inReweavableMode) {

    BcelClassWeaver classWeaver = new BcelClassWeaver(world, clazz, shadowMungers, typeMungers, lateTypeMungers);

    classWeaver.setReweavableMode(inReweavableMode);

    boolean b = classWeaver.weave();

    return b;

  }

  // --------------------------------------------

  private final LazyClassGen clazz;

  private final List<ShadowMunger> shadowMungers;

  private final List<ConcreteTypeMunger> typeMungers;

  private final List<ConcreteTypeMunger> lateTypeMungers;

  private List<ShadowMunger>[] indexedShadowMungers;

  private boolean canMatchBodyShadows = false;

  private final BcelObjectType ty; // alias of clazz.getType()

  private final BcelWorld world; // alias of ty.getWorld()

  private final ConstantPool cpg; // alias of clazz.getConstantPoolGen()

  private final InstructionFactory fact; // alias of clazz.getFactory();

  private final List<LazyMethodGen> addedLazyMethodGens = new ArrayList<LazyMethodGen>();

  private final Set<ResolvedMember> addedDispatchTargets = new HashSet<ResolvedMember>();

  private boolean inReweavableMode = false;

  private List<IfaceInitList> addedSuperInitializersAsList = null;

  private final Map<ResolvedType, IfaceInitList> addedSuperInitializers = new HashMap<ResolvedType, IfaceInitList>();

  private final List<ConcreteTypeMunger> addedThisInitializers = new ArrayList<ConcreteTypeMunger>();

  private final List<ConcreteTypeMunger> addedClassInitializers = new ArrayList<ConcreteTypeMunger>();

  private final Map<ResolvedMember, ResolvedType[]> mapToAnnotations = new HashMap<ResolvedMember, ResolvedType[]>();

  // private BcelShadow clinitShadow = null;

  /**

   * This holds the initialization and pre-initialization shadows for this class that were actually matched by mungers (if no

   * match, then we don't even create the shadows really).

   */

  private final List<BcelShadow> initializationShadows = new ArrayList<BcelShadow>();

  private BcelClassWeaver(BcelWorld world, LazyClassGen clazz, List<ShadowMunger> shadowMungers,

      List<ConcreteTypeMunger> typeMungers, List<ConcreteTypeMunger> lateTypeMungers) {

    super();

    this.world = world;

    this.clazz = clazz;

    this.shadowMungers = shadowMungers;

    this.typeMungers = typeMungers;

    this.lateTypeMungers = lateTypeMungers;

    this.ty = clazz.getBcelObjectType();

    this.cpg = clazz.getConstantPool();

    this.fact = clazz.getFactory();

    indexShadowMungers();

    initializeSuperInitializerMap(ty.getResolvedTypeX());

    if (!checkedXsetForLowLevelContextCapturing) {

      Properties p = world.getExtraConfiguration();

      if (p != null) {

        String s = p.getProperty(World.xsetCAPTURE_ALL_CONTEXT, "false");

        captureLowLevelContext = s.equalsIgnoreCase("true");

        if (captureLowLevelContext) {

          world.getMessageHandler().handleMessage(

              MessageUtil.info("[" + World.xsetCAPTURE_ALL_CONTEXT

                  + "=true] Enabling collection of low level context for debug/crash messages"));

        }

      }

      checkedXsetForLowLevelContextCapturing = true;

    }

  }

  private boolean canMatch(Shadow.Kind kind) {

    return indexedShadowMungers[kind.getKey()] != null;

  }

  // private void fastMatchShadowMungers(List shadowMungers, ArrayList

  // mungers, Kind kind) {

  // FastMatchInfo info = new FastMatchInfo(clazz.getType(), kind);

  // for (Iterator i = shadowMungers.iterator(); i.hasNext();) {

  // ShadowMunger munger = (ShadowMunger) i.next();

  // FuzzyBoolean fb = munger.getPointcut().fastMatch(info);

  // WeaverMetrics.recordFastMatchResult(fb);// Could pass:

  // munger.getPointcut().toString()

  // if (fb.maybeTrue()) mungers.add(munger);

  // }

  // }

  private void initializeSuperInitializerMap(ResolvedType child) {

    ResolvedType[] superInterfaces = child.getDeclaredInterfaces();

    for (int i = 0, len = superInterfaces.length; i < len; i++) {

      if (ty.getResolvedTypeX().isTopmostImplementor(superInterfaces[i])) {

        if (addSuperInitializer(superInterfaces[i])) {

          initializeSuperInitializerMap(superInterfaces[i]);

        }

      }

    }

  }

  /**

   * Process the shadow mungers into array 'buckets', each bucket represents a shadow kind and contains a list of shadowmungers

   * that could potentially apply at that shadow kind.

   */

  private void indexShadowMungers() {

    // beware the annoying property that SHADOW_KINDS[i].getKey == (i+1) !

    indexedShadowMungers = new List[Shadow.MAX_SHADOW_KIND + 1];

    for (ShadowMunger shadowMunger : shadowMungers) {

      int couldMatchKinds = shadowMunger.getPointcut().couldMatchKinds();

      for (Shadow.Kind kind : Shadow.SHADOW_KINDS) {

        if (kind.isSet(couldMatchKinds)) {

          byte k = kind.getKey();

          if (indexedShadowMungers[k] == null) {

            indexedShadowMungers[k] = new ArrayList<ShadowMunger>();

            if (!kind.isEnclosingKind()) {

              canMatchBodyShadows = true;

            }

          }

          indexedShadowMungers[k].add(shadowMunger);

        }

      }

    }

  }

  private boolean addSuperInitializer(ResolvedType onType) {

    if (onType.isRawType() || onType.isParameterizedType()) {

      onType = onType.getGenericType();

    }

    IfaceInitList l = addedSuperInitializers.get(onType);

    if (l != null) {

      return false;

    }

    l = new IfaceInitList(onType);

    addedSuperInitializers.put(onType, l);

    return true;

  }

  public void addInitializer(ConcreteTypeMunger cm) {

    NewFieldTypeMunger m = (NewFieldTypeMunger) cm.getMunger();

    ResolvedType onType = m.getSignature().getDeclaringType().resolve(world);

    if (onType.isRawType()) {

      onType = onType.getGenericType();

    }

    if (Modifier.isStatic(m.getSignature().getModifiers())) {

      addedClassInitializers.add(cm);

    } else {

      if (onType == ty.getResolvedTypeX()) {

        addedThisInitializers.add(cm);

      } else {

        IfaceInitList l = addedSuperInitializers.get(onType);

        l.list.add(cm);

      }

    }

  }

    final ResolvedType onType;

    List<ConcreteTypeMunger> list = new ArrayList<ConcreteTypeMunger>();

    IfaceInitList(ResolvedType onType) {

      this.onType = onType;

    }

    public int compareTo(Object other) {

      IfaceInitList o = (IfaceInitList) other;

      if (onType.isAssignableFrom(o.onType)) {

        return +1;

      } else if (o.onType.isAssignableFrom(onType)) {

        return -1;

      } else {

        return 0;

      }

    }

    public int fallbackCompareTo(Object other) {

      return 0;

    }

  }

  // XXX this is being called, but the result doesn't seem to be being used

  public boolean addDispatchTarget(ResolvedMember m) {

    return addedDispatchTargets.add(m);

  }

  public void addLazyMethodGen(LazyMethodGen gen) {

    addedLazyMethodGens.add(gen);

  }

  public void addOrReplaceLazyMethodGen(LazyMethodGen mg) {

    if (alreadyDefined(clazz, mg)) {

      return;

    }

    for (Iterator<LazyMethodGen> i = addedLazyMethodGens.iterator(); i.hasNext();) {

      LazyMethodGen existing = i.next();

      if (signaturesMatch(mg, existing)) {

        if (existing.definingType == null) {

          // this means existing was introduced on the class itself

          return;

        } else if (mg.definingType.isAssignableFrom(existing.definingType)) {

          // existing is mg's subtype and dominates mg

          return;

        } else if (existing.definingType.isAssignableFrom(mg.definingType)) {

          // mg is existing's subtype and dominates existing

          i.remove();

          addedLazyMethodGens.add(mg);

          return;

        } else {

          throw new BCException("conflict between: " + mg + " and " + existing);

        }

      }

    }

    addedLazyMethodGens.add(mg);

  }

  private boolean alreadyDefined(LazyClassGen clazz, LazyMethodGen mg) {

    for (Iterator<LazyMethodGen> i = clazz.getMethodGens().iterator(); i.hasNext();) {

      LazyMethodGen existing = i.next();

      if (signaturesMatch(mg, existing)) {

        if (!mg.isAbstract() && existing.isAbstract()) {

          i.remove();

          return false;

        }

        return true;

      }

    }

    return false;

  }

  private boolean signaturesMatch(LazyMethodGen mg, LazyMethodGen existing) {

    return mg.getName().equals(existing.getName()) && mg.getSignature().equals(existing.getSignature());

  }

  protected static LazyMethodGen makeBridgeMethod(LazyClassGen gen, ResolvedMember member) {

    // remove abstract modifier

    int mods = member.getModifiers();

    if (Modifier.isAbstract(mods)) {

      mods = mods - Modifier.ABSTRACT;

    }

    LazyMethodGen ret = new LazyMethodGen(mods, BcelWorld.makeBcelType(member.getReturnType()), member.getName(),

        BcelWorld.makeBcelTypes(member.getParameterTypes()), UnresolvedType.getNames(member.getExceptions()), gen);

    // 43972 : Static crosscutting makes interfaces unusable for javac

    // ret.makeSynthetic();

    return ret;

  }

  /**

   * Create a single bridge method called 'theBridgeMethod' that bridges to 'whatToBridgeTo'

   */

  private static void createBridgeMethod(BcelWorld world, LazyMethodGen whatToBridgeToMethodGen, LazyClassGen clazz,

      ResolvedMember theBridgeMethod) {

    InstructionList body;

    InstructionFactory fact;

    int pos = 0;

    ResolvedMember whatToBridgeTo = whatToBridgeToMethodGen.getMemberView();

    if (whatToBridgeTo == null) {

      whatToBridgeTo = new ResolvedMemberImpl(Member.METHOD, whatToBridgeToMethodGen.getEnclosingClass().getType(),

          whatToBridgeToMethodGen.getAccessFlags(), whatToBridgeToMethodGen.getName(),

          whatToBridgeToMethodGen.getSignature());

    }

    // The bridge method in this type will have the same signature as the one in the supertype

    LazyMethodGen bridgeMethod = makeBridgeMethod(clazz, theBridgeMethod);

    int newflags = bridgeMethod.getAccessFlags() | 0x00000040;// BRIDGE = 0x00000040

    if ((newflags & 0x00000100) != 0) {

      newflags = newflags - 0x100;// NATIVE = 0x00000100 - need to clear it

    }

    bridgeMethod.setAccessFlags(newflags);

    Type returnType = BcelWorld.makeBcelType(theBridgeMethod.getReturnType());

    Type[] paramTypes = BcelWorld.makeBcelTypes(theBridgeMethod.getParameterTypes());

    Type[] newParamTypes = whatToBridgeToMethodGen.getArgumentTypes();

    body = bridgeMethod.getBody();

    fact = clazz.getFactory();

    if (!whatToBridgeToMethodGen.isStatic()) {

      body.append(InstructionFactory.createThis());

      pos++;

    }

    for (int i = 0, len = paramTypes.length; i < len; i++) {

      Type paramType = paramTypes[i];

      body.append(InstructionFactory.createLoad(paramType, pos));

      if (!newParamTypes[i].equals(paramTypes[i])) {

        if (world.forDEBUG_bridgingCode) {

          System.err.println("Bridging: Cast " + newParamTypes[i] + " from " + paramTypes[i]);

        }

        body.append(fact.createCast(paramTypes[i], newParamTypes[i]));

      }

      pos += paramType.getSize();

    }

    body.append(Utility.createInvoke(fact, world, whatToBridgeTo));

    body.append(InstructionFactory.createReturn(returnType));