X-Git-Url: https://git.saurik.com/cycript.git/blobdiff_plain/61933e1667bc5f4853a5bcee425ebc9785a366f0..f37e350174fca2296b6052746d6e0a9796ad67cb:/Library.mm?ds=sidebyside diff --git a/Library.mm b/Library.mm index 5d292ae..3357080 100644 --- a/Library.mm +++ b/Library.mm @@ -48,16 +48,12 @@ #include "Pooling.hpp" #include "Struct.hpp" -#include - #include #include +#include #include -#include -#include -#include #include #include @@ -65,11 +61,14 @@ #include #include +#include #include #include "Parser.hpp" #include "Cycript.tab.hh" +#include + #undef _assert #undef _trace @@ -98,51 +97,180 @@ } \ } +void CYThrow(JSContextRef context, JSValueRef value); + +const char *CYPoolCCYON(apr_pool_t *pool, JSContextRef context, JSValueRef value, JSValueRef *exception); +JSStringRef CYCopyJSString(const char *value); + +void CYSetProperty(JSContextRef context, JSObjectRef object, JSStringRef name, JSValueRef value); + +JSValueRef CYCallFunction(apr_pool_t *pool, JSContextRef context, size_t setups, void *setup[], size_t count, const JSValueRef arguments[], bool initialize, JSValueRef *exception, sig::Signature *signature, ffi_cif *cif, void (*function)()); +JSValueRef CYSendMessage(apr_pool_t *pool, JSContextRef context, id self, SEL _cmd, size_t count, const JSValueRef arguments[], bool initialize, JSValueRef *exception); + +/* JavaScript Properties {{{ */ +JSValueRef CYGetProperty(JSContextRef context, JSObjectRef object, size_t index) { + JSValueRef exception(NULL); + JSValueRef value(JSObjectGetPropertyAtIndex(context, object, index, &exception)); + CYThrow(context, exception); + return value; +} + +JSValueRef CYGetProperty(JSContextRef context, JSObjectRef object, JSStringRef name) { + JSValueRef exception(NULL); + JSValueRef value(JSObjectGetProperty(context, object, name, &exception)); + CYThrow(context, exception); + return value; +} + +void CYSetProperty(JSContextRef context, JSObjectRef object, size_t index, JSValueRef value) { + JSValueRef exception(NULL); + JSObjectSetPropertyAtIndex(context, object, index, value, &exception); + CYThrow(context, exception); +} + +void CYSetProperty(JSContextRef context, JSObjectRef object, JSStringRef name, JSValueRef value) { + JSValueRef exception(NULL); + JSObjectSetProperty(context, object, name, value, kJSPropertyAttributeNone, &exception); + CYThrow(context, exception); +} +/* }}} */ +/* JavaScript Strings {{{ */ +JSStringRef CYCopyJSString(id value) { + // XXX: this definition scares me; is anyone using this?! + return value == NULL ? NULL : JSStringCreateWithCFString(reinterpret_cast([value description])); +} + +JSStringRef CYCopyJSString(const char *value) { + return value == NULL ? NULL : JSStringCreateWithUTF8CString(value); +} + +JSStringRef CYCopyJSString(JSStringRef value) { + return value == NULL ? NULL : JSStringRetain(value); +} + +JSStringRef CYCopyJSString(JSContextRef context, JSValueRef value) { + if (JSValueIsNull(context, value)) + return NULL; + JSValueRef exception(NULL); + JSStringRef string(JSValueToStringCopy(context, value, &exception)); + CYThrow(context, exception); + return string; +} + +class CYJSString { + private: + JSStringRef string_; + + void Clear_() { + if (string_ != NULL) + JSStringRelease(string_); + } + + public: + CYJSString(const CYJSString &rhs) : + string_(CYCopyJSString(rhs.string_)) + { + } + + template + CYJSString(Arg0_ arg0) : + string_(CYCopyJSString(arg0)) + { + } + + template + CYJSString(Arg0_ arg0, Arg1_ arg1) : + string_(CYCopyJSString(arg0, arg1)) + { + } + + CYJSString &operator =(const CYJSString &rhs) { + Clear_(); + string_ = CYCopyJSString(rhs.string_); + return *this; + } + + ~CYJSString() { + Clear_(); + } + + void Clear() { + Clear_(); + string_ = NULL; + } + + operator JSStringRef() const { + return string_; + } +}; + +CFStringRef CYCopyCFString(JSStringRef value) { + return JSStringCopyCFString(kCFAllocatorDefault, value); +} + +CFStringRef CYCopyCFString(JSContextRef context, JSValueRef value) { + return CYCopyCFString(CYJSString(context, value)); +} + +/* }}} */ + static JSGlobalContextRef Context_; static JSObjectRef System_; +static JSObjectRef ObjectiveC_; static JSClassRef Functor_; static JSClassRef Instance_; +static JSClassRef Internal_; +static JSClassRef Message_; +static JSClassRef Messages_; +static JSClassRef NSArrayPrototype_; static JSClassRef Pointer_; static JSClassRef Runtime_; static JSClassRef Selector_; static JSClassRef Struct_; +static JSClassRef Type_; + +static JSClassRef ObjectiveC_Classes_; +static JSClassRef ObjectiveC_Image_Classes_; +static JSClassRef ObjectiveC_Images_; +static JSClassRef ObjectiveC_Protocols_; static JSObjectRef Array_; static JSObjectRef Function_; +static JSObjectRef String_; + +static JSStringRef Result_; static JSStringRef length_; static JSStringRef message_; static JSStringRef name_; +static JSStringRef prototype_; static JSStringRef toCYON_; static JSStringRef toJSON_; -static Class NSCFBoolean_; - -static NSArray *Bridge_; +static JSObjectRef Instance_prototype_; +static JSObjectRef Object_prototype_; -struct CYData { - apr_pool_t *pool_; +static JSObjectRef Array_prototype_; +static JSObjectRef Array_pop_; +static JSObjectRef Array_push_; +static JSObjectRef Array_splice_; - virtual ~CYData() { - } +static Class NSArray_; +static Class NSCFBoolean_; +static Class NSCFType_; +static Class NSDictionary_; +static Class NSMessageBuilder_; +static Class NSZombie_; +static Class Object_; - static void *operator new(size_t size) { - apr_pool_t *pool; - apr_pool_create(&pool, NULL); - void *data(apr_palloc(pool, size)); - reinterpret_cast(data)->pool_ = pool; - return data; - } +static NSArray *Bridge_; - static void operator delete(void *data) { - apr_pool_destroy(reinterpret_cast(data)->pool_); - } +static void Finalize(JSObjectRef object) { + delete reinterpret_cast(JSObjectGetPrivate(object)); +} - static void Finalize(JSObjectRef object) { - delete reinterpret_cast(JSObjectGetPrivate(object)); - } -}; +class Type_privateData; struct CYValue : CYData @@ -156,6 +284,15 @@ struct CYValue : value_(value) { } + + CYValue(const CYValue &rhs) : + value_(rhs.value_) + { + } + + virtual Type_privateData *GetType() const { + return NULL; + } }; struct Selector_privateData : @@ -169,8 +306,41 @@ struct Selector_privateData : SEL GetValue() const { return reinterpret_cast(value_); } + + virtual Type_privateData *GetType() const; }; +// XXX: trick this out with associated objects! +JSValueRef CYGetClassPrototype(JSContextRef context, id self) { + if (self == nil) + return Instance_prototype_; + + // XXX: I need to think through multi-context + typedef std::map CacheMap; + static CacheMap cache_; + + JSValueRef &value(cache_[self]); + if (value != NULL) + return value; + + JSClassRef _class(NULL); + JSValueRef prototype; + + if (self == NSArray_) + prototype = Array_prototype_; + else if (self == NSDictionary_) + prototype = Object_prototype_; + else + prototype = CYGetClassPrototype(context, class_getSuperclass(self)); + + JSObjectRef object(JSObjectMake(context, _class, NULL)); + JSObjectSetPrototype(context, object, prototype); + + JSValueProtect(context, object); + value = object; + return object; +} + struct Instance : CYValue { @@ -191,11 +361,14 @@ struct Instance : virtual ~Instance() { if ((flags_ & Transient) == 0) // XXX: does this handle background threads correctly? + // XXX: this simply does not work on the console because I'm stupid [GetValue() performSelector:@selector(release) withObject:nil afterDelay:0]; } - static JSObjectRef Make(JSContextRef context, id object, Flags flags) { - return JSObjectMake(context, Instance_, new Instance(object, flags)); + static JSObjectRef Make(JSContextRef context, id object, Flags flags = None) { + JSObjectRef value(JSObjectMake(context, Instance_, new Instance(object, flags))); + JSObjectSetPrototype(context, value, CYGetClassPrototype(context, object == nil ? nil : object_getClass(object))); + return value; } id GetValue() const { @@ -205,6 +378,74 @@ struct Instance : bool IsUninitialized() const { return (flags_ & Uninitialized) != 0; } + + virtual Type_privateData *GetType() const; +}; + +struct Messages : + CYValue +{ + Messages(Class value) : + CYValue(value) + { + } + + static JSObjectRef Make(JSContextRef context, Class _class, bool array = false) { + JSObjectRef value(JSObjectMake(context, Messages_, new Messages(_class))); + if (_class == NSArray_) + array = true; + if (Class super = class_getSuperclass(_class)) + JSObjectSetPrototype(context, value, Messages::Make(context, super, array)); + /*else if (array) + JSObjectSetPrototype(context, value, Array_prototype_);*/ + return value; + } + + Class GetValue() const { + return reinterpret_cast(value_); + } +}; + +struct CYOwned : + CYValue +{ + private: + JSContextRef context_; + JSObjectRef owner_; + + public: + CYOwned(void *value, JSContextRef context, JSObjectRef owner) : + CYValue(value), + context_(context), + owner_(owner) + { + JSValueProtect(context_, owner_); + } + + virtual ~CYOwned() { + JSValueUnprotect(context_, owner_); + } + + JSObjectRef GetOwner() const { + return owner_; + } +}; + +struct Internal : + CYOwned +{ + Internal(id value, JSContextRef context, JSObjectRef owner) : + CYOwned(value, context, owner) + { + } + + static JSObjectRef Make(JSContextRef context, id object, JSObjectRef owner) { + return JSObjectMake(context, Internal_, new Internal(object, context, owner)); + } + + id GetValue() const { + return reinterpret_cast(value_); + } }; namespace sig { @@ -238,9 +479,14 @@ void Copy(apr_pool_t *pool, Type &lhs, Type &rhs) { if (sig::IsAggregate(rhs.primitive)) Copy(pool, lhs.data.signature, rhs.data.signature); else { - if (rhs.data.data.type != NULL) { - lhs.data.data.type = new(pool) Type; - Copy(pool, *lhs.data.data.type, *rhs.data.data.type); + sig::Type *&lht(lhs.data.data.type); + sig::Type *&rht(rhs.data.data.type); + + if (rht == NULL) + lht = NULL; + else { + lht = new(pool) Type; + Copy(pool, *lht, *rht); } lhs.data.data.size = rhs.data.data.size; @@ -280,29 +526,62 @@ struct CStringMapLess : } }; -struct Type_privateData { - apr_pool_t *pool_; +void Structor_(apr_pool_t *pool, const char *name, const char *types, sig::Type *&type) { + if (name == NULL) + return; + + CYPoolTry { + if (NSMutableArray *entry = [[Bridge_ objectAtIndex:2] objectForKey:[NSString stringWithUTF8String:name]]) + switch ([[entry objectAtIndex:0] intValue]) { + case 0: { + sig::Parse(pool, &type->data.signature, [[entry objectAtIndex:1] UTF8String], &Structor_); + } break; + + case 1: { + sig::Signature signature; + sig::Parse(pool, &signature, [[entry objectAtIndex:1] UTF8String], &Structor_); + type = signature.elements[0].type; + } break; + } + } CYPoolCatch() +} + +struct Type_privateData : + CYData +{ + static Type_privateData *Object; + static Type_privateData *Selector; ffi_type *ffi_; sig::Type *type_; - Type_privateData(apr_pool_t *pool, sig::Type *type) : - pool_(pool), + void Set(sig::Type *type) { + type_ = new(pool_) sig::Type; + sig::Copy(pool_, *type_, *type); + } + + Type_privateData(apr_pool_t *pool, const char *type) : ffi_(NULL) { - if (type != NULL) { - type_ = new(pool) sig::Type; - sig::Copy(pool, *type_, *type); - } + if (pool != NULL) + pool_ = pool; + + sig::Signature signature; + sig::Parse(pool_, &signature, type, &Structor_); + type_ = signature.elements[0].type; } - Type_privateData(apr_pool_t *pool, sig::Type *type, ffi_type *ffi) : - pool_(pool) + Type_privateData(sig::Type *type) : + ffi_(NULL) { - ffi_ = new(pool) ffi_type; - sig::Copy(pool, *ffi_, *ffi); - type_ = new(pool) sig::Type; - sig::Copy(pool, *type_, *type); + if (type != NULL) + Set(type); + } + + Type_privateData(sig::Type *type, ffi_type *ffi) { + ffi_ = new(pool_) ffi_type; + sig::Copy(pool_, *ffi_, *ffi); + Set(type); } ffi_type *GetFFI() { @@ -327,28 +606,36 @@ struct Type_privateData { } }; +Type_privateData *Type_privateData::Object; +Type_privateData *Type_privateData::Selector; + +Type_privateData *Instance::GetType() const { + return Type_privateData::Object; +} + +Type_privateData *Selector_privateData::GetType() const { + return Type_privateData::Selector; +} + struct Pointer : - CYValue + CYOwned { - JSObjectRef owner_; Type_privateData *type_; - Pointer(void *value, sig::Type *type, JSObjectRef owner) : - CYValue(value), - owner_(owner), - type_(new(pool_) Type_privateData(pool_, type)) + Pointer(void *value, JSContextRef context, JSObjectRef owner, sig::Type *type) : + CYOwned(value, context, owner), + type_(new(pool_) Type_privateData(type)) { } }; struct Struct_privateData : - CYValue + CYOwned { - JSObjectRef owner_; Type_privateData *type_; - Struct_privateData(JSObjectRef owner) : - owner_(owner) + Struct_privateData(JSContextRef context, JSObjectRef owner) : + CYOwned(NULL, context, owner) { } }; @@ -357,9 +644,9 @@ typedef std::map TypeMap; static TypeMap Types_; JSObjectRef CYMakeStruct(JSContextRef context, void *data, sig::Type *type, ffi_type *ffi, JSObjectRef owner) { - Struct_privateData *internal(new Struct_privateData(owner)); + Struct_privateData *internal(new Struct_privateData(context, owner)); apr_pool_t *pool(internal->pool_); - Type_privateData *typical(new(pool) Type_privateData(pool, type, ffi)); + Type_privateData *typical(new(pool) Type_privateData(type, ffi)); internal->type_ = typical; if (owner != NULL) @@ -374,54 +661,58 @@ JSObjectRef CYMakeStruct(JSContextRef context, void *data, sig::Type *type, ffi_ return JSObjectMake(context, Struct_, internal); } -void Structor_(apr_pool_t *pool, const char *name, const char *types, sig::Type *&type) { - if (name == NULL) - return; - - CYPoolTry { - if (NSMutableArray *entry = [[Bridge_ objectAtIndex:2] objectForKey:[NSString stringWithUTF8String:name]]) - switch ([[entry objectAtIndex:0] intValue]) { - case 0: { - sig::Parse(pool, &type->data.signature, [[entry objectAtIndex:1] UTF8String], &Structor_); - } break; - - case 1: { - sig::Signature signature; - sig::Parse(pool, &signature, [[entry objectAtIndex:1] UTF8String], &Structor_); - type = signature.elements[0].type; - } break; - } - } CYPoolCatch() -} - struct Functor_privateData : CYValue { sig::Signature signature_; ffi_cif cif_; + Functor_privateData(const char *type, void (*value)()) : CYValue(reinterpret_cast(value)) { sig::Parse(pool_, &signature_, type, &Structor_); sig::sig_ffi_cif(pool_, &sig::ObjectiveC, &signature_, &cif_); } + + void (*GetValue())() const { + return reinterpret_cast(value_); + } }; -struct ffoData : +struct Closure_privateData : Functor_privateData { JSContextRef context_; JSObjectRef function_; - ffoData(const char *type) : - Functor_privateData(type, NULL) + Closure_privateData(JSContextRef context, JSObjectRef function, const char *type) : + Functor_privateData(type, NULL), + context_(context), + function_(function) { + JSValueProtect(context_, function_); + } + + virtual ~Closure_privateData() { + JSValueUnprotect(context_, function_); } }; -JSObjectRef CYMakeInstance(JSContextRef context, id object, bool transient) { - Instance::Flags flags; +struct Message_privateData : + Functor_privateData +{ + SEL sel_; + + Message_privateData(SEL sel, const char *type, IMP value = NULL) : + Functor_privateData(type, reinterpret_cast(value)), + sel_(sel) + { + } +}; + +JSObjectRef CYMakeInstance(JSContextRef context, id object, bool transient) { + Instance::Flags flags; if (transient) flags = Instance::Transient; @@ -469,7 +760,29 @@ JSValueRef CYJSUndefined(JSContextRef context) { return JSValueMakeUndefined(context); } -bool CYGetIndex(const char *value, ssize_t &index) { +size_t CYGetIndex(const char *value) { + if (value[0] != '0') { + char *end; + size_t index(strtoul(value, &end, 10)); + if (value + strlen(value) == end) + return index; + } else if (value[1] == '\0') + return 0; + return _not(size_t); +} + +// XXX: fix this +static const char *CYPoolCString(apr_pool_t *pool, JSStringRef value); + +size_t CYGetIndex(apr_pool_t *pool, NSString *value) { + return CYGetIndex(CYPoolCString(pool, value)); +} + +size_t CYGetIndex(apr_pool_t *pool, JSStringRef value) { + return CYGetIndex(CYPoolCString(pool, value)); +} + +bool CYGetOffset(const char *value, ssize_t &index) { if (value[0] != '0') { char *end; index = strtol(value, &end, 10); @@ -483,10 +796,12 @@ bool CYGetIndex(const char *value, ssize_t &index) { return false; } -bool CYGetIndex(apr_pool_t *pool, NSString *value, ssize_t &index) { - return CYGetIndex(CYPoolCString(pool, value), index); +bool CYGetOffset(apr_pool_t *pool, NSString *value, ssize_t &index) { + return CYGetOffset(CYPoolCString(pool, value), index); } +NSString *CYPoolNSCYON(apr_pool_t *pool, id value); + @interface NSMethodSignature (Cycript) - (NSString *) _typeString; @end @@ -500,6 +815,7 @@ bool CYGetIndex(apr_pool_t *pool, NSString *value, ssize_t &index) { - (NSString *) cy$toCYON; - (NSString *) cy$toKey; +- (bool) cy$hasProperty:(NSString *)name; - (NSObject *) cy$getProperty:(NSString *)name; - (bool) cy$setProperty:(NSString *)name to:(NSObject *)value; - (bool) cy$deleteProperty:(NSString *)name; @@ -600,82 +916,11 @@ struct PropertyAttributes { }; -@implementation NSObject (Cycript) - -- (JSValueRef) cy$JSValueInContext:(JSContextRef)context { - return CYMakeInstance(context, self, false); -} - -- (JSType) cy$JSType { - return kJSTypeObject; -} - -- (NSObject *) cy$toJSON:(NSString *)key { - return [self description]; -} - -- (NSString *) cy$toCYON { - return [[self cy$toJSON:@""] cy$toCYON]; -} - -- (NSString *) cy$toKey { - return [self cy$toCYON]; -} - -- (NSObject *) cy$getProperty:(NSString *)name { - /*if (![name isEqualToString:@"prototype"]) - NSLog(@"get:%@", name);*/ - return nil; -} - -- (bool) cy$setProperty:(NSString *)name to:(NSObject *)value { - //NSLog(@"set:%@", name); - return false; -} - -- (bool) cy$deleteProperty:(NSString *)name { - //NSLog(@"delete:%@", name); - return false; -} - -@end - -@implementation WebUndefined (Cycript) - -- (JSType) cy$JSType { - return kJSTypeUndefined; -} - -- (NSObject *) cy$toJSON:(NSString *)key { - return self; -} - -- (NSString *) cy$toCYON { - return @"undefined"; -} - -- (JSValueRef) cy$JSValueInContext:(JSContextRef)context { - return CYJSUndefined(context); -} - -@end - -@implementation NSNull (Cycript) - -- (JSType) cy$JSType { - return kJSTypeNull; -} - -- (NSObject *) cy$toJSON:(NSString *)key { - return self; -} - -- (NSString *) cy$toCYON { - return @"null"; +NSString *NSCFType$cy$toJSON(id self, SEL sel, NSString *key) { + return [(NSString *) CFCopyDescription((CFTypeRef) self) autorelease]; } -@end - +/* Bridge: NSArray {{{ */ @implementation NSArray (Cycript) - (NSString *) cy$toCYON { @@ -688,8 +933,8 @@ struct PropertyAttributes { [json appendString:@","]; else comma = true; - if ([object cy$JSType] != kJSTypeUndefined) - [json appendString:[object cy$toCYON]]; + if (object == nil || [object cy$JSType] != kJSTypeUndefined) + [json appendString:CYPoolNSCYON(NULL, object)]; else { [json appendString:@","]; comma = false; @@ -700,43 +945,31 @@ struct PropertyAttributes { return json; } +- (bool) cy$hasProperty:(NSString *)name { + if ([name isEqualToString:@"length"]) + return true; + + size_t index(CYGetIndex(NULL, name)); + if (index == _not(size_t) || index >= [self count]) + return [super cy$hasProperty:name]; + else + return true; +} + - (NSObject *) cy$getProperty:(NSString *)name { if ([name isEqualToString:@"length"]) return [NSNumber numberWithUnsignedInteger:[self count]]; - ssize_t index; - if (!CYGetIndex(NULL, name, index) || index < 0 || index >= static_cast([self count])) + size_t index(CYGetIndex(NULL, name)); + if (index == _not(size_t) || index >= [self count]) return [super cy$getProperty:name]; else return [self objectAtIndex:index]; } @end - -@implementation NSMutableArray (Cycript) - -- (bool) cy$setProperty:(NSString *)name to:(NSObject *)value { - ssize_t index; - if (!CYGetIndex(NULL, name, index) || index < 0 || index >= static_cast([self count])) - return [super cy$setProperty:name to:value]; - else { - [self replaceObjectAtIndex:index withObject:(value ?: [NSNull null])]; - return true; - } -} - -- (bool) cy$deleteProperty:(NSString *)name { - ssize_t index; - if (!CYGetIndex(NULL, name, index) || index < 0 || index >= static_cast([self count])) - return [super cy$deleteProperty:name]; - else { - [self removeObjectAtIndex:index]; - return true; - } -} - -@end - +/* }}} */ +/* Bridge: NSDictionary {{{ */ @implementation NSDictionary (Cycript) - (NSString *) cy$toCYON { @@ -752,19 +985,74 @@ struct PropertyAttributes { [json appendString:[key cy$toKey]]; [json appendString:@":"]; NSObject *object([self objectForKey:key]); - [json appendString:[object cy$toCYON]]; + [json appendString:CYPoolNSCYON(NULL, object)]; } [json appendString:@"}"]; return json; } +- (bool) cy$hasProperty:(NSString *)name { + return [self objectForKey:name] != nil; +} + - (NSObject *) cy$getProperty:(NSString *)name { return [self objectForKey:name]; } @end +/* }}} */ +/* Bridge: NSMutableArray {{{ */ +@implementation NSMutableArray (Cycript) + +- (bool) cy$setProperty:(NSString *)name to:(NSObject *)value { + if ([name isEqualToString:@"length"]) { + // XXX: is this not intelligent? + NSUInteger size([(NSNumber *)value unsignedIntegerValue]); + NSUInteger count([self count]); + if (size < count) + [self removeObjectsInRange:NSMakeRange(size, count - size)]; + else if (size != count) { + WebUndefined *undefined([WebUndefined undefined]); + for (size_t i(count); i != size; ++i) + [self addObject:undefined]; + } + return true; + } + + size_t index(CYGetIndex(NULL, name)); + if (index == _not(size_t)) + return [super cy$setProperty:name to:value]; + + id object(value ?: [NSNull null]); + + size_t count([self count]); + if (index < count) + [self replaceObjectAtIndex:index withObject:object]; + else { + if (index != count) { + WebUndefined *undefined([WebUndefined undefined]); + for (size_t i(count); i != index; ++i) + [self addObject:undefined]; + } + + [self addObject:object]; + } + + return true; +} + +- (bool) cy$deleteProperty:(NSString *)name { + size_t index(CYGetIndex(NULL, name)); + if (index == _not(size_t) || index >= [self count]) + return [super cy$deleteProperty:name]; + [self replaceObjectAtIndex:index withObject:[WebUndefined undefined]]; + return true; +} +@end +/* }}} */ +/* Bridge: NSMutableDictionary {{{ */ @implementation NSMutableDictionary (Cycript) - (bool) cy$setProperty:(NSString *)name to:(NSObject *)value { @@ -782,7 +1070,8 @@ struct PropertyAttributes { } @end - +/* }}} */ +/* Bridge: NSNumber {{{ */ @implementation NSNumber (Cycript) - (JSType) cy$JSType { @@ -803,7 +1092,79 @@ struct PropertyAttributes { } @end +/* }}} */ +/* Bridge: NSNull {{{ */ +@implementation NSNull (Cycript) + +- (JSType) cy$JSType { + return kJSTypeNull; +} + +- (NSObject *) cy$toJSON:(NSString *)key { + return self; +} + +- (NSString *) cy$toCYON { + return @"null"; +} + +@end +/* }}} */ +/* Bridge: NSObject {{{ */ +@implementation NSObject (Cycript) + +- (JSValueRef) cy$JSValueInContext:(JSContextRef)context { + return CYMakeInstance(context, self, false); +} + +- (JSType) cy$JSType { + return kJSTypeObject; +} + +- (NSObject *) cy$toJSON:(NSString *)key { + return [self description]; +} + +- (NSString *) cy$toCYON { + return [[self cy$toJSON:@""] cy$toCYON]; +} + +- (NSString *) cy$toKey { + return [self cy$toCYON]; +} + +- (bool) cy$hasProperty:(NSString *)name { + return false; +} + +- (NSObject *) cy$getProperty:(NSString *)name { + return nil; +} + +- (bool) cy$setProperty:(NSString *)name to:(NSObject *)value { + return false; +} + +- (bool) cy$deleteProperty:(NSString *)name { + return false; +} + +@end +/* }}} */ +/* Bridge: NSProxy {{{ */ +@implementation NSProxy (Cycript) + +- (NSObject *) cy$toJSON:(NSString *)key { + return [self description]; +} + +- (NSString *) cy$toCYON { + return [[self cy$toJSON:@""] cy$toCYON]; +} +@end +/* }}} */ +/* Bridge: NSString {{{ */ @implementation NSString (Cycript) - (JSType) cy$JSType { @@ -838,8 +1199,8 @@ struct PropertyAttributes { goto cyon; if (DigitRange_[value[0]]) { - ssize_t index; - if (!CYGetIndex(NULL, self, index) || index < 0) + size_t index(CYGetIndex(NULL, self)); + if (index == _not(size_t)) goto cyon; } else { if (!WordStartRange_[value[0]]) @@ -861,8 +1222,30 @@ struct PropertyAttributes { } @end +/* }}} */ +/* Bridge: WebUndefined {{{ */ +@implementation WebUndefined (Cycript) + +- (JSType) cy$JSType { + return kJSTypeUndefined; +} + +- (NSObject *) cy$toJSON:(NSString *)key { + return self; +} + +- (NSString *) cy$toCYON { + return @"undefined"; +} + +- (JSValueRef) cy$JSValueInContext:(JSContextRef)context { + return CYJSUndefined(context); +} + +@end +/* }}} */ -@interface CYJSObject : NSDictionary { +@interface CYJSObject : NSMutableDictionary { JSObjectRef object_; JSContextRef context_; } @@ -879,7 +1262,7 @@ struct PropertyAttributes { @end -@interface CYJSArray : NSArray { +@interface CYJSArray : NSMutableArray { JSObjectRef object_; JSContextRef context_; } @@ -889,15 +1272,13 @@ struct PropertyAttributes { - (NSUInteger) count; - (id) objectAtIndex:(NSUInteger)index; -@end - -CYRange DigitRange_ (0x3ff000000000000LLU, 0x000000000000000LLU); // 0-9 -CYRange WordStartRange_(0x000001000000000LLU, 0x7fffffe87fffffeLLU); // A-Za-z_$ -CYRange WordEndRange_ (0x3ff001000000000LLU, 0x7fffffe87fffffeLLU); // A-Za-z_$0-9 +- (void) addObject:(id)anObject; +- (void) insertObject:(id)anObject atIndex:(NSUInteger)index; +- (void) removeLastObject; +- (void) removeObjectAtIndex:(NSUInteger)index; +- (void) replaceObjectAtIndex:(NSUInteger)index withObject:(id)anObject; -JSGlobalContextRef CYGetJSContext() { - return Context_; -} +@end #define CYTry \ @try @@ -907,8 +1288,6 @@ JSGlobalContextRef CYGetJSContext() { return NULL; \ } -void CYThrow(JSContextRef context, JSValueRef value); - apr_status_t CYPoolRelease_(void *data) { id object(reinterpret_cast(data)); [object release]; @@ -942,97 +1321,21 @@ id CYCastNSObject(apr_pool_t *pool, JSContextRef context, JSObjectRef object) { if (!JSValueIsObjectOfClass(context, object, Instance_)) return CYCastNSObject_(pool, context, object); else { - Instance *data(reinterpret_cast(JSObjectGetPrivate(object))); - return data->GetValue(); + Instance *internal(reinterpret_cast(JSObjectGetPrivate(object))); + return internal->GetValue(); } } -JSStringRef CYCopyJSString(id value) { - return value == NULL ? NULL : JSStringCreateWithCFString(reinterpret_cast([value description])); +double CYCastDouble(const char *value, size_t size) { + char *end; + double number(strtod(value, &end)); + if (end != value + size) + return NAN; + return number; } -JSStringRef CYCopyJSString(const char *value) { - return value == NULL ? NULL : JSStringCreateWithUTF8CString(value); -} - -JSStringRef CYCopyJSString(JSStringRef value) { - return value == NULL ? NULL : JSStringRetain(value); -} - -JSStringRef CYCopyJSString(JSContextRef context, JSValueRef value) { - if (JSValueIsNull(context, value)) - return NULL; - JSValueRef exception(NULL); - JSStringRef string(JSValueToStringCopy(context, value, &exception)); - CYThrow(context, exception); - return string; -} - -class CYJSString { - private: - JSStringRef string_; - - void Clear_() { - if (string_ != NULL) - JSStringRelease(string_); - } - - public: - CYJSString(const CYJSString &rhs) : - string_(CYCopyJSString(rhs.string_)) - { - } - - template - CYJSString(Arg0_ arg0) : - string_(CYCopyJSString(arg0)) - { - } - - template - CYJSString(Arg0_ arg0, Arg1_ arg1) : - string_(CYCopyJSString(arg0, arg1)) - { - } - - CYJSString &operator =(const CYJSString &rhs) { - Clear_(); - string_ = CYCopyJSString(rhs.string_); - return *this; - } - - ~CYJSString() { - Clear_(); - } - - void Clear() { - Clear_(); - string_ = NULL; - } - - operator JSStringRef() const { - return string_; - } -}; - -CFStringRef CYCopyCFString(JSStringRef value) { - return JSStringCopyCFString(kCFAllocatorDefault, value); -} - -CFStringRef CYCopyCFString(JSContextRef context, JSValueRef value) { - return CYCopyCFString(CYJSString(context, value)); -} - -double CYCastDouble(const char *value, size_t size) { - char *end; - double number(strtod(value, &end)); - if (end != value + size) - return NAN; - return number; -} - -double CYCastDouble(const char *value) { - return CYCastDouble(value, strlen(value)); +double CYCastDouble(const char *value) { + return CYCastDouble(value, strlen(value)); } double CYCastDouble(JSContextRef context, JSValueRef value) { @@ -1166,26 +1469,6 @@ JSObjectRef CYCastJSObject(JSContextRef context, JSValueRef value) { return object; } -JSValueRef CYGetProperty(JSContextRef context, JSObjectRef object, size_t index) { - JSValueRef exception(NULL); - JSValueRef value(JSObjectGetPropertyAtIndex(context, object, index, &exception)); - CYThrow(context, exception); - return value; -} - -JSValueRef CYGetProperty(JSContextRef context, JSObjectRef object, JSStringRef name) { - JSValueRef exception(NULL); - JSValueRef value(JSObjectGetProperty(context, object, name, &exception)); - CYThrow(context, exception); - return value; -} - -void CYSetProperty(JSContextRef context, JSObjectRef object, JSStringRef name, JSValueRef value) { - JSValueRef exception(NULL); - JSObjectSetProperty(context, object, name, value, kJSPropertyAttributeNone, &exception); - CYThrow(context, exception); -} - void CYThrow(JSContextRef context, id error, JSValueRef *exception) { if (exception == NULL) throw error; @@ -1210,9 +1493,15 @@ bool CYIsCallable(JSContextRef context, JSValueRef value) { if ((self = [super init]) != nil) { object_ = object; context_ = context; + JSValueProtect(context_, object_); } return self; } +- (void) dealloc { + JSValueUnprotect(context_, object_); + [super dealloc]; +} + - (NSObject *) cy$toJSON:(NSString *)key { JSValueRef toJSON(CYGetProperty(context_, object_, toJSON_)); if (!CYIsCallable(context_, toJSON)) @@ -1227,12 +1516,11 @@ bool CYIsCallable(JSContextRef context, JSValueRef value) { - (NSString *) cy$toCYON { JSValueRef toCYON(CYGetProperty(context_, object_, toCYON_)); - if (!CYIsCallable(context_, toCYON)) + if (!CYIsCallable(context_, toCYON)) super: return [super cy$toCYON]; - else { - JSValueRef value(CYCallAsFunction(context_, (JSObjectRef) toCYON, object_, 0, NULL)); + else if (JSValueRef value = CYCallAsFunction(context_, (JSObjectRef) toCYON, object_, 0, NULL)) return CYCastNSString(NULL, CYJSString(context_, value)); - } + else goto super; } - (NSUInteger) count { @@ -1243,7 +1531,10 @@ bool CYIsCallable(JSContextRef context, JSValueRef value) { } - (id) objectForKey:(id)key { - return CYCastNSObject(NULL, context_, CYGetProperty(context_, object_, CYJSString(key))) ?: [NSNull null]; + JSValueRef value(CYGetProperty(context_, object_, CYJSString(key))); + if (JSValueIsUndefined(context_, value)) + return nil; + return CYCastNSObject(NULL, context_, value) ?: [NSNull null]; } - (NSEnumerator *) keyEnumerator { @@ -1271,39 +1562,136 @@ bool CYIsCallable(JSContextRef context, JSValueRef value) { if ((self = [super init]) != nil) { object_ = object; context_ = context; + JSValueProtect(context_, object_); } return self; } +- (void) dealloc { + JSValueUnprotect(context_, object_); + [super dealloc]; +} + - (NSUInteger) count { return CYCastDouble(context_, CYGetProperty(context_, object_, length_)); } - (id) objectAtIndex:(NSUInteger)index { + size_t bounds([self count]); + if (index >= bounds) + @throw [NSException exceptionWithName:NSRangeException reason:[NSString stringWithFormat:@"*** -[CYJSArray objectAtIndex:]: index (%zu) beyond bounds (%zu)", index, bounds] userInfo:nil]; JSValueRef exception(NULL); JSValueRef value(JSObjectGetPropertyAtIndex(context_, object_, index, &exception)); CYThrow(context_, exception); return CYCastNSObject(NULL, context_, value) ?: [NSNull null]; } +- (void) addObject:(id)object { + JSValueRef exception(NULL); + JSValueRef arguments[1]; + arguments[0] = CYCastJSValue(context_, object); + JSObjectCallAsFunction(context_, Array_push_, object_, 1, arguments, &exception); + CYThrow(context_, exception); +} + +- (void) insertObject:(id)object atIndex:(NSUInteger)index { + size_t bounds([self count] + 1); + if (index >= bounds) + @throw [NSException exceptionWithName:NSRangeException reason:[NSString stringWithFormat:@"*** -[CYJSArray insertObject:atIndex:]: index (%zu) beyond bounds (%zu)", index, bounds] userInfo:nil]; + JSValueRef exception(NULL); + JSValueRef arguments[3]; + arguments[0] = CYCastJSValue(context_, index); + arguments[1] = CYCastJSValue(context_, 0); + arguments[2] = CYCastJSValue(context_, object); + JSObjectCallAsFunction(context_, Array_splice_, object_, 3, arguments, &exception); + CYThrow(context_, exception); +} + +- (void) removeLastObject { + JSValueRef exception(NULL); + JSObjectCallAsFunction(context_, Array_pop_, object_, 0, NULL, &exception); + CYThrow(context_, exception); +} + +- (void) removeObjectAtIndex:(NSUInteger)index { + size_t bounds([self count]); + if (index >= bounds) + @throw [NSException exceptionWithName:NSRangeException reason:[NSString stringWithFormat:@"*** -[CYJSArray removeObjectAtIndex:]: index (%zu) beyond bounds (%zu)", index, bounds] userInfo:nil]; + JSValueRef exception(NULL); + JSValueRef arguments[2]; + arguments[0] = CYCastJSValue(context_, index); + arguments[1] = CYCastJSValue(context_, 1); + JSObjectCallAsFunction(context_, Array_splice_, object_, 2, arguments, &exception); + CYThrow(context_, exception); +} + +- (void) replaceObjectAtIndex:(NSUInteger)index withObject:(id)object { + size_t bounds([self count]); + if (index >= bounds) + @throw [NSException exceptionWithName:NSRangeException reason:[NSString stringWithFormat:@"*** -[CYJSArray replaceObjectAtIndex:withObject:]: index (%zu) beyond bounds (%zu)", index, bounds] userInfo:nil]; + CYSetProperty(context_, object_, index, CYCastJSValue(context_, object)); +} + @end -CFStringRef CYCopyCYONString(JSContextRef context, JSValueRef value, JSValueRef *exception) { +NSString *CYCopyNSCYON(id value) { + NSString *string; + + if (value == nil) + string = @"nil"; + else { + Class _class(object_getClass(value)); + SEL sel(@selector(cy$toCYON)); + + if (Method toCYON = class_getInstanceMethod(_class, sel)) + string = reinterpret_cast(method_getImplementation(toCYON))(value, sel); + else if (Method methodSignatureForSelector = class_getInstanceMethod(_class, @selector(methodSignatureForSelector:))) { + if (reinterpret_cast(method_getImplementation(methodSignatureForSelector))(value, @selector(methodSignatureForSelector:), sel) != nil) + string = [value cy$toCYON]; + else goto fail; + } else fail: { + if (value == NSZombie_) + string = @"_NSZombie_"; + else if (_class == NSZombie_) + string = [NSString stringWithFormat:@"<_NSZombie_: %p>", value]; + // XXX: frowny /in/ the pants + else if (value == NSMessageBuilder_ || value == Object_) + string = nil; + else + string = [NSString stringWithFormat:@"%@", value]; + } + + // XXX: frowny pants + if (string == nil) + string = @"undefined"; + } + + return [string retain]; +} + +NSString *CYCopyNSCYON(JSContextRef context, JSValueRef value, JSValueRef *exception) { + if (JSValueIsNull(context, value)) + return [@"null" retain]; + CYTry { CYPoolTry { - id object(CYCastNSObject(NULL, context, value) ?: [NSNull null]); - return reinterpret_cast([[object cy$toCYON] retain]); + return CYCopyNSCYON(CYCastNSObject(NULL, context, value)); } CYPoolCatch(NULL) } CYCatch } -const char *CYPoolCYONString(apr_pool_t *pool, JSContextRef context, JSValueRef value, JSValueRef *exception) { - if (NSString *json = (NSString *) CYCopyCYONString(context, value, exception)) { +NSString *CYPoolNSCYON(apr_pool_t *pool, id value) { + return CYPoolRelease(pool, static_cast(CYCopyNSCYON(value))); +} + +const char *CYPoolCCYON(apr_pool_t *pool, JSContextRef context, JSValueRef value, JSValueRef *exception) { + if (NSString *json = CYCopyNSCYON(context, value, exception)) { const char *string(CYPoolCString(pool, json)); [json release]; return string; } else return NULL; } +// XXX: use objc_getAssociatedObject and objc_setAssociatedObject on 10.6 struct CYInternal : CYData { @@ -1341,6 +1729,12 @@ struct CYInternal : return internal; } + bool HasProperty(JSContextRef context, JSStringRef name) { + if (object_ == NULL) + return false; + return JSObjectHasProperty(context, object_, name); + } + JSValueRef GetProperty(JSContextRef context, JSStringRef name) { if (object_ == NULL) return NULL; @@ -1354,126 +1748,40 @@ struct CYInternal : } }; -static JSValueRef Instance_getProperty(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { - CYPool pool; - - CYTry { - NSString *self(CYCastNSObject(pool, context, object)); - NSString *name(CYCastNSString(pool, property)); - - if (CYInternal *internal = CYInternal::Get(self)) - if (JSValueRef value = internal->GetProperty(context, property)) - return value; - - CYPoolTry { - if (NSObject *data = [self cy$getProperty:name]) - return CYCastJSValue(context, data); - } CYPoolCatch(NULL) - - if (objc_property_t property = class_getProperty(object_getClass(self), [name UTF8String])) { - PropertyAttributes attributes(property); - SEL sel(sel_registerName(attributes.Getter())); - return CYSendMessage(pool, context, self, sel, 0, NULL, false, exception); - } - - return NULL; - } CYCatch -} - -static bool Instance_setProperty(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef value, JSValueRef *exception) { - CYPool pool; - - CYTry { - NSString *self(CYCastNSObject(pool, context, object)); - NSString *name(CYCastNSString(pool, property)); - NSString *data(CYCastNSObject(pool, context, value)); - - CYPoolTry { - if ([self cy$setProperty:name to:data]) - return true; - } CYPoolCatch(NULL) - - if (objc_property_t property = class_getProperty(object_getClass(self), [name UTF8String])) { - PropertyAttributes attributes(property); - if (const char *setter = attributes.Setter()) { - SEL sel(sel_registerName(setter)); - JSValueRef arguments[1] = {value}; - CYSendMessage(pool, context, self, sel, 1, arguments, false, exception); - return true; - } - } - - if (CYInternal *internal = CYInternal::Set(self)) { - internal->SetProperty(context, property, value); - return true; - } - - return false; - } CYCatch -} - -static bool Instance_deleteProperty(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { - CYTry { - CYPoolTry { - NSString *self(CYCastNSObject(NULL, context, object)); - NSString *name(CYCastNSString(NULL, property)); - return [self cy$deleteProperty:name]; - } CYPoolCatch(NULL) - } CYCatch -} - -static JSObjectRef Instance_callAsConstructor(JSContextRef context, JSObjectRef object, size_t count, const JSValueRef arguments[], JSValueRef *exception) { - CYTry { - Instance *data(reinterpret_cast(JSObjectGetPrivate(object))); - JSObjectRef value(Instance::Make(context, [data->GetValue() alloc], Instance::Uninitialized)); - return value; - } CYCatch +static JSObjectRef CYMakeSelector(JSContextRef context, SEL sel) { + Selector_privateData *internal(new Selector_privateData(sel)); + return JSObjectMake(context, Selector_, internal); } -JSObjectRef CYMakeSelector(JSContextRef context, SEL sel) { - Selector_privateData *data(new Selector_privateData(sel)); - return JSObjectMake(context, Selector_, data); +static JSObjectRef CYMakePointer(JSContextRef context, void *pointer, sig::Type *type, ffi_type *ffi, JSObjectRef owner) { + Pointer *internal(new Pointer(pointer, context, owner, type)); + return JSObjectMake(context, Pointer_, internal); } -JSObjectRef CYMakePointer(JSContextRef context, void *pointer, sig::Type *type, JSObjectRef owner) { - Pointer *data(new Pointer(pointer, type, owner)); - return JSObjectMake(context, Pointer_, data); +static JSObjectRef CYMakeFunctor(JSContextRef context, void (*function)(), const char *type) { + Functor_privateData *internal(new Functor_privateData(type, function)); + return JSObjectMake(context, Functor_, internal); } -JSObjectRef CYMakeFunctor(JSContextRef context, void (*function)(), const char *type) { - Functor_privateData *data(new Functor_privateData(type, function)); - return JSObjectMake(context, Functor_, data); -} - -const char *CYPoolCString(apr_pool_t *pool, JSStringRef value, size_t *length = NULL) { +static const char *CYPoolCString(apr_pool_t *pool, JSStringRef value) { if (pool == NULL) { + // XXX: this could be much more efficient const char *string([CYCastNSString(NULL, value) UTF8String]); - if (length != NULL) - *length = strlen(string); return string; } else { size_t size(JSStringGetMaximumUTF8CStringSize(value)); char *string(new(pool) char[size]); JSStringGetUTF8CString(value, string, size); - // XXX: this is ironic - if (length != NULL) - *length = strlen(string); return string; } } -const char *CYPoolCString(apr_pool_t *pool, JSContextRef context, JSValueRef value, size_t *length = NULL) { - if (!JSValueIsNull(context, value)) - return CYPoolCString(pool, CYJSString(context, value), length); - else { - if (length != NULL) - *length = 0; - return NULL; - } +static const char *CYPoolCString(apr_pool_t *pool, JSContextRef context, JSValueRef value) { + return JSValueIsNull(context, value) ? NULL : CYPoolCString(pool, CYJSString(context, value)); } -bool CYGetIndex(apr_pool_t *pool, JSStringRef value, ssize_t &index) { - return CYGetIndex(CYPoolCString(pool, value), index); +static bool CYGetOffset(apr_pool_t *pool, JSStringRef value, ssize_t &index) { + return CYGetOffset(CYPoolCString(pool, value), index); } // XXX: this macro is unhygenic @@ -1491,7 +1799,7 @@ bool CYGetIndex(apr_pool_t *pool, JSStringRef value, ssize_t &index) { utf8; \ }) -void *CYCastPointer_(JSContextRef context, JSValueRef value) { +static void *CYCastPointer_(JSContextRef context, JSValueRef value) { switch (JSValueGetType(context, value)) { case kJSTypeNull: return NULL; @@ -1499,8 +1807,8 @@ void *CYCastPointer_(JSContextRef context, JSValueRef value) { return dlsym(RTLD_DEFAULT, CYCastCString(context, value)); case kJSTypeObject: if (JSValueIsObjectOfClass(context, value, Pointer_)) { - Pointer *data(reinterpret_cast(JSObjectGetPrivate((JSObjectRef) value))); - return data->value_; + Pointer *internal(reinterpret_cast(JSObjectGetPrivate((JSObjectRef) value))); + return internal->value_; }*/ default: double number(CYCastDouble(context, value)); @@ -1511,19 +1819,19 @@ void *CYCastPointer_(JSContextRef context, JSValueRef value) { } template -_finline Type_ CYCastPointer(JSContextRef context, JSValueRef value) { +static _finline Type_ CYCastPointer(JSContextRef context, JSValueRef value) { return reinterpret_cast(CYCastPointer_(context, value)); } -SEL CYCastSEL(JSContextRef context, JSValueRef value) { +static SEL CYCastSEL(JSContextRef context, JSValueRef value) { if (JSValueIsObjectOfClass(context, value, Selector_)) { - Selector_privateData *data(reinterpret_cast(JSObjectGetPrivate((JSObjectRef) value))); - return reinterpret_cast(data->value_); + Selector_privateData *internal(reinterpret_cast(JSObjectGetPrivate((JSObjectRef) value))); + return reinterpret_cast(internal->value_); } else return CYCastPointer(context, value); } -void CYPoolFFI(apr_pool_t *pool, JSContextRef context, sig::Type *type, ffi_type *ffi, void *data, JSValueRef value) { +static void CYPoolFFI(apr_pool_t *pool, JSContextRef context, sig::Type *type, ffi_type *ffi, void *data, JSValueRef value) { switch (type->primitive) { case sig::boolean_P: *reinterpret_cast(data) = JSValueToBoolean(context, value); @@ -1601,7 +1909,7 @@ void CYPoolFFI(apr_pool_t *pool, JSContextRef context, sig::Type *type, ffi_type } } -JSValueRef CYFromFFI(JSContextRef context, sig::Type *type, ffi_type *ffi, void *data, bool initialize, JSObjectRef owner = NULL) { +static JSValueRef CYFromFFI(JSContextRef context, sig::Type *type, ffi_type *ffi, void *data, bool initialize = false, JSObjectRef owner = NULL) { JSValueRef value; switch (type->primitive) { @@ -1647,7 +1955,7 @@ JSValueRef CYFromFFI(JSContextRef context, sig::Type *type, ffi_type *ffi, void case sig::pointer_P: if (void *pointer = *reinterpret_cast(data)) - value = CYMakePointer(context, pointer, type->data.data.type, owner); + value = CYMakePointer(context, pointer, type->data.data.type, ffi, owner); else goto null; break; @@ -1677,14 +1985,472 @@ JSValueRef CYFromFFI(JSContextRef context, sig::Type *type, ffi_type *ffi, void return value; } -bool Index_(apr_pool_t *pool, Struct_privateData *internal, JSStringRef property, ssize_t &index, uint8_t *&base) { +static bool CYImplements(id object, Class _class, SEL selector, bool devoid) { + if (Method method = class_getInstanceMethod(_class, selector)) { + if (!devoid) + return true; + char type[16]; + method_getReturnType(method, type, sizeof(type)); + if (type[0] != 'v') + return true; + } + + // XXX: possibly use a more "awesome" check? + return false; +} + +static const char *CYPoolTypeEncoding(apr_pool_t *pool, Class _class, SEL sel, Method method) { + if (method != NULL) + return method_getTypeEncoding(method); + else if (NSString *type = [[Bridge_ objectAtIndex:1] objectForKey:CYCastNSString(pool, sel_getName(sel))]) + return CYPoolCString(pool, type); + else + return NULL; +} + +static void FunctionClosure_(ffi_cif *cif, void *result, void **arguments, void *arg) { + Closure_privateData *internal(reinterpret_cast(arg)); + + JSContextRef context(internal->context_); + + size_t count(internal->cif_.nargs); + JSValueRef values[count]; + + for (size_t index(0); index != count; ++index) + values[index] = CYFromFFI(context, internal->signature_.elements[1 + index].type, internal->cif_.arg_types[index], arguments[index]); + + JSValueRef value(CYCallAsFunction(context, internal->function_, NULL, count, values)); + CYPoolFFI(NULL, context, internal->signature_.elements[0].type, internal->cif_.rtype, result, value); +} + +static void MessageClosure_(ffi_cif *cif, void *result, void **arguments, void *arg) { + Closure_privateData *internal(reinterpret_cast(arg)); + + JSContextRef context(internal->context_); + + size_t count(internal->cif_.nargs); + JSValueRef values[count]; + + for (size_t index(0); index != count; ++index) + values[index] = CYFromFFI(context, internal->signature_.elements[1 + index].type, internal->cif_.arg_types[index], arguments[index]); + + JSObjectRef _this(CYCastJSObject(context, values[0])); + + JSValueRef value(CYCallAsFunction(context, internal->function_, _this, count - 2, values + 2)); + CYPoolFFI(NULL, context, internal->signature_.elements[0].type, internal->cif_.rtype, result, value); +} + +static Closure_privateData *CYMakeFunctor_(JSContextRef context, JSObjectRef function, const char *type, void (*callback)(ffi_cif *, void *, void **, void *)) { + // XXX: in case of exceptions this will leak + // XXX: in point of fact, this may /need/ to leak :( + Closure_privateData *internal(new Closure_privateData(CYGetJSContext(), function, type)); + + ffi_closure *closure((ffi_closure *) _syscall(mmap( + NULL, sizeof(ffi_closure), + PROT_READ | PROT_WRITE, MAP_ANON | MAP_PRIVATE, + -1, 0 + ))); + + ffi_status status(ffi_prep_closure(closure, &internal->cif_, callback, internal)); + _assert(status == FFI_OK); + + _syscall(mprotect(closure, sizeof(*closure), PROT_READ | PROT_EXEC)); + + internal->value_ = closure; + + return internal; +} + +static JSObjectRef CYMakeFunctor(JSContextRef context, JSObjectRef function, const char *type) { + Closure_privateData *internal(CYMakeFunctor_(context, function, type, &FunctionClosure_)); + return JSObjectMake(context, Functor_, internal); +} + +static JSObjectRef CYMakeFunctor(JSContextRef context, JSValueRef value, const char *type) { + JSValueRef exception(NULL); + bool function(JSValueIsInstanceOfConstructor(context, value, Function_, &exception)); + CYThrow(context, exception); + + if (function) { + JSObjectRef function(CYCastJSObject(context, value)); + return CYMakeFunctor(context, function, type); + } else { + void (*function)()(CYCastPointer(context, value)); + return CYMakeFunctor(context, function, type); + } +} + +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); +} + +static IMP CYMakeMessage(JSContextRef context, JSValueRef value, const char *type) { + JSObjectRef function(CYCastJSObject(context, value)); + Closure_privateData *internal(CYMakeFunctor_(context, function, type, &MessageClosure_)); + return reinterpret_cast(internal->GetValue()); +} + +static bool Messages_hasProperty(JSContextRef context, JSObjectRef object, JSStringRef property) { + Messages *internal(reinterpret_cast(JSObjectGetPrivate(object))); + Class _class(internal->GetValue()); + + CYPool pool; + const char *name(CYPoolCString(pool, property)); + + if (SEL sel = sel_getUid(name)) + if (class_getInstanceMethod(_class, sel) != NULL) + return true; + + return false; +} + +static JSValueRef Messages_getProperty(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { + Messages *internal(reinterpret_cast(JSObjectGetPrivate(object))); + Class _class(internal->GetValue()); + + CYPool pool; + const char *name(CYPoolCString(pool, property)); + + if (SEL sel = sel_getUid(name)) + if (Method method = class_getInstanceMethod(_class, sel)) + return CYMakeMessage(context, sel, method_getImplementation(method), method_getTypeEncoding(method)); + + return NULL; +} + +static bool Messages_setProperty(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef value, JSValueRef *exception) { + Messages *internal(reinterpret_cast(JSObjectGetPrivate(object))); + Class _class(internal->GetValue()); + + CYPool pool; + const char *name(CYPoolCString(pool, property)); + + SEL sel(sel_registerName(name)); + + Method method(class_getInstanceMethod(_class, sel)); + + const char *type; + IMP imp; + + if (JSValueIsObjectOfClass(context, value, Message_)) { + Message_privateData *message(reinterpret_cast(JSObjectGetPrivate((JSObjectRef) value))); + type = sig::Unparse(pool, &message->signature_); + imp = reinterpret_cast(message->GetValue()); + } else { + type = CYPoolTypeEncoding(pool, _class, sel, method); + imp = CYMakeMessage(context, value, type); + } + + if (method != NULL) + method_setImplementation(method, imp); + else + class_replaceMethod(_class, sel, imp, type); + + return true; +} + +#if !__OBJC2__ +static bool Messages_deleteProperty(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { + Messages *internal(reinterpret_cast(JSObjectGetPrivate(object))); + Class _class(internal->GetValue()); + + CYPool pool; + const char *name(CYPoolCString(pool, property)); + + if (SEL sel = sel_getUid(name)) + if (Method method = class_getInstanceMethod(_class, sel)) { + objc_method_list list = {NULL, 1, {method}}; + class_removeMethods(_class, &list); + return true; + } + + return false; +} +#endif + +static void Messages_getPropertyNames(JSContextRef context, JSObjectRef object, JSPropertyNameAccumulatorRef names) { + Messages *internal(reinterpret_cast(JSObjectGetPrivate(object))); + Class _class(internal->GetValue()); + + unsigned int size; + 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); +} + +static bool Instance_hasProperty(JSContextRef context, JSObjectRef object, JSStringRef property) { + Instance *internal(reinterpret_cast(JSObjectGetPrivate(object))); + id self(internal->GetValue()); + + if (JSStringIsEqualToUTF8CString(property, "$cyi")) + return true; + + CYPool pool; + NSString *name(CYCastNSString(pool, property)); + + if (CYInternal *internal = CYInternal::Get(self)) + if (internal->HasProperty(context, property)) + return true; + + Class _class(object_getClass(self)); + + CYPoolTry { + // XXX: this is an evil hack to deal with NSProxy; fix elsewhere + if (CYImplements(self, _class, @selector(cy$hasProperty:), false)) + if ([self cy$hasProperty:name]) + return true; + } CYPoolCatch(false) + + const char *string(CYPoolCString(pool, name)); + + if (class_getProperty(_class, string) != NULL) + return true; + + if (SEL sel = sel_getUid(string)) + if (CYImplements(self, _class, sel, true)) + return true; + + return false; +} + +static JSValueRef Instance_getProperty(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { + Instance *internal(reinterpret_cast(JSObjectGetPrivate(object))); + id self(internal->GetValue()); + + if (JSStringIsEqualToUTF8CString(property, "$cyi")) + return Internal::Make(context, self, object); + + CYTry { + CYPool pool; + NSString *name(CYCastNSString(pool, property)); + + if (CYInternal *internal = CYInternal::Get(self)) + if (JSValueRef value = internal->GetProperty(context, property)) + return value; + + CYPoolTry { + if (NSObject *data = [self cy$getProperty:name]) + return CYCastJSValue(context, data); + } CYPoolCatch(NULL) + + const char *string(CYPoolCString(pool, name)); + Class _class(object_getClass(self)); + + if (objc_property_t property = class_getProperty(_class, string)) { + PropertyAttributes attributes(property); + SEL sel(sel_registerName(attributes.Getter())); + return CYSendMessage(pool, context, self, sel, 0, NULL, false, exception); + } + + if (SEL sel = sel_getUid(string)) + if (CYImplements(self, _class, sel, true)) + return CYSendMessage(pool, context, self, sel, 0, NULL, false, exception); + + return NULL; + } CYCatch +} + +static bool Instance_setProperty(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef value, JSValueRef *exception) { + Instance *internal(reinterpret_cast(JSObjectGetPrivate(object))); + id self(internal->GetValue()); + + CYPool pool; + + CYTry { + NSString *name(CYCastNSString(pool, property)); + NSString *data(CYCastNSObject(pool, context, value)); + + CYPoolTry { + if ([self cy$setProperty:name to:data]) + return true; + } CYPoolCatch(NULL) + + const char *string(CYPoolCString(pool, name)); + Class _class(object_getClass(self)); + + if (objc_property_t property = class_getProperty(_class, string)) { + PropertyAttributes attributes(property); + if (const char *setter = attributes.Setter()) { + SEL sel(sel_registerName(setter)); + JSValueRef arguments[1] = {value}; + CYSendMessage(pool, context, self, sel, 1, arguments, false, exception); + return true; + } + } + + size_t length(strlen(string)); + + char set[length + 5]; + + set[0] = 's'; + set[1] = 'e'; + set[2] = 't'; + + if (string[0] != '\0') { + set[3] = toupper(string[0]); + memcpy(set + 4, string + 1, length - 1); + } + + set[length + 3] = ':'; + set[length + 4] = '\0'; + + if (SEL sel = sel_getUid(set)) + if (CYImplements(self, _class, sel, false)) { + JSValueRef arguments[1] = {value}; + CYSendMessage(pool, context, self, sel, 1, arguments, false, exception); + } + + if (CYInternal *internal = CYInternal::Set(self)) { + internal->SetProperty(context, property, value); + return true; + } + + return false; + } CYCatch +} + +static bool Instance_deleteProperty(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { + Instance *internal(reinterpret_cast(JSObjectGetPrivate(object))); + id self(internal->GetValue()); + + CYTry { + CYPoolTry { + NSString *name(CYCastNSString(NULL, property)); + return [self cy$deleteProperty:name]; + } CYPoolCatch(NULL) + } CYCatch +} + +static void Instance_getPropertyNames(JSContextRef context, JSObjectRef object, JSPropertyNameAccumulatorRef names) { + Instance *internal(reinterpret_cast(JSObjectGetPrivate(object))); + id self(internal->GetValue()); + + CYPool pool; + Class _class(object_getClass(self)); + + { + unsigned int size; + objc_property_t *data(class_copyPropertyList(_class, &size)); + for (size_t i(0); i != size; ++i) + JSPropertyNameAccumulatorAddName(names, CYJSString(property_getName(data[i]))); + free(data); + } +} + +static JSObjectRef Instance_callAsConstructor(JSContextRef context, JSObjectRef object, size_t count, const JSValueRef arguments[], JSValueRef *exception) { + CYTry { + Instance *internal(reinterpret_cast(JSObjectGetPrivate(object))); + JSObjectRef value(Instance::Make(context, [internal->GetValue() alloc], Instance::Uninitialized)); + return value; + } CYCatch +} + +static bool CYIsClass(id self) { + // XXX: this is a lame object_isClass + return class_getInstanceMethod(object_getClass(self), @selector(alloc)) != NULL; +} + +static bool Instance_hasInstance(JSContextRef context, JSObjectRef constructor, JSValueRef instance, JSValueRef *exception) { + Instance *internal(reinterpret_cast(JSObjectGetPrivate((JSObjectRef) constructor))); + Class _class(internal->GetValue()); + if (!CYIsClass(_class)) + return false; + + if (JSValueIsObjectOfClass(context, instance, Instance_)) { + Instance *linternal(reinterpret_cast(JSObjectGetPrivate((JSObjectRef) instance))); + // XXX: this isn't always safe + CYTry { + return [linternal->GetValue() isKindOfClass:_class]; + } CYCatch + } + + return false; +} + +static bool Internal_hasProperty(JSContextRef context, JSObjectRef object, JSStringRef property) { + Internal *internal(reinterpret_cast(JSObjectGetPrivate(object))); + CYPool pool; + + id self(internal->GetValue()); + const char *name(CYPoolCString(pool, property)); + + if (object_getInstanceVariable(self, name, NULL) != NULL) + return true; + + return false; +} + +static JSValueRef Internal_getProperty(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { + Internal *internal(reinterpret_cast(JSObjectGetPrivate(object))); + CYPool pool; + + CYTry { + id self(internal->GetValue()); + const char *name(CYPoolCString(pool, property)); + + if (Ivar ivar = object_getInstanceVariable(self, name, NULL)) { + Type_privateData type(pool, ivar_getTypeEncoding(ivar)); + return CYFromFFI(context, type.type_, type.GetFFI(), reinterpret_cast(self) + ivar_getOffset(ivar)); + } + + return NULL; + } CYCatch +} + +static bool Internal_setProperty(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef value, JSValueRef *exception) { + Internal *internal(reinterpret_cast(JSObjectGetPrivate(object))); + CYPool pool; + + CYTry { + id self(internal->GetValue()); + const char *name(CYPoolCString(pool, property)); + + if (Ivar ivar = object_getInstanceVariable(self, name, NULL)) { + Type_privateData type(pool, ivar_getTypeEncoding(ivar)); + CYPoolFFI(pool, context, type.type_, type.GetFFI(), reinterpret_cast(self) + ivar_getOffset(ivar), value); + return true; + } + + return false; + } CYCatch +} + +static void Internal_getPropertyNames_(Class _class, JSPropertyNameAccumulatorRef names) { + if (Class super = class_getSuperclass(_class)) + Internal_getPropertyNames_(super, names); + + unsigned int size; + Ivar *data(class_copyIvarList(_class, &size)); + for (size_t i(0); i != size; ++i) + JSPropertyNameAccumulatorAddName(names, CYJSString(ivar_getName(data[i]))); + free(data); +} + +static void Internal_getPropertyNames(JSContextRef context, JSObjectRef object, JSPropertyNameAccumulatorRef names) { + Internal *internal(reinterpret_cast(JSObjectGetPrivate(object))); + CYPool pool; + + id self(internal->GetValue()); + Class _class(object_getClass(self)); + + Internal_getPropertyNames_(_class, names); +} + +static JSValueRef Internal_callAsFunction_$cya(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { + Internal *internal(reinterpret_cast(JSObjectGetPrivate(object))); + return internal->GetOwner(); +} + +static bool Index_(apr_pool_t *pool, Struct_privateData *internal, JSStringRef property, ssize_t &index, uint8_t *&base) { Type_privateData *typical(internal->type_); sig::Type *type(typical->type_); if (type == NULL) return false; - size_t length; - const char *name(CYPoolCString(pool, property, &length)); + const char *name(CYPoolCString(pool, property)); + size_t length(strlen(name)); double number(CYCastDouble(name, length)); size_t count(type->data.signature.count); @@ -1720,6 +2486,22 @@ bool Index_(apr_pool_t *pool, Struct_privateData *internal, JSStringRef property return true; } +static JSValueRef Pointer_getIndex(JSContextRef context, JSObjectRef object, size_t index, JSValueRef *exception) { + Pointer *internal(reinterpret_cast(JSObjectGetPrivate(object))); + Type_privateData *typical(internal->type_); + + ffi_type *ffi(typical->GetFFI()); + + uint8_t *base(reinterpret_cast(internal->value_)); + base += ffi->size * index; + + JSObjectRef owner(internal->GetOwner() ?: object); + + CYTry { + return CYFromFFI(context, typical->type_, ffi, base, false, owner); + } CYCatch +} + static JSValueRef Pointer_getProperty(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { CYPool pool; Pointer *internal(reinterpret_cast(JSObjectGetPrivate(object))); @@ -1728,19 +2510,29 @@ static JSValueRef Pointer_getProperty(JSContextRef context, JSObjectRef object, if (typical->type_ == NULL) return NULL; - ssize_t index; - if (!CYGetIndex(pool, property, index)) + ssize_t offset; + if (!CYGetOffset(pool, property, offset)) return NULL; + return Pointer_getIndex(context, object, offset, exception); +} + +static JSValueRef Pointer_getProperty_$cyi(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { + return Pointer_getIndex(context, object, 0, exception); +} + +static bool Pointer_setIndex(JSContextRef context, JSObjectRef object, size_t index, JSValueRef value, JSValueRef *exception) { + Pointer *internal(reinterpret_cast(JSObjectGetPrivate(object))); + Type_privateData *typical(internal->type_); + ffi_type *ffi(typical->GetFFI()); uint8_t *base(reinterpret_cast(internal->value_)); base += ffi->size * index; - JSObjectRef owner(internal->owner_ ?: object); - CYTry { - return CYFromFFI(context, typical->type_, ffi, base, false, owner); + CYPoolFFI(NULL, context, typical->type_, ffi, base, value); + return true; } CYCatch } @@ -1752,19 +2544,21 @@ static bool Pointer_setProperty(JSContextRef context, JSObjectRef object, JSStri if (typical->type_ == NULL) return NULL; - ssize_t index; - if (!CYGetIndex(pool, property, index)) + ssize_t offset; + if (!CYGetOffset(pool, property, offset)) return NULL; - ffi_type *ffi(typical->GetFFI()); + return Pointer_setIndex(context, object, offset, value, exception); +} - uint8_t *base(reinterpret_cast(internal->value_)); - base += ffi->size * index; +static bool Pointer_setProperty_$cyi(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef value, JSValueRef *exception) { + return Pointer_setIndex(context, object, 0, value, exception); +} - CYTry { - CYPoolFFI(NULL, context, typical->type_, ffi, base, value); - return true; - } CYCatch +static JSValueRef Struct_callAsFunction_$cya(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { + Struct_privateData *internal(reinterpret_cast(JSObjectGetPrivate(_this))); + Type_privateData *typical(internal->type_); + return CYMakePointer(context, internal->value_, typical->type_, typical->ffi_, _this); } static JSValueRef Struct_getProperty(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { @@ -1778,7 +2572,7 @@ static JSValueRef Struct_getProperty(JSContextRef context, JSObjectRef object, J if (!Index_(pool, internal, property, index, base)) return NULL; - JSObjectRef owner(internal->owner_ ?: object); + JSObjectRef owner(internal->GetOwner() ?: object); CYTry { return CYFromFFI(context, typical->type_->data.signature.elements[index].type, typical->GetFFI()->elements[index], base, false, owner); @@ -1852,46 +2646,132 @@ JSValueRef CYCallFunction(apr_pool_t *pool, JSContextRef context, size_t setups, } CYCatch } -void Closure_(ffi_cif *cif, void *result, void **arguments, void *arg) { - ffoData *data(reinterpret_cast(arg)); +static JSValueRef ObjectiveC_Classes_getProperty(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { + CYTry { + CYPool pool; + NSString *name(CYCastNSString(pool, property)); + if (Class _class = NSClassFromString(name)) + return CYMakeInstance(context, _class, true); + return NULL; + } CYCatch +} + +static void ObjectiveC_Classes_getPropertyNames(JSContextRef context, JSObjectRef object, JSPropertyNameAccumulatorRef names) { + size_t size(objc_getClassList(NULL, 0)); + Class *data(reinterpret_cast(malloc(sizeof(Class) * size))); - JSContextRef context(data->context_); + get: + size_t writ(objc_getClassList(data, size)); + if (size < writ) { + size = writ; + if (Class *copy = reinterpret_cast(realloc(data, sizeof(Class) * writ))) { + data = copy; + goto get; + } else goto done; + } - size_t count(data->cif_.nargs); - JSValueRef values[count]; + for (size_t i(0); i != writ; ++i) + JSPropertyNameAccumulatorAddName(names, CYJSString(class_getName(data[i]))); - for (size_t index(0); index != count; ++index) - values[index] = CYFromFFI(context, data->signature_.elements[1 + index].type, data->cif_.arg_types[index], arguments[index], false); + done: + free(data); +} - JSValueRef value(CYCallAsFunction(context, data->function_, NULL, count, values)); - CYPoolFFI(NULL, context, data->signature_.elements[0].type, data->cif_.rtype, result, value); +static JSValueRef ObjectiveC_Image_Classes_getProperty(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { + const char *internal(reinterpret_cast(JSObjectGetPrivate(object))); + + CYTry { + CYPool pool; + const char *name(CYPoolCString(pool, property)); + unsigned int size; + const char **data(objc_copyClassNamesForImage(internal, &size)); + 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; + } + value = NULL; + free: + free(data); + return value; + } CYCatch } -JSObjectRef CYMakeFunctor(JSContextRef context, JSObjectRef function, const char *type) { - // XXX: in case of exceptions this will leak - ffoData *data(new ffoData(type)); +static void ObjectiveC_Image_Classes_getPropertyNames(JSContextRef context, JSObjectRef object, JSPropertyNameAccumulatorRef names) { + const char *internal(reinterpret_cast(JSObjectGetPrivate(object))); + unsigned int size; + const char **data(objc_copyClassNamesForImage(internal, &size)); + for (size_t i(0); i != size; ++i) + JSPropertyNameAccumulatorAddName(names, CYJSString(data[i])); + free(data); +} - ffi_closure *closure; - _syscall(closure = (ffi_closure *) mmap( - NULL, sizeof(ffi_closure), - PROT_READ | PROT_WRITE, MAP_ANON | MAP_PRIVATE, - -1, 0 - )); +static JSValueRef ObjectiveC_Images_getProperty(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { + CYTry { + CYPool pool; + const char *name(CYPoolCString(pool, property)); + unsigned int size; + const char **data(objc_copyImageNames(&size)); + for (size_t i(0); i != size; ++i) + if (strcmp(name, data[i]) == 0) { + name = data[i]; + goto free; + } + name = NULL; + free: + free(data); + if (name == NULL) + return NULL; + JSObjectRef value(JSObjectMake(context, NULL, NULL)); + CYSetProperty(context, value, CYJSString("classes"), JSObjectMake(context, ObjectiveC_Image_Classes_, const_cast(name))); + return value; + } CYCatch +} - ffi_status status(ffi_prep_closure(closure, &data->cif_, &Closure_, data)); - _assert(status == FFI_OK); +static void ObjectiveC_Images_getPropertyNames(JSContextRef context, JSObjectRef object, JSPropertyNameAccumulatorRef names) { + unsigned int size; + const char **data(objc_copyImageNames(&size)); + for (size_t i(0); i != size; ++i) + JSPropertyNameAccumulatorAddName(names, CYJSString(data[i])); + free(data); +} - _syscall(mprotect(closure, sizeof(*closure), PROT_READ | PROT_EXEC)); +static JSValueRef ObjectiveC_Protocols_getProperty(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { + CYTry { + CYPool pool; + NSString *name(CYCastNSString(pool, property)); + if (Protocol *protocol = NSProtocolFromString(name)) + return CYMakeInstance(context, protocol, true); + return NULL; + } CYCatch +} - data->value_ = closure; +static void ObjectiveC_Protocols_getPropertyNames(JSContextRef context, JSObjectRef object, JSPropertyNameAccumulatorRef names) { + unsigned int size; + Protocol **data(objc_copyProtocolList(&size)); + for (size_t i(0); i != size; ++i) + JSPropertyNameAccumulatorAddName(names, CYJSString(protocol_getName(data[i]))); + free(data); +} - data->context_ = CYGetJSContext(); - data->function_ = function; +static JSObjectRef CYMakeType(JSContextRef context, const char *type) { + Type_privateData *internal(new Type_privateData(NULL, type)); + return JSObjectMake(context, Type_, internal); +} - return JSObjectMake(context, Functor_, data); +static JSObjectRef CYMakeType(JSContextRef context, sig::Type *type) { + Type_privateData *internal(new Type_privateData(type)); + return JSObjectMake(context, Type_, internal); } static JSValueRef Runtime_getProperty(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { + if (JSStringIsEqualToUTF8CString(property, "nil")) + return Instance::Make(context, nil); + CYTry { CYPool pool; NSString *name(CYCastNSString(pool, property)); @@ -1909,13 +2789,19 @@ static JSValueRef Runtime_getProperty(JSContextRef context, JSObjectRef object, sig::Parse(pool, &signature, CYPoolCString(pool, [entry objectAtIndex:1]), &Structor_); ffi_cif cif; sig::sig_ffi_cif(pool, &sig::ObjectiveC, &signature, &cif); - return CYFromFFI(context, signature.elements[0].type, cif.rtype, [name cy$symbol], false); + return CYFromFFI(context, signature.elements[0].type, cif.rtype, [name cy$symbol]); + } + if (NSMutableArray *entry = [[Bridge_ objectAtIndex:2] objectForKey:name]) + switch ([[entry objectAtIndex:0] intValue]) { + // XXX: implement case 0 + case 1: + return CYMakeType(context, CYPoolCString(pool, [entry objectAtIndex:1])); } return NULL; } CYCatch } -bool stret(ffi_type *ffi_type) { +static bool stret(ffi_type *ffi_type) { return ffi_type->type == FFI_TYPE_STRUCT && ( ffi_type->size > OBJC_MAX_STRUCT_BY_VALUE || struct_forward_array[ffi_type->size] != 0 @@ -1925,12 +2811,14 @@ bool stret(ffi_type *ffi_type) { extern "C" { int *_NSGetArgc(void); char ***_NSGetArgv(void); - int UIApplicationMain(int argc, char *argv[], NSString *principalClassName, NSString *delegateClassName); } static JSValueRef System_print(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry { - NSLog(@"%s", CYCastCString(context, arguments[0])); + if (count == 0) + NSLog(@""); + else + NSLog(@"%s", CYCastCString(context, arguments[0])); return CYJSUndefined(context); } CYCatch } @@ -1942,12 +2830,14 @@ JSValueRef CYSendMessage(apr_pool_t *pool, JSContextRef context, id self, SEL _c if (Method method = class_getInstanceMethod(_class, _cmd)) type = method_getTypeEncoding(method); else { - CYPoolTry { - NSMethodSignature *method([self methodSignatureForSelector:_cmd]); - if (method == nil) - @throw [NSException exceptionWithName:NSInvalidArgumentException reason:[NSString stringWithFormat:@"unrecognized selector %s sent to object %p", sel_getName(_cmd), self] userInfo:nil]; - type = CYPoolCString(pool, [method _typeString]); - } CYPoolCatch(NULL) + CYTry { + CYPoolTry { + NSMethodSignature *method([self methodSignatureForSelector:_cmd]); + if (method == nil) + @throw [NSException exceptionWithName:NSInvalidArgumentException reason:[NSString stringWithFormat:@"unrecognized selector %s sent to object %p", sel_getName(_cmd), self] userInfo:nil]; + type = CYPoolCString(pool, [method _typeString]); + } CYPoolCatch(NULL) + } CYCatch } void *setup[2]; @@ -1964,6 +2854,14 @@ JSValueRef CYSendMessage(apr_pool_t *pool, JSContextRef context, id self, SEL _c return CYCallFunction(pool, context, 2, setup, count, arguments, initialize, exception, &signature, &cif, function); } +static size_t Nonce_(0); + +static JSValueRef $cyq(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { + char name[16]; + sprintf(name, "%s%zu", CYCastCString(context, arguments[0]), Nonce_++); + return CYCastJSValue(context, name); +} + static JSValueRef $objc_msgSend(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYPool pool; @@ -1977,11 +2875,11 @@ static JSValueRef $objc_msgSend(JSContextRef context, JSObjectRef object, JSObje @throw [NSException exceptionWithName:NSInvalidArgumentException reason:@"too few arguments to objc_msgSend" userInfo:nil]; if (JSValueIsObjectOfClass(context, arguments[0], Instance_)) { - Instance *data(reinterpret_cast(JSObjectGetPrivate((JSObjectRef) arguments[0]))); - self = data->GetValue(); - uninitialized = data->IsUninitialized(); + Instance *internal(reinterpret_cast(JSObjectGetPrivate((JSObjectRef) arguments[0]))); + self = internal->GetValue(); + uninitialized = internal->IsUninitialized(); if (uninitialized) - data->value_ = nil; + internal->value_ = nil; } else { self = CYCastNSObject(pool, context, arguments[0]); uninitialized = false; @@ -1996,24 +2894,22 @@ static JSValueRef $objc_msgSend(JSContextRef context, JSObjectRef object, JSObje return CYSendMessage(pool, context, self, _cmd, count - 2, arguments + 2, uninitialized, exception); } -void dealloc_(id self, SEL sel) { +/* Hook: objc_registerClassPair {{{ */ +// XXX: replace this with associated objects + +MSHook(void, CYDealloc, id self, SEL sel) { CYInternal *internal; object_getInstanceVariable(self, "cy$internal_", reinterpret_cast(&internal)); if (internal != NULL) delete internal; - if (Method dealloc = class_getInstanceMethod(object_getClass(self), @selector(cy$dealloc))) - reinterpret_cast(method_getImplementation(dealloc))(self, sel); + _CYDealloc(self, sel); } MSHook(void, objc_registerClassPair, Class _class) { Class super(class_getSuperclass(_class)); if (super == NULL || class_getInstanceVariable(super, "cy$internal_") == NULL) { class_addIvar(_class, "cy$internal_", sizeof(CYInternal *), log2(sizeof(CYInternal *)), "^{CYInternal}"); - if (!class_addMethod(_class, @selector(dealloc), reinterpret_cast(&dealloc_), "v8@0:4")) { - Method dealloc(class_getInstanceMethod(_class, @selector(dealloc))); - class_addMethod(_class, @selector(cy$dealloc), method_getImplementation(dealloc), method_getTypeEncoding(dealloc)); - method_setImplementation(dealloc, reinterpret_cast(&dealloc_)); - } + MSHookMessage(_class, @selector(dealloc), MSHake(CYDealloc)); } _objc_registerClassPair(_class); @@ -2021,12 +2917,20 @@ MSHook(void, objc_registerClassPair, Class _class) { static JSValueRef objc_registerClassPair_(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry { + if (count != 1) + @throw [NSException exceptionWithName:NSInvalidArgumentException reason:@"incorrect number of arguments to objc_registerClassPair" userInfo:nil]; CYPool pool; - Class _class(CYCastNSObject(pool, context, object)); + Class _class(CYCastNSObject(pool, context, arguments[0])); $objc_registerClassPair(_class); return CYJSUndefined(context); } CYCatch } +/* }}} */ + +static JSValueRef Cycript_gc_callAsFunction(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { + JSGarbageCollect(context); + return CYJSUndefined(context); +} static JSValueRef Selector_callAsFunction(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { JSValueRef setup[count + 2]; @@ -2036,13 +2940,27 @@ static JSValueRef Selector_callAsFunction(JSContextRef context, JSObjectRef obje return $objc_msgSend(context, NULL, NULL, count + 2, setup, exception); } +static JSValueRef Message_callAsFunction(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { + CYPool pool; + Message_privateData *internal(reinterpret_cast(JSObjectGetPrivate(object))); + + // XXX: handle Instance::Uninitialized? + id self(CYCastNSObject(pool, context, _this)); + + void *setup[2]; + setup[0] = &self; + setup[1] = &internal->sel_; + + return CYCallFunction(pool, context, 2, setup, count, arguments, false, exception, &internal->signature_, &internal->cif_, internal->GetValue()); +} + static JSValueRef Functor_callAsFunction(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYPool pool; - Functor_privateData *data(reinterpret_cast(JSObjectGetPrivate(object))); - return CYCallFunction(pool, context, 0, NULL, count, arguments, false, exception, &data->signature_, &data->cif_, reinterpret_cast(data->value_)); + Functor_privateData *internal(reinterpret_cast(JSObjectGetPrivate(object))); + return CYCallFunction(pool, context, 0, NULL, count, arguments, false, exception, &internal->signature_, &internal->cif_, internal->GetValue()); } -JSObjectRef Selector_new(JSContextRef context, JSObjectRef object, size_t count, const JSValueRef arguments[], JSValueRef *exception) { +static JSObjectRef Selector_new(JSContextRef context, JSObjectRef object, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry { if (count != 1) @throw [NSException exceptionWithName:NSInvalidArgumentException reason:@"incorrect number of arguments to Selector constructor" userInfo:nil]; @@ -2051,7 +2969,7 @@ JSObjectRef Selector_new(JSContextRef context, JSObjectRef object, size_t count, } CYCatch } -JSObjectRef Pointer_new(JSContextRef context, JSObjectRef object, size_t count, const JSValueRef arguments[], JSValueRef *exception) { +static JSObjectRef Pointer_new(JSContextRef context, JSObjectRef object, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry { if (count != 2) @throw [NSException exceptionWithName:NSInvalidArgumentException reason:@"incorrect number of arguments to Functor constructor" userInfo:nil]; @@ -2064,40 +2982,127 @@ JSObjectRef Pointer_new(JSContextRef context, JSObjectRef object, size_t count, sig::Signature signature; sig::Parse(pool, &signature, type, &Structor_); - return CYMakePointer(context, value, signature.elements[0].type, NULL); + return CYMakePointer(context, value, signature.elements[0].type, NULL, NULL); + } CYCatch +} + +static JSObjectRef Type_new(JSContextRef context, JSObjectRef object, size_t count, const JSValueRef arguments[], JSValueRef *exception) { + CYTry { + if (count != 1) + @throw [NSException exceptionWithName:NSInvalidArgumentException reason:@"incorrect number of arguments to Type constructor" userInfo:nil]; + const char *type(CYCastCString(context, arguments[0])); + return CYMakeType(context, type); + } CYCatch +} + +static JSValueRef Type_getProperty(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { + Type_privateData *internal(reinterpret_cast(JSObjectGetPrivate(object))); + + CYTry { + sig::Type type; + + if (JSStringIsEqualToUTF8CString(property, "$cyi")) { + type.primitive = sig::pointer_P; + type.data.data.size = 0; + } else { + size_t index(CYGetIndex(NULL, property)); + if (index == _not(size_t)) + return NULL; + type.primitive = sig::array_P; + type.data.data.size = index; + } + + type.name = NULL; + type.flags = 0; + + type.data.data.type = internal->type_; + + return CYMakeType(context, &type); + } CYCatch +} + +static JSValueRef Type_callAsFunction(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { + Type_privateData *internal(reinterpret_cast(JSObjectGetPrivate(object))); + + CYTry { + if (count != 1) + @throw [NSException exceptionWithName:NSInvalidArgumentException reason:@"incorrect number of arguments to type cast function" userInfo:nil]; + sig::Type *type(internal->type_); + ffi_type *ffi(internal->GetFFI()); + // XXX: alignment? + uint8_t value[ffi->size]; + CYPool pool; + CYPoolFFI(pool, context, type, ffi, value, arguments[0]); + return CYFromFFI(context, type, ffi, value); + } CYCatch +} + +static JSObjectRef Type_callAsConstructor(JSContextRef context, JSObjectRef object, size_t count, const JSValueRef arguments[], JSValueRef *exception) { + CYTry { + if (count != 0) + @throw [NSException exceptionWithName:NSInvalidArgumentException reason:@"incorrect number of arguments to type cast function" userInfo:nil]; + Type_privateData *internal(reinterpret_cast(JSObjectGetPrivate(object))); + + sig::Type *type(internal->type_); + size_t size; + + if (type->primitive != sig::array_P) + size = 0; + else { + size = type->data.data.size; + type = type->data.data.type; + } + + void *value(malloc(internal->GetFFI()->size)); + return CYMakePointer(context, value, type, NULL, NULL); + } CYCatch +} + +static JSObjectRef Instance_new(JSContextRef context, JSObjectRef object, size_t count, const JSValueRef arguments[], JSValueRef *exception) { + CYTry { + if (count > 1) + @throw [NSException exceptionWithName:NSInvalidArgumentException reason:@"incorrect number of arguments to Instance constructor" userInfo:nil]; + id self(count == 0 ? nil : CYCastPointer(context, arguments[0])); + return Instance::Make(context, self); } CYCatch } -JSObjectRef Functor_new(JSContextRef context, JSObjectRef object, size_t count, const JSValueRef arguments[], JSValueRef *exception) { +static JSObjectRef Functor_new(JSContextRef context, JSObjectRef object, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry { if (count != 2) @throw [NSException exceptionWithName:NSInvalidArgumentException reason:@"incorrect number of arguments to Functor constructor" userInfo:nil]; const char *type(CYCastCString(context, arguments[1])); - JSValueRef exception(NULL); - if (JSValueIsInstanceOfConstructor(context, arguments[0], Function_, &exception)) { - JSObjectRef function(CYCastJSObject(context, arguments[0])); - return CYMakeFunctor(context, function, type); - } else if (exception != NULL) { - return NULL; - } else { - void (*function)()(CYCastPointer(context, arguments[0])); - return CYMakeFunctor(context, function, type); - } + return CYMakeFunctor(context, arguments[0], type); } CYCatch } -JSValueRef CYValue_getProperty_value(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { +static JSValueRef CYValue_getProperty_value(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { CYValue *internal(reinterpret_cast(JSObjectGetPrivate(object))); return CYCastJSValue(context, reinterpret_cast(internal->value_)); } -JSValueRef Selector_getProperty_prototype(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { - return Function_; +static JSValueRef CYValue_callAsFunction_$cya(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { + CYValue *internal(reinterpret_cast(JSObjectGetPrivate(_this))); + Type_privateData *typical(internal->GetType()); + + sig::Type *type; + ffi_type *ffi; + + if (typical == NULL) { + type = NULL; + ffi = NULL; + } else { + type = typical->type_; + ffi = typical->ffi_; + } + + return CYMakePointer(context, &internal->value_, type, ffi, object); } static JSValueRef CYValue_callAsFunction_valueOf(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { + CYValue *internal(reinterpret_cast(JSObjectGetPrivate(_this))); + CYTry { - CYValue *internal(reinterpret_cast(JSObjectGetPrivate(_this))); return CYCastJSValue(context, reinterpret_cast(internal->value_)); } CYCatch } @@ -2107,46 +3112,84 @@ static JSValueRef CYValue_callAsFunction_toJSON(JSContextRef context, JSObjectRe } static JSValueRef CYValue_callAsFunction_toCYON(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { + CYValue *internal(reinterpret_cast(JSObjectGetPrivate(_this))); + char string[32]; + sprintf(string, "%p", internal->value_); + CYTry { - CYValue *internal(reinterpret_cast(JSObjectGetPrivate(_this))); - char string[32]; - sprintf(string, "%p", internal->value_); return CYCastJSValue(context, string); } CYCatch } +static JSValueRef Instance_getProperty_constructor(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { + Instance *internal(reinterpret_cast(JSObjectGetPrivate(object))); + return Instance::Make(context, object_getClass(internal->GetValue())); +} + +static JSValueRef Instance_getProperty_protocol(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { + Instance *internal(reinterpret_cast(JSObjectGetPrivate(object))); + id self(internal->GetValue()); + if (!CYIsClass(self)) + return CYJSUndefined(context); + CYTry { + return CYGetClassPrototype(context, self); + } CYCatch +} + +static JSValueRef Instance_getProperty_messages(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { + Instance *internal(reinterpret_cast(JSObjectGetPrivate(object))); + id self(internal->GetValue()); + if (class_getInstanceMethod(object_getClass(self), @selector(alloc)) == NULL) + return CYJSUndefined(context); + return Messages::Make(context, self); +} + static JSValueRef Instance_callAsFunction_toCYON(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { + if (!JSValueIsObjectOfClass(context, _this, Instance_)) + return NULL; + + Instance *internal(reinterpret_cast(JSObjectGetPrivate(_this))); + CYTry { - Instance *internal(reinterpret_cast(JSObjectGetPrivate(_this))); CYPoolTry { - return CYCastJSValue(context, CYJSString([internal->GetValue() cy$toCYON])); + return CYCastJSValue(context, CYJSString(CYPoolNSCYON(NULL, internal->GetValue()))); } CYPoolCatch(NULL) } CYCatch } static JSValueRef Instance_callAsFunction_toJSON(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { + if (!JSValueIsObjectOfClass(context, _this, Instance_)) + return NULL; + + Instance *internal(reinterpret_cast(JSObjectGetPrivate(_this))); + CYTry { - Instance *internal(reinterpret_cast(JSObjectGetPrivate(_this))); CYPoolTry { NSString *key(count == 0 ? nil : CYCastNSString(NULL, CYJSString(context, arguments[0]))); + // XXX: check for support of cy$toJSON? return CYCastJSValue(context, CYJSString([internal->GetValue() cy$toJSON:key])); } CYPoolCatch(NULL) } CYCatch } static JSValueRef Instance_callAsFunction_toString(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { + if (!JSValueIsObjectOfClass(context, _this, Instance_)) + return NULL; + + Instance *internal(reinterpret_cast(JSObjectGetPrivate(_this))); + CYTry { - Instance *data(reinterpret_cast(JSObjectGetPrivate(_this))); CYPoolTry { - return CYCastJSValue(context, CYJSString([data->GetValue() description])); + return CYCastJSValue(context, CYJSString([internal->GetValue() description])); } CYPoolCatch(NULL) } CYCatch } static JSValueRef Selector_callAsFunction_toString(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { + Selector_privateData *internal(reinterpret_cast(JSObjectGetPrivate(_this))); + CYTry { - Selector_privateData *data(reinterpret_cast(JSObjectGetPrivate(_this))); - return CYCastJSValue(context, sel_getName(data->GetValue())); + return CYCastJSValue(context, sel_getName(internal->GetValue())); } CYCatch } @@ -2155,9 +3198,10 @@ 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) { + Selector_privateData *internal(reinterpret_cast(JSObjectGetPrivate(_this))); + const char *name(sel_getName(internal->GetValue())); + CYTry { - Selector_privateData *data(reinterpret_cast(JSObjectGetPrivate(_this))); - const char *name(sel_getName(data->GetValue())); CYPoolTry { return CYCastJSValue(context, CYJSString([NSString stringWithFormat:@"@selector(%s)", name])); } CYPoolCatch(NULL) @@ -2166,27 +3210,54 @@ static JSValueRef Selector_callAsFunction_toCYON(JSContextRef context, JSObjectR static JSValueRef Selector_callAsFunction_type(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry { - if (count != 2) + if (count != 1) @throw [NSException exceptionWithName:NSInvalidArgumentException reason:@"incorrect number of arguments to Selector.type" userInfo:nil]; CYPool pool; - Selector_privateData *data(reinterpret_cast(JSObjectGetPrivate(_this))); + Selector_privateData *internal(reinterpret_cast(JSObjectGetPrivate(_this))); Class _class(CYCastNSObject(pool, context, arguments[0])); - bool instance(CYCastBool(context, arguments[1])); - SEL sel(data->GetValue()); - if (Method method = (*(instance ? &class_getInstanceMethod : class_getClassMethod))(_class, sel)) - return CYCastJSValue(context, method_getTypeEncoding(method)); - else if (NSString *type = [[Bridge_ objectAtIndex:1] objectForKey:CYCastNSString(pool, sel_getName(sel))]) + SEL sel(internal->GetValue()); + Method method(class_getInstanceMethod(_class, sel)); + const char *type(CYPoolTypeEncoding(pool, _class, sel, method)); + return type == NULL ? CYJSNull(context) : CYCastJSValue(context, CYJSString(type)); + } CYCatch +} + +static JSValueRef Type_callAsFunction_toString(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { + CYTry { + Type_privateData *internal(reinterpret_cast(JSObjectGetPrivate(_this))); + CYPool pool; + const char *type(sig::Unparse(pool, internal->type_)); + CYPoolTry { return CYCastJSValue(context, CYJSString(type)); - else - return CYJSNull(context); + } CYPoolCatch(NULL) + } CYCatch +} + +static JSValueRef Type_callAsFunction_toCYON(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { + CYTry { + Type_privateData *internal(reinterpret_cast(JSObjectGetPrivate(_this))); + CYPool pool; + const char *type(sig::Unparse(pool, internal->type_)); + CYPoolTry { + return CYCastJSValue(context, CYJSString([NSString stringWithFormat:@"new Type(%@)", [[NSString stringWithUTF8String:type] cy$toCYON]])); + } CYPoolCatch(NULL) } CYCatch } +static JSValueRef Type_callAsFunction_toJSON(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { + return Type_callAsFunction_toString(context, object, _this, count, arguments, exception); +} + static JSStaticValue CYValue_staticValues[2] = { {"value", &CYValue_getProperty_value, NULL, kJSPropertyAttributeReadOnly | kJSPropertyAttributeDontDelete}, {NULL, NULL, NULL, 0} }; +static JSStaticValue Pointer_staticValues[2] = { + {"$cyi", &Pointer_getProperty_$cyi, &Pointer_setProperty_$cyi, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, + {NULL, NULL, NULL, 0} +}; + static JSStaticFunction Pointer_staticFunctions[4] = { {"toCYON", &CYValue_callAsFunction_toCYON, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, {"toJSON", &CYValue_callAsFunction_toJSON, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, @@ -2194,6 +3265,11 @@ static JSStaticFunction Pointer_staticFunctions[4] = { {NULL, NULL, 0} }; +static JSStaticFunction Struct_staticFunctions[2] = { + {"$cya", &Struct_callAsFunction_$cya, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, + {NULL, NULL, 0} +}; + static JSStaticFunction Functor_staticFunctions[4] = { {"toCYON", &CYValue_callAsFunction_toCYON, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, {"toJSON", &CYValue_callAsFunction_toJSON, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, @@ -2201,18 +3277,27 @@ static JSStaticFunction Functor_staticFunctions[4] = { {NULL, NULL, 0} }; -/*static JSStaticValue Selector_staticValues[2] = { - {"prototype", &Selector_getProperty_prototype, NULL, kJSPropertyAttributeReadOnly | kJSPropertyAttributeDontDelete}, +static JSStaticValue Instance_staticValues[5] = { + {"constructor", &Instance_getProperty_constructor, NULL, kJSPropertyAttributeReadOnly | kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, + {"messages", &Instance_getProperty_messages, NULL, kJSPropertyAttributeReadOnly | kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, + {"prototype", &Instance_getProperty_protocol, NULL, kJSPropertyAttributeReadOnly | kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, + {"value", &CYValue_getProperty_value, NULL, kJSPropertyAttributeReadOnly | kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, {NULL, NULL, NULL, 0} -};*/ +}; -static JSStaticFunction Instance_staticFunctions[4] = { +static JSStaticFunction Instance_staticFunctions[5] = { + {"$cya", &CYValue_callAsFunction_$cya, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, {"toCYON", &Instance_callAsFunction_toCYON, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, {"toJSON", &Instance_callAsFunction_toJSON, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, {"toString", &Instance_callAsFunction_toString, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, {NULL, NULL, 0} }; +static JSStaticFunction Internal_staticFunctions[2] = { + {"$cya", &Internal_callAsFunction_$cya, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, + {NULL, NULL, 0} +}; + static JSStaticFunction Selector_staticFunctions[5] = { {"toCYON", &Selector_callAsFunction_toCYON, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, {"toJSON", &Selector_callAsFunction_toJSON, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, @@ -2221,26 +3306,12 @@ static JSStaticFunction Selector_staticFunctions[5] = { {NULL, NULL, 0} }; -CYDriver::CYDriver(const std::string &filename) : - state_(CYClear), - data_(NULL), - size_(0), - filename_(filename), - source_(NULL) -{ - ScannerInit(); -} - -CYDriver::~CYDriver() { - ScannerDestroy(); -} - -void cy::parser::error(const cy::parser::location_type &location, const std::string &message) { - CYDriver::Error error; - error.location_ = location; - error.message_ = message; - driver.errors_.push_back(error); -} +static JSStaticFunction Type_staticFunctions[4] = { + {"toCYON", &Type_callAsFunction_toCYON, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, + {"toJSON", &Type_callAsFunction_toJSON, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, + {"toString", &Type_callAsFunction_toString, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, + {NULL, NULL, 0} +}; void CYSetArgs(int argc, const char *argv[]) { JSContextRef context(CYGetJSContext()); @@ -2257,97 +3328,372 @@ JSObjectRef CYGetGlobalObject(JSContextRef context) { return JSContextGetGlobalObject(context); } +const char *CYExecute(apr_pool_t *pool, const char *code) { _pooled + JSContextRef context(CYGetJSContext()); + JSValueRef exception(NULL), result; + + try { + result = JSEvaluateScript(context, CYJSString(code), NULL, NULL, 0, &exception); + } catch (const char *error) { + return error; + } + + if (exception != NULL) { error: + result = exception; + exception = NULL; + } + + if (JSValueIsUndefined(context, result)) + return NULL; + + const char *json; + + try { + json = CYPoolCCYON(pool, context, result, &exception); + } catch (const char *error) { + return error; + } + + if (exception != NULL) + goto error; + + CYSetProperty(context, CYGetGlobalObject(context), Result_, result); + return json; +} + +static apr_pool_t *Pool_; + +struct CYExecute_ { + apr_pool_t *pool_; + const char * volatile data_; +}; + +// XXX: this is "tre lame" +@interface CYClient_ : NSObject { +} + +- (void) execute:(NSValue *)value; + +@end + +@implementation CYClient_ + +- (void) execute:(NSValue *)value { + CYExecute_ *execute(reinterpret_cast([value pointerValue])); + const char *data(execute->data_); + execute->data_ = NULL; + execute->data_ = CYExecute(execute->pool_, data); +} + +@end + +struct CYClient : + CYData +{ + int socket_; + apr_thread_t *thread_; + + CYClient(int socket) : + socket_(socket) + { + } + + ~CYClient() { + _syscall(close(socket_)); + } + + void Handle() { _pooled + CYClient_ *client = [[[CYClient_ alloc] init] autorelease]; + + for (;;) { + size_t size; + if (!CYRecvAll(socket_, &size, sizeof(size))) + return; + + CYPool pool; + char *data(new(pool) char[size + 1]); + if (!CYRecvAll(socket_, data, size)) + return; + data[size] = '\0'; + + CYDriver driver(""); + cy::parser parser(driver); + + driver.data_ = data; + driver.size_ = size; + + const char *json; + if (parser.parse() != 0 || !driver.errors_.empty()) { + json = NULL; + size = _not(size_t); + } else { + CYContext context(driver.pool_); + driver.program_->Replace(context); + std::ostringstream str; + CYOutput out(str); + out << *driver.program_; + std::string code(str.str()); + CYExecute_ execute = {pool, code.c_str()}; + [client performSelectorOnMainThread:@selector(execute:) withObject:[NSValue valueWithPointer:&execute] waitUntilDone:YES]; + json = execute.data_; + size = json == NULL ? _not(size_t) : strlen(json); + } + + if (!CYSendAll(socket_, &size, sizeof(size))) + return; + if (json != NULL) + if (!CYSendAll(socket_, json, size)) + return; + } + } +}; + +static void * APR_THREAD_FUNC OnClient(apr_thread_t *thread, void *data) { + CYClient *client(reinterpret_cast(data)); + client->Handle(); + delete client; + return NULL; +} + +extern "C" void CYHandleClient(apr_pool_t *pool, int socket) { + CYClient *client(new(pool) CYClient(socket)); + apr_threadattr_t *attr; + _aprcall(apr_threadattr_create(&attr, client->pool_)); + _aprcall(apr_thread_create(&client->thread_, attr, &OnClient, client, client->pool_)); +} + MSInitialize { _pooled - apr_initialize(); + _aprcall(apr_initialize()); + _aprcall(apr_pool_create(&Pool_, NULL)); + + Type_privateData::Object = new(Pool_) Type_privateData(Pool_, "@"); + Type_privateData::Selector = new(Pool_) Type_privateData(Pool_, ":"); Bridge_ = [[NSMutableArray arrayWithContentsOfFile:@"/usr/lib/libcycript.plist"] retain]; + NSArray_ = objc_getClass("NSArray"); NSCFBoolean_ = objc_getClass("NSCFBoolean"); + NSCFType_ = objc_getClass("NSCFType"); + NSDictionary_ = objc_getClass("NSDictonary"); + NSMessageBuilder_ = objc_getClass("NSMessageBuilder"); + NSZombie_ = objc_getClass("_NSZombie_"); + Object_ = objc_getClass("Object"); +} + +JSGlobalContextRef CYGetJSContext() { + if (Context_ == NULL) { + JSClassDefinition definition; + + definition = kJSClassDefinitionEmpty; + definition.className = "Functor"; + definition.staticFunctions = Functor_staticFunctions; + definition.callAsFunction = &Functor_callAsFunction; + definition.finalize = &Finalize; + Functor_ = JSClassCreate(&definition); + + definition = kJSClassDefinitionEmpty; + definition.className = "Instance"; + definition.staticValues = Instance_staticValues; + definition.staticFunctions = Instance_staticFunctions; + definition.hasProperty = &Instance_hasProperty; + definition.getProperty = &Instance_getProperty; + definition.setProperty = &Instance_setProperty; + definition.deleteProperty = &Instance_deleteProperty; + definition.getPropertyNames = &Instance_getPropertyNames; + definition.callAsConstructor = &Instance_callAsConstructor; + definition.hasInstance = &Instance_hasInstance; + definition.finalize = &Finalize; + Instance_ = 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.finalize = &Finalize; + Internal_ = JSClassCreate(&definition); + + definition = kJSClassDefinitionEmpty; + definition.className = "Message"; + definition.staticFunctions = Functor_staticFunctions; + definition.callAsFunction = &Message_callAsFunction; + definition.finalize = &Finalize; + Message_ = JSClassCreate(&definition); + + definition = kJSClassDefinitionEmpty; + definition.className = "Messages"; + definition.hasProperty = &Messages_hasProperty; + definition.getProperty = &Messages_getProperty; + definition.setProperty = &Messages_setProperty; +#if !__OBJC2__ + definition.deleteProperty = &Messages_deleteProperty; +#endif + definition.getPropertyNames = &Messages_getPropertyNames; + definition.finalize = &Finalize; + Messages_ = JSClassCreate(&definition); + + definition = kJSClassDefinitionEmpty; + definition.className = "NSArrayPrototype"; + //definition.hasProperty = &NSArrayPrototype_hasProperty; + //definition.getProperty = &NSArrayPrototype_getProperty; + //definition.setProperty = &NSArrayPrototype_setProperty; + //definition.deleteProperty = &NSArrayPrototype_deleteProperty; + //definition.getPropertyNames = &NSArrayPrototype_getPropertyNames; + NSArrayPrototype_ = JSClassCreate(&definition); + + definition = kJSClassDefinitionEmpty; + definition.className = "Pointer"; + definition.staticValues = Pointer_staticValues; + definition.staticFunctions = Pointer_staticFunctions; + definition.getProperty = &Pointer_getProperty; + definition.setProperty = &Pointer_setProperty; + definition.finalize = &Finalize; + Pointer_ = JSClassCreate(&definition); + + definition = kJSClassDefinitionEmpty; + definition.className = "Selector"; + definition.staticValues = CYValue_staticValues; + definition.staticFunctions = Selector_staticFunctions; + definition.callAsFunction = &Selector_callAsFunction; + definition.finalize = &Finalize; + Selector_ = JSClassCreate(&definition); + + definition = kJSClassDefinitionEmpty; + definition.className = "Struct"; + definition.staticFunctions = Struct_staticFunctions; + definition.getProperty = &Struct_getProperty; + definition.setProperty = &Struct_setProperty; + definition.getPropertyNames = &Struct_getPropertyNames; + definition.finalize = &Finalize; + Struct_ = JSClassCreate(&definition); + + definition = kJSClassDefinitionEmpty; + definition.className = "Type"; + definition.staticFunctions = Type_staticFunctions; + definition.getProperty = &Type_getProperty; + definition.callAsFunction = &Type_callAsFunction; + definition.callAsConstructor = &Type_callAsConstructor; + definition.finalize = &Finalize; + Type_ = JSClassCreate(&definition); + + definition = kJSClassDefinitionEmpty; + definition.className = "Runtime"; + definition.getProperty = &Runtime_getProperty; + Runtime_ = JSClassCreate(&definition); + + definition = kJSClassDefinitionEmpty; + definition.className = "ObjectiveC::Classes"; + definition.getProperty = &ObjectiveC_Classes_getProperty; + definition.getPropertyNames = &ObjectiveC_Classes_getPropertyNames; + ObjectiveC_Classes_ = JSClassCreate(&definition); + + definition = kJSClassDefinitionEmpty; + definition.className = "ObjectiveC::Images"; + definition.getProperty = &ObjectiveC_Images_getProperty; + definition.getPropertyNames = &ObjectiveC_Images_getPropertyNames; + ObjectiveC_Images_ = JSClassCreate(&definition); + + definition = kJSClassDefinitionEmpty; + definition.className = "ObjectiveC::Image::Classes"; + definition.getProperty = &ObjectiveC_Image_Classes_getProperty; + definition.getPropertyNames = &ObjectiveC_Image_Classes_getPropertyNames; + ObjectiveC_Image_Classes_ = JSClassCreate(&definition); + + definition = kJSClassDefinitionEmpty; + definition.className = "ObjectiveC::Protocols"; + definition.getProperty = &ObjectiveC_Protocols_getProperty; + definition.getPropertyNames = &ObjectiveC_Protocols_getPropertyNames; + ObjectiveC_Protocols_ = JSClassCreate(&definition); + + definition = kJSClassDefinitionEmpty; + //definition.getProperty = &Global_getProperty; + JSClassRef Global(JSClassCreate(&definition)); + + JSGlobalContextRef context(JSGlobalContextCreate(Global)); + Context_ = context; + + JSObjectRef global(CYGetGlobalObject(context)); + + JSObjectSetPrototype(context, global, JSObjectMake(context, Runtime_, NULL)); + ObjectiveC_ = JSObjectMake(context, NULL, NULL); + CYSetProperty(context, global, CYJSString("ObjectiveC"), ObjectiveC_); + + CYSetProperty(context, ObjectiveC_, CYJSString("classes"), JSObjectMake(context, ObjectiveC_Classes_, NULL)); + CYSetProperty(context, ObjectiveC_, CYJSString("images"), JSObjectMake(context, ObjectiveC_Images_, NULL)); + CYSetProperty(context, ObjectiveC_, CYJSString("protocols"), JSObjectMake(context, ObjectiveC_Protocols_, NULL)); + + Array_ = CYCastJSObject(context, CYGetProperty(context, global, CYJSString("Array"))); + Function_ = CYCastJSObject(context, CYGetProperty(context, global, CYJSString("Function"))); + String_ = CYCastJSObject(context, CYGetProperty(context, global, CYJSString("String"))); + + length_ = JSStringCreateWithUTF8CString("length"); + message_ = JSStringCreateWithUTF8CString("message"); + name_ = JSStringCreateWithUTF8CString("name"); + prototype_ = JSStringCreateWithUTF8CString("prototype"); + toCYON_ = JSStringCreateWithUTF8CString("toCYON"); + toJSON_ = JSStringCreateWithUTF8CString("toJSON"); + + JSObjectRef Object(CYCastJSObject(context, CYGetProperty(context, global, CYJSString("Object")))); + Object_prototype_ = CYCastJSObject(context, CYGetProperty(context, Object, prototype_)); + + Array_prototype_ = CYCastJSObject(context, CYGetProperty(context, Array_, prototype_)); + Array_pop_ = CYCastJSObject(context, CYGetProperty(context, Array_prototype_, CYJSString("pop"))); + Array_push_ = CYCastJSObject(context, CYGetProperty(context, Array_prototype_, CYJSString("push"))); + Array_splice_ = CYCastJSObject(context, CYGetProperty(context, Array_prototype_, CYJSString("splice"))); + + JSObjectRef Functor(JSObjectMakeConstructor(context, Functor_, &Functor_new)); + JSObjectRef Instance(JSObjectMakeConstructor(context, Instance_, &Instance_new)); + JSObjectRef Message(JSObjectMakeConstructor(context, Message_, NULL)); + JSObjectRef Selector(JSObjectMakeConstructor(context, Selector_, &Selector_new)); + + Instance_prototype_ = (JSObjectRef) CYGetProperty(context, Instance, prototype_); + + JSValueRef function(CYGetProperty(context, Function_, prototype_)); + JSObjectSetPrototype(context, (JSObjectRef) CYGetProperty(context, Message, prototype_), function); + JSObjectSetPrototype(context, (JSObjectRef) CYGetProperty(context, Functor, prototype_), function); + JSObjectSetPrototype(context, (JSObjectRef) CYGetProperty(context, Selector, prototype_), function); + + CYSetProperty(context, global, CYJSString("Functor"), Functor); + CYSetProperty(context, global, CYJSString("Instance"), Instance); + CYSetProperty(context, global, CYJSString("Pointer"), JSObjectMakeConstructor(context, Pointer_, &Pointer_new)); + CYSetProperty(context, global, CYJSString("Selector"), Selector); + CYSetProperty(context, global, CYJSString("Type"), JSObjectMakeConstructor(context, Type_, &Type_new)); + + MSHookFunction(&objc_registerClassPair, MSHake(objc_registerClassPair)); + + class_addMethod(NSCFType_, @selector(cy$toJSON:), reinterpret_cast(&NSCFType$cy$toJSON), "@12@0:4@8"); + + JSObjectRef cycript(JSObjectMake(context, NULL, NULL)); + CYSetProperty(context, global, CYJSString("Cycript"), cycript); + CYSetProperty(context, cycript, CYJSString("gc"), JSObjectMakeFunctionWithCallback(context, CYJSString("gc"), &Cycript_gc_callAsFunction)); + + CYSetProperty(context, global, CYJSString("objc_registerClassPair"), JSObjectMakeFunctionWithCallback(context, CYJSString("objc_registerClassPair"), &objc_registerClassPair_)); + CYSetProperty(context, global, CYJSString("objc_msgSend"), JSObjectMakeFunctionWithCallback(context, CYJSString("objc_msgSend"), &$objc_msgSend)); + CYSetProperty(context, global, CYJSString("$cyq"), JSObjectMakeFunctionWithCallback(context, CYJSString("$cyq"), &$cyq)); - JSClassDefinition definition; - - definition = kJSClassDefinitionEmpty; - definition.className = "Pointer"; - definition.staticFunctions = Pointer_staticFunctions; - definition.getProperty = &Pointer_getProperty; - definition.setProperty = &Pointer_setProperty; - definition.finalize = &CYData::Finalize; - Pointer_ = JSClassCreate(&definition); - - definition = kJSClassDefinitionEmpty; - definition.className = "Functor"; - definition.staticFunctions = Functor_staticFunctions; - definition.callAsFunction = &Functor_callAsFunction; - definition.finalize = &CYData::Finalize; - Functor_ = JSClassCreate(&definition); - - definition = kJSClassDefinitionEmpty; - definition.className = "Struct"; - definition.getProperty = &Struct_getProperty; - definition.setProperty = &Struct_setProperty; - definition.getPropertyNames = &Struct_getPropertyNames; - definition.finalize = &CYData::Finalize; - Struct_ = JSClassCreate(&definition); - - definition = kJSClassDefinitionEmpty; - definition.className = "Selector"; - definition.staticValues = CYValue_staticValues; - //definition.staticValues = Selector_staticValues; - definition.staticFunctions = Selector_staticFunctions; - definition.callAsFunction = &Selector_callAsFunction; - definition.finalize = &CYData::Finalize; - Selector_ = JSClassCreate(&definition); - - definition = kJSClassDefinitionEmpty; - definition.className = "Instance"; - definition.staticValues = CYValue_staticValues; - definition.staticFunctions = Instance_staticFunctions; - definition.getProperty = &Instance_getProperty; - definition.setProperty = &Instance_setProperty; - definition.deleteProperty = &Instance_deleteProperty; - definition.callAsConstructor = &Instance_callAsConstructor; - definition.finalize = &CYData::Finalize; - Instance_ = JSClassCreate(&definition); - - definition = kJSClassDefinitionEmpty; - definition.className = "Runtime"; - definition.getProperty = &Runtime_getProperty; - Runtime_ = JSClassCreate(&definition); - - definition = kJSClassDefinitionEmpty; - //definition.getProperty = &Global_getProperty; - JSClassRef Global(JSClassCreate(&definition)); - - JSGlobalContextRef context(JSGlobalContextCreate(Global)); - Context_ = context; - - JSObjectRef global(CYGetGlobalObject(context)); - - JSObjectSetPrototype(context, global, JSObjectMake(context, Runtime_, NULL)); - CYSetProperty(context, global, CYJSString("ObjectiveC"), JSObjectMake(context, Runtime_, NULL)); - - CYSetProperty(context, global, CYJSString("Functor"), JSObjectMakeConstructor(context, Functor_, &Functor_new)); - CYSetProperty(context, global, CYJSString("Pointer"), JSObjectMakeConstructor(context, Pointer_, &Pointer_new)); - CYSetProperty(context, global, CYJSString("Selector"), JSObjectMakeConstructor(context, Selector_, &Selector_new)); - - MSHookFunction(&objc_registerClassPair, MSHake(objc_registerClassPair)); - - CYSetProperty(context, global, CYJSString("objc_registerClassPair"), JSObjectMakeFunctionWithCallback(context, CYJSString("objc_registerClassPair"), &objc_registerClassPair_)); - CYSetProperty(context, global, CYJSString("objc_msgSend"), JSObjectMakeFunctionWithCallback(context, CYJSString("objc_msgSend"), &$objc_msgSend)); - - System_ = JSObjectMake(context, NULL, NULL); - CYSetProperty(context, global, CYJSString("system"), System_); - CYSetProperty(context, System_, CYJSString("args"), CYJSNull(context)); - //CYSetProperty(context, System_, CYJSString("global"), global); - - CYSetProperty(context, System_, CYJSString("print"), JSObjectMakeFunctionWithCallback(context, CYJSString("print"), &System_print)); - - length_ = JSStringCreateWithUTF8CString("length"); - message_ = JSStringCreateWithUTF8CString("message"); - name_ = JSStringCreateWithUTF8CString("name"); - toCYON_ = JSStringCreateWithUTF8CString("toCYON"); - toJSON_ = JSStringCreateWithUTF8CString("toJSON"); - - Array_ = CYCastJSObject(context, CYGetProperty(context, global, CYJSString("Array"))); - Function_ = CYCastJSObject(context, CYGetProperty(context, global, CYJSString("Function"))); + System_ = JSObjectMake(context, NULL, NULL); + CYSetProperty(context, global, CYJSString("system"), System_); + CYSetProperty(context, System_, CYJSString("args"), CYJSNull(context)); + //CYSetProperty(context, System_, CYJSString("global"), global); + + CYSetProperty(context, System_, CYJSString("print"), JSObjectMakeFunctionWithCallback(context, CYJSString("print"), &System_print)); + + Result_ = JSStringCreateWithUTF8CString("_"); + + JSValueProtect(context, Array_); + JSValueProtect(context, Function_); + JSValueProtect(context, String_); + + JSValueProtect(context, Instance_prototype_); + JSValueProtect(context, Object_prototype_); + + JSValueProtect(context, Array_prototype_); + JSValueProtect(context, Array_pop_); + JSValueProtect(context, Array_push_); + JSValueProtect(context, Array_splice_); + } + + return Context_; }