| /* |
| * Copyright (c) 2003, 2005, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| package sun.reflect.annotation; |
| |
| import java.lang.annotation.*; |
| import java.util.*; |
| import java.nio.ByteBuffer; |
| import java.nio.BufferUnderflowException; |
| import java.lang.reflect.*; |
| import sun.reflect.ConstantPool; |
| |
| import sun.reflect.generics.parser.SignatureParser; |
| import sun.reflect.generics.tree.TypeSignature; |
| import sun.reflect.generics.factory.GenericsFactory; |
| import sun.reflect.generics.factory.CoreReflectionFactory; |
| import sun.reflect.generics.visitor.Reifier; |
| import sun.reflect.generics.scope.ClassScope; |
| |
| /** |
| * Parser for Java programming language annotations. Translates |
| * annotation byte streams emitted by compiler into annotation objects. |
| * |
| * @author Josh Bloch |
| * @since 1.5 |
| */ |
| public class AnnotationParser { |
| /** |
| * Parses the annotations described by the specified byte array. |
| * resolving constant references in the specified constant pool. |
| * The array must contain an array of annotations as described |
| * in the RuntimeVisibleAnnotations_attribute: |
| * |
| * u2 num_annotations; |
| * annotation annotations[num_annotations]; |
| * |
| * @throws AnnotationFormatError if an annotation is found to be |
| * malformed. |
| */ |
| public static Map<Class<? extends Annotation>, Annotation> parseAnnotations( |
| byte[] rawAnnotations, |
| ConstantPool constPool, |
| Class<?> container) { |
| if (rawAnnotations == null) |
| return Collections.emptyMap(); |
| |
| try { |
| return parseAnnotations2(rawAnnotations, constPool, container); |
| } catch(BufferUnderflowException e) { |
| throw new AnnotationFormatError("Unexpected end of annotations."); |
| } catch(IllegalArgumentException e) { |
| // Type mismatch in constant pool |
| throw new AnnotationFormatError(e); |
| } |
| } |
| |
| private static Map<Class<? extends Annotation>, Annotation> parseAnnotations2( |
| byte[] rawAnnotations, |
| ConstantPool constPool, |
| Class<?> container) { |
| Map<Class<? extends Annotation>, Annotation> result = |
| new LinkedHashMap<Class<? extends Annotation>, Annotation>(); |
| ByteBuffer buf = ByteBuffer.wrap(rawAnnotations); |
| int numAnnotations = buf.getShort() & 0xFFFF; |
| for (int i = 0; i < numAnnotations; i++) { |
| Annotation a = parseAnnotation(buf, constPool, container, false); |
| if (a != null) { |
| Class<? extends Annotation> klass = a.annotationType(); |
| AnnotationType type = AnnotationType.getInstance(klass); |
| if (type.retention() == RetentionPolicy.RUNTIME) |
| if (result.put(klass, a) != null) |
| throw new AnnotationFormatError( |
| "Duplicate annotation for class: "+klass+": " + a); |
| } |
| } |
| return result; |
| } |
| |
| /** |
| * Parses the parameter annotations described by the specified byte array. |
| * resolving constant references in the specified constant pool. |
| * The array must contain an array of annotations as described |
| * in the RuntimeVisibleParameterAnnotations_attribute: |
| * |
| * u1 num_parameters; |
| * { |
| * u2 num_annotations; |
| * annotation annotations[num_annotations]; |
| * } parameter_annotations[num_parameters]; |
| * |
| * Unlike parseAnnotations, rawAnnotations must not be null! |
| * A null value must be handled by the caller. This is so because |
| * we cannot determine the number of parameters if rawAnnotations |
| * is null. Also, the caller should check that the number |
| * of parameters indicated by the return value of this method |
| * matches the actual number of method parameters. A mismatch |
| * indicates that an AnnotationFormatError should be thrown. |
| * |
| * @throws AnnotationFormatError if an annotation is found to be |
| * malformed. |
| */ |
| public static Annotation[][] parseParameterAnnotations( |
| byte[] rawAnnotations, |
| ConstantPool constPool, |
| Class<?> container) { |
| try { |
| return parseParameterAnnotations2(rawAnnotations, constPool, container); |
| } catch(BufferUnderflowException e) { |
| throw new AnnotationFormatError( |
| "Unexpected end of parameter annotations."); |
| } catch(IllegalArgumentException e) { |
| // Type mismatch in constant pool |
| throw new AnnotationFormatError(e); |
| } |
| } |
| |
| private static Annotation[][] parseParameterAnnotations2( |
| byte[] rawAnnotations, |
| ConstantPool constPool, |
| Class<?> container) { |
| ByteBuffer buf = ByteBuffer.wrap(rawAnnotations); |
| int numParameters = buf.get() & 0xFF; |
| Annotation[][] result = new Annotation[numParameters][]; |
| |
| for (int i = 0; i < numParameters; i++) { |
| int numAnnotations = buf.getShort() & 0xFFFF; |
| List<Annotation> annotations = |
| new ArrayList<Annotation>(numAnnotations); |
| for (int j = 0; j < numAnnotations; j++) { |
| Annotation a = parseAnnotation(buf, constPool, container, false); |
| if (a != null) { |
| AnnotationType type = AnnotationType.getInstance( |
| a.annotationType()); |
| if (type.retention() == RetentionPolicy.RUNTIME) |
| annotations.add(a); |
| } |
| } |
| result[i] = annotations.toArray(EMPTY_ANNOTATIONS_ARRAY); |
| } |
| return result; |
| } |
| |
| private static final Annotation[] EMPTY_ANNOTATIONS_ARRAY = |
| new Annotation[0]; |
| |
| /** |
| * Parses the annotation at the current position in the specified |
| * byte buffer, resolving constant references in the specified constant |
| * pool. The cursor of the byte buffer must point to an "annotation |
| * structure" as described in the RuntimeVisibleAnnotations_attribute: |
| * |
| * annotation { |
| * u2 type_index; |
| * u2 num_member_value_pairs; |
| * { u2 member_name_index; |
| * member_value value; |
| * } member_value_pairs[num_member_value_pairs]; |
| * } |
| * } |
| * |
| * Returns the annotation, or null if the annotation's type cannot |
| * be found by the VM, or is not a valid annotation type. |
| * |
| * @param exceptionOnMissingAnnotationClass if true, throw |
| * TypeNotPresentException if a referenced annotation type is not |
| * available at runtime |
| */ |
| private static Annotation parseAnnotation(ByteBuffer buf, |
| ConstantPool constPool, |
| Class<?> container, |
| boolean exceptionOnMissingAnnotationClass) { |
| int typeIndex = buf.getShort() & 0xFFFF; |
| Class<? extends Annotation> annotationClass = null; |
| String sig = "[unknown]"; |
| try { |
| try { |
| sig = constPool.getUTF8At(typeIndex); |
| annotationClass = (Class<? extends Annotation>)parseSig(sig, container); |
| } catch (IllegalArgumentException ex) { |
| // support obsolete early jsr175 format class files |
| annotationClass = constPool.getClassAt(typeIndex); |
| } |
| } catch (NoClassDefFoundError e) { |
| if (exceptionOnMissingAnnotationClass) |
| // note: at this point sig is "[unknown]" or VM-style |
| // name instead of a binary name |
| throw new TypeNotPresentException(sig, e); |
| skipAnnotation(buf, false); |
| return null; |
| } |
| catch (TypeNotPresentException e) { |
| if (exceptionOnMissingAnnotationClass) |
| throw e; |
| skipAnnotation(buf, false); |
| return null; |
| } |
| AnnotationType type = null; |
| try { |
| type = AnnotationType.getInstance(annotationClass); |
| } catch (IllegalArgumentException e) { |
| skipAnnotation(buf, false); |
| return null; |
| } |
| |
| Map<String, Class<?>> memberTypes = type.memberTypes(); |
| Map<String, Object> memberValues = |
| new LinkedHashMap<String, Object>(type.memberDefaults()); |
| |
| int numMembers = buf.getShort() & 0xFFFF; |
| for (int i = 0; i < numMembers; i++) { |
| int memberNameIndex = buf.getShort() & 0xFFFF; |
| String memberName = constPool.getUTF8At(memberNameIndex); |
| Class<?> memberType = memberTypes.get(memberName); |
| |
| if (memberType == null) { |
| // Member is no longer present in annotation type; ignore it |
| skipMemberValue(buf); |
| } else { |
| Object value = parseMemberValue(memberType, buf, constPool, container); |
| if (value instanceof AnnotationTypeMismatchExceptionProxy) |
| ((AnnotationTypeMismatchExceptionProxy) value). |
| setMember(type.members().get(memberName)); |
| memberValues.put(memberName, value); |
| } |
| } |
| return annotationForMap(annotationClass, memberValues); |
| } |
| |
| /** |
| * Returns an annotation of the given type backed by the given |
| * member -> value map. |
| */ |
| public static Annotation annotationForMap( |
| Class<? extends Annotation> type, Map<String, Object> memberValues) |
| { |
| return (Annotation) Proxy.newProxyInstance( |
| type.getClassLoader(), new Class[] { type }, |
| new AnnotationInvocationHandler(type, memberValues)); |
| } |
| |
| /** |
| * Parses the annotation member value at the current position in the |
| * specified byte buffer, resolving constant references in the specified |
| * constant pool. The cursor of the byte buffer must point to a |
| * "member_value structure" as described in the |
| * RuntimeVisibleAnnotations_attribute: |
| * |
| * member_value { |
| * u1 tag; |
| * union { |
| * u2 const_value_index; |
| * { |
| * u2 type_name_index; |
| * u2 const_name_index; |
| * } enum_const_value; |
| * u2 class_info_index; |
| * annotation annotation_value; |
| * { |
| * u2 num_values; |
| * member_value values[num_values]; |
| * } array_value; |
| * } value; |
| * } |
| * |
| * The member must be of the indicated type. If it is not, this |
| * method returns an AnnotationTypeMismatchExceptionProxy. |
| */ |
| public static Object parseMemberValue(Class<?> memberType, |
| ByteBuffer buf, |
| ConstantPool constPool, |
| Class<?> container) { |
| Object result = null; |
| int tag = buf.get(); |
| switch(tag) { |
| case 'e': |
| return parseEnumValue((Class<? extends Enum<?>>)memberType, buf, constPool, container); |
| case 'c': |
| result = parseClassValue(buf, constPool, container); |
| break; |
| case '@': |
| result = parseAnnotation(buf, constPool, container, true); |
| break; |
| case '[': |
| return parseArray(memberType, buf, constPool, container); |
| default: |
| result = parseConst(tag, buf, constPool); |
| } |
| |
| if (!(result instanceof ExceptionProxy) && |
| !memberType.isInstance(result)) |
| result = new AnnotationTypeMismatchExceptionProxy( |
| result.getClass() + "[" + result + "]"); |
| return result; |
| } |
| |
| /** |
| * Parses the primitive or String annotation member value indicated by |
| * the specified tag byte at the current position in the specified byte |
| * buffer, resolving constant reference in the specified constant pool. |
| * The cursor of the byte buffer must point to an annotation member value |
| * of the type indicated by the specified tag, as described in the |
| * RuntimeVisibleAnnotations_attribute: |
| * |
| * u2 const_value_index; |
| */ |
| private static Object parseConst(int tag, |
| ByteBuffer buf, ConstantPool constPool) { |
| int constIndex = buf.getShort() & 0xFFFF; |
| switch(tag) { |
| case 'B': |
| return Byte.valueOf((byte) constPool.getIntAt(constIndex)); |
| case 'C': |
| return Character.valueOf((char) constPool.getIntAt(constIndex)); |
| case 'D': |
| return Double.valueOf(constPool.getDoubleAt(constIndex)); |
| case 'F': |
| return Float.valueOf(constPool.getFloatAt(constIndex)); |
| case 'I': |
| return Integer.valueOf(constPool.getIntAt(constIndex)); |
| case 'J': |
| return Long.valueOf(constPool.getLongAt(constIndex)); |
| case 'S': |
| return Short.valueOf((short) constPool.getIntAt(constIndex)); |
| case 'Z': |
| return Boolean.valueOf(constPool.getIntAt(constIndex) != 0); |
| case 's': |
| return constPool.getUTF8At(constIndex); |
| default: |
| throw new AnnotationFormatError( |
| "Invalid member-value tag in annotation: " + tag); |
| } |
| } |
| |
| /** |
| * Parses the Class member value at the current position in the |
| * specified byte buffer, resolving constant references in the specified |
| * constant pool. The cursor of the byte buffer must point to a "class |
| * info index" as described in the RuntimeVisibleAnnotations_attribute: |
| * |
| * u2 class_info_index; |
| */ |
| private static Object parseClassValue(ByteBuffer buf, |
| ConstantPool constPool, |
| Class<?> container) { |
| int classIndex = buf.getShort() & 0xFFFF; |
| try { |
| try { |
| String sig = constPool.getUTF8At(classIndex); |
| return parseSig(sig, container); |
| } catch (IllegalArgumentException ex) { |
| // support obsolete early jsr175 format class files |
| return constPool.getClassAt(classIndex); |
| } |
| } catch (NoClassDefFoundError e) { |
| return new TypeNotPresentExceptionProxy("[unknown]", e); |
| } |
| catch (TypeNotPresentException e) { |
| return new TypeNotPresentExceptionProxy(e.typeName(), e.getCause()); |
| } |
| } |
| |
| private static Class<?> parseSig(String sig, Class<?> container) { |
| if (sig.equals("V")) return void.class; |
| SignatureParser parser = SignatureParser.make(); |
| TypeSignature typeSig = parser.parseTypeSig(sig); |
| GenericsFactory factory = CoreReflectionFactory.make(container, ClassScope.make(container)); |
| Reifier reify = Reifier.make(factory); |
| typeSig.accept(reify); |
| Type result = reify.getResult(); |
| return toClass(result); |
| } |
| static Class<?> toClass(Type o) { |
| if (o instanceof GenericArrayType) |
| return Array.newInstance(toClass(((GenericArrayType)o).getGenericComponentType()), |
| 0) |
| .getClass(); |
| return (Class)o; |
| } |
| |
| /** |
| * Parses the enum constant member value at the current position in the |
| * specified byte buffer, resolving constant references in the specified |
| * constant pool. The cursor of the byte buffer must point to a |
| * "enum_const_value structure" as described in the |
| * RuntimeVisibleAnnotations_attribute: |
| * |
| * { |
| * u2 type_name_index; |
| * u2 const_name_index; |
| * } enum_const_value; |
| */ |
| private static Object parseEnumValue(Class<? extends Enum> enumType, ByteBuffer buf, |
| ConstantPool constPool, |
| Class<?> container) { |
| int typeNameIndex = buf.getShort() & 0xFFFF; |
| String typeName = constPool.getUTF8At(typeNameIndex); |
| int constNameIndex = buf.getShort() & 0xFFFF; |
| String constName = constPool.getUTF8At(constNameIndex); |
| |
| if (!typeName.endsWith(";")) { |
| // support now-obsolete early jsr175-format class files. |
| if (!enumType.getName().equals(typeName)) |
| return new AnnotationTypeMismatchExceptionProxy( |
| typeName + "." + constName); |
| } else if (enumType != parseSig(typeName, container)) { |
| return new AnnotationTypeMismatchExceptionProxy( |
| typeName + "." + constName); |
| } |
| |
| try { |
| return Enum.valueOf(enumType, constName); |
| } catch(IllegalArgumentException e) { |
| return new EnumConstantNotPresentExceptionProxy( |
| (Class<? extends Enum>)enumType, constName); |
| } |
| } |
| |
| /** |
| * Parses the array value at the current position in the specified byte |
| * buffer, resolving constant references in the specified constant pool. |
| * The cursor of the byte buffer must point to an array value struct |
| * as specified in the RuntimeVisibleAnnotations_attribute: |
| * |
| * { |
| * u2 num_values; |
| * member_value values[num_values]; |
| * } array_value; |
| * |
| * If the array values do not match arrayType, an |
| * AnnotationTypeMismatchExceptionProxy will be returned. |
| */ |
| private static Object parseArray(Class<?> arrayType, |
| ByteBuffer buf, |
| ConstantPool constPool, |
| Class<?> container) { |
| int length = buf.getShort() & 0xFFFF; // Number of array components |
| Class<?> componentType = arrayType.getComponentType(); |
| |
| if (componentType == byte.class) { |
| return parseByteArray(length, buf, constPool); |
| } else if (componentType == char.class) { |
| return parseCharArray(length, buf, constPool); |
| } else if (componentType == double.class) { |
| return parseDoubleArray(length, buf, constPool); |
| } else if (componentType == float.class) { |
| return parseFloatArray(length, buf, constPool); |
| } else if (componentType == int.class) { |
| return parseIntArray(length, buf, constPool); |
| } else if (componentType == long.class) { |
| return parseLongArray(length, buf, constPool); |
| } else if (componentType == short.class) { |
| return parseShortArray(length, buf, constPool); |
| } else if (componentType == boolean.class) { |
| return parseBooleanArray(length, buf, constPool); |
| } else if (componentType == String.class) { |
| return parseStringArray(length, buf, constPool); |
| } else if (componentType == Class.class) { |
| return parseClassArray(length, buf, constPool, container); |
| } else if (componentType.isEnum()) { |
| return parseEnumArray(length, (Class<? extends Enum>)componentType, buf, |
| constPool, container); |
| } else { |
| assert componentType.isAnnotation(); |
| return parseAnnotationArray(length, (Class <? extends Annotation>)componentType, buf, |
| constPool, container); |
| } |
| } |
| |
| private static Object parseByteArray(int length, |
| ByteBuffer buf, ConstantPool constPool) { |
| byte[] result = new byte[length]; |
| boolean typeMismatch = false; |
| int tag = 0; |
| |
| for (int i = 0; i < length; i++) { |
| tag = buf.get(); |
| if (tag == 'B') { |
| int index = buf.getShort() & 0xFFFF; |
| result[i] = (byte) constPool.getIntAt(index); |
| } else { |
| skipMemberValue(tag, buf); |
| typeMismatch = true; |
| } |
| } |
| return typeMismatch ? exceptionProxy(tag) : result; |
| } |
| |
| private static Object parseCharArray(int length, |
| ByteBuffer buf, ConstantPool constPool) { |
| char[] result = new char[length]; |
| boolean typeMismatch = false; |
| byte tag = 0; |
| |
| for (int i = 0; i < length; i++) { |
| tag = buf.get(); |
| if (tag == 'C') { |
| int index = buf.getShort() & 0xFFFF; |
| result[i] = (char) constPool.getIntAt(index); |
| } else { |
| skipMemberValue(tag, buf); |
| typeMismatch = true; |
| } |
| } |
| return typeMismatch ? exceptionProxy(tag) : result; |
| } |
| |
| private static Object parseDoubleArray(int length, |
| ByteBuffer buf, ConstantPool constPool) { |
| double[] result = new double[length]; |
| boolean typeMismatch = false; |
| int tag = 0; |
| |
| for (int i = 0; i < length; i++) { |
| tag = buf.get(); |
| if (tag == 'D') { |
| int index = buf.getShort() & 0xFFFF; |
| result[i] = constPool.getDoubleAt(index); |
| } else { |
| skipMemberValue(tag, buf); |
| typeMismatch = true; |
| } |
| } |
| return typeMismatch ? exceptionProxy(tag) : result; |
| } |
| |
| private static Object parseFloatArray(int length, |
| ByteBuffer buf, ConstantPool constPool) { |
| float[] result = new float[length]; |
| boolean typeMismatch = false; |
| int tag = 0; |
| |
| for (int i = 0; i < length; i++) { |
| tag = buf.get(); |
| if (tag == 'F') { |
| int index = buf.getShort() & 0xFFFF; |
| result[i] = constPool.getFloatAt(index); |
| } else { |
| skipMemberValue(tag, buf); |
| typeMismatch = true; |
| } |
| } |
| return typeMismatch ? exceptionProxy(tag) : result; |
| } |
| |
| private static Object parseIntArray(int length, |
| ByteBuffer buf, ConstantPool constPool) { |
| int[] result = new int[length]; |
| boolean typeMismatch = false; |
| int tag = 0; |
| |
| for (int i = 0; i < length; i++) { |
| tag = buf.get(); |
| if (tag == 'I') { |
| int index = buf.getShort() & 0xFFFF; |
| result[i] = constPool.getIntAt(index); |
| } else { |
| skipMemberValue(tag, buf); |
| typeMismatch = true; |
| } |
| } |
| return typeMismatch ? exceptionProxy(tag) : result; |
| } |
| |
| private static Object parseLongArray(int length, |
| ByteBuffer buf, ConstantPool constPool) { |
| long[] result = new long[length]; |
| boolean typeMismatch = false; |
| int tag = 0; |
| |
| for (int i = 0; i < length; i++) { |
| tag = buf.get(); |
| if (tag == 'J') { |
| int index = buf.getShort() & 0xFFFF; |
| result[i] = constPool.getLongAt(index); |
| } else { |
| skipMemberValue(tag, buf); |
| typeMismatch = true; |
| } |
| } |
| return typeMismatch ? exceptionProxy(tag) : result; |
| } |
| |
| private static Object parseShortArray(int length, |
| ByteBuffer buf, ConstantPool constPool) { |
| short[] result = new short[length]; |
| boolean typeMismatch = false; |
| int tag = 0; |
| |
| for (int i = 0; i < length; i++) { |
| tag = buf.get(); |
| if (tag == 'S') { |
| int index = buf.getShort() & 0xFFFF; |
| result[i] = (short) constPool.getIntAt(index); |
| } else { |
| skipMemberValue(tag, buf); |
| typeMismatch = true; |
| } |
| } |
| return typeMismatch ? exceptionProxy(tag) : result; |
| } |
| |
| private static Object parseBooleanArray(int length, |
| ByteBuffer buf, ConstantPool constPool) { |
| boolean[] result = new boolean[length]; |
| boolean typeMismatch = false; |
| int tag = 0; |
| |
| for (int i = 0; i < length; i++) { |
| tag = buf.get(); |
| if (tag == 'Z') { |
| int index = buf.getShort() & 0xFFFF; |
| result[i] = (constPool.getIntAt(index) != 0); |
| } else { |
| skipMemberValue(tag, buf); |
| typeMismatch = true; |
| } |
| } |
| return typeMismatch ? exceptionProxy(tag) : result; |
| } |
| |
| private static Object parseStringArray(int length, |
| ByteBuffer buf, ConstantPool constPool) { |
| String[] result = new String[length]; |
| boolean typeMismatch = false; |
| int tag = 0; |
| |
| for (int i = 0; i < length; i++) { |
| tag = buf.get(); |
| if (tag == 's') { |
| int index = buf.getShort() & 0xFFFF; |
| result[i] = constPool.getUTF8At(index); |
| } else { |
| skipMemberValue(tag, buf); |
| typeMismatch = true; |
| } |
| } |
| return typeMismatch ? exceptionProxy(tag) : result; |
| } |
| |
| private static Object parseClassArray(int length, |
| ByteBuffer buf, |
| ConstantPool constPool, |
| Class<?> container) { |
| Object[] result = new Class<?>[length]; |
| boolean typeMismatch = false; |
| int tag = 0; |
| |
| for (int i = 0; i < length; i++) { |
| tag = buf.get(); |
| if (tag == 'c') { |
| result[i] = parseClassValue(buf, constPool, container); |
| } else { |
| skipMemberValue(tag, buf); |
| typeMismatch = true; |
| } |
| } |
| return typeMismatch ? exceptionProxy(tag) : result; |
| } |
| |
| private static Object parseEnumArray(int length, Class<? extends Enum> enumType, |
| ByteBuffer buf, |
| ConstantPool constPool, |
| Class<?> container) { |
| Object[] result = (Object[]) Array.newInstance(enumType, length); |
| boolean typeMismatch = false; |
| int tag = 0; |
| |
| for (int i = 0; i < length; i++) { |
| tag = buf.get(); |
| if (tag == 'e') { |
| result[i] = parseEnumValue(enumType, buf, constPool, container); |
| } else { |
| skipMemberValue(tag, buf); |
| typeMismatch = true; |
| } |
| } |
| return typeMismatch ? exceptionProxy(tag) : result; |
| } |
| |
| private static Object parseAnnotationArray(int length, |
| Class<? extends Annotation> annotationType, |
| ByteBuffer buf, |
| ConstantPool constPool, |
| Class<?> container) { |
| Object[] result = (Object[]) Array.newInstance(annotationType, length); |
| boolean typeMismatch = false; |
| int tag = 0; |
| |
| for (int i = 0; i < length; i++) { |
| tag = buf.get(); |
| if (tag == '@') { |
| result[i] = parseAnnotation(buf, constPool, container, true); |
| } else { |
| skipMemberValue(tag, buf); |
| typeMismatch = true; |
| } |
| } |
| return typeMismatch ? exceptionProxy(tag) : result; |
| } |
| |
| /** |
| * Return an appropriate exception proxy for a mismatching array |
| * annotation where the erroneous array has the specified tag. |
| */ |
| private static ExceptionProxy exceptionProxy(int tag) { |
| return new AnnotationTypeMismatchExceptionProxy( |
| "Array with component tag: " + tag); |
| } |
| |
| /** |
| * Skips the annotation at the current position in the specified |
| * byte buffer. The cursor of the byte buffer must point to |
| * an "annotation structure" OR two bytes into an annotation |
| * structure (i.e., after the type index). |
| * |
| * @parameter complete true if the byte buffer points to the beginning |
| * of an annotation structure (rather than two bytes in). |
| */ |
| private static void skipAnnotation(ByteBuffer buf, boolean complete) { |
| if (complete) |
| buf.getShort(); // Skip type index |
| int numMembers = buf.getShort() & 0xFFFF; |
| for (int i = 0; i < numMembers; i++) { |
| buf.getShort(); // Skip memberNameIndex |
| skipMemberValue(buf); |
| } |
| } |
| |
| /** |
| * Skips the annotation member value at the current position in the |
| * specified byte buffer. The cursor of the byte buffer must point to a |
| * "member_value structure." |
| */ |
| private static void skipMemberValue(ByteBuffer buf) { |
| int tag = buf.get(); |
| skipMemberValue(tag, buf); |
| } |
| |
| /** |
| * Skips the annotation member value at the current position in the |
| * specified byte buffer. The cursor of the byte buffer must point |
| * immediately after the tag in a "member_value structure." |
| */ |
| private static void skipMemberValue(int tag, ByteBuffer buf) { |
| switch(tag) { |
| case 'e': // Enum value |
| buf.getInt(); // (Two shorts, actually.) |
| break; |
| case '@': |
| skipAnnotation(buf, true); |
| break; |
| case '[': |
| skipArray(buf); |
| break; |
| default: |
| // Class, primitive, or String |
| buf.getShort(); |
| } |
| } |
| |
| /** |
| * Skips the array value at the current position in the specified byte |
| * buffer. The cursor of the byte buffer must point to an array value |
| * struct. |
| */ |
| private static void skipArray(ByteBuffer buf) { |
| int length = buf.getShort() & 0xFFFF; |
| for (int i = 0; i < length; i++) |
| skipMemberValue(buf); |
| } |
| |
| /* |
| * This method converts the annotation map returned by the parseAnnotations() |
| * method to an array. It is called by Field.getDeclaredAnnotations(), |
| * Method.getDeclaredAnnotations(), and Constructor.getDeclaredAnnotations(). |
| * This avoids the reflection classes to load the Annotation class until |
| * it is needed. |
| */ |
| private static final Annotation[] EMPTY_ANNOTATION_ARRAY = new Annotation[0]; |
| public static Annotation[] toArray(Map<Class<? extends Annotation>, Annotation> annotations) { |
| return annotations.values().toArray(EMPTY_ANNOTATION_ARRAY); |
| } |
| } |
