X-Git-Url: https://git.saurik.com/cycript.git/blobdiff_plain/8493347dd9711848398e2d667080110a376be96d..37dadc219da7f34c243c5c76c2eff2d3fa1f1051:/ObjectiveC/Library.mm diff --git a/ObjectiveC/Library.mm b/ObjectiveC/Library.mm index 7ac3bb0..ac3a963 100644 --- a/ObjectiveC/Library.mm +++ b/ObjectiveC/Library.mm @@ -1,55 +1,58 @@ -/* Cycript - Optimizing JavaScript Compiler/Runtime - * Copyright (C) 2009-2013 Jay Freeman (saurik) +/* Cycript - The Truly Universal Scripting Language + * Copyright (C) 2009-2016 Jay Freeman (saurik) */ -/* GNU 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 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 + * 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 General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Cycript. If not, see <http://www.gnu.org/licenses/>. + * 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 <http://www.gnu.org/licenses/>. **/ /* }}} */ -#include <Foundation/Foundation.h> +#include "cycript.hpp" -#include "ObjectiveC/Internal.hpp" +#include <cmath> -#include <objc/objc-api.h> +#include <map> +#include <set> -#include "cycript.hpp" +#include <dlfcn.h> -#include "ObjectiveC/Internal.hpp" +#ifdef __APPLE__ +#include <malloc/malloc.h> +#include <mach/mach.h> +#endif + +#include <objc/message.h> +#include <objc/runtime.h> #ifdef __APPLE__ #include <CoreFoundation/CoreFoundation.h> #include <JavaScriptCore/JSStringRefCF.h> -#include <objc/runtime.h> #endif -#ifdef __APPLE__ -#include <malloc/malloc.h> -#include <mach/mach.h> -#endif +#include <Foundation/Foundation.h> +#include "Code.hpp" +#include "Decode.hpp" #include "Error.hpp" +#include "Functor.hpp" #include "JavaScript.hpp" #include "String.hpp" #include "Execute.hpp" -#include <cmath> -#include <map> -#include <set> - -#include <dlfcn.h> +#include "ObjectiveC/Internal.hpp" +#include "ObjectiveC/Syntax.hpp" #define CYObjectiveTry_ { \ try @@ -58,7 +61,7 @@ try #define CYObjectiveCatch \ catch (const CYException &error) { \ - @throw CYCastNSObject(NULL, context, error.CastJSValue(context)); \ + @throw CYCastNSObject(NULL, context, error.CastJSValue(context, "Error")); \ } \ } @@ -86,48 +89,11 @@ } 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 - -#define object_getClass GSObjCClass - -#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; \ -}) - -#define object_setIvar(object, ivar, value) ({ \ - void *data = (value); \ - GSObjCSetVariable(object, ivar_getOffset(ivar), sizeof(void *), &data); \ -}) - -#define protocol_getName(protocol) [(protocol) name] -#endif - -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); +@class NSBlock; struct BlockLiteral { Class isa; @@ -164,6 +130,10 @@ enum { BLOCK_HAS_SIGNATURE = 1 << 30, }; +static bool CYIsClass(id self) { + return class_isMetaClass(object_getClass(self)); +} + JSValueRef CYSendMessage(CYPool &pool, JSContextRef context, id self, Class super, SEL _cmd, size_t count, const JSValueRef arguments[], bool initialize); /* Objective-C Pool Release {{{ */ @@ -189,29 +159,37 @@ Type_ CYPoolRelease(CYPool *pool, Type_ object) { } /* }}} */ /* Objective-C Strings {{{ */ -const char *CYPoolCString(CYPool &pool, JSContextRef context, NSString *value) { - size_t size([value maximumLengthOfBytesUsingEncoding:NSUTF8StringEncoding] + 1); - char *string(new(pool) char[size]); +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 string; + 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<CFStringRef>(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) { @@ -270,8 +248,6 @@ bool CYGetOffset(CYPool &pool, JSContextRef context, NSString *value, ssize_t &i return CYGetOffset(CYPoolCString(pool, context, value), index); } -static JSClassRef Instance_; - static JSClassRef ArrayInstance_; static JSClassRef BooleanInstance_; static JSClassRef FunctionInstance_; @@ -279,13 +255,6 @@ static JSClassRef NumberInstance_; static JSClassRef ObjectInstance_; static JSClassRef StringInstance_; -static JSClassRef Class_; -static JSClassRef Internal_; -static JSClassRef Message_; -static JSClassRef Messages_; -static JSClassRef Selector_; -static JSClassRef Super_; - static JSClassRef ObjectiveC_Classes_; static JSClassRef ObjectiveC_Constants_; static JSClassRef ObjectiveC_Protocols_; @@ -300,9 +269,6 @@ static Class __NSMallocBlock__; static Class NSCFBoolean_; static Class NSCFType_; static Class NSGenericDeallocHandler_; -static Class NSZombie_; - -static std::set<Class> banned_; #else static Class NSBoolNumber_; #endif @@ -312,122 +278,112 @@ static Class NSBlock_; static Class NSDictionary_; static Class NSNumber_; static Class NSString_; +static Class NSZombie_; static Class Object_; -static Type_privateData *Object_type; -static Type_privateData *Selector_type; - -Type_privateData *Instance::GetType() const { - return Object_type; -} - -Type_privateData *Selector_privateData::GetType() const { - return Selector_type; -} - static JSValueRef Instance_callAsFunction_toString(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception); -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("Class_prototype")); - - JSObjectRef global(CYGetGlobalObject(context)); - JSObjectRef cy(CYCastJSObject(context, CYGetProperty(context, global, cy_s))); - - char label[32]; - sprintf(label, "i%p", self); - CYJSString name(label); - - JSValueRef value(CYGetProperty(context, cy, name)); - if (!JSValueIsUndefined(context, value)) - return value; - - JSClassRef _class(NULL); - JSValueRef prototype; - +JSValueRef Prototype::GetPrototype(JSContextRef context) const { #ifdef __APPLE__ - if (self == NSCFBoolean_) + if (value_ == NSCFBoolean_) #else - if (self == NSBoolNumber_) + if (value_ == 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_) - prototype = CYGetCachedObject(context, CYJSString("StringInstance_prototype")); - else - prototype = CYGetClassPrototype(context, class_getSuperclass(self), meta); - - JSObjectRef object(JSObjectMake(context, _class, NULL)); - JSObjectSetPrototype(context, object, prototype); - CYSetProperty(context, cy, name, object); - - return object; + return CYGetCachedObject(context, CYJSString("BooleanInstance_prototype")); + if (value_ == NSArray_) + return CYGetCachedObject(context, CYJSString("ArrayInstance_prototype")); + if (value_ == NSBlock_) + return CYGetCachedObject(context, CYJSString("FunctionInstance_prototype")); + if (value_ == NSNumber_) + return CYGetCachedObject(context, CYJSString("NumberInstance_prototype")); + if (value_ == NSDictionary_) + return CYGetCachedObject(context, CYJSString("ObjectInstance_prototype")); + if (value_ == NSString_) + return CYGetCachedObject(context, CYJSString("StringInstance_prototype")); + + if (Class super = class_getSuperclass(value_)) + return CYPrivate<Prototype>::Cache(context, super); + return CYGetCachedObject(context, CYJSString("Instance_prototype")); +} + +JSValueRef Constructor::GetPrototype(JSContextRef context) const { + if (Class super = class_getSuperclass(value_)) + return CYPrivate<Constructor>::Cache(context, super); + return CYGetCachedObject(context, CYJSString("Constructor_prototype")); +} + +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; } -_finline JSValueRef CYGetClassPrototype(JSContextRef context, Class self) { - return CYGetClassPrototype(context, self, class_isMetaClass(self)); +JSValueRef Instance::GetPrototype(JSContextRef context) const { + return CYPrivate<Prototype>::Cache(context, object_getClass(value_)); } -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)); - return value; +JSClassRef Instance::GetClass(id object, Flags flags) { + return CYIsKindOfClass(object, NSBlock_) ? FunctionInstance_ : Instance::Class_; } -JSObjectRef Internal::Make(JSContextRef context, id object, JSObjectRef owner) { - return JSObjectMake(context, Internal_, new Internal(object, context, owner)); -} - -namespace cy { -JSObjectRef Super::Make(JSContextRef context, id object, Class _class) { - JSObjectRef value(JSObjectMake(context, Super_, new Super(object, _class))); - return value; -} } - -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))); - return value; +Instance::Instance(id value, Flags flags) : + value_(value), + flags_(flags) +{ + if (IsPermanent()); + /*else if ([value retainCount] == NSUInteger(-1)) + flags_ |= Instance::Permanent;*/ + else + value_ = [value_ retain]; } Instance::~Instance() { - if ((flags_ & Transient) == 0) - [GetValue() release]; + if (!IsPermanent()) + [value_ release]; } struct Message_privateData : cy::Functor { + static JSClassRef Class_; + SEL sel_; - Message_privateData(SEL sel, const char *type, IMP value = NULL) : - cy::Functor(type, reinterpret_cast<void (*)()>(value)), + Message_privateData(SEL sel, const char *type, IMP value) : + cy::Functor(reinterpret_cast<void (*)()>(value), type), sel_(sel) { } + + static JSObjectRef Make(JSContextRef context, SEL sel, const char *type, IMP value); }; -JSObjectRef CYMakeInstance(JSContextRef context, id object, bool transient) { - Instance::Flags flags; +JSClassRef Message_privateData::Class_; - if (transient) - flags = Instance::Transient; - else { - flags = Instance::None; - object = [object retain]; - } +JSObjectRef CYMakeInstance(JSContextRef context, id object, Instance::Flags flags = Instance::None) { + _assert(object != nil); + +#ifdef __APPLE__ + JSWeakObjectMapRef weak(CYCastPointer<JSWeakObjectMapRef>(context, CYGetCachedValue(context, weak_s))); + + if (weak != NULL && &JSWeakObjectMapGet != NULL) + if (JSObjectRef instance = JSWeakObjectMapGet(context, weak, object)) + return instance; +#endif - return Instance::Make(context, object, flags); + JSObjectRef instance; + if (CYIsClass(object) && !class_isMetaClass(object)) + instance = CYPrivate<Constructor>::Cache(context, object); + else + instance = Instance::Make(context, object, flags); + +#ifdef __APPLE__ + if (weak != NULL && &JSWeakObjectMapSet != NULL) + JSWeakObjectMapSet(context, weak, object, instance); +#endif + + return instance; } @interface NSMethodSignature (Cycript) @@ -440,7 +396,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<void *> &)objects; - (bool) cy$hasProperty:(NSString *)name; - (NSObject *) cy$getProperty:(NSString *)name; @@ -458,45 +414,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<void *> &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<NSString *(*)(id, SEL, bool)>(method_getImplementation(toCYON))(value, sel, objective); - else if (objc_method *methodSignatureForSelector = class_getInstanceMethod(_class, @selector(methodSignatureForSelector:))) { - if (reinterpret_cast<NSMethodSignature *(*)(id, SEL, SEL)>(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 (banned_.find(value) != banned_.end()) - 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<NSString *(*)(id, SEL, bool, std::set<void *> &)>(method_getImplementation(toCYON))(value, sel, objective, objects); + else if (objc_method *methodSignatureForSelector = class_getInstanceMethod(_class, @selector(methodSignatureForSelector:))) + if (reinterpret_cast<NSMethodSignature *(*)(id, SEL, SEL)>(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<void *> *objects) { + if (objects != NULL) + return CYCastNSCYON(value, objective, *objects); + else { + std::set<void *> objects; + return CYCastNSCYON(value, objective, objects); + } } -#ifdef __APPLE__ struct PropertyAttributes { CYPool pool_; @@ -584,7 +537,6 @@ struct PropertyAttributes { } }; -#endif @interface CYWebUndefined : NSObject { } @@ -641,13 +593,14 @@ struct PropertyAttributes { /* }}} */ _finline bool CYJSValueIsNSObject(JSContextRef context, JSValueRef value) { - return JSValueIsObjectOfClass(context, value, Instance_); + return JSValueIsObjectOfClass(context, value, Instance::Class_) || JSValueIsObjectOfClass(context, value, FunctionInstance_) || JSValueIsObjectOfClass(context, value, CYPrivate<Constructor>::Class_); } _finline bool CYJSValueIsInstanceOfCachedConstructor(JSContextRef context, JSValueRef value, JSStringRef cache) { return _jsccall(JSValueIsInstanceOfConstructor, context, value, CYGetCachedObject(context, cache)); } +#ifdef __APPLE__ struct CYBlockDescriptor { struct { BlockDescriptor1 one_; @@ -667,19 +620,15 @@ static JSValueRef BlockAdapter_(JSContextRef context, size_t count, JSValueRef v return CYCallAsFunction(context, function, _this, count - 1, values + 1); } -static void BlockClosure_(ffi_cif *cif, void *result, void **arguments, void *arg) { - CYExecuteClosure(cif, result, arguments, arg, &BlockAdapter_); -} - -NSObject *CYMakeBlock(JSContextRef context, JSObjectRef function, sig::Signature &signature) { +NSBlock *CYMakeBlock(JSContextRef context, JSObjectRef function, sig::Signature &signature) { _assert(__NSMallocBlock__ != Nil); BlockLiteral *literal(reinterpret_cast<BlockLiteral *>(malloc(sizeof(BlockLiteral)))); CYBlockDescriptor *descriptor(new CYBlockDescriptor); memset(&descriptor->d_, 0, sizeof(descriptor->d_)); - descriptor->internal_ = CYMakeFunctor_(context, function, signature, &BlockClosure_); - literal->invoke = reinterpret_cast<void (*)(void *, ...)>(descriptor->internal_->GetValue()); + descriptor->internal_ = CYMakeFunctor_(context, function, signature, &BlockAdapter_); + literal->invoke = reinterpret_cast<void (*)(void *, ...)>(descriptor->internal_->value_); literal->isa = __NSMallocBlock__; literal->flags = BLOCK_HAS_SIGNATURE | BLOCK_HAS_COPY_DISPOSE | BLOCK_IS_GLOBAL; @@ -690,13 +639,14 @@ NSObject *CYMakeBlock(JSContextRef context, JSObjectRef function, sig::Signature descriptor->d_.two_.dispose_helper = &CYDisposeBlock; descriptor->d_.three_.signature = sig::Unparse(*descriptor->internal_->pool_, &signature); - return reinterpret_cast<NSObject *>(literal); + return reinterpret_cast<NSBlock *>(literal); } +#endif NSObject *CYCastNSObject(CYPool *pool, JSContextRef context, JSObjectRef object) { if (CYJSValueIsNSObject(context, object)) { Instance *internal(reinterpret_cast<Instance *>(JSObjectGetPrivate(object))); - return internal->GetValue(); + return internal->value_; } bool array(CYJSValueIsInstanceOfCachedConstructor(context, object, Array_s)); @@ -782,12 +732,14 @@ NSObject *CYCopyNSObject(CYPool &pool, JSContextRef context, JSValueRef value) { return [[self mutableCopy] autorelease]; } -- (NSString *) cy$toCYON:(bool)objective { +- (NSString *) cy$toCYON:(bool)objective inSet:(std::set<void *> &)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) { @@ -797,8 +749,8 @@ NSObject *CYCopyNSObject(CYPool &pool, JSContextRef context, JSValueRef value) { [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; @@ -858,8 +810,39 @@ NSObject *CYCopyNSObject(CYPool &pool, JSContextRef context, JSValueRef value) { /* }}} */ /* Bridge: NSBlock {{{ */ #ifdef __APPLE__ -@interface NSBlock +@interface NSBlock : NSObject - (void) invoke; +@end + +static const char *CYBlockEncoding(NSBlock *self); +static bool CYBlockSignature(CYPool &pool, NSBlock *self, sig::Signature &signature); + +@implementation NSBlock (Cycript) + +- (NSString *) cy$toCYON:(bool)objective inSet:(std::set<void *> &)objects { + CYLocalPool pool; + + sig::Block type; + if (!CYBlockSignature(pool, self, type.signature)) + return [super cy$toCYON:objective inSet:objects]; + _oassert(objects.insert(self).second); + + CYType *typed((new(pool) CYTypeExpression(CYDecodeType(pool, &type)))->typed_); + CYTypeModifier *&modifier(CYGetLast(typed->modifier_)); + CYTypeBlockWith *with(dynamic_cast<CYTypeBlockWith *>(modifier)); + _assert(with != NULL); + CYObjCBlock *block(new(pool) CYObjCBlock(typed, with->parameters_, NULL)); + modifier = 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 /* }}} */ @@ -871,7 +854,7 @@ NSObject *CYCopyNSObject(CYPool &pool, JSContextRef context, JSValueRef value) { return kJSTypeBoolean; } -- (NSString *) cy$toCYON:(bool)objective { +- (NSString *) cy$toCYON:(bool)objective inSet:(std::set<void *> &)objects { NSString *value([self boolValue] ? @"true" : @"false"); return objective ? value : [NSString stringWithFormat:@"@%@", value]; } @@ -890,12 +873,14 @@ NSObject *CYCopyNSObject(CYPool &pool, JSContextRef context, JSValueRef value) { return [[self mutableCopy] autorelease]; } -- (NSString *) cy$toCYON:(bool)objective { +- (NSString *) cy$toCYON:(bool)objective inSet:(std::set<void *> &)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]); @@ -905,10 +890,10 @@ NSObject *CYCopyNSObject(CYPool &pool, JSContextRef context, JSValueRef value) { [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:@"}"]; @@ -926,7 +911,7 @@ NSObject *CYCopyNSObject(CYPool &pool, JSContextRef context, JSValueRef value) { - (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]); @@ -949,11 +934,7 @@ NSObject *CYCopyNSObject(CYPool &pool, JSContextRef context, JSValueRef value) { if ([name isEqualToString:@"length"]) { // XXX: is this not intelligent? NSNumber *number(reinterpret_cast<NSNumber *>(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)]; @@ -1028,7 +1009,7 @@ NSObject *CYCopyNSObject(CYPool &pool, JSContextRef context, JSValueRef value) { return kJSTypeNumber; } -- (NSString *) cy$toCYON:(bool)objective { +- (NSString *) cy$toCYON:(bool)objective inSet:(std::set<void *> &)objects { NSString *value([self cy$JSType] != kJSTypeBoolean ? [self stringValue] : [self boolValue] ? @"true" : @"false"); return objective ? value : [NSString stringWithFormat:@"@%@", value]; } @@ -1046,7 +1027,7 @@ NSObject *CYCopyNSObject(CYPool &pool, JSContextRef context, JSValueRef value) { return kJSTypeNull; } -- (NSString *) cy$toCYON:(bool)objective { +- (NSString *) cy$toCYON:(bool)objective inSet:(std::set<void *> &)objects { NSString *value(@"null"); return objective ? value : [NSString stringWithFormat:@"@%@", value]; } @@ -1076,8 +1057,8 @@ NSObject *CYCopyNSObject(CYPool &pool, JSContextRef context, JSValueRef value) { return kJSTypeObject; } -- (NSString *) cy$toCYON:(bool)objective { - return [@"#" stringByAppendingString:[[self description] cy$toCYON:true]]; +- (NSString *) cy$toCYON:(bool)objective inSet:(std::set<void *> &)objects { + return [@"#" stringByAppendingString:[[self description] cy$toCYON:true inSet:objects]]; } - (bool) cy$hasProperty:(NSString *)name { @@ -1111,11 +1092,28 @@ NSObject *CYCopyNSObject(CYPool &pool, JSContextRef context, JSValueRef value) { @end /* }}} */ +/* Bridge: NSOrderedSet {{{ */ +#ifdef __APPLE__ +@implementation NSOrderedSet (Cycript) + +- (NSString *) cy$toCYON:(bool)objective inSet:(std::set<void *> &)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<void *> &)objects { + return [[self description] cy$toCYON:objective inSet:objects]; } @end @@ -1123,10 +1121,12 @@ NSObject *CYCopyNSObject(CYPool &pool, JSContextRef context, JSValueRef value) { /* Bridge: NSSet {{{ */ @implementation NSSet (Cycript) -- (NSString *) cy$toCYON:(bool)objective { +- (NSString *) cy$toCYON:(bool)objective inSet:(std::set<void *> &)objects { + _oassert(objects.insert(self).second); + NSMutableString *json([[[NSMutableString alloc] init] autorelease]); [json appendString:@"[NSSet setWithArray:"]; - [json appendString:CYCastNSCYON([self allObjects], true)]; + [json appendString:CYCastNSCYON([self allObjects], true, objects)]; [json appendString:@"]]"]; return json; } @@ -1144,12 +1144,12 @@ NSObject *CYCopyNSObject(CYPool &pool, JSContextRef context, JSValueRef value) { return kJSTypeString; } -- (NSString *) cy$toCYON:(bool)objective { +- (NSString *) cy$toCYON:(bool)objective inSet:(std::set<void *> &)objects { std::ostringstream str; if (!objective) str << '@'; CYUTF8String string(CYCastUTF8String(self)); - CYStringify(str, string.data, string.size); + CYStringify(str, string.data, string.size, CYStringifyModeNative); std::string value(str.str()); return CYCastNSString(NULL, CYUTF8String(value.c_str(), value.size())); } @@ -1193,7 +1193,7 @@ NSObject *CYCopyNSObject(CYPool &pool, JSContextRef context, JSValueRef value) { return kJSTypeUndefined; } -- (NSString *) cy$toCYON:(bool)objective { +- (NSString *) cy$toCYON:(bool)objective inSet:(std::set<void *> &)objects { NSString *value(@"undefined"); return value; // XXX: maybe use the below code, adding @undefined? //return objective ? value : [NSString stringWithFormat:@"@%@", value]; @@ -1206,14 +1206,6 @@ NSObject *CYCopyNSObject(CYPool &pool, JSContextRef context, JSValueRef value) { @end /* }}} */ -static bool CYIsClass(id self) { -#ifdef __APPLE__ - return class_isMetaClass(object_getClass(self)); -#else - return GSObjCIsClass(self); -#endif -} - Class CYCastClass(CYPool &pool, JSContextRef context, JSValueRef value) { id self(CYCastNSObject(&pool, context, value)); if (CYIsClass(self)) @@ -1231,12 +1223,11 @@ NSArray *CYCastNSArray(JSContextRef context, JSPropertyNameArrayRef names) { 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 @@ -1255,11 +1246,11 @@ JSValueRef CYCastJSValue(JSContextRef context, NSObject *value) { CYPoolTry { [super dealloc]; } CYObjectiveCatch } -- (NSString *) cy$toCYON:(bool)objective { CYObjectiveTry { +- (NSString *) cy$toCYON:(bool)objective inSet:(std::set<void *> &)objects { CYObjectiveTry { CYPool pool; - const char *cyon(CYPoolCCYON(pool, context, object_)); + 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 } @@ -1297,9 +1288,9 @@ JSValueRef CYCastJSValue(JSContextRef context, NSObject *value) { CYPoolTry { @implementation CYJSArray -- (NSString *) cy$toCYON:(bool)objective { CYObjectiveTry { +- (NSString *) cy$toCYON:(bool)objective inSet:(std::set<void *> &)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_ { @@ -1419,49 +1410,56 @@ 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; } @end -static JSObjectRef CYMakeSelector(JSContextRef context, SEL sel) { - Selector_privateData *internal(new Selector_privateData(sel)); - return JSObjectMake(context, Selector_, internal); +static JSValueRef CYCastJSValue(JSContextRef context, SEL sel) { + if (sel == NULL) + return CYJSNull(context); + return CYPrivate<Selector_privateData>::Make(context, sel); } static SEL CYCastSEL(JSContextRef context, JSValueRef value) { - if (JSValueIsObjectOfClass(context, value, Selector_)) { + if (JSValueIsObjectOfClass(context, value, CYPrivate<Selector_privateData>::Class_)) { Selector_privateData *internal(reinterpret_cast<Selector_privateData *>(JSObjectGetPrivate((JSObjectRef) value))); return reinterpret_cast<SEL>(internal->value_); - } else - return CYCastPointer<SEL>(context, value); + } else { + CYPool pool; + return sel_registerName(CYPoolCString(pool, context, value)); + } } void *CYObjectiveC_ExecuteStart(JSContextRef context) { CYSadTry { @@ -1472,98 +1470,112 @@ 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(CYPool *pool, JSContextRef context, sig::Type *type, ffi_type *ffi, void *data, JSValueRef value) { CYSadTry { - // XXX: assigning to an indirect id * works for return values, but not for properties and fields +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)); - switch (type->primitive) { - case sig::block_P: { - _assert(type->data.signature.count != 0); - sig::Signature signature; - sig::Copy(*pool, signature, type->data.signature); + if (JSValueIsObjectOfClass(context, object, FunctionInstance_)) + return reinterpret_cast<Instance *>(JSObjectGetPrivate(object))->value_; - sig::Element *elements(new(*pool) sig::Element[++signature.count]); - elements[0] = signature.elements[0]; - memcpy(elements + 2, signature.elements + 1, sizeof(sig::Element) * (signature.count - 2)); - signature.elements = elements; + if (JSValueIsObjectOfClass(context, object, Instance::Class_)) { + _assert(reinterpret_cast<Instance *>(JSObjectGetPrivate(object))->value_ == nil); + return nil; + } - elements[1].name = NULL; - elements[1].type = new(*pool) sig::Type(); - elements[1].offset = _not(size_t); + _assert(JSObjectIsFunction(context, object)); - memset(elements[1].type, 0, sizeof(sig::Type)); - elements[1].type->primitive = sig::object_P; + _assert(signature != NULL); + _assert(signature->count != 0); - JSObjectRef function(CYCastJSObject(context, value)); - *reinterpret_cast<id *>(data) = CYMakeBlock(context, function, signature); - } break; + sig::Signature modified; + modified.count = signature->count + 1; + modified.elements = new(pool) sig::Element[modified.count]; - case sig::object_P: - case sig::typename_P: - *reinterpret_cast<id *>(data) = CYCastNSObject(pool, context, value); - break; + modified.elements[0] = signature->elements[0]; + memcpy(modified.elements + 2, signature->elements + 1, sizeof(sig::Element) * (signature->count - 1)); - case sig::selector_P: - *reinterpret_cast<SEL *>(data) = CYCastSEL(context, value); - break; + modified.elements[1].name = NULL; + modified.elements[1].type = new(pool) sig::Object(); + modified.elements[1].offset = _not(size_t); - default: - return false; - } + return CYMakeBlock(context, object, modified); +#else + _assert(false); +#endif +} - 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<NSObject **>(data)) { - JSValueRef value(CYCastJSValue(context, object)); - if (initialize) - [object release]; - return value; - } else goto null; - - case sig::typename_P: - return CYMakeInstance(context, *reinterpret_cast<Class *>(data), true); - - case sig::selector_P: - if (SEL sel = *reinterpret_cast<SEL *>(data)) - return CYMakeSelector(context, sel); - else goto null; - - null: - return CYJSNull(context); - default: - return NULL; +namespace sig { + +void Block::PoolFFI(CYPool *pool, JSContextRef context, ffi_type *ffi, void *data, JSValueRef value) const { + // XXX: this function actually needs to handle null pools as it is an autorelease + _assert(pool != NULL); + *reinterpret_cast<id *>(data) = CYCastNSBlock(*pool, context, value, &signature); +} + +// 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<id *>(data) = CYCastNSObject(pool, context, value); +} + +void Meta::PoolFFI(CYPool *pool, JSContextRef context, ffi_type *ffi, void *data, JSValueRef value) const { + *reinterpret_cast<id *>(data) = CYCastNSObject(pool, context, value); +} + +void Selector::PoolFFI(CYPool *pool, JSContextRef context, ffi_type *ffi, void *data, JSValueRef value) const { + *reinterpret_cast<SEL *>(data) = CYCastSEL(context, value); +} + +JSValueRef Object::FromFFI(JSContextRef context, ffi_type *ffi, void *data, bool initialize, JSObjectRef owner) const { + NSObject *value(*reinterpret_cast<NSObject **>(data)); + if (value == NULL) + return CYJSNull(context); + JSObjectRef object(CYMakeInstance(context, value)); + + if (initialize) { + Instance *internal(reinterpret_cast<Instance *>(JSObjectGetPrivate(object))); + + if (internal->IsUninitialized()) { + internal->flags_ &= ~Instance::Uninitialized; + if (internal->value_ == nil) + internal->value_ = value; + else + _assert(internal->value_ == value); + } + + [value release]; } -} CYPoolCatch(NULL) return /*XXX*/ NULL; } + + return object; +} + +JSValueRef Meta::FromFFI(JSContextRef context, ffi_type *ffi, void *data, bool initialize, JSObjectRef owner) const { + if (Class value = *reinterpret_cast<Class *>(data)) + return CYMakeInstance(context, value, Instance::Permanent); + return CYJSNull(context); +} + +JSValueRef Selector::FromFFI(JSContextRef context, ffi_type *ffi, void *data, bool initialize, JSObjectRef owner) const { + return CYCastJSValue(context, *reinterpret_cast<SEL *>(data)); +} + +JSValueRef Block::FromFFI(JSContextRef context, ffi_type *ffi, void *data, bool initialize, JSObjectRef owner) const { + return CYCastJSValue(context, *reinterpret_cast<NSObject **>(data)); +} + +} 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)); -#else - const char *type(method_getTypeEncoding(method)); -#endif if (type[0] != 'v') return true; } @@ -1572,36 +1584,14 @@ static bool CYImplements(id object, Class _class, SEL selector, bool devoid = fa return false; } -static const char *CYPoolTypeEncoding(CYPool &pool, JSContextRef context, SEL sel, objc_method *method) { - if (method != NULL) - return method_getTypeEncoding(method); - - const char *name(sel_getName(sel)); - size_t length(strlen(name)); - - char keyed[length + 2]; - keyed[0] = '6'; - keyed[length + 1] = '\0'; - memcpy(keyed + 1, name, length); - - if (CYBridgeEntry *entry = CYBridgeHash(keyed, length + 1)) - return entry->value_; - - return NULL; -} - 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 void MessageClosure_(ffi_cif *cif, void *result, void **arguments, void *arg) { - CYExecuteClosure(cif, result, arguments, arg, &MessageAdapter_); -} - -static JSObjectRef CYMakeMessage(JSContextRef context, SEL sel, IMP imp, const char *type) { - Message_privateData *internal(new Message_privateData(sel, type, imp)); - return JSObjectMake(context, Message_, internal); +JSObjectRef Message_privateData::Make(JSContextRef context, SEL sel, const char *type, IMP value) { + Message_privateData *internal(new Message_privateData(sel, type, value)); + return JSObjectMake(context, Message_privateData::Class_, internal); } static IMP CYMakeMessage(JSContextRef context, JSValueRef value, const char *encoding) { @@ -1609,14 +1599,14 @@ static IMP CYMakeMessage(JSContextRef context, JSValueRef value, const char *enc CYPool pool; sig::Signature signature; sig::Parse(pool, &signature, encoding, &Structor_); - Closure_privateData *internal(CYMakeFunctor_(context, function, signature, &MessageClosure_)); + Closure_privateData *internal(CYMakeFunctor_(context, function, signature, &MessageAdapter_)); // XXX: see notes in Library.cpp about needing to leak - return reinterpret_cast<IMP>(internal->GetValue()); + return reinterpret_cast<IMP>(internal->value_); } static bool Messages_hasProperty(JSContextRef context, JSObjectRef object, JSStringRef property) { - Messages *internal(reinterpret_cast<Messages *>(JSObjectGetPrivate(object))); - Class _class(internal->GetValue()); + auto internal(CYPrivate<Messages>::Get(context, object)); + Class _class(internal->GetClass()); CYPool pool; const char *name(CYPoolCString(pool, context, property)); @@ -1629,104 +1619,148 @@ static bool Messages_hasProperty(JSContextRef context, JSObjectRef object, JSStr } static JSValueRef Messages_getProperty(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { CYTry { - Messages *internal(reinterpret_cast<Messages *>(JSObjectGetPrivate(object))); - Class _class(internal->GetValue()); + auto internal(CYPrivate<Messages>::Get(context, object)); + Class _class(internal->GetClass()); CYPool pool; const char *name(CYPoolCString(pool, context, property)); if (SEL sel = sel_getUid(name)) if (objc_method *method = class_getInstanceMethod(_class, sel)) - return CYMakeMessage(context, sel, method_getImplementation(method), method_getTypeEncoding(method)); + return Message_privateData::Make(context, sel, method_getTypeEncoding(method), method_getImplementation(method)); return NULL; } CYCatch(NULL) } static bool Messages_setProperty(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef value, JSValueRef *exception) { CYTry { - Messages *internal(reinterpret_cast<Messages *>(JSObjectGetPrivate(object))); - Class _class(internal->GetValue()); + auto internal(CYPrivate<Messages>::Get(context, object)); + Class _class(internal->GetClass()); 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; - if (JSValueIsObjectOfClass(context, value, Message_)) { + if (JSValueIsObjectOfClass(context, value, Message_privateData::Class_)) { Message_privateData *message(reinterpret_cast<Message_privateData *>(JSObjectGetPrivate((JSObjectRef) value))); type = sig::Unparse(pool, &message->signature_); - imp = reinterpret_cast<IMP>(message->GetValue()); - } else { - type = CYPoolTypeEncoding(pool, context, sel, method); + imp = reinterpret_cast<IMP>(message->value_); + } else if (objc_method *method = class_getInstanceMethod(_class, sel)) { + type = method_getTypeEncoding(method); imp = CYMakeMessage(context, value, type); - } + } else return false; + + objc_method *method(NULL); + unsigned int size; + objc_method **methods(class_copyMethodList(_class, &size)); + pool.atexit(free, methods); + + for (size_t i(0); i != size; ++i) + if (sel_isEqual(method_getName(methods[i]), sel)) { + method = methods[i]; + break; + } 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; } CYCatch(false) } -#if 0 && OBJC_API_VERSION < 2 -static bool Messages_deleteProperty(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { CYTry { - Messages *internal(reinterpret_cast<Messages *>(JSObjectGetPrivate(object))); - Class _class(internal->GetValue()); +static JSValueRef Messages_complete_callAsFunction(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry { + if (count == 2) { + if (!CYCastBool(context, arguments[1])) + return CYObjectMakeArray(context, 0, NULL); + count = 1; + } + _assert(count == 1); 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; -} CYCatch(false) } -#endif + CYUTF8String prefix(CYPoolUTF8String(pool, context, CYJSString(context, arguments[0]))); -static void Messages_getPropertyNames(JSContextRef context, JSObjectRef object, JSPropertyNameAccumulatorRef names) { - Messages *internal(reinterpret_cast<Messages *>(JSObjectGetPrivate(object))); - Class _class(internal->GetValue()); + auto internal(CYPrivate<Messages>::Get(context, _this)); + Class _class(internal->GetClass()); -#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 -} + pool.atexit(free, data); + + JSObjectRef array(NULL); { + CYArrayBuilder<1024> values(context, array); -static bool CYHasImplicitProperties(Class _class) { + for (size_t i(0); i != size; ++i) { + CYUTF8String name(sel_getName(method_getName(data[i]))); + if (CYStartsWith(name, prefix)) + values(CYCastJSValue(context, CYJSString(name))); + } + } return array; +} CYCatch(NULL) } + +static bool CYHasImplicitProperties(JSContextRef context, Class _class) { + if (!CYCastBool(context, CYGetCachedValue(context, CYJSString("cydget")))) + return false; // XXX: this is an evil hack to deal with NSProxy; fix elsewhere if (!CYImplements(_class, object_getClass(_class), @selector(cy$hasImplicitProperties))) return true; return [_class cy$hasImplicitProperties]; } +static objc_property_t CYFindProperty(CYPool &pool, Class _class, const char *name) { + if (_class == Nil) + return NULL; + if (objc_property_t property = class_getProperty(_class, name)) + return property; + return NULL; + + /* // XXX: I don't think any of this is required + unsigned int count; + Protocol **protocols(class_copyProtocolList(_class, &count)); + // XXX: just implement a scope guard already :/ + pool.atexit(free, protocols); + + for (unsigned int i(0); i != count; ++i) + if (objc_property_t property = protocol_getProperty(protocols[i], name, true, true)) + return property; + + return CYFindProperty(pool, class_getSuperclass(_class), name); */ +} + +static JSValueRef Constructor_getProperty_$cyi(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { CYTry { + auto internal(CYPrivate<Constructor>::Get(context, object)); + return CYPrivate<Interior>::Make(context, internal->value_, context, object); +} CYCatch(NULL) } + +static bool Constructor_hasProperty(JSContextRef context, JSObjectRef object, JSStringRef property) { + auto internal(CYPrivate<Constructor>::Get(context, object)); + Class _class(object_getClass(internal->value_)); + if (!CYHasImplicitProperties(context, _class)) + return false; + CYPool pool; + if (SEL sel = sel_getUid(CYPoolCString(pool, context, property))) + if (CYImplements(internal->value_, _class, sel, true)) + return true; + return false; +} + +static JSValueRef Constructor_getProperty(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { CYTry { + auto internal(CYPrivate<Constructor>::Get(context, object)); + Class _class(object_getClass(internal->value_)); + if (!CYHasImplicitProperties(context, _class)) + return NULL; + CYPool pool; + if (SEL sel = sel_getUid(CYPoolCString(pool, context, property))) + if (CYImplements(internal->value_, _class, sel, true)) + return CYSendMessage(pool, context, internal->value_, NULL, sel, 0, NULL, false); + return NULL; +} CYCatch(NULL) } + static bool Instance_hasProperty(JSContextRef context, JSObjectRef object, JSStringRef property) { Instance *internal(reinterpret_cast<Instance *>(JSObjectGetPrivate(object))); - id self(internal->GetValue()); + id self(internal->value_); if (JSStringIsEqualToUTF8CString(property, "$cyi")) return true; @@ -1749,12 +1783,10 @@ static bool Instance_hasProperty(JSContextRef context, JSObjectRef object, JSStr const char *string(CYPoolCString(pool, context, name)); -#ifdef __APPLE__ - if (class_getProperty(_class, string) != NULL) + if (CYFindProperty(pool, _class, string) != NULL) return true; -#endif - if (CYHasImplicitProperties(_class)) + if (CYHasImplicitProperties(context, _class)) if (SEL sel = sel_getUid(string)) if (CYImplements(self, _class, sel, true)) return true; @@ -1764,10 +1796,10 @@ static bool Instance_hasProperty(JSContextRef context, JSObjectRef object, JSStr static JSValueRef Instance_getProperty(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { CYTry { Instance *internal(reinterpret_cast<Instance *>(JSObjectGetPrivate(object))); - id self(internal->GetValue()); + id self(internal->value_); if (JSStringIsEqualToUTF8CString(property, "$cyi")) - return Internal::Make(context, self, object); + return CYPrivate<Interior>::Make(context, self, context, object); CYPool pool; NSString *name(CYCastNSString(&pool, context, property)); @@ -1784,15 +1816,13 @@ 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)) { + if (objc_property_t property = CYFindProperty(pool, _class, string)) { PropertyAttributes attributes(property); SEL sel(sel_registerName(attributes.Getter())); return CYSendMessage(pool, context, self, NULL, sel, 0, NULL, false); } -#endif - if (CYHasImplicitProperties(_class)) + if (CYHasImplicitProperties(context, _class)) if (SEL sel = sel_getUid(string)) if (CYImplements(self, _class, sel, true)) return CYSendMessage(pool, context, self, NULL, sel, 0, NULL, false); @@ -1802,7 +1832,7 @@ static JSValueRef Instance_getProperty(JSContextRef context, JSObjectRef object, static bool Instance_setProperty(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef value, JSValueRef *exception) { CYTry { Instance *internal(reinterpret_cast<Instance *>(JSObjectGetPrivate(object))); - id self(internal->GetValue()); + id self(internal->value_); CYPool pool; @@ -1817,8 +1847,7 @@ static bool Instance_setProperty(JSContextRef context, JSObjectRef object, JSStr const char *string(CYPoolCString(pool, context, name)); Class _class(object_getClass(self)); -#ifdef __APPLE__ - if (objc_property_t property = class_getProperty(_class, string)) { + if (objc_property_t property = CYFindProperty(pool, _class, string)) { PropertyAttributes attributes(property); if (const char *setter = attributes.Setter()) { SEL sel(sel_registerName(setter)); @@ -1827,7 +1856,6 @@ static bool Instance_setProperty(JSContextRef context, JSObjectRef object, JSStr return true; } } -#endif size_t length(strlen(string)); @@ -1862,7 +1890,7 @@ static bool Instance_setProperty(JSContextRef context, JSObjectRef object, JSStr static bool Instance_deleteProperty(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { CYTry { Instance *internal(reinterpret_cast<Instance *>(JSObjectGetPrivate(object))); - id self(internal->GetValue()); + id self(internal->value_); CYPoolTry { NSString *name(CYCastNSString(NULL, context, property)); @@ -1870,49 +1898,44 @@ static bool Instance_deleteProperty(JSContextRef context, JSObjectRef object, JS } 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))); - if (strchr(name, ':') != NULL) - return; +static void CYForEachProperty(CYPool &pool, Class _class, const Functor<void (objc_method *, const char *)> &code) { + for (; _class != Nil; _class = class_getSuperclass(_class)) { + unsigned int size; + objc_method **data(class_copyMethodList(_class, &size)); + pool.atexit(free, data); + + for (size_t i(0); i != size; ++i) { + objc_method *method(data[i]); - const char *type(method_getTypeEncoding(method)); - if (type == NULL || *type == '\0' || *type == 'v') - return; + const char *name(sel_getName(method_getName(method))); + if (strchr(name, ':') != NULL) + continue; - JSPropertyNameAccumulatorAddName(names, CYJSString(name)); + code(method, name); + } + } } static void Instance_getPropertyNames(JSContextRef context, JSObjectRef object, JSPropertyNameAccumulatorRef names) { Instance *internal(reinterpret_cast<Instance *>(JSObjectGetPrivate(object))); - id self(internal->GetValue()); + id self(internal->value_); CYPool pool; Class _class(object_getClass(self)); -#ifdef __APPLE__ - { + for (Class current(_class); current != Nil; current = class_getSuperclass(current)) { unsigned int size; - objc_property_t *data(class_copyPropertyList(_class, &size)); + objc_property_t *data(class_copyPropertyList(current, &size)); + pool.atexit(free, data); + for (size_t i(0); i != size; ++i) 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 - } + if (CYHasImplicitProperties(context, _class)) + CYForEachProperty(pool, _class, fun([&](objc_method *method, const char *name) { + JSPropertyNameAccumulatorAddName(names, CYJSString(name)); + })); CYPoolTry { // XXX: this is an evil hack to deal with NSProxy; fix elsewhere @@ -1921,48 +1944,89 @@ static void Instance_getPropertyNames(JSContextRef context, JSObjectRef object, } CYPoolCatch() } -static JSObjectRef Instance_callAsConstructor(JSContextRef context, JSObjectRef object, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry { - Instance *internal(reinterpret_cast<Instance *>(JSObjectGetPrivate(object))); - JSObjectRef value(Instance::Make(context, [internal->GetValue() alloc], Instance::Uninitialized)); +static JSValueRef Instance_complete_callAsFunction(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry { + if (!CYJSValueIsNSObject(context, _this)) + return CYObjectMakeArray(context, 0, NULL); + + Instance *internal(reinterpret_cast<Instance *>(JSObjectGetPrivate(_this))); + id self(internal->value_); + + _assert(count == 1 || count == 2); + CYPool pool; + Class _class(object_getClass(self)); + + CYUTF8String prefix(CYPoolUTF8String(pool, context, CYJSString(context, arguments[0]))); + + JSObjectRef array(NULL); { + CYArrayBuilder<1024> values(context, array); + + CYForEachProperty(pool, _class, fun([&](objc_method *method, const char *name) { + if (!CYStartsWith(name, prefix)) + return; + const char *type(method_getTypeEncoding(method)); + if (type == NULL || *type == '\0' || *type == 'v') + return; + if (class_getProperty(_class, name) != NULL) + return; + values(CYCastJSValue(context, CYJSString(pool.strcat(name, "()", NULL)))); + })); + } return array; +} CYCatch(NULL) } + +static JSObjectRef Constructor_callAsConstructor(JSContextRef context, JSObjectRef object, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry { + auto internal(CYPrivate<Constructor>::Get(context, object)); + JSObjectRef value(CYMakeInstance(context, [internal->value_ alloc], Instance::Uninitialized)); return value; } CYCatch(NULL) } -static JSValueRef Instance_callAsFunction(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry { - Instance *internal(reinterpret_cast<Instance *>(JSObjectGetPrivate(object))); - id self(internal->GetValue()); +static const char *CYBlockEncoding(NSBlock *self) { + BlockLiteral *literal(reinterpret_cast<BlockLiteral *>(self)); + if ((literal->flags & BLOCK_HAS_SIGNATURE) == 0) + return NULL; + uint8_t *descriptor(reinterpret_cast<uint8_t *>(literal->descriptor)); + descriptor += sizeof(BlockDescriptor1); + if ((literal->flags & BLOCK_HAS_COPY_DISPOSE) != 0) + descriptor += sizeof(BlockDescriptor2); + BlockDescriptor3 *descriptor3(reinterpret_cast<BlockDescriptor3 *>(descriptor)); + return descriptor3->signature; +} - 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 +static bool CYBlockSignature(CYPool &pool, NSBlock *self, sig::Signature &signature) { + const char *encoding(CYBlockEncoding(self)); + if (encoding == NULL) + return false; - BlockLiteral *literal(reinterpret_cast<BlockLiteral *>(self)); + sig::Parse(pool, &signature, encoding, &Structor_); + _assert(signature.count >= 2); - if ((literal->flags & BLOCK_HAS_SIGNATURE) != 0) { - uint8_t *descriptor(reinterpret_cast<uint8_t *>(literal->descriptor)); - descriptor += sizeof(BlockDescriptor1); - if ((literal->flags & BLOCK_HAS_COPY_DISPOSE) != 0) - descriptor += sizeof(BlockDescriptor2); - BlockDescriptor3 *descriptor3(reinterpret_cast<BlockDescriptor3 *>(descriptor)); + _assert(dynamic_cast<sig::Object *>(signature.elements[1].type) != NULL); + signature.elements[1] = signature.elements[0]; - if (const char *type = descriptor3->signature) { - CYPool pool; + ++signature.elements; + --signature.count; - void *setup[1]; - setup[0] = &self; + return true; +} - sig::Signature signature; - sig::Parse(pool, &signature, type, &Structor_); +static JSValueRef FunctionInstance_callAsFunction(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry { + Instance *internal(reinterpret_cast<Instance *>(JSObjectGetPrivate(object))); + id self(internal->value_); - ffi_cif cif; - sig::sig_ffi_cif(pool, &sig::ObjectiveC, &signature, &cif); + if (const char *encoding = CYBlockEncoding(self)) { + CYPool pool; - void (*function)() = reinterpret_cast<void (*)()>(literal->invoke); - return CYCallFunction(pool, context, 1, setup, count, arguments, false, &signature, &cif, function); - } + void *setup[1]; + setup[0] = &self; + + sig::Signature signature; + sig::Parse(pool, &signature, encoding, &Structor_); + + ffi_cif cif; + sig::sig_ffi_cif(pool, 0, signature, &cif); + + BlockLiteral *literal(reinterpret_cast<BlockLiteral *>(self)); + void (*function)() = reinterpret_cast<void (*)()>(literal->invoke); + return CYCallFunction(pool, context, 1, setup, count, arguments, false, false, signature, &cif, function); } if (count != 0) @@ -1975,16 +2039,14 @@ static JSValueRef Instance_callAsFunction(JSContextRef context, JSObjectRef obje return NULL; } CYCatch(NULL) } -static bool Instance_hasInstance(JSContextRef context, JSObjectRef constructor, JSValueRef instance, JSValueRef *exception) { CYTry { - Instance *internal(reinterpret_cast<Instance *>(JSObjectGetPrivate((JSObjectRef) constructor))); - Class _class(internal->GetValue()); - if (!CYIsClass(_class)) - return false; +static bool Constructor_hasInstance(JSContextRef context, JSObjectRef constructor, JSValueRef instance, JSValueRef *exception) { CYTry { + auto internal(CYPrivate<Constructor>::Get(context, constructor)); + Class _class(internal->value_); if (CYJSValueIsNSObject(context, instance)) { Instance *linternal(reinterpret_cast<Instance *>(JSObjectGetPrivate((JSObjectRef) instance))); // XXX: this isn't always safe - return [linternal->GetValue() isKindOfClass:_class]; + return [linternal->value_ isKindOfClass:_class]; } return false; @@ -2000,11 +2062,11 @@ static JSValueRef Instance_box_callAsFunction(JSContextRef context, JSObjectRef return CYCastJSValue(context, [value cy$box]); } CYCatch(NULL) } -static bool Internal_hasProperty(JSContextRef context, JSObjectRef object, JSStringRef property) { - Internal *internal(reinterpret_cast<Internal *>(JSObjectGetPrivate(object))); +static bool Interior_hasProperty(JSContextRef context, JSObjectRef object, JSStringRef property) { + Interior *internal(reinterpret_cast<Interior *>(JSObjectGetPrivate(object))); CYPool pool; - id self(internal->GetValue()); + id self(internal->value_); const char *name(CYPoolCString(pool, context, property)); if (object_getInstanceVariable(self, name, NULL) != NULL) @@ -2013,61 +2075,66 @@ 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) { +static void CYBitField(CYPool &pool, 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)); + pool.atexit(free, ivars); + 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<Internal *>(JSObjectGetPrivate(object))); +static JSValueRef Interior_getProperty(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { CYTry { + Interior *internal(reinterpret_cast<Interior *>(JSObjectGetPrivate(object))); CYPool pool; - id self(internal->GetValue()); + id self(internal->value_); const char *name(CYPoolCString(pool, context, property)); -#ifdef __arm64__ - if (strcmp(name, "isa") == 0) - return CYCastJSValue(context, object_getClass(self)); -#endif - if (objc_ivar *ivar = object_getInstanceVariable(self, name, NULL)) { ptrdiff_t offset(ivar_getOffset(ivar)); void *data(reinterpret_cast<uint8_t *>(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); + CYBitField(pool, length, shift, self, ivar, encoding, offset); _assert(shift + length <= sizeof(uintptr_t) * 8); uintptr_t &field(*reinterpret_cast<uintptr_t *>(data)); uintptr_t mask((1 << length) - 1); return CYCastJSValue(context, (field >> shift) & mask); } else { - Type_privateData type(pool, ivar_getTypeEncoding(ivar)); - return CYFromFFI(context, type.type_, type.GetFFI(), data); +#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(NULL) } -static bool Internal_setProperty(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef value, JSValueRef *exception) { CYTry { - Internal *internal(reinterpret_cast<Internal *>(JSObjectGetPrivate(object))); +static bool Interior_setProperty(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef value, JSValueRef *exception) { CYTry { + Interior *internal(reinterpret_cast<Interior *>(JSObjectGetPrivate(object))); CYPool pool; - id self(internal->GetValue()); + id self(internal->value_); const char *name(CYPoolCString(pool, context, property)); if (objc_ivar *ivar = object_getInstanceVariable(self, name, NULL)) { @@ -2075,16 +2142,17 @@ static bool Internal_setProperty(JSContextRef context, JSObjectRef object, JSStr void *data(reinterpret_cast<uint8_t *>(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); + CYBitField(pool, length, shift, self, ivar, encoding, offset); _assert(shift + length <= sizeof(uintptr_t) * 8); uintptr_t &field(*reinterpret_cast<uintptr_t *>(data)); uintptr_t mask((1 << length) - 1); field = field & ~(mask << shift) | (uintptr_t(CYCastDouble(context, value)) & mask) << shift; } else { - Type_privateData type(pool, ivar_getTypeEncoding(ivar)); - CYPoolFFI(&pool, context, type.type_, type.GetFFI(), reinterpret_cast<uint8_t *>(self) + ivar_getOffset(ivar), value); + auto type(new(pool) Type_privateData(ivar_getTypeEncoding(ivar))); + type->type_->PoolFFI(&pool, context, type->GetFFI(), reinterpret_cast<uint8_t *>(self) + ivar_getOffset(ivar), value); return true; } } @@ -2092,47 +2160,46 @@ static bool Internal_setProperty(JSContextRef context, JSObjectRef object, JSStr return false; } CYCatch(false) } -static void Internal_getPropertyNames_(Class _class, JSPropertyNameAccumulatorRef names) { +static void Interior_getPropertyNames_(CYPool &pool, Class _class, JSPropertyNameAccumulatorRef names) { if (Class super = class_getSuperclass(_class)) - Internal_getPropertyNames_(super, names); + Interior_getPropertyNames_(pool, super, names); -#if OBJC_API_VERSION >= 2 unsigned int size; objc_ivar **data(class_copyIvarList(_class, &size)); + pool.atexit(free, data); + 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) { - Internal *internal(reinterpret_cast<Internal *>(JSObjectGetPrivate(object))); +static void Interior_getPropertyNames(JSContextRef context, JSObjectRef object, JSPropertyNameAccumulatorRef names) { + Interior *internal(reinterpret_cast<Interior *>(JSObjectGetPrivate(object))); CYPool pool; - id self(internal->GetValue()); + id self(internal->value_); Class _class(object_getClass(self)); - Internal_getPropertyNames_(_class, names); + Interior_getPropertyNames_(pool, _class, names); } -static JSValueRef Internal_callAsFunction_$cya(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry { - Internal *internal(reinterpret_cast<Internal *>(JSObjectGetPrivate(object))); - return internal->GetOwner(); +static JSValueRef Interior_callAsFunction_$cya(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry { + Interior *internal(reinterpret_cast<Interior *>(JSObjectGetPrivate(object))); + return internal->owner_; } 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)); if (Class _class = NSClassFromString(name)) - return CYMakeInstance(context, _class, true); + return CYMakeInstance(context, _class, Instance::Permanent); return NULL; } CYCatch(NULL) } -#ifdef __APPLE__ static Class *CYCopyClassList(size_t &size) { size = objc_getClassList(NULL, 0); Class *data(reinterpret_cast<Class *>(malloc(sizeof(Class) * size))); @@ -2154,81 +2221,80 @@ static Class *CYCopyClassList(size_t &size) { size = writ; } } -#endif static void ObjectiveC_Classes_getPropertyNames(JSContextRef context, JSObjectRef object, JSPropertyNameAccumulatorRef names) { -#ifdef __APPLE__ + CYPool pool; + size_t size; if (Class *data = CYCopyClassList(size)) { + pool.atexit(free, data); for (size_t i(0); i != size; ++i) JSPropertyNameAccumulatorAddName(names, CYJSString(class_getName(data[i]))); - free(data); } -#else - void *state(NULL); - while (Class _class = objc_next_class(&state)) - JSPropertyNameAccumulatorAddName(names, CYJSString(class_getName(_class))); -#endif } -#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<const char *>(JSObjectGetPrivate(object))); CYPool pool; const char *name(CYPoolCString(pool, context, property)); + unsigned int size; const char **data(objc_copyClassNamesForImage(internal, &size)); + pool.atexit(free, data); + JSValueRef value; 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); - goto free; - } else - break; + if (Class _class = objc_getClass(name)) + return CYMakeInstance(context, _class, Instance::Permanent); + else + return NULL; } - value = NULL; - free: - free(data); - return value; + + return NULL; } CYCatch(NULL) } static void ObjectiveC_Image_Classes_getPropertyNames(JSContextRef context, JSObjectRef object, JSPropertyNameAccumulatorRef names) { const char *internal(reinterpret_cast<const char *>(JSObjectGetPrivate(object))); + CYPool pool; + unsigned int size; const char **data(objc_copyClassNamesForImage(internal, &size)); + pool.atexit(free, data); + for (size_t i(0); i != size; ++i) JSPropertyNameAccumulatorAddName(names, CYJSString(data[i])); - free(data); } 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<char *>(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<char *>(name))); - return value; + + return NULL; } CYCatch(NULL) } static void ObjectiveC_Images_getPropertyNames(JSContextRef context, JSObjectRef object, JSPropertyNameAccumulatorRef names) { + CYPool pool; + unsigned int size; const char **data(objc_copyImageNames(&size)); + pool.atexit(free, data); + for (size_t i(0); i != size; ++i) JSPropertyNameAccumulatorAddName(names, CYJSString(data[i])); - free(data); } #endif @@ -2236,27 +2302,26 @@ 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(NULL) } static void ObjectiveC_Protocols_getPropertyNames(JSContextRef context, JSObjectRef object, JSPropertyNameAccumulatorRef names) { -#if OBJC_API_VERSION >= 2 + CYPool pool; + unsigned int size; Protocol **data(objc_copyProtocolList(&size)); + pool.atexit(free, data); + 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(NULL) } @@ -2293,7 +2358,7 @@ static void choose_(task_t task, void *baton, unsigned type, vm_range_t *ranges, continue; uintptr_t *pointers(reinterpret_cast<uintptr_t *>(data)); -#ifdef __arm64__ +#if defined(__APPLE__) && defined(__LP64__) Class isa(reinterpret_cast<Class>(pointers[0] & 0x1fffffff8)); #else Class isa(reinterpret_cast<Class>(pointers[0])); @@ -2303,8 +2368,14 @@ static void choose_(task_t task, void *baton, unsigned type, vm_range_t *ranges, if (result == choice->query_.end()) continue; - // XXX: if (size < class_getInstanceSize(*result)) - if ((class_getInstanceSize(*result) + 15) / 16 * 16 != size) + 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<id>(data))); } @@ -2317,7 +2388,7 @@ static JSValueRef choose(JSContextRef context, JSObjectRef object, JSObjectRef _ CYGarbageCollect(context); CYPool pool; - Class _class(CYCastNSObject(&pool, context, arguments[0])); + id _class(CYCastNSObject(&pool, context, arguments[0])); vm_address_t *zones(NULL); unsigned size(0); @@ -2334,6 +2405,7 @@ static JSValueRef choose(JSContextRef context, JSObjectRef object, JSObjectRef _ size_t number; Class *classes(CYCopyClassList(number)); _assert(classes != NULL); + pool.atexit(free, classes); for (size_t i(0); i != number; ++i) for (Class current(classes[i]); current != Nil; current = class_getSuperclass(current)) @@ -2342,8 +2414,6 @@ static JSValueRef choose(JSContextRef context, JSObjectRef object, JSObjectRef _ break; } - free(classes); - for (unsigned i(0); i != size; ++i) { const malloc_zone_t *zone(reinterpret_cast<const malloc_zone_t *>(zones[i])); if (zone == NULL || zone->introspect == NULL) @@ -2379,6 +2449,8 @@ static bool stret(ffi_type *ffi_type) { ); } #endif +#else +#define CY_NO_STRET #endif JSValueRef CYSendMessage(CYPool &pool, JSContextRef context, id self, Class _class, SEL _cmd, size_t count, const JSValueRef arguments[], bool initialize) { @@ -2396,11 +2468,14 @@ JSValueRef CYSendMessage(CYPool &pool, JSContextRef context, id self, Class _cla 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]; @@ -2410,45 +2485,20 @@ JSValueRef CYSendMessage(CYPool &pool, JSContextRef context, id self, Class _cla sig::Signature signature; sig::Parse(pool, &signature, type, &Structor_); - size_t used(count + 3); - if (used > signature.count) { - sig::Element *elements(new (pool) sig::Element[used]); - memcpy(elements, signature.elements, used * sizeof(sig::Element)); - - for (size_t index(signature.count); index != used; ++index) { - 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; - } - - signature.elements = elements; - signature.count = used; - } - ffi_cif cif; - sig::sig_ffi_cif(pool, &sig::ObjectiveC, &signature, &cif); + sig::sig_ffi_cif(pool, 0, signature, &cif); if (imp == NULL) { -#ifdef __APPLE__ #ifndef CY_NO_STRET if (stret(cif.rtype)) imp = class_getMethodImplementation_stret(_class, _cmd); else #endif imp = class_getMethodImplementation(_class, _cmd); -#else - objc_super super = {self, _class}; - imp = objc_msg_lookup_super(&super, _cmd); -#endif } void (*function)() = reinterpret_cast<void (*)()>(imp); - return CYCallFunction(pool, context, 2, setup, count, arguments, initialize, &signature, &cif, function); + return CYCallFunction(pool, context, 2, setup, count, arguments, initialize, true, signature, &cif, function); } static JSValueRef $objc_msgSend(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[]) { @@ -2463,17 +2513,17 @@ static JSValueRef $objc_msgSend(JSContextRef context, JSObjectRef object, JSObje SEL _cmd; Class _class; - if (JSValueIsObjectOfClass(context, arguments[0], Super_)) { + if (JSValueIsObjectOfClass(context, arguments[0], CYPrivate<cy::Super>::Class_)) { cy::Super *internal(reinterpret_cast<cy::Super *>(JSObjectGetPrivate((JSObjectRef) arguments[0]))); - self = internal->GetValue(); + self = internal->value_; _class = internal->class_;; uninitialized = false; } else if (CYJSValueIsNSObject(context, arguments[0])) { Instance *internal(reinterpret_cast<Instance *>(JSObjectGetPrivate((JSObjectRef) arguments[0]))); - self = internal->GetValue(); + self = internal->value_; _class = nil; uninitialized = internal->IsUninitialized(); - if (uninitialized) + if (uninitialized && [internal->value_ retainCount] != NSUInteger(-1)) internal->value_ = nil; } else { self = CYCastNSObject(&pool, context, arguments[0]); @@ -2512,7 +2562,7 @@ static JSValueRef Message_callAsFunction(JSContextRef context, JSObjectRef objec setup[0] = &self; setup[1] = &internal->sel_; - return CYCallFunction(pool, context, 2, setup, count, arguments, false, &internal->signature_, &internal->cif_, internal->GetValue()); + return CYCallFunction(pool, context, 2, setup, count, arguments, false, true, internal->signature_, &internal->cif_, internal->value_); } CYCatch(NULL) } static JSObjectRef Super_new(JSContextRef context, JSObjectRef object, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry { @@ -2521,7 +2571,7 @@ static JSObjectRef Super_new(JSContextRef context, JSObjectRef object, size_t co CYPool pool; id self(CYCastNSObject(&pool, context, arguments[0])); Class _class(CYCastClass(pool, context, arguments[1])); - return cy::Super::Make(context, self, _class); + return CYPrivate<cy::Super>::Make(context, self, _class); } CYCatch(NULL) } static JSObjectRef Selector_new(JSContextRef context, JSObjectRef object, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry { @@ -2529,66 +2579,67 @@ static JSObjectRef Selector_new(JSContextRef context, JSObjectRef object, size_t throw CYJSError(context, "incorrect number of arguments to Selector constructor"); CYPool pool; const char *name(CYPoolCString(pool, context, arguments[0])); - return CYMakeSelector(context, sel_registerName(name)); + return CYPrivate<Selector_privateData>::Make(context, sel_registerName(name)); } 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<id>(context, arguments[0])); - return CYMakeInstance(context, self, false); + return CYMakeInstance(context, CYCastPointer<id>(context, arguments[0])); } CYCatch(NULL) } -static JSValueRef CYValue_getProperty_value(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { CYTry { - CYValue *internal(reinterpret_cast<CYValue *>(JSObjectGetPrivate(object))); - return CYCastJSValue(context, reinterpret_cast<uintptr_t>(internal->value_)); +static JSValueRef Selector_getProperty_$cyt(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { CYTry { + return CYMakeType(context, sig::Selector()); } CYCatch(NULL) } -static JSValueRef CYValue_callAsFunction_$cya(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry { - CYValue *internal(reinterpret_cast<CYValue *>(JSObjectGetPrivate(_this))); - Type_privateData *typical(internal->GetType()); - - sig::Type *type; - ffi_type *ffi; +static JSValueRef Instance_getProperty_$cyt(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { CYTry { + Instance *internal(reinterpret_cast<Instance *>(JSObjectGetPrivate(object))); + id self(internal->value_); + return CYMakeType(context, sig::Object(class_getName(object_getClass(self)))); +} CYCatch(NULL) } - if (typical == NULL) { - type = NULL; - ffi = NULL; - } else { - type = typical->type_; - ffi = typical->ffi_; - } +static JSValueRef FunctionInstance_getProperty_$cyt(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { CYTry { + Instance *internal(reinterpret_cast<Instance *>(JSObjectGetPrivate(object))); + CYPool pool; + sig::Block type; + if (!CYBlockSignature(pool, internal->value_, type.signature)) + return CYJSNull(context); + return CYMakeType(context, type); +} CYCatch(NULL) } - return CYMakePointer(context, &internal->value_, _not(size_t), type, ffi, object); +static JSValueRef Constructor_getProperty_$cyt(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { CYTry { + return CYMakeType(context, sig::Meta()); } CYCatch(NULL) } static JSValueRef Instance_getProperty_constructor(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { CYTry { Instance *internal(reinterpret_cast<Instance *>(JSObjectGetPrivate(object))); - return Instance::Make(context, (id) object_getClass(internal->GetValue())); + return CYMakeInstance(context, object_getClass(internal->value_), Instance::Permanent); } CYCatch(NULL) } -static JSValueRef Instance_getProperty_prototype(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { CYTry { - Instance *internal(reinterpret_cast<Instance *>(JSObjectGetPrivate(object))); - id self(internal->GetValue()); - if (!CYIsClass(self)) - return CYJSUndefined(context); - return CYGetClassPrototype(context, self); +static JSValueRef Constructor_getProperty_constructor(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { CYTry { + auto internal(CYPrivate<Constructor>::Get(context, object)); + return CYMakeInstance(context, object_getClass(internal->value_), Instance::Permanent); } CYCatch(NULL) } -static JSValueRef Instance_getProperty_messages(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { CYTry { +static JSValueRef Constructor_getProperty_prototype(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { CYTry { Instance *internal(reinterpret_cast<Instance *>(JSObjectGetPrivate(object))); - id self(internal->GetValue()); - if (!CYIsClass(self)) - return CYJSUndefined(context); - return Messages::Make(context, (Class) self); + id self(internal->value_); + return CYPrivate<Prototype>::Cache(context, 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<void *> *objects(CYCastObjects(context, _this, count, arguments)); + if (!CYJSValueIsNSObject(context, _this)) return NULL; Instance *internal(reinterpret_cast<Instance *>(JSObjectGetPrivate(_this))); - return CYCastJSValue(context, CYJSString(context, CYCastNSCYON(internal->GetValue(), false))); + return CYCastJSValue(context, CYJSString(context, CYCastNSCYON(internal->value_, false, objects))); +} CYCatch(NULL) } + +static JSValueRef Constructor_callAsFunction_toCYON(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry { + auto internal(CYPrivate<Constructor>::Get(context, _this)); + return CYCastJSValue(context, CYJSString(class_getName(internal->value_))); } CYCatch(NULL) } static JSValueRef Instance_callAsFunction_toJSON(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry { @@ -2596,7 +2647,7 @@ static JSValueRef Instance_callAsFunction_toJSON(JSContextRef context, JSObjectR return NULL; Instance *internal(reinterpret_cast<Instance *>(JSObjectGetPrivate(_this))); - id value(internal->GetValue()); + id value(internal->value_); CYPoolTry { NSString *key; @@ -2619,7 +2670,8 @@ static JSValueRef Instance_callAsFunction_valueOf(JSContextRef context, JSObject return NULL; Instance *internal(reinterpret_cast<Instance *>(JSObjectGetPrivate(_this))); - id value(internal->GetValue()); + id value(internal->value_); + _assert(value != nil); if (![value respondsToSelector:@selector(cy$valueOfInContext:)]) return _this; @@ -2633,10 +2685,15 @@ static JSValueRef Instance_callAsFunction_valueOf(JSContextRef context, JSObject static JSValueRef Instance_callAsFunction_toPointer(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<Instance *>(JSObjectGetPrivate(_this))); - // XXX: but... but... THIS ISN'T A POINTER! :( - return CYCastJSValue(context, reinterpret_cast<uintptr_t>(internal->GetValue())); + // XXX: return CYMakePointer(context, internal->value_, sig::Object(class_getName(object_getClass(internal->value_))), NULL, object); + return CYCastJSValue(context, reinterpret_cast<uintptr_t>(internal->value_)); +} CYCatch(NULL) return /*XXX*/ NULL; } + +static JSValueRef Constructor_callAsFunction_toPointer(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry { + auto internal(CYPrivate<Constructor>::Get(context, object)); + // XXX: return CYMakePointer(context, internal->value_, sig::Meta(), NULL, object); + return CYCastJSValue(context, reinterpret_cast<uintptr_t>(internal->value_)); } 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 { @@ -2644,7 +2701,7 @@ static JSValueRef Instance_callAsFunction_toString(JSContextRef context, JSObjec return NULL; Instance *internal(reinterpret_cast<Instance *>(JSObjectGetPrivate(_this))); - id value(internal->GetValue()); + id value(internal->value_); CYPoolTry { // XXX: this seems like a stupid implementation; what if it crashes? why not use the CYONifier backend? @@ -2657,26 +2714,18 @@ static JSValueRef Class_callAsFunction_pointerTo(JSContextRef context, JSObjectR return NULL; Instance *internal(reinterpret_cast<Instance *>(JSObjectGetPrivate(_this))); - id value(internal->GetValue()); + id value(internal->value_); if (!CYIsClass(value)) CYThrow("non-Class object cannot be used as Type"); - // XXX: this is a very silly implementation - - std::ostringstream type; - type << "@\""; - type << class_getName(value); - type << "\""; - - CYPoolTry { - return CYMakeType(context, type.str().c_str()); - } CYPoolCatch(NULL) + 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<Selector_privateData *>(JSObjectGetPrivate(_this))); - return CYCastJSValue(context, sel_getName(internal->GetValue())); + return CYCastJSValue(context, sel_getName(internal->value_)); } CYCatch(NULL) } static JSValueRef Selector_callAsFunction_toJSON(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { @@ -2685,7 +2734,7 @@ static JSValueRef Selector_callAsFunction_toJSON(JSContextRef context, JSObjectR static JSValueRef Selector_callAsFunction_toCYON(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry { Selector_privateData *internal(reinterpret_cast<Selector_privateData *>(JSObjectGetPrivate(_this))); - const char *name(sel_getName(internal->GetValue())); + const char *name(sel_getName(internal->value_)); CYPoolTry { NSString *string([NSString stringWithFormat:@"@selector(%s)", name]); @@ -2699,38 +2748,38 @@ static JSValueRef Selector_callAsFunction_type(JSContextRef context, JSObjectRef CYPool pool; Selector_privateData *internal(reinterpret_cast<Selector_privateData *>(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; + SEL sel(internal->value_); - const char *encoding(CYPoolTypeEncoding(pool, context, sel, method)); - if (encoding == NULL) - return CYJSNull(context); + Class _class(_require(CYCastClass(pool, context, arguments[0]))); + objc_method *method(_require(class_getInstanceMethod(_class, sel))); + const char *encoding(method_getTypeEncoding(method)); - sig::Signature signature; - sig::Parse(pool, &signature, encoding, &Structor_); - return CYMakeType(context, &signature); + sig::Function type(false); + sig::Parse(pool, &type.signature, encoding, &Structor_); + return CYMakeType(context, type); } CYCatch(NULL) } static JSStaticValue Selector_staticValues[2] = { - {"value", &CYValue_getProperty_value, NULL, kJSPropertyAttributeReadOnly | kJSPropertyAttributeDontDelete}, + {"$cyt", &Selector_getProperty_$cyt, NULL, kJSPropertyAttributeReadOnly | kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, {NULL, NULL, NULL, 0} }; -static JSStaticValue Instance_staticValues[5] = { +static JSStaticValue Instance_staticValues[3] = { + {"$cyt", &Instance_getProperty_$cyt, NULL, kJSPropertyAttributeReadOnly | kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, + // XXX: this is sadly duplicated in FunctionInstance_staticValues + {"constructor", &Instance_getProperty_constructor, NULL, kJSPropertyAttributeReadOnly | kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, + {NULL, NULL, NULL, 0} +}; + +static JSStaticValue FunctionInstance_staticValues[3] = { + {"$cyt", &FunctionInstance_getProperty_$cyt, 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}, + {"cy$complete", &Instance_complete_callAsFunction, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, {"toCYON", &Instance_callAsFunction_toCYON, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, {"toJSON", &Instance_callAsFunction_toJSON, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, {"valueOf", &Instance_callAsFunction_valueOf, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, @@ -2739,13 +2788,28 @@ static JSStaticFunction Instance_staticFunctions[7] = { {NULL, NULL, 0} }; -static JSStaticFunction Class_staticFunctions[2] = { +static JSStaticFunction Messages_staticFunctions[2] = { + {"cy$complete", &Messages_complete_callAsFunction, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, + {NULL, NULL, 0} +}; + +static JSStaticValue Constructor_staticValues[5] = { + {"$cyi", &Constructor_getProperty_$cyi, NULL, kJSPropertyAttributeReadOnly | kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, + {"$cyt", &Constructor_getProperty_$cyt, NULL, kJSPropertyAttributeReadOnly | kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, + {"constructor", &Constructor_getProperty_constructor, NULL, kJSPropertyAttributeReadOnly | kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, + {"prototype", &Constructor_getProperty_prototype, NULL, kJSPropertyAttributeReadOnly | kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, + {NULL, NULL, NULL, 0} +}; + +static JSStaticFunction Constructor_staticFunctions[5] = { {"pointerTo", &Class_callAsFunction_pointerTo, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, + {"toCYON", &Constructor_callAsFunction_toCYON, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, + {"toPointer", &Constructor_callAsFunction_toPointer, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, {NULL, NULL, 0} }; -static JSStaticFunction Internal_staticFunctions[2] = { - {"$cya", &Internal_callAsFunction_$cya, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, +static JSStaticFunction Interior_staticFunctions[2] = { + {"$cya", &Interior_callAsFunction_$cya, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, {NULL, NULL, 0} }; @@ -2764,15 +2828,6 @@ JSValueRef NSCFType$cy$toJSON$inContext$(id self, SEL sel, JSValueRef key, JSCon #endif void CYObjectiveC_Initialize() { /*XXX*/ JSContextRef context(NULL); CYPoolTry { - $objc_setAssociatedObject = reinterpret_cast<void (*)(id, void *, id value, objc_AssociationPolicy)>(dlsym(RTLD_DEFAULT, "objc_setAssociatedObject")); - $objc_getAssociatedObject = reinterpret_cast<id (*)(id, void *)>(dlsym(RTLD_DEFAULT, "objc_getAssociatedObject")); - $objc_removeAssociatedObjects = reinterpret_cast<void (*)(id)>(dlsym(RTLD_DEFAULT, "objc_removeAssociatedObjects")); - - CYPool &pool(CYGetGlobalPool()); - - Object_type = new(pool) Type_privateData("@"); - Selector_type = new(pool) Type_privateData(":"); - NSArray_ = objc_getClass("NSArray"); NSBlock_ = objc_getClass("NSBlock"); NSDictionary_ = objc_getClass("NSDictionary"); @@ -2791,18 +2846,34 @@ void CYObjectiveC_Initialize() { /*XXX*/ JSContextRef context(NULL); CYPoolTry { NSCFType_ = objc_getClass("NSCFType"); NSZombie_ = objc_getClass("_NSZombie_"); - - banned_.insert(Object_); - banned_.insert(objc_getClass("__NSAtom")); - banned_.insert(objc_getClass("__NSGenericDeallocHandler")); - banned_.insert(objc_getClass("NSMessageBuilder")); - banned_.insert(objc_getClass("__NSMessageBuilder")); #else NSBoolNumber_ = objc_getClass("NSBoolNumber"); + NSZombie_ = objc_getClass("NSZombie"); #endif JSClassDefinition definition; + definition = kJSClassDefinitionEmpty; + definition.attributes = kJSClassAttributeNoAutomaticPrototype; + definition.className = "Messages"; + definition.staticFunctions = Messages_staticFunctions; + definition.hasProperty = &Messages_hasProperty; + definition.getProperty = &Messages_getProperty; + definition.setProperty = &Messages_setProperty; + CYPrivate<Messages>::Class_ = JSClassCreate(&definition); + + definition = kJSClassDefinitionEmpty; + definition.className = "Constructor"; + definition.parentClass = CYPrivate<Messages>::Class_; + definition.staticValues = Constructor_staticValues; + definition.staticFunctions = Constructor_staticFunctions; + definition.hasInstance = &Constructor_hasInstance; + definition.hasProperty = &Constructor_hasProperty; + definition.getProperty = &Constructor_getProperty; + definition.callAsConstructor = &Constructor_callAsConstructor; + definition.finalize = &CYFinalize; + CYPrivate<Constructor>::Class_ = JSClassCreate(&definition); + definition = kJSClassDefinitionEmpty; definition.className = "Instance"; definition.staticValues = Instance_staticValues; @@ -2812,11 +2883,8 @@ void CYObjectiveC_Initialize() { /*XXX*/ JSContextRef context(NULL); CYPoolTry { definition.setProperty = &Instance_setProperty; 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); + Instance::Class_ = JSClassCreate(&definition); definition.className = "ArrayInstance"; ArrayInstance_ = JSClassCreate(&definition); @@ -2824,9 +2892,6 @@ void CYObjectiveC_Initialize() { /*XXX*/ JSContextRef context(NULL); CYPoolTry { definition.className = "BooleanInstance"; BooleanInstance_ = JSClassCreate(&definition); - definition.className = "FunctionInstance"; - FunctionInstance_ = JSClassCreate(&definition); - definition.className = "NumberInstance"; NumberInstance_ = JSClassCreate(&definition); @@ -2836,20 +2901,20 @@ void CYObjectiveC_Initialize() { /*XXX*/ JSContextRef context(NULL); CYPoolTry { definition.className = "StringInstance"; StringInstance_ = JSClassCreate(&definition); - definition = kJSClassDefinitionEmpty; - definition.className = "Class"; - definition.staticFunctions = Class_staticFunctions; - Class_ = JSClassCreate(&definition); + definition.className = "FunctionInstance"; + definition.staticValues = FunctionInstance_staticValues; + definition.callAsFunction = &FunctionInstance_callAsFunction; + FunctionInstance_ = JSClassCreate(&definition); definition = kJSClassDefinitionEmpty; - definition.className = "Internal"; - definition.staticFunctions = Internal_staticFunctions; - definition.hasProperty = &Internal_hasProperty; - definition.getProperty = &Internal_getProperty; - definition.setProperty = &Internal_setProperty; - definition.getPropertyNames = &Internal_getPropertyNames; + definition.className = "Interior"; + definition.staticFunctions = Interior_staticFunctions; + definition.hasProperty = &Interior_hasProperty; + definition.getProperty = &Interior_getProperty; + definition.setProperty = &Interior_setProperty; + definition.getPropertyNames = &Interior_getPropertyNames; definition.finalize = &CYFinalize; - Internal_ = JSClassCreate(&definition); + CYPrivate<Interior>::Class_ = JSClassCreate(&definition); definition = kJSClassDefinitionEmpty; definition.className = "Message"; @@ -2857,19 +2922,14 @@ void CYObjectiveC_Initialize() { /*XXX*/ JSContextRef context(NULL); CYPoolTry { definition.staticValues = cy::Functor::StaticValues; definition.callAsFunction = &Message_callAsFunction; definition.finalize = &CYFinalize; - Message_ = JSClassCreate(&definition); + Message_privateData::Class_ = JSClassCreate(&definition); definition = kJSClassDefinitionEmpty; - definition.className = "Messages"; - 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.attributes = kJSClassAttributeNoAutomaticPrototype; + definition.className = "Prototype"; + definition.parentClass = CYPrivate<Messages>::Class_; definition.finalize = &CYFinalize; - Messages_ = JSClassCreate(&definition); + CYPrivate<Prototype>::Class_ = JSClassCreate(&definition); definition = kJSClassDefinitionEmpty; definition.className = "Selector"; @@ -2877,16 +2937,16 @@ void CYObjectiveC_Initialize() { /*XXX*/ JSContextRef context(NULL); CYPoolTry { definition.staticFunctions = Selector_staticFunctions; definition.callAsFunction = &Selector_callAsFunction; definition.finalize = &CYFinalize; - Selector_ = JSClassCreate(&definition); + CYPrivate<Selector_privateData>::Class_ = JSClassCreate(&definition); definition = kJSClassDefinitionEmpty; definition.className = "Super"; - definition.staticFunctions = Internal_staticFunctions; definition.finalize = &CYFinalize; - Super_ = JSClassCreate(&definition); + CYPrivate<cy::Super>::Class_ = JSClassCreate(&definition); 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); @@ -2897,7 +2957,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; @@ -2918,12 +2978,14 @@ void CYObjectiveC_Initialize() { /*XXX*/ JSContextRef context(NULL); CYPoolTry { ObjectiveC_Protocols_ = JSClassCreate(&definition); #ifdef __APPLE__ -// XXX: this is horrible; there has to be a better way to do this -#ifdef __LP64__ - class_addMethod(NSCFType_, @selector(cy$toJSON:inContext:), reinterpret_cast<IMP>(&NSCFType$cy$toJSON$inContext$), "^{OpaqueJSValue=}32@0:8@16^{OpaqueJSContext=}24"); -#else - class_addMethod(NSCFType_, @selector(cy$toJSON:inContext:), reinterpret_cast<IMP>(&NSCFType$cy$toJSON$inContext$), "^{OpaqueJSValue=}16@0:4@8^{OpaqueJSContext=}12"); -#endif + class_addMethod(NSCFType_, @selector(cy$toJSON:inContext:), reinterpret_cast<IMP>(&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() } @@ -2949,60 +3011,60 @@ 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)); - JSObjectRef Super(JSObjectMakeConstructor(context, Super_, &Super_new)); + JSObjectRef Message(JSObjectMakeConstructor(context, Message_privateData::Class_, NULL)); + JSObjectRef Selector(JSObjectMakeConstructor(context, CYPrivate<Selector_privateData>::Class_, &Selector_new)); + JSObjectRef Super(JSObjectMakeConstructor(context, CYPrivate<cy::Super>::Class_, &Super_new)); + JSObjectRef Instance(JSObjectMakeConstructor(context, Instance::Class_, &Instance_new)); JSObjectRef Instance_prototype(CYCastJSObject(context, CYGetProperty(context, Instance, prototype_s))); CYSetProperty(context, cy, CYJSString("Instance_prototype"), Instance_prototype); + JSObjectRef Constructor(JSObjectMakeConstructor(context, CYPrivate<::Constructor>::Class_, NULL)); + JSObjectRef Constructor_prototype(CYCastJSObject(context, CYGetProperty(context, Constructor, prototype_s))); + CYSetProperty(context, cy, CYJSString("Constructor_prototype"), Constructor_prototype); + JSObjectRef ArrayInstance(JSObjectMakeConstructor(context, ArrayInstance_, NULL)); 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"))); - JSObjectSetPrototype(context, BooleanInstance_prototype, 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"))); - JSObjectSetPrototype(context, NumberInstance_prototype, 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); - - JSObjectRef Class_prototype(CYCastJSObject(context, CYGetProperty(context, Class, prototype_s))); - CYSetProperty(context, cy, CYJSString("Class_prototype"), Class_prototype); - JSObjectSetPrototype(context, Class_prototype, Instance_prototype); + CYSetPrototype(context, StringInstance_prototype, String_prototype); CYSetProperty(context, cycript, CYJSString("Instance"), Instance); + CYSetProperty(context, cycript, CYJSString("Message"), Message); CYSetProperty(context, cycript, CYJSString("Selector"), Selector); CYSetProperty(context, cycript, CYJSString("objc_super"), Super); @@ -3015,33 +3077,47 @@ void CYObjectiveC_SetupContext(JSContextRef context) { CYPoolTry { 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); + + CYSetProperty(context, cy, CYJSString("cydget"), CYCastJSValue(context, false)); } 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<void *>(&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 "C" void CydgetSetupContext(JSGlobalContextRef context) { CYObjectiveTry_ { +_extern void CydgetSetupContext(JSGlobalContextRef context) { CYObjectiveTry_ { CYSetupContext(context); + JSObjectRef global(CYGetGlobalObject(context)); + JSObjectRef cy(CYCastJSObject(context, CYGetProperty(context, global, cy_s))); + CYSetProperty(context, cy, CYJSString("cydget"), CYCastJSValue(context, true)); } CYObjectiveCatch } -extern "C" void CydgetMemoryParse(const uint16_t **data, size_t *size) { try { +_extern void CydgetMemoryParse(const uint16_t **data, size_t *size) { try { CYPool pool; CYUTF8String utf8(CYPoolUTF8String(pool, CYUTF16String(*data, *size)));