X-Git-Url: https://git.saurik.com/cycript.git/blobdiff_plain/574d47203e63ac4a85f0d609098118d19e6bbf09..2c4a8bb6222b88ff96fbf25372179646ce15f706:/Execute.cpp diff --git a/Execute.cpp b/Execute.cpp index d25f7b6..18bdce6 100644 --- a/Execute.cpp +++ b/Execute.cpp @@ -1,5 +1,5 @@ -/* Cycript - Optimizing JavaScript Compiler/Runtime - * Copyright (C) 2009-2015 Jay Freeman (saurik) +/* Cycript - The Truly Universal Scripting Language + * Copyright (C) 2009-2016 Jay Freeman (saurik) */ /* GNU Affero General Public License, Version 3 {{{ */ @@ -41,6 +41,7 @@ #include "sig/parse.hpp" #include "sig/ffi_type.hpp" +#include "Bridge.hpp" #include "Code.hpp" #include "Decode.hpp" #include "Error.hpp" @@ -94,7 +95,12 @@ void CYSetProperty(JSContextRef context, JSObjectRef object, JSStringRef name, J CYSetProperty(context, object, name, JSObjectMakeFunctionWithCallback(context, name, callback), attributes); } +JSObjectRef CYGetPrototype(JSContextRef context, JSObjectRef object) { + return CYCastJSObject(context, JSObjectGetPrototype(context, object)); +} + void CYSetPrototype(JSContextRef context, JSObjectRef object, JSValueRef value) { + _assert(!JSValueIsUndefined(context, value)); JSObjectSetPrototype(context, object, value); _assert(CYIsStrictEqual(context, JSObjectGetPrototype(context, object), value)); } @@ -120,6 +126,10 @@ JSStringRef CYCopyJSString(CYUTF8String value) { } } +JSStringRef CYCopyJSString(const std::string &value) { + return CYCopyJSString(CYUTF8String(value.c_str(), value.size())); +} + JSStringRef CYCopyJSString(CYUTF16String value) { return JSStringCreateWithCharacters(value.data, value.size); } @@ -130,10 +140,22 @@ JSStringRef CYCopyJSString(JSContextRef context, JSValueRef value) { return _jsccall(JSValueToStringCopy, context, value); } -static CYUTF16String CYCastUTF16String(JSStringRef value) { +CYUTF16String CYCastUTF16String(JSStringRef value) { return CYUTF16String(JSStringGetCharactersPtr(value), JSStringGetLength(value)); } +const char *CYPoolCString(CYPool &pool, CYUTF8String utf8) { + return pool.strndup(utf8.data, utf8.size); +} + +CYUTF8String CYPoolUTF8String(CYPool &pool, CYUTF8String utf8) { + return {pool.strndup(utf8.data, utf8.size), utf8.size}; +} + +_visible CYUTF8String CYPoolUTF8String(CYPool &pool, const std::string &value) { + return {pool.strndup(value.data(), value.size()), value.size()}; +} + CYUTF8String CYPoolUTF8String(CYPool &pool, JSContextRef context, JSStringRef value) { return CYPoolUTF8String(pool, CYCastUTF16String(value)); } @@ -156,29 +178,27 @@ size_t CYGetIndex(CYPool &pool, JSContextRef context, JSStringRef value) { static JSObjectRef (*JSObjectMakeArray$)(JSContextRef, size_t, const JSValueRef[], JSValueRef *); -static JSObjectRef CYObjectMakeArray(JSContextRef context, size_t length, const JSValueRef values[]) { +JSObjectRef CYObjectMakeArray(JSContextRef context, size_t length, const JSValueRef values[]) { if (JSObjectMakeArray$ != NULL) return _jsccall(*JSObjectMakeArray$, context, length, values); - else { - JSObjectRef Array(CYGetCachedObject(context, CYJSString("Array"))); - JSValueRef value(CYCallAsFunction(context, Array, NULL, length, values)); - return CYCastJSObject(context, value); - } + JSObjectRef Array(CYGetCachedObject(context, CYJSString("Array"))); + bool wat(length == 1 && JSValueGetType(context, values[0]) == kJSTypeNumber); + JSValueRef value(CYCallAsFunction(context, Array, NULL, wat ? 0 : length, values)); + JSObjectRef object(CYCastJSObject(context, value)); + if (wat) CYArrayPush(context, object, 1, values); + return object; } static JSClassRef All_; -static JSClassRef Context_; -static JSClassRef CArray_; -static JSClassRef CString_; -JSClassRef Functor_; +JSClassRef cy::Functor::Class_; static JSClassRef Global_; -static JSClassRef Pointer_; -static JSClassRef Struct_; JSStringRef Array_s; +JSStringRef constructor_s; JSStringRef cy_s; JSStringRef cyi_s; JSStringRef cyt_s; +JSStringRef cyt__s; JSStringRef length_s; JSStringRef message_s; JSStringRef name_s; @@ -198,6 +218,8 @@ static JSStringRef Result_; void CYFinalize(JSObjectRef object) { CYData *internal(reinterpret_cast<CYData *>(JSObjectGetPrivate(object))); + if (internal == NULL) + return; _assert(internal->count_ != _not(unsigned)); if (--internal->count_ == 0) delete internal; @@ -208,10 +230,8 @@ sig::Type *Structor_(CYPool &pool, sig::Aggregate *aggregate) { return aggregate; } -JSClassRef Type_privateData::Class_; - struct Context : - CYData + CYRoot { JSGlobalContextRef context_; @@ -222,13 +242,16 @@ struct Context : }; struct CArray : - CYOwned + CYRoot { + void *value_; + CYProtect owner_; Type_privateData *type_; size_t length_; - CArray(void *value, JSContextRef context, JSObjectRef owner, size_t length, const sig::Type &type, ffi_type *ffi) : - CYOwned(value, context, owner), + CArray(void *value, size_t length, const sig::Type &type, ffi_type *ffi, JSContextRef context, JSObjectRef owner) : + value_(value), + owner_(context, owner), type_(new(*pool_) Type_privateData(type, ffi)), length_(length) { @@ -236,77 +259,61 @@ struct CArray : }; struct CString : - CYOwned + CYRoot { + char *value_; + CYProtect owner_; + CString(char *value, JSContextRef context, JSObjectRef owner) : - CYOwned(value, context, owner) + value_(value), + owner_(context, owner) { } }; struct Pointer : - CYOwned + CYRoot { + void *value_; + CYProtect owner_; Type_privateData *type_; - Pointer(void *value, JSContextRef context, JSObjectRef owner, const sig::Type &type) : - CYOwned(value, context, owner), + Pointer(void *value, const sig::Type &type, JSContextRef context, JSObjectRef owner) : + value_(value), + owner_(context, owner), type_(new(*pool_) Type_privateData(type)) { } - Pointer(void *value, JSContextRef context, JSObjectRef owner, const char *encoding) : - CYOwned(value, context, owner), + Pointer(void *value, const char *encoding, JSContextRef context, JSObjectRef owner) : + value_(value), + owner_(context, owner), type_(new(*pool_) Type_privateData(encoding)) { } }; struct Struct_privateData : - CYOwned + CYRoot { + void *value_; + CYProtect owner_; Type_privateData *type_; - Struct_privateData(void *value, JSContextRef context, JSObjectRef owner, const sig::Type &type, ffi_type *ffi) : - CYOwned(value, context, owner), + Struct_privateData(void *value, const sig::Type &type, ffi_type *ffi, JSContextRef context, JSObjectRef owner) : + value_(value), + owner_(context, owner), type_(new(*pool_) Type_privateData(type, ffi)) { + if (owner == NULL) { + size_t size(ffi->size); + void *copy(pool_->malloc<void>(size, ffi->alignment)); + memcpy(copy, value_, size); + value_ = copy; + } } }; -JSObjectRef CYMakeCArray(JSContextRef context, void *data, size_t length, const sig::Type &type, ffi_type *ffi, JSObjectRef owner) { - CArray *internal(new CArray(data, context, owner, length, type, ffi)); - - if (owner == NULL) { - size_t size(ffi->size * length); - void *copy(internal->pool_->malloc<void>(size, ffi->alignment)); - memcpy(copy, internal->value_, size); - internal->value_ = copy; - } - - return JSObjectMake(context, CArray_, internal); -} - -JSObjectRef CYMakeCString(JSContextRef context, char *pointer, JSObjectRef owner) { - CString *internal(new CString(pointer, context, owner)); - if (owner == NULL) - internal->value_ = internal->pool_->strdup(static_cast<const char *>(internal->value_)); - return JSObjectMake(context, CString_, internal); -} - -JSObjectRef CYMakeStruct(JSContextRef context, void *data, const sig::Type &type, ffi_type *ffi, JSObjectRef owner) { - Struct_privateData *internal(new Struct_privateData(data, context, owner, type, ffi)); - - if (owner == NULL) { - size_t size(ffi->size); - void *copy(internal->pool_->malloc<void>(size, ffi->alignment)); - memcpy(copy, internal->value_, size); - internal->value_ = copy; - } - - return JSObjectMake(context, Struct_, internal); -} - static void *CYCastSymbol(const char *name) { for (CYHook *hook : GetHooks()) if (hook->CastSymbol != NULL) @@ -329,6 +336,7 @@ JSValueRef CYCastJSValue(JSContextRef context, double value) { return JSValueMakeNumber(context, static_cast<double>(value)); \ } +CYCastJSValue_(long double) CYCastJSValue_(signed short int) CYCastJSValue_(unsigned short int) CYCastJSValue_(signed int) @@ -338,6 +346,11 @@ CYCastJSValue_(unsigned long int) CYCastJSValue_(signed long long int) CYCastJSValue_(unsigned long long int) +#ifdef __SIZEOF_INT128__ +CYCastJSValue_(signed __int128) +CYCastJSValue_(unsigned __int128) +#endif + JSValueRef CYJSUndefined(JSContextRef context) { return JSValueMakeUndefined(context); } @@ -399,43 +412,6 @@ 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); @@ -451,6 +427,22 @@ static JSValueRef System_print(JSContextRef context, JSObjectRef object, JSObjec return CYJSUndefined(context); } CYCatch(NULL) } +static JSValueRef Global_print(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry { + FILE *file(stdout); + CYPool pool; + + for (size_t i(0); i != count; ++i) { + if (i != 0) + fputc(' ', file); + CYUTF8String string(CYPoolUTF8String(pool, context, CYJSString(context, arguments[i]))); + fwrite(string.data, string.size, 1, file); + } + + fputc('\n', file); + fflush(file); + return CYJSUndefined(context); +} CYCatch(NULL) } + static void (*JSSynchronousGarbageCollectForDebugging$)(JSContextRef); _visible void CYGarbageCollect(JSContextRef context) { @@ -460,8 +452,7 @@ _visible void CYGarbageCollect(JSContextRef context) { static JSValueRef Cycript_compile_callAsFunction(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry { CYPool pool; CYUTF8String before(CYPoolUTF8String(pool, context, CYJSString(context, arguments[0]))); - std::stringbuf value(std::string(before.data, before.size)); - CYUTF8String after(CYPoolCode(pool, value)); + CYUTF8String after(CYPoolCode(pool, before)); return CYCastJSValue(context, CYJSString(after)); } CYCatch_(NULL, "SyntaxError") } @@ -489,7 +480,7 @@ const char *CYPoolCCYON(CYPool &pool, JSContextRef context, JSValueRef value, st case kJSTypeString: { std::ostringstream str; CYUTF8String string(CYPoolUTF8String(pool, context, CYJSString(context, value))); - CYStringify(str, string.data, string.size); + CYStringify(str, string.data, string.size, CYStringifyModeCycript); std::string value(str.str()); return pool.strmemdup(value.c_str(), value.size()); } break; @@ -544,6 +535,22 @@ const char *CYPoolCCYON(CYPool &pool, JSContextRef context, JSObjectRef object, std::ostringstream str; + JSValueRef value(CYGetProperty(context, object, constructor_s)); + if (JSValueIsObject(context, value)) { + JSObjectRef constructor(CYCastJSObject(context, value)); + JSValueRef theory(CYGetProperty(context, constructor, prototype_s)); + JSValueRef practice(JSObjectGetPrototype(context, object)); + + if (CYIsStrictEqual(context, theory, practice)) { + JSValueRef name(CYGetProperty(context, constructor, name_s)); + if (!JSValueIsUndefined(context, name)) { + auto utf8(CYPoolUTF8String(pool, context, CYJSString(context, name))); + if (utf8 != "Object") + str << "new" << ' ' << utf8; + } + } + } + str << '{'; // XXX: this is, sadly, going to leak @@ -563,7 +570,7 @@ const char *CYPoolCCYON(CYPool &pool, JSContextRef context, JSObjectRef object, if (CYIsKey(string)) str << string.data; else - CYStringify(str, string.data, string.size); + CYStringify(str, string.data, string.size, CYStringifyModeLegacy); str << ':'; @@ -634,26 +641,23 @@ static JSValueRef String_callAsFunction_toCYON(JSContextRef context, JSObjectRef std::ostringstream str; CYUTF8String string(CYPoolUTF8String(pool, context, CYJSString(context, _this))); - CYStringify(str, string.data, string.size); + CYStringify(str, string.data, string.size, CYStringifyModeCycript); std::string value(str.str()); return CYCastJSValue(context, CYJSString(CYUTF8String(value.c_str(), value.size()))); } CYCatch(NULL) } JSObjectRef CYMakePointer(JSContextRef context, void *pointer, const 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, const char *encoding, JSObjectRef owner) { - Pointer *internal(new Pointer(pointer, context, owner, encoding)); - return JSObjectMake(context, Pointer_, internal); + return CYPrivate<Pointer>::Make(context, pointer, type, context, owner); } -static JSObjectRef CYMakeFunctor(JSContextRef context, void (*function)(), bool variadic, const sig::Signature &signature) { - return JSObjectMake(context, Functor_, new cy::Functor(function, variadic, signature)); +static JSValueRef CYMakeFunctor(JSContextRef context, void (*function)(), bool variadic, const sig::Signature &signature) { + if (function == NULL) + return CYJSNull(context); + return JSObjectMake(context, cy::Functor::Class_, new cy::Functor(function, variadic, signature)); } +// XXX: remove this, as it is really stupid static JSObjectRef CYMakeFunctor(JSContextRef context, const char *symbol, const char *encoding) { void (*function)()(reinterpret_cast<void (*)()>(CYCastSymbol(symbol))); if (function == NULL) @@ -661,13 +665,31 @@ static JSObjectRef CYMakeFunctor(JSContextRef context, const char *symbol, const cy::Functor *internal(new cy::Functor(function, encoding)); ++internal->count_; - return JSObjectMake(context, Functor_, internal); + return JSObjectMake(context, cy::Functor::Class_, internal); } -static bool CYGetOffset(CYPool &pool, JSContextRef context, JSStringRef value, ssize_t &index) { +bool CYGetOffset(CYPool &pool, JSContextRef context, JSStringRef value, ssize_t &index) { return CYGetOffset(CYPoolCString(pool, context, value), index); } +// XXX: this is a horrible back added for CFType +void *CYCastPointerEx_(JSContextRef context, JSObjectRef value) { + JSObjectRef object((JSObjectRef) value); + if (JSValueIsObjectOfClass(context, value, CYPrivate<Pointer>::Class_)) { + Pointer *internal(reinterpret_cast<Pointer *>(JSObjectGetPrivate(object))); + return internal->value_; + } + + JSValueRef toPointer(CYGetProperty(context, object, toPointer_s)); + if (CYIsCallable(context, toPointer)) { + JSValueRef value(CYCallAsFunction(context, (JSObjectRef) toPointer, object, 0, NULL)); + _assert(value != NULL); + return CYCastPointer_(context, value); + } + + return NULL; +} + void *CYCastPointer_(JSContextRef context, JSValueRef value, bool *guess) { if (value == NULL) return NULL; @@ -676,7 +698,7 @@ void *CYCastPointer_(JSContextRef context, JSValueRef value, bool *guess) { return NULL; case kJSTypeObject: { JSObjectRef object((JSObjectRef) value); - if (JSValueIsObjectOfClass(context, value, Pointer_)) { + if (JSValueIsObjectOfClass(context, value, CYPrivate<Pointer>::Class_)) { Pointer *internal(reinterpret_cast<Pointer *>(JSObjectGetPrivate(object))); return internal->value_; } @@ -702,6 +724,8 @@ void *CYCastPointer_(JSContextRef context, JSValueRef value, bool *guess) { } } +static JSValueRef FunctionAdapter_(JSContextRef context, size_t count, JSValueRef values[], JSObjectRef function); + namespace sig { // XXX: this is somehow not quite a template :/ @@ -717,22 +741,43 @@ void Primitive<Type_>::PoolFFI(CYPool *pool, JSContextRef context, ffi_type *ffi *reinterpret_cast<Type_ *>(data) = CYCastDouble(context, value); \ } -CYPoolFFI_(char) -CYPoolFFI_(double) +CYPoolFFI_(wchar_t) CYPoolFFI_(float) +CYPoolFFI_(double) +CYPoolFFI_(long double) + 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) +#ifdef __SIZEOF_INT128__ +CYPoolFFI_(signed __int128) +CYPoolFFI_(unsigned __int128) +#endif + +template <> +void Primitive<char>::PoolFFI(CYPool *pool, JSContextRef context, ffi_type *ffi, void *data, JSValueRef value) const { + if (JSValueGetType(context, value) != kJSTypeString) + *reinterpret_cast<char *>(data) = CYCastDouble(context, value); + else { + CYJSString script(context, value); + auto string(CYCastUTF16String(script)); + _assert(string.size == 1); + _assert((string.data[0] & 0xff) == string.data[0]); + *reinterpret_cast<char *>(data) = string.data[0]; + } +} + void Void::PoolFFI(CYPool *pool, JSContextRef context, ffi_type *ffi, void *data, JSValueRef value) const { - _assert(false); + _assert(JSValueIsUndefined(context, value)); } void Unknown::PoolFFI(CYPool *pool, JSContextRef context, ffi_type *ffi, void *data, JSValueRef value) const { @@ -750,17 +795,11 @@ void Bits::PoolFFI(CYPool *pool, JSContextRef context, ffi_type *ffi, void *data _assert(false); } -static void CYArrayCopy(CYPool *pool, JSContextRef context, uint8_t *base, size_t length, const sig::Type &type, ffi_type *ffi, JSValueRef value, JSObjectRef object) { +static void CYArrayCopy(CYPool *pool, JSContextRef context, uint8_t *base, size_t length, const sig::Type &type, ffi_type *ffi, JSObjectRef object) { for (size_t index(0); index != length; ++index) { - JSValueRef rhs; - if (object == NULL) - rhs = value; - else { - rhs = CYGetProperty(context, object, index); - if (JSValueIsUndefined(context, rhs)) - throw CYJSError(context, "unable to extract array value"); - } - + JSValueRef rhs(CYGetProperty(context, object, index)); + if (JSValueIsUndefined(context, rhs)) + throw CYJSError(context, "unable to extract array value"); type.PoolFFI(pool, context, ffi, base, rhs); base += ffi->size; } @@ -771,13 +810,20 @@ void Pointer::PoolFFI(CYPool *pool, JSContextRef context, ffi_type *ffi, void *d *reinterpret_cast<void **>(data) = CYCastPointer<void *>(context, value, &guess); if (!guess || pool == NULL || !JSValueIsObject(context, value)) return; + JSObjectRef object(CYCastJSObject(context, value)); - if (CYHasProperty(context, object, length_s)) { + + if (sig::Function *function = dynamic_cast<sig::Function *>(&type)) { + _assert(!function->variadic); + auto internal(CYMakeFunctor_(context, object, function->signature, &FunctionAdapter_)); + // XXX: see notes in Library.cpp about needing to leak + *reinterpret_cast<void (**)()>(data) = internal->value_; + } else if (CYHasProperty(context, object, length_s)) { size_t length(CYArrayLength(context, object)); ffi_type *element(type.GetFFI(*pool)); size_t size(element->size * length); uint8_t *base(pool->malloc<uint8_t>(size, element->alignment)); - CYArrayCopy(pool, context, base, length, type, element, value, object); + CYArrayCopy(pool, context, base, length, type, element, object); *reinterpret_cast<void **>(data) = base; } } @@ -786,13 +832,18 @@ void Array::PoolFFI(CYPool *pool, JSContextRef context, ffi_type *ffi, void *dat if (size == 0) return; uint8_t *base(reinterpret_cast<uint8_t *>(data)); - JSObjectRef object(JSValueIsObject(context, value) ? (JSObjectRef) value : NULL); - CYArrayCopy(pool, context, base, size, type, ffi->elements[0], value, object); + CYArrayCopy(pool, context, base, size, type, ffi->elements[0], CYCastJSObject(context, value)); +} + +void Enum::PoolFFI(CYPool *pool, JSContextRef context, ffi_type *ffi, void *data, JSValueRef value) const { + return type.PoolFFI(pool, context, ffi, data, value); } void Aggregate::PoolFFI(CYPool *pool, JSContextRef context, ffi_type *ffi, void *data, JSValueRef value) const { _assert(!overlap); + _assert(signature.count != _not(size_t)); + size_t offset(0); 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) { @@ -814,8 +865,9 @@ void Aggregate::PoolFFI(CYPool *pool, JSContextRef context, ffi_type *ffi, void } } - element->type->PoolFFI(pool, context, field, base, rhs); - base += field->size; + element->type->PoolFFI(pool, context, field, base + offset, rhs); + offset += field->size; + CYAlign(offset, field->alignment); } } @@ -823,26 +875,59 @@ void Function::PoolFFI(CYPool *pool, JSContextRef context, ffi_type *ffi, void * _assert(false); } +// XXX: this code is getting worse, not better :/ + #define CYFromFFI_(Type_) \ template <> \ +JSValueRef Primitive<Type_>::FromFFI(JSContextRef context, ffi_type *ffi, void *data, bool initialize, JSObjectRef owner) const { \ + JSValueRef value(CYCastJSValue(context, *reinterpret_cast<Type_ *>(data))); \ + JSObjectRef typed(_jsccall(JSObjectCallAsConstructor, context, CYGetCachedObject(context, CYJSString("Number")), 1, &value)); \ + CYSetProperty(context, typed, cyt__s, CYMakeType(context, *this), kJSPropertyAttributeDontEnum); \ + return typed; \ +} + +#define CYFromFFI_2(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_(wchar_t) CYFromFFI_(float) -CYFromFFI_(signed char) -CYFromFFI_(signed int) +CYFromFFI_(double) +CYFromFFI_(long double) + +CYFromFFI_2(signed char) +CYFromFFI_2(signed int) CYFromFFI_(signed long int) CYFromFFI_(signed long long int) -CYFromFFI_(signed short int) -CYFromFFI_(unsigned char) -CYFromFFI_(unsigned int) +CYFromFFI_2(signed short int) + +CYFromFFI_2(unsigned char) +CYFromFFI_2(unsigned int) CYFromFFI_(unsigned long int) CYFromFFI_(unsigned long long int) -CYFromFFI_(unsigned short int) +CYFromFFI_2(unsigned short int) + +#ifdef __SIZEOF_INT128__ +CYFromFFI_(signed __int128) +CYFromFFI_(unsigned __int128) +#endif + +template <> +JSValueRef Primitive<bool>::FromFFI(JSContextRef context, ffi_type *ffi, void *data, bool initialize, JSObjectRef owner) const { + return CYCastJSValue(context, *reinterpret_cast<bool *>(data)); +} + +template <> +JSValueRef Primitive<char>::FromFFI(JSContextRef context, ffi_type *ffi, void *data, bool initialize, JSObjectRef owner) const { + uint16_t string(uint8_t(*reinterpret_cast<char *>(data))); + JSValueRef value(CYCastJSValue(context, CYJSString(CYUTF16String(&string, 1)))); + JSObjectRef typed(_jsccall(JSObjectCallAsConstructor, context, CYGetCachedObject(context, CYJSString("String")), 1, &value)); + CYSetProperty(context, typed, cyt_s, CYMakeType(context, sig::Primitive<char>()), kJSPropertyAttributeDontEnum); + CYSetPrototype(context, typed, CYGetCachedValue(context, CYJSString("Character_prototype"))); + return typed; +} JSValueRef Void::FromFFI(JSContextRef context, ffi_type *ffi, void *data, bool initialize, JSObjectRef owner) const { return CYJSUndefined(context); @@ -854,7 +939,7 @@ JSValueRef Unknown::FromFFI(JSContextRef context, ffi_type *ffi, void *data, boo 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 CYPrivate<CString>::Make(context, value, context, owner); return CYJSNull(context); } @@ -869,11 +954,17 @@ JSValueRef Pointer::FromFFI(JSContextRef context, ffi_type *ffi, void *data, boo } JSValueRef Array::FromFFI(JSContextRef context, ffi_type *ffi, void *data, bool initialize, JSObjectRef owner) const { - return CYMakeCArray(context, data, size, type, ffi->elements[0], owner); + return CYPrivate<CArray>::Make(context, data, size, type, ffi->elements[0], context, owner); +} + +JSValueRef Enum::FromFFI(JSContextRef context, ffi_type *ffi, void *data, bool initialize, JSObjectRef owner) const { + return type.FromFFI(context, ffi, data, initialize, owner); } JSValueRef Aggregate::FromFFI(JSContextRef context, ffi_type *ffi, void *data, bool initialize, JSObjectRef owner) const { - return CYMakeStruct(context, data, *this, ffi, owner); + _assert(!overlap); + _assert(signature.count != _not(size_t)); + return CYPrivate<Struct_privateData>::Make(context, data, *this, ffi, context, owner); } JSValueRef Function::FromFFI(JSContextRef context, ffi_type *ffi, void *data, bool initialize, JSObjectRef owner) const { @@ -885,7 +976,7 @@ JSValueRef Function::FromFFI(JSContextRef context, ffi_type *ffi, void *data, bo void CYExecuteClosure(ffi_cif *cif, void *result, void **arguments, void *arg) { Closure_privateData *internal(reinterpret_cast<Closure_privateData *>(arg)); - JSContextRef context(internal->context_); + JSContextRef context(internal->function_); size_t count(internal->cif_.nargs); JSValueRef values[count]; @@ -894,8 +985,7 @@ void CYExecuteClosure(ffi_cif *cif, void *result, void **arguments, void *arg) { 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_)); - if (internal->cif_.rtype != &ffi_type_void) - internal->signature_.elements[0].type->PoolFFI(NULL, context, internal->cif_.rtype, result, value); + 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) { @@ -924,7 +1014,7 @@ Closure_privateData *CYMakeFunctor_(JSContextRef context, JSObjectRef function, _assert(status == FFI_OK); internal->pool_->atexit(&CYFreeFunctor, writable); - internal->value_ = executable; + internal->value_ = reinterpret_cast<void (*)()>(executable); #else ffi_closure *closure((ffi_closure *) _syscall(mmap( NULL, sizeof(ffi_closure), @@ -938,7 +1028,7 @@ Closure_privateData *CYMakeFunctor_(JSContextRef context, JSObjectRef function, _syscall(mprotect(closure, sizeof(*closure), PROT_READ | PROT_EXEC)); internal->pool_->atexit(&CYFreeFunctor, closure); - internal->value_ = closure; + internal->value_ = reinterpret_cast<void (*)()>(closure); #endif return internal; @@ -946,7 +1036,7 @@ Closure_privateData *CYMakeFunctor_(JSContextRef context, JSObjectRef function, static JSObjectRef CYMakeFunctor(JSContextRef context, JSObjectRef function, const sig::Signature &signature) { Closure_privateData *internal(CYMakeFunctor_(context, function, signature, &FunctionAdapter_)); - JSObjectRef object(JSObjectMake(context, Functor_, internal)); + JSObjectRef object(JSObjectMake(context, cy::Functor::Class_, internal)); // XXX: see above notes about needing to leak JSValueProtect(CYGetJSContext(context), object); return object; @@ -960,7 +1050,7 @@ JSObjectRef CYGetCachedObject(JSContextRef context, JSStringRef name) { return CYCastJSObject(context, CYGetCachedValue(context, name)); } -static JSObjectRef CYMakeFunctor(JSContextRef context, JSValueRef value, bool variadic, const sig::Signature &signature) { +static JSValueRef CYMakeFunctor(JSContextRef context, JSValueRef value, bool variadic, const sig::Signature &signature) { JSObjectRef Function(CYGetCachedObject(context, CYJSString("Function"))); bool function(_jsccall(JSValueIsInstanceOfConstructor, context, value, Function)); @@ -976,26 +1066,29 @@ static JSObjectRef CYMakeFunctor(JSContextRef context, JSValueRef value, bool va static JSValueRef CString_getProperty(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { CYTry { CYPool pool; CString *internal(reinterpret_cast<CString *>(JSObjectGetPrivate(object))); - char *string(static_cast<char *>(internal->value_)); ssize_t offset; - if (!CYGetOffset(pool, context, property, offset)) + if (JSStringIsEqualToUTF8CString(property, "$cyi")) + offset = 0; + else if (!CYGetOffset(pool, context, property, offset)) return NULL; - return CYCastJSValue(context, CYJSString(CYUTF8String(&string[offset], 1))); + sig::Primitive<char> type; + return type.FromFFI(context, type.GetFFI(pool), internal->value_ + offset, false, NULL); } CYCatch(NULL) } static bool CString_setProperty(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef value, JSValueRef *exception) { CYTry { CYPool pool; CString *internal(reinterpret_cast<CString *>(JSObjectGetPrivate(object))); - char *string(static_cast<char *>(internal->value_)); ssize_t offset; - if (!CYGetOffset(pool, context, property, offset)) + if (JSStringIsEqualToUTF8CString(property, "$cyi")) + offset = 0; + else if (!CYGetOffset(pool, context, property, offset)) return false; - const char *data(CYPoolCString(pool, context, value)); - string[offset] = *data; + sig::Primitive<char> type; + type.PoolFFI(NULL, context, type.GetFFI(pool), internal->value_ + offset, value); return true; } CYCatch(false) } @@ -1078,7 +1171,7 @@ static JSValueRef CArray_getProperty(JSContextRef context, JSObjectRef object, J if (JSStringIsEqual(property, length_s)) return CYCastJSValue(context, internal->length_); Type_privateData *typical(internal->type_); - JSObjectRef owner(internal->GetOwner() ?: object); + JSObjectRef owner(internal->owner_ ?: object); return Offset_getProperty(pool, context, property, internal->value_, typical, owner); } CYCatch(NULL) } @@ -1101,7 +1194,7 @@ static JSValueRef Pointer_getProperty(JSContextRef context, JSObjectRef object, return CYMakeFunctor(context, reinterpret_cast<void (*)()>(internal->value_), function->variadic, function->signature); } - JSObjectRef owner(internal->GetOwner() ?: object); + JSObjectRef owner(internal->owner_ ?: object); return Offset_getProperty(pool, context, property, internal->value_, typical, owner); } CYCatch(NULL) } @@ -1135,7 +1228,7 @@ static JSValueRef Struct_getProperty(JSContextRef context, JSObjectRef object, J if (!Index_(pool, context, internal, property, index, base)) return NULL; - JSObjectRef owner(internal->GetOwner() ?: object); + JSObjectRef owner(internal->owner_ ?: object); return type->signature.elements[index].type->FromFFI(context, typical->GetFFI()->elements[index], base, false, owner); } CYCatch(NULL) } @@ -1189,8 +1282,11 @@ static sig::Type *CYGetType(CYPool &pool, JSContextRef context, JSValueRef value if (JSValueIsNull(context, value)) return &PointerToVoid_; JSObjectRef object(CYCastJSObject(context, value)); - JSObjectRef type(CYCastJSObject(context, CYGetProperty(context, object, cyt_s))); - _assert(JSValueIsObjectOfClass(context, type, Type_privateData::Class_)); + JSValueRef check(CYGetProperty(context, object, cyt_s)); + if (JSValueIsUndefined(context, check)) + CYThrow("could not infer type of argument '%s'", CYPoolCString(pool, context, value)); + JSObjectRef type(CYCastJSObject(context, check)); + _assert(JSValueIsObjectOfClass(context, type, CYPrivate<Type_privateData>::Class_)); Type_privateData *internal(reinterpret_cast<Type_privateData *>(JSObjectGetPrivate(type))); return internal->type_; } @@ -1240,7 +1336,8 @@ JSValueRef CYCallFunction(CYPool &pool, JSContextRef context, size_t setups, voi element.type->PoolFFI(&pool, context, ffi, values[index], arguments[index - setups]); } - uint8_t value[cif->rtype->size]; + CYBuffer buffer(context); + uint8_t *value(buffer->malloc<uint8_t>(std::max<size_t>(cif->rtype->size, sizeof(ffi_arg)), std::max<size_t>(cif->rtype->alignment, alignof(ffi_arg)))); void (*call)(CYPool &, JSContextRef, ffi_cif *, void (*)(), void *, void **) = &CYCallFunction; // XXX: this only supports one hook, but it is a bad idea anyway @@ -1249,13 +1346,13 @@ JSValueRef CYCallFunction(CYPool &pool, JSContextRef context, size_t setups, voi call = hook->CallFunction; call(pool, context, cif, function, value, values); - return signature.elements[0].type->FromFFI(context, cif->rtype, value, initialize); + return signature.elements[0].type->FromFFI(context, cif->rtype, value, initialize, buffer); } static JSValueRef Functor_callAsFunction(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(object))); - return CYCallFunction(pool, context, 0, NULL, count, arguments, false, internal->variadic_, internal->signature_, &internal->cif_, internal->GetValue()); + return CYCallFunction(pool, context, 0, NULL, count, arguments, false, internal->variadic_, internal->signature_, &internal->cif_, internal->value_); } CYCatch(NULL) } static JSValueRef Pointer_callAsFunction(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry { @@ -1267,8 +1364,7 @@ static JSValueRef Pointer_callAsFunction(JSContextRef context, JSObjectRef objec } CYCatch(NULL) } JSObjectRef CYMakeType(JSContextRef context, const sig::Type &type) { - Type_privateData *internal(new Type_privateData(type)); - return JSObjectMake(context, Type_privateData::Class_, internal); + return CYPrivate<Type_privateData>::Make(context, type); } extern "C" bool CYBridgeHash(CYPool &pool, CYUTF8String name, const char *&code, unsigned &flags) { @@ -1348,21 +1444,44 @@ static JSValueRef All_getProperty(JSContextRef context, JSObjectRef object, JSSt CYThrow("%s", pool.strcat("error caching ", CYPoolCString(pool, context, property), ": ", error.PoolCString(pool), NULL)); } - JSValueRef result(_jsccall(JSEvaluateScript, context, CYJSString(parsed), NULL, NULL, 0)); - - if (flags == 0) { - JSObjectRef cache(CYGetCachedObject(context, CYJSString("cache"))); - CYSetProperty(context, cache, property, result); + JSObjectRef cache(CYGetCachedObject(context, CYJSString("cache"))); + + JSObjectRef stub; + if (flags == CYBridgeType) { + stub = CYMakeType(context, sig::Void()); + CYSetProperty(context, cache, property, stub); + } else + stub = NULL; + + JSValueRef value(_jsccall(JSEvaluateScript, context, CYJSString(parsed), NULL, NULL, 0)); + + switch (flags) { + case CYBridgeVoid: { + } break; + + case CYBridgeHold: { + CYSetProperty(context, cache, property, value); + } break; + + case CYBridgeType: { + JSObjectRef swap(CYCastJSObject(context, value)); + void *source(JSObjectGetPrivate(swap)); + _assert(source != NULL); + void *target(JSObjectGetPrivate(stub)); + _assert(JSObjectSetPrivate(swap, target)); + _assert(JSObjectSetPrivate(stub, source)); + value = stub; + } break; } - return result; + return value; } return NULL; } CYCatch(NULL) } static JSValueRef All_complete_callAsFunction(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry { - _assert(count == 1); + _assert(count == 1 || count == 2); CYPool pool; CYUTF8String prefix(CYPoolUTF8String(pool, context, CYJSString(context, arguments[0]))); @@ -1423,25 +1542,37 @@ static void All_getPropertyNames(JSContextRef context, JSObjectRef object, JSPro static JSObjectRef CArray_new(JSContextRef context, JSObjectRef object, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry { _assert(false); -} CYCatch(NULL) } +} CYCatchObject() } static JSObjectRef CString_new(JSContextRef context, JSObjectRef object, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry { _assert(false); -} CYCatch(NULL) } +} CYCatchObject() } static JSObjectRef Pointer_new(JSContextRef context, JSObjectRef object, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry { _assert(false); -} CYCatch(NULL) } +} CYCatchObject() } static JSObjectRef Type_new(JSContextRef context, JSObjectRef object, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry { CYPool pool; if (false) { } else if (count == 1) { - const char *encoding(CYPoolCString(pool, context, arguments[0])); - sig::Signature signature; - sig::Parse(pool, &signature, encoding, &Structor_); - return CYMakeType(context, *signature.elements[0].type); + switch (JSValueGetType(context, arguments[0])) { + case kJSTypeString: { + const char *encoding(CYPoolCString(pool, context, arguments[0])); + sig::Signature signature; + sig::Parse(pool, &signature, encoding, &Structor_); + return CYMakeType(context, *signature.elements[0].type); + } break; + + case kJSTypeObject: { + // XXX: accept a set of enum constants and /guess/ at their size + _assert(false); + } break; + + default: + throw CYJSError(context, "incorrect kind of argument to new Type"); + } } else if (count == 2) { JSObjectRef types(CYCastJSObject(context, arguments[0])); size_t count(CYArrayLength(context, types)); @@ -1463,16 +1594,17 @@ static JSObjectRef Type_new(JSContextRef context, JSObjectRef object, size_t cou element.name = CYPoolCString(pool, context, name); JSObjectRef object(CYCastJSObject(context, CYArrayGet(context, types, i))); - _assert(JSValueIsObjectOfClass(context, object, Type_privateData::Class_)); + _assert(JSValueIsObjectOfClass(context, object, CYPrivate<Type_privateData>::Class_)); Type_privateData *internal(reinterpret_cast<Type_privateData *>(JSObjectGetPrivate(object))); element.type = internal->type_; + _assert(element.type != NULL); } return CYMakeType(context, type); } else { throw CYJSError(context, "incorrect number of arguments to Type constructor"); } -} CYCatch(NULL) } +} CYCatchObject() } 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))); @@ -1492,7 +1624,7 @@ static JSValueRef Type_callAsFunction_$With(JSContextRef context, JSObjectRef ob element.offset = _not(size_t); JSObjectRef object(CYCastJSObject(context, arguments[i])); - _assert(JSValueIsObjectOfClass(context, object, Type_privateData::Class_)); + _assert(JSValueIsObjectOfClass(context, object, CYPrivate<Type_privateData>::Class_)); Type_privateData *internal(reinterpret_cast<Type_privateData *>(JSObjectGetPrivate(object))); element.type = internal->type_; @@ -1516,8 +1648,12 @@ static JSValueRef Type_callAsFunction_arrayOf(JSContextRef context, JSObjectRef } CYCatch(NULL) } static JSValueRef Type_callAsFunction_blockWith(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { +#ifdef CY_OBJECTIVEC sig::Block type; return Type_callAsFunction_$With(context, object, _this, count, arguments, type, exception); +#else + _assert(false); +#endif } static JSValueRef Type_callAsFunction_constant(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry { @@ -1531,6 +1667,37 @@ static JSValueRef Type_callAsFunction_constant(JSContextRef context, JSObjectRef return CYMakeType(context, *type); } CYCatch(NULL) } +static JSValueRef Type_callAsFunction_enumFor(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry { + if (count != 1) + throw CYJSError(context, "incorrect number of arguments to Type.enumFor"); + Type_privateData *internal(reinterpret_cast<Type_privateData *>(JSObjectGetPrivate(_this))); + + CYPool pool; + + JSObjectRef constants(CYCastJSObject(context, arguments[0])); + + // XXX: this is, sadly, going to leak + JSPropertyNameArrayRef names(JSObjectCopyPropertyNames(context, constants)); + + size_t count(JSPropertyNameArrayGetCount(names)); + + sig::Enum type(*internal->type_, count); + type.constants = new(pool) sig::Constant[count]; + + for (size_t index(0); index != count; ++index) { + JSStringRef name(JSPropertyNameArrayGetNameAtIndex(names, index)); + JSValueRef value(CYGetProperty(context, constants, name)); + _assert(JSValueGetType(context, value) == kJSTypeNumber); + CYUTF8String string(CYPoolUTF8String(pool, context, name)); + type.constants[index].name = string.data; + type.constants[index].value = CYCastDouble(context, value); + } + + JSPropertyNameArrayRelease(names); + + 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) { bool variadic(count != 0 && JSValueIsNull(context, arguments[count - 1])); sig::Function type(variadic); @@ -1543,7 +1710,7 @@ static JSValueRef Type_callAsFunction_pointerTo(JSContextRef context, JSObjectRe Type_privateData *internal(reinterpret_cast<Type_privateData *>(JSObjectGetPrivate(_this))); if (dynamic_cast<sig::Primitive<char> *>(internal->type_) != NULL) - return CYMakeType(context, sig::String()); + return CYMakeType(context, sig::String((internal->type_->flags & JOC_TYPE_CONST) != 0)); else return CYMakeType(context, sig::Pointer(*internal->type_)); } CYCatch(NULL) } @@ -1565,36 +1732,45 @@ static JSValueRef Type_callAsFunction(JSContextRef context, JSObjectRef object, if (sig::Function *function = dynamic_cast<sig::Function *>(internal->type_)) return CYMakeFunctor(context, arguments[0], function->variadic, function->signature); - CYPool pool; + CYBuffer buffer(context); + sig::Type *type(internal->type_); ffi_type *ffi(internal->GetFFI()); - void *data(pool.malloc<void>(ffi->size, ffi->alignment)); - type->PoolFFI(&pool, context, ffi, data, arguments[0]); - JSValueRef value(type->FromFFI(context, ffi, data)); - - if (JSValueGetType(context, value) == kJSTypeNumber) { - JSObjectRef typed(_jsccall(JSObjectCallAsConstructor, context, CYGetCachedObject(context, CYJSString("Number")), 1, &value)); - CYSetProperty(context, typed, cyt_s, object, kJSPropertyAttributeDontEnum); - value = typed; + void *data; + if (_this == NULL || CYIsStrictEqual(context, _this, CYGetGlobalObject(context))) + data = buffer->malloc<void>(ffi->size, ffi->alignment); + else { + CYSetProperty(context, buffer, CYJSString("$cyo"), _this, kJSPropertyAttributeDontEnum); + data = CYCastPointer<void *>(context, _this); } + type->PoolFFI(buffer, context, ffi, data, arguments[0]); + JSValueRef value(type->FromFFI(context, ffi, data, false, buffer)); return value; } CYCatch(NULL) } static JSObjectRef Type_callAsConstructor(JSContextRef context, JSObjectRef object, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry { - if (count != 0) + if (count > 1) throw CYJSError(context, "incorrect number of arguments to Type allocator"); Type_privateData *internal(reinterpret_cast<Type_privateData *>(JSObjectGetPrivate(object))); JSObjectRef pointer(CYMakePointer(context, NULL, *internal->type_, NULL, NULL)); Pointer *value(reinterpret_cast<Pointer *>(JSObjectGetPrivate(pointer))); + + sig::Type *type(internal->type_); ffi_type *ffi(internal->GetFFI()); value->value_ = value->pool_->malloc<void>(ffi->size, ffi->alignment); - memset(value->value_, 0, ffi->size); + + if (count == 0) + memset(value->value_, 0, ffi->size); + else + type->PoolFFI(value->pool_, context, ffi, value->value_, arguments[0]); + return pointer; -} CYCatch(NULL) } +} CYCatchObject() } +// XXX: I don't even think the user should be allowed to do this static JSObjectRef Functor_new(JSContextRef context, JSObjectRef object, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry { if (count != 2) throw CYJSError(context, "incorrect number of arguments to Functor constructor"); @@ -1602,18 +1778,19 @@ static JSObjectRef Functor_new(JSContextRef context, JSObjectRef object, size_t const char *encoding(CYPoolCString(pool, context, arguments[1])); sig::Signature signature; sig::Parse(pool, &signature, encoding, &Structor_); - return CYMakeFunctor(context, arguments[0], false, signature); -} CYCatch(NULL) } + // XXX: this can try to return null, and I guess then it just fails + return CYCastJSObject(context, CYMakeFunctor(context, arguments[0], false, signature)); +} CYCatchObject() } static JSValueRef CArray_callAsFunction_toPointer(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry { CArray *internal(reinterpret_cast<CArray *>(JSObjectGetPrivate(_this))); - JSObjectRef owner(internal->GetOwner() ?: object); + JSObjectRef owner(internal->owner_ ?: object); return CYMakePointer(context, internal->value_, *internal->type_->type_, NULL, owner); } 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))); - JSObjectRef owner(internal->GetOwner() ?: object); + JSObjectRef owner(internal->owner_ ?: object); return CYMakePointer(context, internal->value_, sig::Primitive<char>(), NULL, owner); } CYCatch(NULL) } @@ -1624,40 +1801,62 @@ static JSValueRef Functor_callAsFunction_$cya(JSContextRef context, JSObjectRef sig::Function type(internal->variadic_); sig::Copy(pool, type.signature, internal->signature_); - return CYMakePointer(context, internal->value_, type, NULL, NULL); + return CYMakePointer(context, reinterpret_cast<void *>(internal->value_), 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 { return _this; } CYCatch(NULL) } -static JSValueRef CYValue_callAsFunction_valueOf(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry { - CYValue *internal(reinterpret_cast<CYValue *>(JSObjectGetPrivate(_this))); +static JSValueRef CArray_callAsFunction_valueOf(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry { + CArray *internal(reinterpret_cast<CArray *>(JSObjectGetPrivate(_this))); return CYCastJSValue(context, reinterpret_cast<uintptr_t>(internal->value_)); } CYCatch(NULL) } -static JSValueRef CYValue_callAsFunction_toJSON(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { - return CYValue_callAsFunction_valueOf(context, object, _this, count, arguments, exception); -} +static JSValueRef Pointer_callAsFunction_valueOf(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry { + Pointer *internal(reinterpret_cast<Pointer *>(JSObjectGetPrivate(_this))); + return CYCastJSValue(context, reinterpret_cast<uintptr_t>(internal->value_)); +} CYCatch(NULL) } + +static JSValueRef Functor_callAsFunction_valueOf(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry { + cy::Functor *internal(reinterpret_cast<cy::Functor *>(JSObjectGetPrivate(_this))); + return CYCastJSValue(context, reinterpret_cast<uintptr_t>(internal->value_)); +} CYCatch(NULL) } + +static JSValueRef Functor_callAsFunction_toCYON(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry { + cy::Functor *internal(reinterpret_cast<cy::Functor *>(JSObjectGetPrivate(_this))); + uint8_t *value(reinterpret_cast<uint8_t *>(internal->value_)); + _assert(value != NULL); + + CYLocalPool pool; + + sig::Function function(internal->variadic_); + sig::Copy(pool, function.signature, internal->signature_); + + CYPropertyName *name(internal->GetName(pool)); + auto typed(CYDecodeType(pool, &function)); -static JSValueRef CYValue_callAsFunction_toCYON(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry { - CYValue *internal(reinterpret_cast<CYValue *>(JSObjectGetPrivate(_this))); std::ostringstream str; - Dl_info info; - if (internal->value_ == NULL) - str << "NULL"; - else if (dladdr(internal->value_, &info) == 0) - str << internal->value_; - else { - str << info.dli_sname; - off_t offset(static_cast<char *>(internal->value_) - static_cast<char *>(info.dli_saddr)); - if (offset != 0) - str << "+0x" << std::hex << offset; - } - std::string value(str.str()); - return CYCastJSValue(context, CYJSString(CYUTF8String(value.c_str(), value.size()))); + CYOptions options; + CYOutput output(*str.rdbuf(), options); + output.pretty_ = true; + (new(pool) CYExternalExpression(new(pool) CYString("C"), typed, name))->Output(output, CYNoFlags); + return CYCastJSValue(context, CYJSString(str.str())); } CYCatch(NULL) } +CYPropertyName *cy::Functor::GetName(CYPool &pool) const { + Dl_info info; + if (dladdr(reinterpret_cast<void *>(value_), &info) == 0 || strcmp(info.dli_sname, "<redacted>") == 0) + return new(pool) CYNumber(reinterpret_cast<uintptr_t>(value_)); + + std::ostringstream str; + str << info.dli_sname; + off_t offset(reinterpret_cast<uint8_t *>(value_) - reinterpret_cast<uint8_t *>(info.dli_saddr)); + if (offset != 0) + str << "+0x" << std::hex << offset; + return new(pool) CYString(pool.strdup(str.str().c_str())); +} + static JSValueRef Pointer_callAsFunction_toCYON(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry { std::set<void *> *objects(CYCastObjects(context, _this, count, arguments)); @@ -1689,12 +1888,11 @@ static JSValueRef Pointer_callAsFunction_toCYON(JSContextRef context, JSObjectRe static JSValueRef CString_getProperty_length(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { CYTry { CString *internal(reinterpret_cast<CString *>(JSObjectGetPrivate(object))); - char *string(static_cast<char *>(internal->value_)); - return CYCastJSValue(context, strlen(string)); + return CYCastJSValue(context, strlen(internal->value_)); } CYCatch(NULL) } static JSValueRef CString_getProperty_$cyt(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { CYTry { - return CYMakeType(context, sig::String()); + return CYMakeType(context, sig::String(true)); } CYCatch(NULL) } static JSValueRef CArray_getProperty_$cyt(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { CYTry { @@ -1710,23 +1908,22 @@ static JSValueRef Pointer_getProperty_$cyt(JSContextRef context, JSObjectRef obj } 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_)); + CString *internal(reinterpret_cast<CString *>(JSObjectGetPrivate(_this))); + const char *string(internal->value_); std::ostringstream str; if (string == NULL) str << "NULL"; else { str << "&"; - CYStringify(str, string, strlen(string), true); + CYStringify(str, string, strlen(string), CYStringifyModeNative); } std::string value(str.str()); return CYCastJSValue(context, CYJSString(CYUTF8String(value.c_str(), value.size()))); } CYCatch(NULL) } static JSValueRef CString_callAsFunction_toString(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_)); - return CYCastJSValue(context, string); + CString *internal(reinterpret_cast<CString *>(JSObjectGetPrivate(_this))); + return CYCastJSValue(context, internal->value_); } CYCatch(NULL) } static JSValueRef Functor_getProperty_$cyt(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { CYTry { @@ -1765,23 +1962,19 @@ static JSValueRef Type_callAsFunction_toCYON(JSContextRef context, JSObjectRef o std::stringbuf out; CYOptions options; CYOutput output(out, options); - (new(pool) CYTypeExpression(CYDecodeType(pool, internal->type_)))->Output(output, CYNoFlags); + output.pretty_ = true; + (new(pool) CYTypeExpression(CYDecodeType(pool, internal->type_->Copy(pool, ""))))->Output(output, CYNoFlags); return CYCastJSValue(context, CYJSString(out.str().c_str())); } CYCatch(NULL) } -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 JSStaticFunction All_staticFunctions[2] = { {"cy$complete", &All_complete_callAsFunction, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, {NULL, NULL, 0} }; -static JSStaticFunction CArray_staticFunctions[4] = { - {"toJSON", &CYValue_callAsFunction_toJSON, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, +static JSStaticFunction CArray_staticFunctions[3] = { {"toPointer", &CArray_callAsFunction_toPointer, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, - {"valueOf", &CYValue_callAsFunction_valueOf, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, + {"valueOf", &CArray_callAsFunction_valueOf, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, {NULL, NULL, 0} }; @@ -1790,9 +1983,8 @@ static JSStaticValue CArray_staticValues[2] = { {NULL, NULL, NULL, 0} }; -static JSStaticFunction CString_staticFunctions[6] = { +static JSStaticFunction CString_staticFunctions[5] = { {"toCYON", &CString_callAsFunction_toCYON, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, - {"toJSON", &CYValue_callAsFunction_toJSON, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, {"toPointer", &CString_callAsFunction_toPointer, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, {"toString", &CString_callAsFunction_toString, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, {"valueOf", &CString_callAsFunction_toString, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, @@ -1805,11 +1997,10 @@ static JSStaticValue CString_staticValues[3] = { {NULL, NULL, NULL, 0} }; -static JSStaticFunction Pointer_staticFunctions[5] = { +static JSStaticFunction Pointer_staticFunctions[4] = { {"toCYON", &Pointer_callAsFunction_toCYON, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, - {"toJSON", &CYValue_callAsFunction_toJSON, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, {"toPointer", &Pointer_callAsFunction_toPointer, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, - {"valueOf", &CYValue_callAsFunction_valueOf, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, + {"valueOf", &Pointer_callAsFunction_valueOf, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, {NULL, NULL, 0} }; @@ -1830,25 +2021,17 @@ static JSStaticValue Struct_staticValues[2] = { static JSStaticFunction Functor_staticFunctions[5] = { {"$cya", &Functor_callAsFunction_$cya, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, - {"toCYON", &CYValue_callAsFunction_toCYON, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, - {"toJSON", &CYValue_callAsFunction_toJSON, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, - {"valueOf", &CYValue_callAsFunction_valueOf, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, + {"toCYON", &Functor_callAsFunction_toCYON, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, + {"toPointer", &Functor_callAsFunction_$cya, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, + {"valueOf", &Functor_callAsFunction_valueOf, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, {NULL, NULL, 0} }; -namespace cy { - JSStaticFunction const * const Functor::StaticFunctions = Functor_staticFunctions; -} - static JSStaticValue Functor_staticValues[2] = { {"$cyt", &Functor_getProperty_$cyt, NULL, kJSPropertyAttributeReadOnly | kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, {NULL, NULL, NULL, 0} }; -namespace cy { - JSStaticValue const * const Functor::StaticValues = Functor_staticValues; -} - static JSStaticValue Type_staticValues[4] = { {"alignment", &Type_getProperty_alignment, NULL, kJSPropertyAttributeReadOnly | kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, {"name", &Type_getProperty_name, NULL, kJSPropertyAttributeReadOnly | kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, @@ -1860,24 +2043,33 @@ static JSStaticFunction Type_staticFunctions[10] = { {"arrayOf", &Type_callAsFunction_arrayOf, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, {"blockWith", &Type_callAsFunction_blockWith, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, {"constant", &Type_callAsFunction_constant, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, + {"enumFor", &Type_callAsFunction_enumFor, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, {"functionWith", &Type_callAsFunction_functionWith, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete}, {"pointerTo", &Type_callAsFunction_pointerTo, 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}, {NULL, NULL, 0} }; -_visible void CYSetArgs(int argc, const char *argv[]) { +_visible void CYSetArgs(const char *argv0, const char *script, int argc, const char *argv[]) { JSContextRef context(CYGetJSContext()); - JSValueRef args[argc]; + JSValueRef args[argc + 2]; for (int i(0); i != argc; ++i) - args[i] = CYCastJSValue(context, argv[i]); + args[i + 2] = CYCastJSValue(context, argv[i]); + + size_t offset; + if (script == NULL) + offset = 1; + else { + offset = 0; + args[1] = CYCastJSValue(context, CYJSString(script)); + } + + args[offset] = CYCastJSValue(context, CYJSString(argv0)); - JSObjectRef array(CYObjectMakeArray(context, argc, args)); - JSObjectRef System(CYGetCachedObject(context, CYJSString("System"))); - CYSetProperty(context, System, CYJSString("args"), array); + CYSetProperty(context, CYGetCachedObject(context, CYJSString("System")), CYJSString("args"), CYObjectMakeArray(context, argc, args + 2)); + CYSetProperty(context, CYGetCachedObject(context, CYJSString("process")), CYJSString("argv"), CYObjectMakeArray(context, argc + 2 - offset, args + offset)); } JSObjectRef CYGetGlobalObject(JSContextRef context) { @@ -1913,18 +2105,22 @@ class ExecutionHandle { } }; +#ifndef __ANDROID__ static volatile bool cancel_; static bool CYShouldTerminate(JSContextRef context, void *arg) { return cancel_; } +#endif _visible const char *CYExecute(JSContextRef context, CYPool &pool, CYUTF8String code) { ExecutionHandle handle(context); +#ifndef __ANDROID__ cancel_ = false; if (&JSContextGroupSetExecutionTimeLimit != NULL) JSContextGroupSetExecutionTimeLimit(JSContextGetGroup(context), 0.5, &CYShouldTerminate, NULL); +#endif try { JSValueRef result(_jsccall(JSEvaluateScript, context, CYJSString(code), NULL, NULL, 0)); @@ -1941,11 +2137,13 @@ _visible const char *CYExecute(JSContextRef context, CYPool &pool, CYUTF8String } } +#ifndef __ANDROID__ _visible void CYCancel() { cancel_ = true; } +#endif -static const char *CYPoolLibraryPath(CYPool &pool); +const char *CYPoolLibraryPath(CYPool &pool); static bool initialized_ = false; @@ -1964,6 +2162,7 @@ void CYInitializeDynamic() { JSClassDefinition definition; definition = kJSClassDefinitionEmpty; + definition.attributes = kJSClassAttributeNoAutomaticPrototype; definition.className = "All"; definition.staticFunctions = All_staticFunctions; definition.hasProperty = &All_hasProperty; @@ -1972,9 +2171,10 @@ void CYInitializeDynamic() { All_ = JSClassCreate(&definition); definition = kJSClassDefinitionEmpty; + definition.attributes = kJSClassAttributeNoAutomaticPrototype; definition.className = "Context"; definition.finalize = &CYFinalize; - Context_ = JSClassCreate(&definition); + CYPrivate<Context>::Class_ = JSClassCreate(&definition); definition = kJSClassDefinitionEmpty; definition.className = "CArray"; @@ -1983,7 +2183,7 @@ void CYInitializeDynamic() { definition.getProperty = &CArray_getProperty; definition.setProperty = &CArray_setProperty; definition.finalize = &CYFinalize; - CArray_ = JSClassCreate(&definition); + CYPrivate<CArray>::Class_ = JSClassCreate(&definition); definition = kJSClassDefinitionEmpty; definition.className = "CString"; @@ -1992,15 +2192,15 @@ void CYInitializeDynamic() { definition.getProperty = &CString_getProperty; definition.setProperty = &CString_setProperty; definition.finalize = &CYFinalize; - CString_ = JSClassCreate(&definition); + CYPrivate<CString>::Class_ = JSClassCreate(&definition); definition = kJSClassDefinitionEmpty; definition.className = "Functor"; - definition.staticFunctions = cy::Functor::StaticFunctions; + definition.staticFunctions = Functor_staticFunctions; definition.staticValues = Functor_staticValues; definition.callAsFunction = &Functor_callAsFunction; definition.finalize = &CYFinalize; - Functor_ = JSClassCreate(&definition); + cy::Functor::Class_ = JSClassCreate(&definition); definition = kJSClassDefinitionEmpty; definition.className = "Pointer"; @@ -2010,7 +2210,12 @@ void CYInitializeDynamic() { definition.getProperty = &Pointer_getProperty; definition.setProperty = &Pointer_setProperty; definition.finalize = &CYFinalize; - Pointer_ = JSClassCreate(&definition); + CYPrivate<Pointer>::Class_ = JSClassCreate(&definition); + + definition = kJSClassDefinitionEmpty; + definition.className = "Root"; + definition.finalize = &CYFinalize; + CYPrivate<CYRoot>::Class_ = JSClassCreate(&definition); definition = kJSClassDefinitionEmpty; definition.className = "Struct"; @@ -2020,7 +2225,7 @@ void CYInitializeDynamic() { definition.setProperty = &Struct_setProperty; definition.getPropertyNames = &Struct_getPropertyNames; definition.finalize = &CYFinalize; - Struct_ = JSClassCreate(&definition); + CYPrivate<Struct_privateData>::Class_ = JSClassCreate(&definition); definition = kJSClassDefinitionEmpty; definition.className = "Type"; @@ -2029,7 +2234,7 @@ void CYInitializeDynamic() { definition.callAsFunction = &Type_callAsFunction; definition.callAsConstructor = &Type_callAsConstructor; definition.finalize = &CYFinalize; - Type_privateData::Class_ = JSClassCreate(&definition); + CYPrivate<Type_privateData>::Class_ = JSClassCreate(&definition); definition = kJSClassDefinitionEmpty; definition.className = "Global"; @@ -2037,9 +2242,11 @@ void CYInitializeDynamic() { Global_ = JSClassCreate(&definition); Array_s = JSStringCreateWithUTF8CString("Array"); + constructor_s = JSStringCreateWithUTF8CString("constructor"); cy_s = JSStringCreateWithUTF8CString("$cy"); cyi_s = JSStringCreateWithUTF8CString("$cyi"); cyt_s = JSStringCreateWithUTF8CString("$cyt"); + cyt__s = JSStringCreateWithUTF8CString("$cyt_"); length_s = JSStringCreateWithUTF8CString("length"); message_s = JSStringCreateWithUTF8CString("message"); name_s = JSStringCreateWithUTF8CString("name"); @@ -2104,18 +2311,47 @@ JSGlobalContextRef CYGetJSContext(JSContextRef context) { return reinterpret_cast<Context *>(JSObjectGetPrivate(CYCastJSObject(context, CYGetProperty(context, CYGetGlobalObject(context), cy_s))))->context_; } -static const char *CYPoolLibraryPath(CYPool &pool) { +#ifdef __ANDROID__ +char *CYPoolLibraryPath_(CYPool &pool) { + FILE *maps(fopen("/proc/self/maps", "r")); + struct F { FILE *f; F(FILE *f) : f(f) {} + ~F() { fclose(f); } } f(maps); + + size_t function(reinterpret_cast<size_t>(&CYPoolLibraryPath)); + + for (;;) { + size_t start; size_t end; char flags[8]; unsigned long long offset; + int major; int minor; unsigned long long inode; char file[1024]; + int count(fscanf(maps, "%zx-%zx %7s %llx %x:%x %llu%[ ]%1024[^\n]\n", + &start, &end, flags, &offset, &major, &minor, &inode, file, file)); + if (count < 8) break; else if (start <= function && function < end) + return pool.strdup(file); + } + + _assert(false); +} +#else +char *CYPoolLibraryPath_(CYPool &pool) { Dl_info addr; _assert(dladdr(reinterpret_cast<void *>(&CYPoolLibraryPath), &addr) != 0); - char *lib(pool.strdup(addr.dli_fname)); + return pool.strdup(addr.dli_fname); +} +#endif + +const char *CYPoolLibraryPath(CYPool &pool) { + char *lib(CYPoolLibraryPath_(pool)); char *slash(strrchr(lib, '/')); - _assert(slash != NULL); + if (slash == NULL) + return "."; *slash = '\0'; slash = strrchr(lib, '/'); - if (slash != NULL && strcmp(slash, "/.libs") == 0) - *slash = '\0'; + if (slash != NULL) { + if (strcmp(slash, "/.libs") == 0) + *slash = '\0'; + } else if (strcmp(lib, ".libs") == 0) + return "."; return lib; } @@ -2124,17 +2360,43 @@ static JSValueRef require_callAsFunction(JSContextRef context, JSObjectRef objec _assert(count == 1); CYPool pool; - const char *name(CYPoolCString(pool, context, arguments[0])); - if (strchr(name, '/') == NULL && ( + CYUTF8String name(CYPoolUTF8String(pool, context, CYJSString(context, arguments[0]))); + if (memchr(name.data, '/', name.size) == NULL && ( #ifdef __APPLE__ - dlopen(pool.strcat("/System/Library/Frameworks/", name, ".framework/", name, NULL), RTLD_LAZY | RTLD_GLOBAL) != NULL || - dlopen(pool.strcat("/System/Library/PrivateFrameworks/", name, ".framework/", name, NULL), RTLD_LAZY | RTLD_GLOBAL) != NULL || + dlopen(pool.strcat("/System/Library/Frameworks/", name.data, ".framework/", name.data, NULL), RTLD_LAZY | RTLD_GLOBAL) != NULL || + dlopen(pool.strcat("/System/Library/PrivateFrameworks/", name.data, ".framework/", name.data, NULL), RTLD_LAZY | RTLD_GLOBAL) != NULL || #endif false)) return CYJSUndefined(context); - JSObjectRef resolve(CYCastJSObject(context, CYGetProperty(context, object, CYJSString("resolve")))); - CYJSString path(context, CYCallAsFunction(context, resolve, NULL, 1, arguments)); + CYJSString path; + CYUTF8String code; + + sqlite3_stmt *statement; + + _sqlcall(sqlite3_prepare(database_, + "select " + "\"module\".\"code\", " + "\"module\".\"flags\" " + "from \"module\" " + "where" + " \"module\".\"name\" = ?" + " limit 1" + , -1, &statement, NULL)); + + _sqlcall(sqlite3_bind_text(statement, 1, name.data, name.size, SQLITE_STATIC)); + + if (_sqlcall(sqlite3_step(statement)) != SQLITE_DONE) { + code.data = static_cast<const char *>(sqlite3_column_blob(statement, 0)); + code.size = sqlite3_column_bytes(statement, 0); + path = CYJSString(name); + code = CYPoolUTF8String(pool, code); + } else { + JSObjectRef resolve(CYCastJSObject(context, CYGetProperty(context, object, CYJSString("resolve")))); + path = CYJSString(context, CYCallAsFunction(context, resolve, NULL, 1, arguments)); + } + + _sqlcall(sqlite3_finalize(statement)); CYJSString property("exports"); @@ -2146,11 +2408,13 @@ static JSValueRef require_callAsFunction(JSContextRef context, JSObjectRef objec JSObjectRef module(CYCastJSObject(context, cache)); result = CYGetProperty(context, module, property); } else { - CYUTF8String code(CYPoolFileUTF8String(pool, CYPoolCString(pool, context, path))); - _assert(code.data != NULL); + if (code.data == NULL) { + code = CYPoolFileUTF8String(pool, CYPoolCString(pool, context, path)); + _assert(code.data != NULL); + } - size_t length(strlen(name)); - if (length >= 5 && strcmp(name + length - 5, ".json") == 0) { + size_t length(name.size); + if (length >= 5 && strncmp(name.data + length - 5, ".json", 5) == 0) { JSObjectRef JSON(CYGetCachedObject(context, CYJSString("JSON"))); JSObjectRef parse(CYCastJSObject(context, CYGetProperty(context, JSON, CYJSString("parse")))); JSValueRef arguments[1] = { CYCastJSValue(context, CYJSString(code)) }; @@ -2197,7 +2461,7 @@ extern "C" void CYSetupContext(JSGlobalContextRef context) { JSObjectRef global(CYGetGlobalObject(context)); - JSObjectRef cy(JSObjectMake(context, Context_, new Context(context))); + JSObjectRef cy(CYPrivate<Context>::Make(context, context)); CYSetProperty(context, global, cy_s, cy, kJSPropertyAttributeDontEnum); /* Cache Globals {{{ */ @@ -2255,20 +2519,32 @@ extern "C" void CYSetupContext(JSGlobalContextRef context) { CYSetProperty(context, cycript, CYJSString("compile"), &Cycript_compile_callAsFunction); CYSetProperty(context, cycript, CYJSString("gc"), &Cycript_gc_callAsFunction); - JSObjectRef CArray(JSObjectMakeConstructor(context, CArray_, &CArray_new)); + JSObjectRef CArray(JSObjectMakeConstructor(context, CYPrivate<::CArray>::Class_, &CArray_new)); CYSetPrototype(context, CYCastJSObject(context, CYGetProperty(context, CArray, prototype_s)), Array_prototype); CYSetProperty(context, cycript, CYJSString("CArray"), CArray); - JSObjectRef CString(JSObjectMakeConstructor(context, CString_, &CString_new)); + JSObjectRef CString(JSObjectMakeConstructor(context, CYPrivate<::CString>::Class_, &CString_new)); CYSetPrototype(context, CYCastJSObject(context, CYGetProperty(context, CString, prototype_s)), String_prototype); CYSetProperty(context, cycript, CYJSString("CString"), CString); - JSObjectRef Functor(JSObjectMakeConstructor(context, Functor_, &Functor_new)); - CYSetPrototype(context, CYCastJSObject(context, CYGetProperty(context, Functor, prototype_s)), Function_prototype); + JSObjectRef Functor(JSObjectMakeConstructor(context, cy::Functor::Class_, &Functor_new)); + JSObjectRef Functor_prototype(CYCastJSObject(context, CYGetProperty(context, Functor, prototype_s))); + CYSetPrototype(context, Functor_prototype, Function_prototype); + CYSetProperty(context, cy, CYJSString("Functor_prototype"), Functor_prototype); CYSetProperty(context, cycript, CYJSString("Functor"), Functor); - CYSetProperty(context, cycript, CYJSString("Pointer"), JSObjectMakeConstructor(context, Pointer_, &Pointer_new)); - CYSetProperty(context, cycript, CYJSString("Type"), JSObjectMakeConstructor(context, Type_privateData::Class_, &Type_new)); + CYSetProperty(context, cycript, CYJSString("Pointer"), JSObjectMakeConstructor(context, CYPrivate<Pointer>::Class_, &Pointer_new)); + + JSObjectRef Type(JSObjectMakeConstructor(context, CYPrivate<Type_privateData>::Class_, &Type_new)); + JSObjectRef Type_prototype(CYCastJSObject(context, CYGetProperty(context, Type, prototype_s))); + CYSetPrototype(context, Type_prototype, Function_prototype); + CYSetProperty(context, cy, CYJSString("Type_prototype"), Type_prototype); + CYSetProperty(context, cycript, CYJSString("Type"), Type); + + JSObjectRef Character_prototype(JSObjectMake(context, NULL, NULL)); + CYSetPrototype(context, Character_prototype, String_prototype); + CYSetProperty(context, cy, CYJSString("Character_prototype"), Character_prototype); + CYSetProperty(context, Character_prototype, CYJSString("valueOf"), _jsccall(JSEvaluateScript, context, CYJSString("(function(){return this.charCodeAt(0);})"), NULL, NULL, 0)); JSObjectRef modules(JSObjectMake(context, NULL, NULL)); CYSetProperty(context, cy, CYJSString("modules"), modules); @@ -2298,17 +2574,6 @@ extern "C" void CYSetupContext(JSGlobalContextRef context) { CYSetPrototype(context, last, cache); } - JSObjectRef System(JSObjectMake(context, NULL, NULL)); - CYSetProperty(context, cy, CYJSString("System"), System); - - CYSetProperty(context, global, CYJSString("require"), &require_callAsFunction, kJSPropertyAttributeDontEnum); - - CYSetProperty(context, global, CYJSString("system"), System); - CYSetProperty(context, System, CYJSString("args"), CYJSNull(context)); - CYSetProperty(context, System, CYJSString("print"), &System_print); - - CYSetProperty(context, global, CYJSString("global"), global); - #ifdef __APPLE__ if (&JSWeakObjectMapCreate != NULL) { JSWeakObjectMapRef weak(JSWeakObjectMapCreate(context, NULL, &CYDestroyWeak)); @@ -2316,7 +2581,7 @@ extern "C" void CYSetupContext(JSGlobalContextRef context) { } #endif - CYSetProperty(context, String_prototype, cyt_s, CYMakeType(context, sig::String()), kJSPropertyAttributeDontEnum); + CYSetProperty(context, String_prototype, cyt_s, CYMakeType(context, sig::String(true)), kJSPropertyAttributeDontEnum); CYSetProperty(context, cache, CYJSString("dlerror"), CYMakeFunctor(context, "dlerror", "*"), kJSPropertyAttributeDontEnum); CYSetProperty(context, cache, CYJSString("RTLD_DEFAULT"), CYCastJSValue(context, reinterpret_cast<intptr_t>(RTLD_DEFAULT)), kJSPropertyAttributeDontEnum); @@ -2339,8 +2604,31 @@ extern "C" void CYSetupContext(JSGlobalContextRef context) { 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); +#ifdef __SIZEOF_INT128__ + CYSetProperty(context, cache, CYJSString("int128"), CYMakeType(context, sig::Primitive<__int128>()), kJSPropertyAttributeDontEnum); + CYSetProperty(context, cache, CYJSString("uint128"), CYMakeType(context, sig::Primitive<unsigned __int128>()), kJSPropertyAttributeDontEnum); +#endif + CYSetProperty(context, cache, CYJSString("float"), CYMakeType(context, sig::Primitive<float>()), kJSPropertyAttributeDontEnum); CYSetProperty(context, cache, CYJSString("double"), CYMakeType(context, sig::Primitive<double>()), kJSPropertyAttributeDontEnum); + CYSetProperty(context, cache, CYJSString("longdouble"), CYMakeType(context, sig::Primitive<long double>()), kJSPropertyAttributeDontEnum); + + CYSetProperty(context, global, CYJSString("require"), &require_callAsFunction, kJSPropertyAttributeDontEnum); + + JSObjectRef System(JSObjectMake(context, NULL, NULL)); + CYSetProperty(context, all, CYJSString("system"), System); + System = CYCastJSObject(context, CYGetProperty(context, global, CYJSString("system"))); + CYSetProperty(context, cy, CYJSString("System"), System); + + JSObjectRef process(JSObjectMake(context, NULL, NULL)); + CYSetProperty(context, global, CYJSString("process"), process); + CYSetProperty(context, cy, CYJSString("process"), process); + + CYSetProperty(context, System, CYJSString("args"), CYJSNull(context)); + CYSetProperty(context, System, CYJSString("print"), &System_print); + + CYSetProperty(context, global, CYJSString("global"), global); + CYSetProperty(context, global, CYJSString("print"), &Global_print); for (CYHook *hook : GetHooks()) if (hook->SetupContext != NULL)