X-Git-Url: https://git.saurik.com/cycript.git/blobdiff_plain/bc3080fdd24b9858d9c9dcbd3d8dd78ae010962a..9ebca0a01a76e046969f31a376737d075707e3a2:/ObjectiveC/Library.mm diff --git a/ObjectiveC/Library.mm b/ObjectiveC/Library.mm index 44eb057..580660e 100644 --- a/ObjectiveC/Library.mm +++ b/ObjectiveC/Library.mm @@ -1,63 +1,66 @@ /* Cycript - Optimizing JavaScript Compiler/Runtime - * Copyright (C) 2009-2012 Jay Freeman (saurik) + * Copyright (C) 2009-2015 Jay Freeman (saurik) */ -/* GNU Lesser General Public License, Version 3 {{{ */ +/* GNU Affero General Public License, Version 3 {{{ */ /* - * Cycript is free software: you can redistribute it and/or modify it under - * the terms of the GNU Lesser General Public License as published by the - * Free Software Foundation, either version 3 of the License, or (at your - * option) any later version. - * - * Cycript is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public - * License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with Cycript. If not, see . + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Affero General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Affero General Public License for more details. + + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . **/ /* }}} */ -#ifdef __APPLE__ -#include "Struct.hpp" -#endif +#include "cycript.hpp" -#include +#include -#include "ObjectiveC/Internal.hpp" +#include +#include -#include +#include -#include "cycript.hpp" +#ifdef __APPLE__ +#include +#include +#endif -#include "ObjectiveC/Internal.hpp" +#include +#include #ifdef __APPLE__ #include #include -#include -#include #endif +#include + +#include "Code.hpp" +#include "Decode.hpp" #include "Error.hpp" #include "JavaScript.hpp" #include "String.hpp" #include "Execute.hpp" -#include -#include - -#include +#include "ObjectiveC/Internal.hpp" +#include "ObjectiveC/Syntax.hpp" -#define CYObjectiveTry_(context) { \ - JSContextRef context_(context); \ +#define CYObjectiveTry_ { \ try #define CYObjectiveTry { \ + JSContextRef context(context_); \ try #define CYObjectiveCatch \ catch (const CYException &error) { \ - @throw CYCastNSObject(NULL, context_, error.CastJSValue(context_)); \ + @throw CYCastNSObject(NULL, context, error.CastJSValue(context, "Error")); \ } \ } @@ -85,102 +88,103 @@ } return value; \ } -#ifndef __APPLE__ -#define class_getSuperclass GSObjCSuper -#define class_getInstanceVariable GSCGetInstanceVariableDefinition -#define class_getName GSNameFromClass - -#define class_removeMethods(cls, list) GSRemoveMethodList(cls, list, YES) - -#define ivar_getName(ivar) ((ivar)->ivar_name) -#define ivar_getOffset(ivar) ((ivar)->ivar_offset) -#define ivar_getTypeEncoding(ivar) ((ivar)->ivar_type) - -#define method_getName(method) ((method)->method_name) -#define method_getImplementation(method) ((method)->method_imp) -#define method_getTypeEncoding(method) ((method)->method_types) -#define method_setImplementation(method, imp) ((void) ((method)->method_imp = (imp))) - -#undef objc_getClass -#define objc_getClass GSClassFromName +#define _oassert(test) \ + if (!(test)) \ + @throw [NSException exceptionWithName:NSInternalInconsistencyException reason:@"_assert(" #test ")" userInfo:nil]; -#define objc_getProtocol GSProtocolFromName +@class NSBlock; -#define object_getClass GSObjCClass +struct BlockLiteral { + Class isa; + int flags; + int reserved; + void (*invoke)(void *, ...); + void *descriptor; +}; -#define object_getInstanceVariable(object, name, value) ({ \ - objc_ivar *ivar(class_getInstanceVariable(object_getClass(object), name)); \ - _assert(value != NULL); \ - if (ivar != NULL) \ - GSObjCGetVariable(object, ivar_getOffset(ivar), sizeof(void *), value); \ - ivar; \ -}) +struct BlockDescriptor1 { + unsigned long int reserved; + unsigned long int size; +}; -#define object_setIvar(object, ivar, value) ({ \ - void *data = (value); \ - GSObjCSetVariable(object, ivar_getOffset(ivar), sizeof(void *), &data); \ -}) +struct BlockDescriptor2 { + void (*copy_helper)(BlockLiteral *dst, BlockLiteral *src); + void (*dispose_helper)(BlockLiteral *src); +}; -#define protocol_getName(protocol) [(protocol) name] -#endif +struct BlockDescriptor3 { + const char *signature; + const char *layout; +}; -static void (*$objc_setAssociatedObject)(id object, void *key, id value, objc_AssociationPolicy policy); -static id (*$objc_getAssociatedObject)(id object, void *key); -static void (*$objc_removeAssociatedObjects)(id object); +enum { + BLOCK_DEALLOCATING = 0x0001, + BLOCK_REFCOUNT_MASK = 0xfffe, + BLOCK_NEEDS_FREE = 1 << 24, + BLOCK_HAS_COPY_DISPOSE = 1 << 25, + BLOCK_HAS_CTOR = 1 << 26, + BLOCK_IS_GC = 1 << 27, + BLOCK_IS_GLOBAL = 1 << 28, + BLOCK_HAS_STRET = 1 << 29, + BLOCK_HAS_SIGNATURE = 1 << 30, +}; -JSValueRef CYSendMessage(apr_pool_t *pool, JSContextRef context, id self, Class super, SEL _cmd, size_t count, const JSValueRef arguments[], bool initialize, JSValueRef *exception); +JSValueRef CYSendMessage(CYPool &pool, JSContextRef context, id self, Class super, SEL _cmd, size_t count, const JSValueRef arguments[], bool initialize); /* Objective-C Pool Release {{{ */ -apr_status_t CYPoolRelease_(void *data) { +void CYPoolRelease_(void *data) { id object(reinterpret_cast(data)); [object release]; - return APR_SUCCESS; } -id CYPoolRelease_(apr_pool_t *pool, id object) { +id CYPoolRelease_(CYPool *pool, id object) { if (object == nil) return nil; else if (pool == NULL) return [object autorelease]; else { - apr_pool_cleanup_register(pool, object, &CYPoolRelease_, &apr_pool_cleanup_null); + pool->atexit(CYPoolRelease_); return object; } } template -Type_ CYPoolRelease(apr_pool_t *pool, Type_ object) { +Type_ CYPoolRelease(CYPool *pool, Type_ object) { return (Type_) CYPoolRelease_(pool, (id) object); } /* }}} */ /* Objective-C Strings {{{ */ -const char *CYPoolCString(apr_pool_t *pool, JSContextRef context, NSString *value) { - if (pool == NULL) - return [value UTF8String]; - else { - size_t size([value maximumLengthOfBytesUsingEncoding:NSUTF8StringEncoding] + 1); - char *string(new(pool) char[size]); - if (![value getCString:string maxLength:size encoding:NSUTF8StringEncoding]) - throw CYJSError(context, "[NSString getCString:maxLength:encoding:] == NO"); - return string; - } +CYUTF8String CYPoolUTF8String(CYPool &pool, JSContextRef context, NSString *value) { + size_t size([value maximumLengthOfBytesUsingEncoding:NSUTF8StringEncoding]); + char *string(new(pool) char[size + 1]); + if (![value getCString:string maxLength:size encoding:NSUTF8StringEncoding]) + throw CYJSError(context, "[NSString getCString:maxLength:encoding:] == NO"); + return CYUTF8String(string, [value lengthOfBytesUsingEncoding:NSUTF8StringEncoding]); +} + +const char *CYPoolCString(CYPool &pool, JSContextRef context, NSString *value) { + CYUTF8String utf8(CYPoolUTF8String(pool, context, value)); + _assert(memchr(utf8.data, '\0', utf8.size) == NULL); + return utf8.data; } +#ifdef __clang__ JSStringRef CYCopyJSString(JSContextRef context, NSString *value) { -#ifdef __APPLE__ return JSStringCreateWithCFString(reinterpret_cast(value)); -#else - CYPool pool; - return CYCopyJSString(CYPoolCString(pool, context, value)); -#endif } +#endif JSStringRef CYCopyJSString(JSContextRef context, NSObject *value) { if (value == nil) return NULL; // XXX: this definition scares me; is anyone using this?! NSString *string([value description]); +#ifdef __clang__ return CYCopyJSString(context, string); +#else + CYPool pool; + return CYCopyJSString(CYPoolUTF8String(pool, context, string)); +#endif } NSString *CYCopyNSString(const CYUTF8String &value) { @@ -204,16 +208,16 @@ NSString *CYCopyNSString(JSContextRef context, JSValueRef value) { return CYCopyNSString(context, CYJSString(context, value)); } -NSString *CYCastNSString(apr_pool_t *pool, const CYUTF8String &value) { +NSString *CYCastNSString(CYPool *pool, const CYUTF8String &value) { return CYPoolRelease(pool, CYCopyNSString(value)); } -NSString *CYCastNSString(apr_pool_t *pool, SEL sel) { +NSString *CYCastNSString(CYPool *pool, SEL sel) { const char *name(sel_getName(sel)); return CYPoolRelease(pool, CYCopyNSString(CYUTF8String(name, strlen(name)))); } -NSString *CYCastNSString(apr_pool_t *pool, JSContextRef context, JSStringRef value) { +NSString *CYCastNSString(CYPool *pool, JSContextRef context, JSStringRef value) { return CYPoolRelease(pool, CYCopyNSString(context, value)); } @@ -235,18 +239,20 @@ size_t CYGetIndex(NSString *value) { return CYGetIndex(CYCastUTF8String(value)); } -bool CYGetOffset(apr_pool_t *pool, JSContextRef context, NSString *value, ssize_t &index) { +bool CYGetOffset(CYPool &pool, JSContextRef context, NSString *value, ssize_t &index) { return CYGetOffset(CYPoolCString(pool, context, value), index); } static JSClassRef Instance_; static JSClassRef ArrayInstance_; +static JSClassRef BooleanInstance_; static JSClassRef FunctionInstance_; +static JSClassRef NumberInstance_; static JSClassRef ObjectInstance_; static JSClassRef StringInstance_; -static JSClassRef TypeInstance_; +static JSClassRef Class_; static JSClassRef Internal_; static JSClassRef Message_; static JSClassRef Messages_; @@ -263,11 +269,10 @@ static JSClassRef ObjectiveC_Images_; #endif #ifdef __APPLE__ +static Class __NSMallocBlock__; static Class NSCFBoolean_; static Class NSCFType_; static Class NSGenericDeallocHandler_; -static Class NSMessageBuilder_; -static Class NSZombie_; #else static Class NSBoolNumber_; #endif @@ -275,7 +280,9 @@ static Class NSBoolNumber_; static Class NSArray_; static Class NSBlock_; static Class NSDictionary_; +static Class NSNumber_; static Class NSString_; +static Class NSZombie_; static Class Object_; static Type_privateData *Object_type; @@ -295,7 +302,7 @@ JSValueRef CYGetClassPrototype(JSContextRef context, Class self, bool meta) { if (self == nil) return CYGetCachedObject(context, CYJSString("Instance_prototype")); else if (meta && !class_isMetaClass(self)) - return CYGetCachedObject(context, CYJSString("TypeInstance_prototype")); + return CYGetCachedObject(context, CYJSString("Class_prototype")); JSObjectRef global(CYGetGlobalObject(context)); JSObjectRef cy(CYCastJSObject(context, CYGetProperty(context, global, cy_s))); @@ -311,10 +318,18 @@ JSValueRef CYGetClassPrototype(JSContextRef context, Class self, bool meta) { JSClassRef _class(NULL); JSValueRef prototype; - if (self == NSArray_) +#ifdef __APPLE__ + if (self == NSCFBoolean_) +#else + if (self == NSBoolNumber_) +#endif + prototype = CYGetCachedObject(context, CYJSString("BooleanInstance_prototype")); + else if (self == NSArray_) prototype = CYGetCachedObject(context, CYJSString("ArrayInstance_prototype")); else if (self == NSBlock_) prototype = CYGetCachedObject(context, CYJSString("FunctionInstance_prototype")); + else if (self == NSNumber_) + prototype = CYGetCachedObject(context, CYJSString("NumberInstance_prototype")); else if (self == NSDictionary_) prototype = CYGetCachedObject(context, CYJSString("ObjectInstance_prototype")); else if (self == NSString_) @@ -323,7 +338,7 @@ JSValueRef CYGetClassPrototype(JSContextRef context, Class self, bool meta) { prototype = CYGetClassPrototype(context, class_getSuperclass(self), meta); JSObjectRef object(JSObjectMake(context, _class, NULL)); - JSObjectSetPrototype(context, object, prototype); + CYSetPrototype(context, object, prototype); CYSetProperty(context, cy, name, object); return object; @@ -336,7 +351,7 @@ _finline JSValueRef CYGetClassPrototype(JSContextRef context, Class self) { JSObjectRef Messages::Make(JSContextRef context, Class _class) { JSObjectRef value(JSObjectMake(context, Messages_, new Messages(_class))); if (Class super = class_getSuperclass(_class)) - JSObjectSetPrototype(context, value, Messages::Make(context, super)); + CYSetPrototype(context, value, Messages::Make(context, super)); return value; } @@ -350,17 +365,22 @@ JSObjectRef Super::Make(JSContextRef context, id object, Class _class) { return value; } } +bool CYIsKindOfClass(id object, Class _class) { + for (Class isa(object_getClass(object)); isa != NULL; isa = class_getSuperclass(isa)) + if (isa == _class) + return true; + return false; +} + JSObjectRef Instance::Make(JSContextRef context, id object, Flags flags) { - JSObjectRef value(JSObjectMake(context, Instance_, new Instance(object, flags))); - JSObjectSetPrototype(context, value, CYGetClassPrototype(context, object_getClass(object))); + JSObjectRef value(JSObjectMake(context, CYIsKindOfClass(object, NSBlock_) ? FunctionInstance_ : Instance_, new Instance(object, flags))); + CYSetPrototype(context, value, CYGetClassPrototype(context, object_getClass(object))); return value; } Instance::~Instance() { - if ((flags_ & Transient) == 0) - // XXX: does this handle background threads correctly? - // XXX: this simply does not work on the console because I'm stupid - [GetValue() performSelector:@selector(release) withObject:nil afterDelay:0]; + if ((flags_ & Permanent) == 0) + [GetValue() release]; } struct Message_privateData : @@ -375,17 +395,28 @@ struct Message_privateData : } }; -JSObjectRef CYMakeInstance(JSContextRef context, id object, bool transient) { - Instance::Flags flags; +JSObjectRef CYMakeInstance(JSContextRef context, id object, Instance::Flags flags = Instance::None) { + _assert(object != nil); - if (transient) - flags = Instance::Transient; - else { - flags = Instance::None; +#ifdef __APPLE__ + JSWeakObjectMapRef weak(CYCastPointer(context, CYGetCachedValue(context, weak_s))); + + if (weak != NULL && &JSWeakObjectMapGet != NULL) + if (JSObjectRef instance = JSWeakObjectMapGet(context, weak, object)) + return instance; +#endif + + if ((flags & Instance::Permanent) == 0) object = [object retain]; - } - return Instance::Make(context, object, flags); + JSObjectRef instance(Instance::Make(context, object, flags)); + +#ifdef __APPLE__ + if (weak != NULL && &JSWeakObjectMapSet != NULL) + JSWeakObjectMapSet(context, weak, object, instance); +#endif + + return instance; } @interface NSMethodSignature (Cycript) @@ -398,7 +429,7 @@ JSObjectRef CYMakeInstance(JSContextRef context, id object, bool transient) { - (JSType) cy$JSType; - (JSValueRef) cy$toJSON:(NSString *)key inContext:(JSContextRef)context; -- (NSString *) cy$toCYON:(bool)objective; +- (NSString *) cy$toCYON:(bool)objective inSet:(std::set &)objects; - (bool) cy$hasProperty:(NSString *)name; - (NSObject *) cy$getProperty:(NSString *)name; @@ -416,45 +447,42 @@ JSObjectRef CYMakeInstance(JSContextRef context, id object, bool transient) { - (JSValueRef) cy$valueOfInContext:(JSContextRef)context; @end -NSString *CYCastNSCYON(id value, bool objective) { - NSString *string; +NSString *CYCastNSCYON(id value, bool objective, std::set &objects) { + _assert(value != nil); - if (value == nil) - string = @"nil"; - else { - Class _class(object_getClass(value)); - SEL sel(@selector(cy$toCYON:)); - - if (objc_method *toCYON = class_getInstanceMethod(_class, sel)) - string = reinterpret_cast(method_getImplementation(toCYON))(value, sel, objective); - else if (objc_method *methodSignatureForSelector = class_getInstanceMethod(_class, @selector(methodSignatureForSelector:))) { - if (reinterpret_cast(method_getImplementation(methodSignatureForSelector))(value, @selector(methodSignatureForSelector:), sel) != nil) - string = [value cy$toCYON:objective]; - else goto fail; - } else fail: { - if (false); -#ifdef __APPLE__ - else if (value == NSZombie_) - string = @"_NSZombie_"; - else if (_class == NSZombie_) - string = [NSString stringWithFormat:@"<_NSZombie_: %p>", value]; - // XXX: frowny /in/ the pants - else if (value == NSGenericDeallocHandler_ || value == NSMessageBuilder_ || value == Object_) - string = nil; -#endif - else - string = [NSString stringWithFormat:@"%@", value]; - } + Class _class(object_getClass(value)); - // XXX: frowny pants - if (string == nil) - string = @"undefined"; + if (class_isMetaClass(_class)) { + const char *name(class_getName(value)); + if (class_isMetaClass(value)) + return [NSString stringWithFormat:@"object_getClass(%s)", name]; + else + return [NSString stringWithUTF8String:name]; } - return string; + if (_class == NSZombie_) + return [NSString stringWithFormat:@"<_NSZombie_: %p>", value]; + + SEL sel(@selector(cy$toCYON:inSet:)); + + if (objc_method *toCYON = class_getInstanceMethod(_class, sel)) + return reinterpret_cast &)>(method_getImplementation(toCYON))(value, sel, objective, objects); + else if (objc_method *methodSignatureForSelector = class_getInstanceMethod(_class, @selector(methodSignatureForSelector:))) + if (reinterpret_cast(method_getImplementation(methodSignatureForSelector))(value, @selector(methodSignatureForSelector:), sel) != nil) + return [value cy$toCYON:objective inSet:objects]; + + return [NSString stringWithFormat:@"%@", value]; +} + +NSString *CYCastNSCYON(id value, bool objective, std::set *objects) { + if (objects != NULL) + return CYCastNSCYON(value, objective, *objects); + else { + std::set objects; + return CYCastNSCYON(value, objective, objects); + } } -#ifdef __APPLE__ struct PropertyAttributes { CYPool pool_; @@ -488,7 +516,9 @@ struct PropertyAttributes { name = property_getName(property); const char *attributes(property_getAttributes(property)); - for (char *state, *token(apr_strtok(apr_pstrdup(pool_, attributes), ",", &state)); token != NULL; token = apr_strtok(NULL, ",", &state)) { + for (char *token(pool_.strdup(attributes)), *next; token != NULL; token = next) { + if ((next = strchr(token, ',')) != NULL) + *next++ = '\0'; switch (*token) { case 'R': readonly = true; break; case 'C': copy = true; break; @@ -513,7 +543,7 @@ struct PropertyAttributes { const char *Getter() { if (getter_ == NULL) - getter_ = apr_pstrdup(pool_, name); + getter_ = pool_.strdup(name); return getter_; } @@ -540,9 +570,7 @@ struct PropertyAttributes { } }; -#endif -#ifndef __APPLE__ @interface CYWebUndefined : NSObject { } @@ -560,7 +588,6 @@ struct PropertyAttributes { @end #define WebUndefined CYWebUndefined -#endif /* Bridge: CYJSObject {{{ */ @interface CYJSObject : NSMutableDictionary { @@ -599,18 +626,57 @@ struct PropertyAttributes { /* }}} */ _finline bool CYJSValueIsNSObject(JSContextRef context, JSValueRef value) { - return JSValueIsObjectOfClass(context, value, Instance_); + return JSValueIsObjectOfClass(context, value, Instance_) || JSValueIsObjectOfClass(context, value, FunctionInstance_); } _finline bool CYJSValueIsInstanceOfCachedConstructor(JSContextRef context, JSValueRef value, JSStringRef cache) { - JSValueRef exception(NULL); - JSObjectRef constructor(CYGetCachedObject(context, cache)); - bool is(JSValueIsInstanceOfConstructor(context, value, constructor, &exception)); - CYThrow(context, exception); - return is; + return _jsccall(JSValueIsInstanceOfConstructor, context, value, CYGetCachedObject(context, cache)); +} + +#ifdef __APPLE__ +struct CYBlockDescriptor { + struct { + BlockDescriptor1 one_; + BlockDescriptor2 two_; + BlockDescriptor3 three_; + } d_; + + Closure_privateData *internal_; +}; + +void CYDisposeBlock(BlockLiteral *literal) { + delete reinterpret_cast(literal->descriptor)->internal_; +} + +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); } -NSObject *CYCastNSObject(apr_pool_t *pool, JSContextRef context, JSObjectRef object) { +NSBlock *CYMakeBlock(JSContextRef context, JSObjectRef function, sig::Signature &signature) { + _assert(__NSMallocBlock__ != Nil); + BlockLiteral *literal(reinterpret_cast(malloc(sizeof(BlockLiteral)))); + + CYBlockDescriptor *descriptor(new CYBlockDescriptor); + memset(&descriptor->d_, 0, sizeof(descriptor->d_)); + + descriptor->internal_ = CYMakeFunctor_(context, function, signature, &BlockAdapter_); + literal->invoke = reinterpret_cast(descriptor->internal_->GetValue()); + + literal->isa = __NSMallocBlock__; + literal->flags = BLOCK_HAS_SIGNATURE | BLOCK_HAS_COPY_DISPOSE | BLOCK_IS_GLOBAL; + literal->reserved = 0; + literal->descriptor = descriptor; + + descriptor->d_.one_.size = sizeof(descriptor->d_); + descriptor->d_.two_.dispose_helper = &CYDisposeBlock; + descriptor->d_.three_.signature = sig::Unparse(*descriptor->internal_->pool_, &signature); + + return reinterpret_cast(literal); +} +#endif + +NSObject *CYCastNSObject(CYPool *pool, JSContextRef context, JSObjectRef object) { if (CYJSValueIsNSObject(context, object)) { Instance *internal(reinterpret_cast(JSObjectGetPrivate(object))); return internal->GetValue(); @@ -631,7 +697,7 @@ NSNumber *CYCopyNSNumber(JSContextRef context, JSValueRef value) { @end #endif -id CYNSObject(apr_pool_t *pool, JSContextRef context, JSValueRef value, bool cast) { +id CYNSObject(CYPool *pool, JSContextRef context, JSValueRef value, bool cast) { id object; bool copy; @@ -684,12 +750,12 @@ id CYNSObject(apr_pool_t *pool, JSContextRef context, JSValueRef value, bool cas return [object retain]; } -NSObject *CYCastNSObject(apr_pool_t *pool, JSContextRef context, JSValueRef value) { +NSObject *CYCastNSObject(CYPool *pool, JSContextRef context, JSValueRef value) { return CYNSObject(pool, context, value, true); } -NSObject *CYCopyNSObject(apr_pool_t *pool, JSContextRef context, JSValueRef value) { - return CYNSObject(pool, context, value, false); +NSObject *CYCopyNSObject(CYPool &pool, JSContextRef context, JSValueRef value) { + return CYNSObject(&pool, context, value, false); } /* Bridge: NSArray {{{ */ @@ -699,12 +765,14 @@ NSObject *CYCopyNSObject(apr_pool_t *pool, JSContextRef context, JSValueRef valu return [[self mutableCopy] autorelease]; } -- (NSString *) cy$toCYON:(bool)objective { +- (NSString *) cy$toCYON:(bool)objective inSet:(std::set &)objects { + _oassert(objects.insert(self).second); + NSMutableString *json([[[NSMutableString alloc] init] autorelease]); [json appendString:@"@["]; bool comma(false); -#ifdef __APPLE__ +#ifdef __clang__ for (id object in self) { #else for (size_t index(0), count([self count]); index != count; ++index) { @@ -714,8 +782,8 @@ NSObject *CYCopyNSObject(apr_pool_t *pool, JSContextRef context, JSValueRef valu [json appendString:@","]; else comma = true; - if (object == nil || [object cy$JSType] != kJSTypeUndefined) - [json appendString:CYCastNSCYON(object, true)]; + if (object != nil && [object cy$JSType] != kJSTypeUndefined) + [json appendString:CYCastNSCYON(object, true, objects)]; else { [json appendString:@","]; comma = false; @@ -746,7 +814,7 @@ NSObject *CYCopyNSObject(apr_pool_t *pool, JSContextRef context, JSValueRef valu } - (JSValueRef) cy$getProperty:(NSString *)name inContext:(JSContextRef)context { - CYObjectiveTry_(context) { + CYObjectiveTry_ { if ([name isEqualToString:@"length"]) return CYCastJSValue(context, [self count]); } CYObjectiveCatch @@ -775,8 +843,43 @@ NSObject *CYCopyNSObject(apr_pool_t *pool, JSContextRef context, JSValueRef valu /* }}} */ /* Bridge: NSBlock {{{ */ #ifdef __APPLE__ -@interface NSBlock +@interface NSBlock : NSObject - (void) invoke; +@end + +static const char *CYBlockEncoding(NSBlock *self); +static sig::Signature *CYBlockSignature(CYPool &pool, NSBlock *self); + +@implementation NSBlock (Cycript) + +- (NSString *) cy$toCYON:(bool)objective inSet:(std::set &)objects { + CYLocalPool pool; + + sig::Signature *signature(CYBlockSignature(pool, self)); + // XXX: I am checking signature->count due to Decode doing it for block_P + if (signature == NULL || signature->count == 0) + return [super cy$toCYON:objective inSet:objects]; + _oassert(objects.insert(self).second); + + sig::Block type; + sig::Copy(pool, type.signature, *signature); + + CYTypedIdentifier *typed((new(pool) CYTypeExpression(CYDecodeType(pool, &type)))->typed_); + CYTypeFunctionWith *function(typed->Function()); + _assert(function != NULL); + + _assert(function->parameters_ != NULL); + CYObjCBlock *block(new(pool) CYObjCBlock(typed, function->parameters_, NULL)); + + std::ostringstream str; + CYOptions options; + CYOutput out(*str.rdbuf(), options); + block->Output(out, CYNoFlags); + + std::string value(str.str()); + return CYCastNSString(NULL, CYUTF8String(value.c_str(), value.size())); +} + @end #endif /* }}} */ @@ -788,12 +891,12 @@ NSObject *CYCopyNSObject(apr_pool_t *pool, JSContextRef context, JSValueRef valu return kJSTypeBoolean; } -- (NSString *) cy$toCYON:(bool)objective { +- (NSString *) cy$toCYON:(bool)objective inSet:(std::set &)objects { NSString *value([self boolValue] ? @"true" : @"false"); return objective ? value : [NSString stringWithFormat:@"@%@", value]; } -- (JSValueRef) cy$valueOfInContext:(JSContextRef)context { CYObjectiveTry_(context) { +- (JSValueRef) cy$valueOfInContext:(JSContextRef)context { CYObjectiveTry_ { return CYCastJSValue(context, (bool) [self boolValue]); } CYObjectiveCatch } @@ -807,12 +910,14 @@ NSObject *CYCopyNSObject(apr_pool_t *pool, JSContextRef context, JSValueRef valu return [[self mutableCopy] autorelease]; } -- (NSString *) cy$toCYON:(bool)objective { +- (NSString *) cy$toCYON:(bool)objective inSet:(std::set &)objects { + _oassert(objects.insert(self).second); + NSMutableString *json([[[NSMutableString alloc] init] autorelease]); [json appendString:@"@{"]; bool comma(false); -#ifdef __APPLE__ +#ifdef __clang__ for (NSObject *key in self) { #else NSEnumerator *keys([self keyEnumerator]); @@ -822,10 +927,10 @@ NSObject *CYCopyNSObject(apr_pool_t *pool, JSContextRef context, JSValueRef valu [json appendString:@","]; else comma = true; - [json appendString:CYCastNSCYON(key, true)]; + [json appendString:CYCastNSCYON(key, true, objects)]; [json appendString:@":"]; NSObject *object([self objectForKey:key]); - [json appendString:CYCastNSCYON(object, true)]; + [json appendString:CYCastNSCYON(object, true, objects)]; } [json appendString:@"}"]; @@ -843,7 +948,7 @@ NSObject *CYCopyNSObject(apr_pool_t *pool, JSContextRef context, JSValueRef valu - (void) cy$getPropertyNames:(JSPropertyNameAccumulatorRef)names inContext:(JSContextRef)context { [super cy$getPropertyNames:names inContext:context]; -#ifdef __APPLE__ +#ifdef __clang__ for (NSObject *key in self) { #else NSEnumerator *keys([self keyEnumerator]); @@ -866,11 +971,7 @@ NSObject *CYCopyNSObject(apr_pool_t *pool, JSContextRef context, JSValueRef valu if ([name isEqualToString:@"length"]) { // XXX: is this not intelligent? NSNumber *number(reinterpret_cast(value)); -#ifdef __APPLE__ NSUInteger size([number unsignedIntegerValue]); -#else - NSUInteger size([number unsignedIntValue]); -#endif NSUInteger count([self count]); if (size < count) [self removeObjectsInRange:NSMakeRange(size, count - size)]; @@ -945,12 +1046,12 @@ NSObject *CYCopyNSObject(apr_pool_t *pool, JSContextRef context, JSValueRef valu return kJSTypeNumber; } -- (NSString *) cy$toCYON:(bool)objective { +- (NSString *) cy$toCYON:(bool)objective inSet:(std::set &)objects { NSString *value([self cy$JSType] != kJSTypeBoolean ? [self stringValue] : [self boolValue] ? @"true" : @"false"); return objective ? value : [NSString stringWithFormat:@"@%@", value]; } -- (JSValueRef) cy$valueOfInContext:(JSContextRef)context { CYObjectiveTry_(context) { +- (JSValueRef) cy$valueOfInContext:(JSContextRef)context { CYObjectiveTry_ { return [self cy$JSType] != kJSTypeBoolean ? CYCastJSValue(context, [self doubleValue]) : CYCastJSValue(context, static_cast([self boolValue])); } CYObjectiveCatch } @@ -963,12 +1064,12 @@ NSObject *CYCopyNSObject(apr_pool_t *pool, JSContextRef context, JSValueRef valu return kJSTypeNull; } -- (NSString *) cy$toCYON:(bool)objective { +- (NSString *) cy$toCYON:(bool)objective inSet:(std::set &)objects { NSString *value(@"null"); return objective ? value : [NSString stringWithFormat:@"@%@", value]; } -- (JSValueRef) cy$valueOfInContext:(JSContextRef)context { CYObjectiveTry_(context) { +- (JSValueRef) cy$valueOfInContext:(JSContextRef)context { CYObjectiveTry_ { return CYJSNull(context); } CYObjectiveCatch } @@ -985,7 +1086,7 @@ NSObject *CYCopyNSObject(apr_pool_t *pool, JSContextRef context, JSValueRef valu return [self cy$valueOfInContext:context]; } -- (JSValueRef) cy$valueOfInContext:(JSContextRef)context { CYObjectiveTry_(context) { +- (JSValueRef) cy$valueOfInContext:(JSContextRef)context { CYObjectiveTry_ { return NULL; } CYObjectiveCatch } @@ -993,8 +1094,8 @@ NSObject *CYCopyNSObject(apr_pool_t *pool, JSContextRef context, JSValueRef valu return kJSTypeObject; } -- (NSString *) cy$toCYON:(bool)objective { - return [[self description] cy$toCYON:objective]; +- (NSString *) cy$toCYON:(bool)objective inSet:(std::set &)objects { + return [@"#" stringByAppendingString:[[self description] cy$toCYON:true inSet:objects]]; } - (bool) cy$hasProperty:(NSString *)name { @@ -1005,7 +1106,7 @@ NSObject *CYCopyNSObject(apr_pool_t *pool, JSContextRef context, JSValueRef valu return nil; } -- (JSValueRef) cy$getProperty:(NSString *)name inContext:(JSContextRef)context { CYObjectiveTry_(context) { +- (JSValueRef) cy$getProperty:(NSString *)name inContext:(JSContextRef)context { CYObjectiveTry_ { if (NSObject *value = [self cy$getProperty:name]) return CYCastJSValue(context, value); return NULL; @@ -1028,11 +1129,43 @@ NSObject *CYCopyNSObject(apr_pool_t *pool, JSContextRef context, JSValueRef valu @end /* }}} */ +/* Bridge: NSOrderedSet {{{ */ +#ifdef __APPLE__ +@implementation NSOrderedSet (Cycript) + +- (NSString *) cy$toCYON:(bool)objective inSet:(std::set &)objects { + _oassert(objects.insert(self).second); + + NSMutableString *json([[[NSMutableString alloc] init] autorelease]); + [json appendString:@"[NSOrderedSet orderedSetWithArray:"]; + [json appendString:CYCastNSCYON([self array], true, objects)]; + [json appendString:@"]]"]; + return json; +} + +@end +#endif +/* }}} */ /* Bridge: NSProxy {{{ */ @implementation NSProxy (Cycript) -- (NSString *) cy$toCYON:(bool)objective { - return [[self description] cy$toCYON:objective]; +- (NSString *) cy$toCYON:(bool)objective inSet:(std::set &)objects { + return [[self description] cy$toCYON:objective inSet:objects]; +} + +@end +/* }}} */ +/* Bridge: NSSet {{{ */ +@implementation NSSet (Cycript) + +- (NSString *) cy$toCYON:(bool)objective inSet:(std::set &)objects { + _oassert(objects.insert(self).second); + + NSMutableString *json([[[NSMutableString alloc] init] autorelease]); + [json appendString:@"[NSSet setWithArray:"]; + [json appendString:CYCastNSCYON([self allObjects], true, objects)]; + [json appendString:@"]]"]; + return json; } @end @@ -1048,12 +1181,12 @@ NSObject *CYCopyNSObject(apr_pool_t *pool, JSContextRef context, JSValueRef valu return kJSTypeString; } -- (NSString *) cy$toCYON:(bool)objective { +- (NSString *) cy$toCYON:(bool)objective inSet:(std::set &)objects { std::ostringstream str; if (!objective) str << '@'; CYUTF8String string(CYCastUTF8String(self)); - CYStringify(str, string.data, string.size); + CYStringify(str, string.data, string.size, true); std::string value(str.str()); return CYCastNSString(NULL, CYUTF8String(value.c_str(), value.size())); } @@ -1084,7 +1217,7 @@ NSObject *CYCopyNSObject(apr_pool_t *pool, JSContextRef context, JSValueRef valu } } -- (JSValueRef) cy$valueOfInContext:(JSContextRef)context { CYObjectiveTry_(context) { +- (JSValueRef) cy$valueOfInContext:(JSContextRef)context { CYObjectiveTry_ { return CYCastJSValue(context, CYJSString(context, self)); } CYObjectiveCatch } @@ -1097,13 +1230,13 @@ NSObject *CYCopyNSObject(apr_pool_t *pool, JSContextRef context, JSValueRef valu return kJSTypeUndefined; } -- (NSString *) cy$toCYON:(bool)objective { +- (NSString *) cy$toCYON:(bool)objective inSet:(std::set &)objects { NSString *value(@"undefined"); return value; // XXX: maybe use the below code, adding @undefined? //return objective ? value : [NSString stringWithFormat:@"@%@", value]; } -- (JSValueRef) cy$valueOfInContext:(JSContextRef)context { CYObjectiveTry_(context) { +- (JSValueRef) cy$valueOfInContext:(JSContextRef)context { CYObjectiveTry_ { return CYJSUndefined(context); } CYObjectiveCatch } @@ -1111,15 +1244,11 @@ NSObject *CYCopyNSObject(apr_pool_t *pool, JSContextRef context, JSValueRef valu /* }}} */ static bool CYIsClass(id self) { -#ifdef __APPLE__ return class_isMetaClass(object_getClass(self)); -#else - return GSObjCIsClass(self); -#endif } -Class CYCastClass(apr_pool_t *pool, JSContextRef context, JSValueRef value) { - id self(CYCastNSObject(pool, context, value)); +Class CYCastClass(CYPool &pool, JSContextRef context, JSValueRef value) { + id self(CYCastNSObject(&pool, context, value)); if (CYIsClass(self)) return (Class) self; throw CYJSError(context, "got something that is not a Class"); @@ -1131,20 +1260,19 @@ NSArray *CYCastNSArray(JSContextRef context, JSPropertyNameArrayRef names) { size_t size(JSPropertyNameArrayGetCount(names)); NSMutableArray *array([NSMutableArray arrayWithCapacity:size]); for (size_t index(0); index != size; ++index) - [array addObject:CYCastNSString(pool, context, JSPropertyNameArrayGetNameAtIndex(names, index))]; + [array addObject:CYCastNSString(&pool, context, JSPropertyNameArrayGetNameAtIndex(names, index))]; return array; } -JSValueRef CYCastJSValue(JSContextRef context, NSObject *value) { CYPoolTry { +JSValueRef CYCastJSValue(JSContextRef context, NSObject *value) { if (value == nil) return CYJSNull(context); - else - return CYMakeInstance(context, value, false); -} CYPoolCatch(NULL) return /*XXX*/ NULL; } + return CYMakeInstance(context, value); +} @implementation CYJSObject -- (id) initWithJSObject:(JSObjectRef)object inContext:(JSContextRef)context { CYObjectiveTry { +- (id) initWithJSObject:(JSObjectRef)object inContext:(JSContextRef)context { CYObjectiveTry_ { if ((self = [super init]) != nil) { object_ = object; context_ = CYGetJSContext(context); @@ -1159,58 +1287,54 @@ JSValueRef CYCastJSValue(JSContextRef context, NSObject *value) { CYPoolTry { [super dealloc]; } CYObjectiveCatch } -- (NSString *) cy$toCYON:(bool)objective { CYObjectiveTry { +- (NSString *) cy$toCYON:(bool)objective inSet:(std::set &)objects { CYObjectiveTry { CYPool pool; - JSValueRef exception(NULL); - const char *cyon(CYPoolCCYON(pool, context_, object_)); - CYThrow(context_, exception); + const char *cyon(CYPoolCCYON(pool, context, object_, objects)); if (cyon == NULL) - return [super cy$toCYON:objective]; + return [super cy$toCYON:objective inSet:objects]; else return [NSString stringWithUTF8String:cyon]; } CYObjectiveCatch } - (NSUInteger) count { CYObjectiveTry { - JSPropertyNameArrayRef names(JSObjectCopyPropertyNames(context_, object_)); + JSPropertyNameArrayRef names(JSObjectCopyPropertyNames(context, object_)); size_t size(JSPropertyNameArrayGetCount(names)); JSPropertyNameArrayRelease(names); return size; } CYObjectiveCatch } - (id) objectForKey:(id)key { CYObjectiveTry { - JSValueRef value(CYGetProperty(context_, object_, CYJSString(context_, (NSObject *) key))); - if (JSValueIsUndefined(context_, value)) + JSValueRef value(CYGetProperty(context, object_, CYJSString(context, (NSObject *) key))); + if (JSValueIsUndefined(context, value)) return nil; - return CYCastNSObject(NULL, context_, value) ?: [NSNull null]; + return CYCastNSObject(NULL, context, value) ?: [NSNull null]; } CYObjectiveCatch } - (NSEnumerator *) keyEnumerator { CYObjectiveTry { - JSPropertyNameArrayRef names(JSObjectCopyPropertyNames(context_, object_)); - NSEnumerator *enumerator([CYCastNSArray(context_, names) objectEnumerator]); + JSPropertyNameArrayRef names(JSObjectCopyPropertyNames(context, object_)); + NSEnumerator *enumerator([CYCastNSArray(context, names) objectEnumerator]); JSPropertyNameArrayRelease(names); return enumerator; } CYObjectiveCatch } - (void) setObject:(id)object forKey:(id)key { CYObjectiveTry { - CYSetProperty(context_, object_, CYJSString(context_, (NSObject *) key), CYCastJSValue(context_, (NSString *) object)); + CYSetProperty(context, object_, CYJSString(context, (NSObject *) key), CYCastJSValue(context, (NSString *) object)); } CYObjectiveCatch } - (void) removeObjectForKey:(id)key { CYObjectiveTry { - JSValueRef exception(NULL); - (void) JSObjectDeleteProperty(context_, object_, CYJSString(context_, (NSObject *) key), &exception); - CYThrow(context_, exception); + (void) _jsccall(JSObjectDeleteProperty, context, object_, CYJSString(context, (NSObject *) key)); } CYObjectiveCatch } @end @implementation CYJSArray -- (NSString *) cy$toCYON:(bool)objective { +- (NSString *) cy$toCYON:(bool)objective inSet:(std::set &)objects { CYObjectiveTry { CYPool pool; - return [NSString stringWithUTF8String:CYPoolCCYON(pool, context_, object_)]; -} + return [NSString stringWithUTF8String:CYPoolCCYON(pool, context, object_, objects)]; +} CYObjectiveCatch } -- (id) initWithJSObject:(JSObjectRef)object inContext:(JSContextRef)context { CYObjectiveTry { +- (id) initWithJSObject:(JSObjectRef)object inContext:(JSContextRef)context { CYObjectiveTry_ { if ((self = [super init]) != nil) { object_ = object; context_ = CYGetJSContext(context); @@ -1226,62 +1350,54 @@ JSValueRef CYCastJSValue(JSContextRef context, NSObject *value) { CYPoolTry { } CYObjectiveCatch } - (NSUInteger) count { CYObjectiveTry { - return CYArrayLength(context_, object_); + return CYArrayLength(context, object_); } CYObjectiveCatch } - (id) objectAtIndex:(NSUInteger)index { CYObjectiveTry { size_t bounds([self count]); if (index >= bounds) - @throw [NSException exceptionWithName:NSRangeException reason:[NSString stringWithFormat:@"*** -[CYJSArray objectAtIndex:]: index (%zu) beyond bounds (%zu)", index, bounds] userInfo:nil]; - JSValueRef exception(NULL); - JSValueRef value(JSObjectGetPropertyAtIndex(context_, object_, index, &exception)); - CYThrow(context_, exception); - return CYCastNSObject(NULL, context_, value) ?: [NSNull null]; + @throw [NSException exceptionWithName:NSRangeException reason:[NSString stringWithFormat:@"*** -[CYJSArray objectAtIndex:]: index (%zu) beyond bounds (%zu)", static_cast(index), bounds] userInfo:nil]; + JSValueRef value(_jsccall(JSObjectGetPropertyAtIndex, context, object_, index)); + return CYCastNSObject(NULL, context, value) ?: [NSNull null]; } CYObjectiveCatch } - (void) addObject:(id)object { CYObjectiveTry { - CYArrayPush(context_, object_, CYCastJSValue(context_, (NSObject *) object)); + CYArrayPush(context, object_, CYCastJSValue(context, (NSObject *) object)); } CYObjectiveCatch } - (void) insertObject:(id)object atIndex:(NSUInteger)index { CYObjectiveTry { size_t bounds([self count] + 1); if (index >= bounds) - @throw [NSException exceptionWithName:NSRangeException reason:[NSString stringWithFormat:@"*** -[CYJSArray insertObject:atIndex:]: index (%zu) beyond bounds (%zu)", index, bounds] userInfo:nil]; - JSValueRef exception(NULL); + @throw [NSException exceptionWithName:NSRangeException reason:[NSString stringWithFormat:@"*** -[CYJSArray insertObject:atIndex:]: index (%zu) beyond bounds (%zu)", static_cast(index), bounds] userInfo:nil]; JSValueRef arguments[3]; - arguments[0] = CYCastJSValue(context_, index); - arguments[1] = CYCastJSValue(context_, 0); - arguments[2] = CYCastJSValue(context_, (NSObject *) object); - JSObjectRef Array(CYGetCachedObject(context_, CYJSString("Array_prototype"))); - JSObjectCallAsFunction(context_, CYCastJSObject(context_, CYGetProperty(context_, Array, splice_s)), object_, 3, arguments, &exception); - CYThrow(context_, exception); + arguments[0] = CYCastJSValue(context, index); + arguments[1] = CYCastJSValue(context, 0); + arguments[2] = CYCastJSValue(context, (NSObject *) object); + JSObjectRef Array(CYGetCachedObject(context, CYJSString("Array_prototype"))); + _jsccall(JSObjectCallAsFunction, context, CYCastJSObject(context, CYGetProperty(context, Array, splice_s)), object_, 3, arguments); } CYObjectiveCatch } - (void) removeLastObject { CYObjectiveTry { - JSValueRef exception(NULL); - JSObjectRef Array(CYGetCachedObject(context_, CYJSString("Array_prototype"))); - JSObjectCallAsFunction(context_, CYCastJSObject(context_, CYGetProperty(context_, Array, pop_s)), object_, 0, NULL, &exception); - CYThrow(context_, exception); + JSObjectRef Array(CYGetCachedObject(context, CYJSString("Array_prototype"))); + _jsccall(JSObjectCallAsFunction, context, CYCastJSObject(context, CYGetProperty(context, Array, pop_s)), object_, 0, NULL); } CYObjectiveCatch } - (void) removeObjectAtIndex:(NSUInteger)index { CYObjectiveTry { size_t bounds([self count]); if (index >= bounds) - @throw [NSException exceptionWithName:NSRangeException reason:[NSString stringWithFormat:@"*** -[CYJSArray removeObjectAtIndex:]: index (%zu) beyond bounds (%zu)", index, bounds] userInfo:nil]; - JSValueRef exception(NULL); + @throw [NSException exceptionWithName:NSRangeException reason:[NSString stringWithFormat:@"*** -[CYJSArray removeObjectAtIndex:]: index (%zu) beyond bounds (%zu)", static_cast(index), bounds] userInfo:nil]; JSValueRef arguments[2]; - arguments[0] = CYCastJSValue(context_, index); - arguments[1] = CYCastJSValue(context_, 1); - JSObjectRef Array(CYGetCachedObject(context_, CYJSString("Array_prototype"))); - JSObjectCallAsFunction(context_, CYCastJSObject(context_, CYGetProperty(context_, Array, splice_s)), object_, 2, arguments, &exception); - CYThrow(context_, exception); + arguments[0] = CYCastJSValue(context, index); + arguments[1] = CYCastJSValue(context, 1); + JSObjectRef Array(CYGetCachedObject(context, CYJSString("Array_prototype"))); + _jsccall(JSObjectCallAsFunction, context, CYCastJSObject(context, CYGetProperty(context, Array, splice_s)), object_, 2, arguments); } CYObjectiveCatch } - (void) replaceObjectAtIndex:(NSUInteger)index withObject:(id)object { CYObjectiveTry { size_t bounds([self count]); if (index >= bounds) - @throw [NSException exceptionWithName:NSRangeException reason:[NSString stringWithFormat:@"*** -[CYJSArray replaceObjectAtIndex:withObject:]: index (%zu) beyond bounds (%zu)", index, bounds] userInfo:nil]; - CYSetProperty(context_, object_, index, CYCastJSValue(context_, (NSObject *) object)); + @throw [NSException exceptionWithName:NSRangeException reason:[NSString stringWithFormat:@"*** -[CYJSArray replaceObjectAtIndex:withObject:]: index (%zu) beyond bounds (%zu)", static_cast(index), bounds] userInfo:nil]; + CYSetProperty(context, object_, index, CYCastJSValue(context, (NSObject *) object)); } CYObjectiveCatch } @end @@ -1296,18 +1412,18 @@ JSValueRef CYCastJSValue(JSContextRef context, NSObject *value) { CYPoolTry { @implementation CYInternal -- (void) dealloc { +- (void) dealloc { CYObjectiveTry { JSValueUnprotect(context_, object_); JSGlobalContextRelease(context_); [super dealloc]; -} +} CYObjectiveCatch } -- (id) initInContext:(JSContextRef)context { +- (id) initInContext:(JSContextRef)context { CYObjectiveTry_ { if ((self = [super init]) != nil) { context_ = CYGetJSContext(context); JSGlobalContextRetain(context_); } return self; -} +} CYObjectiveCatch } - (bool) hasProperty:(JSStringRef)name inContext:(JSContextRef)context { if (object_ == NULL) @@ -1335,32 +1451,36 @@ JSValueRef CYCastJSValue(JSContextRef context, NSObject *value) { CYPoolTry { } + (CYInternal *) get:(id)object { - if ($objc_getAssociatedObject == NULL) +#ifdef __APPLE__ + if (&objc_getAssociatedObject == NULL) return nil; @synchronized (object) { - if (CYInternal *internal = $objc_getAssociatedObject(object, @selector(cy$internal))) + if (CYInternal *internal = objc_getAssociatedObject(object, @selector(cy$internal))) return internal; } +#endif return nil; } + (CYInternal *) set:(id)object inContext:(JSContextRef)context { - if ($objc_getAssociatedObject == NULL) +#ifdef __APPLE__ + if (&objc_getAssociatedObject == NULL) return nil; @synchronized (object) { - if (CYInternal *internal = $objc_getAssociatedObject(object, @selector(cy$internal))) + if (CYInternal *internal = objc_getAssociatedObject(object, @selector(cy$internal))) return internal; - if ($objc_setAssociatedObject == NULL) + if (&objc_setAssociatedObject == NULL) return nil; CYInternal *internal([[[CYInternal alloc] initInContext:context] autorelease]); objc_setAssociatedObject(object, @selector(cy$internal), internal, OBJC_ASSOCIATION_RETAIN_NONATOMIC); return internal; } +#endif return nil; } @@ -1372,12 +1492,20 @@ static JSObjectRef CYMakeSelector(JSContextRef context, SEL sel) { return JSObjectMake(context, Selector_, internal); } +static JSValueRef CYCastJSValue(JSContextRef context, SEL sel) { + if (sel == NULL) + return CYJSNull(context); + return CYMakeSelector(context, sel); +} + static SEL CYCastSEL(JSContextRef context, JSValueRef value) { if (JSValueIsObjectOfClass(context, value, Selector_)) { Selector_privateData *internal(reinterpret_cast(JSObjectGetPrivate((JSObjectRef) value))); return reinterpret_cast(internal->value_); - } else - return CYCastPointer(context, value); + } else { + CYPool pool; + return sel_registerName(CYPoolCString(pool, context, value)); + } } void *CYObjectiveC_ExecuteStart(JSContextRef context) { CYSadTry { @@ -1388,118 +1516,120 @@ void CYObjectiveC_ExecuteEnd(JSContextRef context, void *handle) { CYSadTry { return [(NSAutoreleasePool *) handle release]; } CYSadCatch() } -JSValueRef CYObjectiveC_RuntimeProperty(JSContextRef context, CYUTF8String name) { CYPoolTry { - if (name == "nil") - return Instance::Make(context, nil); - if (Class _class = objc_getClass(name.data)) - return CYMakeInstance(context, _class, true); - if (Protocol *protocol = objc_getProtocol(name.data)) - return CYMakeInstance(context, protocol, true); - return NULL; -} CYPoolCatch(NULL) return /*XXX*/ NULL; } - -static void CYObjectiveC_CallFunction(JSContextRef context, ffi_cif *cif, void (*function)(), uint8_t *value, void **values) { CYSadTry { - ffi_call(cif, function, value, values); +static void CYObjectiveC_CallFunction(CYPool &pool, JSContextRef context, ffi_cif *cif, void (*function)(), void *value, void **values) { CYSadTry { + CYCallFunction(pool, context, cif, function, value, values); } CYSadCatch() } -static bool CYObjectiveC_PoolFFI(apr_pool_t *pool, JSContextRef context, sig::Type *type, ffi_type *ffi, void *data, JSValueRef value) { CYSadTry { - switch (type->primitive) { - // XXX: do something epic about blocks - case sig::block_P: - case sig::object_P: - case sig::typename_P: - *reinterpret_cast(data) = CYCastNSObject(pool, context, value); - break; +static NSBlock *CYCastNSBlock(CYPool &pool, JSContextRef context, JSValueRef value, const sig::Signature *signature) { +#ifdef __APPLE__ + if (JSValueIsNull(context, value)) + return nil; + JSObjectRef object(CYCastJSObject(context, value)); - case sig::selector_P: - *reinterpret_cast(data) = CYCastSEL(context, value); - break; + if (JSValueIsObjectOfClass(context, object, FunctionInstance_)) + return reinterpret_cast(JSObjectGetPrivate(object))->GetValue(); - default: - return false; + if (JSValueIsObjectOfClass(context, object, Instance_)) { + _assert(reinterpret_cast(JSObjectGetPrivate(object))->GetValue() == nil); + return nil; } - return true; -} CYSadCatch(false) } - -static JSValueRef CYObjectiveC_FromFFI(JSContextRef context, sig::Type *type, ffi_type *ffi, void *data, bool initialize, JSObjectRef owner) { CYPoolTry { - switch (type->primitive) { - // XXX: do something epic about blocks - case sig::block_P: - case sig::object_P: - if (NSObject *object = *reinterpret_cast(data)) { - JSValueRef value(CYCastJSValue(context, object)); - if (initialize) - [object release]; - return value; - } else goto null; - - case sig::typename_P: - return CYMakeInstance(context, *reinterpret_cast(data), true); - - case sig::selector_P: - if (SEL sel = *reinterpret_cast(data)) - return CYMakeSelector(context, sel); - else goto null; - - null: - return CYJSNull(context); - default: - return NULL; - } -} CYPoolCatch(NULL) return /*XXX*/ NULL; } + _assert(JSObjectIsFunction(context, object)); -static bool CYImplements(id object, Class _class, SEL selector, bool devoid = false) { - if (objc_method *method = class_getInstanceMethod(_class, selector)) { - if (!devoid) - return true; -#if OBJC_API_VERSION >= 2 - char type[16]; - method_getReturnType(method, type, sizeof(type)); + _assert(signature != NULL); + _assert(signature->count != 0); + + sig::Signature modified; + modified.count = signature->count + 1; + modified.elements = new(pool) sig::Element[modified.count]; + + modified.elements[0] = signature->elements[0]; + memcpy(modified.elements + 2, signature->elements + 1, sizeof(sig::Element) * (signature->count - 1)); + + modified.elements[1].name = NULL; + modified.elements[1].type = new(pool) sig::Object(); + modified.elements[1].offset = _not(size_t); + + return CYMakeBlock(context, object, modified); #else - const char *type(method_getTypeEncoding(method)); + _assert(false); #endif - if (type[0] != 'v') - return true; - } +} - // XXX: possibly use a more "awesome" check? - return false; +namespace sig { + +void Block::PoolFFI(CYPool *pool, JSContextRef context, ffi_type *ffi, void *data, JSValueRef value) const { + // XXX: this function might not handle the idea of a null pool + *reinterpret_cast(data) = CYCastNSBlock(*pool, context, value, &signature); } -static const char *CYPoolTypeEncoding(apr_pool_t *pool, JSContextRef context, SEL sel, objc_method *method) { - if (method != NULL) - return method_getTypeEncoding(method); +// XXX: assigning to an indirect id * works for return values, but not for properties and fields +void Object::PoolFFI(CYPool *pool, JSContextRef context, ffi_type *ffi, void *data, JSValueRef value) const { + *reinterpret_cast(data) = CYCastNSObject(pool, context, value); +} - const char *name(sel_getName(sel)); - size_t length(strlen(name)); +void Meta::PoolFFI(CYPool *pool, JSContextRef context, ffi_type *ffi, void *data, JSValueRef value) const { + *reinterpret_cast(data) = CYCastNSObject(pool, context, value); +} - char keyed[length + 2]; - keyed[0] = '6'; - keyed[length + 1] = '\0'; - memcpy(keyed + 1, name, length); +void Selector::PoolFFI(CYPool *pool, JSContextRef context, ffi_type *ffi, void *data, JSValueRef value) const { + *reinterpret_cast(data) = CYCastSEL(context, value); +} - if (CYBridgeEntry *entry = CYBridgeHash(keyed, length + 1)) - return entry->value_; +JSValueRef Object::FromFFI(JSContextRef context, ffi_type *ffi, void *data, bool initialize, JSObjectRef owner) const { + NSObject *value(*reinterpret_cast(data)); + if (value == NULL) + return CYJSNull(context); + JSObjectRef object(CYMakeInstance(context, value)); - return NULL; + if (initialize) { + Instance *internal(reinterpret_cast(JSObjectGetPrivate(object))); + + if ((internal->flags_ & Instance::Uninitialized) != 0) { + internal->flags_ = static_cast(internal->flags_ & ~Instance::Uninitialized); + _assert(internal->value_ == nil); + internal->value_ = value; + } + + [value release]; + } + + return object; } -static void MessageClosure_(ffi_cif *cif, void *result, void **arguments, void *arg) { - Closure_privateData *internal(reinterpret_cast(arg)); +JSValueRef Meta::FromFFI(JSContextRef context, ffi_type *ffi, void *data, bool initialize, JSObjectRef owner) const { + if (Class value = *reinterpret_cast(data)) + return CYMakeInstance(context, value, Instance::Permanent); + return CYJSNull(context); +} - JSContextRef context(internal->context_); +JSValueRef Selector::FromFFI(JSContextRef context, ffi_type *ffi, void *data, bool initialize, JSObjectRef owner) const { + return CYCastJSValue(context, *reinterpret_cast(data)); +} - size_t count(internal->cif_.nargs); - JSValueRef values[count]; +JSValueRef Block::FromFFI(JSContextRef context, ffi_type *ffi, void *data, bool initialize, JSObjectRef owner) const { + return CYCastJSValue(context, *reinterpret_cast(data)); +} - for (size_t index(0); index != count; ++index) - values[index] = CYFromFFI(context, internal->signature_.elements[1 + index].type, internal->cif_.arg_types[index], arguments[index]); +} - JSObjectRef _this(CYCastJSObject(context, values[0])); +static bool CYImplements(id object, Class _class, SEL selector, bool devoid = false) { + if (objc_method *method = class_getInstanceMethod(_class, selector)) { + if (!devoid) + return true; + char type[16]; + method_getReturnType(method, type, sizeof(type)); + if (type[0] != 'v') + return true; + } - JSValueRef value(CYCallAsFunction(context, internal->function_, _this, count - 2, values + 2)); - CYPoolFFI(NULL, context, internal->signature_.elements[0].type, internal->cif_.rtype, result, value); + // XXX: possibly use a more "awesome" check? + return false; +} + +static JSValueRef MessageAdapter_(JSContextRef context, size_t count, JSValueRef values[], JSObjectRef function) { + JSObjectRef _this(CYCastJSObject(context, values[0])); + return CYCallAsFunction(context, function, _this, count - 2, values + 2); } static JSObjectRef CYMakeMessage(JSContextRef context, SEL sel, IMP imp, const char *type) { @@ -1507,9 +1637,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, &MessageAdapter_)); // XXX: see notes in Library.cpp about needing to leak return reinterpret_cast(internal->GetValue()); } @@ -1528,7 +1661,7 @@ static bool Messages_hasProperty(JSContextRef context, JSObjectRef object, JSStr return false; } -static JSValueRef Messages_getProperty(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { +static JSValueRef Messages_getProperty(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { CYTry { Messages *internal(reinterpret_cast(JSObjectGetPrivate(object))); Class _class(internal->GetValue()); @@ -1540,19 +1673,16 @@ static JSValueRef Messages_getProperty(JSContextRef context, JSObjectRef object, return CYMakeMessage(context, sel, method_getImplementation(method), method_getTypeEncoding(method)); return NULL; -} +} CYCatch(NULL) } -static bool Messages_setProperty(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef value, JSValueRef *exception) { +static bool Messages_setProperty(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef value, JSValueRef *exception) { CYTry { Messages *internal(reinterpret_cast(JSObjectGetPrivate(object))); Class _class(internal->GetValue()); CYPool pool; const char *name(CYPoolCString(pool, context, property)); - SEL sel(sel_registerName(name)); - objc_method *method(class_getInstanceMethod(_class, sel)); - const char *type; IMP imp; @@ -1560,61 +1690,38 @@ static bool Messages_setProperty(JSContextRef context, JSObjectRef object, JSStr Message_privateData *message(reinterpret_cast(JSObjectGetPrivate((JSObjectRef) value))); type = sig::Unparse(pool, &message->signature_); imp = reinterpret_cast(message->GetValue()); - } else { - type = CYPoolTypeEncoding(pool, context, sel, method); + } else if (objc_method *method = class_getInstanceMethod(_class, sel)) { + type = method_getTypeEncoding(method); imp = CYMakeMessage(context, value, type); - } + } else _assert(false); + + objc_method *method(NULL); + unsigned int size; + objc_method **methods(class_copyMethodList(_class, &size)); + for (size_t i(0); i != size; ++i) + if (sel_isEqual(method_getName(methods[i]), sel)) { + method = methods[i]; + break; + } + free(methods); if (method != NULL) method_setImplementation(method, imp); - else { -#ifdef GNU_RUNTIME - GSMethodList list(GSAllocMethodList(1)); - GSAppendMethodToList(list, sel, type, imp, YES); - GSAddMethodList(_class, list, YES); - GSFlushMethodCacheForClass(_class); -#else + else class_addMethod(_class, sel, imp, type); -#endif - } return true; -} - -#if 0 && OBJC_API_VERSION < 2 -static bool Messages_deleteProperty(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { - Messages *internal(reinterpret_cast(JSObjectGetPrivate(object))); - Class _class(internal->GetValue()); - - CYPool pool; - const char *name(CYPoolCString(pool, context, property)); - - if (SEL sel = sel_getUid(name)) - if (objc_method *method = class_getInstanceMethod(_class, sel)) { - objc_method_list list = {NULL, 1, {method}}; - class_removeMethods(_class, &list); - return true; - } - - return false; -} -#endif +} CYCatch(false) } static void Messages_getPropertyNames(JSContextRef context, JSObjectRef object, JSPropertyNameAccumulatorRef names) { Messages *internal(reinterpret_cast(JSObjectGetPrivate(object))); Class _class(internal->GetValue()); -#if OBJC_API_VERSION >= 2 unsigned int size; objc_method **data(class_copyMethodList(_class, &size)); for (size_t i(0); i != size; ++i) JSPropertyNameAccumulatorAddName(names, CYJSString(sel_getName(method_getName(data[i])))); free(data); -#else - for (objc_method_list *methods(_class->methods); methods != NULL; methods = methods->method_next) - for (int i(0); i != methods->method_count; ++i) - JSPropertyNameAccumulatorAddName(names, CYJSString(sel_getName(method_getName(&methods->method_list[i])))); -#endif } static bool CYHasImplicitProperties(Class _class) { @@ -1632,7 +1739,7 @@ static bool Instance_hasProperty(JSContextRef context, JSObjectRef object, JSStr return true; CYPool pool; - NSString *name(CYCastNSString(pool, context, property)); + NSString *name(CYCastNSString(&pool, context, property)); if (CYInternal *internal = [CYInternal get:self]) if ([internal hasProperty:property inContext:context]) @@ -1649,10 +1756,8 @@ static bool Instance_hasProperty(JSContextRef context, JSObjectRef object, JSStr const char *string(CYPoolCString(pool, context, name)); -#ifdef __APPLE__ if (class_getProperty(_class, string) != NULL) return true; -#endif if (CYHasImplicitProperties(_class)) if (SEL sel = sel_getUid(string)) @@ -1670,7 +1775,7 @@ static JSValueRef Instance_getProperty(JSContextRef context, JSObjectRef object, return Internal::Make(context, self, object); CYPool pool; - NSString *name(CYCastNSString(pool, context, property)); + NSString *name(CYCastNSString(&pool, context, property)); if (CYInternal *internal = [CYInternal get:self]) if (JSValueRef value = [internal getProperty:property inContext:context]) @@ -1684,21 +1789,19 @@ static JSValueRef Instance_getProperty(JSContextRef context, JSObjectRef object, const char *string(CYPoolCString(pool, context, name)); Class _class(object_getClass(self)); -#ifdef __APPLE__ if (objc_property_t property = class_getProperty(_class, string)) { PropertyAttributes attributes(property); SEL sel(sel_registerName(attributes.Getter())); - return CYSendMessage(pool, context, self, NULL, sel, 0, NULL, false, exception); + return CYSendMessage(pool, context, self, NULL, sel, 0, NULL, false); } -#endif if (CYHasImplicitProperties(_class)) if (SEL sel = sel_getUid(string)) if (CYImplements(self, _class, sel, true)) - return CYSendMessage(pool, context, self, NULL, sel, 0, NULL, false, exception); + return CYSendMessage(pool, context, self, NULL, sel, 0, NULL, false); return NULL; -} CYCatch } +} CYCatch(NULL) } static bool Instance_setProperty(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef value, JSValueRef *exception) { CYTry { Instance *internal(reinterpret_cast(JSObjectGetPrivate(object))); @@ -1706,28 +1809,26 @@ static bool Instance_setProperty(JSContextRef context, JSObjectRef object, JSStr CYPool pool; - NSString *name(CYCastNSString(pool, context, property)); - NSObject *data(CYCastNSObject(pool, context, value)); + NSString *name(CYCastNSString(&pool, context, property)); + NSObject *data(CYCastNSObject(&pool, context, value)); CYPoolTry { if ([self cy$setProperty:name to:data]) return true; - } CYPoolCatch(NULL) + } CYPoolCatch(false) const char *string(CYPoolCString(pool, context, name)); Class _class(object_getClass(self)); -#ifdef __APPLE__ if (objc_property_t property = class_getProperty(_class, string)) { PropertyAttributes attributes(property); if (const char *setter = attributes.Setter()) { SEL sel(sel_registerName(setter)); JSValueRef arguments[1] = {value}; - CYSendMessage(pool, context, self, NULL, sel, 1, arguments, false, exception); + CYSendMessage(pool, context, self, NULL, sel, 1, arguments, false); return true; } } -#endif size_t length(strlen(string)); @@ -1748,7 +1849,7 @@ static bool Instance_setProperty(JSContextRef context, JSObjectRef object, JSStr if (SEL sel = sel_getUid(set)) if (CYImplements(self, _class, sel)) { JSValueRef arguments[1] = {value}; - CYSendMessage(pool, context, self, NULL, sel, 1, arguments, false, exception); + CYSendMessage(pool, context, self, NULL, sel, 1, arguments, false); return true; } @@ -1758,7 +1859,7 @@ static bool Instance_setProperty(JSContextRef context, JSObjectRef object, JSStr } return false; -} CYCatch } +} CYCatch(false) } static bool Instance_deleteProperty(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { CYTry { Instance *internal(reinterpret_cast(JSObjectGetPrivate(object))); @@ -1767,8 +1868,8 @@ static bool Instance_deleteProperty(JSContextRef context, JSObjectRef object, JS CYPoolTry { NSString *name(CYCastNSString(NULL, context, property)); return [self cy$deleteProperty:name]; - } CYPoolCatch(NULL) -} CYCatch return /*XXX*/ NULL; } + } CYPoolCatch(false) +} CYCatch(false) return /*XXX*/ false; } static void Instance_getPropertyNames_message(JSPropertyNameAccumulatorRef names, objc_method *method) { const char *name(sel_getName(method_getName(method))); @@ -1789,7 +1890,6 @@ static void Instance_getPropertyNames(JSContextRef context, JSObjectRef object, CYPool pool; Class _class(object_getClass(self)); -#ifdef __APPLE__ { unsigned int size; objc_property_t *data(class_copyPropertyList(_class, &size)); @@ -1797,21 +1897,14 @@ static void Instance_getPropertyNames(JSContextRef context, JSObjectRef object, JSPropertyNameAccumulatorAddName(names, CYJSString(property_getName(data[i]))); free(data); } -#endif if (CYHasImplicitProperties(_class)) for (Class current(_class); current != nil; current = class_getSuperclass(current)) { -#if OBJC_API_VERSION >= 2 unsigned int size; objc_method **data(class_copyMethodList(current, &size)); for (size_t i(0); i != size; ++i) Instance_getPropertyNames_message(names, data[i]); free(data); -#else - for (objc_method_list *methods(current->methods); methods != NULL; methods = methods->method_next) - for (int i(0); i != methods->method_count; ++i) - Instance_getPropertyNames_message(names, &methods->method_list[i]); -#endif } CYPoolTry { @@ -1823,79 +1916,51 @@ static void Instance_getPropertyNames(JSContextRef context, JSObjectRef object, static JSObjectRef Instance_callAsConstructor(JSContextRef context, JSObjectRef object, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry { Instance *internal(reinterpret_cast(JSObjectGetPrivate(object))); - JSObjectRef value(Instance::Make(context, [internal->GetValue() alloc], Instance::Uninitialized)); + JSObjectRef value(CYMakeInstance(context, [internal->GetValue() alloc], Instance::Uninitialized)); return value; -} CYCatch } +} CYCatch(NULL) } -static JSValueRef Instance_callAsFunction(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry { +static const char *CYBlockEncoding(NSBlock *self) { + BlockLiteral *literal(reinterpret_cast(self)); + if ((literal->flags & BLOCK_HAS_SIGNATURE) == 0) + return NULL; + uint8_t *descriptor(reinterpret_cast(literal->descriptor)); + descriptor += sizeof(BlockDescriptor1); + if ((literal->flags & BLOCK_HAS_COPY_DISPOSE) != 0) + descriptor += sizeof(BlockDescriptor2); + BlockDescriptor3 *descriptor3(reinterpret_cast(descriptor)); + return descriptor3->signature; +} + +static sig::Signature *CYBlockSignature(CYPool &pool, NSBlock *self) { + const char *encoding(CYBlockEncoding(self)); + if (encoding == NULL) + return NULL; + // XXX: this should be stored on a FunctionInstance private value subclass + sig::Signature *signature(new(pool) sig::Signature()); + sig::Parse(pool, signature, encoding, &Structor_); + return signature; +} + +static JSValueRef FunctionInstance_callAsFunction(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry { Instance *internal(reinterpret_cast(JSObjectGetPrivate(object))); id self(internal->GetValue()); - if (![self isKindOfClass:NSBlock_]) - CYThrow("non-NSBlock object is not a function"); - // XXX: replace above logic with the following assertion - //_assert([self isKindOfClass:NSBlock_]); - // to do this, make it so FunctionInstance_ is the class of blocks - // to do /that/, generalize the various "is exactly Instance_" checks - // then, move Instance_callAsFunction to only be on FunctionInstance - - struct BlockDescriptor1 { - unsigned long int reserved; - unsigned long int size; - }; - - struct BlockDescriptor2 { - void (*copy_helper)(void *dst, void *src); - void (*dispose_helper)(void *src); - }; - - struct BlockDescriptor3 { - const char *signature; - const char *layout; - }; - - struct BlockLiteral { - Class isa; - int flags; - int reserved; - void (*invoke)(void *, ...); - void *descriptor; - } *literal = reinterpret_cast(self); - - enum { - BLOCK_DEALLOCATING = 0x0001, - BLOCK_REFCOUNT_MASK = 0xfffe, - BLOCK_NEEDS_FREE = 1 << 24, - BLOCK_HAS_COPY_DISPOSE = 1 << 25, - BLOCK_HAS_CTOR = 1 << 26, - BLOCK_IS_GC = 1 << 27, - BLOCK_IS_GLOBAL = 1 << 28, - BLOCK_HAS_STRET = 1 << 29, - BLOCK_HAS_SIGNATURE = 1 << 30, - }; - - if ((literal->flags & BLOCK_HAS_SIGNATURE) != 0) { - uint8_t *descriptor(reinterpret_cast(literal->descriptor)); - descriptor += sizeof(BlockDescriptor1); - if ((literal->flags & BLOCK_HAS_COPY_DISPOSE) != 0) - descriptor += sizeof(BlockDescriptor2); - BlockDescriptor3 *descriptor3(reinterpret_cast(descriptor)); - - if (const char *type = descriptor3->signature) { - CYPool pool; - - void *setup[1]; - setup[0] = &self; - - sig::Signature signature; - sig::Parse(pool, &signature, type, &Structor_); - - ffi_cif cif; - sig::sig_ffi_cif(pool, &sig::ObjectiveC, &signature, &cif); - - void (*function)() = reinterpret_cast(literal->invoke); - return CYCallFunction(pool, context, 1, setup, count, arguments, false, exception, &signature, &cif, function); - } + if (const char *encoding = CYBlockEncoding(self)) { + CYPool pool; + + void *setup[1]; + setup[0] = &self; + + sig::Signature signature; + sig::Parse(pool, &signature, encoding, &Structor_); + + ffi_cif cif; + sig::sig_ffi_cif(pool, &signature, &cif); + + BlockLiteral *literal(reinterpret_cast(self)); + void (*function)() = reinterpret_cast(literal->invoke); + return CYCallFunction(pool, context, 1, setup, count, arguments, false, &signature, &cif, function); } if (count != 0) @@ -1906,7 +1971,7 @@ static JSValueRef Instance_callAsFunction(JSContextRef context, JSObjectRef obje } CYPoolCatch(NULL); return NULL; -} CYCatch } +} CYCatch(NULL) } static bool Instance_hasInstance(JSContextRef context, JSObjectRef constructor, JSValueRef instance, JSValueRef *exception) { CYTry { Instance *internal(reinterpret_cast(JSObjectGetPrivate((JSObjectRef) constructor))); @@ -1921,17 +1986,17 @@ static bool Instance_hasInstance(JSContextRef context, JSObjectRef constructor, } return false; -} CYCatch } +} CYCatch(false) } static JSValueRef Instance_box_callAsFunction(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry { if (count == 0) throw CYJSError(context, "incorrect number of arguments to Instance"); CYPool pool; - id value(CYCastNSObject(pool, context, arguments[0])); + id value(CYCastNSObject(&pool, context, arguments[0])); if (value == nil) value = [NSNull null]; return CYCastJSValue(context, [value cy$box]); -} CYCatch } +} CYCatch(NULL) } static bool Internal_hasProperty(JSContextRef context, JSObjectRef object, JSStringRef property) { Internal *internal(reinterpret_cast(JSObjectGetPrivate(object))); @@ -1946,6 +2011,24 @@ static bool Internal_hasProperty(JSContextRef context, JSObjectRef object, JSStr return false; } +static void CYBitField(unsigned &length, unsigned &shift, id self, Ivar ivar, const char *encoding, unsigned offset) { + length = CYCastDouble(encoding + 1); + shift = 0; + + unsigned int size; + objc_ivar **ivars(class_copyIvarList(object_getClass(self), &size)); + for (size_t i(0); i != size; ++i) + if (ivars[i] == ivar) + break; + else if (ivar_getOffset(ivars[i]) == offset) { + const char *encoding(ivar_getTypeEncoding(ivars[i])); + _assert(encoding != NULL); + _assert(encoding[0] == 'b'); + shift += CYCastDouble(encoding + 1); + } + free(ivars); +} + static JSValueRef Internal_getProperty(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { CYTry { Internal *internal(reinterpret_cast(JSObjectGetPrivate(object))); CYPool pool; @@ -1954,13 +2037,33 @@ static JSValueRef Internal_getProperty(JSContextRef context, JSObjectRef object, const char *name(CYPoolCString(pool, context, property)); if (objc_ivar *ivar = object_getInstanceVariable(self, name, NULL)) { - Type_privateData type(pool, ivar_getTypeEncoding(ivar)); - // XXX: if this fails and throws an exception the person we are throwing it to gets the wrong exception - return CYFromFFI(context, type.type_, type.GetFFI(), reinterpret_cast(self) + ivar_getOffset(ivar)); + ptrdiff_t offset(ivar_getOffset(ivar)); + void *data(reinterpret_cast(self) + offset); + + const char *encoding(ivar_getTypeEncoding(ivar)); + _assert(encoding != NULL); + _assert(encoding[0] != '\0'); + if (encoding[0] == 'b') { + unsigned length, shift; + CYBitField(length, shift, self, ivar, encoding, offset); + _assert(shift + length <= sizeof(uintptr_t) * 8); + uintptr_t &field(*reinterpret_cast(data)); + uintptr_t mask((1 << length) - 1); + return CYCastJSValue(context, (field >> shift) & mask); + } else { +#if defined(__APPLE__) && defined(__LP64__) + // XXX: maybe do even more verifications here + if (strcmp(name, "isa") == 0) + return CYCastJSValue(context, object_getClass(self)); +#endif + + auto type(new(pool) Type_privateData(encoding)); + return type->type_->FromFFI(context, type->GetFFI(), data); + } } return NULL; -} CYCatch } +} CYCatch(NULL) } static bool Internal_setProperty(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef value, JSValueRef *exception) { CYTry { Internal *internal(reinterpret_cast(JSObjectGetPrivate(object))); @@ -1970,29 +2073,37 @@ static bool Internal_setProperty(JSContextRef context, JSObjectRef object, JSStr const char *name(CYPoolCString(pool, context, property)); if (objc_ivar *ivar = object_getInstanceVariable(self, name, NULL)) { - Type_privateData type(pool, ivar_getTypeEncoding(ivar)); - CYPoolFFI(pool, context, type.type_, type.GetFFI(), reinterpret_cast(self) + ivar_getOffset(ivar), value); - return true; + ptrdiff_t offset(ivar_getOffset(ivar)); + void *data(reinterpret_cast(self) + offset); + + const char *encoding(ivar_getTypeEncoding(ivar)); + _assert(encoding != NULL); + if (encoding[0] == 'b') { + unsigned length, shift; + CYBitField(length, shift, self, ivar, encoding, offset); + _assert(shift + length <= sizeof(uintptr_t) * 8); + uintptr_t &field(*reinterpret_cast(data)); + uintptr_t mask((1 << length) - 1); + field = field & ~(mask << shift) | (uintptr_t(CYCastDouble(context, value)) & mask) << shift; + } else { + auto type(new(pool) Type_privateData(ivar_getTypeEncoding(ivar))); + type->type_->PoolFFI(&pool, context, type->GetFFI(), reinterpret_cast(self) + ivar_getOffset(ivar), value); + return true; + } } return false; -} CYCatch } +} CYCatch(false) } static void Internal_getPropertyNames_(Class _class, JSPropertyNameAccumulatorRef names) { if (Class super = class_getSuperclass(_class)) Internal_getPropertyNames_(super, names); -#if OBJC_API_VERSION >= 2 unsigned int size; objc_ivar **data(class_copyIvarList(_class, &size)); for (size_t i(0); i != size; ++i) JSPropertyNameAccumulatorAddName(names, CYJSString(ivar_getName(data[i]))); free(data); -#else - if (objc_ivar_list *ivars = _class->ivars) - for (int i(0); i != ivars->ivar_count; ++i) - JSPropertyNameAccumulatorAddName(names, CYJSString(ivar_getName(&ivars->ivar_list[i]))); -#endif } static void Internal_getPropertyNames(JSContextRef context, JSObjectRef object, JSPropertyNameAccumulatorRef names) { @@ -2005,47 +2116,56 @@ static void Internal_getPropertyNames(JSContextRef context, JSObjectRef object, Internal_getPropertyNames_(_class, names); } -static JSValueRef Internal_callAsFunction_$cya(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { +static JSValueRef Internal_callAsFunction_$cya(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry { Internal *internal(reinterpret_cast(JSObjectGetPrivate(object))); return internal->GetOwner(); +} CYCatch(NULL) } + +static bool ObjectiveC_Classes_hasProperty(JSContextRef context, JSObjectRef object, JSStringRef property) { + CYPool pool; + return objc_getClass(CYPoolCString(pool, context, property)) != Nil; } static JSValueRef ObjectiveC_Classes_getProperty(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { CYTry { CYPool pool; - NSString *name(CYCastNSString(pool, context, property)); + NSString *name(CYCastNSString(&pool, context, property)); if (Class _class = NSClassFromString(name)) - return CYMakeInstance(context, _class, true); + return CYMakeInstance(context, _class, Instance::Permanent); return NULL; -} CYCatch } +} CYCatch(NULL) } -static void ObjectiveC_Classes_getPropertyNames(JSContextRef context, JSObjectRef object, JSPropertyNameAccumulatorRef names) { -#ifdef __APPLE__ - size_t size(objc_getClassList(NULL, 0)); +static Class *CYCopyClassList(size_t &size) { + size = objc_getClassList(NULL, 0); Class *data(reinterpret_cast(malloc(sizeof(Class) * size))); - get: - size_t writ(objc_getClassList(data, size)); - if (size < writ) { + for (;;) { + size_t writ(objc_getClassList(data, size)); + if (writ <= size) { + size = writ; + return data; + } + + Class *copy(reinterpret_cast(realloc(data, sizeof(Class) * writ))); + if (copy == NULL) { + free(data); + return NULL; + } + + data = copy; size = writ; - if (Class *copy = reinterpret_cast(realloc(data, sizeof(Class) * writ))) { - data = copy; - goto get; - } else goto done; } +} - for (size_t i(0); i != writ; ++i) - JSPropertyNameAccumulatorAddName(names, CYJSString(class_getName(data[i]))); - - done: - free(data); -#else - void *state(NULL); - while (Class _class = objc_next_class(&state)) - JSPropertyNameAccumulatorAddName(names, CYJSString(class_getName(_class))); -#endif +static void ObjectiveC_Classes_getPropertyNames(JSContextRef context, JSObjectRef object, JSPropertyNameAccumulatorRef names) { + size_t size; + if (Class *data = CYCopyClassList(size)) { + for (size_t i(0); i != size; ++i) + JSPropertyNameAccumulatorAddName(names, CYJSString(class_getName(data[i]))); + free(data); + } } -#if OBJC_API_VERSION >= 2 +#ifdef __APPLE__ static JSValueRef ObjectiveC_Image_Classes_getProperty(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { CYTry { const char *internal(reinterpret_cast(JSObjectGetPrivate(object))); @@ -2057,7 +2177,7 @@ static JSValueRef ObjectiveC_Image_Classes_getProperty(JSContextRef context, JSO for (size_t i(0); i != size; ++i) if (strcmp(name, data[i]) == 0) { if (Class _class = objc_getClass(name)) { - value = CYMakeInstance(context, _class, true); + value = CYMakeInstance(context, _class, Instance::Permanent); goto free; } else break; @@ -2066,7 +2186,7 @@ static JSValueRef ObjectiveC_Image_Classes_getProperty(JSContextRef context, JSO free: free(data); return value; -} CYCatch } +} CYCatch(NULL) } static void ObjectiveC_Image_Classes_getPropertyNames(JSContextRef context, JSObjectRef object, JSPropertyNameAccumulatorRef names) { const char *internal(reinterpret_cast(JSObjectGetPrivate(object))); @@ -2079,23 +2199,21 @@ static void ObjectiveC_Image_Classes_getPropertyNames(JSContextRef context, JSOb static JSValueRef ObjectiveC_Images_getProperty(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { CYTry { CYPool pool; - const char *name(CYPoolCString(pool, context, property)); + CYUTF8String name(CYPoolUTF8String(pool, context, property)); + unsigned int size; const char **data(objc_copyImageNames(&size)); + pool.atexit(free, data); + for (size_t i(0); i != size; ++i) - if (strcmp(name, data[i]) == 0) { - name = data[i]; - goto free; + if (name == data[i]) { + JSObjectRef value(JSObjectMake(context, NULL, NULL)); + CYSetProperty(context, value, CYJSString("classes"), JSObjectMake(context, ObjectiveC_Image_Classes_, const_cast(data[i]))); + return value; } - name = NULL; - free: - free(data); - if (name == NULL) - return NULL; - JSObjectRef value(JSObjectMake(context, NULL, NULL)); - CYSetProperty(context, value, CYJSString("classes"), JSObjectMake(context, ObjectiveC_Image_Classes_, const_cast(name))); - return value; -} CYCatch } + + return NULL; +} CYCatch(NULL) } static void ObjectiveC_Images_getPropertyNames(JSContextRef context, JSObjectRef object, JSPropertyNameAccumulatorRef names) { unsigned int size; @@ -2110,35 +2228,144 @@ static JSValueRef ObjectiveC_Protocols_getProperty(JSContextRef context, JSObjec CYPool pool; const char *name(CYPoolCString(pool, context, property)); if (Protocol *protocol = objc_getProtocol(name)) - return CYMakeInstance(context, protocol, true); + return CYMakeInstance(context, protocol, Instance::Permanent); return NULL; -} CYCatch } +} CYCatch(NULL) } static void ObjectiveC_Protocols_getPropertyNames(JSContextRef context, JSObjectRef object, JSPropertyNameAccumulatorRef names) { -#if OBJC_API_VERSION >= 2 unsigned int size; Protocol **data(objc_copyProtocolList(&size)); for (size_t i(0); i != size; ++i) JSPropertyNameAccumulatorAddName(names, CYJSString(protocol_getName(data[i]))); free(data); -#else - // XXX: fix this! -#endif } static JSValueRef ObjectiveC_Constants_getProperty(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { CYTry { CYPool pool; CYUTF8String name(CYPoolUTF8String(pool, context, property)); if (name == "nil") - return Instance::Make(context, nil); + return CYJSNull(context); return NULL; -} CYCatch } +} CYCatch(NULL) } static void ObjectiveC_Constants_getPropertyNames(JSContextRef context, JSObjectRef object, JSPropertyNameAccumulatorRef names) { JSPropertyNameAccumulatorAddName(names, CYJSString("nil")); } #ifdef __APPLE__ +static kern_return_t CYReadMemory(task_t task, vm_address_t address, vm_size_t size, void **data) { + *data = reinterpret_cast(address); + return KERN_SUCCESS; +} + +struct CYChoice { + std::set query_; + JSContextRef context_; + JSObjectRef results_; +}; + +struct CYObjectStruct { + Class isa_; +}; + +static void choose_(task_t task, void *baton, unsigned type, vm_range_t *ranges, unsigned count) { + CYChoice *choice(reinterpret_cast(baton)); + JSContextRef context(choice->context_); + + for (unsigned i(0); i != count; ++i) { + vm_range_t &range(ranges[i]); + void *data(reinterpret_cast(range.address)); + size_t size(range.size); + + if (size < sizeof(CYObjectStruct)) + continue; + + uintptr_t *pointers(reinterpret_cast(data)); +#if defined(__APPLE__) && defined(__LP64__) + Class isa(reinterpret_cast(pointers[0] & 0x1fffffff8)); +#else + Class isa(reinterpret_cast(pointers[0])); +#endif + + std::set::const_iterator result(choice->query_.find(isa)); + if (result == choice->query_.end()) + continue; + + size_t needed(class_getInstanceSize(*result)); + // XXX: if (size < needed) + + size_t boundary(496); +#ifdef __LP64__ + boundary *= 2; +#endif + if (needed <= boundary && (needed + 15) / 16 * 16 != size || needed > boundary && (needed + 511) / 512 * 512 != size) + continue; + CYArrayPush(context, choice->results_, CYCastJSValue(context, reinterpret_cast(data))); + } +} + +static JSValueRef choose(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry { + if (count != 1) + throw CYJSError(context, "choose() takes a class argument"); + + CYGarbageCollect(context); + + CYPool pool; + id _class(CYCastNSObject(&pool, context, arguments[0])); + + vm_address_t *zones(NULL); + unsigned size(0); + kern_return_t error(malloc_get_all_zones(0, &CYReadMemory, &zones, &size)); + _assert(error == KERN_SUCCESS); + + JSObjectRef Array(CYGetCachedObject(context, CYJSString("Array"))); + JSObjectRef results(_jsccall(JSObjectCallAsConstructor, context, Array, 0, NULL)); + + CYChoice choice; + choice.context_ = context; + choice.results_ = results; + + size_t number; + Class *classes(CYCopyClassList(number)); + _assert(classes != NULL); + + for (size_t i(0); i != number; ++i) + for (Class current(classes[i]); current != Nil; current = class_getSuperclass(current)) + if (current == _class) { + choice.query_.insert(classes[i]); + break; + } + + free(classes); + + for (unsigned i(0); i != size; ++i) { + const malloc_zone_t *zone(reinterpret_cast(zones[i])); + if (zone == NULL || zone->introspect == NULL) + continue; + + zone->introspect->enumerator(mach_task_self(), &choice, MALLOC_PTR_IN_USE_RANGE_TYPE, zones[i], &CYReadMemory, &choose_); + } + + return results; +} CYCatch(NULL) } +#endif + +#ifdef __APPLE__ +#if defined(__i386__) || defined(__x86_64__) +#define OBJC_MAX_STRUCT_BY_VALUE 8 +static int struct_forward_array[] = { + 0, 0, 0, 1, 0, 1, 1, 1, 0 }; +#elif defined(__arm__) +#define OBJC_MAX_STRUCT_BY_VALUE 1 +static int struct_forward_array[] = { + 0, 0 }; +#elif defined(__arm64__) +#define CY_NO_STRET +#else +#error missing objc-runtime-info +#endif + +#ifndef CY_NO_STRET static bool stret(ffi_type *ffi_type) { return ffi_type->type == FFI_TYPE_STRUCT && ( ffi_type->size > OBJC_MAX_STRUCT_BY_VALUE || @@ -2146,8 +2373,11 @@ static bool stret(ffi_type *ffi_type) { ); } #endif +#else +#define CY_NO_STRET +#endif -JSValueRef CYSendMessage(apr_pool_t *pool, JSContextRef context, id self, Class _class, SEL _cmd, size_t count, const JSValueRef arguments[], bool initialize, JSValueRef *exception) { CYTry { +JSValueRef CYSendMessage(CYPool &pool, JSContextRef context, id self, Class _class, SEL _cmd, size_t count, const JSValueRef arguments[], bool initialize) { const char *type; if (_class == NULL) @@ -2162,11 +2392,14 @@ JSValueRef CYSendMessage(apr_pool_t *pool, JSContextRef context, id self, Class imp = NULL; CYPoolTry { - NSMethodSignature *method([self methodSignatureForSelector:_cmd]); - if (method == nil) - throw CYJSError(context, "unrecognized selector %s sent to object %p", sel_getName(_cmd), self); - type = CYPoolCString(pool, context, [method _typeString]); + if (NSMethodSignature *method = [self methodSignatureForSelector:_cmd]) + type = CYPoolCString(pool, context, [method _typeString]); + else + type = NULL; } CYPoolCatch(NULL) + + if (type == NULL) + throw CYJSError(context, "unrecognized selector %s sent to object %p", sel_getName(_cmd), self); } void *setup[2]; @@ -2185,11 +2418,7 @@ JSValueRef CYSendMessage(apr_pool_t *pool, JSContextRef context, id self, Class sig::Element *element(&elements[index]); element->name = NULL; element->offset = _not(size_t); - - sig::Type *type(new (pool) sig::Type); - memset(type, 0, sizeof(*type)); - type->primitive = sig::object_P; - element->type = type; + element->type = new(pool) sig::Object(); } signature.elements = elements; @@ -2197,25 +2426,22 @@ JSValueRef CYSendMessage(apr_pool_t *pool, JSContextRef context, id self, Class } ffi_cif cif; - sig::sig_ffi_cif(pool, &sig::ObjectiveC, &signature, &cif); + sig::sig_ffi_cif(pool, &signature, &cif); if (imp == NULL) { -#ifdef __APPLE__ +#ifndef CY_NO_STRET if (stret(cif.rtype)) imp = class_getMethodImplementation_stret(_class, _cmd); else - imp = class_getMethodImplementation(_class, _cmd); -#else - objc_super super = {self, _class}; - imp = objc_msg_lookup_super(&super, _cmd); #endif + imp = class_getMethodImplementation(_class, _cmd); } void (*function)() = reinterpret_cast(imp); - return CYCallFunction(pool, context, 2, setup, count, arguments, initialize, exception, &signature, &cif, function); -} CYCatch } + return CYCallFunction(pool, context, 2, setup, count, arguments, initialize, &signature, &cif, function); +} -static JSValueRef $objc_msgSend(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry { +static JSValueRef $objc_msgSend(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[]) { if (count < 2) throw CYJSError(context, "too few arguments to objc_msgSend"); @@ -2240,7 +2466,7 @@ static JSValueRef $objc_msgSend(JSContextRef context, JSObjectRef object, JSObje if (uninitialized) internal->value_ = nil; } else { - self = CYCastNSObject(pool, context, arguments[0]); + self = CYCastNSObject(&pool, context, arguments[0]); _class = nil; uninitialized = false; } @@ -2250,39 +2476,43 @@ static JSValueRef $objc_msgSend(JSContextRef context, JSObjectRef object, JSObje _cmd = CYCastSEL(context, arguments[1]); - return CYSendMessage(pool, context, self, _class, _cmd, count - 2, arguments + 2, uninitialized, exception); -} CYCatch } + return CYSendMessage(pool, context, self, _class, _cmd, count - 2, arguments + 2, uninitialized); +} -static JSValueRef Selector_callAsFunction(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { +static JSValueRef $objc_msgSend(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry { + return $objc_msgSend(context, object, _this, count, arguments); +} CYCatch(NULL) } + +static JSValueRef Selector_callAsFunction(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry { JSValueRef setup[count + 2]; setup[0] = _this; setup[1] = object; memcpy(setup + 2, arguments, sizeof(JSValueRef) * count); - return $objc_msgSend(context, NULL, NULL, count + 2, setup, exception); -} + return $objc_msgSend(context, NULL, NULL, count + 2, setup); +} CYCatch(NULL) } -static JSValueRef Message_callAsFunction(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { +static JSValueRef Message_callAsFunction(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry { CYPool pool; Message_privateData *internal(reinterpret_cast(JSObjectGetPrivate(object))); // XXX: handle Instance::Uninitialized? - id self(CYCastNSObject(pool, context, _this)); + id self(CYCastNSObject(&pool, context, _this)); void *setup[2]; setup[0] = &self; setup[1] = &internal->sel_; - return CYCallFunction(pool, context, 2, setup, count, arguments, false, exception, &internal->signature_, &internal->cif_, internal->GetValue()); -} + return CYCallFunction(pool, context, 2, setup, count, arguments, false, &internal->signature_, &internal->cif_, internal->GetValue()); +} CYCatch(NULL) } static JSObjectRef Super_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 Super constructor"); + throw CYJSError(context, "incorrect number of arguments to objc_super constructor"); CYPool pool; - id self(CYCastNSObject(pool, context, arguments[0])); + id self(CYCastNSObject(&pool, context, arguments[0])); Class _class(CYCastClass(pool, context, arguments[1])); return cy::Super::Make(context, self, _class); -} CYCatch } +} CYCatch(NULL) } static JSObjectRef Selector_new(JSContextRef context, JSObjectRef object, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry { if (count != 1) @@ -2290,42 +2520,52 @@ static JSObjectRef Selector_new(JSContextRef context, JSObjectRef object, size_t CYPool pool; const char *name(CYPoolCString(pool, context, arguments[0])); return CYMakeSelector(context, sel_registerName(name)); -} CYCatch } +} CYCatch(NULL) } static JSObjectRef Instance_new(JSContextRef context, JSObjectRef object, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry { - if (count > 1) + if (count != 1) throw CYJSError(context, "incorrect number of arguments to Instance constructor"); - id self(count == 0 ? nil : CYCastPointer(context, arguments[0])); - return CYMakeInstance(context, self, false); -} CYCatch } + return CYMakeInstance(context, CYCastPointer(context, arguments[0])); +} CYCatch(NULL) } -static JSValueRef CYValue_getProperty_value(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { +static JSValueRef CYValue_getProperty_value(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { CYTry { CYValue *internal(reinterpret_cast(JSObjectGetPrivate(object))); return CYCastJSValue(context, reinterpret_cast(internal->value_)); -} +} CYCatch(NULL) } -static JSValueRef CYValue_callAsFunction_$cya(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { +static JSValueRef CYValue_callAsFunction_$cya(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry { CYValue *internal(reinterpret_cast(JSObjectGetPrivate(_this))); Type_privateData *typical(internal->GetType()); + sig::Void XXX; + sig::Type *type; ffi_type *ffi; if (typical == NULL) { - type = NULL; + type = &XXX; ffi = NULL; } else { type = typical->type_; ffi = typical->ffi_; } - return CYMakePointer(context, &internal->value_, _not(size_t), type, ffi, object); -} + return CYMakePointer(context, &internal->value_, *type, ffi, object); +} CYCatch(NULL) } -static JSValueRef Instance_getProperty_constructor(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { +static JSValueRef FunctionInstance_getProperty_type(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { CYTry { Instance *internal(reinterpret_cast(JSObjectGetPrivate(object))); - return Instance::Make(context, (id) object_getClass(internal->GetValue())); -} + CYPool pool; + sig::Signature *signature(CYBlockSignature(pool, internal->GetValue())); + if (signature == NULL) + return CYJSNull(context); + return CYMakeType(context, signature); +} CYCatch(NULL) } + +static JSValueRef Instance_getProperty_constructor(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { CYTry { + Instance *internal(reinterpret_cast(JSObjectGetPrivate(object))); + return CYMakeInstance(context, object_getClass(internal->GetValue()), Instance::Permanent); +} CYCatch(NULL) } static JSValueRef Instance_getProperty_prototype(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { CYTry { Instance *internal(reinterpret_cast(JSObjectGetPrivate(object))); @@ -2333,23 +2573,25 @@ static JSValueRef Instance_getProperty_prototype(JSContextRef context, JSObjectR if (!CYIsClass(self)) return CYJSUndefined(context); return CYGetClassPrototype(context, self); -} CYCatch } +} CYCatch(NULL) } -static JSValueRef Instance_getProperty_messages(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { +static JSValueRef Instance_getProperty_messages(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { CYTry { Instance *internal(reinterpret_cast(JSObjectGetPrivate(object))); id self(internal->GetValue()); if (!CYIsClass(self)) return CYJSUndefined(context); return Messages::Make(context, (Class) self); -} +} CYCatch(NULL) } static JSValueRef Instance_callAsFunction_toCYON(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry { + std::set *objects(CYCastObjects(context, _this, count, arguments)); + if (!CYJSValueIsNSObject(context, _this)) return NULL; Instance *internal(reinterpret_cast(JSObjectGetPrivate(_this))); - return CYCastJSValue(context, CYJSString(context, CYCastNSCYON(internal->GetValue(), false))); -} CYCatch } + return CYCastJSValue(context, CYJSString(context, CYCastNSCYON(internal->GetValue(), false, objects))); +} CYCatch(NULL) } static JSValueRef Instance_callAsFunction_toJSON(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry { if (!CYJSValueIsNSObject(context, _this)) @@ -2372,7 +2614,7 @@ static JSValueRef Instance_callAsFunction_toJSON(JSContextRef context, JSObjectR else return CYCastJSValue(context, CYJSString(context, [value description])); } CYPoolCatch(NULL) -} CYCatch return /*XXX*/ NULL; } +} CYCatch(NULL) return /*XXX*/ NULL; } static JSValueRef Instance_callAsFunction_valueOf(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry { if (!CYJSValueIsNSObject(context, _this)) @@ -2380,6 +2622,7 @@ static JSValueRef Instance_callAsFunction_valueOf(JSContextRef context, JSObject Instance *internal(reinterpret_cast(JSObjectGetPrivate(_this))); id value(internal->GetValue()); + _assert(value != nil); if (![value respondsToSelector:@selector(cy$valueOfInContext:)]) return _this; @@ -2388,7 +2631,7 @@ static JSValueRef Instance_callAsFunction_valueOf(JSContextRef context, JSObject return result; return _this; -} CYCatch return /*XXX*/ NULL; } +} CYCatch(NULL) return /*XXX*/ NULL; } static JSValueRef Instance_callAsFunction_toPointer(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry { if (!CYJSValueIsNSObject(context, _this)) @@ -2397,7 +2640,7 @@ static JSValueRef Instance_callAsFunction_toPointer(JSContextRef context, JSObje Instance *internal(reinterpret_cast(JSObjectGetPrivate(_this))); // XXX: but... but... THIS ISN'T A POINTER! :( return CYCastJSValue(context, reinterpret_cast(internal->GetValue())); -} CYCatch return /*XXX*/ NULL; } +} CYCatch(NULL) return /*XXX*/ NULL; } static JSValueRef Instance_callAsFunction_toString(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry { if (!CYJSValueIsNSObject(context, _this)) @@ -2406,19 +2649,30 @@ static JSValueRef Instance_callAsFunction_toString(JSContextRef context, JSObjec Instance *internal(reinterpret_cast(JSObjectGetPrivate(_this))); id value(internal->GetValue()); - if (value == nil) - return CYCastJSValue(context, "nil"); - CYPoolTry { // XXX: this seems like a stupid implementation; what if it crashes? why not use the CYONifier backend? return CYCastJSValue(context, CYJSString(context, [value description])); } CYPoolCatch(NULL) -} CYCatch return /*XXX*/ NULL; } +} CYCatch(NULL) return /*XXX*/ NULL; } + +static JSValueRef Class_callAsFunction_pointerTo(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry { + if (!CYJSValueIsNSObject(context, _this)) + return NULL; + + Instance *internal(reinterpret_cast(JSObjectGetPrivate(_this))); + id value(internal->GetValue()); + + if (!CYIsClass(value)) + CYThrow("non-Class object cannot be used as Type"); + + sig::Object type(class_getName(value)); + return CYMakeType(context, type); +} CYCatch(NULL) return /*XXX*/ NULL; } static JSValueRef Selector_callAsFunction_toString(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry { Selector_privateData *internal(reinterpret_cast(JSObjectGetPrivate(_this))); return CYCastJSValue(context, sel_getName(internal->GetValue())); -} CYCatch } +} CYCatch(NULL) } static JSValueRef Selector_callAsFunction_toJSON(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { return Selector_callAsFunction_toString(context, object, _this, count, arguments, exception); @@ -2432,7 +2686,7 @@ static JSValueRef Selector_callAsFunction_toCYON(JSContextRef context, JSObjectR NSString *string([NSString stringWithFormat:@"@selector(%s)", name]); return CYCastJSValue(context, CYJSString(context, string)); } CYPoolCatch(NULL) -} CYCatch return /*XXX*/ NULL; } +} CYCatch(NULL) return /*XXX*/ NULL; } static JSValueRef Selector_callAsFunction_type(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry { if (count != 1) @@ -2442,23 +2696,21 @@ static JSValueRef Selector_callAsFunction_type(JSContextRef context, JSObjectRef Selector_privateData *internal(reinterpret_cast(JSObjectGetPrivate(_this))); SEL sel(internal->GetValue()); - objc_method *method; - if (Class _class = CYCastClass(pool, context, arguments[0])) - method = class_getInstanceMethod(_class, sel); - else - method = NULL; - - if (const char *type = CYPoolTypeEncoding(pool, context, sel, method)) - return CYCastJSValue(context, CYJSString(type)); + Class _class(_require(CYCastClass(pool, context, arguments[0]))); + objc_method *method(_require(class_getInstanceMethod(_class, sel))); + const char *encoding(method_getTypeEncoding(method)); - return CYJSNull(context); -} CYCatch } + sig::Signature signature; + sig::Parse(pool, &signature, encoding, &Structor_); + return CYMakeType(context, &signature); +} CYCatch(NULL) } static JSStaticValue Selector_staticValues[2] = { {"value", &CYValue_getProperty_value, NULL, kJSPropertyAttributeReadOnly | kJSPropertyAttributeDontDelete}, {NULL, NULL, NULL, 0} }; +// XXX: this is sadly duplicated in FunctionInstance_staticValues static JSStaticValue Instance_staticValues[5] = { {"constructor", &Instance_getProperty_constructor, NULL, kJSPropertyAttributeReadOnly | kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, {"messages", &Instance_getProperty_messages, NULL, kJSPropertyAttributeReadOnly | kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, @@ -2467,6 +2719,16 @@ static JSStaticValue Instance_staticValues[5] = { {NULL, NULL, NULL, 0} }; +static JSStaticValue FunctionInstance_staticValues[6] = { + {"type", &FunctionInstance_getProperty_type, NULL, kJSPropertyAttributeReadOnly | kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, + // XXX: this is sadly a duplicate of Instance_staticValues + {"constructor", &Instance_getProperty_constructor, NULL, kJSPropertyAttributeReadOnly | kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, + {"messages", &Instance_getProperty_messages, NULL, kJSPropertyAttributeReadOnly | kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, + {"prototype", &Instance_getProperty_prototype, NULL, kJSPropertyAttributeReadOnly | kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, + {"value", &CYValue_getProperty_value, NULL, kJSPropertyAttributeReadOnly | kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, + {NULL, NULL, NULL, 0} +}; + static JSStaticFunction Instance_staticFunctions[7] = { {"$cya", &CYValue_callAsFunction_$cya, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, {"toCYON", &Instance_callAsFunction_toCYON, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, @@ -2477,6 +2739,11 @@ static JSStaticFunction Instance_staticFunctions[7] = { {NULL, NULL, 0} }; +static JSStaticFunction Class_staticFunctions[2] = { + {"pointerTo", &Class_callAsFunction_pointerTo, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, + {NULL, NULL, 0} +}; + static JSStaticFunction Internal_staticFunctions[2] = { {"$cya", &Internal_callAsFunction_$cya, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, {NULL, NULL, 0} @@ -2491,41 +2758,40 @@ static JSStaticFunction Selector_staticFunctions[5] = { }; #ifdef __APPLE__ -JSValueRef NSCFType$cy$toJSON$inContext$(id self, SEL sel, JSValueRef key, JSContextRef context) { CYObjectiveTry_(context) { +JSValueRef NSCFType$cy$toJSON$inContext$(id self, SEL sel, JSValueRef key, JSContextRef context) { CYObjectiveTry_ { return CYCastJSValue(context, [(NSString *) CFCopyDescription((CFTypeRef) self) autorelease]); } CYObjectiveCatch } #endif void CYObjectiveC_Initialize() { /*XXX*/ JSContextRef context(NULL); CYPoolTry { - $objc_setAssociatedObject = reinterpret_cast(dlsym(RTLD_DEFAULT, "objc_setAssociatedObject")); - $objc_getAssociatedObject = reinterpret_cast(dlsym(RTLD_DEFAULT, "objc_getAssociatedObject")); - $objc_removeAssociatedObjects = reinterpret_cast(dlsym(RTLD_DEFAULT, "objc_removeAssociatedObjects")); + CYPool &pool(CYGetGlobalPool()); - apr_pool_t *pool(CYGetGlobalPool()); + Object_type = new(pool) Type_privateData(sig::Object()); + Selector_type = new(pool) Type_privateData(sig::Selector()); - Object_type = new(pool) Type_privateData("@"); - Selector_type = new(pool) Type_privateData(":"); + NSArray_ = objc_getClass("NSArray"); + NSBlock_ = objc_getClass("NSBlock"); + NSDictionary_ = objc_getClass("NSDictionary"); + NSNumber_ = objc_getClass("NSNumber"); + NSString_ = objc_getClass("NSString"); + Object_ = objc_getClass("Object"); #ifdef __APPLE__ + __NSMallocBlock__ = objc_getClass("__NSMallocBlock__"); + // XXX: apparently, iOS now has both of these NSCFBoolean_ = objc_getClass("__NSCFBoolean"); if (NSCFBoolean_ == nil) NSCFBoolean_ = objc_getClass("NSCFBoolean"); NSCFType_ = objc_getClass("NSCFType"); - NSGenericDeallocHandler_ = objc_getClass("__NSGenericDeallocHandler"); - NSMessageBuilder_ = objc_getClass("NSMessageBuilder"); + NSZombie_ = objc_getClass("_NSZombie_"); #else NSBoolNumber_ = objc_getClass("NSBoolNumber"); + NSZombie_ = objc_getClass("NSZombie"); #endif - NSArray_ = objc_getClass("NSArray"); - NSBlock_ = objc_getClass("NSBlock"); - NSDictionary_ = objc_getClass("NSDictionary"); - NSString_ = objc_getClass("NSString"); - Object_ = objc_getClass("Object"); - JSClassDefinition definition; definition = kJSClassDefinitionEmpty; @@ -2538,7 +2804,6 @@ void CYObjectiveC_Initialize() { /*XXX*/ JSContextRef context(NULL); CYPoolTry { definition.deleteProperty = &Instance_deleteProperty; definition.getPropertyNames = &Instance_getPropertyNames; definition.callAsConstructor = &Instance_callAsConstructor; - definition.callAsFunction = &Instance_callAsFunction; definition.hasInstance = &Instance_hasInstance; definition.finalize = &CYFinalize; Instance_ = JSClassCreate(&definition); @@ -2546,18 +2811,28 @@ void CYObjectiveC_Initialize() { /*XXX*/ JSContextRef context(NULL); CYPoolTry { definition.className = "ArrayInstance"; ArrayInstance_ = JSClassCreate(&definition); + definition.className = "BooleanInstance"; + BooleanInstance_ = JSClassCreate(&definition); + + definition.className = "NumberInstance"; + NumberInstance_ = JSClassCreate(&definition); + definition.className = "ObjectInstance"; ObjectInstance_ = JSClassCreate(&definition); definition.className = "StringInstance"; StringInstance_ = JSClassCreate(&definition); - definition.className = "TypeInstance"; - TypeInstance_ = JSClassCreate(&definition); - definition.className = "FunctionInstance"; + definition.staticValues = FunctionInstance_staticValues; + definition.callAsFunction = &FunctionInstance_callAsFunction; FunctionInstance_ = JSClassCreate(&definition); + definition = kJSClassDefinitionEmpty; + definition.className = "Class"; + definition.staticFunctions = Class_staticFunctions; + Class_ = JSClassCreate(&definition); + definition = kJSClassDefinitionEmpty; definition.className = "Internal"; definition.staticFunctions = Internal_staticFunctions; @@ -2571,6 +2846,7 @@ void CYObjectiveC_Initialize() { /*XXX*/ JSContextRef context(NULL); CYPoolTry { definition = kJSClassDefinitionEmpty; definition.className = "Message"; definition.staticFunctions = cy::Functor::StaticFunctions; + definition.staticValues = cy::Functor::StaticValues; definition.callAsFunction = &Message_callAsFunction; definition.finalize = &CYFinalize; Message_ = JSClassCreate(&definition); @@ -2580,9 +2856,6 @@ void CYObjectiveC_Initialize() { /*XXX*/ JSContextRef context(NULL); CYPoolTry { definition.hasProperty = &Messages_hasProperty; definition.getProperty = &Messages_getProperty; definition.setProperty = &Messages_setProperty; -#if 0 && OBJC_API_VERSION < 2 - definition.deleteProperty = &Messages_deleteProperty; -#endif definition.getPropertyNames = &Messages_getPropertyNames; definition.finalize = &CYFinalize; Messages_ = JSClassCreate(&definition); @@ -2603,6 +2876,7 @@ void CYObjectiveC_Initialize() { /*XXX*/ JSContextRef context(NULL); CYPoolTry { definition = kJSClassDefinitionEmpty; definition.className = "ObjectiveC::Classes"; + definition.hasProperty = &ObjectiveC_Classes_hasProperty; definition.getProperty = &ObjectiveC_Classes_getProperty; definition.getPropertyNames = &ObjectiveC_Classes_getPropertyNames; ObjectiveC_Classes_ = JSClassCreate(&definition); @@ -2613,7 +2887,7 @@ void CYObjectiveC_Initialize() { /*XXX*/ JSContextRef context(NULL); CYPoolTry { definition.getPropertyNames = &ObjectiveC_Constants_getPropertyNames; ObjectiveC_Constants_ = JSClassCreate(&definition); -#if OBJC_API_VERSION >= 2 +#ifdef __APPLE__ definition = kJSClassDefinitionEmpty; definition.className = "ObjectiveC::Images"; definition.getProperty = &ObjectiveC_Images_getProperty; @@ -2634,7 +2908,14 @@ void CYObjectiveC_Initialize() { /*XXX*/ JSContextRef context(NULL); CYPoolTry { ObjectiveC_Protocols_ = JSClassCreate(&definition); #ifdef __APPLE__ - class_addMethod(NSCFType_, @selector(cy$toJSON:inContext:), reinterpret_cast(&NSCFType$cy$toJSON$inContext$), "^{OpaqueJSValue=}16@0:4@8^{OpaqueJSContext=}12"); + class_addMethod(NSCFType_, @selector(cy$toJSON:inContext:), reinterpret_cast(&NSCFType$cy$toJSON$inContext$), + // XXX: this is horrible; there has to be a better way to do this + #ifdef __LP64__ + "^{OpaqueJSValue=}32@0:8@16^{OpaqueJSContext=}24" + #else + "^{OpaqueJSValue=}16@0:4@8^{OpaqueJSContext=}12" + #endif + ); #endif } CYPoolCatch() } @@ -2660,10 +2941,11 @@ void CYObjectiveC_SetupContext(JSContextRef context) { CYPoolTry { CYSetProperty(context, ObjectiveC, CYJSString("constants"), constants); CYArrayPush(context, alls, constants); -#if OBJC_API_VERSION >= 2 +#ifdef __APPLE__ CYSetProperty(context, ObjectiveC, CYJSString("images"), JSObjectMake(context, ObjectiveC_Images_, NULL)); #endif + JSObjectRef Class(JSObjectMakeConstructor(context, Class_, NULL)); JSObjectRef Instance(JSObjectMakeConstructor(context, Instance_, &Instance_new)); JSObjectRef Message(JSObjectMakeConstructor(context, Message_, NULL)); JSObjectRef Selector(JSObjectMakeConstructor(context, Selector_, &Selector_new)); @@ -2676,63 +2958,104 @@ void CYObjectiveC_SetupContext(JSContextRef context) { CYPoolTry { JSObjectRef ArrayInstance_prototype(CYCastJSObject(context, CYGetProperty(context, ArrayInstance, prototype_s))); CYSetProperty(context, cy, CYJSString("ArrayInstance_prototype"), ArrayInstance_prototype); JSObjectRef Array_prototype(CYGetCachedObject(context, CYJSString("Array_prototype"))); - JSObjectSetPrototype(context, ArrayInstance_prototype, Array_prototype); + CYSetPrototype(context, ArrayInstance_prototype, Array_prototype); + + JSObjectRef BooleanInstance(JSObjectMakeConstructor(context, BooleanInstance_, NULL)); + JSObjectRef BooleanInstance_prototype(CYCastJSObject(context, CYGetProperty(context, BooleanInstance, prototype_s))); + CYSetProperty(context, cy, CYJSString("BooleanInstance_prototype"), BooleanInstance_prototype); + JSObjectRef Boolean_prototype(CYGetCachedObject(context, CYJSString("Boolean_prototype"))); + CYSetPrototype(context, BooleanInstance_prototype, Boolean_prototype); JSObjectRef FunctionInstance(JSObjectMakeConstructor(context, FunctionInstance_, NULL)); JSObjectRef FunctionInstance_prototype(CYCastJSObject(context, CYGetProperty(context, FunctionInstance, prototype_s))); CYSetProperty(context, cy, CYJSString("FunctionInstance_prototype"), FunctionInstance_prototype); JSObjectRef Function_prototype(CYGetCachedObject(context, CYJSString("Function_prototype"))); - JSObjectSetPrototype(context, FunctionInstance_prototype, Function_prototype); + CYSetPrototype(context, FunctionInstance_prototype, Function_prototype); + + JSObjectRef NumberInstance(JSObjectMakeConstructor(context, NumberInstance_, NULL)); + JSObjectRef NumberInstance_prototype(CYCastJSObject(context, CYGetProperty(context, NumberInstance, prototype_s))); + CYSetProperty(context, cy, CYJSString("NumberInstance_prototype"), NumberInstance_prototype); + JSObjectRef Number_prototype(CYGetCachedObject(context, CYJSString("Number_prototype"))); + CYSetPrototype(context, NumberInstance_prototype, Number_prototype); JSObjectRef ObjectInstance(JSObjectMakeConstructor(context, ObjectInstance_, NULL)); JSObjectRef ObjectInstance_prototype(CYCastJSObject(context, CYGetProperty(context, ObjectInstance, prototype_s))); CYSetProperty(context, cy, CYJSString("ObjectInstance_prototype"), ObjectInstance_prototype); JSObjectRef Object_prototype(CYGetCachedObject(context, CYJSString("Object_prototype"))); - JSObjectSetPrototype(context, ObjectInstance_prototype, Object_prototype); + CYSetPrototype(context, ObjectInstance_prototype, Object_prototype); JSObjectRef StringInstance(JSObjectMakeConstructor(context, StringInstance_, NULL)); JSObjectRef StringInstance_prototype(CYCastJSObject(context, CYGetProperty(context, StringInstance, prototype_s))); CYSetProperty(context, cy, CYJSString("StringInstance_prototype"), StringInstance_prototype); JSObjectRef String_prototype(CYGetCachedObject(context, CYJSString("String_prototype"))); - JSObjectSetPrototype(context, StringInstance_prototype, String_prototype); + CYSetPrototype(context, StringInstance_prototype, String_prototype); - JSObjectRef TypeInstance(JSObjectMakeConstructor(context, TypeInstance_, NULL)); - JSObjectRef TypeInstance_prototype(CYCastJSObject(context, CYGetProperty(context, TypeInstance, prototype_s))); - CYSetProperty(context, cy, CYJSString("TypeInstance_prototype"), TypeInstance_prototype); - JSObjectRef Type_prototype(CYGetCachedObject(context, CYJSString("Type_prototype"))); - JSObjectSetPrototype(context, TypeInstance_prototype, Type_prototype); + JSObjectRef Class_prototype(CYCastJSObject(context, CYGetProperty(context, Class, prototype_s))); + CYSetProperty(context, cy, CYJSString("Class_prototype"), Class_prototype); + CYSetPrototype(context, Class_prototype, Instance_prototype); CYSetProperty(context, cycript, CYJSString("Instance"), Instance); CYSetProperty(context, cycript, CYJSString("Selector"), Selector); - CYSetProperty(context, cycript, CYJSString("Super"), Super); + CYSetProperty(context, cycript, CYJSString("objc_super"), Super); JSObjectRef box(JSObjectMakeFunctionWithCallback(context, CYJSString("box"), &Instance_box_callAsFunction)); - CYSetProperty(context, Instance, CYJSString("box"), box); + CYSetProperty(context, Instance, CYJSString("box"), box, kJSPropertyAttributeDontEnum); -#if defined(__APPLE__) && defined(__arm__) && 0 - CYSetProperty(context, all, CYJSString("objc_registerClassPair"), &objc_registerClassPair_, kJSPropertyAttributeDontEnum); +#ifdef __APPLE__ + CYSetProperty(context, all, CYJSString("choose"), &choose, kJSPropertyAttributeDontEnum); #endif CYSetProperty(context, all, CYJSString("objc_msgSend"), &$objc_msgSend, kJSPropertyAttributeDontEnum); - JSObjectSetPrototype(context, CYCastJSObject(context, CYGetProperty(context, Message, prototype_s)), Function_prototype); - JSObjectSetPrototype(context, CYCastJSObject(context, CYGetProperty(context, Selector, prototype_s)), Function_prototype); + CYSetPrototype(context, CYCastJSObject(context, CYGetProperty(context, Message, prototype_s)), Function_prototype); + CYSetPrototype(context, CYCastJSObject(context, CYGetProperty(context, Selector, prototype_s)), Function_prototype); + + JSObjectRef cache(CYGetCachedObject(context, CYJSString("cache"))); + CYSetProperty(context, cache, CYJSString("YES"), JSValueMakeBoolean(context, true), kJSPropertyAttributeDontEnum); + CYSetProperty(context, cache, CYJSString("NO"), JSValueMakeBoolean(context, false), kJSPropertyAttributeDontEnum); + CYSetProperty(context, cache, CYJSString("id"), CYMakeType(context, sig::Object()), kJSPropertyAttributeDontEnum); + CYSetProperty(context, cache, CYJSString("Class"), CYMakeType(context, sig::Meta()), kJSPropertyAttributeDontEnum); + CYSetProperty(context, cache, CYJSString("SEL"), CYMakeType(context, sig::Selector()), kJSPropertyAttributeDontEnum); } CYPoolCatch() } -static CYHooks CYObjectiveCHooks = { +static void *CYObjectiveC_CastSymbol(const char *name) { + if (false); +#ifdef __GNU_LIBOBJC__ + else if (strcmp(name, "object_getClass") == 0) + return reinterpret_cast(&object_getClass); +#endif + return NULL; +} + +static CYHook CYObjectiveCHook = { &CYObjectiveC_ExecuteStart, &CYObjectiveC_ExecuteEnd, &CYObjectiveC_CallFunction, &CYObjectiveC_Initialize, &CYObjectiveC_SetupContext, - &CYObjectiveC_PoolFFI, - &CYObjectiveC_FromFFI, + &CYObjectiveC_CastSymbol, }; -struct CYObjectiveC { - CYObjectiveC() { - hooks_ = &CYObjectiveCHooks; - // XXX: evil magic juju to make this actually take effect on a Mac when compiled with autoconf/libtool doom! - _assert(hooks_ != NULL); - } -} CYObjectiveC; +CYRegisterHook CYObjectiveC(&CYObjectiveCHook); + +_extern void CydgetSetupContext(JSGlobalContextRef context) { CYObjectiveTry_ { + CYSetupContext(context); +} CYObjectiveCatch } + +_extern 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(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]; +} }