#include <Foundation/Foundation.h>
#include "Code.hpp"
+#include "Decode.hpp"
#include "Error.hpp"
#include "JavaScript.hpp"
#include "String.hpp"
#include "Execute.hpp"
#include "ObjectiveC/Internal.hpp"
+#include "ObjectiveC/Syntax.hpp"
#define CYObjectiveTry_ { \
try
/* }}} */
/* Bridge: NSBlock {{{ */
#ifdef __APPLE__
-@interface NSBlock
+@interface NSBlock : NSObject
- (void) invoke;
+@end
+
+static const char *CYBlockEncoding(NSBlock *self);
+static sig::Signature *CYBlockSignature(CYPool &pool, NSBlock *self);
+
+@implementation NSBlock (Cycript)
+
+- (NSString *) cy$toCYON:(bool)objective inSet:(std::set<void *> &)objects {
+ CYLocalPool pool;
+
+ sig::Signature *signature(CYBlockSignature(pool, self));
+ // XXX: I am checking signature->count due to Decode doing it for block_P
+ if (signature == NULL || signature->count == 0)
+ return [super cy$toCYON:objective inSet:objects];
+ _oassert(objects.insert(self).second);
+
+ sig::Block type;
+ sig::Copy(pool, type.signature, *signature);
+
+ CYTypedIdentifier *typed((new(pool) CYTypeExpression(CYDecodeType(pool, &type)))->typed_);
+ CYTypeFunctionWith *function(typed->Function());
+ _assert(function != NULL);
+
+ _assert(function->parameters_ != NULL);
+ CYObjCBlock *block(new(pool) CYObjCBlock(typed, function->parameters_, NULL));
+
+ std::ostringstream str;
+ CYOptions options;
+ CYOutput out(*str.rdbuf(), options);
+ block->Output(out, CYNoFlags);
+
+ std::string value(str.str());
+ return CYCastNSString(NULL, CYUTF8String(value.c_str(), value.size()));
+}
+
@end
#endif
/* }}} */
return array;
}
-JSValueRef CYCastJSValue(JSContextRef context, NSObject *value) { CYPoolTry {
+JSValueRef CYCastJSValue(JSContextRef context, NSObject *value) {
if (value == nil)
return CYJSNull(context);
- else
- return CYMakeInstance(context, value);
-} CYPoolCatch(NULL) return /*XXX*/ NULL; }
+ return CYMakeInstance(context, value);
+}
@implementation CYJSObject
return JSObjectMake(context, Selector_, internal);
}
+static JSValueRef CYCastJSValue(JSContextRef context, SEL sel) {
+ if (sel == NULL)
+ return CYJSNull(context);
+ return CYMakeSelector(context, sel);
+}
+
static SEL CYCastSEL(JSContextRef context, JSValueRef value) {
if (JSValueIsObjectOfClass(context, value, Selector_)) {
Selector_privateData *internal(reinterpret_cast<Selector_privateData *>(JSObjectGetPrivate((JSObjectRef) value)));
CYCallFunction(pool, context, cif, function, value, values);
} CYSadCatch() }
+static NSBlock *CYCastNSBlock(CYPool &pool, JSContextRef context, JSValueRef value, const sig::Signature *signature) {
#ifdef __APPLE__
-static NSBlock *CYCastNSBlock(CYPool &pool, JSContextRef context, JSValueRef value, sig::Signature *signature) {
if (JSValueIsNull(context, value))
return nil;
JSObjectRef object(CYCastJSObject(context, value));
memcpy(modified.elements + 2, signature->elements + 1, sizeof(sig::Element) * (signature->count - 1));
modified.elements[1].name = NULL;
- modified.elements[1].type = new(pool) sig::Type();
+ modified.elements[1].type = new(pool) sig::Object();
modified.elements[1].offset = _not(size_t);
- memset(modified.elements[1].type, 0, sizeof(sig::Type));
- modified.elements[1].type->primitive = sig::object_P;
-
return CYMakeBlock(context, object, modified);
-}
+#else
+ _assert(false);
#endif
+}
-static bool CYObjectiveC_PoolFFI(CYPool *pool, JSContextRef context, sig::Type *type, ffi_type *ffi, void *data, JSValueRef value) { CYSadTry {
- // XXX: assigning to an indirect id * works for return values, but not for properties and fields
+namespace sig {
- switch (type->primitive) {
-#ifdef __APPLE__
- case sig::block_P:
- // XXX: this function might not handle the idea of a null pool
- *reinterpret_cast<id *>(data) = CYCastNSBlock(*pool, context, value, &type->data.signature);
- break;
-#endif
+void Block::PoolFFI(CYPool *pool, JSContextRef context, ffi_type *ffi, void *data, JSValueRef value) const {
+ // XXX: this function might not handle the idea of a null pool
+ *reinterpret_cast<id *>(data) = CYCastNSBlock(*pool, context, value, &signature);
+}
- case sig::object_P:
- case sig::typename_P:
- *reinterpret_cast<id *>(data) = CYCastNSObject(pool, context, value);
- break;
+// XXX: assigning to an indirect id * works for return values, but not for properties and fields
+void Object::PoolFFI(CYPool *pool, JSContextRef context, ffi_type *ffi, void *data, JSValueRef value) const {
+ *reinterpret_cast<id *>(data) = CYCastNSObject(pool, context, value);
+}
- case sig::selector_P:
- *reinterpret_cast<SEL *>(data) = CYCastSEL(context, value);
- break;
+void Meta::PoolFFI(CYPool *pool, JSContextRef context, ffi_type *ffi, void *data, JSValueRef value) const {
+ *reinterpret_cast<id *>(data) = CYCastNSObject(pool, context, value);
+}
- default:
- return false;
- }
+void Selector::PoolFFI(CYPool *pool, JSContextRef context, ffi_type *ffi, void *data, JSValueRef value) const {
+ *reinterpret_cast<SEL *>(data) = CYCastSEL(context, value);
+}
- return true;
-} CYSadCatch(false) }
-
-static JSValueRef CYObjectiveC_FromFFI(JSContextRef context, sig::Type *type, ffi_type *ffi, void *data, bool initialize, JSObjectRef owner) { CYPoolTry {
- switch (type->primitive) {
- // XXX: do something epic about blocks
- case sig::block_P:
- case sig::object_P:
- if (NSObject *value = *reinterpret_cast<NSObject **>(data)) {
- JSObjectRef object(CYMakeInstance(context, value));
-
- if (initialize) {
- Instance *internal(reinterpret_cast<Instance *>(JSObjectGetPrivate(object)));
-
- if ((internal->flags_ & Instance::Uninitialized) != 0) {
- internal->flags_ = static_cast<Instance::Flags>(internal->flags_ & ~Instance::Uninitialized);
- _assert(internal->value_ == nil);
- internal->value_ = value;
- }
-
- [value release];
- }
-
- return object;
- } else goto null;
-
- case sig::typename_P:
- if (Class value = *reinterpret_cast<Class *>(data))
- return CYMakeInstance(context, value, Instance::Permanent);
- else goto null;
-
- case sig::selector_P:
- if (SEL value = *reinterpret_cast<SEL *>(data))
- return CYMakeSelector(context, value);
- else goto null;
-
- null:
- return CYJSNull(context);
- default:
- return NULL;
+JSValueRef Object::FromFFI(JSContextRef context, ffi_type *ffi, void *data, bool initialize, JSObjectRef owner) const {
+ NSObject *value(*reinterpret_cast<NSObject **>(data));
+ if (value == NULL)
+ return CYJSNull(context);
+ JSObjectRef object(CYMakeInstance(context, value));
+
+ if (initialize) {
+ Instance *internal(reinterpret_cast<Instance *>(JSObjectGetPrivate(object)));
+
+ if ((internal->flags_ & Instance::Uninitialized) != 0) {
+ internal->flags_ = static_cast<Instance::Flags>(internal->flags_ & ~Instance::Uninitialized);
+ _assert(internal->value_ == nil);
+ internal->value_ = value;
+ }
+
+ [value release];
}
-} CYPoolCatch(NULL) return /*XXX*/ NULL; }
+
+ return object;
+}
+
+JSValueRef Meta::FromFFI(JSContextRef context, ffi_type *ffi, void *data, bool initialize, JSObjectRef owner) const {
+ if (Class value = *reinterpret_cast<Class *>(data))
+ return CYMakeInstance(context, value, Instance::Permanent);
+ return CYJSNull(context);
+}
+
+JSValueRef Selector::FromFFI(JSContextRef context, ffi_type *ffi, void *data, bool initialize, JSObjectRef owner) const {
+ return CYCastJSValue(context, *reinterpret_cast<SEL *>(data));
+}
+
+JSValueRef Block::FromFFI(JSContextRef context, ffi_type *ffi, void *data, bool initialize, JSObjectRef owner) const {
+ return CYCastJSValue(context, *reinterpret_cast<NSObject **>(data));
+}
+
+}
static bool CYImplements(id object, Class _class, SEL selector, bool devoid = false) {
if (objc_method *method = class_getInstanceMethod(_class, selector)) {
return descriptor3->signature;
}
+static sig::Signature *CYBlockSignature(CYPool &pool, NSBlock *self) {
+ const char *encoding(CYBlockEncoding(self));
+ if (encoding == NULL)
+ return NULL;
+ // XXX: this should be stored on a FunctionInstance private value subclass
+ sig::Signature *signature(new(pool) sig::Signature());
+ sig::Parse(pool, signature, encoding, &Structor_);
+ return signature;
+}
+
static JSValueRef FunctionInstance_callAsFunction(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
Instance *internal(reinterpret_cast<Instance *>(JSObjectGetPrivate(object)));
id self(internal->GetValue());
sig::Parse(pool, &signature, encoding, &Structor_);
ffi_cif cif;
- sig::sig_ffi_cif(pool, &sig::ObjectiveC, &signature, &cif);
+ sig::sig_ffi_cif(pool, &signature, &cif);
BlockLiteral *literal(reinterpret_cast<BlockLiteral *>(self));
void (*function)() = reinterpret_cast<void (*)()>(literal->invoke);
#endif
auto type(new(pool) Type_privateData(encoding));
- return CYFromFFI(context, type->type_, type->GetFFI(), data);
+ return type->type_->FromFFI(context, type->GetFFI(), data);
}
}
field = field & ~(mask << shift) | (uintptr_t(CYCastDouble(context, value)) & mask) << shift;
} else {
auto type(new(pool) Type_privateData(ivar_getTypeEncoding(ivar)));
- CYPoolFFI(&pool, context, type->type_, type->GetFFI(), reinterpret_cast<uint8_t *>(self) + ivar_getOffset(ivar), value);
+ type->type_->PoolFFI(&pool, context, type->GetFFI(), reinterpret_cast<uint8_t *>(self) + ivar_getOffset(ivar), value);
return true;
}
}
sig::Element *element(&elements[index]);
element->name = NULL;
element->offset = _not(size_t);
-
- sig::Type *type(new (pool) sig::Type);
- memset(type, 0, sizeof(*type));
- type->primitive = sig::object_P;
- element->type = type;
+ element->type = new(pool) sig::Object();
}
signature.elements = elements;
}
ffi_cif cif;
- sig::sig_ffi_cif(pool, &sig::ObjectiveC, &signature, &cif);
+ sig::sig_ffi_cif(pool, &signature, &cif);
if (imp == NULL) {
#ifndef CY_NO_STRET
} CYCatch(NULL) }
static JSObjectRef Instance_new(JSContextRef context, JSObjectRef object, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
- if (count > 1)
+ if (count != 1)
throw CYJSError(context, "incorrect number of arguments to Instance constructor");
- id self(count == 0 ? nil : CYCastPointer<id>(context, arguments[0]));
- return CYMakeInstance(context, self);
+ return CYMakeInstance(context, CYCastPointer<id>(context, arguments[0]));
} CYCatch(NULL) }
static JSValueRef CYValue_getProperty_value(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { CYTry {
CYValue *internal(reinterpret_cast<CYValue *>(JSObjectGetPrivate(_this)));
Type_privateData *typical(internal->GetType());
+ sig::Void XXX;
+
sig::Type *type;
ffi_type *ffi;
if (typical == NULL) {
- type = NULL;
+ type = &XXX;
ffi = NULL;
} else {
type = typical->type_;
ffi = typical->ffi_;
}
- return CYMakePointer(context, &internal->value_, _not(size_t), type, ffi, object);
+ return CYMakePointer(context, &internal->value_, *type, ffi, object);
} CYCatch(NULL) }
static JSValueRef FunctionInstance_getProperty_type(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { CYTry {
Instance *internal(reinterpret_cast<Instance *>(JSObjectGetPrivate(object)));
- const char *encoding(CYBlockEncoding(internal->GetValue()));
- if (encoding == NULL)
- return CYJSNull(context);
- // XXX: this should be stored on a FunctionInstance private value subclass
CYPool pool;
- sig::Signature signature;
- sig::Parse(pool, &signature, encoding, &Structor_);
- return CYMakeType(context, &signature);
+ sig::Signature *signature(CYBlockSignature(pool, internal->GetValue()));
+ if (signature == NULL)
+ return CYJSNull(context);
+ return CYMakeType(context, signature);
} CYCatch(NULL) }
static JSValueRef Instance_getProperty_constructor(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { CYTry {
if (!CYIsClass(value))
CYThrow("non-Class object cannot be used as Type");
- sig::Type type;
- memset(&type, 0, sizeof(type));
- type.primitive = sig::object_P;
- type.name = class_getName(value);
- return CYMakeType(context, &type);
+ sig::Object type(class_getName(value));
+ return CYMakeType(context, type);
} CYCatch(NULL) return /*XXX*/ NULL; }
static JSValueRef Selector_callAsFunction_toString(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
void CYObjectiveC_Initialize() { /*XXX*/ JSContextRef context(NULL); CYPoolTry {
CYPool &pool(CYGetGlobalPool());
- Object_type = new(pool) Type_privateData(sig::object_P);
- Selector_type = new(pool) Type_privateData(sig::selector_P);
+ Object_type = new(pool) Type_privateData(sig::Object());
+ Selector_type = new(pool) Type_privateData(sig::Selector());
NSArray_ = objc_getClass("NSArray");
NSBlock_ = objc_getClass("NSBlock");
JSObjectRef cache(CYGetCachedObject(context, CYJSString("cache")));
CYSetProperty(context, cache, CYJSString("YES"), JSValueMakeBoolean(context, true), kJSPropertyAttributeDontEnum);
CYSetProperty(context, cache, CYJSString("NO"), JSValueMakeBoolean(context, false), kJSPropertyAttributeDontEnum);
- CYSetProperty(context, cache, CYJSString("id"), CYMakeType(context, "@"), kJSPropertyAttributeDontEnum);
- CYSetProperty(context, cache, CYJSString("Class"), CYMakeType(context, "#"), kJSPropertyAttributeDontEnum);
- CYSetProperty(context, cache, CYJSString("SEL"), CYMakeType(context, ":"), kJSPropertyAttributeDontEnum);
+ CYSetProperty(context, cache, CYJSString("id"), CYMakeType(context, sig::Object()), kJSPropertyAttributeDontEnum);
+ CYSetProperty(context, cache, CYJSString("Class"), CYMakeType(context, sig::Meta()), kJSPropertyAttributeDontEnum);
+ CYSetProperty(context, cache, CYJSString("SEL"), CYMakeType(context, sig::Selector()), kJSPropertyAttributeDontEnum);
} CYPoolCatch() }
static void *CYObjectiveC_CastSymbol(const char *name) {
&CYObjectiveC_CallFunction,
&CYObjectiveC_Initialize,
&CYObjectiveC_SetupContext,
- &CYObjectiveC_PoolFFI,
- &CYObjectiveC_FromFFI,
&CYObjectiveC_CastSymbol,
};
projects / cycript.git / blobdiff