Start implementing JNI.
This patch replaces our JniEnvironment class with the regular JNIEnv.
This patch also adds support for .jar, .zip, and .apk files in the
boot classpath.
There's also an attempt at implementing JNIEnv::FindClass.
I've also fixed a few scoped_ptr/scoped_array bugs (this kind of thing
being the reason we use UniquePtr in libcore), and removed some
unnecessary .
The 'tools/art' script makes it easier to play with aexec on the command-line.
Change-Id: Ic4f704c12e0071f17e95b6e182fdab9370ead9b0
diff --git a/src/class_linker.cc b/src/class_linker.cc
index 2aed455..ac11578 100644
--- a/src/class_linker.cc
+++ b/src/class_linker.cc
@@ -484,7 +484,7 @@
dst->name_ = ResolveString(klass, method_id.name_idx_, dex_file);
{
int32_t utf16_length;
- scoped_ptr<char> utf8(dex_file.CreateMethodDescriptor(method_id.proto_idx_,
+ scoped_array<char> utf8(dex_file.CreateMethodDescriptor(method_id.proto_idx_,
&utf16_length));
dst->descriptor_ = String::AllocFromModifiedUtf8(utf16_length, utf8.get());
}
diff --git a/src/common_test.h b/src/common_test.h
index f1c952c..2ae4159 100644
--- a/src/common_test.h
+++ b/src/common_test.h
@@ -342,7 +342,7 @@
DexFile* GetLibCoreDex() {
std::string libcore_dex_file_name = GetLibCoreDexFileName();
- return DexFile::OpenZip(libcore_dex_file_name.c_str());
+ return DexFile::OpenZip(libcore_dex_file_name);
}
void UseLibCoreDex() {
diff --git a/src/dex_file.cc b/src/dex_file.cc
index b3bb7d2..3cddd7f 100644
--- a/src/dex_file.cc
+++ b/src/dex_file.cc
@@ -151,6 +151,7 @@
adjacent_dex_filename.end(),
".dex");
// Example adjacent_dex_filename = dir/foo.dex
+ // TODO: stat first, so we don't report a bogus error.
DexFile* adjacent_dex_file = DexFile::OpenFile(adjacent_dex_filename);
if (adjacent_dex_file != NULL) {
// We don't verify anything in this case, because we aren't in
@@ -204,11 +205,18 @@
// lock. If somebody else is working on it, we'll block here until
// they complete. Because we're waiting on an external resource,
// we go into native mode.
+ // Note that current_thread can be NULL if we're parsing the bootclasspath
+ // during JNI_CreateJavaVM.
Thread* current_thread = Thread::Current();
- Thread::State old = current_thread->GetState();
- current_thread->SetState(Thread::kNative);
+ Thread::State old;
+ if (current_thread != NULL) {
+ old = current_thread->GetState();
+ current_thread->SetState(Thread::kNative);
+ }
scoped_ptr<LockedFd> fd(LockedFd::CreateAndLock(cache_path_tmp, 0644));
- current_thread->SetState(old);
+ if (current_thread != NULL) {
+ current_thread->SetState(old);
+ }
if (fd == NULL) {
return NULL;
}
diff --git a/src/intern_table.cc b/src/intern_table.cc
index 31749fd..3a0dff8 100644
--- a/src/intern_table.cc
+++ b/src/intern_table.cc
@@ -19,7 +19,7 @@
}
String* InternTable::Intern(int32_t utf16_length, const char* utf8_data_in) {
- scoped_ptr<uint16_t> utf16_data_out(new uint16_t[utf16_length]);
+ scoped_array<uint16_t> utf16_data_out(new uint16_t[utf16_length]);
String::ConvertModifiedUtf8ToUtf16(utf16_data_out.get(), utf8_data_in);
int32_t hash_code = String::ComputeUtf16Hash(utf16_data_out.get(), utf16_length);
{
diff --git a/src/jni_compiler.cc b/src/jni_compiler.cc
index 436d4d8..b7d8f5d 100644
--- a/src/jni_compiler.cc
+++ b/src/jni_compiler.cc
@@ -134,9 +134,11 @@
FrameOffset out_off = jni_conv.CurrentParamStackOffset();
jni_asm->StoreRawPtr(out_off, jni_env_register);
}
- // Call JNIEnv*->MonitorEnter(JNIEnv*, object)
- jni_asm->Call(jni_env_register, JniEnvironment::MonitorEnterOffset(),
+ // Call JNIEnvExt::MonitorEnterHelper(JNIEnv*, object)
+ static Offset monitor_enter(OFFSETOF_MEMBER(JNIEnvExt, MonitorEnterHelper));
+ jni_asm->Call(jni_env_register, monitor_enter,
jni_conv.InterproceduralScratchRegister());
+ jni_asm->ExceptionPoll(jni_conv.InterproceduralScratchRegister());
}
// 8. Iterate over arguments placing values from managed calling convention in
@@ -232,9 +234,11 @@
FrameOffset out_off = jni_conv.CurrentParamStackOffset();
jni_asm->StoreRawPtr(out_off, jni_env_register);
}
- // Call JNIEnv*->MonitorExit(JNIEnv*, object)
- jni_asm->Call(jni_env_register, JniEnvironment::MonitorExitOffset(),
+ // Call JNIEnvExt::MonitorExitHelper(JNIEnv*, object)
+ static Offset monitor_exit(OFFSETOF_MEMBER(JNIEnvExt, MonitorExitHelper));
+ jni_asm->Call(jni_env_register, monitor_exit,
jni_conv.InterproceduralScratchRegister());
+ jni_asm->ExceptionPoll(jni_conv.InterproceduralScratchRegister());
// Reload return value
jni_asm->Load(jni_conv.ReturnRegister(), return_save_location,
jni_conv.SizeOfReturnValue());
diff --git a/src/jni_internal.cc b/src/jni_internal.cc
index a495d65..839ad0e 100644
--- a/src/jni_internal.cc
+++ b/src/jni_internal.cc
@@ -5,6 +5,7 @@
#include <vector>
#include <utility>
+#include "class_linker.h"
#include "jni.h"
#include "logging.h"
#include "runtime.h"
@@ -14,1673 +15,1219 @@
namespace art {
-static void JniMonitorEnter(JniEnvironment*, jobject) {
- LOG(WARNING) << "Unimplemented: JNI Monitor Enter";
-}
-
-static void JniMonitorExit(JniEnvironment*, jobject) {
- LOG(WARNING) << "Unimplemented: JNI Monitor Exit";
-}
-
-JniEnvironment::JniEnvironment() {
- monitor_enter_ = &JniMonitorEnter;
- monitor_exit_ = &JniMonitorExit;
-}
-
-// JNI Native interface.
-
-jint JniNativeInterface::GetVersion(JNIEnv* env) {
+jint GetVersion(JNIEnv* env) {
return JNI_VERSION_1_6;
}
-jclass JniNativeInterface::DefineClass(JNIEnv *env,
- const char *name,
- jobject loader,
- const jbyte *buf,
- jsize len) {
+jclass DefineClass(JNIEnv *env, const char *name,
+ jobject loader, const jbyte *buf, jsize len) {
LOG(FATAL) << "Unimplemented";
return NULL;
}
-jclass JniNativeInterface::FindClass(JNIEnv *env, const char *name) {
+jclass FindClass(JNIEnv* env, const char* name) {
+ ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
+ // TODO: need to get the appropriate ClassLoader.
+ Class* c = class_linker->FindClass(name, NULL);
+ // TODO: local reference.
+ return reinterpret_cast<jclass>(c);
+}
+
+jmethodID FromReflectedMethod(JNIEnv* env, jobject method) {
LOG(FATAL) << "Unimplemented";
return NULL;
}
-jmethodID JniNativeInterface::FromReflectedMethod(JNIEnv* env, jobject method) {
+jfieldID FromReflectedField(JNIEnv* env, jobject field) {
LOG(FATAL) << "Unimplemented";
return NULL;
}
-jfieldID JniNativeInterface::FromReflectedField(JNIEnv* env, jobject field) {
+jobject ToReflectedMethod(JNIEnv* env, jclass cls,
+ jmethodID methodID, jboolean isStatic) {
LOG(FATAL) << "Unimplemented";
return NULL;
}
-jobject JniNativeInterface::ToReflectedMethod(JNIEnv* env,
- jclass cls,
- jmethodID methodID,
- jboolean isStatic) {
+jclass GetSuperclass(JNIEnv* env, jclass sub) {
LOG(FATAL) << "Unimplemented";
return NULL;
}
-jclass JniNativeInterface::GetSuperclass(JNIEnv* env, jclass sub) {
- LOG(FATAL) << "Unimplemented";
- return NULL;
-}
-
-jboolean JniNativeInterface::IsAssignableFrom(JNIEnv* env,
- jclass sub,
- jclass sup) {
+jboolean IsAssignableFrom(JNIEnv* env, jclass sub, jclass sup) {
LOG(FATAL) << "Unimplemented";
return JNI_FALSE;
}
-jobject JniNativeInterface::ToReflectedField(JNIEnv* env,
- jclass cls,
- jfieldID fieldID,
- jboolean isStatic) {
+jobject ToReflectedField(JNIEnv* env, jclass cls,
+ jfieldID fieldID, jboolean isStatic) {
LOG(FATAL) << "Unimplemented";
return NULL;
}
-jint JniNativeInterface::Throw(JNIEnv* env, jthrowable obj) {
+jint Throw(JNIEnv* env, jthrowable obj) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jint JniNativeInterface::ThrowNew(JNIEnv* env, jclass clazz, const char* msg) {
+jint ThrowNew(JNIEnv* env, jclass clazz, const char* msg) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jthrowable JniNativeInterface::ExceptionOccurred(JNIEnv* env) {
+jthrowable ExceptionOccurred(JNIEnv* env) {
LOG(FATAL) << "Unimplemented";
return NULL;
}
-void JniNativeInterface::ExceptionDescribe(JNIEnv* env) {
+void ExceptionDescribe(JNIEnv* env) {
LOG(FATAL) << "Unimplemented";
}
-void JniNativeInterface::ExceptionClear(JNIEnv* env) {
+void ExceptionClear(JNIEnv* env) {
LOG(FATAL) << "Unimplemented";
}
-void JniNativeInterface::FatalError(JNIEnv* env, const char* msg) {
+void FatalError(JNIEnv* env, const char* msg) {
LOG(FATAL) << "Unimplemented";
}
-jint JniNativeInterface::PushLocalFrame(JNIEnv* env, jint cap) {
+jint PushLocalFrame(JNIEnv* env, jint cap) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jobject JniNativeInterface::PopLocalFrame(JNIEnv* env, jobject res) {
+jobject PopLocalFrame(JNIEnv* env, jobject res) {
LOG(FATAL) << "Unimplemented";
return NULL;
}
-jobject JniNativeInterface::NewGlobalRef(JNIEnv* env, jobject lobj) {
+jobject NewGlobalRef(JNIEnv* env, jobject lobj) {
LOG(FATAL) << "Unimplemented";
return NULL;
}
-void JniNativeInterface::DeleteGlobalRef(JNIEnv* env, jobject gref) {
+void DeleteGlobalRef(JNIEnv* env, jobject gref) {
LOG(FATAL) << "Unimplemented";
}
-void JniNativeInterface::DeleteLocalRef(JNIEnv* env, jobject obj) {
+void DeleteLocalRef(JNIEnv* env, jobject obj) {
LOG(FATAL) << "Unimplemented";
}
-jboolean JniNativeInterface::IsSameObject(JNIEnv* env,
- jobject obj1,
- jobject obj2) {
+jboolean IsSameObject(JNIEnv* env, jobject obj1, jobject obj2) {
LOG(FATAL) << "Unimplemented";
return JNI_FALSE;
}
-jobject JniNativeInterface::NewLocalRef(JNIEnv* env, jobject ref) {
+jobject NewLocalRef(JNIEnv* env, jobject ref) {
LOG(FATAL) << "Unimplemented";
return NULL;
}
-jint JniNativeInterface::EnsureLocalCapacity(JNIEnv* env, jint) {
+jint EnsureLocalCapacity(JNIEnv* env, jint) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jobject JniNativeInterface::AllocObject(JNIEnv* env, jclass clazz) {
+jobject AllocObject(JNIEnv* env, jclass clazz) {
LOG(FATAL) << "Unimplemented";
return NULL;
}
-jobject JniNativeInterface::NewObject(JNIEnv* env,
- jclass clazz,
- jmethodID methodID,
- ...) {
+jobject NewObject(JNIEnv* env, jclass clazz, jmethodID methodID, ...) {
LOG(FATAL) << "Unimplemented";
return NULL;
}
-jobject JniNativeInterface::NewObjectV(JNIEnv* env,
- jclass clazz,
- jmethodID methodID,
- va_list args) {
+jobject NewObjectV(JNIEnv* env,
+ jclass clazz, jmethodID methodID, va_list args) {
LOG(FATAL) << "Unimplemented";
return NULL;
}
-jobject JniNativeInterface::NewObjectA(JNIEnv* env,
- jclass clazz,
- jmethodID methodID,
- jvalue* args) {
+jobject NewObjectA(JNIEnv* env,
+ jclass clazz, jmethodID methodID, jvalue* args) {
LOG(FATAL) << "Unimplemented";
return NULL;
}
-jclass JniNativeInterface::GetObjectClass(JNIEnv* env, jobject obj) {
+jclass GetObjectClass(JNIEnv* env, jobject obj) {
LOG(FATAL) << "Unimplemented";
return NULL;
}
-jboolean JniNativeInterface::IsInstanceOf(JNIEnv* env,
- jobject obj,
- jclass clazz) {
+jboolean IsInstanceOf(JNIEnv* env, jobject obj, jclass clazz) {
LOG(FATAL) << "Unimplemented";
return JNI_FALSE;
}
-jmethodID JniNativeInterface::GetMethodID(JNIEnv* env,
- jclass clazz,
- const char* name,
- const char* sig) {
+jmethodID GetMethodID(JNIEnv* env,
+ jclass clazz, const char* name, const char* sig) {
LOG(FATAL) << "Unimplemented";
return NULL;
}
-jobject JniNativeInterface::CallObjectMethod(JNIEnv* env,
- jobject obj,
- jmethodID methodID,
- ...) {
+jobject CallObjectMethod(JNIEnv* env, jobject obj, jmethodID methodID, ...) {
LOG(FATAL) << "Unimplemented";
return NULL;
}
-jobject JniNativeInterface::CallObjectMethodV(JNIEnv* env,
- jobject obj,
- jmethodID methodID,
- va_list args) {
+jobject CallObjectMethodV(JNIEnv* env,
+ jobject obj, jmethodID methodID, va_list args) {
LOG(FATAL) << "Unimplemented";
return NULL;
}
-jobject JniNativeInterface::CallObjectMethodA(JNIEnv* env,
- jobject obj,
- jmethodID methodID,
- jvalue* args) {
+jobject CallObjectMethodA(JNIEnv* env,
+ jobject obj, jmethodID methodID, jvalue* args) {
LOG(FATAL) << "Unimplemented";
return NULL;
}
-jboolean JniNativeInterface::CallBooleanMethod(JNIEnv* env,
- jobject obj,
- jmethodID methodID,
- ...) {
+jboolean CallBooleanMethod(JNIEnv* env, jobject obj, jmethodID methodID, ...) {
LOG(FATAL) << "Unimplemented";
return JNI_FALSE;
}
-jboolean JniNativeInterface::CallBooleanMethodV(JNIEnv* env,
- jobject obj,
- jmethodID methodID,
- va_list args) {
+jboolean CallBooleanMethodV(JNIEnv* env,
+ jobject obj, jmethodID methodID, va_list args) {
LOG(FATAL) << "Unimplemented";
return JNI_FALSE;
}
-jboolean JniNativeInterface::CallBooleanMethodA(JNIEnv* env,
- jobject obj,
- jmethodID methodID,
- jvalue* args) {
+jboolean CallBooleanMethodA(JNIEnv* env,
+ jobject obj, jmethodID methodID, jvalue* args) {
LOG(FATAL) << "Unimplemented";
return JNI_FALSE;
}
-jbyte JniNativeInterface::CallByteMethod(JNIEnv* env,
- jobject obj,
- jmethodID methodID,
- ...) {
+jbyte CallByteMethod(JNIEnv* env, jobject obj, jmethodID methodID, ...) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jbyte JniNativeInterface::CallByteMethodV(JNIEnv* env,
- jobject obj,
- jmethodID methodID,
- va_list args) {
+jbyte CallByteMethodV(JNIEnv* env,
+ jobject obj, jmethodID methodID, va_list args) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jbyte JniNativeInterface::CallByteMethodA(JNIEnv* env,
- jobject obj,
- jmethodID methodID,
- jvalue* args) {
+jbyte CallByteMethodA(JNIEnv* env,
+ jobject obj, jmethodID methodID, jvalue* args) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jchar JniNativeInterface::CallCharMethod(JNIEnv* env,
- jobject obj,
- jmethodID methodID, ...) {
+jchar CallCharMethod(JNIEnv* env, jobject obj, jmethodID methodID, ...) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jchar JniNativeInterface::CallCharMethodV(JNIEnv* env,
- jobject obj,
- jmethodID methodID,
- va_list args) {
+jchar CallCharMethodV(JNIEnv* env,
+ jobject obj, jmethodID methodID, va_list args) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jchar JniNativeInterface::CallCharMethodA(JNIEnv* env,
- jobject obj,
- jmethodID methodID,
- jvalue* args) {
+jchar CallCharMethodA(JNIEnv* env,
+ jobject obj, jmethodID methodID, jvalue* args) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jshort JniNativeInterface::CallShortMethod(JNIEnv* env,
- jobject obj,
- jmethodID methodID,
- ...) {
+jshort CallShortMethod(JNIEnv* env, jobject obj, jmethodID methodID, ...) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jshort JniNativeInterface::CallShortMethodV(JNIEnv* env,
- jobject obj,
- jmethodID methodID,
- va_list args) {
+jshort CallShortMethodV(JNIEnv* env,
+ jobject obj, jmethodID methodID, va_list args) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jshort JniNativeInterface::CallShortMethodA(JNIEnv* env,
- jobject obj,
- jmethodID methodID,
- jvalue* args) {
+jshort CallShortMethodA(JNIEnv* env,
+ jobject obj, jmethodID methodID, jvalue* args) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jint JniNativeInterface::CallIntMethod(JNIEnv* env,
- jobject obj,
- jmethodID methodID,
- ...) {
+jint CallIntMethod(JNIEnv* env, jobject obj, jmethodID methodID, ...) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jint JniNativeInterface::CallIntMethodV(JNIEnv* env,
- jobject obj,
- jmethodID methodID,
- va_list args) {
+jint CallIntMethodV(JNIEnv* env,
+ jobject obj, jmethodID methodID, va_list args) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jint JniNativeInterface::CallIntMethodA(JNIEnv* env,
- jobject obj,
- jmethodID methodID,
- jvalue* args) {
+jint CallIntMethodA(JNIEnv* env,
+ jobject obj, jmethodID methodID, jvalue* args) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jlong JniNativeInterface::CallLongMethod(JNIEnv* env,
- jobject obj,
- jmethodID methodID,
- ...) {
+jlong CallLongMethod(JNIEnv* env, jobject obj, jmethodID methodID, ...) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jlong JniNativeInterface::CallLongMethodV(JNIEnv* env,
- jobject obj,
- jmethodID methodID,
- va_list args) {
+jlong CallLongMethodV(JNIEnv* env,
+ jobject obj, jmethodID methodID, va_list args) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jlong JniNativeInterface::CallLongMethodA(JNIEnv* env,
- jobject obj,
- jmethodID methodID,
- jvalue* args) {
+jlong CallLongMethodA(JNIEnv* env,
+ jobject obj, jmethodID methodID, jvalue* args) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jfloat JniNativeInterface::CallFloatMethod(JNIEnv* env,
- jobject obj,
- jmethodID methodID,
- ...) {
+jfloat CallFloatMethod(JNIEnv* env, jobject obj, jmethodID methodID, ...) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jfloat JniNativeInterface::CallFloatMethodV(JNIEnv* env,
- jobject obj,
- jmethodID methodID,
- va_list args) {
+jfloat CallFloatMethodV(JNIEnv* env,
+ jobject obj, jmethodID methodID, va_list args) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jfloat JniNativeInterface::CallFloatMethodA(JNIEnv* env,
- jobject obj,
- jmethodID methodID,
- jvalue* args) {
+jfloat CallFloatMethodA(JNIEnv* env,
+ jobject obj, jmethodID methodID, jvalue* args) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jdouble JniNativeInterface::CallDoubleMethod(JNIEnv* env,
- jobject obj,
- jmethodID methodID,
- ...) {
+jdouble CallDoubleMethod(JNIEnv* env, jobject obj, jmethodID methodID, ...) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jdouble JniNativeInterface::CallDoubleMethodV(JNIEnv* env,
- jobject obj,
- jmethodID methodID,
- va_list args) {
+jdouble CallDoubleMethodV(JNIEnv* env,
+ jobject obj, jmethodID methodID, va_list args) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jdouble JniNativeInterface::CallDoubleMethodA(JNIEnv* env,
- jobject obj,
- jmethodID methodID,
- jvalue* args) {
+jdouble CallDoubleMethodA(JNIEnv* env,
+ jobject obj, jmethodID methodID, jvalue* args) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-void JniNativeInterface::CallVoidMethod(JNIEnv* env,
- jobject obj,
- jmethodID methodID,
- ...) {
+void CallVoidMethod(JNIEnv* env, jobject obj, jmethodID methodID, ...) {
LOG(FATAL) << "Unimplemented";
}
-void JniNativeInterface::CallVoidMethodV(JNIEnv* env,
- jobject obj,
- jmethodID methodID,
- va_list args) {
+void CallVoidMethodV(JNIEnv* env, jobject obj,
+ jmethodID methodID, va_list args) {
LOG(FATAL) << "Unimplemented";
}
-void JniNativeInterface::CallVoidMethodA(JNIEnv* env,
- jobject obj,
- jmethodID methodID,
- jvalue* args) {
+void CallVoidMethodA(JNIEnv* env, jobject obj,
+ jmethodID methodID, jvalue* args) {
LOG(FATAL) << "Unimplemented";
}
-jobject JniNativeInterface::CallNonvirtualObjectMethod(JNIEnv* env,
- jobject obj,
- jclass clazz,
- jmethodID methodID,
- ...) {
+jobject CallNonvirtualObjectMethod(JNIEnv* env,
+ jobject obj, jclass clazz, jmethodID methodID, ...) {
LOG(FATAL) << "Unimplemented";
return NULL;
}
-jobject JniNativeInterface::CallNonvirtualObjectMethodV(JNIEnv* env,
- jobject obj,
- jclass clazz,
- jmethodID methodID,
- va_list args) {
+jobject CallNonvirtualObjectMethodV(JNIEnv* env,
+ jobject obj, jclass clazz, jmethodID methodID, va_list args) {
LOG(FATAL) << "Unimplemented";
return NULL;
}
-jobject JniNativeInterface::CallNonvirtualObjectMethodA(JNIEnv* env,
- jobject obj,
- jclass clazz,
- jmethodID methodID,
- jvalue* args) {
+jobject CallNonvirtualObjectMethodA(JNIEnv* env,
+ jobject obj, jclass clazz, jmethodID methodID, jvalue* args) {
LOG(FATAL) << "Unimplemented";
return NULL;
}
-jboolean JniNativeInterface::CallNonvirtualBooleanMethod(JNIEnv* env,
- jobject obj,
- jclass clazz,
- jmethodID methodID,
- ...) {
+jboolean CallNonvirtualBooleanMethod(JNIEnv* env,
+ jobject obj, jclass clazz, jmethodID methodID, ...) {
LOG(FATAL) << "Unimplemented";
return JNI_FALSE;
}
-jboolean JniNativeInterface::CallNonvirtualBooleanMethodV(JNIEnv* env,
- jobject obj,
- jclass clazz,
- jmethodID methodID,
- va_list args) {
+jboolean CallNonvirtualBooleanMethodV(JNIEnv* env,
+ jobject obj, jclass clazz, jmethodID methodID, va_list args) {
LOG(FATAL) << "Unimplemented";
return JNI_FALSE;
}
-jboolean JniNativeInterface::CallNonvirtualBooleanMethodA(JNIEnv* env,
- jobject obj,
- jclass clazz,
- jmethodID methodID,
- jvalue* args) {
+jboolean CallNonvirtualBooleanMethodA(JNIEnv* env,
+ jobject obj, jclass clazz, jmethodID methodID, jvalue* args) {
LOG(FATAL) << "Unimplemented";
return JNI_FALSE;
}
-jbyte JniNativeInterface::CallNonvirtualByteMethod(JNIEnv* env,
- jobject obj,
- jclass clazz,
- jmethodID methodID,
- ...) {
+jbyte CallNonvirtualByteMethod(JNIEnv* env,
+ jobject obj, jclass clazz, jmethodID methodID, ...) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jbyte JniNativeInterface::CallNonvirtualByteMethodV(JNIEnv* env,
- jobject obj,
- jclass clazz,
- jmethodID methodID,
- va_list args) {
+jbyte CallNonvirtualByteMethodV(JNIEnv* env,
+ jobject obj, jclass clazz, jmethodID methodID, va_list args) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jbyte JniNativeInterface::CallNonvirtualByteMethodA(JNIEnv* env,
- jobject obj,
- jclass clazz,
- jmethodID methodID,
- jvalue* args) {
+jbyte CallNonvirtualByteMethodA(JNIEnv* env,
+ jobject obj, jclass clazz, jmethodID methodID, jvalue* args) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jchar JniNativeInterface::CallNonvirtualCharMethod(JNIEnv* env,
- jobject obj,
- jclass clazz,
- jmethodID methodID,
- ...) {
+jchar CallNonvirtualCharMethod(JNIEnv* env,
+ jobject obj, jclass clazz, jmethodID methodID, ...) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jchar JniNativeInterface::CallNonvirtualCharMethodV(JNIEnv* env,
- jobject obj,
- jclass clazz,
- jmethodID methodID,
- va_list args) {
+jchar CallNonvirtualCharMethodV(JNIEnv* env,
+ jobject obj, jclass clazz, jmethodID methodID, va_list args) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jchar JniNativeInterface::CallNonvirtualCharMethodA(JNIEnv* env,
- jobject obj,
- jclass clazz,
- jmethodID methodID,
- jvalue* args) {
+jchar CallNonvirtualCharMethodA(JNIEnv* env,
+ jobject obj, jclass clazz, jmethodID methodID, jvalue* args) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jshort JniNativeInterface::CallNonvirtualShortMethod(JNIEnv* env,
- jobject obj,
- jclass clazz,
- jmethodID methodID,
- ...) {
+jshort CallNonvirtualShortMethod(JNIEnv* env,
+ jobject obj, jclass clazz, jmethodID methodID, ...) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jshort JniNativeInterface::CallNonvirtualShortMethodV(JNIEnv* env,
- jobject obj,
- jclass clazz,
- jmethodID methodID,
- va_list args) {
+jshort CallNonvirtualShortMethodV(JNIEnv* env,
+ jobject obj, jclass clazz, jmethodID methodID, va_list args) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jshort JniNativeInterface::CallNonvirtualShortMethodA(JNIEnv* env,
- jobject obj,
- jclass clazz,
- jmethodID methodID,
- jvalue* args) {
+jshort CallNonvirtualShortMethodA(JNIEnv* env,
+ jobject obj, jclass clazz, jmethodID methodID, jvalue* args) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jint JniNativeInterface::CallNonvirtualIntMethod(JNIEnv* env,
- jobject obj,
- jclass clazz,
- jmethodID methodID,
- ...) {
+jint CallNonvirtualIntMethod(JNIEnv* env,
+ jobject obj, jclass clazz, jmethodID methodID, ...) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jint JniNativeInterface::CallNonvirtualIntMethodV(JNIEnv* env,
- jobject obj,
- jclass clazz,
- jmethodID methodID,
- va_list args) {
+jint CallNonvirtualIntMethodV(JNIEnv* env,
+ jobject obj, jclass clazz, jmethodID methodID, va_list args) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jint JniNativeInterface::CallNonvirtualIntMethodA(JNIEnv* env,
- jobject obj,
- jclass clazz,
- jmethodID methodID,
- jvalue* args) {
+jint CallNonvirtualIntMethodA(JNIEnv* env,
+ jobject obj, jclass clazz, jmethodID methodID, jvalue* args) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jlong JniNativeInterface::CallNonvirtualLongMethod(JNIEnv* env,
- jobject obj,
- jclass clazz,
- jmethodID methodID,
- ...) {
+jlong CallNonvirtualLongMethod(JNIEnv* env,
+ jobject obj, jclass clazz, jmethodID methodID, ...) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jlong JniNativeInterface::CallNonvirtualLongMethodV(JNIEnv* env,
- jobject obj,
- jclass clazz,
- jmethodID methodID,
- va_list args) {
+jlong CallNonvirtualLongMethodV(JNIEnv* env,
+ jobject obj, jclass clazz, jmethodID methodID, va_list args) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jlong JniNativeInterface::CallNonvirtualLongMethodA(JNIEnv* env,
- jobject obj,
- jclass clazz,
- jmethodID methodID,
- jvalue* args) {
+jlong CallNonvirtualLongMethodA(JNIEnv* env,
+ jobject obj, jclass clazz, jmethodID methodID, jvalue* args) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jfloat JniNativeInterface::CallNonvirtualFloatMethod(JNIEnv* env,
- jobject obj,
- jclass clazz,
- jmethodID methodID,
- ...) {
+jfloat CallNonvirtualFloatMethod(JNIEnv* env,
+ jobject obj, jclass clazz, jmethodID methodID, ...) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jfloat JniNativeInterface::CallNonvirtualFloatMethodV(JNIEnv* env,
- jobject obj,
- jclass clazz,
- jmethodID methodID,
- va_list args) {
+jfloat CallNonvirtualFloatMethodV(JNIEnv* env,
+ jobject obj, jclass clazz, jmethodID methodID, va_list args) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jfloat JniNativeInterface::CallNonvirtualFloatMethodA(JNIEnv* env,
- jobject obj,
- jclass clazz,
- jmethodID methodID,
- jvalue* args) {
+jfloat CallNonvirtualFloatMethodA(JNIEnv* env,
+ jobject obj, jclass clazz, jmethodID methodID, jvalue* args) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jdouble JniNativeInterface::CallNonvirtualDoubleMethod(JNIEnv* env,
- jobject obj,
- jclass clazz,
- jmethodID methodID,
- ...) {
+jdouble CallNonvirtualDoubleMethod(JNIEnv* env,
+ jobject obj, jclass clazz, jmethodID methodID, ...) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jdouble JniNativeInterface::CallNonvirtualDoubleMethodV(JNIEnv* env,
- jobject obj,
- jclass clazz,
- jmethodID methodID,
- va_list args) {
+jdouble CallNonvirtualDoubleMethodV(JNIEnv* env,
+ jobject obj, jclass clazz, jmethodID methodID, va_list args) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jdouble JniNativeInterface::CallNonvirtualDoubleMethodA(JNIEnv* env,
- jobject obj,
- jclass clazz,
- jmethodID methodID,
- jvalue* args) {
+jdouble CallNonvirtualDoubleMethodA(JNIEnv* env,
+ jobject obj, jclass clazz, jmethodID methodID, jvalue* args) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-void JniNativeInterface::CallNonvirtualVoidMethod(JNIEnv* env,
- jobject obj,
- jclass clazz,
- jmethodID methodID,
- ...) {
+void CallNonvirtualVoidMethod(JNIEnv* env,
+ jobject obj, jclass clazz, jmethodID methodID, ...) {
LOG(FATAL) << "Unimplemented";
}
-void JniNativeInterface::CallNonvirtualVoidMethodV(JNIEnv* env,
- jobject obj,
- jclass clazz,
- jmethodID methodID,
- va_list args) {
+void CallNonvirtualVoidMethodV(JNIEnv* env,
+ jobject obj, jclass clazz, jmethodID methodID, va_list args) {
LOG(FATAL) << "Unimplemented";
}
-void JniNativeInterface::CallNonvirtualVoidMethodA(JNIEnv* env,
- jobject obj,
- jclass clazz,
- jmethodID methodID,
- jvalue* args) {
+void CallNonvirtualVoidMethodA(JNIEnv* env,
+ jobject obj, jclass clazz, jmethodID methodID, jvalue* args) {
LOG(FATAL) << "Unimplemented";
}
-jfieldID JniNativeInterface::GetFieldID(JNIEnv* env,
- jclass clazz,
- const char* name,
- const char* sig) {
+jfieldID GetFieldID(JNIEnv* env,
+ jclass clazz, const char* name, const char* sig) {
LOG(FATAL) << "Unimplemented";
return NULL;
}
-jobject JniNativeInterface::GetObjectField(JNIEnv* env,
- jobject obj,
- jfieldID fieldID) {
+jobject GetObjectField(JNIEnv* env, jobject obj, jfieldID fieldID) {
LOG(FATAL) << "Unimplemented";
return NULL;
}
-jboolean JniNativeInterface::GetBooleanField(JNIEnv* env,
- jobject obj,
- jfieldID fieldID) {
+jboolean GetBooleanField(JNIEnv* env, jobject obj, jfieldID fieldID) {
LOG(FATAL) << "Unimplemented";
return JNI_FALSE;
}
-jbyte JniNativeInterface::GetByteField(JNIEnv* env,
- jobject obj,
- jfieldID fieldID) {
+jbyte GetByteField(JNIEnv* env, jobject obj, jfieldID fieldID) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jchar JniNativeInterface::GetCharField(JNIEnv* env,
- jobject obj,
- jfieldID fieldID) {
+jchar GetCharField(JNIEnv* env, jobject obj, jfieldID fieldID) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jshort JniNativeInterface::GetShortField(JNIEnv* env,
- jobject obj,
- jfieldID fieldID) {
+jshort GetShortField(JNIEnv* env, jobject obj, jfieldID fieldID) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jint JniNativeInterface::GetIntField(JNIEnv* env,
- jobject obj,
- jfieldID fieldID) {
+jint GetIntField(JNIEnv* env, jobject obj, jfieldID fieldID) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jlong JniNativeInterface::GetLongField(JNIEnv* env,
- jobject obj,
- jfieldID fieldID) {
+jlong GetLongField(JNIEnv* env, jobject obj, jfieldID fieldID) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jfloat JniNativeInterface::GetFloatField(JNIEnv* env,
- jobject obj,
- jfieldID fieldID) {
+jfloat GetFloatField(JNIEnv* env, jobject obj, jfieldID fieldID) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jdouble JniNativeInterface::GetDoubleField(JNIEnv* env,
- jobject obj,
- jfieldID fieldID) {
+jdouble GetDoubleField(JNIEnv* env, jobject obj, jfieldID fieldID) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-void JniNativeInterface::SetObjectField(JNIEnv* env,
- jobject obj,
- jfieldID fieldID,
- jobject val) {
+void SetObjectField(JNIEnv* env, jobject obj, jfieldID fieldID, jobject val) {
LOG(FATAL) << "Unimplemented";
}
-void JniNativeInterface::SetBooleanField(JNIEnv* env,
- jobject obj,
- jfieldID fieldID,
- jboolean val) {
+void SetBooleanField(JNIEnv* env, jobject obj, jfieldID fieldID, jboolean val) {
LOG(FATAL) << "Unimplemented";
}
-void JniNativeInterface::SetByteField(JNIEnv* env,
- jobject obj,
- jfieldID fieldID,
- jbyte val) {
+void SetByteField(JNIEnv* env, jobject obj, jfieldID fieldID, jbyte val) {
LOG(FATAL) << "Unimplemented";
}
-void JniNativeInterface::SetCharField(JNIEnv* env,
- jobject obj,
- jfieldID fieldID,
- jchar val) {
+void SetCharField(JNIEnv* env, jobject obj, jfieldID fieldID, jchar val) {
LOG(FATAL) << "Unimplemented";
}
-void JniNativeInterface::SetShortField(JNIEnv* env,
- jobject obj,
- jfieldID fieldID,
- jshort val) {
+void SetShortField(JNIEnv* env, jobject obj, jfieldID fieldID, jshort val) {
LOG(FATAL) << "Unimplemented";
}
-void JniNativeInterface::SetIntField(JNIEnv* env,
- jobject obj,
- jfieldID fieldID,
- jint val) {
+void SetIntField(JNIEnv* env, jobject obj, jfieldID fieldID, jint val) {
LOG(FATAL) << "Unimplemented";
}
-void JniNativeInterface::SetLongField(JNIEnv* env,
- jobject obj,
- jfieldID fieldID,
- jlong val) {
+void SetLongField(JNIEnv* env, jobject obj, jfieldID fieldID, jlong val) {
LOG(FATAL) << "Unimplemented";
}
-void JniNativeInterface::SetFloatField(JNIEnv* env,
- jobject obj,
- jfieldID fieldID,
- jfloat val) {
+void SetFloatField(JNIEnv* env, jobject obj, jfieldID fieldID, jfloat val) {
LOG(FATAL) << "Unimplemented";
}
-void JniNativeInterface::SetDoubleField(JNIEnv* env,
- jobject obj,
- jfieldID fieldID,
- jdouble val) {
+void SetDoubleField(JNIEnv* env, jobject obj, jfieldID fieldID, jdouble val) {
LOG(FATAL) << "Unimplemented";
}
-jmethodID JniNativeInterface::GetStaticMethodID(JNIEnv* env,
- jclass clazz,
- const char* name,
- const char* sig) {
+jmethodID GetStaticMethodID(JNIEnv* env,
+ jclass clazz, const char* name, const char* sig) {
LOG(FATAL) << "Unimplemented";
return NULL;
}
-jobject JniNativeInterface::CallStaticObjectMethod(JNIEnv* env,
- jclass clazz,
- jmethodID methodID,
- ...) {
+jobject CallStaticObjectMethod(JNIEnv* env,
+ jclass clazz, jmethodID methodID, ...) {
LOG(FATAL) << "Unimplemented";
return NULL;
}
-jobject JniNativeInterface::CallStaticObjectMethodV(JNIEnv* env,
- jclass clazz,
- jmethodID methodID,
- va_list args) {
+jobject CallStaticObjectMethodV(JNIEnv* env,
+ jclass clazz, jmethodID methodID, va_list args) {
LOG(FATAL) << "Unimplemented";
return NULL;
}
-jobject JniNativeInterface::CallStaticObjectMethodA(JNIEnv* env,
- jclass clazz,
- jmethodID methodID,
- jvalue* args) {
+jobject CallStaticObjectMethodA(JNIEnv* env,
+ jclass clazz, jmethodID methodID, jvalue* args) {
LOG(FATAL) << "Unimplemented";
return NULL;
}
-jboolean JniNativeInterface::CallStaticBooleanMethod(JNIEnv* env,
- jclass clazz,
- jmethodID methodID,
- ...) {
+jboolean CallStaticBooleanMethod(JNIEnv* env,
+ jclass clazz, jmethodID methodID, ...) {
LOG(FATAL) << "Unimplemented";
return JNI_FALSE;
}
-jboolean JniNativeInterface::CallStaticBooleanMethodV(JNIEnv* env,
- jclass clazz,
- jmethodID methodID,
- va_list args) {
+jboolean CallStaticBooleanMethodV(JNIEnv* env,
+ jclass clazz, jmethodID methodID, va_list args) {
LOG(FATAL) << "Unimplemented";
return JNI_FALSE;
}
-jboolean JniNativeInterface::CallStaticBooleanMethodA(JNIEnv* env,
- jclass clazz,
- jmethodID methodID,
- jvalue* args) {
+jboolean CallStaticBooleanMethodA(JNIEnv* env,
+ jclass clazz, jmethodID methodID, jvalue* args) {
LOG(FATAL) << "Unimplemented";
return JNI_FALSE;
}
-jbyte JniNativeInterface::CallStaticByteMethod(JNIEnv* env,
- jclass clazz,
- jmethodID methodID,
- ...) {
+jbyte CallStaticByteMethod(JNIEnv* env, jclass clazz, jmethodID methodID, ...) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jbyte JniNativeInterface::CallStaticByteMethodV(JNIEnv* env,
- jclass clazz,
- jmethodID methodID,
- va_list args) {
+jbyte CallStaticByteMethodV(JNIEnv* env,
+ jclass clazz, jmethodID methodID, va_list args) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jbyte JniNativeInterface::CallStaticByteMethodA(JNIEnv* env,
- jclass clazz,
- jmethodID methodID,
- jvalue* args) {
+jbyte CallStaticByteMethodA(JNIEnv* env,
+ jclass clazz, jmethodID methodID, jvalue* args) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jchar JniNativeInterface::CallStaticCharMethod(JNIEnv* env,
- jclass clazz,
- jmethodID methodID,
- ...) {
+jchar CallStaticCharMethod(JNIEnv* env, jclass clazz, jmethodID methodID, ...) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jchar JniNativeInterface::CallStaticCharMethodV(JNIEnv* env,
- jclass clazz,
- jmethodID methodID,
- va_list args) {
+jchar CallStaticCharMethodV(JNIEnv* env,
+ jclass clazz, jmethodID methodID, va_list args) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jchar JniNativeInterface::CallStaticCharMethodA(JNIEnv* env,
- jclass clazz,
- jmethodID methodID,
- jvalue* args) {
+jchar CallStaticCharMethodA(JNIEnv* env,
+ jclass clazz, jmethodID methodID, jvalue* args) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jshort JniNativeInterface::CallStaticShortMethod(JNIEnv* env,
- jclass clazz,
- jmethodID methodID,
- ...) {
+jshort CallStaticShortMethod(JNIEnv* env,
+ jclass clazz, jmethodID methodID, ...) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jshort JniNativeInterface::CallStaticShortMethodV(JNIEnv* env,
- jclass clazz,
- jmethodID methodID,
- va_list args) {
+jshort CallStaticShortMethodV(JNIEnv* env,
+ jclass clazz, jmethodID methodID, va_list args) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jshort JniNativeInterface::CallStaticShortMethodA(JNIEnv* env,
- jclass clazz,
- jmethodID methodID,
- jvalue* args) {
+jshort CallStaticShortMethodA(JNIEnv* env,
+ jclass clazz, jmethodID methodID, jvalue* args) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jint JniNativeInterface::CallStaticIntMethod(JNIEnv* env,
- jclass clazz,
- jmethodID methodID,
- ...) {
+jint CallStaticIntMethod(JNIEnv* env, jclass clazz, jmethodID methodID, ...) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jint JniNativeInterface::CallStaticIntMethodV(JNIEnv* env,
- jclass clazz,
- jmethodID methodID,
- va_list args) {
+jint CallStaticIntMethodV(JNIEnv* env,
+ jclass clazz, jmethodID methodID, va_list args) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jint JniNativeInterface::CallStaticIntMethodA(JNIEnv* env,
- jclass clazz,
- jmethodID methodID,
- jvalue* args) {
+jint CallStaticIntMethodA(JNIEnv* env,
+ jclass clazz, jmethodID methodID, jvalue* args) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jlong JniNativeInterface::CallStaticLongMethod(JNIEnv* env,
- jclass clazz,
- jmethodID methodID,
- ...) {
+jlong CallStaticLongMethod(JNIEnv* env, jclass clazz, jmethodID methodID, ...) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jlong JniNativeInterface::CallStaticLongMethodV(JNIEnv* env,
- jclass clazz,
- jmethodID methodID,
- va_list args) {
+jlong CallStaticLongMethodV(JNIEnv* env,
+ jclass clazz, jmethodID methodID, va_list args) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jlong JniNativeInterface::CallStaticLongMethodA(JNIEnv* env,
- jclass clazz,
- jmethodID methodID,
- jvalue* args) {
+jlong CallStaticLongMethodA(JNIEnv* env,
+ jclass clazz, jmethodID methodID, jvalue* args) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jfloat JniNativeInterface::CallStaticFloatMethod(JNIEnv* env,
- jclass clazz,
- jmethodID methodID,
- ...) {
+jfloat CallStaticFloatMethod(JNIEnv* env,
+ jclass clazz, jmethodID methodID, ...) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jfloat JniNativeInterface::CallStaticFloatMethodV(JNIEnv* env,
- jclass clazz,
- jmethodID methodID,
- va_list args) {
+jfloat CallStaticFloatMethodV(JNIEnv* env,
+ jclass clazz, jmethodID methodID, va_list args) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jfloat JniNativeInterface::CallStaticFloatMethodA(JNIEnv* env,
- jclass clazz,
- jmethodID methodID,
- jvalue* args) {
+jfloat CallStaticFloatMethodA(JNIEnv* env,
+ jclass clazz, jmethodID methodID, jvalue* args) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jdouble JniNativeInterface::CallStaticDoubleMethod(JNIEnv* env,
- jclass clazz,
- jmethodID methodID,
- ...) {
+jdouble CallStaticDoubleMethod(JNIEnv* env,
+ jclass clazz, jmethodID methodID, ...) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jdouble JniNativeInterface::CallStaticDoubleMethodV(JNIEnv* env,
- jclass clazz,
- jmethodID methodID,
- va_list args) {
+jdouble CallStaticDoubleMethodV(JNIEnv* env,
+ jclass clazz, jmethodID methodID, va_list args) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jdouble JniNativeInterface::CallStaticDoubleMethodA(JNIEnv* env,
- jclass clazz,
- jmethodID methodID,
- jvalue* args) {
+jdouble CallStaticDoubleMethodA(JNIEnv* env,
+ jclass clazz, jmethodID methodID, jvalue* args) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-void JniNativeInterface::CallStaticVoidMethod(JNIEnv* env,
- jclass cls,
- jmethodID methodID,
- ...) {
+void CallStaticVoidMethod(JNIEnv* env, jclass cls, jmethodID methodID, ...) {
LOG(FATAL) << "Unimplemented";
}
-void JniNativeInterface::CallStaticVoidMethodV(JNIEnv* env,
- jclass cls,
- jmethodID methodID,
- va_list args) {
+void CallStaticVoidMethodV(JNIEnv* env,
+ jclass cls, jmethodID methodID, va_list args) {
LOG(FATAL) << "Unimplemented";
}
-void JniNativeInterface::CallStaticVoidMethodA(JNIEnv* env,
- jclass cls,
- jmethodID methodID,
- jvalue* args) {
+void CallStaticVoidMethodA(JNIEnv* env,
+ jclass cls, jmethodID methodID, jvalue* args) {
LOG(FATAL) << "Unimplemented";
}
-jfieldID JniNativeInterface::GetStaticFieldID(JNIEnv* env,
- jclass clazz,
- const char* name,
- const char* sig) {
+jfieldID GetStaticFieldID(JNIEnv* env,
+ jclass clazz, const char* name, const char* sig) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jobject JniNativeInterface::GetStaticObjectField(JNIEnv* env,
- jclass clazz,
- jfieldID fieldID) {
+jobject GetStaticObjectField(JNIEnv* env, jclass clazz, jfieldID fieldID) {
LOG(FATAL) << "Unimplemented";
return NULL;
}
-jboolean JniNativeInterface::GetStaticBooleanField(JNIEnv* env,
- jclass clazz,
- jfieldID fieldID) {
+jboolean GetStaticBooleanField(JNIEnv* env, jclass clazz, jfieldID fieldID) {
LOG(FATAL) << "Unimplemented";
return JNI_FALSE;
}
-jbyte JniNativeInterface::GetStaticByteField(JNIEnv* env,
- jclass clazz,
- jfieldID fieldID) {
+jbyte GetStaticByteField(JNIEnv* env, jclass clazz, jfieldID fieldID) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jchar JniNativeInterface::GetStaticCharField(JNIEnv* env,
- jclass clazz,
- jfieldID fieldID) {
+jchar GetStaticCharField(JNIEnv* env, jclass clazz, jfieldID fieldID) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jshort JniNativeInterface::GetStaticShortField(JNIEnv* env,
- jclass clazz,
- jfieldID fieldID) {
+jshort GetStaticShortField(JNIEnv* env, jclass clazz, jfieldID fieldID) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jint JniNativeInterface::GetStaticIntField(JNIEnv* env,
- jclass clazz,
- jfieldID fieldID) {
+jint GetStaticIntField(JNIEnv* env, jclass clazz, jfieldID fieldID) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jlong JniNativeInterface::GetStaticLongField(JNIEnv* env,
- jclass clazz,
- jfieldID fieldID) {
+jlong GetStaticLongField(JNIEnv* env, jclass clazz, jfieldID fieldID) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jfloat JniNativeInterface::GetStaticFloatField(JNIEnv* env,
- jclass clazz,
- jfieldID fieldID) {
+jfloat GetStaticFloatField(JNIEnv* env, jclass clazz, jfieldID fieldID) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jdouble JniNativeInterface::GetStaticDoubleField(JNIEnv* env,
- jclass clazz,
- jfieldID fieldID) {
+jdouble GetStaticDoubleField(JNIEnv* env, jclass clazz, jfieldID fieldID) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-void JniNativeInterface::SetStaticObjectField(JNIEnv* env,
- jclass clazz,
- jfieldID fieldID,
- jobject value) {
+void SetStaticObjectField(JNIEnv* env,
+ jclass clazz, jfieldID fieldID, jobject value) {
LOG(FATAL) << "Unimplemented";
}
-void JniNativeInterface::SetStaticBooleanField(JNIEnv* env,
- jclass clazz,
- jfieldID fieldID,
- jboolean value) {
+void SetStaticBooleanField(JNIEnv* env,
+ jclass clazz, jfieldID fieldID, jboolean value) {
LOG(FATAL) << "Unimplemented";
}
-void JniNativeInterface::SetStaticByteField(JNIEnv* env,
- jclass clazz,
- jfieldID fieldID,
- jbyte value) {
+void SetStaticByteField(JNIEnv* env,
+ jclass clazz, jfieldID fieldID, jbyte value) {
LOG(FATAL) << "Unimplemented";
}
-void JniNativeInterface::SetStaticCharField(JNIEnv* env,
- jclass clazz,
- jfieldID fieldID,
- jchar value) {
+void SetStaticCharField(JNIEnv* env,
+ jclass clazz, jfieldID fieldID, jchar value) {
LOG(FATAL) << "Unimplemented";
}
-void JniNativeInterface::SetStaticShortField(JNIEnv* env,
- jclass clazz,
- jfieldID fieldID,
- jshort value) {
+void SetStaticShortField(JNIEnv* env,
+ jclass clazz, jfieldID fieldID, jshort value) {
LOG(FATAL) << "Unimplemented";
}
-void JniNativeInterface::SetStaticIntField(JNIEnv* env,
- jclass clazz,
- jfieldID fieldID,
- jint value) {
+void SetStaticIntField(JNIEnv* env,
+ jclass clazz, jfieldID fieldID, jint value) {
LOG(FATAL) << "Unimplemented";
}
-void JniNativeInterface::SetStaticLongField(JNIEnv* env,
- jclass clazz,
- jfieldID fieldID,
- jlong value) {
+void SetStaticLongField(JNIEnv* env,
+ jclass clazz, jfieldID fieldID, jlong value) {
LOG(FATAL) << "Unimplemented";
}
-void JniNativeInterface::SetStaticFloatField(JNIEnv* env,
- jclass clazz,
- jfieldID fieldID,
- jfloat value) {
+void SetStaticFloatField(JNIEnv* env,
+ jclass clazz, jfieldID fieldID, jfloat value) {
LOG(FATAL) << "Unimplemented";
}
-void JniNativeInterface::SetStaticDoubleField(JNIEnv* env,
- jclass clazz,
- jfieldID fieldID,
- jdouble value) {
+void SetStaticDoubleField(JNIEnv* env,
+ jclass clazz, jfieldID fieldID, jdouble value) {
LOG(FATAL) << "Unimplemented";
}
-jstring JniNativeInterface::NewString(JNIEnv* env,
- const jchar* unicode,
- jsize len) {
+jstring NewString(JNIEnv* env, const jchar* unicode, jsize len) {
LOG(FATAL) << "Unimplemented";
return NULL;
}
-jsize JniNativeInterface::GetStringLength(JNIEnv* env, jstring str) {
+jsize GetStringLength(JNIEnv* env, jstring str) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-const jchar* JniNativeInterface::GetStringChars(JNIEnv* env,
- jstring str,
- jboolean* isCopy) {
+const jchar* GetStringChars(JNIEnv* env, jstring str, jboolean* isCopy) {
LOG(FATAL) << "Unimplemented";
return NULL;
}
-void JniNativeInterface::ReleaseStringChars(JNIEnv* env,
- jstring str,
- const jchar* chars) {
+void ReleaseStringChars(JNIEnv* env, jstring str, const jchar* chars) {
LOG(FATAL) << "Unimplemented";
}
-jstring JniNativeInterface::NewStringUTF(JNIEnv* env, const char* utf) {
+jstring NewStringUTF(JNIEnv* env, const char* utf) {
LOG(FATAL) << "Unimplemented";
return NULL;
}
-jsize JniNativeInterface::GetStringUTFLength(JNIEnv* env, jstring str) {
+jsize GetStringUTFLength(JNIEnv* env, jstring str) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-const char* JniNativeInterface::GetStringUTFChars(JNIEnv* env,
- jstring str,
- jboolean* isCopy) {
+const char* GetStringUTFChars(JNIEnv* env, jstring str, jboolean* isCopy) {
LOG(FATAL) << "Unimplemented";
return NULL;
}
-void JniNativeInterface::ReleaseStringUTFChars(JNIEnv* env,
- jstring str,
- const char* chars) {
+void ReleaseStringUTFChars(JNIEnv* env, jstring str, const char* chars) {
LOG(FATAL) << "Unimplemented";
}
-jsize JniNativeInterface::GetArrayLength(JNIEnv* env, jarray array) {
+jsize GetArrayLength(JNIEnv* env, jarray array) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jobjectArray JniNativeInterface::NewObjectArray(JNIEnv* env,
- jsize len,
- jclass clazz,
- jobject init) {
+jobjectArray NewObjectArray(JNIEnv* env,
+ jsize len, jclass clazz, jobject init) {
LOG(FATAL) << "Unimplemented";
return NULL;
}
-jobject JniNativeInterface::GetObjectArrayElement(JNIEnv* env,
- jobjectArray array,
- jsize index) {
+jobject GetObjectArrayElement(JNIEnv* env, jobjectArray array, jsize index) {
LOG(FATAL) << "Unimplemented";
return NULL;
}
-void JniNativeInterface::SetObjectArrayElement(JNIEnv* env,
- jobjectArray array,
- jsize index,
- jobject val) {
+void SetObjectArrayElement(JNIEnv* env,
+ jobjectArray array, jsize index, jobject val) {
LOG(FATAL) << "Unimplemented";
}
-jbooleanArray JniNativeInterface::NewBooleanArray(JNIEnv* env, jsize len) {
+jbooleanArray NewBooleanArray(JNIEnv* env, jsize len) {
LOG(FATAL) << "Unimplemented";
return NULL;
}
-jbyteArray JniNativeInterface::NewByteArray(JNIEnv* env, jsize len) {
+jbyteArray NewByteArray(JNIEnv* env, jsize len) {
LOG(FATAL) << "Unimplemented";
return NULL;
}
-jcharArray JniNativeInterface::NewCharArray(JNIEnv* env, jsize len) {
+jcharArray NewCharArray(JNIEnv* env, jsize len) {
LOG(FATAL) << "Unimplemented";
return NULL;
}
-jshortArray JniNativeInterface::NewShortArray(JNIEnv* env, jsize len) {
+jshortArray NewShortArray(JNIEnv* env, jsize len) {
LOG(FATAL) << "Unimplemented";
return NULL;
}
-jintArray JniNativeInterface::NewIntArray(JNIEnv* env, jsize len) {
+jintArray NewIntArray(JNIEnv* env, jsize len) {
LOG(FATAL) << "Unimplemented";
return NULL;
}
-jlongArray JniNativeInterface::NewLongArray(JNIEnv* env, jsize len) {
+jlongArray NewLongArray(JNIEnv* env, jsize len) {
LOG(FATAL) << "Unimplemented";
return NULL;
}
-jfloatArray JniNativeInterface::NewFloatArray(JNIEnv* env, jsize len) {
+jfloatArray NewFloatArray(JNIEnv* env, jsize len) {
LOG(FATAL) << "Unimplemented";
return NULL;
}
-jdoubleArray JniNativeInterface::NewDoubleArray(JNIEnv* env, jsize len) {
+jdoubleArray NewDoubleArray(JNIEnv* env, jsize len) {
LOG(FATAL) << "Unimplemented";
return NULL;
}
-jboolean* JniNativeInterface::GetBooleanArrayElements(JNIEnv* env,
- jbooleanArray array,
- jboolean* isCopy) {
+jboolean* GetBooleanArrayElements(JNIEnv* env,
+ jbooleanArray array, jboolean* isCopy) {
LOG(FATAL) << "Unimplemented";
return NULL;
}
-jbyte* JniNativeInterface::GetByteArrayElements(JNIEnv* env,
- jbyteArray array,
- jboolean* isCopy) {
+jbyte* GetByteArrayElements(JNIEnv* env, jbyteArray array, jboolean* isCopy) {
LOG(FATAL) << "Unimplemented";
return NULL;
}
-jchar* JniNativeInterface::GetCharArrayElements(JNIEnv* env,
- jcharArray array,
- jboolean* isCopy) {
+jchar* GetCharArrayElements(JNIEnv* env, jcharArray array, jboolean* isCopy) {
LOG(FATAL) << "Unimplemented";
return NULL;
}
-jshort* JniNativeInterface::GetShortArrayElements(JNIEnv* env,
- jshortArray array,
- jboolean* isCopy) {
+jshort* GetShortArrayElements(JNIEnv* env,
+ jshortArray array, jboolean* isCopy) {
LOG(FATAL) << "Unimplemented";
return NULL;
}
-jint* JniNativeInterface::GetIntArrayElements(JNIEnv* env,
- jintArray array,
- jboolean* isCopy) {
+jint* GetIntArrayElements(JNIEnv* env, jintArray array, jboolean* isCopy) {
LOG(FATAL) << "Unimplemented";
return NULL;
}
-jlong* JniNativeInterface::GetLongArrayElements(JNIEnv* env,
- jlongArray array,
- jboolean* isCopy) {
+jlong* GetLongArrayElements(JNIEnv* env, jlongArray array, jboolean* isCopy) {
LOG(FATAL) << "Unimplemented";
return NULL;
}
-jfloat* JniNativeInterface::GetFloatArrayElements(JNIEnv* env,
- jfloatArray array,
- jboolean* isCopy) {
+jfloat* GetFloatArrayElements(JNIEnv* env,
+ jfloatArray array, jboolean* isCopy) {
LOG(FATAL) << "Unimplemented";
return NULL;
}
-jdouble* JniNativeInterface::GetDoubleArrayElements(JNIEnv* env,
- jdoubleArray array,
- jboolean* isCopy) {
+jdouble* GetDoubleArrayElements(JNIEnv* env,
+ jdoubleArray array, jboolean* isCopy) {
LOG(FATAL) << "Unimplemented";
return NULL;
}
-void JniNativeInterface::ReleaseBooleanArrayElements(JNIEnv* env,
- jbooleanArray array,
- jboolean* elems,
- jint mode) {
+void ReleaseBooleanArrayElements(JNIEnv* env,
+ jbooleanArray array, jboolean* elems, jint mode) {
LOG(FATAL) << "Unimplemented";
}
-void JniNativeInterface::ReleaseByteArrayElements(JNIEnv* env,
- jbyteArray array,
- jbyte* elems,
- jint mode) {
+void ReleaseByteArrayElements(JNIEnv* env,
+ jbyteArray array, jbyte* elems, jint mode) {
LOG(FATAL) << "Unimplemented";
}
-void JniNativeInterface::ReleaseCharArrayElements(JNIEnv* env,
- jcharArray array,
- jchar* elems,
- jint mode) {
+void ReleaseCharArrayElements(JNIEnv* env,
+ jcharArray array, jchar* elems, jint mode) {
LOG(FATAL) << "Unimplemented";
}
-void JniNativeInterface::ReleaseShortArrayElements(JNIEnv* env,
- jshortArray array,
- jshort* elems,
- jint mode) {
+void ReleaseShortArrayElements(JNIEnv* env,
+ jshortArray array, jshort* elems, jint mode) {
LOG(FATAL) << "Unimplemented";
}
-void JniNativeInterface::ReleaseIntArrayElements(JNIEnv* env,
- jintArray array,
- jint* elems,
- jint mode) {
+void ReleaseIntArrayElements(JNIEnv* env,
+ jintArray array, jint* elems, jint mode) {
LOG(FATAL) << "Unimplemented";
}
-void JniNativeInterface::ReleaseLongArrayElements(JNIEnv* env,
- jlongArray array,
- jlong* elems,
- jint mode) {
+void ReleaseLongArrayElements(JNIEnv* env,
+ jlongArray array, jlong* elems, jint mode) {
LOG(FATAL) << "Unimplemented";
}
-void JniNativeInterface::ReleaseFloatArrayElements(JNIEnv* env,
- jfloatArray array,
- jfloat* elems,
- jint mode) {
+void ReleaseFloatArrayElements(JNIEnv* env,
+ jfloatArray array, jfloat* elems, jint mode) {
LOG(FATAL) << "Unimplemented";
}
-void JniNativeInterface::ReleaseDoubleArrayElements(JNIEnv* env,
- jdoubleArray array,
- jdouble* elems,
- jint mode) {
+void ReleaseDoubleArrayElements(JNIEnv* env,
+ jdoubleArray array, jdouble* elems, jint mode) {
LOG(FATAL) << "Unimplemented";
}
-void JniNativeInterface::GetBooleanArrayRegion(JNIEnv* env,
- jbooleanArray array,
- jsize start,
- jsize l,
- jboolean* buf) {
+void GetBooleanArrayRegion(JNIEnv* env,
+ jbooleanArray array, jsize start, jsize l, jboolean* buf) {
LOG(FATAL) << "Unimplemented";
}
-void JniNativeInterface::GetByteArrayRegion(JNIEnv* env,
- jbyteArray array,
- jsize start,
- jsize len,
- jbyte* buf) {
+void GetByteArrayRegion(JNIEnv* env,
+ jbyteArray array, jsize start, jsize len, jbyte* buf) {
LOG(FATAL) << "Unimplemented";
}
-void JniNativeInterface::GetCharArrayRegion(JNIEnv* env,
- jcharArray array,
- jsize start,
- jsize len,
- jchar* buf) {
+void GetCharArrayRegion(JNIEnv* env,
+ jcharArray array, jsize start, jsize len, jchar* buf) {
LOG(FATAL) << "Unimplemented";
}
-void JniNativeInterface::GetShortArrayRegion(JNIEnv* env,
- jshortArray array,
- jsize start,
- jsize len,
- jshort* buf) {
+void GetShortArrayRegion(JNIEnv* env,
+ jshortArray array, jsize start, jsize len, jshort* buf) {
LOG(FATAL) << "Unimplemented";
}
-void JniNativeInterface::GetIntArrayRegion(JNIEnv* env,
- jintArray array,
- jsize start,
- jsize len,
- jint* buf) {
+void GetIntArrayRegion(JNIEnv* env,
+ jintArray array, jsize start, jsize len, jint* buf) {
LOG(FATAL) << "Unimplemented";
}
-void JniNativeInterface::GetLongArrayRegion(JNIEnv* env,
- jlongArray array,
- jsize start,
- jsize len,
- jlong* buf) {
+void GetLongArrayRegion(JNIEnv* env,
+ jlongArray array, jsize start, jsize len, jlong* buf) {
LOG(FATAL) << "Unimplemented";
}
-void JniNativeInterface::GetFloatArrayRegion(JNIEnv* env,
- jfloatArray array,
- jsize start,
- jsize len,
- jfloat* buf) {
+void GetFloatArrayRegion(JNIEnv* env,
+ jfloatArray array, jsize start, jsize len, jfloat* buf) {
LOG(FATAL) << "Unimplemented";
}
-void JniNativeInterface::GetDoubleArrayRegion(JNIEnv* env,
- jdoubleArray array,
- jsize start,
- jsize len,
- jdouble* buf) {
+void GetDoubleArrayRegion(JNIEnv* env,
+ jdoubleArray array, jsize start, jsize len, jdouble* buf) {
LOG(FATAL) << "Unimplemented";
}
-void JniNativeInterface::SetBooleanArrayRegion(JNIEnv* env,
- jbooleanArray array,
- jsize start,
- jsize l,
- const jboolean* buf) {
+void SetBooleanArrayRegion(JNIEnv* env,
+ jbooleanArray array, jsize start, jsize l, const jboolean* buf) {
LOG(FATAL) << "Unimplemented";
}
-void JniNativeInterface::SetByteArrayRegion(JNIEnv* env,
- jbyteArray array,
- jsize start,
- jsize len,
- const jbyte* buf) {
+void SetByteArrayRegion(JNIEnv* env,
+ jbyteArray array, jsize start, jsize len, const jbyte* buf) {
LOG(FATAL) << "Unimplemented";
}
-void JniNativeInterface::SetCharArrayRegion(JNIEnv* env,
- jcharArray array,
- jsize start,
- jsize len,
- const jchar* buf) {
+void SetCharArrayRegion(JNIEnv* env,
+ jcharArray array, jsize start, jsize len, const jchar* buf) {
LOG(FATAL) << "Unimplemented";
}
-void JniNativeInterface::SetShortArrayRegion(JNIEnv* env,
- jshortArray array,
- jsize start,
- jsize len,
- const jshort* buf) {
+void SetShortArrayRegion(JNIEnv* env,
+ jshortArray array, jsize start, jsize len, const jshort* buf) {
LOG(FATAL) << "Unimplemented";
}
-void JniNativeInterface::SetIntArrayRegion(JNIEnv* env,
- jintArray array,
- jsize start,
- jsize len,
- const jint* buf) {
+void SetIntArrayRegion(JNIEnv* env,
+ jintArray array, jsize start, jsize len, const jint* buf) {
LOG(FATAL) << "Unimplemented";
}
-void JniNativeInterface::SetLongArrayRegion(JNIEnv* env,
- jlongArray array,
- jsize start,
- jsize len,
- const jlong* buf) {
+void SetLongArrayRegion(JNIEnv* env,
+ jlongArray array, jsize start, jsize len, const jlong* buf) {
LOG(FATAL) << "Unimplemented";
}
-void JniNativeInterface::SetFloatArrayRegion(JNIEnv* env,
- jfloatArray array,
- jsize start,
- jsize len,
- const jfloat* buf) {
+void SetFloatArrayRegion(JNIEnv* env,
+ jfloatArray array, jsize start, jsize len, const jfloat* buf) {
LOG(FATAL) << "Unimplemented";
}
-void JniNativeInterface::SetDoubleArrayRegion(JNIEnv* env,
- jdoubleArray array,
- jsize start,
- jsize len,
- const jdouble* buf) {
+void SetDoubleArrayRegion(JNIEnv* env,
+ jdoubleArray array, jsize start, jsize len, const jdouble* buf) {
LOG(FATAL) << "Unimplemented";
}
-jint JniNativeInterface::RegisterNatives(JNIEnv* env,
- jclass clazz,
- const JNINativeMethod* methods,
- jint nMethods) {
+jint RegisterNatives(JNIEnv* env,
+ jclass clazz, const JNINativeMethod* methods, jint nMethods) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jint JniNativeInterface::UnregisterNatives(JNIEnv* env, jclass clazz) {
+jint UnregisterNatives(JNIEnv* env, jclass clazz) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jint JniNativeInterface::MonitorEnter(JNIEnv* env, jobject obj) {
+jint MonitorEnter(JNIEnv* env, jobject obj) {
+ LOG(WARNING) << "MonitorEnter unimplemented";
+ return 0;
+}
+
+jint MonitorExit(JNIEnv* env, jobject obj) {
+ LOG(WARNING) << "MonitorExit unimplemented";
+ return 0;
+}
+
+jint GetJavaVM(JNIEnv* env, JavaVM* *vm) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jint JniNativeInterface::MonitorExit(JNIEnv* env, jobject obj) {
- LOG(FATAL) << "Unimplemented";
- return 0;
-}
-
-jint JniNativeInterface::GetJavaVM(JNIEnv* env, JavaVM* *vm) {
- LOG(FATAL) << "Unimplemented";
- return 0;
-}
-
-void JniNativeInterface::GetStringRegion(JNIEnv* env,
- jstring str,
- jsize start,
- jsize len,
- jchar* buf) {
+void GetStringRegion(JNIEnv* env,
+ jstring str, jsize start, jsize len, jchar* buf) {
LOG(FATAL) << "Unimplemented";
}
-void JniNativeInterface::GetStringUTFRegion(JNIEnv* env,
- jstring str,
- jsize start,
- jsize len,
- char* buf) {
+void GetStringUTFRegion(JNIEnv* env,
+ jstring str, jsize start, jsize len, char* buf) {
LOG(FATAL) << "Unimplemented";
}
-void* JniNativeInterface::GetPrimitiveArrayCritical(JNIEnv* env,
- jarray array,
- jboolean* isCopy) {
+void* GetPrimitiveArrayCritical(JNIEnv* env,
+ jarray array, jboolean* isCopy) {
LOG(FATAL) << "Unimplemented";
return NULL;
}
-void JniNativeInterface::ReleasePrimitiveArrayCritical(JNIEnv* env,
- jarray array,
- void* carray,
- jint mode) {
+void ReleasePrimitiveArrayCritical(JNIEnv* env,
+ jarray array, void* carray, jint mode) {
LOG(FATAL) << "Unimplemented";
}
-const jchar* JniNativeInterface::GetStringCritical(JNIEnv* env,
- jstring s,
- jboolean* isCopy) {
+const jchar* GetStringCritical(JNIEnv* env, jstring s, jboolean* isCopy) {
LOG(FATAL) << "Unimplemented";
return NULL;
}
-void JniNativeInterface::ReleaseStringCritical(JNIEnv* env,
- jstring s,
- const jchar* cstr) {
+void ReleaseStringCritical(JNIEnv* env, jstring s, const jchar* cstr) {
LOG(FATAL) << "Unimplemented";
}
-jweak JniNativeInterface::NewWeakGlobalRef(JNIEnv* env, jobject obj) {
+jweak NewWeakGlobalRef(JNIEnv* env, jobject obj) {
LOG(FATAL) << "Unimplemented";
return NULL;
}
-void JniNativeInterface::DeleteWeakGlobalRef(JNIEnv* env, jweak obj) {
+void DeleteWeakGlobalRef(JNIEnv* env, jweak obj) {
LOG(FATAL) << "Unimplemented";
}
-jboolean JniNativeInterface::ExceptionCheck(JNIEnv* env) {
+jboolean ExceptionCheck(JNIEnv* env) {
LOG(FATAL) << "Unimplemented";
return JNI_FALSE;
}
-jobject JniNativeInterface::NewDirectByteBuffer(JNIEnv* env,
- void* address,
- jlong capacity) {
+jobject NewDirectByteBuffer(JNIEnv* env, void* address, jlong capacity) {
LOG(FATAL) << "Unimplemented";
return NULL;
}
-void* JniNativeInterface::GetDirectBufferAddress(JNIEnv* env, jobject buf) {
+void* GetDirectBufferAddress(JNIEnv* env, jobject buf) {
LOG(FATAL) << "Unimplemented";
return NULL;
}
-jlong JniNativeInterface::GetDirectBufferCapacity(JNIEnv* env, jobject buf) {
+jlong GetDirectBufferCapacity(JNIEnv* env, jobject buf) {
LOG(FATAL) << "Unimplemented";
return 0;
}
-jobjectRefType JniNativeInterface::GetObjectRefType(JNIEnv* env, jobject jobj) {
+jobjectRefType GetObjectRefType(JNIEnv* env, jobject jobj) {
LOG(FATAL) << "Unimplemented";
return JNIInvalidRefType;
}
-struct JNINativeInterface JniNativeInterface::native_interface_ = {
+static const struct JNINativeInterface gNativeInterface = {
NULL, // reserved0.
NULL, // reserved1.
NULL, // reserved2.
@@ -1916,6 +1463,23 @@
GetObjectRefType,
};
+void MonitorEnterHelper(JNIEnv* env, jobject obj) {
+ MonitorEnter(env, obj); // Ignore the result.
+}
+
+void MonitorExitHelper(JNIEnv* env, jobject obj) {
+ MonitorExit(env, obj); // Ignore the result.
+}
+
+JNIEnv* CreateJNIEnv() {
+ JNIEnvExt* result = (JNIEnvExt*) calloc(1, sizeof(JNIEnvExt));
+ result->fns = &gNativeInterface;
+ result->self = Thread::Current();
+ result->MonitorEnterHelper = &MonitorEnterHelper;
+ result->MonitorExitHelper = &MonitorExitHelper;
+ return reinterpret_cast<JNIEnv*>(result);
+}
+
// JNI Invocation interface.
extern "C" jint JNI_CreateJavaVM(JavaVM** p_vm, void** p_env, void* vm_args) {
@@ -1974,14 +1538,13 @@
return JNI_ERR;
}
Runtime* runtime = reinterpret_cast<Runtime*>(vm);
- JniEnvironment** jni_env = reinterpret_cast<JniEnvironment**>(p_env);
const char* name = NULL;
if (thr_args != NULL) {
// TODO: check version
name = static_cast<JavaVMAttachArgs*>(thr_args)->name;
// TODO: thread group
}
- bool success = runtime->AttachCurrentThread(name, jni_env);
+ bool success = runtime->AttachCurrentThread(name, p_env);
if (!success) {
return JNI_ERR;
} else {
@@ -2022,14 +1585,13 @@
return JNI_ERR;
}
Runtime* runtime = reinterpret_cast<Runtime*>(vm);
- JniEnvironment** jni_env = reinterpret_cast<JniEnvironment**>(p_env);
const char* name = NULL;
if (thr_args != NULL) {
// TODO: check version
name = static_cast<JavaVMAttachArgs*>(thr_args)->name;
// TODO: thread group
}
- bool success = runtime->AttachCurrentThreadAsDaemon(name, jni_env);
+ bool success = runtime->AttachCurrentThreadAsDaemon(name, p_env);
if (!success) {
return JNI_ERR;
} else {
diff --git a/src/jni_internal.h b/src/jni_internal.h
index ceaeb96..39ce2cd 100644
--- a/src/jni_internal.h
+++ b/src/jni_internal.h
@@ -10,858 +10,22 @@
namespace art {
-// TODO: This is a place holder for a true JNIEnv used to provide limited
-// functionality for the JNI compiler
-class JniEnvironment {
- public:
- explicit JniEnvironment();
+class Thread;
- static Offset MonitorEnterOffset() {
- return Offset(OFFSETOF_MEMBER(JniEnvironment, monitor_enter_));
- }
+JNIEnv* CreateJNIEnv();
- static Offset MonitorExitOffset() {
- return Offset(OFFSETOF_MEMBER(JniEnvironment, monitor_exit_));
- }
+struct JNIEnvExt {
+ const struct JNINativeInterface* fns; // Must be first.
- private:
- struct JNINativeInterface_* functions_;
+ Thread* self;
- void (*monitor_enter_)(JniEnvironment*, jobject);
- void (*monitor_exit_)(JniEnvironment*, jobject);
+ // Are we in a "critical" JNI call?
+ bool critical;
- DISALLOW_COPY_AND_ASSIGN(JniEnvironment);
-};
-
-class JniNativeInterface {
- public:
- static struct JNINativeInterface* GetInterface() {
- return &native_interface_;
- }
- private:
- static jint GetVersion(JNIEnv* env);
-
- static jclass DefineClass(JNIEnv* env,
- const char* name,
- jobject loader,
- const jbyte* buf,
- jsize len);
- static jclass FindClass(JNIEnv* env, const char* name);
-
- static jmethodID FromReflectedMethod(JNIEnv* env, jobject method);
- static jfieldID FromReflectedField(JNIEnv* env, jobject field);
- static jobject ToReflectedMethod(JNIEnv* env,
- jclass cls,
- jmethodID methodID,
- jboolean isStatic);
-
- static jclass GetSuperclass(JNIEnv* env, jclass sub);
- static jboolean IsAssignableFrom(JNIEnv* env, jclass sub, jclass sup);
- static jobject ToReflectedField(JNIEnv* env,
- jclass cls,
- jfieldID fieldID,
- jboolean isStatic);
-
- static jint Throw(JNIEnv* env, jthrowable obj);
- static jint ThrowNew(JNIEnv* env, jclass clazz, const char* msg);
- static jthrowable ExceptionOccurred(JNIEnv* env);
- static void ExceptionDescribe(JNIEnv* env);
- static void ExceptionClear(JNIEnv* env);
- static void FatalError(JNIEnv* env, const char* msg);
-
- static jint PushLocalFrame(JNIEnv* env, jint cap);
- static jobject PopLocalFrame(JNIEnv* env, jobject res);
-
- static jobject NewGlobalRef(JNIEnv* env, jobject lobj);
- static void DeleteGlobalRef(JNIEnv* env, jobject gref);
- static void DeleteLocalRef(JNIEnv* env, jobject obj);
- static jboolean IsSameObject(JNIEnv* env, jobject obj1, jobject obj2);
-
- static jobject NewLocalRef(JNIEnv* env, jobject ref);
- static jint EnsureLocalCapacity(JNIEnv* env, jint);
-
- static jobject AllocObject(JNIEnv* env, jclass clazz);
- static jobject NewObject(JNIEnv* env, jclass clazz, jmethodID methodID, ...);
- static jobject NewObjectV(JNIEnv* env,
- jclass clazz,
- jmethodID methodID,
- va_list args);
- static jobject NewObjectA(JNIEnv* env,
- jclass clazz,
- jmethodID methodID,
- jvalue* args);
-
- static jclass GetObjectClass(JNIEnv* env, jobject obj);
- static jboolean IsInstanceOf(JNIEnv* env, jobject obj, jclass clazz);
-
- static jmethodID GetMethodID(JNIEnv* env,
- jclass clazz,
- const char* name,
- const char* sig);
-
- static jobject CallObjectMethod(JNIEnv* env,
- jobject obj,
- jmethodID methodID,
- ...);
- static jobject CallObjectMethodV(JNIEnv* env,
- jobject obj,
- jmethodID methodID,
- va_list args);
- static jobject CallObjectMethodA(JNIEnv* env,
- jobject obj,
- jmethodID methodID,
- jvalue* args);
-
- static jboolean CallBooleanMethod(JNIEnv* env,
- jobject obj,
- jmethodID methodID,
- ...);
- static jboolean CallBooleanMethodV(JNIEnv* env,
- jobject obj,
- jmethodID methodID,
- va_list args);
- static jboolean CallBooleanMethodA(JNIEnv* env,
- jobject obj,
- jmethodID methodID,
- jvalue* args);
-
- static jbyte CallByteMethod(JNIEnv* env,
- jobject obj,
- jmethodID methodID,
- ...);
- static jbyte CallByteMethodV(JNIEnv* env,
- jobject obj,
- jmethodID methodID,
- va_list args);
- static jbyte CallByteMethodA(JNIEnv* env,
- jobject obj,
- jmethodID methodID,
- jvalue* args);
-
- static jchar CallCharMethod(JNIEnv* env,
- jobject obj,
- jmethodID methodID,
- ...);
- static jchar CallCharMethodV(JNIEnv* env,
- jobject obj,
- jmethodID methodID,
- va_list args);
- static jchar CallCharMethodA(JNIEnv* env,
- jobject obj,
- jmethodID methodID,
- jvalue* args);
-
- static jshort CallShortMethod(JNIEnv* env,
- jobject obj,
- jmethodID methodID,
- ...);
- static jshort CallShortMethodV(JNIEnv* env,
- jobject obj,
- jmethodID methodID,
- va_list args);
- static jshort CallShortMethodA(JNIEnv* env,
- jobject obj,
- jmethodID methodID,
- jvalue* args);
-
- static jint CallIntMethod(JNIEnv* env,
- jobject obj,
- jmethodID methodID,
- ...);
- static jint CallIntMethodV(JNIEnv* env,
- jobject obj,
- jmethodID methodID,
- va_list args);
- static jint CallIntMethodA(JNIEnv* env,
- jobject obj,
- jmethodID methodID,
- jvalue* args);
-
- static jlong CallLongMethod(JNIEnv* env,
- jobject obj,
- jmethodID methodID,
- ...);
- static jlong CallLongMethodV(JNIEnv* env,
- jobject obj,
- jmethodID methodID,
- va_list args);
- static jlong CallLongMethodA(JNIEnv* env,
- jobject obj,
- jmethodID methodID,
- jvalue* args);
-
- static jfloat CallFloatMethod(JNIEnv* env,
- jobject obj,
- jmethodID methodID,
- ...);
- static jfloat CallFloatMethodV(JNIEnv* env,
- jobject obj,
- jmethodID methodID,
- va_list args);
- static jfloat CallFloatMethodA(JNIEnv* env,
- jobject obj,
- jmethodID methodID,
- jvalue* args);
-
- static jdouble CallDoubleMethod(JNIEnv* env,
- jobject obj,
- jmethodID methodID,
- ...);
- static jdouble CallDoubleMethodV(JNIEnv* env,
- jobject obj,
- jmethodID methodID,
- va_list args);
- static jdouble CallDoubleMethodA(JNIEnv* env,
- jobject obj,
- jmethodID methodID,
- jvalue* args);
-
- static void CallVoidMethod(JNIEnv* env,
- jobject obj,
- jmethodID methodID,
- ...);
- static void CallVoidMethodV(JNIEnv* env,
- jobject obj,
- jmethodID methodID,
- va_list args);
- static void CallVoidMethodA(JNIEnv* env,
- jobject obj,
- jmethodID methodID,
- jvalue* args);
-
- static jobject CallNonvirtualObjectMethod(JNIEnv* env,
- jobject obj,
- jclass clazz,
- jmethodID methodID,
- ...);
- static jobject CallNonvirtualObjectMethodV(JNIEnv* env,
- jobject obj,
- jclass clazz,
- jmethodID methodID,
- va_list args);
- static jobject CallNonvirtualObjectMethodA(JNIEnv* env,
- jobject obj,
- jclass clazz,
- jmethodID methodID,
- jvalue* args);
-
- static jboolean CallNonvirtualBooleanMethod(JNIEnv* env,
- jobject obj,
- jclass clazz,
- jmethodID methodID,
- ...);
- static jboolean CallNonvirtualBooleanMethodV(JNIEnv* env,
- jobject obj,
- jclass clazz,
- jmethodID methodID,
- va_list args);
- static jboolean CallNonvirtualBooleanMethodA(JNIEnv* env,
- jobject obj,
- jclass clazz,
- jmethodID methodID,
- jvalue* args);
-
- static jbyte CallNonvirtualByteMethod(JNIEnv* env,
- jobject obj,
- jclass clazz,
- jmethodID methodID,
- ...);
- static jbyte CallNonvirtualByteMethodV(JNIEnv* env,
- jobject obj,
- jclass clazz,
- jmethodID methodID,
- va_list args);
- static jbyte CallNonvirtualByteMethodA(JNIEnv* env,
- jobject obj,
- jclass clazz,
- jmethodID methodID,
- jvalue* args);
-
- static jchar CallNonvirtualCharMethod(JNIEnv* env,
- jobject obj,
- jclass clazz,
- jmethodID methodID,
- ...);
- static jchar CallNonvirtualCharMethodV(JNIEnv* env,
- jobject obj,
- jclass clazz,
- jmethodID methodID,
- va_list args);
- static jchar CallNonvirtualCharMethodA(JNIEnv* env,
- jobject obj,
- jclass clazz,
- jmethodID methodID,
- jvalue* args);
-
- static jshort CallNonvirtualShortMethod(JNIEnv* env,
- jobject obj,
- jclass clazz,
- jmethodID methodID,
- ...);
- static jshort CallNonvirtualShortMethodV(JNIEnv* env,
- jobject obj,
- jclass clazz,
- jmethodID methodID,
- va_list args);
- static jshort CallNonvirtualShortMethodA(JNIEnv* env,
- jobject obj,
- jclass clazz,
- jmethodID methodID,
- jvalue* args);
-
- static jint CallNonvirtualIntMethod(JNIEnv* env,
- jobject obj,
- jclass clazz,
- jmethodID methodID,
- ...);
- static jint CallNonvirtualIntMethodV(JNIEnv* env,
- jobject obj,
- jclass clazz,
- jmethodID methodID,
- va_list args);
- static jint CallNonvirtualIntMethodA(JNIEnv* env,
- jobject obj,
- jclass clazz,
- jmethodID methodID,
- jvalue* args);
-
- static jlong CallNonvirtualLongMethod(JNIEnv* env,
- jobject obj,
- jclass clazz,
- jmethodID methodID,
- ...);
- static jlong CallNonvirtualLongMethodV(JNIEnv* env,
- jobject obj,
- jclass clazz,
- jmethodID methodID,
- va_list args);
- static jlong CallNonvirtualLongMethodA(JNIEnv* env,
- jobject obj,
- jclass clazz,
- jmethodID methodID,
- jvalue* args);
-
- static jfloat CallNonvirtualFloatMethod(JNIEnv* env,
- jobject obj,
- jclass clazz,
- jmethodID methodID,
- ...);
- static jfloat CallNonvirtualFloatMethodV(JNIEnv* env,
- jobject obj,
- jclass clazz,
- jmethodID methodID,
- va_list args);
- static jfloat CallNonvirtualFloatMethodA(JNIEnv* env,
- jobject obj,
- jclass clazz,
- jmethodID methodID,
- jvalue* args);
-
- static jdouble CallNonvirtualDoubleMethod(JNIEnv* env,
- jobject obj,
- jclass clazz,
- jmethodID methodID,
- ...);
- static jdouble CallNonvirtualDoubleMethodV(JNIEnv* env,
- jobject obj,
- jclass clazz,
- jmethodID methodID,
- va_list args);
- static jdouble CallNonvirtualDoubleMethodA(JNIEnv* env,
- jobject obj,
- jclass clazz,
- jmethodID methodID,
- jvalue* args);
-
- static void CallNonvirtualVoidMethod(JNIEnv* env,
- jobject obj,
- jclass clazz,
- jmethodID methodID,
- ...);
- static void CallNonvirtualVoidMethodV(JNIEnv* env,
- jobject obj,
- jclass clazz,
- jmethodID methodID,
- va_list args);
- static void CallNonvirtualVoidMethodA(JNIEnv* env,
- jobject obj,
- jclass clazz,
- jmethodID methodID,
- jvalue* args);
-
- static jfieldID GetFieldID(JNIEnv* env,
- jclass clazz,
- const char* name,
- const char* sig);
-
- static jobject GetObjectField(JNIEnv* env, jobject obj, jfieldID fieldID);
- static jboolean GetBooleanField(JNIEnv* env, jobject obj, jfieldID fieldID);
- static jbyte GetByteField(JNIEnv* env, jobject obj, jfieldID fieldID);
- static jchar GetCharField(JNIEnv* env, jobject obj, jfieldID fieldID);
- static jshort GetShortField(JNIEnv* env, jobject obj, jfieldID fieldID);
- static jint GetIntField(JNIEnv* env, jobject obj, jfieldID fieldID);
- static jlong GetLongField(JNIEnv* env, jobject obj, jfieldID fieldID);
- static jfloat GetFloatField(JNIEnv* env, jobject obj, jfieldID fieldID);
- static jdouble GetDoubleField(JNIEnv* env, jobject obj, jfieldID fieldID);
-
- static void SetObjectField(JNIEnv* env,
- jobject obj,
- jfieldID fieldID,
- jobject val);
- static void SetBooleanField(JNIEnv* env,
- jobject obj,
- jfieldID fieldID,
- jboolean val);
- static void SetByteField(JNIEnv* env,
- jobject obj,
- jfieldID fieldID,
- jbyte val);
- static void SetCharField(JNIEnv* env,
- jobject obj,
- jfieldID fieldID,
- jchar val);
- static void SetShortField(JNIEnv* env,
- jobject obj,
- jfieldID fieldID,
- jshort val);
- static void SetIntField(JNIEnv* env, jobject obj, jfieldID fieldID, jint val);
- static void SetLongField(JNIEnv* env,
- jobject obj,
- jfieldID fieldID,
- jlong val);
- static void SetFloatField(JNIEnv* env,
- jobject obj,
- jfieldID fieldID,
- jfloat val);
- static void SetDoubleField(JNIEnv* env,
- jobject obj,
- jfieldID fieldID,
- jdouble val);
-
- static jmethodID GetStaticMethodID(JNIEnv* env,
- jclass clazz,
- const char* name,
- const char* sig);
-
- static jobject CallStaticObjectMethod(JNIEnv* env,
- jclass clazz,
- jmethodID methodID,
- ...);
- static jobject CallStaticObjectMethodV(JNIEnv* env,
- jclass clazz,
- jmethodID methodID,
- va_list args);
- static jobject CallStaticObjectMethodA(JNIEnv* env,
- jclass clazz,
- jmethodID methodID,
- jvalue* args);
-
- static jboolean CallStaticBooleanMethod(JNIEnv* env,
- jclass clazz,
- jmethodID methodID,
- ...);
- static jboolean CallStaticBooleanMethodV(JNIEnv* env,
- jclass clazz,
- jmethodID methodID,
- va_list args);
- static jboolean CallStaticBooleanMethodA(JNIEnv* env,
- jclass clazz,
- jmethodID methodID,
- jvalue* args);
-
- static jbyte CallStaticByteMethod(JNIEnv* env,
- jclass clazz,
- jmethodID methodID,
- ...);
- static jbyte CallStaticByteMethodV(JNIEnv* env,
- jclass clazz,
- jmethodID methodID,
- va_list args);
- static jbyte CallStaticByteMethodA(JNIEnv* env,
- jclass clazz,
- jmethodID methodID,
- jvalue* args);
-
- static jchar CallStaticCharMethod(JNIEnv* env,
- jclass clazz,
- jmethodID methodID,
- ...);
- static jchar CallStaticCharMethodV(JNIEnv* env,
- jclass clazz,
- jmethodID methodID,
- va_list args);
- static jchar CallStaticCharMethodA(JNIEnv* env,
- jclass clazz,
- jmethodID methodID,
- jvalue* args);
-
- static jshort CallStaticShortMethod(JNIEnv* env,
- jclass clazz,
- jmethodID methodID,
- ...);
- static jshort CallStaticShortMethodV(JNIEnv* env,
- jclass clazz,
- jmethodID methodID,
- va_list args);
- static jshort CallStaticShortMethodA(JNIEnv* env,
- jclass clazz,
- jmethodID methodID,
- jvalue* args);
-
- static jint CallStaticIntMethod(JNIEnv* env,
- jclass clazz,
- jmethodID methodID,
- ...);
- static jint CallStaticIntMethodV(JNIEnv* env,
- jclass clazz,
- jmethodID methodID,
- va_list args);
- static jint CallStaticIntMethodA(JNIEnv* env,
- jclass clazz,
- jmethodID methodID,
- jvalue* args);
-
- static jlong CallStaticLongMethod(JNIEnv* env,
- jclass clazz,
- jmethodID methodID,
- ...);
- static jlong CallStaticLongMethodV(JNIEnv* env,
- jclass clazz,
- jmethodID methodID,
- va_list args);
- static jlong CallStaticLongMethodA(JNIEnv* env,
- jclass clazz,
- jmethodID methodID,
- jvalue* args);
-
- static jfloat CallStaticFloatMethod(JNIEnv* env,
- jclass clazz,
- jmethodID methodID,
- ...);
- static jfloat CallStaticFloatMethodV(JNIEnv* env,
- jclass clazz,
- jmethodID methodID,
- va_list args);
- static jfloat CallStaticFloatMethodA(JNIEnv* env,
- jclass clazz,
- jmethodID methodID,
- jvalue* args);
-
- static jdouble CallStaticDoubleMethod(JNIEnv* env,
- jclass clazz,
- jmethodID methodID,
- ...);
- static jdouble CallStaticDoubleMethodV(JNIEnv* env,
- jclass clazz,
- jmethodID methodID,
- va_list args);
- static jdouble CallStaticDoubleMethodA(JNIEnv* env,
- jclass clazz,
- jmethodID methodID,
- jvalue* args);
-
- static void CallStaticVoidMethod(JNIEnv* env,
- jclass cls,
- jmethodID methodID,
- ...);
- static void CallStaticVoidMethodV(JNIEnv* env,
- jclass cls,
- jmethodID methodID,
- va_list args);
- static void CallStaticVoidMethodA(JNIEnv* env,
- jclass cls,
- jmethodID methodID,
- jvalue* args);
-
- static jfieldID GetStaticFieldID(JNIEnv* env,
- jclass clazz,
- const char* name,
- const char* sig);
- static jobject GetStaticObjectField(JNIEnv* env,
- jclass clazz,
- jfieldID fieldID);
- static jboolean GetStaticBooleanField(JNIEnv* env,
- jclass clazz,
- jfieldID fieldID);
- static jbyte GetStaticByteField(JNIEnv* env, jclass clazz, jfieldID fieldID);
- static jchar GetStaticCharField(JNIEnv* env, jclass clazz, jfieldID fieldID);
- static jshort GetStaticShortField(JNIEnv* env,
- jclass clazz,
- jfieldID fieldID);
- static jint GetStaticIntField(JNIEnv* env, jclass clazz, jfieldID fieldID);
- static jlong GetStaticLongField(JNIEnv* env, jclass clazz, jfieldID fieldID);
- static jfloat GetStaticFloatField(JNIEnv* env,
- jclass clazz,
- jfieldID fieldID);
- static jdouble GetStaticDoubleField(JNIEnv* env,
- jclass clazz,
- jfieldID fieldID);
-
- static void SetStaticObjectField(JNIEnv* env,
- jclass clazz,
- jfieldID fieldID,
- jobject value);
- static void SetStaticBooleanField(JNIEnv* env,
- jclass clazz,
- jfieldID fieldID,
- jboolean value);
- static void SetStaticByteField(JNIEnv* env,
- jclass clazz,
- jfieldID fieldID,
- jbyte value);
- static void SetStaticCharField(JNIEnv* env,
- jclass clazz,
- jfieldID fieldID,
- jchar value);
- static void SetStaticShortField(JNIEnv* env,
- jclass clazz,
- jfieldID fieldID,
- jshort value);
- static void SetStaticIntField(JNIEnv* env,
- jclass clazz,
- jfieldID fieldID,
- jint value);
- static void SetStaticLongField(JNIEnv* env,
- jclass clazz,
- jfieldID fieldID,
- jlong value);
- static void SetStaticFloatField(JNIEnv* env,
- jclass clazz,
- jfieldID fieldID,
- jfloat value);
- static void SetStaticDoubleField(JNIEnv* env,
- jclass clazz,
- jfieldID fieldID,
- jdouble value);
-
- static jstring NewString(JNIEnv* env, const jchar* unicode, jsize len);
- static jsize GetStringLength(JNIEnv* env, jstring str);
- static const jchar* GetStringChars(JNIEnv* env,
- jstring str,
- jboolean* isCopy);
- static void ReleaseStringChars(JNIEnv* env, jstring str, const jchar* chars);
- static jstring NewStringUTF(JNIEnv* env, const char* utf);
- static jsize GetStringUTFLength(JNIEnv* env, jstring str);
- static const char* GetStringUTFChars(JNIEnv* env,
- jstring str,
- jboolean* isCopy);
- static void ReleaseStringUTFChars(JNIEnv* env,
- jstring str,
- const char* chars);
-
- static jsize GetArrayLength(JNIEnv* env, jarray array);
-
- static jobjectArray NewObjectArray(JNIEnv* env,
- jsize len,
- jclass clazz,
- jobject init);
- static jobject GetObjectArrayElement(JNIEnv* env,
- jobjectArray array,
- jsize index);
- static void SetObjectArrayElement(JNIEnv* env,
- jobjectArray array,
- jsize index,
- jobject val);
-
- static jbooleanArray NewBooleanArray(JNIEnv* env, jsize len);
- static jbyteArray NewByteArray(JNIEnv* env, jsize len);
- static jcharArray NewCharArray(JNIEnv* env, jsize len);
- static jshortArray NewShortArray(JNIEnv* env, jsize len);
- static jintArray NewIntArray(JNIEnv* env, jsize len);
- static jlongArray NewLongArray(JNIEnv* env, jsize len);
- static jfloatArray NewFloatArray(JNIEnv* env, jsize len);
- static jdoubleArray NewDoubleArray(JNIEnv* env, jsize len);
-
- static jboolean* GetBooleanArrayElements(JNIEnv* env,
- jbooleanArray array,
- jboolean* isCopy);
- static jbyte* GetByteArrayElements(JNIEnv* env,
- jbyteArray array,
- jboolean* isCopy);
- static jchar* GetCharArrayElements(JNIEnv* env,
- jcharArray array,
- jboolean* isCopy);
- static jshort* GetShortArrayElements(JNIEnv* env,
- jshortArray array,
- jboolean* isCopy);
- static jint* GetIntArrayElements(JNIEnv* env,
- jintArray array,
- jboolean* isCopy);
- static jlong* GetLongArrayElements(JNIEnv* env,
- jlongArray array,
- jboolean* isCopy);
- static jfloat* GetFloatArrayElements(JNIEnv* env,
- jfloatArray array,
- jboolean* isCopy);
- static jdouble* GetDoubleArrayElements(JNIEnv* env,
- jdoubleArray array,
- jboolean* isCopy);
-
- static void ReleaseBooleanArrayElements(JNIEnv* env,
- jbooleanArray array,
- jboolean* elems,
- jint mode);
- static void ReleaseByteArrayElements(JNIEnv* env,
- jbyteArray array,
- jbyte* elems,
- jint mode);
- static void ReleaseCharArrayElements(JNIEnv* env,
- jcharArray array,
- jchar* elems,
- jint mode);
- static void ReleaseShortArrayElements(JNIEnv* env,
- jshortArray array,
- jshort* elems,
- jint mode);
- static void ReleaseIntArrayElements(JNIEnv* env,
- jintArray array,
- jint* elems,
- jint mode);
- static void ReleaseLongArrayElements(JNIEnv* env,
- jlongArray array,
- jlong* elems,
- jint mode);
- static void ReleaseFloatArrayElements(JNIEnv* env,
- jfloatArray array,
- jfloat* elems,
- jint mode);
- static void ReleaseDoubleArrayElements(JNIEnv* env,
- jdoubleArray array,
- jdouble* elems,
- jint mode);
-
- static void GetBooleanArrayRegion(JNIEnv* env,
- jbooleanArray array,
- jsize start,
- jsize l,
- jboolean* buf);
- static void GetByteArrayRegion(JNIEnv* env,
- jbyteArray array,
- jsize start,
- jsize len,
- jbyte* buf);
- static void GetCharArrayRegion(JNIEnv* env,
- jcharArray array,
- jsize start,
- jsize len,
- jchar* buf);
- static void GetShortArrayRegion(JNIEnv* env,
- jshortArray array,
- jsize start,
- jsize len,
- jshort* buf);
- static void GetIntArrayRegion(JNIEnv* env,
- jintArray array,
- jsize start,
- jsize len,
- jint* buf);
- static void GetLongArrayRegion(JNIEnv* env,
- jlongArray array,
- jsize start,
- jsize len,
- jlong* buf);
- static void GetFloatArrayRegion(JNIEnv* env,
- jfloatArray array,
- jsize start,
- jsize len,
- jfloat* buf);
- static void GetDoubleArrayRegion(JNIEnv* env,
- jdoubleArray array,
- jsize start,
- jsize len,
- jdouble* buf);
-
- static void SetBooleanArrayRegion(JNIEnv* env,
- jbooleanArray array,
- jsize start,
- jsize l,
- const jboolean* buf);
- static void SetByteArrayRegion(JNIEnv* env,
- jbyteArray array,
- jsize start,
- jsize len,
- const jbyte* buf);
- static void SetCharArrayRegion(JNIEnv* env,
- jcharArray array,
- jsize start,
- jsize len,
- const jchar* buf);
- static void SetShortArrayRegion(JNIEnv* env,
- jshortArray array,
- jsize start,
- jsize len,
- const jshort* buf);
- static void SetIntArrayRegion(JNIEnv* env,
- jintArray array,
- jsize start,
- jsize len,
- const jint* buf);
- static void SetLongArrayRegion(JNIEnv* env,
- jlongArray array,
- jsize start,
- jsize len,
- const jlong* buf);
- static void SetFloatArrayRegion(JNIEnv* env,
- jfloatArray array,
- jsize start,
- jsize len,
- const jfloat* buf);
- static void SetDoubleArrayRegion(JNIEnv* env,
- jdoubleArray array,
- jsize start,
- jsize len,
- const jdouble* buf);
-
- static jint RegisterNatives(JNIEnv* env,
- jclass clazz,
- const JNINativeMethod* methods,
- jint nMethods);
- static jint UnregisterNatives(JNIEnv* env, jclass clazz);
-
- static jint MonitorEnter(JNIEnv* env, jobject obj);
- static jint MonitorExit(JNIEnv* env, jobject obj);
-
- static jint GetJavaVM(JNIEnv* env, JavaVM* *vm);
-
- static void GetStringRegion(JNIEnv* env,
- jstring str,
- jsize start,
- jsize len,
- jchar* buf);
- static void GetStringUTFRegion(JNIEnv* env,
- jstring str,
- jsize start,
- jsize len,
- char* buf);
-
- static void* GetPrimitiveArrayCritical(JNIEnv* env,
- jarray array,
- jboolean* isCopy);
- static void ReleasePrimitiveArrayCritical(JNIEnv* env,
- jarray array,
- void* carray,
- jint mode);
-
- static const jchar* GetStringCritical(JNIEnv* env,
- jstring s,
- jboolean* isCopy);
- static void ReleaseStringCritical(JNIEnv* env, jstring s, const jchar* cstr);
-
- static jweak NewWeakGlobalRef(JNIEnv* env, jobject obj);
- static void DeleteWeakGlobalRef(JNIEnv* env, jweak obj);
-
- static jboolean ExceptionCheck(JNIEnv* env);
-
- static jobject NewDirectByteBuffer(JNIEnv* env,
- void* address,
- jlong capacity);
- static void* GetDirectBufferAddress(JNIEnv* env, jobject buf);
- static jlong GetDirectBufferCapacity(JNIEnv* env, jobject buf);
-
- static jobjectRefType GetObjectRefType(JNIEnv* env, jobject obj);
-
- static struct JNINativeInterface native_interface_;
- DISALLOW_IMPLICIT_CONSTRUCTORS(JniNativeInterface);
+ // Used to help call synchronized native methods.
+ // TODO: make jni_compiler.cc do the indirection itself.
+ void (*MonitorEnterHelper)(JNIEnv*, jobject);
+ void (*MonitorExitHelper)(JNIEnv*, jobject);
};
class JniInvokeInterface {
diff --git a/src/runtime.cc b/src/runtime.cc
index 6d0dfd2..a02b09c 100644
--- a/src/runtime.cc
+++ b/src/runtime.cc
@@ -89,6 +89,19 @@
}
}
+DexFile* Open(const std::string& filename) {
+ if (filename.size() < 4) {
+ LOG(WARNING) << "Ignoring short classpath entry '" << filename << "'";
+ return NULL;
+ }
+ std::string suffix(filename.substr(filename.size() - 4));
+ if (suffix == ".zip" || suffix == ".jar" || suffix == ".apk") {
+ return DexFile::OpenZip(filename);
+ } else {
+ return DexFile::OpenFile(filename);
+ }
+}
+
void CreateBootClassPath(const Runtime::Options& options,
std::vector<DexFile*>* boot_class_path) {
CHECK(boot_class_path != NULL);
@@ -96,7 +109,7 @@
std::vector<std::string> parsed;
ParseClassPath(str, &parsed);
for (size_t i = 0; i < parsed.size(); ++i) {
- DexFile* dex_file = DexFile::OpenFile(parsed[i].c_str());
+ DexFile* dex_file = Open(parsed[i]);
if (dex_file != NULL) {
boot_class_path->push_back(dex_file);
}
@@ -136,12 +149,11 @@
return true;
}
-bool Runtime::AttachCurrentThread(const char* name, JniEnvironment** penv) {
+bool Runtime::AttachCurrentThread(const char* name, JNIEnv** penv) {
return Thread::Attach() != NULL;
}
-bool Runtime::AttachCurrentThreadAsDaemon(const char* name,
- JniEnvironment** penv) {
+bool Runtime::AttachCurrentThreadAsDaemon(const char* name, JNIEnv** penv) {
// TODO: do something different for daemon threads.
return Thread::Attach() != NULL;
}
diff --git a/src/runtime.h b/src/runtime.h
index 1a9661f..f04aefe 100644
--- a/src/runtime.h
+++ b/src/runtime.h
@@ -6,6 +6,7 @@
#include <vector>
#include <utility>
+#include "jni.h"
#include "globals.h"
#include "macros.h"
#include "stringpiece.h"
@@ -15,7 +16,6 @@
class ClassLinker;
class DexFile;
class Heap;
-class JniEnvironment;
class ThreadList;
class Runtime {
@@ -41,8 +41,8 @@
static void Abort(const char* file, int line);
// Attaches the current native thread to the runtime.
- bool AttachCurrentThread(const char* name, JniEnvironment** jni_env);
- bool AttachCurrentThreadAsDaemon(const char* name, JniEnvironment** jni_env);
+ bool AttachCurrentThread(const char* name, JNIEnv** jni_env);
+ bool AttachCurrentThreadAsDaemon(const char* name, JNIEnv** jni_env);
// Detaches the current native thread from the runtime.
bool DetachCurrentThread();
diff --git a/src/thread.h b/src/thread.h
index d0f6623..02b2f65 100644
--- a/src/thread.h
+++ b/src/thread.h
@@ -189,7 +189,7 @@
}
// JNI methods
- JniEnvironment* GetJniEnv() const {
+ JNIEnv* GetJniEnv() const {
return jni_env_;
}
@@ -240,9 +240,9 @@
void DecrementSuspendCount() { suspend_count_--; }
private:
- Thread() :
- id_(1234), top_shb_(NULL), exception_(NULL), suspend_count_(0) {
- jni_env_ = new JniEnvironment();
+ Thread()
+ : id_(1234), top_shb_(NULL), exception_(NULL), suspend_count_(0) {
+ jni_env_ = CreateJNIEnv();
}
~Thread() {
@@ -263,7 +263,7 @@
StackHandleBlock* top_shb_;
// Every thread may have an associated JNI environment
- JniEnvironment* jni_env_;
+ JNIEnv* jni_env_;
State state_;
diff --git a/src/zip_archive.cc b/src/zip_archive.cc
index 0303e6f..e44b855 100644
--- a/src/zip_archive.cc
+++ b/src/zip_archive.cc
@@ -342,7 +342,7 @@
read_amount = file_length;
}
- scoped_ptr<uint8_t> scan_buf(new uint8_t[read_amount]);
+ scoped_array<uint8_t> scan_buf(new uint8_t[read_amount]);
if (scan_buf == NULL) {
return false;
}
diff --git a/tools/art b/tools/art
new file mode 100755
index 0000000..ab252eb
--- /dev/null
+++ b/tools/art
@@ -0,0 +1,26 @@
+#!/bin/sh
+#
+# Copyright (C) 2011 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+mkdir -p /tmp/android-data/art-cache
+ANDROID_DATA=/tmp/android-data \
+ANDROID_ROOT=$ANDROID_BUILD_TOP/out/host/linux-x86 \
+LD_LIBRARY_PATH=$ANDROID_BUILD_TOP/out/host/linux-x86/lib \
+$ANDROID_BUILD_TOP/out/host/linux-x86/bin/aexecd \
+-Xbootclasspath\
+:$ANDROID_BUILD_TOP/out/host/linux-x86/framework/core-hostdex.jar\
+:$ANDROID_BUILD_TOP/out/host/linux-x86/framework/bouncycastle-hostdex.jar\
+:$ANDROID_BUILD_TOP/out/host/linux-x86/framework/apache-xml-hostdex.jar \
+$*