| /* Copyright 2006 aQute SARL |
| * Licensed under the Apache License, Version 2.0, see http://www.apache.org/licenses/LICENSE-2.0 */ |
| package aQute.lib.osgi; |
| |
| import java.io.*; |
| import java.nio.*; |
| import java.util.*; |
| |
| public class Clazz { |
| public static enum QUERY { |
| IMPLEMENTS, EXTENDS, IMPORTS, NAMED, ANY, VERSION |
| }; |
| |
| static protected class Assoc { |
| Assoc(byte tag, int a, int b) { |
| this.tag = tag; |
| this.a = a; |
| this.b = b; |
| } |
| |
| byte tag; |
| int a; |
| int b; |
| } |
| |
| final static byte SkipTable[] = { 0, // 0 non existent |
| -1, // 1 CONSTANT_utf8 UTF 8, handled in |
| // method |
| -1, // 2 |
| 4, // 3 CONSTANT_Integer |
| 4, // 4 CONSTANT_Float |
| 8, // 5 CONSTANT_Long (index +=2!) |
| 8, // 6 CONSTANT_Double (index +=2!) |
| -1, // 7 CONSTANT_Class |
| 2, // 8 CONSTANT_String |
| 4, // 9 CONSTANT_FieldRef |
| 4, // 10 CONSTANT_MethodRef |
| 4, // 11 CONSTANT_InterfaceMethodRef |
| 4, // 12 CONSTANT_NameAndType |
| }; |
| |
| String className; |
| Object pool[]; |
| int intPool[]; |
| Map<String, Map<String, String>> imports = new HashMap<String, Map<String, String>>(); |
| String path; |
| |
| // static String type = "([BCDFIJSZ\\[]|L[^<>]+;)"; |
| // static Pattern descriptor = Pattern.compile("\\(" + type + "*\\)((" |
| // + type + ")|V)"); |
| int minor = 0; |
| int major = 0; |
| |
| String sourceFile; |
| Set<String> xref; |
| Set<Integer> classes; |
| Set<Integer> descriptors; |
| int forName = 0; |
| int class$ = 0; |
| String[] interfaces; |
| String zuper; |
| |
| public Clazz(String path) { |
| this.path = path; |
| } |
| |
| public Clazz(String path, InputStream in) throws IOException { |
| this.path = path; |
| DataInputStream din = new DataInputStream(in); |
| parseClassFile(din); |
| din.close(); |
| } |
| |
| Set<String> parseClassFile(DataInputStream in) throws IOException { |
| xref = new HashSet<String>(); |
| classes = new HashSet<Integer>(); |
| descriptors = new HashSet<Integer>(); |
| |
| boolean crawl = false; // Crawl the byte code |
| int magic = in.readInt(); |
| if (magic != 0xCAFEBABE) |
| throw new IOException("Not a valid class file (no CAFEBABE header)"); |
| |
| minor = in.readUnsignedShort(); // minor version |
| major = in.readUnsignedShort(); // major version |
| int count = in.readUnsignedShort(); |
| pool = new Object[count]; |
| intPool = new int[count]; |
| |
| process: for (int poolIndex = 1; poolIndex < count; poolIndex++) { |
| byte tag = in.readByte(); |
| switch (tag) { |
| case 0: |
| break process; |
| case 1: |
| constantUtf8(in, poolIndex); |
| break; |
| |
| // For some insane optimization reason are |
| // the long and the double two entries in the |
| // constant pool. See 4.4.5 |
| case 5: |
| constantLong(in, poolIndex); |
| poolIndex++; |
| break; |
| |
| case 6: |
| constantDouble(in, poolIndex); |
| poolIndex++; |
| break; |
| |
| case 7: |
| constantClass(in, poolIndex); |
| break; |
| |
| case 8: |
| constantString(in, poolIndex); |
| break; |
| |
| case 10: // Method ref |
| methodRef(in, poolIndex); |
| break; |
| |
| // Name and Type |
| case 12: |
| nameAndType(in, poolIndex, tag); |
| break; |
| |
| // We get the skip count for each record type |
| // from the SkipTable. This will also automatically |
| // abort when |
| default: |
| if (tag == 2) |
| throw new IOException("Invalid tag " + tag); |
| in.skipBytes(SkipTable[tag]); |
| break; |
| } |
| } |
| |
| pool(pool, intPool); |
| /* |
| * Parse after the constant pool, code thanks to Hans Christian |
| * Falkenberg |
| */ |
| |
| /* int access_flags = */in.readUnsignedShort(); // access |
| int this_class = in.readUnsignedShort(); |
| int super_class = in.readUnsignedShort(); |
| zuper = (String) pool[intPool[super_class]]; |
| if (zuper != null) { |
| addReference(zuper); |
| } |
| className = (String) pool[intPool[this_class]]; |
| |
| int interfacesCount = in.readUnsignedShort(); |
| if (interfacesCount > 0) { |
| interfaces = new String[interfacesCount]; |
| for (int i = 0; i < interfacesCount; i++) |
| interfaces[i] = (String) pool[intPool[in.readUnsignedShort()]]; |
| } |
| |
| int fieldsCount = in.readUnsignedShort(); |
| for (int i = 0; i < fieldsCount; i++) { |
| /* access_flags = */in.readUnsignedShort(); // skip access flags |
| int name_index = in.readUnsignedShort(); |
| int descriptor_index = in.readUnsignedShort(); |
| |
| // Java prior to 1.5 used a weird |
| // static variable to hold the com.X.class |
| // result construct. If it did not find it |
| // it would create a variable class$com$X |
| // that would be used to hold the class |
| // object gotten with Class.forName ... |
| // Stupidly, they did not actively use the |
| // class name for the field type, so bnd |
| // would not see a reference. We detect |
| // this case and add an artificial descriptor |
| String name = pool[name_index].toString(); // name_index |
| if (name.startsWith("class$")) { |
| crawl = true; |
| } |
| |
| descriptors.add(new Integer(descriptor_index)); |
| doAttributes(in, false); |
| } |
| |
| // |
| // Check if we have to crawl the code to find |
| // the ldc(_w) <string constant> invokestatic Class.forName |
| // if so, calculate the method ref index so we |
| // can do this efficiently |
| // |
| if (crawl) { |
| forName = findMethod("java/lang/Class", "forName", |
| "(Ljava/lang/String;)Ljava/lang/Class;"); |
| class$ = findMethod(className, "class$", |
| "(Ljava/lang/String;)Ljava/lang/Class;"); |
| } |
| |
| // |
| // Handle the methods |
| // |
| int methodCount = in.readUnsignedShort(); |
| for (int i = 0; i < methodCount; i++) { |
| /* access_flags = */in.readUnsignedShort(); |
| /* int name_index = */in.readUnsignedShort(); |
| int descriptor_index = in.readUnsignedShort(); |
| // String s = (String) pool[name_index]; |
| descriptors.add(new Integer(descriptor_index)); |
| doAttributes(in, crawl); |
| } |
| |
| doAttributes(in, false); |
| |
| // |
| // Now iterate over all classes we found and |
| // parse those as well. We skip duplicates |
| // |
| |
| for (Iterator<Integer> e = classes.iterator(); e.hasNext();) { |
| int class_index = e.next().shortValue(); |
| doClassReference((String) pool[class_index]); |
| } |
| |
| // |
| // Parse all the descriptors we found |
| // |
| |
| for (Iterator<Integer> e = descriptors.iterator(); e.hasNext();) { |
| Integer index = e.next(); |
| String prototype = (String) pool[index.intValue()]; |
| if (prototype != null) |
| parseDescriptor(prototype); |
| else |
| System.err.println("Unrecognized descriptor: " + index); |
| } |
| Set<String> xref = this.xref; |
| reset(); |
| return xref; |
| } |
| |
| protected void pool(Object[] pool, int[] intPool) { |
| } |
| |
| /** |
| * @param in |
| * @param poolIndex |
| * @param tag |
| * @throws IOException |
| */ |
| protected void nameAndType(DataInputStream in, int poolIndex, byte tag) |
| throws IOException { |
| int name_index = in.readUnsignedShort(); |
| int descriptor_index = in.readUnsignedShort(); |
| descriptors.add(new Integer(descriptor_index)); |
| pool[poolIndex] = new Assoc(tag, name_index, descriptor_index); |
| } |
| |
| /** |
| * @param in |
| * @param poolIndex |
| * @param tag |
| * @throws IOException |
| */ |
| private void methodRef(DataInputStream in, int poolIndex) |
| throws IOException { |
| int class_index = in.readUnsignedShort(); |
| int name_and_type_index = in.readUnsignedShort(); |
| pool[poolIndex] = new Assoc((byte) 10, class_index, name_and_type_index); |
| } |
| |
| /** |
| * @param in |
| * @param poolIndex |
| * @throws IOException |
| */ |
| private void constantString(DataInputStream in, int poolIndex) |
| throws IOException { |
| int string_index = in.readUnsignedShort(); |
| intPool[poolIndex] = string_index; |
| } |
| |
| /** |
| * @param in |
| * @param poolIndex |
| * @throws IOException |
| */ |
| protected void constantClass(DataInputStream in, int poolIndex) |
| throws IOException { |
| int class_index = in.readUnsignedShort(); |
| classes.add(new Integer(class_index)); |
| intPool[poolIndex] = class_index; |
| } |
| |
| /** |
| * @param in |
| * @throws IOException |
| */ |
| protected void constantDouble(DataInputStream in, int poolIndex) |
| throws IOException { |
| in.skipBytes(8); |
| } |
| |
| /** |
| * @param in |
| * @throws IOException |
| */ |
| protected void constantLong(DataInputStream in, int poolIndex) |
| throws IOException { |
| in.skipBytes(8); |
| } |
| |
| /** |
| * @param in |
| * @param poolIndex |
| * @throws IOException |
| */ |
| protected void constantUtf8(DataInputStream in, int poolIndex) |
| throws IOException { |
| // CONSTANT_Utf8 |
| |
| String name = in.readUTF(); |
| xref.add(name); |
| pool[poolIndex] = name; |
| } |
| |
| /** |
| * Find a method reference in the pool that points to the given class, |
| * methodname and descriptor. |
| * |
| * @param clazz |
| * @param methodname |
| * @param descriptor |
| * @return index in constant pool |
| */ |
| private int findMethod(String clazz, String methodname, String descriptor) { |
| for (int i = 1; i < pool.length; i++) { |
| if (pool[i] instanceof Assoc) { |
| Assoc methodref = (Assoc) pool[i]; |
| if (methodref.tag == 10) { |
| // Method ref |
| int class_index = methodref.a; |
| int class_name_index = intPool[class_index]; |
| if (clazz.equals(pool[class_name_index])) { |
| int name_and_type_index = methodref.b; |
| Assoc name_and_type = (Assoc) pool[name_and_type_index]; |
| if (name_and_type.tag == 12) { |
| // Name and Type |
| int name_index = name_and_type.a; |
| int type_index = name_and_type.b; |
| if (methodname.equals(pool[name_index])) { |
| if (descriptor.equals(pool[type_index])) { |
| return i; |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| return -1; |
| } |
| |
| private void doClassReference(String next) { |
| if (next != null) { |
| String normalized = normalize(next); |
| if (normalized != null) { |
| String pack = getPackage(normalized); |
| packageReference(pack); |
| } |
| } else |
| throw new IllegalArgumentException("Invalid class, parent="); |
| } |
| |
| /** |
| * Called for each attribute in the class, field, or method. |
| * |
| * @param in |
| * The stream |
| * @throws IOException |
| */ |
| private void doAttributes(DataInputStream in, boolean crawl) |
| throws IOException { |
| int attributesCount = in.readUnsignedShort(); |
| for (int j = 0; j < attributesCount; j++) { |
| // skip name CONSTANT_Utf8 pointer |
| doAttribute(in, crawl); |
| } |
| } |
| |
| /** |
| * Process a single attribute, if not recognized, skip it. |
| * |
| * @param in |
| * the data stream |
| * @throws IOException |
| */ |
| private void doAttribute(DataInputStream in, boolean crawl) |
| throws IOException { |
| int attribute_name_index = in.readUnsignedShort(); |
| String attributeName = (String) pool[attribute_name_index]; |
| if (attribute_name_index == 560) |
| System.out.println("Index " + attribute_name_index + ":" |
| + attributeName); |
| long attribute_length = in.readInt(); |
| attribute_length &= 0xFFFFFFFF; |
| if ("RuntimeVisibleAnnotations".equals(attributeName)) |
| doAnnotations(in); |
| else if ("RuntimeVisibleParameterAnnotations".equals(attributeName)) |
| doParameterAnnotations(in); |
| else if ("SourceFile".equals(attributeName)) |
| doSourceFile(in); |
| else if ("Code".equals(attributeName) && crawl) |
| doCode(in); |
| else { |
| if (attribute_length > 0x7FFFFFFF) { |
| throw new IllegalArgumentException("Attribute > 2Gb"); |
| } |
| in.skipBytes((int) attribute_length); |
| } |
| } |
| |
| /** |
| * <pre> |
| * Code_attribute { |
| * u2 attribute_name_index; |
| * u4 attribute_length; |
| * u2 max_stack; |
| * u2 max_locals; |
| * u4 code_length; |
| * u1 code[code_length]; |
| * u2 exception_table_length; |
| * { u2 start_pc; |
| * u2 end_pc; |
| * u2 handler_pc; |
| * u2 catch_type; |
| * } exception_table[exception_table_length]; |
| * u2 attributes_count; |
| * attribute_info attributes[attributes_count]; |
| * } |
| * </pre> |
| * |
| * @param in |
| * @param pool |
| * @throws IOException |
| */ |
| private void doCode(DataInputStream in) throws IOException { |
| /* int max_stack = */in.readUnsignedShort(); |
| /* int max_locals = */in.readUnsignedShort(); |
| int code_length = in.readInt(); |
| byte code[] = new byte[code_length]; |
| in.readFully(code); |
| crawl(code); |
| int exception_table_length = in.readUnsignedShort(); |
| in.skipBytes(exception_table_length * 8); |
| doAttributes(in, false); |
| } |
| |
| /** |
| * We must find Class.forName references ... |
| * |
| * @param code |
| */ |
| protected void crawl(byte[] code) { |
| ByteBuffer bb = ByteBuffer.wrap(code); |
| bb.order(ByteOrder.BIG_ENDIAN); |
| int lastReference = -1; |
| |
| while (bb.remaining() > 0) { |
| int instruction = 0xFF & bb.get(); |
| switch (instruction) { |
| case OpCodes.ldc: |
| lastReference = 0xFF & bb.get(); |
| break; |
| |
| case OpCodes.ldc_w: |
| lastReference = 0xFFFF & bb.getShort(); |
| break; |
| |
| case OpCodes.invokestatic: |
| int methodref = 0xFFFF & bb.getShort(); |
| if ((methodref == forName || methodref == class$) |
| && lastReference != -1 |
| && pool[intPool[lastReference]] instanceof String) { |
| String clazz = (String) pool[intPool[lastReference]]; |
| doClassReference(clazz.replace('.', '/')); |
| } |
| break; |
| |
| case OpCodes.tableswitch: |
| // Skip to place divisible by 4 |
| while ((bb.position() & 0x3) != 0) |
| bb.get(); |
| /* int deflt = */ |
| bb.getInt(); |
| int low = bb.getInt(); |
| int high = bb.getInt(); |
| bb.position(bb.position() + (high - low + 1) * 4); |
| lastReference = -1; |
| break; |
| |
| case OpCodes.lookupswitch: |
| // Skip to place divisible by 4 |
| while ((bb.position() & 0x3) != 0) |
| bb.get(); |
| /* deflt = */ |
| bb.getInt(); |
| int npairs = bb.getInt(); |
| bb.position(bb.position() + npairs * 8); |
| lastReference = -1; |
| break; |
| |
| default: |
| lastReference = -1; |
| bb.position(bb.position() + OpCodes.OFFSETS[instruction]); |
| } |
| } |
| } |
| |
| private void doSourceFile(DataInputStream in) throws IOException { |
| int sourcefile_index = in.readUnsignedShort(); |
| this.sourceFile = pool[sourcefile_index].toString(); |
| } |
| |
| private void doParameterAnnotations(DataInputStream in) throws IOException { |
| int num_parameters = in.readUnsignedByte(); |
| for (int p = 0; p < num_parameters; p++) { |
| int num_annotations = in.readUnsignedShort(); // # of annotations |
| for (int a = 0; a < num_annotations; a++) { |
| doAnnotation(in); |
| } |
| } |
| } |
| |
| private void doAnnotations(DataInputStream in) throws IOException { |
| int num_annotations = in.readUnsignedShort(); // # of annotations |
| for (int a = 0; a < num_annotations; a++) { |
| doAnnotation(in); |
| } |
| } |
| |
| private void doAnnotation(DataInputStream in) throws IOException { |
| int type_index = in.readUnsignedShort(); |
| descriptors.add(new Integer(type_index)); |
| int num_element_value_pairs = in.readUnsignedShort(); |
| for (int v = 0; v < num_element_value_pairs; v++) { |
| /* int element_name_index = */in.readUnsignedShort(); |
| doElementValue(in); |
| } |
| } |
| |
| private void doElementValue(DataInputStream in) throws IOException { |
| int tag = in.readUnsignedByte(); |
| switch (tag) { |
| case 'B': |
| case 'C': |
| case 'D': |
| case 'F': |
| case 'I': |
| case 'J': |
| case 'S': |
| case 'Z': |
| case 's': |
| /* int const_value_index = */ |
| in.readUnsignedShort(); |
| break; |
| |
| case 'e': |
| int type_name_index = in.readUnsignedShort(); |
| descriptors.add(new Integer(type_name_index)); |
| /* int const_name_index = */ |
| in.readUnsignedShort(); |
| break; |
| |
| case 'c': |
| int class_info_index = in.readUnsignedShort(); |
| descriptors.add(new Integer(class_info_index)); |
| break; |
| |
| case '@': |
| doAnnotation(in); |
| break; |
| |
| case '[': |
| int num_values = in.readUnsignedShort(); |
| for (int i = 0; i < num_values; i++) { |
| doElementValue(in); |
| } |
| break; |
| |
| default: |
| throw new IllegalArgumentException( |
| "Invalid value for Annotation ElementValue tag " + tag); |
| } |
| } |
| |
| void packageReference(String pack) { |
| if (pack.indexOf('<') >= 0) |
| System.out.println("Oops: " + pack); |
| if (!imports.containsKey(pack)) |
| imports.put(pack, new LinkedHashMap<String, String>()); |
| } |
| |
| void parseDescriptor(String prototype) { |
| addReference(prototype); |
| StringTokenizer st = new StringTokenizer(prototype, "(;)", true); |
| while (st.hasMoreTokens()) { |
| if (st.nextToken().equals("(")) { |
| String token = st.nextToken(); |
| while (!token.equals(")")) { |
| addReference(token); |
| token = st.nextToken(); |
| } |
| token = st.nextToken(); |
| addReference(token); |
| } |
| } |
| } |
| |
| private void addReference(String token) { |
| while (token.startsWith("[")) |
| token = token.substring(1); |
| |
| if (token.startsWith("L")) { |
| String clazz = normalize(token.substring(1)); |
| if (clazz.startsWith("java/")) |
| return; |
| String pack = getPackage(clazz); |
| packageReference(pack); |
| } |
| } |
| |
| static String normalize(String s) { |
| if (s.startsWith("[L")) |
| return normalize(s.substring(2)); |
| if (s.startsWith("[")) |
| if (s.length() == 2) |
| return null; |
| else |
| return normalize(s.substring(1)); |
| if (s.endsWith(";")) |
| return normalize(s.substring(0, s.length() - 1)); |
| return s + ".class"; |
| } |
| |
| public static String getPackage(String clazz) { |
| int n = clazz.lastIndexOf('/'); |
| if (n < 0) |
| return "."; |
| return clazz.substring(0, n).replace('/', '.'); |
| } |
| |
| public Map<String, Map<String, String>> getReferred() { |
| return imports; |
| } |
| |
| String getClassName() { |
| return className; |
| } |
| |
| public String getPath() { |
| return path; |
| } |
| |
| public Set<String> xref(InputStream in) throws IOException { |
| DataInputStream din = new DataInputStream(in); |
| Set<String> set = parseClassFile(din); |
| din.close(); |
| return set; |
| } |
| |
| public String getSourceFile() { |
| return sourceFile; |
| } |
| |
| /** |
| * .class construct for different compilers |
| * |
| * sun 1.1 Detect static variable class$com$acme$MyClass 1.2 " 1.3 " 1.4 " |
| * 1.5 ldc_w (class) 1.6 " |
| * |
| * eclipse 1.1 class$0, ldc (string), invokestatic Class.forName 1.2 " 1.3 " |
| * 1.5 ldc (class) 1.6 " |
| * |
| * 1.5 and later is not an issue, sun pre 1.5 is easy to detect the static |
| * variable that decodes the class name. For eclipse, the class$0 gives away |
| * we have a reference encoded in a string. |
| * compilerversions/compilerversions.jar contains test versions of all |
| * versions/compilers. |
| */ |
| |
| public void reset() { |
| pool = null; |
| intPool = null; |
| xref = null; |
| classes = null; |
| descriptors = null; |
| } |
| |
| public boolean is(QUERY query, Instruction instr, Map<String, Clazz> classspace) { |
| switch (query) { |
| case ANY: |
| return true; |
| |
| case NAMED: |
| if ( instr.matches(getClassName())) |
| return !instr.isNegated(); |
| return false; |
| |
| case VERSION: |
| String v = major + "/" + minor; |
| if ( instr.matches(v)) |
| return !instr.isNegated(); |
| return false; |
| |
| |
| case IMPLEMENTS: |
| for ( int i=0; interfaces != null && i<interfaces.length; i++ ) { |
| if ( instr.matches(interfaces[i])) |
| return !instr.isNegated(); |
| } |
| break; |
| case EXTENDS: |
| if ( zuper == null ) |
| return false; |
| |
| if ( instr.matches(zuper)) |
| return !instr.isNegated(); |
| break; |
| |
| case IMPORTS: |
| for ( String imp : imports.keySet() ) { |
| if ( instr.matches(imp.replace('.', '/'))) |
| return !instr.isNegated(); |
| } |
| } |
| |
| if ( zuper == null || classspace == null) |
| return false; |
| |
| Clazz clazz = classspace.get(zuper); |
| if (clazz == null) |
| return false; |
| |
| return clazz.is(query, instr, classspace); |
| } |
| |
| public String toString() { |
| return getFQN(); |
| } |
| |
| public String getFQN() { |
| return getClassName().replace('/', '.'); |
| } |
| } |