[vmkit-commits] [vmkit] r180313 - Support for annotations in Fields and Methods when GNUClasspath is used. It is not a finished work.
Peter Senna Tschudin
peter.senna at gmail.com
Thu Apr 25 09:54:49 PDT 2013
Author: peter.senna
Date: Thu Apr 25 11:53:18 2013
New Revision: 180313
URL: http://llvm.org/viewvc/llvm-project?rev=180313&view=rev
Log:
Support for annotations in Fields and Methods when GNUClasspath is used. It is not a finished work.
Done:
VMMethod.getAnnotation(Class)
VMField.getAnnotation(Class)
(cherry picked from commit f547cba473cd8029f18ad3afa05c01b23174e1ae)
Modified:
vmkit/trunk/lib/j3/ClassLib/GNUClasspath/ClasspathVMClass.inc
vmkit/trunk/lib/j3/ClassLib/GNUClasspath/ClasspathVMField.inc
vmkit/trunk/lib/j3/ClassLib/GNUClasspath/ClasspathVMMethod.inc
vmkit/trunk/lib/j3/ClassLib/GNUClasspath/JavaUpcalls.cpp
vmkit/trunk/lib/j3/ClassLib/GNUClasspath/JavaUpcalls.h
vmkit/trunk/lib/j3/ClassLib/Reflect.inc
vmkit/trunk/lib/j3/VMCore/JavaClass.cpp
vmkit/trunk/lib/j3/VMCore/JavaClass.h
vmkit/trunk/tests/AnnotationClassTest.java
Modified: vmkit/trunk/lib/j3/ClassLib/GNUClasspath/ClasspathVMClass.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/ClassLib/GNUClasspath/ClasspathVMClass.inc?rev=180313&r1=180312&r2=180313&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/ClassLib/GNUClasspath/ClasspathVMClass.inc (original)
+++ vmkit/trunk/lib/j3/ClassLib/GNUClasspath/ClasspathVMClass.inc Thu Apr 25 11:53:18 2013
@@ -435,6 +435,8 @@ jclass clazz,
#endif
JavaObject* Cl) {
// TODO implement me
+ fprintf(stderr, "Java_java_lang_VMClass_getDeclaredAnnotations not implemented\n");
+ abort();
ArrayObject* res = 0;
llvm_gcroot(res, 0);
Modified: vmkit/trunk/lib/j3/ClassLib/GNUClasspath/ClasspathVMField.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/ClassLib/GNUClasspath/ClasspathVMField.inc?rev=180313&r1=180312&r2=180313&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/ClassLib/GNUClasspath/ClasspathVMField.inc (original)
+++ vmkit/trunk/lib/j3/ClassLib/GNUClasspath/ClasspathVMField.inc Thu Apr 25 11:53:18 2013
@@ -20,6 +20,7 @@
#include "ClasspathReflect.h"
#include "JavaClass.h"
#include "JavaThread.h"
+#include "JavaConstantPool.h"
#include "JavaTypes.h"
#include "JavaUpcalls.h"
#include "Jnjvm.h"
@@ -27,7 +28,7 @@
#include "Reader.h"
-#if 0
+#if 1
using namespace vmkit;
#define dprintf(...) do { printf("ClasspathVMField: "); printf(__VA_ARGS__); } while(0)
#else
@@ -38,6 +39,72 @@ using namespace j3;
extern "C" {
+JNIEXPORT JavaObject* JNICALL Java_java_lang_reflect_VMField_getAnnotation(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+#endif
+JavaObjectVMField* VMField, JavaObjectClass* annotationClass) {
+ JavaObject* res = 0;
+ JavaObject* newHashMap = 0;
+ llvm_gcroot(res, 0);
+ llvm_gcroot(newHashMap, 0);
+ llvm_gcroot(VMField, 0);
+ llvm_gcroot(annotationClass, 0);
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
+ Jnjvm* vm = JavaThread::get()->getJVM();
+ Classpath* upcalls = vm->upcalls;
+
+ dprintf("*************VMField_getAnnotation*************\n");
+ if (annotationClass) {
+ /* Retrieving annotationClass classname */
+ UserClass* clazz = JavaObjectClass::getClass(annotationClass)->asClass();
+ dprintf("searched annotation : %s\n\n", UTF8Buffer(clazz->name).cString());
+
+ /* Retrieving VMField.class attributes list */
+ UserClass* compilingClass = JavaObjectVMField::getClass(VMField);
+ JavaField* field = JavaObjectVMField::getInternalField(VMField);
+ Attribut* annotationsAtt =
+ field->lookupAttribut(Attribut::annotationsAttribut);
+ dprintf("JavaField : %s\n", UTF8Buffer(field->name).cString());
+
+ if (annotationsAtt) {
+ Reader reader(annotationsAtt, compilingClass->bytes);
+ AnnotationReader AR(reader, compilingClass);
+ uint16 numAnnotations = reader.readU2();
+
+ for (uint16 i = 0; i < numAnnotations; ++i) {
+ uint16 typeIndex = reader.readU2();
+ const UTF8* annoType = compilingClass->ctpInfo->UTF8At(typeIndex);
+
+ // Remove the L and ; in the name annotation type (L.....;)
+ // for the comparison.
+ dprintf("Comparing with : %s\n", UTF8Buffer(annoType).cString());
+ if (clazz->name->equals(annoType->elements+1, annoType->size-2)) {
+ newHashMap = AR.createAnnotationMapValues();
+ break;
+
+ } else {
+ AR.readAnnotationElementValues();
+ }
+ } // end for
+
+ if (newHashMap) {
+ dprintf("Annotation creation\n");
+ res = upcalls->createAnnotation->invokeJavaObjectStatic(vm, upcalls->newAnnotationHandler, &annotationClass, &newHashMap);
+ }
+
+ }
+ } else {
+ vm->nullPointerException();
+ }
+
+ END_NATIVE_EXCEPTION
+ dprintf("Annotation found\n");
+ return res;
+}
+
JNIEXPORT jint JNICALL Java_java_lang_reflect_VMField_getModifiersInternal(
#ifdef NATIVE_JNI
JNIEnv *env,
Modified: vmkit/trunk/lib/j3/ClassLib/GNUClasspath/ClasspathVMMethod.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/ClassLib/GNUClasspath/ClasspathVMMethod.inc?rev=180313&r1=180312&r2=180313&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/ClassLib/GNUClasspath/ClasspathVMMethod.inc (original)
+++ vmkit/trunk/lib/j3/ClassLib/GNUClasspath/ClasspathVMMethod.inc Thu Apr 25 11:53:18 2013
@@ -25,6 +25,109 @@ using namespace j3;
extern "C" {
+JNIEXPORT JavaObject* JNICALL Java_java_lang_reflect_VMMethod_getDefaultValue(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+#endif
+JavaObjectVMMethod* VMMeth) {
+ JavaObject* res = 0;
+ llvm_gcroot(VMMeth, 0);
+ llvm_gcroot(res, 0);
+
+ BEGIN_NATIVE_EXCEPTION(0)
+ dprintf("*************VMMethod_getDefaultValue*************\n");
+ Classpath* upcalls = JavaThread::get()->getJVM()->upcalls;
+ UserClass* cl = JavaObjectVMMethod::getClass(VMMeth);
+ dprintf("JavaClass:%s\n", UTF8Buffer(cl->name).cString());
+
+ // Annotation interface class.
+ const UTF8* name = upcalls->newAnnotation->name;
+
+ if (cl->inheritName(name->elements, name->size)) {
+ // Find "default attribute"
+ JavaMethod* method = JavaObjectVMMethod::getInternalMethod(VMMeth);
+ Attribut* annotationsAtt =
+ method->lookupAttribut(Attribut::annotationDefaultAttribut);
+ dprintf("JavaMethod:%s\n", UTF8Buffer(method->name).cString());
+
+ if (annotationsAtt) {
+ Reader reader(annotationsAtt, cl->bytes);
+ AnnotationReader AR(reader, cl);
+
+ res = AR.createElementValue();
+ }
+ }
+
+ END_NATIVE_EXCEPTION
+
+ return res;
+}
+
+JNIEXPORT JavaObject* JNICALL Java_java_lang_reflect_VMMethod_getAnnotation(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+#endif
+JavaObjectVMMethod* VMMeth, JavaObjectClass* annotationClass) {
+ JavaObject* res = 0;
+ JavaObject* newHashMap = 0;
+ llvm_gcroot(res, 0);
+ llvm_gcroot(newHashMap, 0);
+ llvm_gcroot(VMMeth, 0);
+ llvm_gcroot(annotationClass, 0);
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
+ Jnjvm* vm = JavaThread::get()->getJVM();
+ Classpath* upcalls = vm->upcalls;
+
+ dprintf("*************VMMethod_getAnnotation*************\n");
+ if (annotationClass) {
+ /* Retrieving annotationClass classname */
+ UserClass* clazz = JavaObjectClass::getClass(annotationClass)->asClass();
+ dprintf("searched annotation:%s\n\n", UTF8Buffer(clazz->name).cString());
+
+ /* Retrieving VMMethod.class attributes list */
+ UserClass* compilingClass = JavaObjectVMMethod::getClass(VMMeth);
+ JavaMethod* method = JavaObjectVMMethod::getInternalMethod(VMMeth);
+ Attribut* annotationsAtt =
+ method->lookupAttribut(Attribut::annotationsAttribut);
+ dprintf("JavaMethod:%s\n", UTF8Buffer(method->name).cString());
+
+ if (annotationsAtt) {
+ Reader reader(annotationsAtt, compilingClass->bytes);
+ AnnotationReader AR(reader, compilingClass);
+ uint16 numAnnotations = reader.readU2();
+
+ for (uint16 i = 0; i < numAnnotations; ++i) {
+ uint16 typeIndex = reader.readU2();
+ const UTF8* annoType = compilingClass->ctpInfo->UTF8At(typeIndex);
+
+ // Remove the L and ; in the name annotation type (L.....;)
+ // for the comparison.
+ if (clazz->name->equals(annoType->elements+1, annoType->size-2)) {
+ newHashMap = AR.createAnnotationMapValues();
+ break;
+
+ } else {
+ AR.readAnnotationElementValues();
+ }
+ } // end for
+
+ if (newHashMap) {
+ dprintf("Annotation creation\n");
+ res = upcalls->createAnnotation->invokeJavaObjectStatic(vm, upcalls->newAnnotationHandler, &annotationClass, &newHashMap);
+ }
+
+ }
+ } else {
+ vm->nullPointerException();
+ }
+
+ END_NATIVE_EXCEPTION
+
+ return res;
+}
+
JNIEXPORT jint JNICALL Java_java_lang_reflect_VMMethod_getModifiersInternal(
#ifdef NATIVE_JNI
JNIEnv *env,
Modified: vmkit/trunk/lib/j3/ClassLib/GNUClasspath/JavaUpcalls.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/ClassLib/GNUClasspath/JavaUpcalls.cpp?rev=180313&r1=180312&r2=180313&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/ClassLib/GNUClasspath/JavaUpcalls.cpp (original)
+++ vmkit/trunk/lib/j3/ClassLib/GNUClasspath/JavaUpcalls.cpp Thu Apr 25 11:53:18 2013
@@ -73,6 +73,13 @@ Class* Classpath::newVMConstructor;
ClassArray* Classpath::constructorArrayClass;
ClassArray* Classpath::constructorArrayAnnotation;
JavaField* Classpath::constructorSlot;
+UserClass* Classpath::newHashMap;
+JavaMethod* Classpath::initHashMap;
+JavaMethod* Classpath::putHashMap;
+JavaMethod* Classpath::createAnnotation;
+UserClass* Classpath::newAnnotationHandler;
+UserClass* Classpath::newAnnotation;
+UserClassArray* Classpath::annotationArrayClass;
JavaMethod* Classpath::initMethod;
JavaMethod* Classpath::initVMMethod;
JavaMethod* Classpath::initField;
@@ -623,6 +630,33 @@ void Classpath::initialiseClasspath(Jnjv
constructorSlot =
UPCALL_FIELD(loader, "java/lang/reflect/Constructor", "slot", "I", ACC_VIRTUAL);
+
+
+ newHashMap =
+ UPCALL_CLASS(loader, "java/util/HashMap");
+
+ initHashMap =
+ UPCALL_METHOD(loader, "java/util/HashMap", "<init>",
+ "()V", ACC_VIRTUAL);
+ putHashMap =
+ UPCALL_METHOD(loader, "java/util/HashMap", "put",
+ "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;",
+ ACC_VIRTUAL);
+
+ newAnnotationHandler =
+ UPCALL_CLASS(loader, "sun/reflect/annotation/AnnotationInvocationHandler");
+
+ createAnnotation =
+ UPCALL_METHOD(loader, "sun/reflect/annotation/AnnotationInvocationHandler",
+ "create", "(Ljava/lang/Class;Ljava/util/Map;)Ljava/lang/annotation/Annotation;",
+ ACC_STATIC);
+
+ annotationArrayClass =
+ UPCALL_ARRAY_CLASS(loader, "java/lang/annotation/Annotation", 1);
+
+ newAnnotation =
+ UPCALL_CLASS(loader, "java/lang/annotation/Annotation");
+
initMethod =
UPCALL_METHOD(loader, "java/lang/reflect/Method", "<init>",
Modified: vmkit/trunk/lib/j3/ClassLib/GNUClasspath/JavaUpcalls.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/ClassLib/GNUClasspath/JavaUpcalls.h?rev=180313&r1=180312&r2=180313&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/ClassLib/GNUClasspath/JavaUpcalls.h (original)
+++ vmkit/trunk/lib/j3/ClassLib/GNUClasspath/JavaUpcalls.h Thu Apr 25 11:53:18 2013
@@ -80,6 +80,13 @@ public:
ISOLATE_STATIC JavaMethod* getCallingClassLoader;
ISOLATE_STATIC JavaMethod* initConstructor;
ISOLATE_STATIC JavaMethod* initVMConstructor;
+ ISOLATE_STATIC UserClass* newHashMap;
+ ISOLATE_STATIC JavaMethod* initHashMap;
+ ISOLATE_STATIC JavaMethod* putHashMap;
+ ISOLATE_STATIC JavaMethod* createAnnotation;
+ ISOLATE_STATIC UserClass* newAnnotationHandler;
+ ISOLATE_STATIC UserClass* newAnnotation;
+ ISOLATE_STATIC UserClassArray* annotationArrayClass;
ISOLATE_STATIC UserClassArray* constructorArrayClass;
ISOLATE_STATIC UserClassArray* constructorArrayAnnotation;
ISOLATE_STATIC UserClass* newConstructor;
Modified: vmkit/trunk/lib/j3/ClassLib/Reflect.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/ClassLib/Reflect.inc?rev=180313&r1=180312&r2=180313&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/ClassLib/Reflect.inc (original)
+++ vmkit/trunk/lib/j3/ClassLib/Reflect.inc Thu Apr 25 11:53:18 2013
@@ -78,8 +78,17 @@ ArrayObject* JavaObjectClass::getDeclare
UserClass* realCl = cl->asClass();
JnjvmClassLoader* classLoader = cl->classLoader;
uint32 size = 0;
+ bool annot = false;
+
+ // Check if the class is an annotation.
+ const UTF8* name = upcalls->newAnnotation->name;
+ if (realCl->inheritName(name->elements, name->size))
+ annot = true;
- for (uint32 i = 0; i < realCl->nbVirtualMethods + realCl->nbStaticMethods;
+ // Ugly hack : we don't want this method to return annotationType()
+ // method for annotations. For that, we start the counter to 1 instead
+ // of 0.
+ for (uint32 i = annot?1:0 ; i < realCl->nbVirtualMethods + realCl->nbStaticMethods;
++i) {
JavaMethod* meth = &realCl->virtualMethods[i];
bool pub = isPublic(meth->access);
@@ -94,7 +103,7 @@ ArrayObject* JavaObjectClass::getDeclare
ret = (ArrayObject*)upcalls->methodArrayClass->doNew(size, vm);
sint32 index = 0;
- for (uint32 i = 0; i < realCl->nbVirtualMethods + realCl->nbStaticMethods;
+ for (uint32 i = annot?1:0; i < realCl->nbVirtualMethods + realCl->nbStaticMethods;
++i) {
JavaMethod* meth = &realCl->virtualMethods[i];
bool pub = isPublic(meth->access);
Modified: vmkit/trunk/lib/j3/VMCore/JavaClass.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/VMCore/JavaClass.cpp?rev=180313&r1=180312&r2=180313&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/VMCore/JavaClass.cpp (original)
+++ vmkit/trunk/lib/j3/VMCore/JavaClass.cpp Thu Apr 25 11:53:18 2013
@@ -18,6 +18,7 @@
#include "JavaArray.h"
#include "JavaClass.h"
#include "JavaCompiler.h"
+#include "JavaString.h"
#include "JavaConstantPool.h"
#include "JavaObject.h"
#include "JavaThread.h"
@@ -29,6 +30,15 @@
#include <cstring>
+#if 0
+using namespace vmkit;
+#define dprintf(...) do { printf("JavaClass: "); printf(__VA_ARGS__); } while(0)
+#define ddprintf(...) do { printf(__VA_ARGS__); } while(0)
+#else
+#define dprintf(...)
+#define ddprintf(...)
+#endif
+
using namespace j3;
using namespace std;
@@ -1678,6 +1688,15 @@ void AnnotationReader::readAnnotation()
AnnotationNameIndex = typeIndex;
}
+void AnnotationReader::readAnnotationElementValues() {
+ uint16 numPairs = reader.readU2();
+
+ for (uint16 j = 0; j < numPairs; ++j) {
+ reader.readU2();
+ readElementValue();
+ }
+}
+
void AnnotationReader::readElementValue() {
uint8 tag = reader.readU1();
if ((tag == 'B') || (tag == 'C') || (tag == 'D') || (tag == 'F') ||
@@ -1699,6 +1718,135 @@ void AnnotationReader::readElementValue(
}
}
+JavaObject* AnnotationReader::createElementValue() {
+ uint8 tag = reader.readU1();
+ JavaObject* res = 0;
+ JavaObject* tmp = 0;
+ llvm_gcroot(res, 0);
+ llvm_gcroot(tmp, 0);
+
+ Jnjvm* vm = JavaThread::get()->getJVM();
+ Classpath* upcalls = JavaThread::get()->getJVM()->upcalls;
+ ddprintf("value:");
+
+ if (tag == 'B') {
+ uint32 val = cl->ctpInfo->IntegerAt(reader.readU2());
+ ddprintf("B=%d", val);
+ res = upcalls->boolClass->doNew(vm);
+ upcalls->boolValue->setInstanceInt8Field(res, val);
+
+ } else if (tag == 'C') {
+ uint32 val = cl->ctpInfo->IntegerAt(reader.readU2());
+ ddprintf("C=%c", val);
+ res = upcalls->intClass->doNew(vm);
+ upcalls->intValue->setInstanceInt32Field(res, val);
+
+ } else if (tag == 'D') {
+ double val = cl->ctpInfo->DoubleAt(reader.readU2());
+ ddprintf("D=%f", val);
+ res = upcalls->doubleClass->doNew(vm);
+ upcalls->doubleValue->setInstanceDoubleField(res, val);
+
+ } else if (tag == 'F') {
+ float val = cl->ctpInfo->FloatAt(reader.readU2());
+ ddprintf("F=%f", val);
+ res = upcalls->floatClass->doNew(vm);
+ upcalls->floatValue->setInstanceFloatField(res, val);
+
+ } else if (tag == 'J') {
+ sint64 val = cl->ctpInfo->LongAt(reader.readU2());
+ ddprintf("J=%lld", val);
+ res = upcalls->longClass->doNew(vm);
+ upcalls->longValue->setInstanceLongField(res, val);
+
+ } else if (tag == 'S') {
+ uint32 val = cl->ctpInfo->IntegerAt(reader.readU2());
+ ddprintf("S=%d", val);
+ res = upcalls->shortClass->doNew(vm);
+ upcalls->shortValue->setInstanceInt16Field(res, val);
+
+ } else if (tag == 'I') {
+ uint32 val = cl->ctpInfo->IntegerAt(reader.readU2());
+ ddprintf("I=%d", val);
+ res = upcalls->intClass->doNew(vm);
+ upcalls->intValue->setInstanceInt32Field(res, val);
+
+ } else if (tag == 'Z') {
+ bool val = cl->ctpInfo->IntegerAt(reader.readU2());
+ ddprintf("Z=%d", val);
+ res = upcalls->boolClass->doNew(vm);
+ upcalls->boolValue->setInstanceInt8Field(res, val);
+
+ } else if (tag == 's') {
+ const UTF8* s = cl->ctpInfo->UTF8At(reader.readU2());
+ ddprintf("s=%s", PrintBuffer(s).cString());
+ res = JavaString::internalToJava(s, JavaThread::get()->getJVM());
+
+ } else if (tag == 'e') {
+ // Element_value Enumeration not implemented
+ const UTF8* n = cl->ctpInfo->UTF8At(reader.readU2());
+ ddprintf("%s", PrintBuffer(n).cString());
+ const UTF8* m = cl->ctpInfo->UTF8At(reader.readU2());
+ ddprintf("%s", PrintBuffer(m).cString());
+ fprintf(stderr, "Annotation not supported for %c type\n", tag);
+ abort();
+
+ } else if (tag == 'c') {
+ ddprintf("class=");
+ const UTF8* m = cl->ctpInfo->UTF8At(reader.readU2());
+ ddprintf("%s", PrintBuffer(m).cString());
+
+ } else if (tag == '[') {
+ uint16 numValues = reader.readU2();
+ UserClassArray* array = upcalls->annotationArrayClass;
+ res = array->doNew(numValues, vm);
+
+ ddprintf("Tableau de %d elements\n", numValues);
+ for (uint32 i = 0; i < numValues; ++i) {
+ tmp = createElementValue();
+ ArrayObject::setElement((ArrayObject *)res, tmp, i);
+ }
+ ddprintf("Fin du Tableau");
+ } else {
+ // Element_value Annotation not implemented
+ fprintf(stderr, "Annotation not supported for %c type\n", tag);
+ abort();
+ }
+ ddprintf("\n");
+
+ return res;
+}
+
+JavaObject* AnnotationReader::createAnnotationMapValues() {
+ std::pair<JavaObject*, JavaObject*> pair;
+ JavaObject* tmp = 0;
+ JavaString* str = 0;
+ JavaObject* newHashMap = 0;
+ llvm_gcroot(tmp, 0);
+ llvm_gcroot(str, 0);
+ llvm_gcroot(newHashMap, 0);
+
+ Jnjvm * vm = JavaThread::get()->getJVM();
+ Classpath* upcalls = vm->upcalls;
+ UserClass* HashMap = upcalls->newHashMap;
+ newHashMap = HashMap->doNew(vm);
+ upcalls->initHashMap->invokeIntSpecial(vm, HashMap, newHashMap);
+
+ uint16 numPairs = reader.readU2();
+ dprintf("numPairs:%d\n", numPairs);
+ for (uint16 j = 0; j < numPairs; ++j) {
+ uint16 nameIndex = reader.readU2();
+ const UTF8* key = cl->ctpInfo->UTF8At(nameIndex);
+ dprintf("keyAn:%s|", PrintBuffer(key).cString());
+
+ tmp = createElementValue();
+ str = JavaString::internalToJava(key, JavaThread::get()->getJVM());
+ upcalls->putHashMap->invokeJavaObjectVirtual(vm, HashMap, newHashMap, &str, &tmp);
+ }
+
+ return newHashMap;
+}
+
uint16 JavaMethod::lookupLineNumber(vmkit::FrameInfo* info) {
JavaAttribute* codeAtt = lookupAttribute(JavaAttribute::codeAttribute);
if (codeAtt == NULL) return 0;
Modified: vmkit/trunk/lib/j3/VMCore/JavaClass.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/VMCore/JavaClass.h?rev=180313&r1=180312&r2=180313&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/VMCore/JavaClass.h (original)
+++ vmkit/trunk/lib/j3/VMCore/JavaClass.h Thu Apr 25 11:53:18 2013
@@ -71,6 +71,19 @@ public:
AnnotationNameIndex(0) {}
void readAnnotation();
void readElementValue();
+
+
+ void readAnnotationElementValues();
+
+ // createAnnotation - search for a specific annotation in annotation
+ // attributes.
+ //
+ JavaObject* createAnnotationMapValues();
+
+ // createElementValue - create the Java type associated withe the value
+ // of the current annotation key.
+ //
+ JavaObject* createElementValue();
};
/// Attribute - This class represents JVM attributes to Java class, methods and
Modified: vmkit/trunk/tests/AnnotationClassTest.java
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/tests/AnnotationClassTest.java?rev=180313&r1=180312&r2=180313&view=diff
==============================================================================
--- vmkit/trunk/tests/AnnotationClassTest.java (original)
+++ vmkit/trunk/tests/AnnotationClassTest.java Thu Apr 25 11:53:18 2013
@@ -1,6 +1,7 @@
import java.lang.Deprecated;
import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
+import java.lang.reflect.Method;
/**
* Created with IntelliJ IDEA.
@@ -10,23 +11,34 @@ import java.lang.reflect.Field;
* To change this template use File | Settings | File Templates.
*/
public class AnnotationClassTest {
+
static class Sample {
@Deprecated
+ @MyAnnotation (property=5)
public int x;
+
+ @MyAnnotation (property=5)
+ public int y() {
+ return x*x;
+ }
}
public static void main(String[] args) throws Exception {
Field f = Sample.class.getField("x");
+ Method m = Sample.class.getMethod("y");
Sample sample = new Sample();
sample.x = 14;
- Annotation xx = f.getAnnotation(Deprecated.class);
- //Annotation[] a = f.getDeclaredAnnotations();
+ MyAnnotation xx = (MyAnnotation)f.getAnnotation(MyAnnotation.class);
+ MyAnnotation yy = (MyAnnotation)f.getAnnotation(MyAnnotation.class);
check(f.getInt(sample) == 14);
f.setInt(sample, 17);
check(f.getInt(sample) == 17);
- check(xx.annotationType().getCanonicalName().equals("java.lang.Deprecated"));
+ check(xx != null);
+ check(yy != null);
+ //int s = yy.property();
+ //check(s == 5);
}
private static void check(boolean b) throws Exception {
More information about the vmkit-commits
mailing list