1 /*
   2  * Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 package sun.reflect.annotation;
  27 
  28 import java.lang.annotation.*;
  29 import java.util.*;
  30 import java.nio.ByteBuffer;
  31 import java.nio.BufferUnderflowException;
  32 import java.lang.reflect.*;
  33 import java.security.AccessController;
  34 import java.security.PrivilegedAction;
  35 import sun.reflect.ConstantPool;
  36 
  37 import sun.reflect.generics.parser.SignatureParser;
  38 import sun.reflect.generics.tree.TypeSignature;
  39 import sun.reflect.generics.factory.GenericsFactory;
  40 import sun.reflect.generics.factory.CoreReflectionFactory;
  41 import sun.reflect.generics.visitor.Reifier;
  42 import sun.reflect.generics.scope.ClassScope;
  43 
  44 /**
  45  * Parser for Java programming language annotations.  Translates
  46  * annotation byte streams emitted by compiler into annotation objects.
  47  *
  48  * @author  Josh Bloch
  49  * @since   1.5
  50  */
  51 public class AnnotationParser {
  52     /**
  53      * Parses the annotations described by the specified byte array.
  54      * resolving constant references in the specified constant pool.
  55      * The array must contain an array of annotations as described
  56      * in the RuntimeVisibleAnnotations_attribute:
  57      *
  58      *   u2 num_annotations;
  59      *   annotation annotations[num_annotations];
  60      *
  61      * @throws AnnotationFormatError if an annotation is found to be
  62      *         malformed.
  63      */
  64     public static Map<Class<? extends Annotation>, Annotation> parseAnnotations(
  65                 byte[] rawAnnotations,
  66                 ConstantPool constPool,
  67                 Class<?> container) {
  68         if (rawAnnotations == null)
  69             return Collections.emptyMap();
  70 
  71         try {
  72             return parseAnnotations2(rawAnnotations, constPool, container, null);
  73         } catch(BufferUnderflowException e) {
  74             throw new AnnotationFormatError("Unexpected end of annotations.");
  75         } catch(IllegalArgumentException e) {
  76             // Type mismatch in constant pool
  77             throw new AnnotationFormatError(e);
  78         }
  79     }
  80 
  81     /**
  82      * Like {@link #parseAnnotations(byte[], sun.reflect.ConstantPool, Class)}
  83      * with an additional parameter {@code selectAnnotationClasses} which selects the
  84      * annotation types to parse (other than selected are quickly skipped).<p>
  85      * This method is only used to parse select meta annotations in the construction
  86      * phase of {@link AnnotationType} instances to prevent infinite recursion.
  87      *
  88      * @param selectAnnotationClasses an array of annotation types to select when parsing
  89      */
  90     @SafeVarargs
  91     @SuppressWarnings("varargs") // selectAnnotationClasses is used safely
  92     static Map<Class<? extends Annotation>, Annotation> parseSelectAnnotations(
  93                 byte[] rawAnnotations,
  94                 ConstantPool constPool,
  95                 Class<?> container,
  96                 Class<? extends Annotation> ... selectAnnotationClasses) {
  97         if (rawAnnotations == null)
  98             return Collections.emptyMap();
  99 
 100         try {
 101             return parseAnnotations2(rawAnnotations, constPool, container, selectAnnotationClasses);
 102         } catch(BufferUnderflowException e) {
 103             throw new AnnotationFormatError("Unexpected end of annotations.");
 104         } catch(IllegalArgumentException e) {
 105             // Type mismatch in constant pool
 106             throw new AnnotationFormatError(e);
 107         }
 108     }
 109 
 110     private static Map<Class<? extends Annotation>, Annotation> parseAnnotations2(
 111                 byte[] rawAnnotations,
 112                 ConstantPool constPool,
 113                 Class<?> container,
 114                 Class<? extends Annotation>[] selectAnnotationClasses) {
 115         Map<Class<? extends Annotation>, Annotation> result =
 116             new LinkedHashMap<Class<? extends Annotation>, Annotation>();
 117         ByteBuffer buf = ByteBuffer.wrap(rawAnnotations);
 118         int numAnnotations = buf.getShort() & 0xFFFF;
 119         for (int i = 0; i < numAnnotations; i++) {
 120             Annotation a = parseAnnotation2(buf, constPool, container, false, selectAnnotationClasses);
 121             if (a != null) {
 122                 Class<? extends Annotation> klass = a.annotationType();
 123                 if (AnnotationType.getInstance(klass).retention() == RetentionPolicy.RUNTIME &&
 124                     result.put(klass, a) != null) {
 125                         throw new AnnotationFormatError(
 126                             "Duplicate annotation for class: "+klass+": " + a);
 127             }
 128         }
 129         }
 130         return result;
 131     }
 132 
 133     /**
 134      * Parses the parameter annotations described by the specified byte array.
 135      * resolving constant references in the specified constant pool.
 136      * The array must contain an array of annotations as described
 137      * in the RuntimeVisibleParameterAnnotations_attribute:
 138      *
 139      *    u1 num_parameters;
 140      *    {
 141      *        u2 num_annotations;
 142      *        annotation annotations[num_annotations];
 143      *    } parameter_annotations[num_parameters];
 144      *
 145      * Unlike parseAnnotations, rawAnnotations must not be null!
 146      * A null value must be handled by the caller.  This is so because
 147      * we cannot determine the number of parameters if rawAnnotations
 148      * is null.  Also, the caller should check that the number
 149      * of parameters indicated by the return value of this method
 150      * matches the actual number of method parameters.  A mismatch
 151      * indicates that an AnnotationFormatError should be thrown.
 152      *
 153      * @throws AnnotationFormatError if an annotation is found to be
 154      *         malformed.
 155      */
 156     public static Annotation[][] parseParameterAnnotations(
 157                     byte[] rawAnnotations,
 158                     ConstantPool constPool,
 159                     Class<?> container) {
 160         try {
 161             return parseParameterAnnotations2(rawAnnotations, constPool, container);
 162         } catch(BufferUnderflowException e) {
 163             throw new AnnotationFormatError(
 164                 "Unexpected end of parameter annotations.");
 165         } catch(IllegalArgumentException e) {
 166             // Type mismatch in constant pool
 167             throw new AnnotationFormatError(e);
 168         }
 169     }
 170 
 171     private static Annotation[][] parseParameterAnnotations2(
 172                     byte[] rawAnnotations,
 173                     ConstantPool constPool,
 174                     Class<?> container) {
 175         ByteBuffer buf = ByteBuffer.wrap(rawAnnotations);
 176         int numParameters = buf.get() & 0xFF;
 177         Annotation[][] result = new Annotation[numParameters][];
 178 
 179         for (int i = 0; i < numParameters; i++) {
 180             int numAnnotations = buf.getShort() & 0xFFFF;
 181             List<Annotation> annotations =
 182                 new ArrayList<Annotation>(numAnnotations);
 183             for (int j = 0; j < numAnnotations; j++) {
 184                 Annotation a = parseAnnotation(buf, constPool, container, false);
 185                 if (a != null) {
 186                     AnnotationType type = AnnotationType.getInstance(
 187                                               a.annotationType());
 188                     if (type.retention() == RetentionPolicy.RUNTIME)
 189                         annotations.add(a);
 190                 }
 191             }
 192             result[i] = annotations.toArray(EMPTY_ANNOTATIONS_ARRAY);
 193         }
 194         return result;
 195     }
 196 
 197     private static final Annotation[] EMPTY_ANNOTATIONS_ARRAY =
 198                     new Annotation[0];
 199 
 200     /**
 201      * Parses the annotation at the current position in the specified
 202      * byte buffer, resolving constant references in the specified constant
 203      * pool.  The cursor of the byte buffer must point to an "annotation
 204      * structure" as described in the RuntimeVisibleAnnotations_attribute:
 205      *
 206      * annotation {
 207      *    u2    type_index;
 208      *       u2    num_member_value_pairs;
 209      *       {    u2    member_name_index;
 210      *             member_value value;
 211      *       }    member_value_pairs[num_member_value_pairs];
 212      *    }
 213      * }
 214      *
 215      * Returns the annotation, or null if the annotation's type cannot
 216      * be found by the VM, or is not a valid annotation type.
 217      *
 218      * @param exceptionOnMissingAnnotationClass if true, throw
 219      * TypeNotPresentException if a referenced annotation type is not
 220      * available at runtime
 221      */
 222     static Annotation parseAnnotation(ByteBuffer buf,
 223                                               ConstantPool constPool,
 224                                               Class<?> container,
 225                                               boolean exceptionOnMissingAnnotationClass) {
 226        return parseAnnotation2(buf, constPool, container, exceptionOnMissingAnnotationClass, null);
 227     }
 228 
 229     @SuppressWarnings("unchecked")
 230     private static Annotation parseAnnotation2(ByteBuffer buf,
 231                                               ConstantPool constPool,
 232                                               Class<?> container,
 233                                               boolean exceptionOnMissingAnnotationClass,
 234                                               Class<? extends Annotation>[] selectAnnotationClasses) {
 235         int typeIndex = buf.getShort() & 0xFFFF;
 236         Class<? extends Annotation> annotationClass = null;
 237         String sig = "[unknown]";
 238         try {
 239             try {
 240                 sig = constPool.getUTF8At(typeIndex);
 241                 annotationClass = (Class<? extends Annotation>)parseSig(sig, container);
 242             } catch (IllegalArgumentException ex) {
 243                 // support obsolete early jsr175 format class files
 244                 annotationClass = (Class<? extends Annotation>)constPool.getClassAt(typeIndex);
 245             }
 246         } catch (NoClassDefFoundError e) {
 247             if (exceptionOnMissingAnnotationClass)
 248                 // note: at this point sig is "[unknown]" or VM-style
 249                 // name instead of a binary name
 250                 throw new TypeNotPresentException(sig, e);
 251             skipAnnotation(buf, false);
 252             return null;
 253         }
 254         catch (TypeNotPresentException e) {
 255             if (exceptionOnMissingAnnotationClass)
 256                 throw e;
 257             skipAnnotation(buf, false);
 258             return null;
 259         }
 260         if (selectAnnotationClasses != null && !contains(selectAnnotationClasses, annotationClass)) {
 261             skipAnnotation(buf, false);
 262             return null;
 263         }
 264         AnnotationType type = null;
 265         try {
 266             type = AnnotationType.getInstance(annotationClass);
 267         } catch (IllegalArgumentException e) {
 268             skipAnnotation(buf, false);
 269             return null;
 270         }
 271 
 272         Map<String, Class<?>> memberTypes = type.memberTypes();
 273         Map<String, Object> memberValues =
 274             new LinkedHashMap<String, Object>(type.memberDefaults());
 275 
 276         int numMembers = buf.getShort() & 0xFFFF;
 277         for (int i = 0; i < numMembers; i++) {
 278             int memberNameIndex = buf.getShort() & 0xFFFF;
 279             String memberName = constPool.getUTF8At(memberNameIndex);
 280             Class<?> memberType = memberTypes.get(memberName);
 281 
 282             if (memberType == null) {
 283                 // Member is no longer present in annotation type; ignore it
 284                 skipMemberValue(buf);
 285             } else {
 286                 Object value = parseMemberValue(memberType, buf, constPool, container);
 287                 if (value instanceof AnnotationTypeMismatchExceptionProxy)
 288                     ((AnnotationTypeMismatchExceptionProxy) value).
 289                         setMember(type.members().get(memberName));
 290                 memberValues.put(memberName, value);
 291             }
 292         }
 293         return annotationForMap(annotationClass, memberValues);
 294     }
 295 
 296     /**
 297      * Returns an annotation of the given type backed by the given
 298      * member -> value map.
 299      */
 300     public static Annotation annotationForMap(final Class<? extends Annotation> type,
 301                                               final Map<String, Object> memberValues)
 302     {
 303         return AccessController.doPrivileged(new PrivilegedAction<Annotation>() {
 304             public Annotation run() {
 305                 return (Annotation) Proxy.newProxyInstance(
 306                     type.getClassLoader(), new Class<?>[] { type },
 307                     new AnnotationInvocationHandler(type, memberValues));
 308             }});
 309     }
 310 
 311     /**
 312      * Parses the annotation member value at the current position in the
 313      * specified byte buffer, resolving constant references in the specified
 314      * constant pool.  The cursor of the byte buffer must point to a
 315      * "member_value structure" as described in the
 316      * RuntimeVisibleAnnotations_attribute:
 317      *
 318      *  member_value {
 319      *    u1 tag;
 320      *    union {
 321      *       u2   const_value_index;
 322      *       {
 323      *           u2   type_name_index;
 324      *           u2   const_name_index;
 325      *       } enum_const_value;
 326      *       u2   class_info_index;
 327      *       annotation annotation_value;
 328      *       {
 329      *           u2    num_values;
 330      *           member_value values[num_values];
 331      *       } array_value;
 332      *    } value;
 333      * }
 334      *
 335      * The member must be of the indicated type. If it is not, this
 336      * method returns an AnnotationTypeMismatchExceptionProxy.
 337      */
 338     @SuppressWarnings("unchecked")
 339     public static Object parseMemberValue(Class<?> memberType,
 340                                           ByteBuffer buf,
 341                                           ConstantPool constPool,
 342                                           Class<?> container) {
 343         Object result = null;
 344         int tag = buf.get();
 345         switch(tag) {
 346           case 'e':
 347               return parseEnumValue((Class<? extends Enum<?>>)memberType, buf, constPool, container);
 348           case 'c':
 349               result = parseClassValue(buf, constPool, container);
 350               break;
 351           case '@':
 352               result = parseAnnotation(buf, constPool, container, true);
 353               break;
 354           case '[':
 355               return parseArray(memberType, buf, constPool, container);
 356           default:
 357               result = parseConst(tag, buf, constPool);
 358         }
 359 
 360         if (!(result instanceof ExceptionProxy) &&
 361             !memberType.isInstance(result))
 362             result = new AnnotationTypeMismatchExceptionProxy(
 363                 result.getClass() + "[" + result + "]");
 364         return result;
 365     }
 366 
 367     /**
 368      * Parses the primitive or String annotation member value indicated by
 369      * the specified tag byte at the current position in the specified byte
 370      * buffer, resolving constant reference in the specified constant pool.
 371      * The cursor of the byte buffer must point to an annotation member value
 372      * of the type indicated by the specified tag, as described in the
 373      * RuntimeVisibleAnnotations_attribute:
 374      *
 375      *       u2   const_value_index;
 376      */
 377     private static Object parseConst(int tag,
 378                                      ByteBuffer buf, ConstantPool constPool) {
 379         int constIndex = buf.getShort() & 0xFFFF;
 380         switch(tag) {
 381           case 'B':
 382             return Byte.valueOf((byte) constPool.getIntAt(constIndex));
 383           case 'C':
 384             return Character.valueOf((char) constPool.getIntAt(constIndex));
 385           case 'D':
 386             return Double.valueOf(constPool.getDoubleAt(constIndex));
 387           case 'F':
 388             return Float.valueOf(constPool.getFloatAt(constIndex));
 389           case 'I':
 390             return Integer.valueOf(constPool.getIntAt(constIndex));
 391           case 'J':
 392             return Long.valueOf(constPool.getLongAt(constIndex));
 393           case 'S':
 394             return Short.valueOf((short) constPool.getIntAt(constIndex));
 395           case 'Z':
 396             return Boolean.valueOf(constPool.getIntAt(constIndex) != 0);
 397           case 's':
 398             return constPool.getUTF8At(constIndex);
 399           default:
 400             throw new AnnotationFormatError(
 401                 "Invalid member-value tag in annotation: " + tag);
 402         }
 403     }
 404 
 405     /**
 406      * Parses the Class member value at the current position in the
 407      * specified byte buffer, resolving constant references in the specified
 408      * constant pool.  The cursor of the byte buffer must point to a "class
 409      * info index" as described in the RuntimeVisibleAnnotations_attribute:
 410      *
 411      *       u2   class_info_index;
 412      */
 413     private static Object parseClassValue(ByteBuffer buf,
 414                                           ConstantPool constPool,
 415                                           Class<?> container) {
 416         int classIndex = buf.getShort() & 0xFFFF;
 417         try {
 418             try {
 419                 String sig = constPool.getUTF8At(classIndex);
 420                 return parseSig(sig, container);
 421             } catch (IllegalArgumentException ex) {
 422                 // support obsolete early jsr175 format class files
 423                 return constPool.getClassAt(classIndex);
 424             }
 425         } catch (NoClassDefFoundError e) {
 426             return new TypeNotPresentExceptionProxy("[unknown]", e);
 427         }
 428         catch (TypeNotPresentException e) {
 429             return new TypeNotPresentExceptionProxy(e.typeName(), e.getCause());
 430         }
 431     }
 432 
 433     private static Class<?> parseSig(String sig, Class<?> container) {
 434         if (sig.equals("V")) return void.class;
 435         SignatureParser parser = SignatureParser.make();
 436         TypeSignature typeSig = parser.parseTypeSig(sig);
 437         GenericsFactory factory = CoreReflectionFactory.make(container, ClassScope.make(container));
 438         Reifier reify = Reifier.make(factory);
 439         typeSig.accept(reify);
 440         Type result = reify.getResult();
 441         return toClass(result);
 442     }
 443     static Class<?> toClass(Type o) {
 444         if (o instanceof GenericArrayType)
 445             return Array.newInstance(toClass(((GenericArrayType)o).getGenericComponentType()),
 446                                      0)
 447                 .getClass();
 448         return (Class)o;
 449     }
 450 
 451     /**
 452      * Parses the enum constant member value at the current position in the
 453      * specified byte buffer, resolving constant references in the specified
 454      * constant pool.  The cursor of the byte buffer must point to a
 455      * "enum_const_value structure" as described in the
 456      * RuntimeVisibleAnnotations_attribute:
 457      *
 458      *       {
 459      *           u2   type_name_index;
 460      *           u2   const_name_index;
 461      *       } enum_const_value;
 462      */
 463     @SuppressWarnings({"rawtypes", "unchecked"})
 464     private static Object parseEnumValue(Class<? extends Enum> enumType, ByteBuffer buf,
 465                                          ConstantPool constPool,
 466                                          Class<?> container) {
 467         int typeNameIndex = buf.getShort() & 0xFFFF;
 468         String typeName  = constPool.getUTF8At(typeNameIndex);
 469         int constNameIndex = buf.getShort() & 0xFFFF;
 470         String constName = constPool.getUTF8At(constNameIndex);
 471 
 472         if (!typeName.endsWith(";")) {
 473             // support now-obsolete early jsr175-format class files.
 474             if (!enumType.getName().equals(typeName))
 475             return new AnnotationTypeMismatchExceptionProxy(
 476                 typeName + "." + constName);
 477         } else if (enumType != parseSig(typeName, container)) {
 478             return new AnnotationTypeMismatchExceptionProxy(
 479                 typeName + "." + constName);
 480         }
 481 
 482         try {
 483             return  Enum.valueOf(enumType, constName);
 484         } catch(IllegalArgumentException e) {
 485             return new EnumConstantNotPresentExceptionProxy(
 486                 (Class<? extends Enum<?>>)enumType, constName);
 487         }
 488     }
 489 
 490     /**
 491      * Parses the array value at the current position in the specified byte
 492      * buffer, resolving constant references in the specified constant pool.
 493      * The cursor of the byte buffer must point to an array value struct
 494      * as specified in the RuntimeVisibleAnnotations_attribute:
 495      *
 496      *       {
 497      *           u2    num_values;
 498      *           member_value values[num_values];
 499      *       } array_value;
 500      *
 501      * If the array values do not match arrayType, an
 502      * AnnotationTypeMismatchExceptionProxy will be returned.
 503      */
 504     @SuppressWarnings("unchecked")
 505     private static Object parseArray(Class<?> arrayType,
 506                                      ByteBuffer buf,
 507                                      ConstantPool constPool,
 508                                      Class<?> container) {
 509         int length = buf.getShort() & 0xFFFF;  // Number of array components
 510         Class<?> componentType = arrayType.getComponentType();
 511 
 512         if (componentType == byte.class) {
 513             return parseByteArray(length, buf, constPool);
 514         } else if (componentType == char.class) {
 515             return parseCharArray(length, buf, constPool);
 516         } else if (componentType == double.class) {
 517             return parseDoubleArray(length, buf, constPool);
 518         } else if (componentType == float.class) {
 519             return parseFloatArray(length, buf, constPool);
 520         } else if (componentType == int.class) {
 521             return parseIntArray(length, buf, constPool);
 522         } else if (componentType == long.class) {
 523             return parseLongArray(length, buf, constPool);
 524         } else if (componentType == short.class) {
 525             return parseShortArray(length, buf, constPool);
 526         } else if (componentType == boolean.class) {
 527             return parseBooleanArray(length, buf, constPool);
 528         } else if (componentType == String.class) {
 529             return parseStringArray(length, buf, constPool);
 530         } else if (componentType == Class.class) {
 531             return parseClassArray(length, buf, constPool, container);
 532         } else if (componentType.isEnum()) {
 533             return parseEnumArray(length, (Class<? extends Enum<?>>)componentType, buf,
 534                                   constPool, container);
 535         } else {
 536             assert componentType.isAnnotation();
 537             return parseAnnotationArray(length, (Class <? extends Annotation>)componentType, buf,
 538                                         constPool, container);
 539         }
 540     }
 541 
 542     private static Object parseByteArray(int length,
 543                                   ByteBuffer buf, ConstantPool constPool) {
 544         byte[] result = new byte[length];
 545         boolean typeMismatch = false;
 546         int tag = 0;
 547 
 548         for (int i = 0; i < length; i++) {
 549             tag = buf.get();
 550             if (tag == 'B') {
 551                 int index = buf.getShort() & 0xFFFF;
 552                 result[i] = (byte) constPool.getIntAt(index);
 553             } else {
 554                 skipMemberValue(tag, buf);
 555                 typeMismatch = true;
 556             }
 557         }
 558         return typeMismatch ? exceptionProxy(tag) : result;
 559     }
 560 
 561     private static Object parseCharArray(int length,
 562                                   ByteBuffer buf, ConstantPool constPool) {
 563         char[] result = new char[length];
 564         boolean typeMismatch = false;
 565         byte tag = 0;
 566 
 567         for (int i = 0; i < length; i++) {
 568             tag = buf.get();
 569             if (tag == 'C') {
 570                 int index = buf.getShort() & 0xFFFF;
 571                 result[i] = (char) constPool.getIntAt(index);
 572             } else {
 573                 skipMemberValue(tag, buf);
 574                 typeMismatch = true;
 575             }
 576         }
 577         return typeMismatch ? exceptionProxy(tag) : result;
 578     }
 579 
 580     private static Object parseDoubleArray(int length,
 581                                     ByteBuffer buf, ConstantPool constPool) {
 582         double[] result = new  double[length];
 583         boolean typeMismatch = false;
 584         int tag = 0;
 585 
 586         for (int i = 0; i < length; i++) {
 587             tag = buf.get();
 588             if (tag == 'D') {
 589                 int index = buf.getShort() & 0xFFFF;
 590                 result[i] = constPool.getDoubleAt(index);
 591             } else {
 592                 skipMemberValue(tag, buf);
 593                 typeMismatch = true;
 594             }
 595         }
 596         return typeMismatch ? exceptionProxy(tag) : result;
 597     }
 598 
 599     private static Object parseFloatArray(int length,
 600                                    ByteBuffer buf, ConstantPool constPool) {
 601         float[] result = new float[length];
 602         boolean typeMismatch = false;
 603         int tag = 0;
 604 
 605         for (int i = 0; i < length; i++) {
 606             tag = buf.get();
 607             if (tag == 'F') {
 608                 int index = buf.getShort() & 0xFFFF;
 609                 result[i] = constPool.getFloatAt(index);
 610             } else {
 611                 skipMemberValue(tag, buf);
 612                 typeMismatch = true;
 613             }
 614         }
 615         return typeMismatch ? exceptionProxy(tag) : result;
 616     }
 617 
 618     private static Object parseIntArray(int length,
 619                                  ByteBuffer buf, ConstantPool constPool) {
 620         int[] result = new  int[length];
 621         boolean typeMismatch = false;
 622         int tag = 0;
 623 
 624         for (int i = 0; i < length; i++) {
 625             tag = buf.get();
 626             if (tag == 'I') {
 627                 int index = buf.getShort() & 0xFFFF;
 628                 result[i] = constPool.getIntAt(index);
 629             } else {
 630                 skipMemberValue(tag, buf);
 631                 typeMismatch = true;
 632             }
 633         }
 634         return typeMismatch ? exceptionProxy(tag) : result;
 635     }
 636 
 637     private static Object parseLongArray(int length,
 638                                   ByteBuffer buf, ConstantPool constPool) {
 639         long[] result = new long[length];
 640         boolean typeMismatch = false;
 641         int tag = 0;
 642 
 643         for (int i = 0; i < length; i++) {
 644             tag = buf.get();
 645             if (tag == 'J') {
 646                 int index = buf.getShort() & 0xFFFF;
 647                 result[i] = constPool.getLongAt(index);
 648             } else {
 649                 skipMemberValue(tag, buf);
 650                 typeMismatch = true;
 651             }
 652         }
 653         return typeMismatch ? exceptionProxy(tag) : result;
 654     }
 655 
 656     private static Object parseShortArray(int length,
 657                                    ByteBuffer buf, ConstantPool constPool) {
 658         short[] result = new short[length];
 659         boolean typeMismatch = false;
 660         int tag = 0;
 661 
 662         for (int i = 0; i < length; i++) {
 663             tag = buf.get();
 664             if (tag == 'S') {
 665                 int index = buf.getShort() & 0xFFFF;
 666                 result[i] = (short) constPool.getIntAt(index);
 667             } else {
 668                 skipMemberValue(tag, buf);
 669                 typeMismatch = true;
 670             }
 671         }
 672         return typeMismatch ? exceptionProxy(tag) : result;
 673     }
 674 
 675     private static Object parseBooleanArray(int length,
 676                                      ByteBuffer buf, ConstantPool constPool) {
 677         boolean[] result = new boolean[length];
 678         boolean typeMismatch = false;
 679         int tag = 0;
 680 
 681         for (int i = 0; i < length; i++) {
 682             tag = buf.get();
 683             if (tag == 'Z') {
 684                 int index = buf.getShort() & 0xFFFF;
 685                 result[i] = (constPool.getIntAt(index) != 0);
 686             } else {
 687                 skipMemberValue(tag, buf);
 688                 typeMismatch = true;
 689             }
 690         }
 691         return typeMismatch ? exceptionProxy(tag) : result;
 692     }
 693 
 694     private static Object parseStringArray(int length,
 695                                     ByteBuffer buf,  ConstantPool constPool) {
 696         String[] result = new String[length];
 697         boolean typeMismatch = false;
 698         int tag = 0;
 699 
 700         for (int i = 0; i < length; i++) {
 701             tag = buf.get();
 702             if (tag == 's') {
 703                 int index = buf.getShort() & 0xFFFF;
 704                 result[i] = constPool.getUTF8At(index);
 705             } else {
 706                 skipMemberValue(tag, buf);
 707                 typeMismatch = true;
 708             }
 709         }
 710         return typeMismatch ? exceptionProxy(tag) : result;
 711     }
 712 
 713     private static Object parseClassArray(int length,
 714                                           ByteBuffer buf,
 715                                           ConstantPool constPool,
 716                                           Class<?> container) {
 717         Object[] result = new Class<?>[length];
 718         boolean typeMismatch = false;
 719         int tag = 0;
 720 
 721         for (int i = 0; i < length; i++) {
 722             tag = buf.get();
 723             if (tag == 'c') {
 724                 result[i] = parseClassValue(buf, constPool, container);
 725             } else {
 726                 skipMemberValue(tag, buf);
 727                 typeMismatch = true;
 728             }
 729         }
 730         return typeMismatch ? exceptionProxy(tag) : result;
 731     }
 732 
 733     private static Object parseEnumArray(int length, Class<? extends Enum<?>> enumType,
 734                                          ByteBuffer buf,
 735                                          ConstantPool constPool,
 736                                          Class<?> container) {
 737         Object[] result = (Object[]) Array.newInstance(enumType, length);
 738         boolean typeMismatch = false;
 739         int tag = 0;
 740 
 741         for (int i = 0; i < length; i++) {
 742             tag = buf.get();
 743             if (tag == 'e') {
 744                 result[i] = parseEnumValue(enumType, buf, constPool, container);
 745             } else {
 746                 skipMemberValue(tag, buf);
 747                 typeMismatch = true;
 748             }
 749         }
 750         return typeMismatch ? exceptionProxy(tag) : result;
 751     }
 752 
 753     private static Object parseAnnotationArray(int length,
 754                                                Class<? extends Annotation> annotationType,
 755                                                ByteBuffer buf,
 756                                                ConstantPool constPool,
 757                                                Class<?> container) {
 758         Object[] result = (Object[]) Array.newInstance(annotationType, length);
 759         boolean typeMismatch = false;
 760         int tag = 0;
 761 
 762         for (int i = 0; i < length; i++) {
 763             tag = buf.get();
 764             if (tag == '@') {
 765                 result[i] = parseAnnotation(buf, constPool, container, true);
 766             } else {
 767                 skipMemberValue(tag, buf);
 768                 typeMismatch = true;
 769             }
 770         }
 771         return typeMismatch ? exceptionProxy(tag) : result;
 772     }
 773 
 774     /**
 775      * Return an appropriate exception proxy for a mismatching array
 776      * annotation where the erroneous array has the specified tag.
 777      */
 778     private static ExceptionProxy exceptionProxy(int tag) {
 779         return new AnnotationTypeMismatchExceptionProxy(
 780             "Array with component tag: " + tag);
 781     }
 782 
 783     /**
 784      * Skips the annotation at the current position in the specified
 785      * byte buffer.  The cursor of the byte buffer must point to
 786      * an "annotation structure" OR two bytes into an annotation
 787      * structure (i.e., after the type index).
 788      *
 789      * @parameter complete true if the byte buffer points to the beginning
 790      *     of an annotation structure (rather than two bytes in).
 791      */
 792     private static void skipAnnotation(ByteBuffer buf, boolean complete) {
 793         if (complete)
 794             buf.getShort();   // Skip type index
 795         int numMembers = buf.getShort() & 0xFFFF;
 796         for (int i = 0; i < numMembers; i++) {
 797             buf.getShort();   // Skip memberNameIndex
 798             skipMemberValue(buf);
 799         }
 800     }
 801 
 802     /**
 803      * Skips the annotation member value at the current position in the
 804      * specified byte buffer.  The cursor of the byte buffer must point to a
 805      * "member_value structure."
 806      */
 807     private static void skipMemberValue(ByteBuffer buf) {
 808         int tag = buf.get();
 809         skipMemberValue(tag, buf);
 810     }
 811 
 812     /**
 813      * Skips the annotation member value at the current position in the
 814      * specified byte buffer.  The cursor of the byte buffer must point
 815      * immediately after the tag in a "member_value structure."
 816      */
 817     private static void skipMemberValue(int tag, ByteBuffer buf) {
 818         switch(tag) {
 819           case 'e': // Enum value
 820             buf.getInt();  // (Two shorts, actually.)
 821             break;
 822           case '@':
 823             skipAnnotation(buf, true);
 824             break;
 825           case '[':
 826             skipArray(buf);
 827             break;
 828           default:
 829             // Class, primitive, or String
 830             buf.getShort();
 831         }
 832     }
 833 
 834     /**
 835      * Skips the array value at the current position in the specified byte
 836      * buffer.  The cursor of the byte buffer must point to an array value
 837      * struct.
 838      */
 839     private static void skipArray(ByteBuffer buf) {
 840         int length = buf.getShort() & 0xFFFF;
 841         for (int i = 0; i < length; i++)
 842             skipMemberValue(buf);
 843     }
 844 
 845     /**
 846      * Searches for given {@code element} in given {@code array} by identity.
 847      * Returns {@code true} if found {@code false} if not.
 848      */
 849     private static boolean contains(Object[] array, Object element) {
 850         for (Object e : array)
 851             if (e == element)
 852                 return true;
 853         return false;
 854     }
 855 
 856     /*
 857      * This method converts the annotation map returned by the parseAnnotations()
 858      * method to an array.  It is called by Field.getDeclaredAnnotations(),
 859      * Method.getDeclaredAnnotations(), and Constructor.getDeclaredAnnotations().
 860      * This avoids the reflection classes to load the Annotation class until
 861      * it is needed.
 862      */
 863     private static final Annotation[] EMPTY_ANNOTATION_ARRAY = new Annotation[0];
 864     public static Annotation[] toArray(Map<Class<? extends Annotation>, Annotation> annotations) {
 865         return annotations.values().toArray(EMPTY_ANNOTATION_ARRAY);
 866     }
 867 
 868     static Annotation[] getEmptyAnnotationArray() { return EMPTY_ANNOTATION_ARRAY; }
 869 }