Package org.aspectj.weaver

Examples of org.aspectj.weaver.IntMap


      // System.err.println("start: " + searchStart);
      // ResolvedType[] parameterTypes = searchStart.getWorld().resolve(pointcutDec.getParameterTypes());

      TypePatternList arguments = this.arguments.resolveReferences(bindings);

      IntMap newBindings = new IntMap();
      for (int i = 0, len = arguments.size(); i < len; i++) {
        TypePattern p = arguments.get(i);
        if (p == TypePattern.NO) {
          continue;
        }
        // we are allowed to bind to pointcuts which use subtypes as this is type safe
        // this will be checked in ReferencePointcut.resolveBindings(). Can't check it here
        // as we don't know about any new parents added via decp.
        if (p instanceof BindingTypePattern) {
          newBindings.put(i, ((BindingTypePattern) p).getFormalIndex());
        }
      }

      if (searchStart.isParameterizedType()) {
        // build a type map mapping type variable names in the generic type to
        // the type parameters presented
        typeVariableMap = new HashMap<String, UnresolvedType>();
        ResolvedType underlyingGenericType = searchStart.getGenericType();
        TypeVariable[] tVars = underlyingGenericType.getTypeVariables();
        ResolvedType[] typeParams = searchStart.getResolvedTypeParameters();
        for (int i = 0; i < tVars.length; i++) {
          typeVariableMap.put(tVars[i].getName(), typeParams[i]);
        }
      }

      newBindings.copyContext(bindings);
      newBindings.pushEnclosingDefinition(pointcutDec);
      try {
        Pointcut ret = pointcutDec.getPointcut();
        if (typeVariableMap != null && !hasBeenParameterized) {
          ret = ret.parameterizeWith(typeVariableMap, searchStart.getWorld());
          ret.hasBeenParameterized = true;
        }
        return ret.concretize(searchStart, declaringType, newBindings);
      } finally {
        newBindings.popEnclosingDefinitition();
      }

    } finally {
      concretizing = false;
    }
View Full Code Here


            ret.baseArgsCount++;
          }
        }
      }

      IntMap newBindings = IntMap.idMap(ret.baseArgsCount);
      newBindings.copyContext(bindings);
      ret.residueSource = def.getPointcut().concretize(inAspect, declaringType, newBindings);
    }

    return ret;
  }
View Full Code Here

    if (inScope != null) {
      declaringTypeForResolution = getWorld().resolve(inScope.getName());
    } else {
      declaringTypeForResolution = ResolvedType.OBJECT.resolve(getWorld());
    }
    IntMap arity = new IntMap(formalParameters.length);
    for (int i = 0; i < formalParameters.length; i++) {
      arity.put(i, i);
    }
    return pc.concretize(declaringTypeForResolution, declaringTypeForResolution, arity);
  }
View Full Code Here

    // create a map that will move all slots in advice method forward by extraParamOffset
    // in order to make room for the new proceed-required arguments that are added at
    // the beginning of the parameter list
    int nVars = adviceMethod.getMaxLocals() + extraParamOffset;
    IntMap varMap = IntMap.idMap(nVars);
    for (int i = extraParamOffset; i < nVars; i++) {
      varMap.put(i - extraParamOffset, i);
    }

    final InstructionFactory fact = getFactory();

    localAdviceMethod.getBody().insert(
View Full Code Here

    InstructionList ret = new InstructionList();
    // we have on stack all the arguments for the ADVICE call.
    // we have in frame somewhere all the arguments for the non-advice call.

    BcelVar[] adviceVars = munger.getExposedStateAsBcelVars(true);
    IntMap proceedMap = makeProceedArgumentMap(adviceVars);

    // System.out.println(proceedMap + " for " + this);
    // System.out.println(argVarList);

    ResolvedType[] proceedParamTypes = world.resolve(munger.getSignature().getParameterTypes());
    // remove this*JoinPoint* as arguments to proceed
    if (munger.getBaseParameterCount() + 1 < proceedParamTypes.length) {
      int len = munger.getBaseParameterCount() + 1;
      ResolvedType[] newTypes = new ResolvedType[len];
      System.arraycopy(proceedParamTypes, 0, newTypes, 0, len);
      proceedParamTypes = newTypes;
    }

    // System.out.println("stateTypes: " + Arrays.asList(stateTypes));
    BcelVar[] proceedVars = Utility.pushAndReturnArrayOfVars(proceedParamTypes, ret, fact, localAdviceMethod);

    Type[] stateTypes = callbackMethod.getArgumentTypes();
    // System.out.println("stateTypes: " + Arrays.asList(stateTypes));

    for (int i = 0, len = stateTypes.length; i < len; i++) {
      Type stateType = stateTypes[i];
      ResolvedType stateTypeX = BcelWorld.fromBcel(stateType).resolve(world);
      if (proceedMap.hasKey(i)) {
        // throw new RuntimeException("unimplemented");
        proceedVars[proceedMap.get(i)].appendLoadAndConvert(ret, fact, stateTypeX);
      } else {
        argVarList.get(i).appendLoad(ret, fact);
      }
    }

View Full Code Here

  }

  private IntMap makeProceedArgumentMap(BcelVar[] adviceArgs) {
    // System.err.println("coming in with " + Arrays.asList(adviceArgs));

    IntMap ret = new IntMap();
    for (int i = 0, len = adviceArgs.length; i < len; i++) {
      BcelVar v = adviceArgs[i];
      if (v == null) {
        continue; // XXX we don't know why this is required
      }
      int pos = v.getPositionInAroundState();
      if (pos >= 0) { // need this test to avoid args bound via cflow
        ret.put(pos, i);
      }
    }
    // System.err.println("returning " + ret);

    return ret;
View Full Code Here

    if (!getKind().allowsExtraction()) {
      throw new BCException("Attempt to extract method from a shadow kind (" + getKind()
          + ") that does not support this operation");
    }
    LazyMethodGen newMethod = createShadowMethodGen(extractedMethodName, extractedMethodVisibilityModifier, parameterNames);
    IntMap remapper = makeRemap();
    range.extractInstructionsInto(newMethod, remapper, (getKind() != PreInitialization) && isFallsThrough());
    if (getKind() == PreInitialization) {
      addPreInitializationReturnCode(newMethod, getSuperConstructorParameterTypes());
    }
    getEnclosingClass().addMethodGen(newMethod, adviceSourceLocation);
View Full Code Here

  /**
   * make a map from old frame location to new frame location. Any unkeyed frame location picks out a copied local
   */
  private IntMap makeRemap() {
    IntMap ret = new IntMap(5);
    int reti = 0;
    if (thisVar != null) {
      ret.put(0, reti++); // thisVar guaranteed to be 0
    }
    if (targetVar != null && targetVar != thisVar) {
      ret.put(targetVar.getSlot(), reti++);
    }
    for (int i = 0, len = argVars.length; i < len; i++) {
      ret.put(argVars[i].getSlot(), reti);
      reti += argVars[i].getType().getSize();
    }
    if (thisJoinPointVar != null) {
      ret.put(thisJoinPointVar.getSlot(), reti++);
    }
    // we not only need to put the arguments, we also need to remap their
    // aliases, which we so helpfully put into temps at the beginning of this join
    // point.
    if (!getKind().argsOnStack()) {
      int oldi = 0;
      int newi = 0;
      // if we're passing in a this and we're not argsOnStack we're always
      // passing in a target too
      if (arg0HoldsThis()) {
        ret.put(0, 0);
        oldi++;
        newi += 1;
      }
      // assert targetVar == thisVar
      for (int i = 0; i < getArgCount(); i++) {
        UnresolvedType type = getArgType(i);
        ret.put(oldi, newi);
        oldi += type.getSize();
        newi += type.getSize();
      }
    }

View Full Code Here

    if (inScope != null) {
      declaringTypeForResolution = getWorld().resolve(inScope.getName());
    } else {
      declaringTypeForResolution = ResolvedType.OBJECT.resolve(getWorld());
    }
    IntMap arity = new IntMap(formalParameters.length);
    for (int i = 0; i < formalParameters.length; i++) {
      arity.put(i, i);
    }
    return pc.concretize(declaringTypeForResolution, declaringTypeForResolution, arity);
  }
View Full Code Here

  }

  // XXX this is the signature we're moving to
  public final Pointcut concretize(ResolvedType inAspect, ResolvedType declaringType, int arity, ShadowMunger advice) {
    // if (state == CONCRETE) return this; //???
    IntMap map = IntMap.idMap(arity);
    map.setEnclosingAdvice(advice);
    map.setConcreteAspect(inAspect);
    return concretize(inAspect, declaringType, map);
  }
View Full Code Here

TOP

Related Classes of org.aspectj.weaver.IntMap

Copyright © 2018 www.massapicom. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.