Example usage for org.aspectj.apache.bcel.classfile JavaClass getSuperclassName

Introduction

In this page you can find the example usage for org.aspectj.apache.bcel.classfile JavaClass getSuperclassName.

Prototype

public String getSuperclassName() 

Source Link

Usage

From source file:br.jabuti.lookup.java.bytecode.RClassCode.java

License:Open Source License

/** Creates a RClassCode given its name and a {@link JavaClass}
 object /*from  w w  w.ja  v  a 2  s . c  om*/
        
 @param y The {@link JavaClass} object already created for this class
 @param x The complete name of the class
 */
public RClassCode(JavaClass y, String x) {
    super(x);
    theClass = null;
    theClassPersistent = Persistency.add(y.getBytes());
    if (theClassPersistent == null)
        theClass = y;
    superName = y.getSuperclassName();
    interfaces = y.getInterfaceNames();
    isInter = y.isInterface();
}

---

From source file:org.caesarj.mixer.intern.ClassModifier.java

License:Open Source License

public void modify(String className, String newClassName, String newSuperclassName, String outerClassName,
        KjcEnvironment env) throws MixerException {
    JavaClass clazz = null;

    // Load the class
    try {//from ww  w . java2 s .  com
        InputStream is = _classPath.getInputStream(className);
        clazz = new ClassParser(is, className).parse();
    } catch (IOException e) {
        throw new MixerException("Class not found " + className);
    }

    String oldSuperclassName = clazz.getSuperclassName().replace('.', '/');

    // use the typesystem to calculate some missing information
    String outerOfOldSuper = null;
    //        CCjSourceClass oldSuperClass = env.getClassReader().findSourceClass(oldSuperclassName);
    CClass oldSuperClass = lookupClass(env, oldSuperclassName);
    if (oldSuperClass != null && oldSuperClass.getOwner() != null) {
        outerOfOldSuper = oldSuperClass.getOwner().getQualifiedName();
    }

    String outerOfNewSuper = null;
    //      CCjSourceClass newSuperClass = env.getClassReader().findSourceClass(newSuperclassName);
    CClass newSuperClass = lookupClass(env, newSuperclassName);
    if (newSuperClass != null && newSuperClass.getOwner() != null) {
        outerOfNewSuper = newSuperClass.getOwner().getQualifiedName();
    }

    // collect all outer classes for this mixin
    Vector<String> outerClasses = new Vector<String>();

    CClass //mixinType =
    //                lookupClass(env, newClassName),
    //                    env.getClassReader().findSourceClass(newClassName),
    //                           outerType = mixinType.getOwner();
    outerType = lookupClass(env, outerClassName);
    while (outerType != null) {
        String identifier = new JavaQualifiedName(outerType.getQualifiedName()).getIdent();
        outerClasses.add(identifier);
        outerType = outerType.getOwner();
    }

    String[] outers = outerClasses.toArray(new String[outerClasses.size()]);

    // tranform class
    final ClassModifyingVisitor visitor = new ClassModifyingVisitor(className, newClassName, newSuperclassName,
            outerClassName, outerOfOldSuper, outerOfNewSuper, outers);

    JavaClass newClass = visitor.transform(clazz);

    // write tranformed class copy
    writeClass(newClassName, newClass);

    //        CClass cc = env.getClassReader().findSourceClass(className);
    CClass cc = lookupClass(env, className);

    CReferenceType[] innerTypes = cc.getInnerClasses();

    // transform anonymous inner classes
    for (int i = 0; i < innerTypes.length; i++) {
        CReferenceType innerType = innerTypes[i];
        CClass inner = innerType.getCClass();
        if (inner.isAnonymous()) {
            String innerClassName = inner.getQualifiedName(),
                    newSuperName = inner.getSuperClass().getQualifiedName(),

                    innerOuterName = className;

            String ident = innerClassName.split("\\$")[1], newInnerName = newClassName + "$" + ident;

            modify(innerClassName, newInnerName, newSuperName, newClassName, env);
        }
    }
}

---

From source file:org.caesarj.mixer.intern.ClassModifyingVisitor.java

License:Open Source License

protected JavaClass transform(JavaClass clazz) throws MixerException {
    // empty collection of anonymous inner classes
    anonymousInners = new Vector<String>();

    oldOuterClassName = Tools.getOuterClass(clazz, oldClassName);
    oldSuperclassName = clazz.getSuperclassName();

    // create a copy as work base
    JavaClass newClass = clazz.copy();/*from   ww w.j  av a2 s .  c om*/

    // find indices of class and super class name
    int classNameIndex = newClass.getClassNameIndex(), superclassNameIndex = newClass.getSuperclassNameIndex();
    ConstantClass cc = (ConstantClass) newClass.getConstantPool().getConstant(classNameIndex),
            csc = (ConstantClass) newClass.getConstantPool().getConstant(superclassNameIndex);
    classNameIndex = cc.getNameIndex();
    superclassNameIndex = csc.getNameIndex();

    // Set new class & superclass name
    newClass.getConstantPool().setConstant(superclassNameIndex, new ConstantUtf8(newSuperclassName));
    newClass.getConstantPool().setConstant(classNameIndex, new ConstantUtf8(newClassName));

    // visit fields, methods and local variables to replace type references
    new DescendingVisitor(newClass, this).visit();

    // Delete all inner class references 
    Attribute[] atts = newClass.getAttributes();
    Vector<Attribute> v = new Vector<Attribute>();
    for (int i = 0; i < atts.length; i++) {
        Attribute attribute = atts[i];
        if (attribute.getTag() == Constants.ATTR_INNER_CLASSES) {
            InnerClasses ic = (InnerClasses) attribute;
            ic.setInnerClasses(new InnerClass[0]);
            ic.setLength(2);

        }
        v.add(attribute);
    }
    atts = v.toArray(new Attribute[v.size()]);
    newClass.setAttributes(atts);

    newClass = removeFactoryMethods(newClass);

    // Mixin classes must be abstract, because they do not implement factory methods,
    // (if the class is final => it was a anonymous inner class)
    if (!newClass.isFinal()) {
        newClass.setAccessFlags(newClass.getAccessFlags() | Constants.ACC_ABSTRACT);
    }

    // take a look at all methodrefs
    modifyMethodAndFieldRefs(newClass);

    // return generated class
    return newClass;
}

---