X-Git-Url: https://git.saurik.com/cycript.git/blobdiff_plain/436a877be73ebe14fecd3ef0e9b7dd6b854d2e3b..840966082c867decd624b074661e31945193abea:/Execute.cpp diff --git a/Execute.cpp b/Execute.cpp index b8978db..527d2cc 100644 --- a/Execute.cpp +++ b/Execute.cpp @@ -41,6 +41,7 @@ #include "sig/parse.hpp" #include "sig/ffi_type.hpp" +#include "Bridge.hpp" #include "Code.hpp" #include "Decode.hpp" #include "Error.hpp" @@ -184,6 +185,7 @@ JSClassRef Functor_; static JSClassRef Global_; JSStringRef Array_s; +JSStringRef constructor_s; JSStringRef cy_s; JSStringRef cyi_s; JSStringRef cyt_s; @@ -335,6 +337,11 @@ CYCastJSValue_(unsigned long int) CYCastJSValue_(signed long long int) CYCastJSValue_(unsigned long long int) +#ifdef __SIZEOF_INT128__ +CYCastJSValue_(signed __int128) +CYCastJSValue_(unsigned __int128) +#endif + JSValueRef CYJSUndefined(JSContextRef context) { return JSValueMakeUndefined(context); } @@ -503,6 +510,22 @@ const char *CYPoolCCYON(CYPool &pool, JSContextRef context, JSObjectRef object, std::ostringstream str; + JSValueRef value(CYGetProperty(context, object, constructor_s)); + if (JSValueIsObject(context, value)) { + JSObjectRef constructor(CYCastJSObject(context, value)); + JSValueRef theory(CYGetProperty(context, constructor, prototype_s)); + JSValueRef practice(JSObjectGetPrototype(context, object)); + + if (CYIsStrictEqual(context, theory, practice)) { + JSValueRef name(CYGetProperty(context, constructor, name_s)); + if (!JSValueIsUndefined(context, name)) { + auto utf8(CYPoolUTF8String(pool, context, CYJSString(context, name))); + if (utf8 != "Object") + str << "new" << ' ' << utf8; + } + } + } + str << '{'; // XXX: this is, sadly, going to leak @@ -684,6 +707,11 @@ CYPoolFFI_(unsigned long int) CYPoolFFI_(unsigned long long int) CYPoolFFI_(unsigned short int) +#ifdef __SIZEOF_INT128__ +CYPoolFFI_(signed __int128) +CYPoolFFI_(unsigned __int128) +#endif + void Void::PoolFFI(CYPool *pool, JSContextRef context, ffi_type *ffi, void *data, JSValueRef value) const { _assert(false); } @@ -743,6 +771,10 @@ void Array::PoolFFI(CYPool *pool, JSContextRef context, ffi_type *ffi, void *dat CYArrayCopy(pool, context, base, size, type, ffi->elements[0], value, object); } +void Enum::PoolFFI(CYPool *pool, JSContextRef context, ffi_type *ffi, void *data, JSValueRef value) const { + return type.PoolFFI(pool, context, ffi, data, value); +} + void Aggregate::PoolFFI(CYPool *pool, JSContextRef context, ffi_type *ffi, void *data, JSValueRef value) const { _assert(!overlap); @@ -799,6 +831,11 @@ CYFromFFI_(unsigned long int) CYFromFFI_(unsigned long long int) CYFromFFI_(unsigned short int) +#ifdef __SIZEOF_INT128__ +CYFromFFI_(signed __int128) +CYFromFFI_(unsigned __int128) +#endif + JSValueRef Void::FromFFI(JSContextRef context, ffi_type *ffi, void *data, bool initialize, JSObjectRef owner) const { return CYJSUndefined(context); } @@ -827,6 +864,10 @@ JSValueRef Array::FromFFI(JSContextRef context, ffi_type *ffi, void *data, bool return CArray::Make(context, data, size, type, ffi->elements[0], context, owner); } +JSValueRef Enum::FromFFI(JSContextRef context, ffi_type *ffi, void *data, bool initialize, JSObjectRef owner) const { + return type.FromFFI(context, ffi, data, initialize, owner); +} + JSValueRef Aggregate::FromFFI(JSContextRef context, ffi_type *ffi, void *data, bool initialize, JSObjectRef owner) const { return Struct_privateData::Make(context, data, *this, ffi, context, owner); } @@ -1300,14 +1341,37 @@ static JSValueRef All_getProperty(JSContextRef context, JSObjectRef object, JSSt CYThrow("%s", pool.strcat("error caching ", CYPoolCString(pool, context, property), ": ", error.PoolCString(pool), NULL)); } - JSValueRef result(_jsccall(JSEvaluateScript, context, CYJSString(parsed), NULL, NULL, 0)); - - if (flags == 0) { - JSObjectRef cache(CYGetCachedObject(context, CYJSString("cache"))); - CYSetProperty(context, cache, property, result); + JSObjectRef cache(CYGetCachedObject(context, CYJSString("cache"))); + + JSObjectRef stub; + if (flags == CYBridgeType) { + stub = CYMakeType(context, sig::Void()); + CYSetProperty(context, cache, property, stub); + } else + stub = NULL; + + JSValueRef value(_jsccall(JSEvaluateScript, context, CYJSString(parsed), NULL, NULL, 0)); + + switch (flags) { + case CYBridgeVoid: { + } break; + + case CYBridgeHold: { + CYSetProperty(context, cache, property, value); + } break; + + case CYBridgeType: { + JSObjectRef swap(CYCastJSObject(context, value)); + void *source(JSObjectGetPrivate(swap)); + _assert(source != NULL); + void *target(JSObjectGetPrivate(stub)); + _assert(JSObjectSetPrivate(swap, target)); + _assert(JSObjectSetPrivate(stub, source)); + value = stub; + } break; } - return result; + return value; } return NULL; @@ -1390,10 +1454,22 @@ static JSObjectRef Type_new(JSContextRef context, JSObjectRef object, size_t cou if (false) { } else if (count == 1) { - const char *encoding(CYPoolCString(pool, context, arguments[0])); - sig::Signature signature; - sig::Parse(pool, &signature, encoding, &Structor_); - return CYMakeType(context, *signature.elements[0].type); + switch (JSValueGetType(context, arguments[0])) { + case kJSTypeString: { + const char *encoding(CYPoolCString(pool, context, arguments[0])); + sig::Signature signature; + sig::Parse(pool, &signature, encoding, &Structor_); + return CYMakeType(context, *signature.elements[0].type); + } break; + + case kJSTypeObject: { + // XXX: accept a set of enum constants and /guess/ at their size + _assert(false); + } break; + + default: + throw CYJSError(context, "incorrect kind of argument to new Type"); + } } else if (count == 2) { JSObjectRef types(CYCastJSObject(context, arguments[0])); size_t count(CYArrayLength(context, types)); @@ -1487,6 +1563,37 @@ static JSValueRef Type_callAsFunction_constant(JSContextRef context, JSObjectRef return CYMakeType(context, *type); } CYCatch(NULL) } +static JSValueRef Type_callAsFunction_enumFor(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry { + if (count != 1) + throw CYJSError(context, "incorrect number of arguments to Type.enumFor"); + Type_privateData *internal(reinterpret_cast(JSObjectGetPrivate(_this))); + + CYPool pool; + + JSObjectRef constants(CYCastJSObject(context, arguments[0])); + + // XXX: this is, sadly, going to leak + JSPropertyNameArrayRef names(JSObjectCopyPropertyNames(context, constants)); + + size_t count(JSPropertyNameArrayGetCount(names)); + + sig::Enum type(*internal->type_, count); + type.constants = new(pool) sig::Constant[count]; + + for (size_t index(0); index != count; ++index) { + JSStringRef name(JSPropertyNameArrayGetNameAtIndex(names, index)); + JSValueRef value(CYGetProperty(context, constants, name)); + _assert(JSValueGetType(context, value) == kJSTypeNumber); + CYUTF8String string(CYPoolUTF8String(pool, context, name)); + type.constants[index].name = string.data; + type.constants[index].value = CYCastDouble(context, value); + } + + JSPropertyNameArrayRelease(names); + + return CYMakeType(context, type); +} CYCatch(NULL) } + static JSValueRef Type_callAsFunction_functionWith(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { bool variadic(count != 0 && JSValueIsNull(context, arguments[count - 1])); sig::Function type(variadic); @@ -1522,10 +1629,11 @@ static JSValueRef Type_callAsFunction(JSContextRef context, JSObjectRef object, return CYMakeFunctor(context, arguments[0], function->variadic, function->signature); CYPool pool; + sig::Type *type(internal->type_); ffi_type *ffi(internal->GetFFI()); - void *data(pool.malloc(ffi->size, ffi->alignment)); + type->PoolFFI(&pool, context, ffi, data, arguments[0]); JSValueRef value(type->FromFFI(context, ffi, data)); @@ -1539,15 +1647,22 @@ static JSValueRef Type_callAsFunction(JSContextRef context, JSObjectRef object, } CYCatch(NULL) } static JSObjectRef Type_callAsConstructor(JSContextRef context, JSObjectRef object, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry { - if (count != 0) + if (count > 1) throw CYJSError(context, "incorrect number of arguments to Type allocator"); Type_privateData *internal(reinterpret_cast(JSObjectGetPrivate(object))); JSObjectRef pointer(CYMakePointer(context, NULL, *internal->type_, NULL, NULL)); Pointer *value(reinterpret_cast(JSObjectGetPrivate(pointer))); + + sig::Type *type(internal->type_); ffi_type *ffi(internal->GetFFI()); value->value_ = value->pool_->malloc(ffi->size, ffi->alignment); - memset(value->value_, 0, ffi->size); + + if (count == 0) + memset(value->value_, 0, ffi->size); + else + type->PoolFFI(value->pool_, context, ffi, value->value_, arguments[0]); + return pointer; } CYCatch(NULL) } @@ -1825,10 +1940,11 @@ static JSStaticValue Type_staticValues[4] = { {NULL, NULL, NULL, 0} }; -static JSStaticFunction Type_staticFunctions[9] = { +static JSStaticFunction Type_staticFunctions[10] = { {"arrayOf", &Type_callAsFunction_arrayOf, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, {"blockWith", &Type_callAsFunction_blockWith, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, {"constant", &Type_callAsFunction_constant, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, + {"enumFor", &Type_callAsFunction_enumFor, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, {"functionWith", &Type_callAsFunction_functionWith, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, {"pointerTo", &Type_callAsFunction_pointerTo, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, {"withName", &Type_callAsFunction_withName, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, @@ -2011,6 +2127,7 @@ void CYInitializeDynamic() { Global_ = JSClassCreate(&definition); Array_s = JSStringCreateWithUTF8CString("Array"); + constructor_s = JSStringCreateWithUTF8CString("constructor"); cy_s = JSStringCreateWithUTF8CString("$cy"); cyi_s = JSStringCreateWithUTF8CString("$cyi"); cyt_s = JSStringCreateWithUTF8CString("$cyt"); @@ -2078,10 +2195,35 @@ JSGlobalContextRef CYGetJSContext(JSContextRef context) { return reinterpret_cast(JSObjectGetPrivate(CYCastJSObject(context, CYGetProperty(context, CYGetGlobalObject(context), cy_s))))->context_; } -const char *CYPoolLibraryPath(CYPool &pool) { +#ifdef __ANDROID__ +char *CYPoolLibraryPath_(CYPool &pool) { + FILE *maps(fopen("/proc/self/maps", "r")); + struct F { FILE *f; F(FILE *f) : f(f) {} + ~F() { fclose(f); } } f(maps); + + size_t function(reinterpret_cast(&CYPoolLibraryPath)); + + for (;;) { + size_t start; size_t end; char flags[8]; unsigned long long offset; + int major; int minor; unsigned long long inode; char file[1024]; + int count(fscanf(maps, "%zx-%zx %7s %llx %x:%x %llu%[ ]%1024[^\n]\n", + &start, &end, flags, &offset, &major, &minor, &inode, file, file)); + if (count < 8) break; else if (start <= function && function < end) + return pool.strdup(file); + } + + _assert(false); +} +#else +char *CYPoolLibraryPath_(CYPool &pool) { Dl_info addr; _assert(dladdr(reinterpret_cast(&CYPoolLibraryPath), &addr) != 0); - char *lib(pool.strdup(addr.dli_fname)); + return pool.strdup(addr.dli_fname); +} +#endif + +const char *CYPoolLibraryPath(CYPool &pool) { + char *lib(CYPoolLibraryPath_(pool)); char *slash(strrchr(lib, '/')); if (slash == NULL) @@ -2089,8 +2231,11 @@ const char *CYPoolLibraryPath(CYPool &pool) { *slash = '\0'; slash = strrchr(lib, '/'); - if (slash != NULL && strcmp(slash, "/.libs") == 0) - *slash = '\0'; + if (slash != NULL) { + if (strcmp(slash, "/.libs") == 0) + *slash = '\0'; + } else if (strcmp(lib, ".libs") == 0) + return "."; return lib; } @@ -2314,6 +2459,11 @@ extern "C" void CYSetupContext(JSGlobalContextRef context) { CYSetProperty(context, cache, CYJSString("ulong"), CYMakeType(context, sig::Primitive()), kJSPropertyAttributeDontEnum); CYSetProperty(context, cache, CYJSString("ulonglong"), CYMakeType(context, sig::Primitive()), kJSPropertyAttributeDontEnum); +#ifdef __SIZEOF_INT128__ + CYSetProperty(context, cache, CYJSString("int128"), CYMakeType(context, sig::Primitive<__int128>()), kJSPropertyAttributeDontEnum); + CYSetProperty(context, cache, CYJSString("uint128"), CYMakeType(context, sig::Primitive()), kJSPropertyAttributeDontEnum); +#endif + CYSetProperty(context, cache, CYJSString("float"), CYMakeType(context, sig::Primitive()), kJSPropertyAttributeDontEnum); CYSetProperty(context, cache, CYJSString("double"), CYMakeType(context, sig::Primitive()), kJSPropertyAttributeDontEnum);