X-Git-Url: https://git.saurik.com/cycript.git/blobdiff_plain/3853f09957ea2fd44bdef8fe5805f7da7529de8a..97bec96b43b66ab78af95d2b6c6c24f0d0a8006a:/Java/Execute.cpp diff --git a/Java/Execute.cpp b/Java/Execute.cpp index ee2d2be..618be7c 100644 --- a/Java/Execute.cpp +++ b/Java/Execute.cpp @@ -190,6 +190,13 @@ struct CYJavaGlobal : { value.value_ = NULL; } + + template + CYJavaGlobal &operator =(const CYJavaRef &other) { + this->~CYJavaGlobal(); + new (this) CYJavaGlobal(other); + return *this; + } }; template @@ -345,6 +352,12 @@ struct CYJavaEnv { return {jni, _envcall(jni, FindClass(name))}; } + CYJavaLocal FindClass$(const char *name) const { + jclass value(jni->FindClass(name)); + jni->ExceptionClear(); + return {jni, value}; + } + CYJavaLocal GetObjectClass(jobject object) const { return {jni, _envcall(jni, GetObjectClass(object))}; } @@ -365,6 +378,10 @@ struct CYJavaEnv { return {jni, _envcall(jni, NewObjectA(_class, method, args))}; } + CYJavaLocal NewObjectArray(jsize length, jclass _class, jobject initial) const { + return {jni, _envcall(jni, NewObjectArray(length, _class, initial))}; + } + CYJavaLocal NewString(const jchar *data, jsize size) const { return {jni, _envcall(jni, NewString(data, size))}; } @@ -439,6 +456,24 @@ static CYJavaLocal CYCastJavaString(const CYJavaRef &value) { return jni.CallObjectMethod(value, Object$toString); } +static CYJavaLocal CYCastJavaString(const CYJavaEnv &jni, CYUTF16String value) { + return jni.NewString(value.data, value.size); +} + +static CYJavaLocal CYCastJavaString(const CYJavaEnv &jni, CYUTF8String value) { + // XXX: if there are no nulls then you can do this faster + CYPool pool; + return CYCastJavaString(jni, CYPoolUTF16String(pool, value)); +} + +static CYJavaLocal CYCastJavaString(const CYJavaEnv &jni, const char *value) { + return CYCastJavaString(jni, CYUTF8String(value)); +} + +static CYJavaLocal CYCastJavaString(const CYJavaEnv &jni, JSContextRef context, JSStringRef value) { + return CYCastJavaString(jni, CYCastUTF16String(value)); +} + static JSValueRef CYCastJSValue(JSContextRef context, const CYJavaRef &value); template @@ -459,6 +494,57 @@ JSValueRef CYJavaError::CastJSValue(JSContextRef context, const char *name) cons return CYCastJSValue(context, value_); } +struct CYJava : + CYRoot +{ + CYJavaGlobal loader_; + jmethodID ClassLoader$loadClass; + + CYJava() { + } + + bool Setup(JNIEnv *env) { + if (loader_) + return false; + + CYJavaEnv jni(env); + CYPool pool; + + auto ClassLoader$(jni.FindClass("java/lang/ClassLoader")); + ClassLoader$loadClass = jni.GetMethodID(ClassLoader$, "loadClass", "(Ljava/lang/String;)Ljava/lang/Class;"); + + auto ClassLoader$getSystemClassLoader(jni.GetStaticMethodID(ClassLoader$, "getSystemClassLoader", "()Ljava/lang/ClassLoader;")); + auto parent(jni.CallStaticObjectMethod(ClassLoader$, ClassLoader$getSystemClassLoader)); + + auto path(CYCastJavaString(jni, pool.strcat("file://", CYPoolLibraryPath(pool), "/libcycript.jar", NULL))); + + auto PathClassLoader$(jni.FindClass$("dalvik/system/PathClassLoader")); + if (PathClassLoader$) { + auto PathClassLoader$$init$(jni.GetMethodID(PathClassLoader$, "", "(Ljava/lang/String;Ljava/lang/ClassLoader;)V")); + loader_ = jni.NewObject(PathClassLoader$, PathClassLoader$$init$, path.get(), parent.get()); + } else { + auto URL$(jni.FindClass("java/net/URL")); + auto URL$$init$(jni.GetMethodID(URL$, "", "(Ljava/lang/String;)V")); + + auto URLClassLoader$(jni.FindClass("java/net/URLClassLoader")); + auto URLClassLoader$$init$(jni.GetMethodID(URLClassLoader$, "", "([Ljava/net/URL;Ljava/lang/ClassLoader;)V")); + + auto url(jni.NewObject(URL$, URL$$init$, path.get())); + auto urls(jni.NewObjectArray(1, URL$, url)); + // XXX: .cast().get() <- this is required :/ + loader_ = jni.NewObject(URLClassLoader$, URLClassLoader$$init$, urls.cast().get(), parent.get()); + } + + return true; + } + + CYJavaLocal LoadClass(const char *name) { + _assert(loader_); + CYJavaEnv jni(loader_); + return jni.CallObjectMethod(loader_, ClassLoader$loadClass, CYCastJavaString(jni, name).get()); + } +}; + static std::map Primitives_; static CYJavaPrimitive CYJavaGetPrimitive(JSContextRef context, const CYJavaRef &type, jmethodID Class$get$$Name) { @@ -515,23 +601,28 @@ typedef std::map CYJavaOverloads; struct CYJavaMethod : CYRoot { + CYUTF8String type_; + CYUTF8String name_; CYJavaOverloads overloads_; - CYJavaMethod(const CYJavaOverloads &overloads) : + CYJavaMethod(CYUTF8String type, CYUTF8String name, const CYJavaOverloads &overloads) : + type_(CYPoolUTF8String(*pool_, type)), + name_(CYPoolUTF8String(*pool_, name)), overloads_(overloads) { } }; -struct CYJavaStaticMethod : - CYRoot +struct CYJavaInstanceMethod : + CYJavaMethod { - CYJavaOverloads overloads_; + using CYJavaMethod::CYJavaMethod; +}; - CYJavaStaticMethod(const CYJavaOverloads &overloads) : - overloads_(overloads) - { - } +struct CYJavaStaticMethod : + CYJavaMethod +{ + using CYJavaMethod::CYJavaMethod; }; struct CYJavaClass : @@ -651,7 +742,9 @@ static JSValueRef CYCastJSValue(JSContextRef context, const CYJavaRef & return CYPrivate::Make(context, value.cast(), CYJavaGetPrimitive(context, component, Class$getName)); } - auto Wrapper$(jni.FindClass("Cycript$Wrapper")); + auto java(reinterpret_cast(JSObjectGetPrivate(CYGetCachedObject(context, CYJSString("Java"))))); + auto Wrapper$(java->LoadClass("Cycript$Wrapper")); + if (jni.IsSameObject(_class, Wrapper$)) { auto Wrapper$getProtect(jni.GetMethodID(Wrapper$, "getProtect", "()J")); auto &protect(*reinterpret_cast(jni.CallLongMethod(value, Wrapper$getProtect))); @@ -666,14 +759,6 @@ static _finline JSObjectRef CYCastJSObject(JSContextRef context, const CYJavaRef return CYCastJSObject(context, CYCastJSValue(context, value)); } -static CYJavaLocal CYCastJavaString(const CYJavaEnv &jni, JSContextRef context, CYUTF16String value) { - return jni.NewString(value.data, value.size); -} - -static CYJavaLocal CYCastJavaString(const CYJavaEnv &jni, JSContextRef context, JSStringRef value) { - return CYCastJavaString(jni, context, CYCastUTF16String(value)); -} - #define CYCastJava$(T, Type, jtype, Cast) \ _disused static CYJavaLocal CYCastJava ## Type(const CYJavaEnv &jni, JSContextRef context, JSValueRef value) { \ auto Type$(jni.FindClass("java/lang/" #Type)); \ @@ -706,7 +791,9 @@ static CYJavaLocal CYCastJavaObject(const CYJavaEnv &jni, JSContextRef if (CYJavaObject *internal = CYGetJavaObject(context, value)) return internal->value_; - auto Wrapper$(jni.FindClass("Cycript$Wrapper")); + auto java(reinterpret_cast(JSObjectGetPrivate(CYGetCachedObject(context, CYJSString("Java"))))); + auto Wrapper$(java->LoadClass("Cycript$Wrapper")); + auto Wrapper$$init$(jni.GetMethodID(Wrapper$, "", "(J)V")); CYProtect *protect(new CYProtect(context, value)); return jni.NewObject(Wrapper$, Wrapper$$init$, reinterpret_cast(protect)); @@ -743,7 +830,10 @@ static JSObjectRef CYGetJavaClass(JSContextRef context, const CYJavaRef auto Class$(jni.FindClass("java/lang/Class")); auto Class$getName(jni.GetMethodID(Class$, "getName", "()Ljava/lang/String;")); - CYJSString name(jni.CallObjectMethod(value, Class$getName)); + auto string(jni.CallObjectMethod(value, Class$getName)); + CYJavaUTF8String utf8(string); + CYJSString name(utf8); + JSValueRef cached(CYGetProperty(context, cy, name)); if (!JSValueIsUndefined(context, cached)) return CYCastJSObject(context, cached); @@ -848,12 +938,12 @@ static JSObjectRef CYGetJavaClass(JSContextRef context, const CYJavaRef for (const auto &entry : entries) { bool instance(entry.first.first); - CYJSString name(entry.first.second); + CYJSString method(entry.first.second); auto &overload(entry.second); if (instance) - CYSetProperty(context, prototype, name, CYPrivate::Make(context, overload), kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete); + CYSetProperty(context, prototype, method, CYPrivate::Make(context, utf8, entry.first.second.c_str(), overload), kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete); else - CYSetProperty(context, constructor, name, CYPrivate::Make(context, overload), kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete); + CYSetProperty(context, constructor, method, CYPrivate::Make(context, utf8, entry.first.second.c_str(), overload), kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete); } } @@ -937,8 +1027,8 @@ static bool CYCastJavaArguments(const CYJavaFrame &frame, const CYJavaShorty &sh return true; } -static JSValueRef JavaMethod_callAsFunction(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry { - auto internal(CYPrivate::Get(context, object)); +static JSValueRef JavaInstanceMethod_callAsFunction(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry { + auto internal(CYPrivate::Get(context, object)); CYJavaObject *self(CYGetJavaObject(context, _this)); _assert(self != NULL); CYJavaEnv jni(self->value_); @@ -1006,7 +1096,8 @@ static JSObjectRef JavaClass_callAsConstructor(JSContextRef context, JSObjectRef jclass _class(table->value_); if (table->interface_ && count == 1) { - auto Cycript$(jni.FindClass("Cycript")); + auto java(reinterpret_cast(JSObjectGetPrivate(CYGetCachedObject(context, CYJSString("Java"))))); + auto Cycript$(java->LoadClass("Cycript")); auto Cycript$Make(jni.GetStaticMethodID(Cycript$, "proxy", "(Ljava/lang/Class;LCycript$Wrapper;)Ljava/lang/Object;")); return CYCastJSObject(context, jni.CallObjectMethod(Cycript$, Cycript$Make, _class, CYCastJavaObject(jni, context, CYCastJSObject(context, arguments[0])).get())); } @@ -1186,12 +1277,22 @@ static JSValueRef JavaClass_callAsFunction_toCYON(JSContextRef context, JSObject } CYCatch(NULL) } static JSValueRef JavaMethod_callAsFunction_toCYON(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry { + auto internal(CYPrivate::Get(context, _this)); std::ostringstream cyon; - return CYCastJSValue(context, CYJSString(cyon.str())); -} CYCatch(NULL) } - -static JSValueRef JavaStaticMethod_callAsFunction_toCYON(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry { - std::ostringstream cyon; + if (false) + cyon << internal->type_ << "." << internal->name_; + else { + bool comma(false); + for (auto overload(internal->overloads_.begin()); overload != internal->overloads_.end(); ++overload) + for (auto signature(overload->second.begin()); signature != overload->second.end(); ++signature) { + if (comma) + cyon << std::endl; + else + comma = true; + auto string(CYCastJavaString(signature->reflected_)); + cyon << CYJavaUTF8String(string); + } + } return CYCastJSValue(context, CYJSString(cyon.str())); } CYCatch(NULL) } @@ -1371,14 +1472,8 @@ static JavaVM *CYGetJavaVM(JSContextRef context) { std::vector options; - { - std::ostringstream option; - option << "-Djava.class.path="; - option << CYPoolLibraryPath(pool) << "/libcycript.jar"; - if (const char *classpath = getenv("CLASSPATH")) - option << ':' << classpath; - options.push_back(JavaVMOption{pool.strdup(option.str().c_str()), NULL}); - } + if (const char *classpath = getenv("CLASSPATH")) + options.push_back(JavaVMOption{pool.strcat("-Djava.class.path=", classpath, NULL), NULL}); // To use libnativehelper to access JNI_GetCreatedJavaVMs, you need JniInvocation. // ...but there can only be one JniInvocation, and assuradely the other VM has it. @@ -1476,18 +1571,33 @@ static JavaVM *CYGetJavaVM(JSContextRef context) { static JNIEnv *GetJNI(JSContextRef context, JNIEnv *&env) { auto jvm(CYGetJavaVM(context)); _assert(jvm != NULL); - _jnicall(jvm->GetEnv(reinterpret_cast(&env), CYJavaVersion)); - CYJavaEnv jni(env); - // XXX: this happens once per stub :/ + switch (jvm->GetEnv(reinterpret_cast(&env), CYJavaVersion)) { + case JNI_EDETACHED: + _jnicall(jvm->AttachCurrentThreadAsDaemon( +#ifndef __ANDROID__ + reinterpret_cast +#endif + (&env), NULL)); + break; + case JNI_OK: + break; + default: + _assert(false); + } + + CYJavaEnv jni(env); - auto Cycript$(jni.FindClass("Cycript")); - jni.RegisterNatives(Cycript$, Cycript_, sizeof(Cycript_) / sizeof(Cycript_[0])); + auto java(reinterpret_cast(JSObjectGetPrivate(CYGetCachedObject(context, CYJSString("Java"))))); + if (java->Setup(jni)) { + auto Cycript$(java->LoadClass("Cycript")); + jni.RegisterNatives(Cycript$, Cycript_, sizeof(Cycript_) / sizeof(Cycript_[0])); - JSObjectRef java(CYGetCachedObject(context, CYJSString("Java"))); - JSValueRef arguments[1]; - arguments[0] = CYCastJSValue(context, CYJSString("setup")); - CYCallAsFunction(context, CYCastJSObject(context, CYGetProperty(context, java, CYJSString("emit"))), java, 1, arguments); + JSObjectRef java(CYGetCachedObject(context, CYJSString("Java"))); + JSValueRef arguments[1]; + arguments[0] = CYCastJSValue(context, CYJSString("setup")); + CYCallAsFunction(context, CYCastJSObject(context, CYGetProperty(context, java, CYJSString("emit"))), java, 1, arguments); + } return env; } @@ -1509,13 +1619,13 @@ static JSStaticValue JavaObject_staticValues[3] = { {NULL, NULL, NULL, 0} }; -static JSStaticFunction JavaMethod_staticFunctions[2] = { +static JSStaticFunction JavaInstanceMethod_staticFunctions[2] = { {"toCYON", &JavaMethod_callAsFunction_toCYON, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, {NULL, NULL, 0} }; static JSStaticFunction JavaStaticMethod_staticFunctions[2] = { - {"toCYON", &JavaStaticMethod_callAsFunction_toCYON, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, + {"toCYON", &JavaMethod_callAsFunction_toCYON, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, {NULL, NULL, 0} }; @@ -1533,6 +1643,12 @@ CYJavaForEachPrimitive JSClassDefinition definition; + definition = kJSClassDefinitionEmpty; + definition.attributes = kJSClassAttributeNoAutomaticPrototype; + definition.className = "Java"; + definition.finalize = &CYFinalize; + CYPrivate::Class_ = JSClassCreate(&definition); + definition = kJSClassDefinitionEmpty; definition.className = "JavaClass"; definition.staticValues = JavaClass_staticValues; @@ -1553,16 +1669,21 @@ CYJavaForEachPrimitive definition = kJSClassDefinitionEmpty; definition.className = "JavaMethod"; - definition.staticFunctions = JavaMethod_staticFunctions; - definition.callAsFunction = &JavaMethod_callAsFunction; definition.finalize = &CYFinalize; CYPrivate::Class_ = JSClassCreate(&definition); + definition = kJSClassDefinitionEmpty; + definition.className = "JavaInstanceMethod"; + definition.parentClass = CYPrivate::Class_; + definition.staticFunctions = JavaInstanceMethod_staticFunctions; + definition.callAsFunction = &JavaInstanceMethod_callAsFunction; + CYPrivate::Class_ = JSClassCreate(&definition); + definition = kJSClassDefinitionEmpty; definition.className = "JavaStaticMethod"; + definition.parentClass = CYPrivate::Class_; definition.staticFunctions = JavaStaticMethod_staticFunctions; definition.callAsFunction = &JavaStaticMethod_callAsFunction; - definition.finalize = &CYFinalize; CYPrivate::Class_ = JSClassCreate(&definition); definition = kJSClassDefinitionEmpty; @@ -1605,7 +1726,7 @@ void CYJava_SetupContext(JSContextRef context) { JSObjectRef all(CYCastJSObject(context, CYGetProperty(context, cycript, CYJSString("all")))); //JSObjectRef alls(CYCastJSObject(context, CYGetProperty(context, cycript, CYJSString("alls")))); - JSObjectRef Java(JSObjectMake(context, NULL, NULL)); + JSObjectRef Java(CYPrivate::Make(context)); CYSetProperty(context, cycript, CYJSString("Java"), Java); CYSetProperty(context, cy, CYJSString("Java"), Java);