예제 #1
0
파일: CtNewMethod.java 프로젝트: bily/fsxp
  /**
   * Creates a public setter method. The setter method assigns the value of the first parameter to
   * the specified field in the class to which this method is added. The created method is not
   * static even if the field is static. You may not change it to be static by <code>setModifiers()
   * </code> in <code>CtBehavior</code>.
   *
   * @param methodName the name of the setter
   * @param field the field accessed.
   */
  public static CtMethod setter(String methodName, CtField field) throws CannotCompileException {
    FieldInfo finfo = field.getFieldInfo2();
    String fieldType = finfo.getDescriptor();
    String desc = "(" + fieldType + ")V";
    ConstPool cp = finfo.getConstPool();
    MethodInfo minfo = new MethodInfo(cp, methodName, desc);
    minfo.setAccessFlags(AccessFlag.PUBLIC);

    Bytecode code = new Bytecode(cp, 3, 3);
    try {
      String fieldName = finfo.getName();
      if ((finfo.getAccessFlags() & AccessFlag.STATIC) == 0) {
        code.addAload(0);
        code.addLoad(1, field.getType());
        code.addPutfield(Bytecode.THIS, fieldName, fieldType);
      } else {
        code.addLoad(1, field.getType());
        code.addPutstatic(Bytecode.THIS, fieldName, fieldType);
      }

      code.addReturn(null);
    } catch (NotFoundException e) {
      throw new CannotCompileException(e);
    }

    minfo.setCodeAttribute(code.toCodeAttribute());
    return new CtMethod(minfo, field.getDeclaringClass());
  }
 public String apply(StaticFieldDescriptor from) {
   // this is quite simple. First we create a proxy
   String proxyName = ProxyDefinitionStore.getProxyName();
   ClassFile proxy = new ClassFile(false, proxyName, "java.lang.Object");
   ClassDataStore.instance().registerProxyName(from.getClazz(), proxyName);
   proxy.setAccessFlags(AccessFlag.PUBLIC);
   FieldInfo newField =
       new FieldInfo(proxy.getConstPool(), from.getName(), from.getDescriptor());
   newField.setAccessFlags(AccessFlag.PUBLIC | AccessFlag.STATIC);
   if (from.getSigniture() != null) {
     SignatureAttribute sig =
         new SignatureAttribute(proxy.getConstPool(), from.getSigniture());
     newField.addAttribute(sig);
   }
   try {
     proxy.addField(newField);
     ByteArrayOutputStream bytes = new ByteArrayOutputStream();
     DataOutputStream dos = new DataOutputStream(bytes);
     try {
       proxy.write(dos);
     } catch (IOException e) {
       throw new RuntimeException(e);
     }
     ProxyDefinitionStore.saveProxyDefinition(
         from.getClazz().getClassLoader(), proxyName, bytes.toByteArray());
   } catch (DuplicateMemberException e) {
     // can't happen
   }
   return proxyName;
 }
    @Override
    protected void doInjection(String value) {
      final FieldInfo ctFieldInfo = ctField.getFieldInfo();

      ctFieldInfo.addAttribute(
          new ConstantAttribute(
              ctFieldInfo.getConstPool(), ctFieldInfo.getConstPool().addStringInfo(value)));
    }
예제 #4
0
  public BaseClassData(ClassFile file, ClassLoader loader, boolean replaceable) {
    className = file.getName();
    this.replaceable = replaceable;
    internalName = Descriptor.toJvmName(file.getName());
    this.loader = loader;
    superClassName = file.getSuperclass();
    boolean finalMethod = false;
    Set<MethodData> meths = new HashSet<MethodData>();
    for (Object o : file.getMethods()) {
      String methodClassName = className;
      MethodInfo m = (MethodInfo) o;
      MemberType type = MemberType.NORMAL;
      if ((m.getDescriptor().equals(Constants.ADDED_METHOD_DESCRIPTOR)
              && m.getName().equals(Constants.ADDED_METHOD_NAME))
          || (m.getDescriptor().equals(Constants.ADDED_STATIC_METHOD_DESCRIPTOR)
              && m.getName().equals(Constants.ADDED_STATIC_METHOD_NAME))
          || (m.getDescriptor().equals(Constants.ADDED_CONSTRUCTOR_DESCRIPTOR))) {
        type = MemberType.ADDED_SYSTEM;
      } else if (m.getAttribute(Constants.FINAL_METHOD_ATTRIBUTE) != null) {
        finalMethod = true;
      }

      MethodData md =
          new MethodData(
              m.getName(),
              m.getDescriptor(),
              methodClassName,
              type,
              m.getAccessFlags(),
              finalMethod);
      meths.add(md);
    }
    this.methods = Collections.unmodifiableSet(meths);
    Set<FieldData> fieldData = new HashSet<FieldData>();
    for (Object o : file.getFields()) {
      FieldInfo m = (FieldInfo) o;
      MemberType mt = MemberType.NORMAL;
      fieldData.add(new FieldData(m, mt, className, m.getAccessFlags()));
    }
    this.fields = Collections.unmodifiableSet(fieldData);
  }