API/ObjCCallbackFunction.mm

   1 /*
   2  * Copyright (C) 2013 Apple Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
  14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
  17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #include "config.h"
  27 #import "JavaScriptCore.h"
  28
  29 #if JSC_OBJC_API_ENABLED
  30
  31 #import "APICast.h"
  32 #import "APIShims.h"
  33 #import "Error.h"
  34 #import "JSCJSValueInlines.h"
  35 #import "JSCell.h"
  36 #import "JSCellInlines.h"
  37 #import "JSContextInternal.h"
  38 #import "JSWrapperMap.h"
  39 #import "JSValueInternal.h"
  40 #import "ObjCCallbackFunction.h"
  41 #import "ObjcRuntimeExtras.h"
  42 #import <objc/runtime.h>
  43 #import <wtf/RetainPtr.h>
  44
  45 class CallbackArgument {
  46 public:
  47     virtual ~CallbackArgument();
  48     virtual void set(NSInvocation *, NSInteger, JSContext *, JSValueRef, JSValueRef*) = 0;
  49
  50     OwnPtr<CallbackArgument> m_next;
  51 };
  52
  53 CallbackArgument::~CallbackArgument()
  54 {
  55 }
  56
  57 class CallbackArgumentBoolean : public CallbackArgument {
  58     virtual void set(NSInvocation *invocation, NSInteger argumentNumber, JSContext *context, JSValueRef argument, JSValueRef*) override
  59     {
  60         bool value = JSValueToBoolean([context JSGlobalContextRef], argument);
  61         [invocation setArgument:&value atIndex:argumentNumber];
  62     }
  63 };
  64
  65 template<typename T>
  66 class CallbackArgumentInteger : public CallbackArgument {
  67     virtual void set(NSInvocation *invocation, NSInteger argumentNumber, JSContext *context, JSValueRef argument, JSValueRef* exception) override
  68     {
  69         T value = (T)JSC::toInt32(JSValueToNumber([context JSGlobalContextRef], argument, exception));
  70         [invocation setArgument:&value atIndex:argumentNumber];
  71     }
  72 };
  73
  74 template<typename T>
  75 class CallbackArgumentDouble : public CallbackArgument {
  76     virtual void set(NSInvocation *invocation, NSInteger argumentNumber, JSContext *context, JSValueRef argument, JSValueRef* exception) override
  77     {
  78         T value = (T)JSValueToNumber([context JSGlobalContextRef], argument, exception);
  79         [invocation setArgument:&value atIndex:argumentNumber];
  80     }
  81 };
  82
  83 class CallbackArgumentJSValue : public CallbackArgument {
  84     virtual void set(NSInvocation *invocation, NSInteger argumentNumber, JSContext *context, JSValueRef argument, JSValueRef*) override
  85     {
  86         JSValue *value = [JSValue valueWithJSValueRef:argument inContext:context];
  87         [invocation setArgument:&value atIndex:argumentNumber];
  88     }
  89 };
  90
  91 class CallbackArgumentId : public CallbackArgument {
  92     virtual void set(NSInvocation *invocation, NSInteger argumentNumber, JSContext *context, JSValueRef argument, JSValueRef*) override
  93     {
  94         id value = valueToObject(context, argument);
  95         [invocation setArgument:&value atIndex:argumentNumber];
  96     }
  97 };
  98
  99 class CallbackArgumentOfClass : public CallbackArgument {
 100 public:
 101     CallbackArgumentOfClass(Class cls)
 102         : CallbackArgument()
 103         , m_class(cls)
 104     {
 105         [m_class retain];
 106     }
 107
 108 private:
 109     virtual ~CallbackArgumentOfClass()
 110     {
 111         [m_class release];
 112     }
 113
 114     virtual void set(NSInvocation *invocation, NSInteger argumentNumber, JSContext *context, JSValueRef argument, JSValueRef* exception) override
 115     {
 116         JSGlobalContextRef contextRef = [context JSGlobalContextRef];
 117
 118         id object = tryUnwrapObjcObject(contextRef, argument);
 119         if (object && [object isKindOfClass:m_class]) {
 120             [invocation setArgument:&object atIndex:argumentNumber];
 121             return;
 122         }
 123
 124         if (JSValueIsNull(contextRef, argument) || JSValueIsUndefined(contextRef, argument)) {
 125             object = nil;
 126             [invocation setArgument:&object atIndex:argumentNumber];
 127             return;
 128         }
 129
 130         *exception = toRef(JSC::createTypeError(toJS(contextRef), "Argument does not match Objective-C Class"));
 131     }
 132
 133     Class m_class;
 134 };
 135
 136 class CallbackArgumentNSNumber : public CallbackArgument {
 137     virtual void set(NSInvocation *invocation, NSInteger argumentNumber, JSContext *context, JSValueRef argument, JSValueRef* exception) override
 138     {
 139         id value = valueToNumber([context JSGlobalContextRef], argument, exception);
 140         [invocation setArgument:&value atIndex:argumentNumber];
 141     }
 142 };
 143
 144 class CallbackArgumentNSString : public CallbackArgument {
 145     virtual void set(NSInvocation *invocation, NSInteger argumentNumber, JSContext *context, JSValueRef argument, JSValueRef* exception) override
 146     {
 147         id value = valueToString([context JSGlobalContextRef], argument, exception);
 148         [invocation setArgument:&value atIndex:argumentNumber];
 149     }
 150 };
 151
 152 class CallbackArgumentNSDate : public CallbackArgument {
 153     virtual void set(NSInvocation *invocation, NSInteger argumentNumber, JSContext *context, JSValueRef argument, JSValueRef* exception) override
 154     {
 155         id value = valueToDate([context JSGlobalContextRef], argument, exception);
 156         [invocation setArgument:&value atIndex:argumentNumber];
 157     }
 158 };
 159
 160 class CallbackArgumentNSArray : public CallbackArgument {
 161     virtual void set(NSInvocation *invocation, NSInteger argumentNumber, JSContext *context, JSValueRef argument, JSValueRef* exception) override
 162     {
 163         id value = valueToArray([context JSGlobalContextRef], argument, exception);
 164         [invocation setArgument:&value atIndex:argumentNumber];
 165     }
 166 };
 167
 168 class CallbackArgumentNSDictionary : public CallbackArgument {
 169     virtual void set(NSInvocation *invocation, NSInteger argumentNumber, JSContext *context, JSValueRef argument, JSValueRef* exception) override
 170     {
 171         id value = valueToDictionary([context JSGlobalContextRef], argument, exception);
 172         [invocation setArgument:&value atIndex:argumentNumber];
 173     }
 174 };
 175
 176 class CallbackArgumentStruct : public CallbackArgument {
 177 public:
 178     CallbackArgumentStruct(NSInvocation *conversionInvocation, const char* encodedType)
 179         : m_conversionInvocation(conversionInvocation)
 180         , m_buffer(encodedType)
 181     {
 182     }
 183
 184 private:
 185     virtual void set(NSInvocation *invocation, NSInteger argumentNumber, JSContext *context, JSValueRef argument, JSValueRef*) override
 186     {
 187         JSValue *value = [JSValue valueWithJSValueRef:argument inContext:context];
 188         [m_conversionInvocation invokeWithTarget:value];
 189         [m_conversionInvocation getReturnValue:m_buffer];
 190         [invocation setArgument:m_buffer atIndex:argumentNumber];
 191     }
 192
 193     RetainPtr<NSInvocation> m_conversionInvocation;
 194     StructBuffer m_buffer;
 195 };
 196
 197 class ArgumentTypeDelegate {
 198 public:
 199     typedef CallbackArgument* ResultType;
 200
 201     template<typename T>
 202     static ResultType typeInteger()
 203     {
 204         return new CallbackArgumentInteger<T>;
 205     }
 206
 207     template<typename T>
 208     static ResultType typeDouble()
 209     {
 210         return new CallbackArgumentDouble<T>;
 211     }
 212
 213     static ResultType typeBool()
 214     {
 215         return new CallbackArgumentBoolean;
 216     }
 217
 218     static ResultType typeVoid()
 219     {
 220         RELEASE_ASSERT_NOT_REACHED();
 221         return 0;
 222     }
 223
 224     static ResultType typeId()
 225     {
 226         return new CallbackArgumentId;
 227     }
 228
 229     static ResultType typeOfClass(const char* begin, const char* end)
 230     {
 231         StringRange copy(begin, end);
 232         Class cls = objc_getClass(copy);
 233         if (!cls)
 234             return 0;
 235
 236         if (cls == [JSValue class])
 237             return new CallbackArgumentJSValue;
 238         if (cls == [NSString class])
 239             return new CallbackArgumentNSString;
 240         if (cls == [NSNumber class])
 241             return new CallbackArgumentNSNumber;
 242         if (cls == [NSDate class])
 243             return new CallbackArgumentNSDate;
 244         if (cls == [NSArray class])
 245             return new CallbackArgumentNSArray;
 246         if (cls == [NSDictionary class])
 247             return new CallbackArgumentNSDictionary;
 248
 249         return new CallbackArgumentOfClass(cls);
 250     }
 251
 252     static ResultType typeBlock(const char*, const char*)
 253     {
 254         return nil;
 255     }
 256
 257     static ResultType typeStruct(const char* begin, const char* end)
 258     {
 259         StringRange copy(begin, end);
 260         if (NSInvocation *invocation = valueToTypeInvocationFor(copy))
 261             return new CallbackArgumentStruct(invocation, copy);
 262         return 0;
 263     }
 264 };
 265
 266 class CallbackResult {
 267 public:
 268     virtual ~CallbackResult()
 269     {
 270     }
 271
 272     virtual JSValueRef get(NSInvocation *, JSContext *, JSValueRef*) = 0;
 273 };
 274
 275 class CallbackResultVoid : public CallbackResult {
 276     virtual JSValueRef get(NSInvocation *, JSContext *context, JSValueRef*) override
 277     {
 278         return JSValueMakeUndefined([context JSGlobalContextRef]);
 279     }
 280 };
 281
 282 class CallbackResultId : public CallbackResult {
 283     virtual JSValueRef get(NSInvocation *invocation, JSContext *context, JSValueRef*) override
 284     {
 285         id value;
 286         [invocation getReturnValue:&value];
 287         return objectToValue(context, value);
 288     }
 289 };
 290
 291 template<typename T>
 292 class CallbackResultNumeric : public CallbackResult {
 293     virtual JSValueRef get(NSInvocation *invocation, JSContext *context, JSValueRef*) override
 294     {
 295         T value;
 296         [invocation getReturnValue:&value];
 297         return JSValueMakeNumber([context JSGlobalContextRef], value);
 298     }
 299 };
 300
 301 class CallbackResultBoolean : public CallbackResult {
 302     virtual JSValueRef get(NSInvocation *invocation, JSContext *context, JSValueRef*) override
 303     {
 304         bool value;
 305         [invocation getReturnValue:&value];
 306         return JSValueMakeBoolean([context JSGlobalContextRef], value);
 307     }
 308 };
 309
 310 class CallbackResultStruct : public CallbackResult {
 311 public:
 312     CallbackResultStruct(NSInvocation *conversionInvocation, const char* encodedType)
 313         : m_conversionInvocation(conversionInvocation)
 314         , m_buffer(encodedType)
 315     {
 316     }
 317
 318 private:
 319     virtual JSValueRef get(NSInvocation *invocation, JSContext *context, JSValueRef*) override
 320     {
 321         [invocation getReturnValue:m_buffer];
 322
 323         [m_conversionInvocation setArgument:m_buffer atIndex:2];
 324         [m_conversionInvocation setArgument:&context atIndex:3];
 325         [m_conversionInvocation invokeWithTarget:[JSValue class]];
 326
 327         JSValue *value;
 328         [m_conversionInvocation getReturnValue:&value];
 329         return valueInternalValue(value);
 330     }
 331
 332     RetainPtr<NSInvocation> m_conversionInvocation;
 333     StructBuffer m_buffer;
 334 };
 335
 336 class ResultTypeDelegate {
 337 public:
 338     typedef CallbackResult* ResultType;
 339
 340     template<typename T>
 341     static ResultType typeInteger()
 342     {
 343         return new CallbackResultNumeric<T>;
 344     }
 345
 346     template<typename T>
 347     static ResultType typeDouble()
 348     {
 349         return new CallbackResultNumeric<T>;
 350     }
 351
 352     static ResultType typeBool()
 353     {
 354         return new CallbackResultBoolean;
 355     }
 356
 357     static ResultType typeVoid()
 358     {
 359         return new CallbackResultVoid;
 360     }
 361
 362     static ResultType typeId()
 363     {
 364         return new CallbackResultId();
 365     }
 366
 367     static ResultType typeOfClass(const char*, const char*)
 368     {
 369         return new CallbackResultId();
 370     }
 371
 372     static ResultType typeBlock(const char*, const char*)
 373     {
 374         return new CallbackResultId();
 375     }
 376
 377     static ResultType typeStruct(const char* begin, const char* end)
 378     {
 379         StringRange copy(begin, end);
 380         if (NSInvocation *invocation = typeToValueInvocationFor(copy))
 381             return new CallbackResultStruct(invocation, copy);
 382         return 0;
 383     }
 384 };
 385
 386 enum CallbackType {
 387     CallbackInstanceMethod,
 388     CallbackClassMethod,
 389     CallbackBlock
 390 };
 391
 392 namespace JSC {
 393
 394 class ObjCCallbackFunctionImpl {
 395 public:
 396     ObjCCallbackFunctionImpl(JSContext *context, NSInvocation *invocation, CallbackType type, Class instanceClass, PassOwnPtr<CallbackArgument> arguments, PassOwnPtr<CallbackResult> result)
 397         : m_context(context)
 398         , m_type(type)
 399         , m_instanceClass([instanceClass retain])
 400         , m_invocation(invocation)
 401         , m_arguments(arguments)
 402         , m_result(result)
 403     {
 404         ASSERT(type != CallbackInstanceMethod || instanceClass);
 405     }
 406
 407     ~ObjCCallbackFunctionImpl()
 408     {
 409         if (m_type != CallbackInstanceMethod)
 410             [[m_invocation.get() target] release];
 411         [m_instanceClass release];
 412     }
 413
 414     JSValueRef call(JSContext *context, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception);
 415
 416     JSContext *context()
 417     {
 418         return m_context.get();
 419     }
 420
 421     void setContext(JSContext *context)
 422     {
 423         ASSERT(!m_context.get());
 424         m_context.set(context);
 425     }
 426
 427     id wrappedBlock()
 428     {
 429         return m_type == CallbackBlock ? [m_invocation target] : nil;
 430     }
 431
 432 private:
 433     WeakContextRef m_context;
 434     CallbackType m_type;
 435     Class m_instanceClass;
 436     RetainPtr<NSInvocation> m_invocation;
 437     OwnPtr<CallbackArgument> m_arguments;
 438     OwnPtr<CallbackResult> m_result;
 439 };
 440
 441 static JSValueRef objCCallbackFunctionCallAsFunction(JSContextRef callerContext, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)
 442 {
 443     // Retake the API lock - we need this for a few reasons:
 444     // (1) We don't want to support the C-API's confusing drops-locks-once policy - should only drop locks if we can do so recursively.
 445     // (2) We're calling some JSC internals that require us to be on the 'inside' - e.g. createTypeError.
 446     // (3) We need to be locked (per context would be fine) against conflicting usage of the ObjCCallbackFunction's NSInvocation.
 447     JSC::APIEntryShim entryShim(toJS(callerContext));
 448
 449     ObjCCallbackFunction* callback = static_cast<ObjCCallbackFunction*>(toJS(function));
 450     ObjCCallbackFunctionImpl* impl = callback->impl();
 451     JSContext *context = impl->context();
 452     if (!context) {
 453         context = [JSContext contextWithJSGlobalContextRef:toGlobalRef(toJS(callerContext)->lexicalGlobalObject()->globalExec())];
 454         impl->setContext(context);
 455     }
 456
 457     CallbackData callbackData;
 458     JSValueRef result;
 459     @autoreleasepool {
 460         [context beginCallbackWithData:&callbackData thisValue:thisObject argumentCount:argumentCount arguments:arguments];
 461         result = impl->call(context, thisObject, argumentCount, arguments, exception);
 462         if (context.exception)
 463             *exception = valueInternalValue(context.exception);
 464         [context endCallbackWithData:&callbackData];
 465     }
 466     return result;
 467 }
 468
 469 const JSC::ClassInfo ObjCCallbackFunction::s_info = { "CallbackFunction", &Base::s_info, 0, 0, CREATE_METHOD_TABLE(ObjCCallbackFunction) };
 470
 471 ObjCCallbackFunction::ObjCCallbackFunction(JSC::JSGlobalObject* globalObject, JSObjectCallAsFunctionCallback callback, PassOwnPtr<ObjCCallbackFunctionImpl> impl)
 472     : Base(globalObject, globalObject->objcCallbackFunctionStructure(), callback)
 473     , m_impl(impl)
 474 {
 475 }
 476
 477 ObjCCallbackFunction* ObjCCallbackFunction::create(JSC::ExecState* exec, JSC::JSGlobalObject* globalObject, const String& name, PassOwnPtr<ObjCCallbackFunctionImpl> impl)
 478 {
 479     ObjCCallbackFunction* function = new (NotNull, allocateCell<ObjCCallbackFunction>(*exec->heap())) ObjCCallbackFunction(globalObject, objCCallbackFunctionCallAsFunction, impl);
 480     function->finishCreation(exec->vm(), name);
 481     return function;
 482 }
 483
 484 void ObjCCallbackFunction::destroy(JSCell* cell)
 485 {
 486     static_cast<ObjCCallbackFunction*>(cell)->ObjCCallbackFunction::~ObjCCallbackFunction();
 487 }
 488
 489 JSValueRef ObjCCallbackFunctionImpl::call(JSContext *context, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)
 490 {
 491     JSGlobalContextRef contextRef = [context JSGlobalContextRef];
 492
 493     size_t firstArgument;
 494     switch (m_type) {
 495     case CallbackInstanceMethod: {
 496         id target = tryUnwrapObjcObject(contextRef, thisObject);
 497         if (!target || ![target isKindOfClass:m_instanceClass]) {
 498             *exception = toRef(JSC::createTypeError(toJS(contextRef), "self type check failed for Objective-C instance method"));
 499             return JSValueMakeUndefined(contextRef);
 500         }
 501         [m_invocation setTarget:target];
 502     }
 503     // fallthrough - firstArgument for CallbackInstanceMethod is also 2!
 504     case CallbackClassMethod:
 505         firstArgument = 2;
 506         break;
 507     case CallbackBlock:
 508         firstArgument = 1;
 509     }
 510
 511     size_t argumentNumber = 0;
 512     for (CallbackArgument* argument = m_arguments.get(); argument; argument = argument->m_next.get()) {
 513         JSValueRef value = argumentNumber < argumentCount ? arguments[argumentNumber] : JSValueMakeUndefined(contextRef);
 514         argument->set(m_invocation.get(), argumentNumber + firstArgument, context, value, exception);
 515         if (*exception)
 516             return JSValueMakeUndefined(contextRef);
 517         ++argumentNumber;
 518     }
 519
 520     [m_invocation invoke];
 521
 522     return m_result->get(m_invocation.get(), context, exception);
 523 }
 524
 525 } // namespace JSC
 526
 527 static bool blockSignatureContainsClass()
 528 {
 529     static bool containsClass = ^{
 530         id block = ^(NSString *string){ return string; };
 531         return _Block_has_signature(block) && strstr(_Block_signature(block), "NSString");
 532     }();
 533     return containsClass;
 534 }
 535
 536 inline bool skipNumber(const char*& position)
 537 {
 538     if (!isASCIIDigit(*position))
 539         return false;
 540     while (isASCIIDigit(*++position)) { }
 541     return true;
 542 }
 543
 544 static JSObjectRef objCCallbackFunctionForInvocation(JSContext *context, NSInvocation *invocation, CallbackType type, Class instanceClass, const char* signatureWithObjcClasses)
 545 {
 546     const char* position = signatureWithObjcClasses;
 547
 548     OwnPtr<CallbackResult> result = adoptPtr(parseObjCType<ResultTypeDelegate>(position));
 549     if (!result || !skipNumber(position))
 550         return nil;
 551
 552     switch (type) {
 553     case CallbackInstanceMethod:
 554     case CallbackClassMethod:
 555         // Methods are passed two implicit arguments - (id)self, and the selector.
 556         if ('@' != *position++ || !skipNumber(position) || ':' != *position++ || !skipNumber(position))
 557             return nil;
 558         break;
 559     case CallbackBlock:
 560         // Blocks are passed one implicit argument - the block, of type "@?".
 561         if (('@' != *position++) || ('?' != *position++) || !skipNumber(position))
 562             return nil;
 563         // Only allow arguments of type 'id' if the block signature contains the NS type information.
 564         if ((!blockSignatureContainsClass() && strchr(position, '@')))
 565             return nil;
 566         break;
 567     }
 568
 569     OwnPtr<CallbackArgument> arguments = 0;
 570     OwnPtr<CallbackArgument>* nextArgument = &arguments;
 571     unsigned argumentCount = 0;
 572     while (*position) {
 573         OwnPtr<CallbackArgument> argument = adoptPtr(parseObjCType<ArgumentTypeDelegate>(position));
 574         if (!argument || !skipNumber(position))
 575             return nil;
 576
 577         *nextArgument = argument.release();
 578         nextArgument = &(*nextArgument)->m_next;
 579         ++argumentCount;
 580     }
 581
 582     JSC::ExecState* exec = toJS([context JSGlobalContextRef]);
 583     JSC::APIEntryShim shim(exec);
 584     OwnPtr<JSC::ObjCCallbackFunctionImpl> impl = adoptPtr(new JSC::ObjCCallbackFunctionImpl(context, invocation, type, instanceClass, arguments.release(), result.release()));
 585     // FIXME: Maybe we could support having the selector as the name of the function to make it a bit more user-friendly from the JS side?
 586     return toRef(JSC::ObjCCallbackFunction::create(exec, exec->lexicalGlobalObject(), "", impl.release()));
 587 }
 588
 589 JSObjectRef objCCallbackFunctionForMethod(JSContext *context, Class cls, Protocol *protocol, BOOL isInstanceMethod, SEL sel, const char* types)
 590 {
 591     NSInvocation *invocation = [NSInvocation invocationWithMethodSignature:[NSMethodSignature signatureWithObjCTypes:types]];
 592     [invocation setSelector:sel];
 593     if (!isInstanceMethod)
 594         [invocation setTarget:cls];
 595     return objCCallbackFunctionForInvocation(context, invocation, isInstanceMethod ? CallbackInstanceMethod : CallbackClassMethod, isInstanceMethod ? cls : nil, _protocol_getMethodTypeEncoding(protocol, sel, YES, isInstanceMethod));
 596 }
 597
 598 JSObjectRef objCCallbackFunctionForBlock(JSContext *context, id target)
 599 {
 600     if (!_Block_has_signature(target))
 601         return 0;
 602     const char* signature = _Block_signature(target);
 603     NSInvocation *invocation = [NSInvocation invocationWithMethodSignature:[NSMethodSignature signatureWithObjCTypes:signature]];
 604     [invocation setTarget:[target copy]];
 605     return objCCallbackFunctionForInvocation(context, invocation, CallbackBlock, nil, signature);
 606 }
 607
 608 id tryUnwrapBlock(JSObjectRef object)
 609 {
 610     if (!toJS(object)->inherits(&JSC::ObjCCallbackFunction::s_info))
 611         return nil;
 612     return static_cast<JSC::ObjCCallbackFunction*>(toJS(object))->impl()->wrappedBlock();
 613 }
 614
 615 #endif