JSStringRef CYCopyJSString(CYUTF8String value) {
if (memchr(value.data, '\0', value.size) != NULL) {
CYPool pool;
- return CYCopyJSString(pool.memdup(value.data, value.size));
+ return CYCopyJSString(CYPoolUTF16String(pool, value));
} else if (value.data[value.size] != '\0') {
CYPool pool;
- return CYCopyJSString(CYPoolUTF16String(pool, value));
+ return CYCopyJSString(pool.strmemdup(value.data, value.size));
} else {
return CYCopyJSString(value.data);
}
delete internal;
}
-void Structor_(CYPool &pool, sig::Type *&type) {
- if (
- type->primitive == sig::pointer_P &&
- type->data.data.type->primitive == sig::struct_P &&
- type->data.data.type->name != NULL &&
- strcmp(type->data.data.type->name, "_objc_class") == 0
- ) {
- type->primitive = sig::typename_P;
- type->data.data.type = NULL;
- return;
- }
-
- if (type->primitive != sig::struct_P || type->name == NULL)
- return;
-
+sig::Type *Structor_(CYPool &pool, sig::Aggregate *aggregate) {
//_assert(false);
+ return aggregate;
}
JSClassRef Type_privateData::Class_;
Type_privateData *type_;
size_t length_;
- Pointer(void *value, JSContextRef context, JSObjectRef owner, size_t length, sig::Type *type) :
+ Pointer(void *value, JSContextRef context, JSObjectRef owner, size_t length, const sig::Type &type) :
CYOwned(value, context, owner),
type_(new(*pool_) Type_privateData(type)),
length_(length)
}
};
-JSObjectRef CYMakeStruct(JSContextRef context, void *data, sig::Type *type, ffi_type *ffi, JSObjectRef owner) {
+JSObjectRef CYMakeStruct(JSContextRef context, void *data, const sig::Type &type, ffi_type *ffi, JSObjectRef owner) {
Struct_privateData *internal(new Struct_privateData(context, owner));
CYPool &pool(*internal->pool_);
Type_privateData *typical(new(pool) Type_privateData(type, ffi));
if (owner != NULL)
internal->value_ = data;
else {
- size_t size(typical->GetFFI()->size);
- void *copy(internal->pool_->malloc<void>(size));
- memcpy(copy, data, size);
+ ffi_type *ffi(typical->GetFFI());
+ void *copy(internal->pool_->malloc<void>(ffi->size, ffi->alignment));
+ memcpy(copy, data, ffi->size);
internal->value_ = copy;
}
return _jsccall(JSObjectGetPropertyAtIndex, context, array, index);
}
-void CYArrayPush(JSContextRef context, JSObjectRef array, JSValueRef value) {
- JSValueRef arguments[1];
- arguments[0] = value;
+void CYArrayPush(JSContextRef context, JSObjectRef array, size_t length, const JSValueRef arguments[]) {
JSObjectRef Array(CYGetCachedObject(context, CYJSString("Array_prototype")));
- _jsccall(JSObjectCallAsFunction, context, CYCastJSObject(context, CYGetProperty(context, Array, push_s)), array, 1, arguments);
+ _jsccall(JSObjectCallAsFunction, context, CYCastJSObject(context, CYGetProperty(context, Array, push_s)), array, length, arguments);
+}
+
+void CYArrayPush(JSContextRef context, JSObjectRef array, JSValueRef value) {
+ return CYArrayPush(context, array, 1, &value);
}
+template <size_t Size_>
+class CYArrayBuilder {
+ private:
+ JSContextRef context_;
+ JSObjectRef &array_;
+ size_t size_;
+ JSValueRef values_[Size_];
+
+ void flush() {
+ if (array_ == NULL)
+ array_ = CYObjectMakeArray(context_, size_, values_);
+ else
+ CYArrayPush(context_, array_, size_, values_);
+ }
+
+ public:
+ CYArrayBuilder(JSContextRef context, JSObjectRef &array) :
+ context_(context),
+ array_(array),
+ size_(0)
+ {
+ }
+
+ ~CYArrayBuilder() {
+ flush();
+ }
+
+ void operator ()(JSValueRef value) {
+ if (size_ == Size_) {
+ flush();
+ size_ = 0;
+ }
+
+ values_[size_++] = value;
+ }
+};
+
static JSValueRef System_print(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
FILE *file(stdout);
return CYCastJSValue(context, CYJSString(CYUTF8String(value.c_str(), value.size())));
} CYCatch(NULL) }
-JSObjectRef CYMakePointer(JSContextRef context, void *pointer, size_t length, sig::Type *type, ffi_type *ffi, JSObjectRef owner) {
+JSObjectRef CYMakePointer(JSContextRef context, void *pointer, size_t length, const sig::Type &type, ffi_type *ffi, JSObjectRef owner) {
Pointer *internal(new Pointer(pointer, context, owner, length, type));
return JSObjectMake(context, Pointer_, internal);
}
}
}
-void CYPoolFFI(CYPool *pool, JSContextRef context, sig::Type *type, ffi_type *ffi, void *data, JSValueRef value) {
- switch (type->primitive) {
- case sig::boolean_P:
- *reinterpret_cast<bool *>(data) = JSValueToBoolean(context, value);
- break;
-
-#define CYPoolFFI_(primitive, native) \
- case sig::primitive ## _P: \
- *reinterpret_cast<native *>(data) = CYCastDouble(context, value); \
- break;
-
- CYPoolFFI_(uchar, unsigned char)
- CYPoolFFI_(schar, signed char)
- CYPoolFFI_(ushort, unsigned short)
- CYPoolFFI_(short, short)
- CYPoolFFI_(ulong, unsigned long)
- CYPoolFFI_(long, long)
- CYPoolFFI_(uint, unsigned int)
- CYPoolFFI_(int, int)
- CYPoolFFI_(ulonglong, unsigned long long)
- CYPoolFFI_(longlong, long long)
- CYPoolFFI_(float, float)
- CYPoolFFI_(double, double)
-
- case sig::array_P: {
- uint8_t *base(reinterpret_cast<uint8_t *>(data));
- JSObjectRef aggregate(JSValueIsObject(context, value) ? (JSObjectRef) value : NULL);
- for (size_t index(0); index != type->data.data.size; ++index) {
- ffi_type *field(ffi->elements[index]);
-
- JSValueRef rhs;
- if (aggregate == NULL)
- rhs = value;
- else {
- rhs = CYGetProperty(context, aggregate, index);
- if (JSValueIsUndefined(context, rhs))
- throw CYJSError(context, "unable to extract array value");
- }
-
- CYPoolFFI(pool, context, type->data.data.type, field, base, rhs);
- // XXX: alignment?
- base += field->size;
- }
- } break;
+namespace sig {
- case sig::pointer_P:
- *reinterpret_cast<void **>(data) = CYCastPointer<void *>(context, value);
- break;
+// XXX: this is somehow not quite a template :/
- case sig::string_P: {
- bool guess(false);
- *reinterpret_cast<const char **>(data) = CYCastPointer<const char *>(context, value, &guess);
- if (guess && pool != NULL)
- *reinterpret_cast<const char **>(data) = CYPoolCString(*pool, context, value);
- } break;
+template <>
+void Primitive<bool>::PoolFFI(CYPool *pool, JSContextRef context, ffi_type *ffi, void *data, JSValueRef value) const {
+ *reinterpret_cast<bool *>(data) = JSValueToBoolean(context, value);
+}
- case sig::struct_P: {
- uint8_t *base(reinterpret_cast<uint8_t *>(data));
- JSObjectRef aggregate(JSValueIsObject(context, value) ? (JSObjectRef) value : NULL);
- for (size_t index(0); index != type->data.signature.count; ++index) {
- sig::Element *element(&type->data.signature.elements[index]);
- ffi_type *field(ffi->elements[index]);
-
- JSValueRef rhs;
- if (aggregate == NULL)
- rhs = value;
- else {
- rhs = CYGetProperty(context, aggregate, index);
- if (JSValueIsUndefined(context, rhs)) {
- if (element->name != NULL)
- rhs = CYGetProperty(context, aggregate, CYJSString(element->name));
- else
- goto undefined;
- if (JSValueIsUndefined(context, rhs)) undefined:
- throw CYJSError(context, "unable to extract structure value");
- }
- }
-
- CYPoolFFI(pool, context, element->type, field, base, rhs);
- // XXX: alignment?
- base += field->size;
- }
- } break;
+#define CYPoolFFI_(Type_) \
+template <> \
+void Primitive<Type_>::PoolFFI(CYPool *pool, JSContextRef context, ffi_type *ffi, void *data, JSValueRef value) const { \
+ *reinterpret_cast<Type_ *>(data) = CYCastDouble(context, value); \
+}
- case sig::void_P:
- break;
+CYPoolFFI_(char)
+CYPoolFFI_(double)
+CYPoolFFI_(float)
+CYPoolFFI_(signed char)
+CYPoolFFI_(signed int)
+CYPoolFFI_(signed long int)
+CYPoolFFI_(signed long long int)
+CYPoolFFI_(signed short int)
+CYPoolFFI_(unsigned char)
+CYPoolFFI_(unsigned int)
+CYPoolFFI_(unsigned long int)
+CYPoolFFI_(unsigned long long int)
+CYPoolFFI_(unsigned short int)
- // XXX: implement a conversion from a single character string?
- CYPoolFFI_(char, char)
+void Void::PoolFFI(CYPool *pool, JSContextRef context, ffi_type *ffi, void *data, JSValueRef value) const {
+ _assert(false);
+}
- default:
- for (CYHook *hook : GetHooks())
- if (hook->PoolFFI != NULL)
- if ((*hook->PoolFFI)(pool, context, type, ffi, data, value))
- return;
+void Unknown::PoolFFI(CYPool *pool, JSContextRef context, ffi_type *ffi, void *data, JSValueRef value) const {
+ _assert(false);
+}
+
+void String::PoolFFI(CYPool *pool, JSContextRef context, ffi_type *ffi, void *data, JSValueRef value) const {
+ bool guess(false);
+ *reinterpret_cast<const char **>(data) = CYCastPointer<const char *>(context, value, &guess);
+ if (guess && pool != NULL)
+ *reinterpret_cast<const char **>(data) = CYPoolCString(*pool, context, value);
+}
+
+void Bits::PoolFFI(CYPool *pool, JSContextRef context, ffi_type *ffi, void *data, JSValueRef value) const {
+ _assert(false);
+}
- CYThrow("unimplemented signature code: '%c''\n", type->primitive);
+void Pointer::PoolFFI(CYPool *pool, JSContextRef context, ffi_type *ffi, void *data, JSValueRef value) const {
+ *reinterpret_cast<void **>(data) = CYCastPointer<void *>(context, value);
+}
+
+void Array::PoolFFI(CYPool *pool, JSContextRef context, ffi_type *ffi, void *data, JSValueRef value) const {
+ uint8_t *base(reinterpret_cast<uint8_t *>(data));
+ JSObjectRef aggregate(JSValueIsObject(context, value) ? (JSObjectRef) value : NULL);
+ for (size_t index(0); index != size; ++index) {
+ ffi_type *field(ffi->elements[index]);
+
+ JSValueRef rhs;
+ if (aggregate == NULL)
+ rhs = value;
+ else {
+ rhs = CYGetProperty(context, aggregate, index);
+ if (JSValueIsUndefined(context, rhs))
+ throw CYJSError(context, "unable to extract array value");
+ }
+
+ type.PoolFFI(pool, context, field, base, rhs);
+ base += field->size;
}
}
-JSValueRef CYFromFFI(JSContextRef context, sig::Type *type, ffi_type *ffi, void *data, bool initialize, JSObjectRef owner) {
- switch (type->primitive) {
- case sig::boolean_P:
- return CYCastJSValue(context, *reinterpret_cast<bool *>(data));
-
-#define CYFromFFI_(primitive, native) \
- case sig::primitive ## _P: \
- return CYCastJSValue(context, *reinterpret_cast<native *>(data)); \
-
- CYFromFFI_(uchar, unsigned char)
- CYFromFFI_(schar, signed char)
- CYFromFFI_(ushort, unsigned short)
- CYFromFFI_(short, short)
- CYFromFFI_(ulong, unsigned long)
- CYFromFFI_(long, long)
- CYFromFFI_(uint, unsigned int)
- CYFromFFI_(int, int)
- CYFromFFI_(ulonglong, unsigned long long)
- CYFromFFI_(longlong, long long)
- CYFromFFI_(float, float)
- CYFromFFI_(double, double)
-
- case sig::array_P:
- if (void *pointer = data)
- return CYMakePointer(context, pointer, type->data.data.size, type->data.data.type, NULL, owner);
- else goto null;
-
- case sig::pointer_P:
- if (void *pointer = *reinterpret_cast<void **>(data))
- return CYMakePointer(context, pointer, _not(size_t), type->data.data.type, NULL, owner);
- else goto null;
-
- case sig::string_P:
- if (char *pointer = *reinterpret_cast<char **>(data))
- return CYMakeCString(context, pointer, owner);
- else goto null;
-
- case sig::struct_P:
- return CYMakeStruct(context, data, type, ffi, owner);
- case sig::void_P:
- return CYJSUndefined(context);
-
- CYFromFFI_(char, char)
-
- null:
- return CYJSNull(context);
- default:
- for (CYHook *hook : GetHooks())
- if (hook->FromFFI != NULL)
- if (JSValueRef value = (*hook->FromFFI)(context, type, ffi, data, initialize, owner))
- return value;
+void Aggregate::PoolFFI(CYPool *pool, JSContextRef context, ffi_type *ffi, void *data, JSValueRef value) const {
+ _assert(!overlap);
+
+ uint8_t *base(reinterpret_cast<uint8_t *>(data));
+ JSObjectRef aggregate(JSValueIsObject(context, value) ? (JSObjectRef) value : NULL);
+ for (size_t index(0); index != signature.count; ++index) {
+ sig::Element *element(&signature.elements[index]);
+ ffi_type *field(ffi->elements[index]);
+
+ JSValueRef rhs;
+ if (aggregate == NULL)
+ rhs = value;
+ else {
+ rhs = CYGetProperty(context, aggregate, index);
+ if (JSValueIsUndefined(context, rhs)) {
+ if (element->name != NULL)
+ rhs = CYGetProperty(context, aggregate, CYJSString(element->name));
+ else
+ goto undefined;
+ if (JSValueIsUndefined(context, rhs)) undefined:
+ throw CYJSError(context, "unable to extract structure value");
+ }
+ }
- CYThrow("unimplemented signature code: '%c''\n", type->primitive);
+ element->type->PoolFFI(pool, context, field, base, rhs);
+ base += field->size;
}
}
+void Function::PoolFFI(CYPool *pool, JSContextRef context, ffi_type *ffi, void *data, JSValueRef value) const {
+ _assert(false);
+}
+
+#define CYFromFFI_(Type_) \
+template <> \
+JSValueRef Primitive<Type_>::FromFFI(JSContextRef context, ffi_type *ffi, void *data, bool initialize, JSObjectRef owner) const { \
+ return CYCastJSValue(context, *reinterpret_cast<Type_ *>(data)); \
+}
+
+CYFromFFI_(bool)
+CYFromFFI_(char)
+CYFromFFI_(double)
+CYFromFFI_(float)
+CYFromFFI_(signed char)
+CYFromFFI_(signed int)
+CYFromFFI_(signed long int)
+CYFromFFI_(signed long long int)
+CYFromFFI_(signed short int)
+CYFromFFI_(unsigned char)
+CYFromFFI_(unsigned int)
+CYFromFFI_(unsigned long int)
+CYFromFFI_(unsigned long long int)
+CYFromFFI_(unsigned short int)
+
+JSValueRef Void::FromFFI(JSContextRef context, ffi_type *ffi, void *data, bool initialize, JSObjectRef owner) const {
+ return CYJSUndefined(context);
+}
+
+JSValueRef Unknown::FromFFI(JSContextRef context, ffi_type *ffi, void *data, bool initialize, JSObjectRef owner) const {
+ _assert(false);
+}
+
+JSValueRef String::FromFFI(JSContextRef context, ffi_type *ffi, void *data, bool initialize, JSObjectRef owner) const {
+ if (char *value = *reinterpret_cast<char **>(data))
+ return CYMakeCString(context, value, owner);
+ return CYJSNull(context);
+}
+
+JSValueRef Bits::FromFFI(JSContextRef context, ffi_type *ffi, void *data, bool initialize, JSObjectRef owner) const {
+ _assert(false);
+}
+
+JSValueRef Pointer::FromFFI(JSContextRef context, ffi_type *ffi, void *data, bool initialize, JSObjectRef owner) const {
+ if (void *value = *reinterpret_cast<void **>(data))
+ return CYMakePointer(context, value, _not(size_t), type, NULL, owner);
+ return CYJSNull(context);
+}
+
+JSValueRef Array::FromFFI(JSContextRef context, ffi_type *ffi, void *data, bool initialize, JSObjectRef owner) const {
+ _assert(data != NULL);
+ return CYMakePointer(context, data, size, type, NULL, owner);
+}
+
+JSValueRef Aggregate::FromFFI(JSContextRef context, ffi_type *ffi, void *data, bool initialize, JSObjectRef owner) const {
+ return CYMakeStruct(context, data, *this, ffi, owner);
+}
+
+JSValueRef Function::FromFFI(JSContextRef context, ffi_type *ffi, void *data, bool initialize, JSObjectRef owner) const {
+ return CYMakeFunctor(context, reinterpret_cast<void (*)()>(data), signature);
+}
+
+}
+
void CYExecuteClosure(ffi_cif *cif, void *result, void **arguments, void *arg) {
Closure_privateData *internal(reinterpret_cast<Closure_privateData *>(arg));
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]);
+ values[index] = internal->signature_.elements[1 + index].type->FromFFI(context, internal->cif_.arg_types[index], arguments[index]);
JSValueRef value(internal->adapter_(context, count, values, internal->function_));
- CYPoolFFI(NULL, context, internal->signature_.elements[0].type, internal->cif_.rtype, result, value);
+ if (internal->cif_.rtype != &ffi_type_void)
+ internal->signature_.elements[0].type->PoolFFI(NULL, context, internal->cif_.rtype, result, value);
}
static JSValueRef FunctionAdapter_(JSContextRef context, size_t count, JSValueRef values[], JSObjectRef function) {
static bool Index_(CYPool &pool, JSContextRef context, Struct_privateData *internal, JSStringRef property, ssize_t &index, uint8_t *&base) {
Type_privateData *typical(internal->type_);
- sig::Type *type(typical->type_);
+ sig::Aggregate *type(static_cast<sig::Aggregate *>(typical->type_));
if (type == NULL)
return false;
size_t length(strlen(name));
double number(CYCastDouble(name, length));
- size_t count(type->data.signature.count);
+ size_t count(type->signature.count);
if (std::isnan(number)) {
if (property == NULL)
return false;
- sig::Element *elements(type->data.signature.elements);
+ sig::Element *elements(type->signature.elements);
for (size_t local(0); local != count; ++local) {
sig::Element *element(&elements[local]);
Type_privateData *typical(internal->type_);
if (typical->type_ == NULL)
return NULL;
- sig::Type &type(*typical->type_);
+
+ if (sig::Function *function = dynamic_cast<sig::Function *>(typical->type_)) {
+ if (!JSStringIsEqualToUTF8CString(property, "$cyi"))
+ return NULL;
+ return CYMakeFunctor(context, reinterpret_cast<void (*)()>(internal->value_), function->signature);
+ }
ssize_t offset;
if (JSStringIsEqualToUTF8CString(property, "$cyi"))
else if (!CYGetOffset(pool, context, property, offset))
return NULL;
- if (type.primitive == sig::function_P)
- return CYMakeFunctor(context, reinterpret_cast<void (*)()>(internal->value_), type.data.signature);
-
ffi_type *ffi(typical->GetFFI());
uint8_t *base(reinterpret_cast<uint8_t *>(internal->value_));
base += ffi->size * offset;
JSObjectRef owner(internal->GetOwner() ?: object);
- return CYFromFFI(context, &type, ffi, base, false, owner);
+ return typical->type_->FromFFI(context, ffi, base, false, owner);
} CYCatch(NULL) }
static bool Pointer_setProperty(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef value, JSValueRef *exception) { CYTry {
uint8_t *base(reinterpret_cast<uint8_t *>(internal->value_));
base += ffi->size * offset;
- CYPoolFFI(NULL, context, typical->type_, ffi, base, value);
+ typical->type_->PoolFFI(NULL, context, ffi, base, value);
return true;
} CYCatch(false) }
static JSValueRef Struct_callAsFunction_$cya(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
Struct_privateData *internal(reinterpret_cast<Struct_privateData *>(JSObjectGetPrivate(_this)));
Type_privateData *typical(internal->type_);
- return CYMakePointer(context, internal->value_, _not(size_t), typical->type_, typical->ffi_, _this);
+ return CYMakePointer(context, internal->value_, _not(size_t), *typical->type_, typical->ffi_, _this);
+} CYCatch(NULL) }
+
+static JSValueRef Struct_getProperty_type(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { CYTry {
+ Struct_privateData *internal(reinterpret_cast<Struct_privateData *>(JSObjectGetPrivate(object)));
+ return CYMakeType(context, *internal->type_->type_);
} CYCatch(NULL) }
static JSValueRef Struct_getProperty(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { CYTry {
CYPool pool;
Struct_privateData *internal(reinterpret_cast<Struct_privateData *>(JSObjectGetPrivate(object)));
Type_privateData *typical(internal->type_);
+ sig::Aggregate *type(static_cast<sig::Aggregate *>(typical->type_));
ssize_t index;
uint8_t *base;
JSObjectRef owner(internal->GetOwner() ?: object);
- return CYFromFFI(context, typical->type_->data.signature.elements[index].type, typical->GetFFI()->elements[index], base, false, owner);
+ return type->signature.elements[index].type->FromFFI(context, typical->GetFFI()->elements[index], base, false, owner);
} CYCatch(NULL) }
static bool Struct_setProperty(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef value, JSValueRef *exception) { CYTry {
CYPool pool;
Struct_privateData *internal(reinterpret_cast<Struct_privateData *>(JSObjectGetPrivate(object)));
Type_privateData *typical(internal->type_);
+ sig::Aggregate *type(static_cast<sig::Aggregate *>(typical->type_));
ssize_t index;
uint8_t *base;
if (!Index_(pool, context, internal, property, index, base))
return false;
- CYPoolFFI(NULL, context, typical->type_->data.signature.elements[index].type, typical->GetFFI()->elements[index], base, value);
+ type->signature.elements[index].type->PoolFFI(NULL, context, typical->GetFFI()->elements[index], base, value);
return true;
} CYCatch(false) }
static void Struct_getPropertyNames(JSContextRef context, JSObjectRef object, JSPropertyNameAccumulatorRef names) {
Struct_privateData *internal(reinterpret_cast<Struct_privateData *>(JSObjectGetPrivate(object)));
Type_privateData *typical(internal->type_);
- sig::Type *type(typical->type_);
+ sig::Aggregate *type(static_cast<sig::Aggregate *>(typical->type_));
if (type == NULL)
return;
- size_t count(type->data.signature.count);
- sig::Element *elements(type->data.signature.elements);
+ size_t count(type->signature.count);
+ sig::Element *elements(type->signature.elements);
char number[32];
for (size_t index(setups); index != size; ++index) {
sig::Element *element(&signature->elements[index + 1]);
ffi_type *ffi(cif->arg_types[index]);
- // XXX: alignment?
- values[index] = new(pool) uint8_t[ffi->size];
- CYPoolFFI(&pool, context, element->type, ffi, values[index], arguments[index - setups]);
+ values[index] = pool.malloc<uint8_t>(ffi->size, ffi->alignment);
+ element->type->PoolFFI(&pool, context, ffi, values[index], arguments[index - setups]);
}
uint8_t value[cif->rtype->size];
call = hook->CallFunction;
call(pool, context, cif, function, value, values);
- return CYFromFFI(context, signature->elements[0].type, cif->rtype, value, initialize);
+ return signature->elements[0].type->FromFFI(context, cif->rtype, value, initialize);
}
static JSValueRef Functor_callAsFunction(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
static JSValueRef Pointer_callAsFunction(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
Pointer *internal(reinterpret_cast<Pointer *>(JSObjectGetPrivate(object)));
- if (internal->type_->type_->primitive != sig::function_P)
+ if (dynamic_cast<sig::Function *>(internal->type_->type_) == NULL)
throw CYJSError(context, "cannot call a pointer to non-function");
JSObjectRef functor(CYCastJSObject(context, CYGetProperty(context, object, cyi_s)));
return CYCallAsFunction(context, functor, _this, count, arguments);
} CYCatch(NULL) }
-JSObjectRef CYMakeType(JSContextRef context, sig::Primitive primitive) {
- Type_privateData *internal(new Type_privateData(primitive));
- return JSObjectMake(context, Type_privateData::Class_, internal);
-}
-
-JSObjectRef CYMakeType(JSContextRef context, sig::Type *type) {
+JSObjectRef CYMakeType(JSContextRef context, const sig::Type &type) {
Type_privateData *internal(new Type_privateData(type));
return JSObjectMake(context, Type_privateData::Class_, internal);
}
JSObjectRef CYMakeType(JSContextRef context, sig::Signature *signature) {
CYPool pool;
-
- sig::Type type;
- type.name = NULL;
- type.flags = 0;
-
- type.primitive = sig::function_P;
- sig::Copy(pool, type.data.signature, *signature);
-
- return CYMakeType(context, &type);
+ sig::Function type;
+ sig::Copy(pool, type.signature, *signature);
+ return CYMakeType(context, type);
}
extern "C" bool CYBridgeHash(CYPool &pool, CYUTF8String name, const char *&code, unsigned &flags) {
CYPool pool;
CYUTF8String prefix(CYPoolUTF8String(pool, context, CYJSString(context, arguments[0])));
- std::vector<JSValueRef> values;
+ JSObjectRef array(NULL);
+
+ {
+ CYArrayBuilder<1024> values(context, array);
sqlite3_stmt *statement;
}
while (_sqlcall(sqlite3_step(statement)) != SQLITE_DONE)
- values.push_back(CYCastJSValue(context, CYJSString(sqlite3_column_string(statement, 0))));
+ values(CYCastJSValue(context, CYJSString(sqlite3_column_string(statement, 0))));
_sqlcall(sqlite3_finalize(statement));
+ }
- return CYObjectMakeArray(context, values.size(), values.data());
+ return array;
} CYCatch(NULL) }
static void All_getPropertyNames(JSContextRef context, JSObjectRef object, JSPropertyNameAccumulatorRef names) {
sig::Signature signature;
sig::Parse(pool, &signature, type, &Structor_);
- return CYMakePointer(context, value, _not(size_t), signature.elements[0].type, NULL, NULL);
+ return CYMakePointer(context, value, _not(size_t), *signature.elements[0].type, NULL, NULL);
} CYCatch(NULL) }
static JSObjectRef Type_new(JSContextRef context, JSObjectRef object, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
const char *encoding(CYPoolCString(pool, context, arguments[0]));
sig::Signature signature;
sig::Parse(pool, &signature, encoding, &Structor_);
- return CYMakeType(context, signature.elements[0].type);
+ return CYMakeType(context, *signature.elements[0].type);
} else if (count == 2) {
JSObjectRef types(CYCastJSObject(context, arguments[0]));
size_t count(CYArrayLength(context, types));
JSObjectRef names(CYCastJSObject(context, arguments[1]));
- sig::Type type;
- type.name = NULL;
- type.flags = 0;
-
- type.primitive = sig::struct_P;
- type.data.signature.elements = new(pool) sig::Element[count];
- type.data.signature.count = count;
+ sig::Aggregate type(false);
+ type.signature.elements = new(pool) sig::Element[count];
+ type.signature.count = count;
for (size_t i(0); i != count; ++i) {
- sig::Element &element(type.data.signature.elements[i]);
+ sig::Element &element(type.signature.elements[i]);
element.offset = _not(size_t);
JSValueRef name(CYArrayGet(context, names, i));
element.type = internal->type_;
}
- return CYMakeType(context, &type);
+ return CYMakeType(context, type);
} else {
throw CYJSError(context, "incorrect number of arguments to Type constructor");
}
} CYCatch(NULL) }
-static JSValueRef Type_callAsFunction_$With(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], sig::Primitive primitive, JSValueRef *exception) { CYTry {
+static JSValueRef Type_callAsFunction_$With(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], sig::Callable &type, JSValueRef *exception) { CYTry {
Type_privateData *internal(reinterpret_cast<Type_privateData *>(JSObjectGetPrivate(_this)));
CYPool pool;
- sig::Type type;
- type.name = NULL;
- type.flags = 0;
-
- type.primitive = primitive;
- type.data.signature.elements = new(pool) sig::Element[1 + count];
- type.data.signature.count = 1 + count;
+ type.signature.elements = new(pool) sig::Element[1 + count];
+ type.signature.count = 1 + count;
- type.data.signature.elements[0].name = NULL;
- type.data.signature.elements[0].type = internal->type_;
- type.data.signature.elements[0].offset = _not(size_t);
+ type.signature.elements[0].name = NULL;
+ type.signature.elements[0].type = internal->type_;
+ type.signature.elements[0].offset = _not(size_t);
for (size_t i(0); i != count; ++i) {
- sig::Element &element(type.data.signature.elements[i + 1]);
+ sig::Element &element(type.signature.elements[i + 1]);
element.name = NULL;
element.offset = _not(size_t);
element.type = internal->type_;
}
- return CYMakeType(context, &type);
+ return CYMakeType(context, type);
} CYCatch(NULL) }
static JSValueRef Type_callAsFunction_arrayOf(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
if (index == _not(size_t))
throw CYJSError(context, "invalid array size used with Type.arrayOf");
- sig::Type type;
- type.name = NULL;
- type.flags = 0;
-
- type.primitive = sig::array_P;
- type.data.data.type = internal->type_;
- type.data.data.size = index;
-
- return CYMakeType(context, &type);
+ sig::Array type(*internal->type_, index);
+ return CYMakeType(context, type);
} CYCatch(NULL) }
static JSValueRef Type_callAsFunction_blockWith(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) {
- return Type_callAsFunction_$With(context, object, _this, count, arguments, sig::block_P, exception);
+ sig::Block type;
+ return Type_callAsFunction_$With(context, object, _this, count, arguments, type, exception);
}
static JSValueRef Type_callAsFunction_constant(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
throw CYJSError(context, "incorrect number of arguments to Type.constant");
Type_privateData *internal(reinterpret_cast<Type_privateData *>(JSObjectGetPrivate(_this)));
- sig::Type type(*internal->type_);
- type.flags |= JOC_TYPE_CONST;
- return CYMakeType(context, &type);
-} CYCatch(NULL) }
-
-static JSValueRef Type_callAsFunction_long(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
- if (count != 0)
- throw CYJSError(context, "incorrect number of arguments to Type.long");
- Type_privateData *internal(reinterpret_cast<Type_privateData *>(JSObjectGetPrivate(_this)));
-
- sig::Type type(*internal->type_);
-
- switch (type.primitive) {
- case sig::short_P: type.primitive = sig::int_P; break;
- case sig::int_P: type.primitive = sig::long_P; break;
- case sig::long_P: type.primitive = sig::longlong_P; break;
- default: throw CYJSError(context, "invalid type argument to Type.long");
- }
-
- return CYMakeType(context, &type);
-} CYCatch(NULL) }
-
-static JSValueRef Type_callAsFunction_short(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
- if (count != 0)
- throw CYJSError(context, "incorrect number of arguments to Type.short");
- Type_privateData *internal(reinterpret_cast<Type_privateData *>(JSObjectGetPrivate(_this)));
-
- sig::Type type(*internal->type_);
-
- switch (type.primitive) {
- case sig::int_P: type.primitive = sig::short_P; break;
- case sig::long_P: type.primitive = sig::int_P; break;
- case sig::longlong_P: type.primitive = sig::long_P; break;
- default: throw CYJSError(context, "invalid type argument to Type.short");
- }
-
- return CYMakeType(context, &type);
-} CYCatch(NULL) }
-
-static JSValueRef Type_callAsFunction_signed(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
- if (count != 0)
- throw CYJSError(context, "incorrect number of arguments to Type.signed");
- Type_privateData *internal(reinterpret_cast<Type_privateData *>(JSObjectGetPrivate(_this)));
-
- sig::Type type(*internal->type_);
-
- switch (type.primitive) {
- case sig::char_P: case sig::schar_P: case sig::uchar_P: type.primitive = sig::schar_P; break;
- case sig::short_P: case sig::ushort_P: type.primitive = sig::short_P; break;
- case sig::int_P: case sig::uint_P: type.primitive = sig::int_P; break;
- case sig::long_P: case sig::ulong_P: type.primitive = sig::long_P; break;
- case sig::longlong_P: case sig::ulonglong_P: type.primitive = sig::longlong_P; break;
- default: throw CYJSError(context, "invalid type argument to Type.signed");
- }
-
- return CYMakeType(context, &type);
-} CYCatch(NULL) }
-
-static JSValueRef Type_callAsFunction_unsigned(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
- if (count != 0)
- throw CYJSError(context, "incorrect number of arguments to Type.unsigned");
- Type_privateData *internal(reinterpret_cast<Type_privateData *>(JSObjectGetPrivate(_this)));
-
- sig::Type type(*internal->type_);
-
- switch (type.primitive) {
- case sig::char_P: case sig::schar_P: case sig::uchar_P: type.primitive = sig::uchar_P; break;
- case sig::short_P: case sig::ushort_P: type.primitive = sig::ushort_P; break;
- case sig::int_P: case sig::uint_P: type.primitive = sig::uint_P; break;
- case sig::long_P: case sig::ulong_P: type.primitive = sig::ulong_P; break;
- case sig::longlong_P: case sig::ulonglong_P: type.primitive = sig::ulonglong_P; break;
- default: throw CYJSError(context, "invalid type argument to Type.unsigned");
- }
-
- return CYMakeType(context, &type);
+ CYPool pool;
+ sig::Type *type(internal->type_->Copy(pool));
+ type->flags |= JOC_TYPE_CONST;
+ return CYMakeType(context, *type);
} CYCatch(NULL) }
static JSValueRef Type_callAsFunction_functionWith(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) {
- return Type_callAsFunction_$With(context, object, _this, count, arguments, sig::function_P, exception);
+ sig::Function type;
+ return Type_callAsFunction_$With(context, object, _this, count, arguments, type, exception);
}
static JSValueRef Type_callAsFunction_pointerTo(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
throw CYJSError(context, "incorrect number of arguments to Type.pointerTo");
Type_privateData *internal(reinterpret_cast<Type_privateData *>(JSObjectGetPrivate(_this)));
- sig::Type type;
- type.name = NULL;
-
- if (internal->type_->primitive == sig::char_P) {
- type.flags = internal->type_->flags;
- type.primitive = sig::string_P;
- type.data.data.type = NULL;
- type.data.data.size = 0;
- } else {
- type.flags = 0;
- type.primitive = sig::pointer_P;
- type.data.data.type = internal->type_;
- type.data.data.size = 0;
- }
-
- return CYMakeType(context, &type);
+ if (dynamic_cast<sig::Primitive<char> *>(internal->type_) != NULL)
+ return CYMakeType(context, sig::String());
+ else
+ return CYMakeType(context, sig::Pointer(*internal->type_));
} CYCatch(NULL) }
static JSValueRef Type_callAsFunction_withName(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
Type_privateData *internal(reinterpret_cast<Type_privateData *>(JSObjectGetPrivate(_this)));
CYPool pool;
- const char *name(CYPoolCString(pool, context, arguments[0]));
-
- sig::Type type(*internal->type_);
- type.name = name;
- return CYMakeType(context, &type);
+ return CYMakeType(context, *internal->type_->Copy(pool, CYPoolCString(pool, context, arguments[0])));
} CYCatch(NULL) }
static JSValueRef Type_callAsFunction(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
throw CYJSError(context, "incorrect number of arguments to type cast function");
Type_privateData *internal(reinterpret_cast<Type_privateData *>(JSObjectGetPrivate(object)));
- if (internal->type_->primitive == sig::function_P)
- return CYMakeFunctor(context, arguments[0], internal->type_->data.signature);
+ if (sig::Function *function = dynamic_cast<sig::Function *>(internal->type_))
+ return CYMakeFunctor(context, arguments[0], function->signature);
+ CYPool pool;
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);
+ void *value(pool.malloc<void>(ffi->size, ffi->alignment));
+ type->PoolFFI(&pool, context, ffi, value, arguments[0]);
+ return type->FromFFI(context, ffi, value);
} CYCatch(NULL) }
static JSObjectRef Type_callAsConstructor(JSContextRef context, JSObjectRef object, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
Type_privateData *internal(reinterpret_cast<Type_privateData *>(JSObjectGetPrivate(object)));
sig::Type *type(internal->type_);
- size_t length;
+ size_t length(type->Translate(type));
- if (type->primitive != sig::array_P)
- length = _not(size_t);
- else {
- length = type->data.data.size;
- type = type->data.data.type;
- }
-
- JSObjectRef pointer(CYMakePointer(context, NULL, length, type, NULL, NULL));
+ JSObjectRef pointer(CYMakePointer(context, NULL, length, *type, NULL, NULL));
Pointer *value(reinterpret_cast<Pointer *>(JSObjectGetPrivate(pointer)));
- value->value_ = value->pool_->malloc<void>(internal->GetFFI()->size);
- memset(value->value_, 0, internal->GetFFI()->size);
+ ffi_type *ffi(internal->GetFFI());
+ value->value_ = value->pool_->malloc<void>(ffi->size, ffi->alignment);
+ memset(value->value_, 0, ffi->size);
return pointer;
} CYCatch(NULL) }
static JSValueRef CString_callAsFunction_toPointer(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
CString *internal(reinterpret_cast<CString *>(JSObjectGetPrivate(_this)));
-
- sig::Type type;
- type.name = NULL;
- type.flags = 0;
-
- type.primitive = sig::char_P;
- type.data.data.type = NULL;
- type.data.data.size = 0;
-
- return CYMakePointer(context, internal->value_, _not(size_t), &type, NULL, NULL);
+ return CYMakePointer(context, internal->value_, _not(size_t), sig::Primitive<char>(), NULL, NULL);
} CYCatch(NULL) }
static JSValueRef Functor_callAsFunction_$cya(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
CYPool pool;
cy::Functor *internal(reinterpret_cast<cy::Functor *>(JSObjectGetPrivate(_this)));
- sig::Type type;
- type.name = NULL;
- type.flags = 0;
+ sig::Function type;
+ sig::Copy(pool, type.signature, internal->signature_);
- type.primitive = sig::function_P;
- sig::Copy(pool, type.data.signature, internal->signature_);
-
- return CYMakePointer(context, internal->value_, _not(size_t), &type, NULL, NULL);
+ return CYMakePointer(context, internal->value_, _not(size_t), type, NULL, NULL);
} CYCatch(NULL) }
static JSValueRef Pointer_callAsFunction_toPointer(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
JSObjectRef Array(CYGetCachedObject(context, CYJSString("Array_prototype")));
JSObjectRef toCYON(CYCastJSObject(context, CYGetProperty(context, Array, toCYON_s)));
return CYCallAsFunction(context, toCYON, _this, count, arguments);
- } else if (internal->type_->type_ == NULL) pointer: {
- CYLocalPool pool;
- std::ostringstream str;
-
- sig::Type type;
- type.name = NULL;
- type.flags = 0;
-
- type.primitive = sig::pointer_P;
- type.data.data.type = internal->type_->type_;
- type.data.data.size = 0;
-
- CYOptions options;
- CYOutput output(*str.rdbuf(), options);
- (new(pool) CYTypeExpression(Decode(pool, &type)))->Output(output, CYNoFlags);
-
- str << "(" << internal->value_ << ")";
- std::string value(str.str());
- return CYCastJSValue(context, CYJSString(CYUTF8String(value.c_str(), value.size())));
- } else try {
+ }
+
+ try {
JSValueRef value(CYGetProperty(context, _this, cyi_s));
- if (JSValueIsUndefined(context, value))
- goto pointer;
- CYPool pool;
- return CYCastJSValue(context, pool.strcat("&", CYPoolCCYON(pool, context, value, objects), NULL));
+ if (!JSValueIsUndefined(context, value)) {
+ CYPool pool;
+ return CYCastJSValue(context, pool.strcat("&", CYPoolCCYON(pool, context, value, objects), NULL));
+ }
} catch (const CYException &e) {
- goto pointer;
+ // XXX: it might be interesting to include this error
}
+
+ CYLocalPool pool;
+ std::ostringstream str;
+
+ sig::Pointer type(*internal->type_->type_);
+
+ CYOptions options;
+ CYOutput output(*str.rdbuf(), options);
+ (new(pool) CYTypeExpression(CYDecodeType(pool, &type)))->Output(output, CYNoFlags);
+
+ str << "(" << internal->value_ << ")";
+ std::string value(str.str());
+ return CYCastJSValue(context, CYJSString(CYUTF8String(value.c_str(), value.size())));
} CYCatch(NULL) }
static JSValueRef CString_getProperty_length(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { CYTry {
} CYCatch(NULL) }
static JSValueRef CString_getProperty_type(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { CYTry {
- sig::Type type;
- type.name = NULL;
- type.flags = 0;
-
- type.primitive = sig::char_P;
- type.data.data.type = NULL;
- type.data.data.size = 0;
-
- return CYMakeType(context, &type);
+ return CYMakeType(context, sig::String());
} CYCatch(NULL) }
static JSValueRef Pointer_getProperty_type(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { CYTry {
Pointer *internal(reinterpret_cast<Pointer *>(JSObjectGetPrivate(object)));
- return CYMakeType(context, internal->type_->type_);
+ sig::Pointer type(*internal->type_->type_);
+ return CYMakeType(context, type);
} CYCatch(NULL) }
static JSValueRef CString_callAsFunction_toCYON(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
Pointer *internal(reinterpret_cast<Pointer *>(JSObjectGetPrivate(_this)));
const char *string(static_cast<const char *>(internal->value_));
std::ostringstream str;
- str << "&";
- CYStringify(str, string, strlen(string), true);
+ if (string == NULL)
+ str << "NULL";
+ else {
+ str << "&";
+ CYStringify(str, string, strlen(string), true);
+ }
std::string value(str.str());
return CYCastJSValue(context, CYJSString(CYUTF8String(value.c_str(), value.size())));
} CYCatch(NULL) }
static JSValueRef Type_getProperty_name(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { CYTry {
Type_privateData *internal(reinterpret_cast<Type_privateData *>(JSObjectGetPrivate(object)));
- return CYCastJSValue(context, internal->type_->name);
+ return CYCastJSValue(context, internal->type_->GetName());
} CYCatch(NULL) }
static JSValueRef Type_getProperty_size(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { CYTry {
std::stringbuf out;
CYOptions options;
CYOutput output(out, options);
- (new(pool) CYTypeExpression(Decode(pool, internal->type_)))->Output(output, CYNoFlags);
+ (new(pool) CYTypeExpression(CYDecodeType(pool, internal->type_)))->Output(output, CYNoFlags);
return CYCastJSValue(context, CYJSString(out.str().c_str()));
} CYCatch(NULL) }
{NULL, NULL, 0}
};
+static JSStaticValue Struct_staticValues[2] = {
+ {"type", &Struct_getProperty_type, NULL, kJSPropertyAttributeReadOnly | kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
+ {NULL, NULL, NULL, 0}
+};
+
static JSStaticFunction Functor_staticFunctions[5] = {
{"$cya", &Functor_callAsFunction_$cya, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
{"toCYON", &CYValue_callAsFunction_toCYON, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
{NULL, NULL, NULL, 0}
};
-static JSStaticFunction Type_staticFunctions[14] = {
+static JSStaticFunction Type_staticFunctions[10] = {
{"arrayOf", &Type_callAsFunction_arrayOf, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
{"blockWith", &Type_callAsFunction_blockWith, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
{"constant", &Type_callAsFunction_constant, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
{"functionWith", &Type_callAsFunction_functionWith, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
- {"long", &Type_callAsFunction_long, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
{"pointerTo", &Type_callAsFunction_pointerTo, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
- {"short", &Type_callAsFunction_short, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
- {"signed", &Type_callAsFunction_signed, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
{"withName", &Type_callAsFunction_withName, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
{"toCYON", &Type_callAsFunction_toCYON, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
{"toJSON", &Type_callAsFunction_toJSON, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
{"toString", &Type_callAsFunction_toString, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
- {"unsigned", &Type_callAsFunction_unsigned, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
{NULL, NULL, 0}
};
definition = kJSClassDefinitionEmpty;
definition.className = "Struct";
definition.staticFunctions = Struct_staticFunctions;
+ definition.staticValues = Struct_staticValues;
definition.getProperty = &Struct_getProperty;
definition.setProperty = &Struct_setProperty;
definition.getPropertyNames = &Struct_getPropertyNames;
CYSetProperty(context, cache, CYJSString("NULL"), CYJSNull(context), kJSPropertyAttributeDontEnum);
- CYSetProperty(context, cache, CYJSString("bool"), CYMakeType(context, sig::boolean_P), kJSPropertyAttributeDontEnum);
- CYSetProperty(context, cache, CYJSString("char"), CYMakeType(context, sig::char_P), kJSPropertyAttributeDontEnum);
- CYSetProperty(context, cache, CYJSString("short"), CYMakeType(context, sig::short_P), kJSPropertyAttributeDontEnum);
- CYSetProperty(context, cache, CYJSString("int"), CYMakeType(context, sig::int_P), kJSPropertyAttributeDontEnum);
- CYSetProperty(context, cache, CYJSString("long"), CYMakeType(context, sig::long_P), kJSPropertyAttributeDontEnum);
- CYSetProperty(context, cache, CYJSString("float"), CYMakeType(context, sig::float_P), kJSPropertyAttributeDontEnum);
- CYSetProperty(context, cache, CYJSString("double"), CYMakeType(context, sig::double_P), kJSPropertyAttributeDontEnum);
+ CYSetProperty(context, cache, CYJSString("bool"), CYMakeType(context, sig::Primitive<bool>()), kJSPropertyAttributeDontEnum);
+ CYSetProperty(context, cache, CYJSString("char"), CYMakeType(context, sig::Primitive<char>()), kJSPropertyAttributeDontEnum);
+ CYSetProperty(context, cache, CYJSString("schar"), CYMakeType(context, sig::Primitive<signed char>()), kJSPropertyAttributeDontEnum);
+ CYSetProperty(context, cache, CYJSString("uchar"), CYMakeType(context, sig::Primitive<unsigned char>()), kJSPropertyAttributeDontEnum);
+
+ CYSetProperty(context, cache, CYJSString("short"), CYMakeType(context, sig::Primitive<short>()), kJSPropertyAttributeDontEnum);
+ CYSetProperty(context, cache, CYJSString("int"), CYMakeType(context, sig::Primitive<int>()), kJSPropertyAttributeDontEnum);
+ CYSetProperty(context, cache, CYJSString("long"), CYMakeType(context, sig::Primitive<long>()), kJSPropertyAttributeDontEnum);
+ CYSetProperty(context, cache, CYJSString("longlong"), CYMakeType(context, sig::Primitive<long long>()), kJSPropertyAttributeDontEnum);
+
+ CYSetProperty(context, cache, CYJSString("ushort"), CYMakeType(context, sig::Primitive<unsigned short>()), kJSPropertyAttributeDontEnum);
+ CYSetProperty(context, cache, CYJSString("uint"), CYMakeType(context, sig::Primitive<unsigned int>()), kJSPropertyAttributeDontEnum);
+ CYSetProperty(context, cache, CYJSString("ulong"), CYMakeType(context, sig::Primitive<unsigned long>()), kJSPropertyAttributeDontEnum);
+ CYSetProperty(context, cache, CYJSString("ulonglong"), CYMakeType(context, sig::Primitive<unsigned long long>()), kJSPropertyAttributeDontEnum);
+
+ CYSetProperty(context, cache, CYJSString("float"), CYMakeType(context, sig::Primitive<float>()), kJSPropertyAttributeDontEnum);
+ CYSetProperty(context, cache, CYJSString("double"), CYMakeType(context, sig::Primitive<double>()), kJSPropertyAttributeDontEnum);
for (CYHook *hook : GetHooks())
if (hook->SetupContext != NULL)
projects / cycript.git / blobdiff