Try a new (safer) mechanism to get object private.

[cycript.git] / Execute.cpp

diff --git a/Execute.cpp b/Execute.cpp
index 57f3721580e7de2179b3c7118624e019b01ffb5b..375facf5db70d13ee812bf21696fff3e57aaa9c3 100644 (file)
--- a/Execute.cpp
+++ b/Execute.cpp
@@ -148,6 +148,14 @@ const char *CYPoolCString(CYPool &pool, CYUTF8String utf8) {
     return pool.strndup(utf8.data, utf8.size);
 }
 
     return pool.strndup(utf8.data, utf8.size);
 }
 

+CYUTF8String CYPoolUTF8String(CYPool &pool, CYUTF8String utf8) {
+    return {pool.strndup(utf8.data, utf8.size), utf8.size};
+}
+
+_visible CYUTF8String CYPoolUTF8String(CYPool &pool, const std::string &value) {
+    return {pool.strndup(value.data(), value.size()), value.size()};
+}
+

 CYUTF8String CYPoolUTF8String(CYPool &pool, JSContextRef context, JSStringRef value) {
     return CYPoolUTF8String(pool, CYCastUTF16String(value));
 }
 CYUTF8String CYPoolUTF8String(CYPool &pool, JSContextRef context, JSStringRef value) {
     return CYPoolUTF8String(pool, CYCastUTF16String(value));
 }


@@ -626,10 +634,13 @@ JSObjectRef CYMakePointer(JSContextRef context, void *pointer, const sig::Type &
     return Pointer::Make(context, pointer, type, context, owner);
 }
 
     return Pointer::Make(context, pointer, type, context, owner);
 }
 

-static JSObjectRef CYMakeFunctor(JSContextRef context, void (*function)(), bool variadic, const sig::Signature &signature) {
+static JSValueRef CYMakeFunctor(JSContextRef context, void (*function)(), bool variadic, const sig::Signature &signature) {
+    if (function == NULL)
+        return CYJSNull(context);

     return JSObjectMake(context, Functor_, new cy::Functor(function, variadic, signature));
 }
 
     return JSObjectMake(context, Functor_, new cy::Functor(function, variadic, signature));
 }
 

+// XXX: remove this, as it is really stupid

 static JSObjectRef CYMakeFunctor(JSContextRef context, const char *symbol, const char *encoding) {
     void (*function)()(reinterpret_cast<void (*)()>(CYCastSymbol(symbol)));
     if (function == NULL)
 static JSObjectRef CYMakeFunctor(JSContextRef context, const char *symbol, const char *encoding) {
     void (*function)()(reinterpret_cast<void (*)()>(CYCastSymbol(symbol)));
     if (function == NULL)


@@ -771,8 +782,13 @@ void Array::PoolFFI(CYPool *pool, JSContextRef context, ffi_type *ffi, void *dat
     CYArrayCopy(pool, context, base, size, type, ffi->elements[0], value, object);
 }
 
     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);
 void Aggregate::PoolFFI(CYPool *pool, JSContextRef context, ffi_type *ffi, void *data, JSValueRef value) const {
     _assert(!overlap);

+    _assert(signature.count != _not(size_t));

 
     size_t offset(0);
     uint8_t *base(reinterpret_cast<uint8_t *>(data));
 
     size_t offset(0);
     uint8_t *base(reinterpret_cast<uint8_t *>(data));


@@ -860,7 +876,13 @@ JSValueRef Array::FromFFI(JSContextRef context, ffi_type *ffi, void *data, bool
     return CArray::Make(context, data, size, type, ffi->elements[0], context, owner);
 }
 
     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 {
 JSValueRef Aggregate::FromFFI(JSContextRef context, ffi_type *ffi, void *data, bool initialize, JSObjectRef owner) const {

+    _assert(!overlap);
+    _assert(signature.count != _not(size_t));

     return Struct_privateData::Make(context, data, *this, ffi, context, owner);
 }
 
     return Struct_privateData::Make(context, data, *this, ffi, context, owner);
 }
 


@@ -948,7 +970,7 @@ JSObjectRef CYGetCachedObject(JSContextRef context, JSStringRef name) {
     return CYCastJSObject(context, CYGetCachedValue(context, name));
 }
 
     return CYCastJSObject(context, CYGetCachedValue(context, name));
 }
 

-static JSObjectRef CYMakeFunctor(JSContextRef context, JSValueRef value, bool variadic, const sig::Signature &signature) {
+static JSValueRef CYMakeFunctor(JSContextRef context, JSValueRef value, bool variadic, const sig::Signature &signature) {

     JSObjectRef Function(CYGetCachedObject(context, CYJSString("Function")));
 
     bool function(_jsccall(JSValueIsInstanceOfConstructor, context, value, Function));
     JSObjectRef Function(CYGetCachedObject(context, CYJSString("Function")));
 
     bool function(_jsccall(JSValueIsInstanceOfConstructor, context, value, Function));


@@ -966,7 +988,9 @@ static JSValueRef CString_getProperty(JSContextRef context, JSObjectRef object,
     CString *internal(reinterpret_cast<CString *>(JSObjectGetPrivate(object)));
 
     ssize_t offset;
     CString *internal(reinterpret_cast<CString *>(JSObjectGetPrivate(object)));
 
     ssize_t offset;

-    if (!CYGetOffset(pool, context, property, offset))
+    if (JSStringIsEqualToUTF8CString(property, "$cyi"))
+        offset = 0;
+    else if (!CYGetOffset(pool, context, property, offset))

         return NULL;
 
     return CYCastJSValue(context, CYJSString(CYUTF8String(&internal->value_[offset], 1)));
         return NULL;
 
     return CYCastJSValue(context, CYJSString(CYUTF8String(&internal->value_[offset], 1)));


@@ -977,7 +1001,9 @@ static bool CString_setProperty(JSContextRef context, JSObjectRef object, JSStri
     CString *internal(reinterpret_cast<CString *>(JSObjectGetPrivate(object)));
 
     ssize_t offset;
     CString *internal(reinterpret_cast<CString *>(JSObjectGetPrivate(object)));
 
     ssize_t offset;

-    if (!CYGetOffset(pool, context, property, offset))
+    if (JSStringIsEqualToUTF8CString(property, "$cyi"))
+        offset = 0;
+    else if (!CYGetOffset(pool, context, property, offset))

         return false;
 
     const char *data(CYPoolCString(pool, context, value));
         return false;
 
     const char *data(CYPoolCString(pool, context, value));


@@ -1226,7 +1252,7 @@ JSValueRef CYCallFunction(CYPool &pool, JSContextRef context, size_t setups, voi
         element.type->PoolFFI(&pool, context, ffi, values[index], arguments[index - setups]);
     }
 
         element.type->PoolFFI(&pool, context, ffi, values[index], arguments[index - setups]);
     }
 

-    uint8_t value[cif->rtype->size];
+    uint8_t *value(pool.malloc<uint8_t>(std::max<size_t>(cif->rtype->size, sizeof(ffi_arg)), std::max<size_t>(cif->rtype->alignment, alignof(ffi_arg))));

 
     void (*call)(CYPool &, JSContextRef, ffi_cif *, void (*)(), void *, void **) = &CYCallFunction;
     // XXX: this only supports one hook, but it is a bad idea anyway
 
     void (*call)(CYPool &, JSContextRef, ffi_cif *, void (*)(), void *, void **) = &CYCallFunction;
     // XXX: this only supports one hook, but it is a bad idea anyway


@@ -1446,10 +1472,22 @@ static JSObjectRef Type_new(JSContextRef context, JSObjectRef object, size_t cou
 
     if (false) {
     } else if (count == 1) {
 
     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));
     } else if (count == 2) {
         JSObjectRef types(CYCastJSObject(context, arguments[0]));
         size_t count(CYArrayLength(context, types));


@@ -1474,6 +1512,7 @@ static JSObjectRef Type_new(JSContextRef context, JSObjectRef object, size_t cou
             _assert(JSValueIsObjectOfClass(context, object, Type_privateData::Class_));
             Type_privateData *internal(reinterpret_cast<Type_privateData *>(JSObjectGetPrivate(object)));
             element.type = internal->type_;
             _assert(JSValueIsObjectOfClass(context, object, Type_privateData::Class_));
             Type_privateData *internal(reinterpret_cast<Type_privateData *>(JSObjectGetPrivate(object)));
             element.type = internal->type_;

+            _assert(element.type != NULL);

         }
 
         return CYMakeType(context, type);
         }
 
         return CYMakeType(context, type);


@@ -1543,6 +1582,37 @@ static JSValueRef Type_callAsFunction_constant(JSContextRef context, JSObjectRef
     return CYMakeType(context, *type);
 } CYCatch(NULL) }
 
     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<Type_privateData *>(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);
 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);


@@ -1615,6 +1685,7 @@ static JSObjectRef Type_callAsConstructor(JSContextRef context, JSObjectRef obje
     return pointer;
 } CYCatch(NULL) }
 
     return pointer;
 } CYCatch(NULL) }
 

+// XXX: I don't even think the user should be allowed to do this

 static JSObjectRef Functor_new(JSContextRef context, JSObjectRef object, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
     if (count != 2)
         throw CYJSError(context, "incorrect number of arguments to Functor constructor");
 static JSObjectRef Functor_new(JSContextRef context, JSObjectRef object, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
     if (count != 2)
         throw CYJSError(context, "incorrect number of arguments to Functor constructor");


@@ -1622,7 +1693,8 @@ static JSObjectRef Functor_new(JSContextRef context, JSObjectRef object, size_t
     const char *encoding(CYPoolCString(pool, context, arguments[1]));
     sig::Signature signature;
     sig::Parse(pool, &signature, encoding, &Structor_);
     const char *encoding(CYPoolCString(pool, context, arguments[1]));
     sig::Signature signature;
     sig::Parse(pool, &signature, encoding, &Structor_);

-    return CYMakeFunctor(context, arguments[0], false, signature);
+    // XXX: this can try to return null, and I guess then it just fails
+    return CYCastJSObject(context, CYMakeFunctor(context, arguments[0], false, signature));

 } CYCatch(NULL) }
 
 static JSValueRef CArray_callAsFunction_toPointer(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
 } CYCatch(NULL) }
 
 static JSValueRef CArray_callAsFunction_toPointer(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {


@@ -1675,6 +1747,8 @@ static JSValueRef Functor_callAsFunction_toCYON(JSContextRef context, JSObjectRe
     sig::Function function(internal->variadic_);
     sig::Copy(pool, function.signature, internal->signature_);
 
     sig::Function function(internal->variadic_);
     sig::Copy(pool, function.signature, internal->signature_);
 

+    CYString *name;
+

     auto typed(CYDecodeType(pool, &function)); {
         std::ostringstream str;
         Dl_info info;
     auto typed(CYDecodeType(pool, &function)); {
         std::ostringstream str;
         Dl_info info;


@@ -1689,14 +1763,14 @@ static JSValueRef Functor_callAsFunction_toCYON(JSContextRef context, JSObjectRe
                 str << "+0x" << std::hex << offset;
         }
 
                 str << "+0x" << std::hex << offset;
         }
 

-        typed->identifier_ = new(pool) CYIdentifier(pool.strdup(str.str().c_str()));
+        name = new(pool) CYString(pool.strdup(str.str().c_str()));

     }
 
     std::ostringstream str;
     CYOptions options;
     CYOutput output(*str.rdbuf(), options);
     output.pretty_ = true;
     }
 
     std::ostringstream str;
     CYOptions options;
     CYOutput output(*str.rdbuf(), options);
     output.pretty_ = true;

-    (new(pool) CYExternalExpression(new(pool) CYString("C"), typed))->Output(output, CYNoFlags);
+    (new(pool) CYExternalExpression(new(pool) CYString("C"), typed, name))->Output(output, CYNoFlags);

     return CYCastJSValue(context, CYJSString(str.str()));
 } CYCatch(NULL) }
 
     return CYCastJSValue(context, CYJSString(str.str()));
 } CYCatch(NULL) }
 


@@ -1889,10 +1963,11 @@ static JSStaticValue Type_staticValues[4] = {
     {NULL, NULL, NULL, 0}
 };
 
     {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},
     {"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},
     {"functionWith", &Type_callAsFunction_functionWith, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
     {"pointerTo", &Type_callAsFunction_pointerTo, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
     {"withName", &Type_callAsFunction_withName, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},


@@ -2192,17 +2267,43 @@ static JSValueRef require_callAsFunction(JSContextRef context, JSObjectRef objec
     _assert(count == 1);
     CYPool pool;
 
     _assert(count == 1);
     CYPool pool;
 

-    const char *name(CYPoolCString(pool, context, arguments[0]));
-    if (strchr(name, '/') == NULL && (
+    CYUTF8String name(CYPoolUTF8String(pool, context, CYJSString(context, arguments[0])));
+    if (memchr(name.data, '/', name.size) == NULL && (

 #ifdef __APPLE__
 #ifdef __APPLE__

-        dlopen(pool.strcat("/System/Library/Frameworks/", name, ".framework/", name, NULL), RTLD_LAZY | RTLD_GLOBAL) != NULL ||
-        dlopen(pool.strcat("/System/Library/PrivateFrameworks/", name, ".framework/", name, NULL), RTLD_LAZY | RTLD_GLOBAL) != NULL ||
+        dlopen(pool.strcat("/System/Library/Frameworks/", name.data, ".framework/", name.data, NULL), RTLD_LAZY | RTLD_GLOBAL) != NULL ||
+        dlopen(pool.strcat("/System/Library/PrivateFrameworks/", name.data, ".framework/", name.data, NULL), RTLD_LAZY | RTLD_GLOBAL) != NULL ||

 #endif
     false))
         return CYJSUndefined(context);
 
 #endif
     false))
         return CYJSUndefined(context);
 

-    JSObjectRef resolve(CYCastJSObject(context, CYGetProperty(context, object, CYJSString("resolve"))));
-    CYJSString path(context, CYCallAsFunction(context, resolve, NULL, 1, arguments));
+    CYJSString path;
+    CYUTF8String code;
+
+    sqlite3_stmt *statement;
+
+    _sqlcall(sqlite3_prepare(database_,
+        "select "
+            "\"module\".\"code\", "
+            "\"module\".\"flags\" "
+        "from \"module\" "
+        "where"
+            " \"module\".\"name\" = ?"
+        " limit 1"
+    , -1, &statement, NULL));
+
+    _sqlcall(sqlite3_bind_text(statement, 1, name.data, name.size, SQLITE_STATIC));
+
+    if (_sqlcall(sqlite3_step(statement)) != SQLITE_DONE) {
+        code.data = static_cast<const char *>(sqlite3_column_blob(statement, 0));
+        code.size = sqlite3_column_bytes(statement, 0);
+        path = CYJSString(name);
+        code = CYPoolUTF8String(pool, code);
+    } else {
+        JSObjectRef resolve(CYCastJSObject(context, CYGetProperty(context, object, CYJSString("resolve"))));
+        path = CYJSString(context, CYCallAsFunction(context, resolve, NULL, 1, arguments));
+    }
+
+    _sqlcall(sqlite3_finalize(statement));

 
     CYJSString property("exports");
 
 
     CYJSString property("exports");
 


@@ -2214,11 +2315,13 @@ static JSValueRef require_callAsFunction(JSContextRef context, JSObjectRef objec
         JSObjectRef module(CYCastJSObject(context, cache));
         result = CYGetProperty(context, module, property);
     } else {
         JSObjectRef module(CYCastJSObject(context, cache));
         result = CYGetProperty(context, module, property);
     } else {

-        CYUTF8String code(CYPoolFileUTF8String(pool, CYPoolCString(pool, context, path)));
-        _assert(code.data != NULL);
+        if (code.data == NULL) {
+            code = CYPoolFileUTF8String(pool, CYPoolCString(pool, context, path));
+            _assert(code.data != NULL);
+        }

 
 

-        size_t length(strlen(name));
-        if (length >= 5 && strcmp(name + length - 5, ".json") == 0) {
+        size_t length(name.size);
+        if (length >= 5 && strncmp(name.data + length - 5, ".json", 5) == 0) {

             JSObjectRef JSON(CYGetCachedObject(context, CYJSString("JSON")));
             JSObjectRef parse(CYCastJSObject(context, CYGetProperty(context, JSON, CYJSString("parse"))));
             JSValueRef arguments[1] = { CYCastJSValue(context, CYJSString(code)) };
             JSObjectRef JSON(CYGetCachedObject(context, CYJSString("JSON")));
             JSObjectRef parse(CYCastJSObject(context, CYGetProperty(context, JSON, CYJSString("parse"))));
             JSValueRef arguments[1] = { CYCastJSValue(context, CYJSString(code)) };