#include <stdio.h>
#include <stdlib.h>
+#include "mm/memory.h"
+
+#include "native/llni.h"
+
#include "toolbox/logging.h"
#include "vm/global.h"
}
+/* array **********************************************************************/
+
+java_handle_t *array_objectarray_element_get(java_handle_objectarray_t *a, int32_t index)
+{
+ java_handle_t *value;
+ int32_t size;
+
+ if (a == NULL) {
+ log_println("array_objectarray_element_get(a=%p, index=%d): NullPointerException", a, index);
+ return NULL;
+ }
+
+ size = LLNI_array_size(a);
+
+ if ((index < 0) || (index > size)) {
+ log_println("array_objectarray_element_get(a=%p, index=%d): ArrayIndexOutOfBoundsException", a, index);
+ return NULL;
+ }
+
+ value = LLNI_array_direct(a, index);
+
+ return value;
+}
+
+void array_objectarray_element_set(java_handle_objectarray_t *a, int32_t index, java_handle_t *value)
+{
+ int32_t size;
+
+ if (a == NULL) {
+ log_println("array_objectarray_element_set(a=%p, index=%d): NullPointerException", a, index);
+ return;
+ }
+
+ size = LLNI_array_size(a);
+
+ if ((index < 0) || (index > size)) {
+ log_println("array_objectarray_element_set(a=%p, index=%d): ArrayIndexOutOfBoundsException", a, index);
+ return;
+ }
+
+ LLNI_array_direct(a, index) = value;
+}
+
+int32_t array_length_get(java_handle_t *a)
+{
+ if (a == NULL) {
+ log_println("array_length_get(a=%p): NullPointerException", a);
+ return 0;
+ }
+
+ return LLNI_array_size(a);
+}
+
+
/* asm ************************************************************************/
void asm_abstractmethoderror(void)
java_handle_objectarray_t *builtin_anewarray(int32_t size, classinfo *componentclass)
{
- abort();
+ java_handle_objectarray_t *oa = (java_handle_objectarray_t*)mem_alloc(
+ sizeof(java_array_t) + size * sizeof(java_object_t*));
- return NULL;
+ if (oa != NULL) {
+ LLNI_array_size(oa) = size;
+ }
+
+ return oa;
}
java_handle_bytearray_t *builtin_newarray_byte(int32_t size)
{
- abort();
+ java_handle_bytearray_t *ba = (java_handle_bytearray_t*)mem_alloc(
+ sizeof(java_array_t) + size * sizeof(int8_t));
- return NULL;
+ if (ba != NULL) {
+ LLNI_array_size(ba) = size;
+ }
+
+ return ba;
}
/* primitive ******************************************************************/
+classinfo *primitive_arrayclass_get_by_type(int type)
+{
+ return NULL;
+}
+
classinfo *primitive_class_get_by_type(int type)
{
abort();
*/
JNIEXPORT struct java_util_Map* JNICALL Java_java_lang_reflect_Constructor_declaredAnnotations(JNIEnv *env, java_lang_reflect_Constructor *this)
{
- java_handle_t *o = (java_handle_t*)this;
struct java_util_Map *declaredAnnotations = NULL;
java_handle_bytearray_t *annotations = NULL;
java_lang_Class *declaringClass = NULL;
*/
JNIEXPORT java_handle_objectarray_t* JNICALL Java_java_lang_reflect_Constructor_getParameterAnnotations(JNIEnv *env, java_lang_reflect_Constructor *this)
{
- java_handle_t *o = (java_handle_t*)this;
java_handle_bytearray_t *parameterAnnotations = NULL;
int32_t slot = -1;
java_lang_Class *declaringClass = NULL;
*/
JNIEXPORT struct java_util_Map* JNICALL Java_java_lang_reflect_Field_declaredAnnotations(JNIEnv *env, java_lang_reflect_Field *this)
{
- java_handle_t *o = (java_handle_t*)this;
struct java_util_Map *declaredAnnotations = NULL;
java_handle_bytearray_t *annotations = NULL;
java_lang_Class *declaringClass = NULL;
utf *utf_parseAnnotationDefault = NULL;
utf *utf_desc = NULL;
sun_reflect_ConstantPool *constantPool = NULL;
- java_handle_t *o = (java_handle_t*)this;
java_lang_Class *constantPoolOop = NULL;
classinfo *referer = NULL;
*/
JNIEXPORT struct java_util_Map* JNICALL Java_java_lang_reflect_Method_declaredAnnotations(JNIEnv *env, java_lang_reflect_Method *this)
{
- java_handle_t *o = (java_handle_t*)this;
struct java_util_Map *declaredAnnotations = NULL;
java_handle_bytearray_t *annotations = NULL;
java_lang_Class *declaringClass = NULL;
*/
JNIEXPORT java_handle_objectarray_t* JNICALL Java_java_lang_reflect_Method_getParameterAnnotations(JNIEnv *env, java_lang_reflect_Method *this)
{
- java_handle_t *o = (java_handle_t*)this;
java_handle_bytearray_t *parameterAnnotations = NULL;
int32_t slot = -1;
java_lang_Class *declaringClass = NULL;
void _Jv_sun_reflect_ConstantPool_init(void)
{
- native_method_register(utf_sun_reflect_ConstantPool, methods, NATIVE_METHODS_COUNT);
+ native_method_register(utf_new_char("sun/reflect/ConstantPool"), methods, NATIVE_METHODS_COUNT);
}
/*
#include "vmcore/loader.h"
#if defined(WITH_CLASSPATH_GNU) && defined(ENABLE_ANNOTATIONS)
+#include "native/include/sun_reflect_ConstantPool.h"
+
#include "vm/vm.h"
+
#include "vmcore/annotation.h"
-#include "native/include/sun_reflect_ConstantPool.h"
#endif
/*
if (exceptions_get_exception() != NULL) {
/* the only exception possible here should be a out of memory exception
- * raised by copying the annotations into a java bytearray */
+ * raised by copying the annotations into a new java bytearray */
return NULL;
}
#include <assert.h>
+#include "native/llni.h"
+
#include "vm/types.h"
+#include "vm/array.h"
+#include "vm/builtin.h"
+#include "vm/primitive.h"
#include "mm/memory.h"
# error annotation support has to be enabled when compling this file!
#endif
-/* annotation_bytearray_new ***************************************************
-
- Allocate a new bytearray.
-
-*******************************************************************************/
-
-annotation_bytearray_t *annotation_bytearray_new(uint32_t size)
-{
- annotation_bytearray_t *ba =
- mem_alloc(sizeof(uint32_t) + sizeof(uint8_t) * size);
-
- if (ba != NULL) {
- ba->size = size;
- }
-
- return ba;
-}
-
-
-/* annotation_bytearray_free **************************************************
-
- Free a bytearray.
-
-*******************************************************************************/
-
-void annotation_bytearray_free(annotation_bytearray_t *ba)
-{
- if (ba != NULL) {
- mem_free(ba, sizeof(uint32_t) + sizeof(uint8_t) * ba->size);
- }
-}
-
-
-/* annotation_bytearrays_new **************************************************
-
- Allocate a new array of bytearrays.
-
-*******************************************************************************/
-
-annotation_bytearrays_t *annotation_bytearrays_new(uint32_t size)
-{
- annotation_bytearrays_t *bas =
- mem_alloc(sizeof(uint32_t) + sizeof(annotation_bytearray_t*) * size);
-
- if (bas != NULL) {
- bas->size = size;
- }
-
- return bas;
-}
-
/* annotation_bytearrays_resize ***********************************************
*******************************************************************************/
-bool annotation_bytearrays_resize(annotation_bytearrays_t **bas,
+static bool annotation_bytearrays_resize(java_handle_objectarray_t **bas,
uint32_t size)
{
- annotation_bytearrays_t *newbas = NULL;
+ java_handle_objectarray_t *newbas = NULL;
+ java_handle_t *o;
uint32_t i;
uint32_t minsize;
+ uint32_t oldsize;
assert(bas != NULL);
- newbas = annotation_bytearrays_new(size);
+ /* if the size already fits do nothing */
+ if (*bas != NULL) {
+ oldsize = array_length_get((java_handle_t*)*bas);
+
+ if (size == oldsize) {
+ return true;
+ }
+ }
+
+ newbas = builtin_anewarray(size,
+ primitive_arrayclass_get_by_type(PRIMITIVETYPE_BYTE));
if (newbas == NULL) {
+ /* out of memory */
return false;
}
+ /* is there a old byte array array? */
if (*bas != NULL) {
- minsize = size < (*bas)->size ? size : (*bas)->size;
-
- for (i = size; i < (*bas)->size; ++ i) {
- annotation_bytearray_free((*bas)->data[i]);
- }
+ minsize = size < oldsize ? size : oldsize;
- for (i = 0; i < minsize; ++i) {
- newbas->data[i] = (*bas)->data[i];
- }
+ MCOPY(LLNI_array_data(newbas), LLNI_array_data(*bas), java_object_t*, minsize);
}
*bas = newbas;
*******************************************************************************/
-bool annotation_bytearrays_insert(annotation_bytearrays_t **bas,
- uint32_t index, annotation_bytearray_t *ba)
+static bool annotation_bytearrays_insert(java_handle_objectarray_t **bas,
+ uint32_t index, java_handle_bytearray_t *ba)
{
+ uint32_t size = 0;
+
assert(bas != NULL);
- if (ba != NULL) {
- if (*bas == NULL || (*bas)->size <= index) {
+ /* do nothing if NULL is inserted but no array exists */
+ if (ba == NULL && *bas == NULL) {
+ return true;
+ }
+
+ /* get lengths if array exists */
+ if (*bas != NULL) {
+ size = array_length_get((java_handle_t*)*bas);
+ }
+
+ if (ba == NULL) {
+ /* insert NULL only if array is big enough */
+ if (size > index) {
+ array_objectarray_element_set(*bas, index, NULL);
+ }
+ }
+ else {
+ /* resize array if it's not enough for inserted value */
+ if (size <= index) {
if (!annotation_bytearrays_resize(bas, index + 1)) {
+ /* out of memory */
return false;
}
}
- else {
- /* free old bytearray (if any) */
- annotation_bytearray_free((*bas)->data[index]);
- }
- /* insert new bytearray */
- (*bas)->data[index] = ba;
+ array_objectarray_element_set(*bas, index, (java_handle_t*)ba);
}
- else if (*bas != NULL && (*bas)->size > index) {
- /* do not resize when just inserting NULL,
- * but free old bytearray if there is any */
- annotation_bytearray_free((*bas)->data[index]);
- }
-
+
return true;
}
-/* annotation_bytearrays_free *************************************************
-
- Free an array of bytearrays.
-
-*******************************************************************************/
-
-void annotation_bytearrays_free(annotation_bytearrays_t *bas)
-{
- uint32_t i;
-
- if (bas != NULL) {
- for (i = 0; i < bas->size; ++ i) {
- annotation_bytearray_free(bas->data[i]);
- }
-
- mem_free(bas, sizeof(uint32_t) +
- sizeof(annotation_bytearray_t*) * bas->size);
- }
-}
-
-
/* annotation_load_attribute_body *********************************************
This function loads the body of a generic attribute.
*******************************************************************************/
static bool annotation_load_attribute_body(classbuffer *cb,
- annotation_bytearray_t **attribute, const char *errormsg_prefix)
+ java_handle_bytearray_t **attribute, const char *errormsg_prefix)
{
uint32_t size = 0;
- annotation_bytearray_t *ba = NULL;
+ java_handle_bytearray_t *ba = NULL;
assert(cb != NULL);
assert(attribute != NULL);
/* if attribute_length == 0 then NULL is
* the right value for this attribute */
if (size > 0) {
- ba = annotation_bytearray_new(size);
+ ba = builtin_newarray_byte(size);
if (ba == NULL) {
/* out of memory */
}
/* load data */
- suck_nbytes(ba->data, cb, size);
+ suck_nbytes((uint8_t*)LLNI_array_data(ba), cb, size);
/* return data */
*attribute = ba;
classbuffer *cb, methodinfo *m)
{
int slot = 0;
- annotation_bytearray_t *annotationdefault = NULL;
- annotation_bytearrays_t **annotationdefaults = NULL;
+ java_handle_bytearray_t *annotationdefault = NULL;
+ java_handle_objectarray_t **annotationdefaults = NULL;
assert(cb != NULL);
assert(m != NULL);
annotationdefaults = &(m->class->method_annotationdefaults);
if (!annotation_load_attribute_body(
- cb, &annotationdefault,
- "invalid annotation default method attribute")) {
+ cb, &annotationdefault,
+ "invalid annotation default method attribute")) {
return false;
}
slot = m - m->class->methods;
if (!annotation_bytearrays_insert(
- annotationdefaults, slot, annotationdefault)) {
- annotation_bytearray_free(annotationdefault);
+ annotationdefaults, slot, annotationdefault)) {
return false;
}
}
classbuffer *cb, methodinfo *m)
{
int slot = 0;
- annotation_bytearray_t *annotations = NULL;
- annotation_bytearrays_t **parameterannotations = NULL;
+ java_handle_bytearray_t *annotations = NULL;
+ java_handle_objectarray_t **parameterannotations = NULL;
assert(cb != NULL);
assert(m != NULL);
parameterannotations = &(m->class->method_parameterannotations);
if (!annotation_load_attribute_body(
- cb, &annotations,
- "invalid runtime visible parameter annotations method attribute")) {
+ cb, &annotations,
+ "invalid runtime visible parameter annotations method attribute")) {
return false;
}
slot = m - m->class->methods;
if (!annotation_bytearrays_insert(
- parameterannotations, slot, annotations)) {
- annotation_bytearray_free(annotations);
+ parameterannotations, slot, annotations)) {
return false;
}
}
classbuffer *cb, methodinfo *m)
{
int slot = 0;
- annotation_bytearray_t *annotations = NULL;
- annotation_bytearrays_t **method_annotations = NULL;
+ java_handle_bytearray_t *annotations = NULL;
+ java_handle_objectarray_t **method_annotations = NULL;
assert(cb != NULL);
assert(m != NULL);
method_annotations = &(m->class->method_annotations);
if (!annotation_load_attribute_body(
- cb, &annotations,
- "invalid runtime visible annotations method attribute")) {
+ cb, &annotations,
+ "invalid runtime visible annotations method attribute")) {
return false;
}
slot = m - m->class->methods;
if (!annotation_bytearrays_insert(
- method_annotations, slot, annotations)) {
- annotation_bytearray_free(annotations);
+ method_annotations, slot, annotations)) {
return false;
}
}
classbuffer *cb, fieldinfo *f)
{
int slot = 0;
- annotation_bytearray_t *annotations = NULL;
- annotation_bytearrays_t **field_annotations = NULL;
+ java_handle_bytearray_t *annotations = NULL;
+ java_handle_objectarray_t **field_annotations = NULL;
assert(cb != NULL);
assert(f != NULL);
field_annotations = &(f->class->field_annotations);
if (!annotation_load_attribute_body(
- cb, &annotations,
- "invalid runtime visible annotations field attribute")) {
+ cb, &annotations,
+ "invalid runtime visible annotations field attribute")) {
return false;
}
slot = f - f->class->fields;
if (!annotation_bytearrays_insert(
- field_annotations, slot, annotations)) {
- annotation_bytearray_free(annotations);
+ field_annotations, slot, annotations)) {
return false;
}
}
#ifndef _ANNOTATION_H
#define _ANNOTATION_H
-/* forward typedefs ***********************************************************/
-
-typedef struct annotation_bytearray_t annotation_bytearray_t;
-typedef struct annotation_t annotation_t;
-typedef struct element_value_t element_value_t;
-typedef struct annotation_bytearrays_t annotation_bytearrays_t;
#include "config.h"
#include "vm/types.h"
#include "vmcore/utf8.h"
-/* annotation_bytearray *******************************************************/
-
-struct annotation_bytearray_t {
- uint32_t size;
- uint8_t data[1];
-};
-
-
-/* annotation_bytearrays ******************************************************/
-
-struct annotation_bytearrays_t {
- uint32_t size;
- annotation_bytearray_t *data[1];
-};
-
-
/* function prototypes ********************************************************/
-annotation_bytearray_t *annotation_bytearray_new(uint32_t size);
-
-void annotation_bytearray_free(annotation_bytearray_t *ba);
-
-annotation_bytearrays_t *annotation_bytearrays_new(uint32_t size);
-
-bool annotation_bytearrays_resize(annotation_bytearrays_t **bas,
- uint32_t size);
-
-bool annotation_bytearrays_insert(annotation_bytearrays_t **bas,
- uint32_t index, annotation_bytearray_t *ba);
-
-void annotation_bytearrays_free(annotation_bytearrays_t *bas);
-
bool annotation_load_class_attribute_runtimevisibleannotations(
classbuffer *cb);
#if defined(ENABLE_ANNOTATIONS)
classinfo *class_sun_reflect_ConstantPool;
+#if defined(WITH_CLASSPATH_GNU)
classinfo *class_sun_reflect_annotation_AnnotationParser;
#endif
#endif
+#endif
/* pseudo classes for the typechecker */
mem_free(c->header.vftbl, sizeof(vftbl) + sizeof(methodptr)*(c->vftbl->vftbllength-1)); */
/* GCFREE(c); */
-
-#if defined(ENABLE_ANNOTATIONS)
- annotation_bytearray_free(c->annotations);
-
- annotation_bytearrays_free(c->method_annotations);
- annotation_bytearrays_free(c->method_parameterannotations);
- annotation_bytearrays_free(c->method_annotationdefaults);
-
- annotation_bytearrays_free(c->field_annotations);
-#endif
}
java_handle_bytearray_t *class_get_annotations(classinfo *c)
{
#if defined(ENABLE_ANNOTATIONS)
- java_handle_bytearray_t *annotations = NULL;
- uint32_t size = 0;
-
- /* Return null for arrays and primitives: */
- if (class_is_primitive(c) || class_is_array(c)) {
- return NULL;
- }
-
- /* copy the annotations into a java byte array: */
- if (c->annotations != NULL) {
- size = c->annotations->size;
- annotations = builtin_newarray_byte(size);
-
- if(annotations != NULL) {
- MCOPY(annotations->data, c->annotations->data, uint8_t, size);
- }
- }
-
- return annotations;
+ return c->annotations;
#else
return NULL;
#endif
#if defined(ENABLE_JAVASE)
utf *signature; /* Signature attribute */
#if defined(ENABLE_ANNOTATIONS)
- /* all the anntation attributes are NULL (and not a zero length array)
- if there is nothing */
- annotation_bytearray_t *annotations; /* annotations of this class */
+ /* All the annotation attributes are NULL (and not a zero length array) */
+ /* if there is nothing. */
+ java_handle_bytearray_t *annotations; /* annotations of this class */
- annotation_bytearrays_t *method_annotations; /* array of annotations for */
- /* the methods */
- annotation_bytearrays_t *method_parameterannotations; /* array of */
+ java_handle_objectarray_t *method_annotations; /* array of annotations */
+ /* for the methods */
+ java_handle_objectarray_t *method_parameterannotations; /* array of */
/* parameter annotations for the methods */
- annotation_bytearrays_t *method_annotationdefaults; /* array for */
+ java_handle_objectarray_t *method_annotationdefaults; /* array for */
/* annotation default values for the */
- /* methods */
+ /* methods */
- annotation_bytearrays_t *field_annotations; /* array of annotations for */
+ java_handle_objectarray_t *field_annotations; /* array of annotations for */
/* the fields */
#endif
#endif
#if defined(ENABLE_ANNOTATIONS)
classinfo *c;
int slot;
- annotation_bytearray_t *ba;
java_handle_bytearray_t *annotations;
c = f->class;
slot = f - c->fields;
annotations = NULL;
- if (c->field_annotations != NULL && c->field_annotations->size > slot) {
- ba = c->field_annotations->data[slot];
-
- if (ba != NULL) {
- annotations = builtin_newarray_byte(ba->size);
-
- if (annotations != NULL) {
- MCOPY(annotations->data, ba->data, uint8_t, ba->size);
- }
- }
+ if (c->field_annotations != NULL &&
+ array_length_get(c->field_annotations) > slot) {
+ annotations = (java_handle_bytearray_t*)
+ array_objectarray_element_get(
+ c->field_annotations, slot);
}
return annotations;
#if defined(ENABLE_ANNOTATIONS)
/* needed by annotation support */
if (!(class_sun_reflect_ConstantPool =
- load_class_bootstrap(utf_sun_reflect_ConstantPool)))
+ load_class_bootstrap(utf_new_char("sun/reflect/ConstantPool"))))
return false;
#if defined(WITH_CLASSPATH_GNU)
/* needed by GNU Classpaths annotation support */
if (!(class_sun_reflect_annotation_AnnotationParser =
- load_class_bootstrap(utf_sun_reflect_annotation_AnnotationParser)))
+ load_class_bootstrap(utf_new_char("sun/reflect/annotation/AnnotationParser"))))
return false;
#endif
#endif
#if defined(ENABLE_ANNOTATIONS)
classinfo *c;
int slot;
- annotation_bytearray_t *ba;
java_handle_bytearray_t *annotations;
c = m->class;
slot = m - c->methods;
annotations = NULL;
- if (c->method_annotations != NULL && c->method_annotations->size > slot) {
- ba = c->method_annotations->data[slot];
-
- if (ba != NULL) {
- annotations = builtin_newarray_byte(ba->size);
-
- if (annotations != NULL) {
- MCOPY(annotations->data, ba->data, uint8_t, ba->size);
- }
- }
+ if (c->method_annotations != NULL && array_length_get(c->method_annotations) > slot) {
+ annotations = (java_handle_bytearray_t*)array_objectarray_element_get(
+ c->method_annotations, slot);
}
return annotations;
#if defined(ENABLE_ANNOTATIONS)
classinfo *c;
int slot;
- annotation_bytearray_t *ba;
java_handle_bytearray_t *parameterAnnotations;
c = m->class;
parameterAnnotations = NULL;
if (c->method_parameterannotations != NULL &&
- c->method_parameterannotations->size > slot) {
- ba = c->method_parameterannotations->data[slot];
-
- if (ba != NULL) {
- parameterAnnotations = builtin_newarray_byte(ba->size);
-
- if (parameterAnnotations != NULL) {
- MCOPY(parameterAnnotations->data, ba->data, uint8_t, ba->size);
- }
- }
+ array_length_get(c->method_parameterannotations) > slot) {
+ parameterAnnotations =
+ (java_handle_bytearray_t*)array_objectarray_element_get(
+ c->method_parameterannotations, slot);
}
return parameterAnnotations;
#if defined(ENABLE_ANNOTATIONS)
classinfo *c;
int slot;
- annotation_bytearray_t *ba;
java_handle_bytearray_t *annotationDefault;
c = m->class;
annotationDefault = NULL;
if (c->method_annotationdefaults != NULL &&
- c->method_annotationdefaults->size > slot) {
- ba = c->method_annotationdefaults->data[slot];
-
- if (ba != NULL) {
- annotationDefault = builtin_newarray_byte(ba->size);
-
- if (annotationDefault != NULL) {
- MCOPY(annotationDefault->data, ba->data, uint8_t, ba->size);
- }
- }
+ array_length_get(c->method_annotationdefaults) > slot) {
+ annotationDefault =
+ (java_handle_bytearray_t*)array_objectarray_element_get(
+ c->method_annotationdefaults, slot);
}
return annotationDefault;
utf *utf_StackMapTable;
#if defined(ENABLE_ANNOTATIONS)
-utf *utf_sun_reflect_ConstantPool;
-#if defined(WITH_CLASSPATH_GNU)
-utf *utf_sun_reflect_annotation_AnnotationParser;
-#endif
-
utf *utf_RuntimeVisibleAnnotations;
utf *utf_RuntimeInvisibleAnnotations;
utf *utf_RuntimeVisibleParameterAnnotations;
utf_StackMapTable = utf_new_char("StackMapTable");
#if defined(ENABLE_ANNOTATIONS)
- utf_sun_reflect_ConstantPool = utf_new_char("sun/reflect/ConstantPool");
-#if defined(WITH_CLASSPATH_GNU)
- utf_sun_reflect_annotation_AnnotationParser = utf_new_char("sun/reflect/annotation/AnnotationParser");
-#endif
-
utf_RuntimeVisibleAnnotations = utf_new_char("RuntimeVisibleAnnotations");
utf_RuntimeInvisibleAnnotations = utf_new_char("RuntimeInvisibleAnnotations");
utf_RuntimeVisibleParameterAnnotations = utf_new_char("RuntimeVisibleParameterAnnotations");
extern utf *utf_StackMapTable;
#if defined(ENABLE_ANNOTATIONS)
-/* OpenJDKs sun.reflect.ConstantPool class is for now only
- * used by annotations but will probably be used for other
- * things in the future. For now I just couple it with
- * annotation support.
- */
-extern utf *utf_sun_reflect_ConstantPool;
-#if defined(WITH_CLASSPATH_GNU)
-extern utf *utf_sun_reflect_annotation_AnnotationParser;
-#endif
-
extern utf *utf_RuntimeVisibleAnnotations;
extern utf *utf_RuntimeInvisibleAnnotations;
extern utf *utf_RuntimeVisibleParameterAnnotations;
projects / cacao.git / commitdiff