{
value.value_ = NULL;
}
+
+ template <typename Other_>
+ CYJavaGlobal &operator =(const CYJavaRef<Other_> &other) {
+ this->~CYJavaGlobal();
+ new (this) CYJavaGlobal(other);
+ return *this;
+ }
};
template <typename Value_>
public CYUTF8String
{
private:
- const CYJavaRef<jstring> *value_;
+ const CYJavaRef<jstring> &value_;
public:
CYJavaUTF8String(const CYJavaRef<jstring> &value) :
- value_(&value)
+ value_(value)
{
_assert(value);
JNIEnv *jni(value.jni());
data = jni->GetStringUTFChars(value, NULL);
}
- CYJavaUTF8String(const CYJavaRef<jobject> &value) :
- CYJavaUTF8String(CYCastJavaString(value))
- {
- }
+ CYJavaUTF8String(CYJavaRef<jstring> &&) = delete;
~CYJavaUTF8String() {
- if (value_ != NULL) {
- JNIEnv *jni(value_->jni());
- jni->ReleaseStringUTFChars(*value_, data);
- }
+ JNIEnv *jni(value_.jni());
+ jni->ReleaseStringUTFChars(value_, data);
}
CYJavaUTF8String(const CYJavaUTF8String &) = delete;
-
- CYJavaUTF8String(CYJavaUTF8String &&rhs) :
- value_(rhs.value_)
- {
- rhs.value_ = NULL;
- }
};
CYJavaUTF8String CYCastUTF8String(const CYJavaRef<jstring> &value) {
- return CYJavaUTF8String(value);
+ return {value};
}
JSStringRef CYCopyJSString(const CYJavaRef<jstring> &value) {
}
virtual const char *PoolCString(CYPool &pool) const {
- return CYPoolCString(pool, CYJavaUTF8String(value_.cast<jobject>()));
+ auto string(CYCastJavaString(value_.cast<jobject>()));
+ return CYPoolCString(pool, CYJavaUTF8String(string));
}
virtual JSValueRef CastJSValue(JSContextRef context, const char *name) const;
return {jni, _envcall(jni, FindClass(name))};
}
+ CYJavaLocal<jclass> FindClass$(const char *name) const {
+ jclass value(jni->FindClass(name));
+ jni->ExceptionClear();
+ return {jni, value};
+ }
+
CYJavaLocal<jclass> GetObjectClass(jobject object) const {
return {jni, _envcall(jni, GetObjectClass(object))};
}
return {jni, _envcall(jni, NewObjectA(_class, method, args))};
}
+ CYJavaLocal<jobjectArray> NewObjectArray(jsize length, jclass _class, jobject initial) const {
+ return {jni, _envcall(jni, NewObjectArray(length, _class, initial))};
+ }
+
CYJavaLocal<jstring> NewString(const jchar *data, jsize size) const {
return {jni, _envcall(jni, NewString(data, size))};
}
return jni.CallObjectMethod<jstring>(value, Object$toString);
}
+static CYJavaLocal<jstring> CYCastJavaString(const CYJavaEnv &jni, CYUTF16String value) {
+ return jni.NewString(value.data, value.size);
+}
+
+static CYJavaLocal<jstring> 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<jstring> CYCastJavaString(const CYJavaEnv &jni, const char *value) {
+ return CYCastJavaString(jni, CYUTF8String(value));
+}
+
+static CYJavaLocal<jstring> CYCastJavaString(const CYJavaEnv &jni, JSContextRef context, JSStringRef value) {
+ return CYCastJavaString(jni, CYCastUTF16String(value));
+}
+
static JSValueRef CYCastJSValue(JSContextRef context, const CYJavaRef<jobject> &value);
template <typename Other_>
return CYCastJSValue(context, value_);
}
+struct CYJava :
+ CYRoot
+{
+ CYJavaGlobal<jobject> 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<jobject>(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$, "<init>", "(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$, "<init>", "(Ljava/lang/String;)V"));
+
+ auto URLClassLoader$(jni.FindClass("java/net/URLClassLoader"));
+ auto URLClassLoader$$init$(jni.GetMethodID(URLClassLoader$, "<init>", "([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<jobject>().get(), parent.get());
+ }
+
+ return true;
+ }
+
+ CYJavaLocal<jclass> LoadClass(const char *name) {
+ _assert(loader_);
+ CYJavaEnv jni(loader_);
+ return jni.CallObjectMethod<jclass>(loader_, ClassLoader$loadClass, CYCastJavaString(jni, name).get());
+ }
+};
+
static std::map<std::string, CYJavaPrimitive> Primitives_;
static CYJavaPrimitive CYJavaGetPrimitive(JSContextRef context, const CYJavaRef<jclass> &type, jmethodID Class$get$$Name) {
{
}
- CYJavaSignature(unsigned count) :
- shorty_(count)
- {
- }
-
+ // XXX: the shorty doesn't store enough information
bool operator <(const CYJavaSignature &rhs) const {
- return shorty_.size() < rhs.shorty_.size();
+ return shorty_ < rhs.shorty_;
}
};
-typedef std::multiset<CYJavaSignature> CYJavaOverload;
+typedef std::set<CYJavaSignature> CYJavaOverload;
+typedef std::map<unsigned, CYJavaOverload> CYJavaOverloads;
struct CYJavaMethod :
CYRoot
{
- CYJavaOverload overload_;
-
- CYJavaMethod(const CYJavaOverload &overload) :
- overload_(overload)
+ CYUTF8String type_;
+ CYUTF8String name_;
+ 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
{
- CYJavaOverload overload_;
+ using CYJavaMethod::CYJavaMethod;
+};
- CYJavaStaticMethod(const CYJavaOverload &overload) :
- overload_(overload)
- {
- }
+struct CYJavaStaticMethod :
+ CYJavaMethod
+{
+ using CYJavaMethod::CYJavaMethod;
};
struct CYJavaClass :
CYJavaFieldMap static_;
CYJavaFieldMap instance_;
- CYJavaOverload overload_;
+ CYJavaOverloads overloads_;
CYJavaClass(const CYJavaRef<jclass> &value, bool interface) :
value_(value),
return CYPrivate<CYJavaArray>::Make(context, value.cast<jarray>(), CYJavaGetPrimitive(context, component, Class$getName));
}
- auto Wrapper$(jni.FindClass("Cycript$Wrapper"));
+ auto java(reinterpret_cast<CYJava *>(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<CYProtect *>(jni.CallLongMethod(value, Wrapper$getProtect)));
return CYCastJSObject(context, CYCastJSValue(context, value));
}
-static CYJavaLocal<jstring> CYCastJavaString(const CYJavaEnv &jni, JSContextRef context, CYUTF16String value) {
- return jni.NewString(value.data, value.size);
-}
-
-static CYJavaLocal<jstring> CYCastJavaString(const CYJavaEnv &jni, JSContextRef context, JSStringRef value) {
- return CYCastJavaString(jni, context, CYCastUTF16String(value));
-}
-
#define CYCastJava$(T, Type, jtype, Cast) \
_disused static CYJavaLocal<jobject> CYCastJava ## Type(const CYJavaEnv &jni, JSContextRef context, JSValueRef value) { \
auto Type$(jni.FindClass("java/lang/" #Type)); \
if (CYJavaObject *internal = CYGetJavaObject(context, value))
return internal->value_;
- auto Wrapper$(jni.FindClass("Cycript$Wrapper"));
+ auto java(reinterpret_cast<CYJava *>(JSObjectGetPrivate(CYGetCachedObject(context, CYJSString("Java")))));
+ auto Wrapper$(java->LoadClass("Cycript$Wrapper"));
+
auto Wrapper$$init$(jni.GetMethodID(Wrapper$, "<init>", "(J)V"));
CYProtect *protect(new CYProtect(context, value));
return jni.NewObject(Wrapper$, Wrapper$$init$, reinterpret_cast<jlong>(protect));
auto Class$(jni.FindClass("java/lang/Class"));
auto Class$getName(jni.GetMethodID(Class$, "getName", "()Ljava/lang/String;"));
- CYJSString name(jni.CallObjectMethod<jstring>(value, Class$getName));
+ auto string(jni.CallObjectMethod<jstring>(value, Class$getName));
+ CYJavaUTF8String utf8(string);
+ CYJSString name(utf8);
+
JSValueRef cached(CYGetProperty(context, cy, name));
if (!JSValueIsUndefined(context, cached))
return CYCastJSObject(context, cached);
auto modifiers(jni.CallIntMethod(field, Field$getModifiers));
auto instance(!jni.CallStaticBooleanMethod(Modifier$, Modifier$isStatic, modifiers));
auto &map(instance ? table->instance_ : table->static_);
- CYJavaUTF8String name(jni.CallObjectMethod<jstring>(field, Field$getName));
+ auto string(jni.CallObjectMethod<jstring>(field, Field$getName));
+ CYJavaUTF8String name(string);
auto id(jni.FromReflectedField(field));
auto type(jni.CallObjectMethod<jclass>(field, Field$getType));
map.insert(std::make_pair(std::string(name), CYJavaField{id, CYJavaGetPrimitive(context, type, Class$getName)}));
auto parameters(jni.CallObjectMethod<jobjectArray>(constructor, Constructor$getParameterTypes));
CYJavaShorty shorty(CYJavaGetShorty(context, parameters, Class$getName));
auto id(jni.FromReflectedMethod(constructor));
- table->overload_.insert(CYJavaSignature(constructor, id, CYJavaPrimitiveObject, shorty));
+ table->overloads_[shorty.size()].insert(CYJavaSignature(constructor, id, CYJavaPrimitiveObject, shorty));
}
- auto methods(jni.CallObjectMethod<jobjectArray>(value, Class$getDeclaredMethods));
+ std::map<std::pair<bool, std::string>, CYJavaOverloads> entries;
- std::map<std::pair<bool, std::string>, CYJavaOverload> entries;
+ bool base(false);
+ for (CYJavaLocal<jclass> prototype(value); prototype; prototype = jni.GetSuperclass(prototype)) {
+ auto methods(jni.CallObjectMethod<jobjectArray>(prototype, Class$getDeclaredMethods));
- for (jsize i(0), e(jni.GetArrayLength(methods)); i != e; ++i) {
- auto method(jni.GetObjectArrayElement<jobject>(methods, i));
- auto modifiers(jni.CallIntMethod(method, Method$getModifiers));
- auto instance(!jni.CallStaticBooleanMethod(Modifier$, Modifier$isStatic, modifiers));
- CYJavaUTF8String name(jni.CallObjectMethod<jstring>(method, Method$getName));
- auto parameters(jni.CallObjectMethod<jobjectArray>(method, Method$getParameterTypes));
- CYJavaShorty shorty(CYJavaGetShorty(context, parameters, Class$getName));
- auto type(jni.CallObjectMethod<jclass>(method, Method$getReturnType));
- auto primitive(CYJavaGetPrimitive(context, type, Class$getName));
- auto id(jni.FromReflectedMethod(method));
- entries[std::make_pair(instance, std::string(name))].insert(CYJavaSignature(method, id, primitive, shorty));
+ for (jsize i(0), e(jni.GetArrayLength(methods)); i != e; ++i) {
+ auto method(jni.GetObjectArrayElement<jobject>(methods, i));
+ auto modifiers(jni.CallIntMethod(method, Method$getModifiers));
+ auto instance(!jni.CallStaticBooleanMethod(Modifier$, Modifier$isStatic, modifiers));
+ auto string(jni.CallObjectMethod<jstring>(method, Method$getName));
+ CYJavaUTF8String name(string);
+
+ auto parameters(jni.CallObjectMethod<jobjectArray>(method, Method$getParameterTypes));
+ CYJavaShorty shorty(CYJavaGetShorty(context, parameters, Class$getName));
+
+ CYJavaOverload *overload;
+ if (!base)
+ overload = &entries[std::make_pair(instance, std::string(name))][shorty.size()];
+ else {
+ auto entry(entries.find(std::make_pair(instance, std::string(name))));
+ if (entry == entries.end())
+ continue;
+ overload = &entry->second[shorty.size()];
+ }
+
+ auto type(jni.CallObjectMethod<jclass>(method, Method$getReturnType));
+ auto primitive(CYJavaGetPrimitive(context, type, Class$getName));
+ auto id(jni.FromReflectedMethod(method));
+ overload->insert(CYJavaSignature(method, id, primitive, shorty));
+ }
+
+ base = true;
}
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<CYJavaMethod>::Make(context, overload), kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete);
+ CYSetProperty(context, prototype, method, CYPrivate<CYJavaInstanceMethod>::Make(context, utf8, entry.first.second.c_str(), overload), kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete);
else
- CYSetProperty(context, constructor, name, CYPrivate<CYJavaStaticMethod>::Make(context, overload), kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete);
+ CYSetProperty(context, constructor, method, CYPrivate<CYJavaStaticMethod>::Make(context, utf8, entry.first.second.c_str(), overload), kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete);
}
}
return true;
}
-static JSValueRef JavaMethod_callAsFunction(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
- auto internal(CYPrivate<CYJavaMethod>::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<CYJavaInstanceMethod>::Get(context, object));
CYJavaObject *self(CYGetJavaObject(context, _this));
_assert(self != NULL);
CYJavaEnv jni(self->value_);
- CYJavaSignature bound(count);
- for (auto overload(internal->overload_.lower_bound(bound)), e(internal->overload_.upper_bound(bound)); overload != e; ++overload) {
+ auto overload(internal->overloads_.find(count));
+ if (overload != internal->overloads_.end())
+ for (auto signature(overload->second.begin()); signature != overload->second.end(); ++signature) {
CYJavaFrame frame(jni, count + 16);
jvalue array[count];
- if (!CYCastJavaArguments(frame, overload->shorty_, context, arguments, array))
+ if (!CYCastJavaArguments(frame, signature->shorty_, context, arguments, array))
continue;
jvalue *values(array);
- switch (overload->primitive_) {
+ switch (signature->primitive_) {
case CYJavaPrimitiveObject:
- return CYCastJSValue(context, jni.CallObjectMethodA<jobject>(self->value_, overload->method_, values));
+ return CYCastJSValue(context, jni.CallObjectMethodA<jobject>(self->value_, signature->method_, values));
case CYJavaPrimitiveVoid:
- jni.CallVoidMethodA(self->value_, overload->method_, values);
+ jni.CallVoidMethodA(self->value_, signature->method_, values);
return CYJSUndefined(context);
#define CYJavaForEachPrimitive_(T, t, Typ, Type, type) \
case CYJavaPrimitive ## Type: \
- return CYJavaCastJSValue(context, jni.Call ## Typ ## MethodA(self->value_, overload->method_, values));
+ return CYJavaCastJSValue(context, jni.Call ## Typ ## MethodA(self->value_, signature->method_, values));
CYJavaForEachPrimitive
#undef CYJavaForEachPrimitive_
default: _assert(false);
CYJavaClass *table(CYGetJavaTable(context, _this));
CYJavaEnv jni(table->value_);
- CYJavaSignature bound(count);
- for (auto overload(internal->overload_.lower_bound(bound)), e(internal->overload_.upper_bound(bound)); overload != e; ++overload) {
+ auto overload(internal->overloads_.find(count));
+ if (overload != internal->overloads_.end())
+ for (auto signature(overload->second.begin()); signature != overload->second.end(); ++signature) {
CYJavaFrame frame(jni, count + 16);
jvalue array[count];
- if (!CYCastJavaArguments(frame, overload->shorty_, context, arguments, array))
+ if (!CYCastJavaArguments(frame, signature->shorty_, context, arguments, array))
continue;
jvalue *values(array);
- switch (overload->primitive_) {
+ switch (signature->primitive_) {
case CYJavaPrimitiveObject:
- return CYCastJSValue(context, jni.CallStaticObjectMethodA<jobject>(table->value_, overload->method_, values));
+ return CYCastJSValue(context, jni.CallStaticObjectMethodA<jobject>(table->value_, signature->method_, values));
case CYJavaPrimitiveVoid:
- jni.CallStaticVoidMethodA(table->value_, overload->method_, values);
+ jni.CallStaticVoidMethodA(table->value_, signature->method_, values);
return CYJSUndefined(context);
#define CYJavaForEachPrimitive_(T, t, Typ, Type, type) \
case CYJavaPrimitive ## Type: \
- return CYJavaCastJSValue(context, jni.CallStatic ## Typ ## MethodA(table->value_, overload->method_, values));
+ return CYJavaCastJSValue(context, jni.CallStatic ## Typ ## MethodA(table->value_, signature->method_, values));
CYJavaForEachPrimitive
#undef CYJavaForEachPrimitive_
default: _assert(false);
jclass _class(table->value_);
if (table->interface_ && count == 1) {
- auto Cycript$(jni.FindClass("Cycript"));
+ auto java(reinterpret_cast<CYJava *>(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<jobject>(Cycript$, Cycript$Make, _class, CYCastJavaObject(jni, context, CYCastJSObject(context, arguments[0])).get()));
}
- CYJavaSignature bound(count);
- for (auto overload(table->overload_.lower_bound(bound)), e(table->overload_.upper_bound(bound)); overload != e; ++overload) {
+ auto overload(table->overloads_.find(count));
+ if (overload != table->overloads_.end())
+ for (auto signature(overload->second.begin()); signature != overload->second.end(); ++signature) {
CYJavaFrame frame(jni, count + 16);
jvalue array[count];
- if (!CYCastJavaArguments(frame, overload->shorty_, context, arguments, array))
+ if (!CYCastJavaArguments(frame, signature->shorty_, context, arguments, array))
continue;
jvalue *values(array);
- auto object(jni.NewObjectA(_class, overload->method_, values));
+ auto object(jni.NewObjectA(_class, signature->method_, values));
return CYCastJSObject(context, object);
}
} 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<CYJavaMethod>::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) }
std::vector<JavaVMOption> 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.
static JNIEnv *GetJNI(JSContextRef context, JNIEnv *&env) {
auto jvm(CYGetJavaVM(context));
_assert(jvm != NULL);
- _jnicall(jvm->GetEnv(reinterpret_cast<void **>(&env), CYJavaVersion));
- CYJavaEnv jni(env);
- // XXX: this happens once per stub :/
+ switch (jvm->GetEnv(reinterpret_cast<void **>(&env), CYJavaVersion)) {
+ case JNI_EDETACHED:
+ _jnicall(jvm->AttachCurrentThreadAsDaemon(
+#ifndef __ANDROID__
+ reinterpret_cast<void **>
+#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<CYJava *>(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;
}
{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}
};
JSClassDefinition definition;
+ definition = kJSClassDefinitionEmpty;
+ definition.attributes = kJSClassAttributeNoAutomaticPrototype;
+ definition.className = "Java";
+ definition.finalize = &CYFinalize;
+ CYPrivate<CYJava>::Class_ = JSClassCreate(&definition);
+
definition = kJSClassDefinitionEmpty;
definition.className = "JavaClass";
definition.staticValues = JavaClass_staticValues;
definition = kJSClassDefinitionEmpty;
definition.className = "JavaMethod";
- definition.staticFunctions = JavaMethod_staticFunctions;
- definition.callAsFunction = &JavaMethod_callAsFunction;
definition.finalize = &CYFinalize;
CYPrivate<CYJavaMethod>::Class_ = JSClassCreate(&definition);
+ definition = kJSClassDefinitionEmpty;
+ definition.className = "JavaInstanceMethod";
+ definition.parentClass = CYPrivate<CYJavaMethod>::Class_;
+ definition.staticFunctions = JavaInstanceMethod_staticFunctions;
+ definition.callAsFunction = &JavaInstanceMethod_callAsFunction;
+ CYPrivate<CYJavaInstanceMethod>::Class_ = JSClassCreate(&definition);
+
definition = kJSClassDefinitionEmpty;
definition.className = "JavaStaticMethod";
+ definition.parentClass = CYPrivate<CYJavaMethod>::Class_;
definition.staticFunctions = JavaStaticMethod_staticFunctions;
definition.callAsFunction = &JavaStaticMethod_callAsFunction;
- definition.finalize = &CYFinalize;
CYPrivate<CYJavaStaticMethod>::Class_ = JSClassCreate(&definition);
definition = kJSClassDefinitionEmpty;
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<CYJava>::Make(context));
CYSetProperty(context, cycript, CYJSString("Java"), Java);
CYSetProperty(context, cy, CYJSString("Java"), Java);
projects / cycript.git / blobdiff