clirr-devel Mailing List for Clirr (Page 10)

SourceForge Headquarters 1320 Columbia Street Suite 310 San Diego, CA 92101 +1 (858) 422-6466

Update of /cvsroot/clirr/clirr/core/src/java/net/sf/clirr/core/internal/asm
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv6735/src/java/net/sf/clirr/core/internal/asm

Added Files:
	ClassInfoCollector.java package.html AsmMethod.java 
	AsmTypeArrayBuilder.java AsmField.java AbstractAsmScoped.java 
	AsmJavaType.java Repository.java 
Log Message:
Replaced BCEL with ASM.
This lays the groundwork for the Java5 RFEs and also fixes bug 1373831, which was caused by a bug in BCEL.
As an added bonus, the uberjar file size drops by several hundred KB.

--- NEW FILE ---
package net.sf.clirr.core.internal.asm;

import org.objectweb.asm.ClassAdapter;
import org.objectweb.asm.FieldVisitor;
import org.objectweb.asm.MethodVisitor;
import org.objectweb.asm.Type;
import org.objectweb.asm.commons.EmptyVisitor;

/**
 * An ASM class visitor that collects the information clirr needs in a JavaType.
 * @author lk
 *
 */
class ClassInfoCollector extends ClassAdapter
{
    private AsmJavaType javaType;
    private final Repository repository;
    
    ClassInfoCollector(Repository repository)
    {
        super(new EmptyVisitor());
        this.repository = repository;
    }

    public void visit(int version, int access, String name, String signature, String superName, String[] interfaces)
    {
        final String className = prettyprintClassName(name);
        final String superClassName = prettyprintClassName(superName);
        final String[] interfaceNames = prettyprintClassNames(interfaces);
        javaType = new AsmJavaType(repository, access, className, superClassName, interfaceNames);
    }

    public FieldVisitor visitField(int access, String name, String desc, String signature, Object value)
    {
        Type type = Type.getType(desc);
        final AsmField asmField = new AsmField(repository, access, name, value, type);
        javaType.addField(asmField);
        
        // currently no need for visiting annotations 
        return null;
    }

    public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions)
    {
        final Type[] argumentTypes = Type.getArgumentTypes(desc);
        final Type returnType = Type.getReturnType(desc);
        final AsmMethod asmMethod = 
            new AsmMethod(repository, access, returnType, name, argumentTypes, exceptions);
        javaType.addMethod(asmMethod);

        // currently no need for visiting annotations 
        return null;
    }
    
    
    public void visitInnerClass(String name, String outerName, String innerName, int access)
    {
        super.visitInnerClass(name, outerName, innerName, access);
    }

    private static String prettyprintClassName(final String internal)
    {
        if (internal == null)
        {
            return null;
        }
        return internal.replaceAll("/", ".");
    }
    
    private static String[] prettyprintClassNames(String[] internal)
    {
        String[] ret = new String[internal.length];
        for (int i = 0; i < internal.length; i++)
        {
            ret[i] = prettyprintClassName(internal[i]);
        }
        return ret;
    }

    public AsmJavaType getJavaType()
    {
        return javaType;
    }

}

--- NEW FILE ---
<html>
<body>
ObjectWeb's <a target="_top" href="http://asm.objectweb.org">ASM</a> is currently used to read the compiled Java classes.
</body>
</html>
--- NEW FILE ---
package net.sf.clirr.core.internal.asm;

import org.objectweb.asm.Opcodes;
import org.objectweb.asm.Type;

import net.sf.clirr.core.spi.JavaType;
import net.sf.clirr.core.spi.Method;
import net.sf.clirr.core.spi.Scope;

public class AsmMethod extends AbstractAsmScoped implements Method
{
    private final Repository repository;

    private final Type returnType;

    private final String name;

    private final Type[] argumentTypes;

    private final String[] exceptions;
    
    AsmMethod(Repository repository, int access, Type returnType,
            String name, Type[] argumentTypes, String[] exceptions)
    {
        super(access);
        this.repository = repository;
        this.returnType = returnType;
        this.name = name;
        this.argumentTypes = argumentTypes;
        this.exceptions = exceptions;
    }
    
    public JavaType getReturnType()
    {
        if (Type.VOID_TYPE.equals(returnType))
        {
            return null;
        }
        return repository.findTypeByName(returnType.getClassName());
    }

    public JavaType[] getArgumentTypes()
    {
        // TODO support primitive types
        JavaType[] ret = new JavaType[argumentTypes.length];
        for (int i = 0; i < ret.length; i++)
        {
            final String className = argumentTypes[i].getClassName();
            ret[i] = repository.findTypeByName(className);
        }
        return ret;
    }

    public JavaType[] getDeclaredExceptions()
    {
        JavaType[] ret = new JavaType[exceptions.length];
        for (int i = 0; i < ret.length; i++)
        {
            ret[i] = repository.findTypeByName(exceptions[i]);
        }
        return ret;
    }

    public boolean isFinal()
    {
        return checkFlag(Opcodes.ACC_FINAL);
    }

    public boolean isStatic()
    {
        return checkFlag(Opcodes.ACC_STATIC);
    }

    public boolean isAbstract()
    {
        return checkFlag(Opcodes.ACC_ABSTRACT);
    }

    public boolean isDeprecated()
    {
        return checkFlag(Opcodes.ACC_DEPRECATED);
    }

    public String getName()
    {
        return name;
    }

    public Scope getEffectiveScope()
    {
        // TODO Auto-generated method stub
        return getDeclaredScope();
    }

}

--- NEW FILE ---
package net.sf.clirr.core.internal.asm;

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;

import net.sf.clirr.core.CheckerException;
import net.sf.clirr.core.ClassFilter;
import net.sf.clirr.core.ClassSelector;
import net.sf.clirr.core.spi.JavaType;
import net.sf.clirr.core.spi.TypeArrayBuilderSupport;

public class AsmTypeArrayBuilder extends TypeArrayBuilderSupport
{


    public AsmTypeArrayBuilder()
    {
    }

    public JavaType[] createClassSet(File[] jarFiles, ClassLoader thirdPartyClasses, ClassFilter classSelector) throws CheckerException
    {
        if (classSelector == null)
        {
            // create a class selector that selects all classes
            classSelector = new ClassSelector(ClassSelector.MODE_UNLESS);
        }

        ClassLoader classLoader = createClassLoader(jarFiles, thirdPartyClasses);

        Repository repository = new Repository(classLoader);

        List selected = new ArrayList();

        for (int i = 0; i < jarFiles.length; i++)
        {
            File jarFile = jarFiles[i];
            ZipFile zip = null;
            try
            {
                zip = new ZipFile(jarFile, ZipFile.OPEN_READ);
            }
            catch (IOException ex)
            {
                throw new CheckerException(
                    "Cannot open " + jarFile + " for reading", ex);
            }
            Enumeration enumEntries = zip.entries();
            while (enumEntries.hasMoreElements())
            {
                ZipEntry zipEntry = (ZipEntry) enumEntries.nextElement();
                if (!zipEntry.isDirectory() && zipEntry.getName().endsWith(".class"))
                {
                    final AsmJavaType javaType = extractClass(repository, zipEntry, zip);
                    if (classSelector.isSelected(javaType))
                    {
                        selected.add(javaType);
                    }
                }
            }
        }

        JavaType[] ret = new JavaType[selected.size()];
        selected.toArray(ret);
        return ret;

    }
    
    private AsmJavaType extractClass(
            Repository repository, ZipEntry zipEntry, ZipFile zip)
            throws CheckerException
    {
        String name = zipEntry.getName();
        InputStream is = null;
        try
        {
            is = zip.getInputStream(zipEntry);
            
            return repository.readJavaTypeFromStream(is);
        }
        catch (IOException ex)
        {
            throw new CheckerException(
                    "Cannot read " + zipEntry.getName() + " from " + zip.getName(),
                    ex);
        }
        finally
        {
            if (is != null)
            {
                try
                {
                    is.close();
                }
                catch (IOException ex)
                {
                    throw new CheckerException("Cannot close " + zip.getName(), ex);
                }
            }
        }
    }


}

--- NEW FILE ---
package net.sf.clirr.core.internal.asm;

import org.objectweb.asm.Opcodes;
import org.objectweb.asm.Type;

import net.sf.clirr.core.spi.Field;
import net.sf.clirr.core.spi.JavaType;
import net.sf.clirr.core.spi.Scope;

class AsmField extends AbstractAsmScoped implements Field
{
    private final String name;
    private final Object value;
    private final Type type;
    private final Repository repository;

    AsmField(Repository repository, int access, String name, Object value, Type type)
    {
        super(access);
        this.repository = repository;
        this.name = name;
        this.value = value;
        this.type = type;
    }

    public JavaType getType()
    {
        // todo: handle primitive values and arrays
        return repository.findTypeByName(type.getClassName());
    }

    public boolean isFinal()
    {
        return checkFlag(Opcodes.ACC_FINAL);
    }

    public boolean isStatic()
    {
        return checkFlag(Opcodes.ACC_STATIC);
    }

    public boolean isDeprecated()
    {
        return checkFlag(Opcodes.ACC_DEPRECATED);
    }

    public Object getConstantValue()
    {
        return value;
    }

    public String getName()
    {
        return name;
    }

    public Scope getEffectiveScope()
    {
        return getDeclaredScope(); // TODO: FIXME
    }

}

--- NEW FILE ---
package net.sf.clirr.core.internal.asm;

import org.objectweb.asm.Opcodes;

import net.sf.clirr.core.spi.Scope;
import net.sf.clirr.core.spi.Scoped;

abstract class AbstractAsmScoped implements Scoped
{

    private final int access;

    AbstractAsmScoped(int access)
    {
        this.access = access;
    }
    
    public Scope getDeclaredScope()
    {
        if (checkFlag(Opcodes.ACC_PRIVATE))
        {
            return Scope.PRIVATE;
        }
        else if (checkFlag(Opcodes.ACC_PROTECTED))
        {
            return Scope.PROTECTED;
        }
        else if (checkFlag(Opcodes.ACC_PUBLIC))
        {
            return Scope.PUBLIC;
        }
        return Scope.PACKAGE;
    }

    /**
     * @return whether access field has mask set
     */
    protected boolean checkFlag(int mask)
    {
        return (access & mask) != 0;
    }
}

--- NEW FILE ---
package net.sf.clirr.core.internal.asm;

import java.util.ArrayList;
import java.util.List;

import org.objectweb.asm.Opcodes;

import net.sf.clirr.core.spi.Field;
import net.sf.clirr.core.spi.JavaType;
import net.sf.clirr.core.spi.Method;
import net.sf.clirr.core.spi.Scope;

public class AsmJavaType extends AbstractAsmScoped implements JavaType
{
    private final Repository repository;
    
    private final String name;

    private String superClassName;
    
    private final List fields = new ArrayList();
    
    private final List methods = new ArrayList();

    private final String[] interfaceNames;

    public AsmJavaType(Repository repository, int access, String name, String superClassName, String[] interfaceNames)
    {
        super(access);
        this.repository = repository;
        this.name = name;
        this.superClassName = superClassName;
        this.interfaceNames = interfaceNames;
    }

    
    public String getBasicName()
    {
        // TODO handle array types correctly
        return name;
    }
    
    public String getName()
    {
        return name;
    }

    public JavaType getContainingClass()
    {
        // TODO Auto-generated method stub
        return null;
    }

    public JavaType[] getSuperClasses()
    {
        if (superClassName == null)
        {
            return new JavaType[0];
        }
        JavaType superType = repository.findTypeByName(superClassName);
        final JavaType[] superSuper = superType.getSuperClasses();
        JavaType[] ret = new JavaType[superSuper.length + 1];
        System.arraycopy(superSuper, 0, ret, 0, superSuper.length);
        ret[superSuper.length] = superType;
        return ret;
    }

    public JavaType[] getAllInterfaces()
    {
        JavaType[] ret = new JavaType[interfaceNames.length];
        for (int i = 0; i < ret.length; i++)
        {
            ret[i] = repository.findTypeByName(interfaceNames[i]);
        }
        return ret;
    }

    public JavaType[] getInnerClasses()
    {
        // TODO Auto-generated method stub
        return null;
    }

    void addMethod(Method method)
    {
        methods.add(method);
    }

    public Method[] getMethods()
    {
        Method[] ret = new Method[methods.size()];
        methods.toArray(ret);
        return ret;
    }

    void addField(Field field)
    {
        fields.add(field);
    }
    
    public Field[] getFields()
    {
        Field[] ret = new Field[fields.size()];
        fields.toArray(ret);
        return ret;
    }

    public boolean isPrimitive()
    {
        // TODO Auto-generated method stub
        return false;
    }

    public int getArrayDimension()
    {
        // TODO: handle correctly for method argument and return types
        return 0;
    }

    public boolean isFinal()
    {
        return checkFlag(Opcodes.ACC_FINAL);
    }

    public boolean isAbstract()
    {
        return checkFlag(Opcodes.ACC_ABSTRACT);
    }

    public boolean isInterface()
    {
        return checkFlag(Opcodes.ACC_INTERFACE);
    }

    public Scope getEffectiveScope()
    {
        // TODO: replace with real impl
        return getDeclaredScope();
    }

    public String toString()
    {
        return "AsmJavaType[" + name + "]";
    }
}

--- NEW FILE ---
package net.sf.clirr.core.internal.asm;

import java.io.IOException;
import java.io.InputStream;
import java.net.URLClassLoader;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import net.sf.clirr.core.spi.Field;
import net.sf.clirr.core.spi.JavaType;
import net.sf.clirr.core.spi.Method;
import net.sf.clirr.core.spi.Scope;

import org.objectweb.asm.ClassReader;

/**
 * Stores all known JavaTypes, used to implement crossreferences between types.
 *  
 * @author lkuehne
 */
class Repository
{
    private static final Pattern PRIMITIVE_PATTERN = Pattern.compile("(int|float|long|double|boolean|char|short)(\\[\\])*");

    private static final class PrimitiveType implements JavaType
    {
        private final String basicName;
        private final int dimension;

        private PrimitiveType(String name, int dimension)
        {
            this.basicName = name;
            this.dimension = dimension;
        }
        
        public String getBasicName()
        {
            return basicName;
        }

        public String getName()
        {
            String name = basicName;
            for (int i = 0; i < getArrayDimension(); i++)
            {
                name += "[]";
            }
            return basicName;
        }

        public JavaType getContainingClass()
        {
            return null;
        }

        public JavaType[] getSuperClasses()
        {
            return new JavaType[0];
        }

        public JavaType[] getAllInterfaces()
        {
            return new JavaType[0];
        }

        public JavaType[] getInnerClasses()
        {
            return new JavaType[0];
        }

        public Method[] getMethods()
        {
            return new Method[0];
        }

        public Field[] getFields()
        {
            return new Field[0];
        }

        public int getArrayDimension()
        {
            return dimension;
        }

        public boolean isPrimitive()
        {
            return true;
        }

        public boolean isFinal()
        {
            return true;
        }

        public boolean isAbstract()
        {
            return false;
        }

        public boolean isInterface()
        {
            return false;
        }

        public Scope getDeclaredScope()
        {
            return Scope.PUBLIC;
        }

        public Scope getEffectiveScope()
        {
            // TODO Auto-generated method stub
            return null;
        }
        
        public String toString()
        {
            return getName();
        }
    }

    private final ClassLoader classLoader;
    private Map nameTypeMap = new HashMap();

    public Repository(ClassLoader classLoader)
    {
        this.classLoader = classLoader;
    }

    /**
     * @param is
     * @return
     * @throws IOException
     */
    AsmJavaType readJavaTypeFromStream(InputStream is) throws IOException
    {
        ClassReader parser = new ClassReader(is);
        
        ClassInfoCollector infoCollector = new ClassInfoCollector(this);
        
        parser.accept(infoCollector, true);
        
        final AsmJavaType javaType = infoCollector.getJavaType();
        
        nameTypeMap.put(javaType.getName(), javaType);
        return javaType;
    }

    public JavaType findTypeByName(String typeName)
    {
        JavaType type = (JavaType) nameTypeMap.get(typeName);
        if (type != null)
        {
            return type;
        }
        final Matcher matcher = PRIMITIVE_PATTERN.matcher(typeName);
        if (matcher.matches())
        {
            final String basicType = matcher.group(1);
            final String arrayBrackets = matcher.group(2);
            final int dimension = arrayBrackets == null ? 0 : arrayBrackets.length() / 2;
            JavaType primitive = new PrimitiveType(basicType, dimension);
            nameTypeMap.put(typeName, primitive);
            return primitive; 
        }
        String resourceName = typeName.replace('.', '/') + ".class";
        InputStream is = classLoader.getResourceAsStream(resourceName);
        if (is == null)
        {
            String clDetails;
            if (classLoader instanceof URLClassLoader)
            {
                URLClassLoader ucl = (URLClassLoader) classLoader;
                clDetails = String.valueOf(Arrays.asList(ucl.getURLs()));
            }
            else
            {
                clDetails = String.valueOf(classLoader);
            }
            throw new IllegalArgumentException("Type " + typeName + " is unknown in classLoader " + clDetails);
        }
        try
        {
            return readJavaTypeFromStream(is);
        }
        catch (IOException ex)
        {
            throw new IllegalStateException();
        }
        finally
        {
            try
            {
                is.close();
            }
            catch (IOException e)
            {
            }
        }
    }

}

2003	Jan	Feb	Mar	Apr	May	Jun	Jul	Aug	Sep (15)	Oct (23)	Nov	Dec (25)
2004	Jan (9)	Feb	Mar	Apr	May (76)	Jun (207)	Jul (242)	Aug (42)	Sep (33)	Oct	Nov (7)	Dec (1)
2005	Jan	Feb	Mar (5)	Apr	May	Jun	Jul (3)	Aug (66)	Sep (38)	Oct (6)	Nov	Dec (2)
2006	Jan (17)	Feb (5)	Mar (28)	Apr (6)	May	Jun	Jul (1)	Aug	Sep	Oct (1)	Nov (1)	Dec (7)
2007	Jan	Feb	Mar	Apr (7)	May (33)	Jun (4)	Jul (3)	Aug	Sep (5)	Oct	Nov	Dec
2008	Jan (4)	Feb (3)	Mar (2)	Apr	May (1)	Jun	Jul (6)	Aug (8)	Sep (5)	Oct (20)	Nov (7)	Dec (9)
2009	Jan (8)	Feb (3)	Mar (20)	Apr (10)	May (40)	Jun (11)	Jul (23)	Aug (4)	Sep (1)	Oct (1)	Nov	Dec (2)
2010	Jan (5)	Feb (1)	Mar	Apr	May	Jun (1)	Jul	Aug (2)	Sep	Oct	Nov	Dec
2011	Jan	Feb	Mar	Apr (3)	May	Jun	Jul	Aug	Sep	Oct	Nov	Dec (1)
2012	Jan	Feb	Mar	Apr	May	Jun	Jul	Aug (1)	Sep	Oct	Nov	Dec
2013	Jan	Feb	Mar	Apr (6)	May (22)	Jun (2)	Jul	Aug	Sep	Oct (2)	Nov (1)	Dec (2)
2014	Jan (5)	Feb	Mar	Apr	May (1)	Jun	Jul	Aug	Sep	Oct	Nov (1)	Dec
2015	Jan (1)	Feb (2)	Mar (1)	Apr	May	Jun	Jul	Aug	Sep	Oct	Nov	Dec
2016	Jan	Feb	Mar	Apr	May	Jun	Jul	Aug	Sep	Oct (1)	Nov	Dec
2017	Jan	Feb	Mar (1)	Apr	May	Jun	Jul	Aug	Sep	Oct	Nov	Dec

clirr-devel Mailing List for Clirr (Page 10)

clirr-devel — Discussion about the source code of Clirr