• Home
• net.wetheinter
• xapi-dev
• 0.5
• source code
• CtClassType.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

xapi.bytecode.CtClassType Maven / Gradle / Ivy

/*
 * Javassist, a Java-bytecode translator toolkit.
 * Copyright (C) 1999- Shigeru Chiba. All Rights Reserved.
 *
 * The contents of this file are subject to the Mozilla Public License Version
 * 1.1 (the "License"); you may not use this file except in compliance with
 * the License.  Alternatively, the contents of this file may be used under
 * the terms of the GNU Lesser General Public License Version 2.1 or later,
 * or the Apache License Version 2.0.
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * MODIFIED BY James Nelson of We The Internet, 2013.
 * Repackaged to avoid conflicts with different versions of Javassist,
 * and modified Javassist APIs to make them more accessible to outside code.
 */
package xapi.bytecode;

import static xapi.source.X_Modifier.ABSTRACT;
import static xapi.source.X_Modifier.INTERFACE;
import static xapi.source.X_Modifier.PUBLIC;
import static xapi.source.X_Modifier.isPrivate;

import java.io.BufferedInputStream;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.lang.ref.WeakReference;
import java.net.URL;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.List;
import java.util.Set;

import xapi.bytecode.CtMember.Cache;
import xapi.bytecode.annotation.Annotation;
import xapi.bytecode.annotation.AnnotationsAttribute;
import xapi.bytecode.attributes.AttributeInfo;
import xapi.bytecode.attributes.InnerClassesAttribute;
import xapi.bytecode.attributes.ParameterAnnotationsAttribute;
import xapi.source.X_Modifier;

@SuppressWarnings({"unchecked", "rawtypes"})
public class CtClassType extends CtClass {
  ClassPool classPool;
  boolean wasChanged;
  boolean wasPruned;
  boolean gcConstPool; // if true, the constant pool entries will be garbage
                       // collected.
  ClassFile classfile;
  byte[] rawClassfile; // backup storage

  private WeakReference memberCache;

  private Hashtable hiddenMethods; // must be synchronous
  private int uniqueNumberSeed;

  private boolean doPruning = ClassPool.doPruning;
  private int getCount;
  private static final int GET_THRESHOLD = 2; // see compress()

  CtClassType(String name, ClassPool cp) {
    super(name);
    classPool = cp;
    wasChanged = wasPruned = gcConstPool = false;
    classfile = null;
    rawClassfile = null;
    memberCache = null;
    hiddenMethods = null;
    uniqueNumberSeed = 0;
    getCount = 0;
  }

  public CtClassType(InputStream ins, ClassPool cp) throws IOException {
    this((String) null, cp);
    classfile = new ClassFile(new DataInputStream(ins));
    qualifiedName = classfile.getName();
  }

  @Override
  public ClassFile getClassFile2() {
    ClassFile cfile = classfile;
    if (cfile != null) {
      return cfile;
    }

    classPool.compress();
    if (rawClassfile != null) {
      try {
        classfile = new ClassFile(new DataInputStream(new ByteArrayInputStream(
            rawClassfile)));
        rawClassfile = null;
        getCount = GET_THRESHOLD;
        return classfile;
      } catch (IOException e) {
        throw new RuntimeException(e.toString(), e);
      }
    }

    InputStream fin = null;
    try {
      fin = classPool.openClassfile(getName());
      if (fin == null) {
        throw new NotFoundException(getName());
      }

      fin = new BufferedInputStream(fin);
      ClassFile cf = new ClassFile(new DataInputStream(fin));
      if (!cf.getName().equals(qualifiedName)) {
        throw new RuntimeException("cannot find " + qualifiedName + ": "
            + cf.getName() + " found in " + qualifiedName.replace('.', '/')
            + ".class");
      }

      classfile = cf;
      return cf;
    } catch (NotFoundException e) {
      throw new RuntimeException(e.toString(), e);
    } catch (IOException e) {
      throw new RuntimeException(e.toString(), e);
    } finally {
      if (fin != null) {
        try {
          fin.close();
        } catch (IOException e) {
        }
      }
    }
  }

  /*
   * Inherited from CtClass. Called by get() in ClassPool.
   *
   * @see javassist.CtClass#incGetCounter()
   *
   * @see #toBytecode(DataOutputStream)
   */
  @Override
  final void incGetCounter() {
    ++getCount;
  }

  /**
   * Invoked from ClassPool#compress(). It releases the class files that have
   * not been recently used if they are unmodified.
   */
  @Override
  void compress() {
    if (getCount < GET_THRESHOLD) {
      if (!isModified() && ClassPool.releaseUnmodifiedClassFile) {
        removeClassFile();
      } else if (isFrozen() && !wasPruned) {
        saveClassFile();
      }
    }

    getCount = 0;
  }

  /**
   * Converts a ClassFile object into a byte array for saving memory space.
   */
  private synchronized void saveClassFile() {
    /*
     * getMembers() and releaseClassFile() are also synchronized.
     */
    if (classfile == null) {
      return;
    }

    ByteArrayOutputStream barray = new ByteArrayOutputStream();
    DataOutputStream out = new DataOutputStream(barray);
    try {
      classfile.write(out);
      barray.close();
      rawClassfile = barray.toByteArray();
      classfile = null;
    } catch (IOException e) {
    }
  }

  private synchronized void removeClassFile() {
    if (classfile != null && !isModified()) {
      classfile = null;
    }
  }

  @Override
  public ClassPool getClassPool() {
    return classPool;
  }

  void setClassPool(ClassPool cp) {
    classPool = cp;
  }

  @Override
  public URL getURL() throws NotFoundException {
    URL url = classPool.find(getName());
    if (url == null) {
      throw new NotFoundException(getName());
    } else {
      return url;
    }
  }

  @Override
  public boolean isModified() {
    return wasChanged;
  }

  @Override
  public boolean subtypeOf(CtClass clazz) throws NotFoundException {
    int i;
    String cname = clazz.getName();
    if (this == clazz || getName().equals(cname)) {
      return true;
    }

    ClassFile file = getClassFile2();
    String supername = file.getSuperclass();
    if (supername != null && supername.equals(cname)) {
      return true;
    }

    String[] ifs = file.getInterfaces();
    int num = ifs.length;
    for (i = 0; i < num; ++i) {
      if (ifs[i].equals(cname)) {
        return true;
      }
    }

    if (supername != null && classPool.get(supername).subtypeOf(clazz)) {
      return true;
    }

    for (i = 0; i < num; ++i) {
      if (classPool.get(ifs[i]).subtypeOf(clazz)) {
        return true;
      }
    }

    return false;
  }

  // @Override
  @Override
  public void setName(String name) throws RuntimeException {
    String oldname = getName();
    if (name.equals(oldname)) {
      return;
    }

    // check this in advance although classNameChanged() below does.
    classPool.checkNotFrozen(name);
    ClassFile cf = getClassFile2();
    super.setName(name);
    cf.setName(name);
    nameReplaced();
    classPool.classNameChanged(oldname, this);
  }

  private void nameReplaced() {
    CtMember.Cache cache = hasMemberCache();
    if (cache != null) {
      CtMember mth = cache.methodHead();
      CtMember tail = cache.lastMethod();
      while (mth != tail) {
        mth = mth.next();
        mth.nameReplaced();
      }
    }
  }

  /**
   * Returns null if members are not cached.
   */
  protected CtMember.Cache hasMemberCache() {
    if (memberCache != null) {
      return (CtMember.Cache) memberCache.get();
    } else {
      return null;
    }
  }

  @Override
  public boolean isInterface() {
    return X_Modifier.isInterface(getModifiers());
  }

  @Override
  public boolean isAnnotation() {
    return X_Modifier.isAnnotation(getModifiers());
  }

  @Override
  public boolean isEnum() {
    return X_Modifier.isEnum(getModifiers());
  }

  @Override
  public int getModifiers() {
    ClassFile cf = getClassFile2();
    int acc = cf.getAccessFlags();

    acc = X_Modifier.clear(acc, X_Modifier.SUPER);
    int inner = cf.getInnerAccessFlags();
    if (inner != -1 && (inner & X_Modifier.STATIC) != 0) {
      acc |= X_Modifier.STATIC;
    }

    return acc;
  }

  @Override
  public CtClass[] getNestedClasses() throws NotFoundException {
    ClassFile cf = getClassFile2();
    InnerClassesAttribute ica = (InnerClassesAttribute) cf
        .getAttribute(InnerClassesAttribute.tag);
    if (ica == null) {
      return new CtClass[0];
    }

    String thisName = cf.getName();
    int n = ica.tableLength();
    ArrayList list = new ArrayList(n);
    for (int i = 0; i < n; i++) {
      String outer = ica.outerClass(i);
      /*
       * If a nested class is local or anonymous, the outer_class_info_index is
       * 0.
       */
      if (outer == null || outer.equals(thisName)) {
        String inner = ica.innerClass(i);
        if (inner != null) {
          list.add(classPool.get(inner));
        }
      }
    }

    return (CtClass[]) list.toArray(new CtClass[list.size()]);
  }

  @Override
  public void setModifiers(int mod) {
    ClassFile cf = getClassFile2();
    if (X_Modifier.isStatic(mod)) {
      int flags = cf.getInnerAccessFlags();
      if (flags != -1 && (flags & X_Modifier.STATIC) != 0) {
        mod = mod & ~X_Modifier.STATIC;
      } else {
        throw new RuntimeException("cannot change " + getName()
            + " into a static class");
      }
    }

    checkModify();
    cf.setAccessFlags(mod);
  }

  @Override
  public boolean hasAnnotation(Class clz) {
    ClassFile cf = getClassFile2();
    AnnotationsAttribute ainfo = (AnnotationsAttribute) cf
        .getAttribute(AnnotationsAttribute.invisibleTag);
    AnnotationsAttribute ainfo2 = (AnnotationsAttribute) cf
        .getAttribute(AnnotationsAttribute.visibleTag);
    return hasAnnotationType(clz, getClassPool(), ainfo, ainfo2);
  }

  static boolean hasAnnotationType(Class clz, ClassPool cp,
      AnnotationsAttribute a1, AnnotationsAttribute a2) {
    Annotation[] anno1, anno2;

    if (a1 == null) {
      anno1 = null;
    } else {
      anno1 = a1.getAnnotations();
    }

    if (a2 == null) {
      anno2 = null;
    } else {
      anno2 = a2.getAnnotations();
    }

    String typeName = clz.getName();
    if (anno1 != null) {
      for (int i = 0; i < anno1.length; i++) {
        if (anno1[i].getTypeName().equals(typeName)) {
          return true;
        }
      }
    }

    if (anno2 != null) {
      for (int i = 0; i < anno2.length; i++) {
        if (anno2[i].getTypeName().equals(typeName)) {
          return true;
        }
      }
    }

    return false;
  }

  @Override
  public Object getAnnotation(Class clz) throws ClassNotFoundException {
    ClassFile cf = getClassFile2();
    AnnotationsAttribute ainfo = (AnnotationsAttribute) cf
        .getAttribute(AnnotationsAttribute.invisibleTag);
    AnnotationsAttribute ainfo2 = (AnnotationsAttribute) cf
        .getAttribute(AnnotationsAttribute.visibleTag);
    return getAnnotationType(clz, getClassPool(), ainfo, ainfo2);
  }

  static Object getAnnotationType(Class clz, ClassPool cp,
      AnnotationsAttribute a1, AnnotationsAttribute a2)
      throws ClassNotFoundException {
    Annotation[] anno1, anno2;

    if (a1 == null) {
      anno1 = null;
    } else {
      anno1 = a1.getAnnotations();
    }

    if (a2 == null) {
      anno2 = null;
    } else {
      anno2 = a2.getAnnotations();
    }

    String typeName = clz.getName();
    if (anno1 != null) {
      for (int i = 0; i < anno1.length; i++) {
        if (anno1[i].getTypeName().equals(typeName)) {
          return toAnnoType(anno1[i], cp);
        }
      }
    }

    if (anno2 != null) {
      for (int i = 0; i < anno2.length; i++) {
        if (anno2[i].getTypeName().equals(typeName)) {
          return toAnnoType(anno2[i], cp);
        }
      }
    }

    return null;
  }

  @Override
  public Object[] getAnnotations() throws ClassNotFoundException {
    return getAnnotations(false);
  }

  @Override
  public Object[] getAvailableAnnotations() {
    try {
      return getAnnotations(true);
    } catch (ClassNotFoundException e) {
      throw new RuntimeException("Unexpected exception ", e);
    }
  }

  private Object[] getAnnotations(boolean ignoreNotFound)
      throws ClassNotFoundException {
    ClassFile cf = getClassFile2();
    AnnotationsAttribute ainfo = (AnnotationsAttribute) cf
        .getAttribute(AnnotationsAttribute.invisibleTag);
    AnnotationsAttribute ainfo2 = (AnnotationsAttribute) cf
        .getAttribute(AnnotationsAttribute.visibleTag);
    return toAnnotationType(ignoreNotFound, getClassPool(), ainfo, ainfo2);
  }

  static Object[] toAnnotationType(boolean ignoreNotFound, ClassPool cp,
      AnnotationsAttribute a1, AnnotationsAttribute a2)
      throws ClassNotFoundException {
    Annotation[] anno1, anno2;
    int size1, size2;

    if (a1 == null) {
      anno1 = null;
      size1 = 0;
    } else {
      anno1 = a1.getAnnotations();
      size1 = anno1.length;
    }

    if (a2 == null) {
      anno2 = null;
      size2 = 0;
    } else {
      anno2 = a2.getAnnotations();
      size2 = anno2.length;
    }

    if (!ignoreNotFound) {
      Object[] result = new Object[size1 + size2];
      for (int i = 0; i < size1; i++) {
        result[i] = toAnnoType(anno1[i], cp);
      }

      for (int j = 0; j < size2; j++) {
        result[j + size1] = toAnnoType(anno2[j], cp);
      }

      return result;
    } else {
      ArrayList