X-Git-Url: https://git.saurik.com/cycript.git/blobdiff_plain/24ffc58c2367143a1cad64e4340e0fb5e863637a..aaa29c28ae45afad21be2891d38744d68d3c907e:/Execute.cpp diff --git a/Execute.cpp b/Execute.cpp index 36c400a..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" @@ -517,8 +518,11 @@ const char *CYPoolCCYON(CYPool &pool, JSContextRef context, JSObjectRef object, if (CYIsStrictEqual(context, theory, practice)) { JSValueRef name(CYGetProperty(context, constructor, name_s)); - if (!JSValueIsUndefined(context, name)) - str << "new" << ' ' << CYPoolUTF8String(pool, context, CYJSString(context, name)); + if (!JSValueIsUndefined(context, name)) { + auto utf8(CYPoolUTF8String(pool, context, CYJSString(context, name))); + if (utf8 != "Object") + str << "new" << ' ' << utf8; + } } } @@ -767,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); @@ -856,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); } @@ -1329,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; @@ -1419,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)); @@ -1516,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); @@ -1862,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}, @@ -2116,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) @@ -2127,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; }