Move Cydget* to ObjectiveC and @throw exceptions.

[cycript.git] / ObjectiveC / Library.mm

diff --git a/ObjectiveC/Library.mm b/ObjectiveC/Library.mm
index bb62fc4a70997f41794b7e1616512c97818be226..b6410c7471507cddbd3e158379ab6861bcac5ca2 100644 (file)
--- a/ObjectiveC/Library.mm
+++ b/ObjectiveC/Library.mm
@@ -638,30 +638,46 @@ _finline bool CYJSValueIsInstanceOfCachedConstructor(JSContextRef context, JSVal
     return _jsccall(JSValueIsInstanceOfConstructor, context, value, CYGetCachedObject(context, cache));
 }
 
-NSObject *CYMakeBlock(void (*invoke)(), sig::Signature &signature) {
-    BlockLiteral *literal(reinterpret_cast<BlockLiteral *>(malloc(sizeof(BlockLiteral))));
+struct CYBlockDescriptor {
+    struct {
+        BlockDescriptor1 one_;
+        BlockDescriptor2 two_;
+        BlockDescriptor3 three_;
+    } d_;
+
+    Closure_privateData *internal_;
+};
 
-    struct Descriptor {
-        struct {
-            BlockDescriptor1 one_;
-            BlockDescriptor2 two_;
-            BlockDescriptor3 three_;
-        } d_;
+void CYDisposeBlock(BlockLiteral *literal) {
+    delete reinterpret_cast<CYBlockDescriptor *>(literal->descriptor)->internal_;
+}
 
-        CYPool pool_;
-    };
+static JSValueRef BlockAdapter_(JSContextRef context, size_t count, JSValueRef values[], JSObjectRef function) {
+    JSObjectRef _this(CYCastJSObject(context, values[0]));
+    return CYCallAsFunction(context, function, _this, count - 1, values + 1);
+}
+
+static void BlockClosure_(ffi_cif *cif, void *result, void **arguments, void *arg) {
+    CYExecuteClosure(cif, result, arguments, arg, &BlockAdapter_);
+}
+
+NSObject *CYMakeBlock(JSContextRef context, JSObjectRef function, sig::Signature &signature) {
+    BlockLiteral *literal(reinterpret_cast<BlockLiteral *>(malloc(sizeof(BlockLiteral))));
 
-    Descriptor *descriptor(new Descriptor);
+    CYBlockDescriptor *descriptor(new CYBlockDescriptor);
     memset(&descriptor->d_, 0, sizeof(descriptor->d_));
 
-    literal->isa = objc_getClass("__NSGlobalBlock__");
+    descriptor->internal_ = CYMakeFunctor_(context, function, signature, &BlockClosure_);
+    literal->invoke = reinterpret_cast<void (*)(void *, ...)>(descriptor->internal_->GetValue());
+
+    literal->isa = objc_getClass("__NSMallocBlock__");
     literal->flags = BLOCK_HAS_SIGNATURE | BLOCK_HAS_COPY_DISPOSE | BLOCK_IS_GLOBAL;
     literal->reserved = 0;
-    literal->invoke = reinterpret_cast<void (*)(void *, ...)>(invoke);
     literal->descriptor = descriptor;
 
     descriptor->d_.one_.size = sizeof(descriptor->d_);
-    descriptor->d_.three_.signature = sig::Unparse(descriptor->pool_, &signature);
+    descriptor->d_.two_.dispose_helper = &CYDisposeBlock;
+    descriptor->d_.three_.signature = sig::Unparse(*descriptor->internal_->pool_, &signature);
 
     return reinterpret_cast<NSObject *>(literal);
 }
@@ -672,11 +688,6 @@ NSObject *CYCastNSObject(CYPool *pool, JSContextRef context, JSObjectRef object)
         return internal->GetValue();
     }
 
-    if (JSValueIsObjectOfClass(context, object, Functor_)) {
-        cy::Functor *internal(reinterpret_cast<cy::Functor *>(JSObjectGetPrivate(object)));
-        return CYMakeBlock(internal->GetValue(), internal->signature_);
-    }
-
     bool array(CYJSValueIsInstanceOfCachedConstructor(context, object, Array_s));
     id value(array ? [CYJSArray alloc] : [CYJSObject alloc]);
     return CYPoolRelease(pool, [value initWithJSObject:object inContext:context]);
@@ -1452,12 +1463,32 @@ static void CYObjectiveC_CallFunction(JSContextRef context, ffi_cif *cif, void (
 } CYSadCatch() }
 
 static bool CYObjectiveC_PoolFFI(CYPool *pool, JSContextRef context, sig::Type *type, ffi_type *ffi, void *data, JSValueRef value) { CYSadTry {
+    // XXX: assigning to an indirect id * works for return values, but not for properties and fields
+
     switch (type->primitive) {
-        // XXX: do something epic about blocks
-        case sig::block_P:
+        case sig::block_P: {
+            _assert(type->data.signature.count != 0);
+            sig::Signature signature;
+            sig::Copy(*pool, signature, type->data.signature);
+
+            sig::Element *elements(new(*pool) sig::Element[++signature.count]);
+            elements[0] = signature.elements[0];
+            memcpy(elements + 2, signature.elements + 1, sizeof(sig::Element) * (signature.count - 2));
+            signature.elements = elements;
+
+            elements[1].name = NULL;
+            elements[1].type = new(*pool) sig::Type();
+            elements[1].offset = _not(size_t);
+
+            memset(elements[1].type, 0, sizeof(sig::Type));
+            elements[1].type->primitive = sig::object_P;
+
+            JSObjectRef function(CYCastJSObject(context, value));
+            *reinterpret_cast<id *>(data) = CYMakeBlock(context, function, signature);
+        } break;
+
         case sig::object_P:
         case sig::typename_P:
-            // XXX: this works for return values, but not for properties and fields
             *reinterpret_cast<id *>(data) = CYCastNSObject(pool, context, value);
         break;
 
@@ -1549,9 +1580,12 @@ static JSObjectRef CYMakeMessage(JSContextRef context, SEL sel, IMP imp, const c
     return JSObjectMake(context, Message_, internal);
 }
 
-static IMP CYMakeMessage(JSContextRef context, JSValueRef value, const char *type) {
+static IMP CYMakeMessage(JSContextRef context, JSValueRef value, const char *encoding) {
     JSObjectRef function(CYCastJSObject(context, value));
-    Closure_privateData *internal(CYMakeFunctor_(context, function, type, &MessageClosure_));
+    CYPool pool;
+    sig::Signature signature;
+    sig::Parse(pool, &signature, encoding, &Structor_);
+    Closure_privateData *internal(CYMakeFunctor_(context, function, signature, &MessageClosure_));
     // XXX: see notes in Library.cpp about needing to leak
     return reinterpret_cast<IMP>(internal->GetValue());
 }
@@ -2927,10 +2961,6 @@ void CYObjectiveC_SetupContext(JSContextRef context) { CYPoolTry {
     JSObjectRef box(JSObjectMakeFunctionWithCallback(context, CYJSString("box"), &Instance_box_callAsFunction));
     CYSetProperty(context, Instance, CYJSString("box"), box);
 
-#if defined(__APPLE__) && defined(__arm__) && 0
-    CYSetProperty(context, all, CYJSString("objc_registerClassPair"), &objc_registerClassPair_, kJSPropertyAttributeDontEnum);
-#endif
-
 #ifdef __APPLE__
     CYSetProperty(context, all, CYJSString("choose"), &choose, kJSPropertyAttributeDontEnum);
 #endif
@@ -2958,3 +2988,25 @@ struct CYObjectiveC {
         _assert(hooks_ != NULL);
     }
 } CYObjectiveC;
+
+extern "C" void CydgetSetupContext(JSGlobalContextRef context) { CYObjectiveTry_ {
+    CYSetupContext(context);
+} CYObjectiveCatch }
+
+extern "C" void CydgetMemoryParse(const uint16_t **data, size_t *size) { try {
+    CYPool pool;
+
+    CYUTF8String utf8(CYPoolUTF8String(pool, CYUTF16String(*data, *size)));
+    utf8 = CYPoolCode(pool, utf8);
+
+    CYUTF16String utf16(CYPoolUTF16String(pool, CYUTF8String(utf8.data, utf8.size)));
+    size_t bytes(utf16.size * sizeof(uint16_t));
+    uint16_t *copy(reinterpret_cast<uint16_t *>(malloc(bytes)));
+    memcpy(copy, utf16.data, bytes);
+
+    *data = copy;
+    *size = utf16.size;
+} catch (const CYException &exception) {
+    CYPool pool;
+    @throw [NSException exceptionWithName:NSRangeException reason:[NSString stringWithFormat:@"%s", exception.PoolCString(pool)] userInfo:nil];
+} }