private void processSignature(DataInputStream data, AnnotationTarget target) throws IOException { String signature = decodeUtf8Entry(data.readUnsignedShort()); signatures.add(signature); signatures.add(target); signaturePresent.put(target, null); }
private void processFieldInfo(DataInputStream data) throws IOException { int numFields = data.readUnsignedShort(); List<FieldInfo> fields = numFields > 0 ? new ArrayList<FieldInfo>(numFields) : Collections.<FieldInfo>emptyList(); for (int i = 0; i < numFields; i++) { short flags = (short) data.readUnsignedShort(); byte[] name = intern(decodeUtf8EntryAsBytes(data.readUnsignedShort())); Type type = parseType(decodeUtf8Entry(data.readUnsignedShort())); FieldInfo field = new FieldInfo(currentClass, name, type, flags); processAttributes(data, field); field.setAnnotations(elementAnnotations); elementAnnotations.clear(); fields.add(field); } this.fields = fields; }
private void processMethodInfo(DataInputStream data) throws IOException { int numMethods = data.readUnsignedShort(); List<MethodInfo> methods = numMethods > 0 ? new ArrayList<MethodInfo>(numMethods) : Collections.<MethodInfo>emptyList(); for (int i = 0; i < numMethods; i++) { short flags = (short) data.readUnsignedShort(); byte[] name = intern(decodeUtf8EntryAsBytes(data.readUnsignedShort())); String descriptor = decodeUtf8Entry(data.readUnsignedShort()); IntegerHolder pos = new IntegerHolder(); Type[] parameters = intern(parseMethodArgs(descriptor, pos)); Type returnType = parseType(descriptor, pos); MethodInfo method = new MethodInfo(currentClass, name, MethodInternal.EMPTY_PARAMETER_NAMES, parameters, returnType, flags); if (parameters.length == 0 && Arrays.equals(INIT_METHOD_NAME, name)) { currentClass.setHasNoArgsConstructor(true); } methodParameterNames = debugParameterNames = null; processAttributes(data, method); method.setAnnotations(elementAnnotations); elementAnnotations.clear(); // Prefer method parameter names over debug info if(methodParameterNames != null) method.methodInternal().setParameterNames(methodParameterNames); else if(debugParameterNames != null) method.methodInternal().setParameterNames(debugParameterNames); methods.add(method); } this.methods = methods; }
private DotName decodeClassEntry(int classInfoIndex) { byte[] pool = constantPool; int[] offsets = constantPoolOffsets; int pos = offsets[classInfoIndex - 1]; if (pool[pos] != CONSTANT_CLASS) throw new IllegalStateException("Constant pool entry is not a class info type: " + classInfoIndex + ":" + pos); int nameIndex = (pool[++pos] & 0xFF) << 8 | (pool[++pos] & 0xFF); return names.convertToName(decodeUtf8Entry(nameIndex), '/'); }
private NameAndType decodeNameAndTypeEntry(int index) { byte[] pool = constantPool; int[] offsets = constantPoolOffsets; int pos = offsets[index - 1]; if (pool[pos] != CONSTANT_NAMEANDTYPE) throw new IllegalStateException("Constant pool entry is not a name and type type: " + index + ":" + pos); int nameIndex = (pool[++pos] & 0xFF) << 8 | (pool[++pos] & 0xFF); int descriptorIndex = (pool[++pos] & 0xFF) << 8 | (pool[++pos] & 0xFF); return new NameAndType(intern(decodeUtf8Entry(nameIndex)), decodeUtf8Entry(descriptorIndex)); }
private void processInnerClasses(DataInputStream data, ClassInfo target) throws IOException { int numClasses = data.readUnsignedShort(); innerClasses = numClasses > 0 ? new HashMap<DotName, InnerClassInfo>(numClasses) : Collections.<DotName, InnerClassInfo>emptyMap(); for (int i = 0; i < numClasses; i++) { DotName innerClass = decodeClassEntry(data.readUnsignedShort()); int outerIndex = data.readUnsignedShort(); DotName outerClass = outerIndex == 0 ? null : decodeClassEntry(outerIndex); int simpleIndex = data.readUnsignedShort(); String simpleName = simpleIndex == 0 ? null : decodeUtf8Entry(simpleIndex); int flags = data.readUnsignedShort(); if (innerClass.equals(target.name())) { target.setInnerClassInfo(outerClass, simpleName); target.setFlags((short)flags); } innerClasses.put(innerClass, new InnerClassInfo(innerClass, outerClass, simpleName, flags)); } }
private AnnotationInstance processAnnotation(DataInputStream data, AnnotationTarget target) throws IOException { String annotation = convertClassFieldDescriptor(decodeUtf8Entry(data.readUnsignedShort())); int valuePairs = data.readUnsignedShort(); AnnotationValue[] values = new AnnotationValue[valuePairs]; for (int v = 0; v < valuePairs; v++) { String name = intern(decodeUtf8Entry(data.readUnsignedShort())); values[v] = processAnnotationElementValue(name, data); } // Sort entries so they can be binary searched Arrays.sort(values, new Comparator<AnnotationValue>() { public int compare(AnnotationValue o1, AnnotationValue o2) { return o1.name().compareTo(o2.name()); } }); DotName annotationName = names.convertToName(annotation); AnnotationInstance instance = new AnnotationInstance(annotationName, target, values); // Don't record nested annotations in index if (target != null) { recordAnnotation(classAnnotations, annotationName, instance); recordAnnotation(masterAnnotations, annotationName, instance); if (target instanceof FieldInfo || target instanceof MethodInfo || target instanceof MethodParameterInfo) { elementAnnotations.add(instance); } } return instance; }
return new AnnotationValue.StringValue(name, decodeUtf8Entry(data.readUnsignedShort())); case 'c': return new AnnotationValue.ClassValue(name, parseType(decodeUtf8Entry(data.readUnsignedShort()))); case 'e': { DotName type = parseType(decodeUtf8Entry(data.readUnsignedShort())).name(); String value = decodeUtf8Entry(data.readUnsignedShort()); return new AnnotationValue.EnumValue(name, type, value);