JSStringRef Array_s;
JSStringRef cy_s;
+JSStringRef cyi_s;
JSStringRef length_s;
JSStringRef message_s;
JSStringRef name_s;
return CYCastJSValue(context, name);
} CYCatch(NULL) }
+static void (*JSSynchronousGarbageCollectForDebugging$)(JSContextRef);
+
+void CYGarbageCollect(JSContextRef context) {
+ (JSSynchronousGarbageCollectForDebugging$ ?: &JSGarbageCollect)(context);
+}
+
static JSValueRef Cycript_gc_callAsFunction(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
- JSGarbageCollect(context);
+ CYGarbageCollect(context);
return CYJSUndefined(context);
} CYCatch(NULL) }
// XXX: in point of fact, this may /need/ to leak :(
Closure_privateData *internal(new Closure_privateData(context, function, signature));
-#if defined(__APPLE__) && defined(__arm__)
+#if defined(__APPLE__) && (defined(__arm__) || defined(__arm64__))
void *executable;
ffi_closure *writable(reinterpret_cast<ffi_closure *>(ffi_closure_alloc(sizeof(ffi_closure), &executable)));
return internal->length_ == _not(size_t) ? CYJSUndefined(context) : CYCastJSValue(context, internal->length_);
Type_privateData *typical(internal->type_);
-
if (typical->type_ == NULL)
return NULL;
+ sig::Type &type(*typical->type_);
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, typical->type_, ffi, base, false, owner);
+ return CYFromFFI(context, &type, ffi, base, false, owner);
} CYCatch(NULL) }
static bool Pointer_setProperty(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef value, JSValueRef *exception) { CYTry {
return CYMakeType(context, type);
} 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 {
+ 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.data.signature.elements[0].name = NULL;
+ type.data.signature.elements[0].type = internal->type_;
+ type.data.signature.elements[0].offset = _not(size_t);
+
+ for (size_t i(0); i != count; ++i) {
+ sig::Element &element(type.data.signature.elements[i + 1]);
+ element.name = NULL;
+ element.offset = _not(size_t);
+
+ JSObjectRef object(CYCastJSObject(context, arguments[i]));
+ _assert(JSValueIsObjectOfClass(context, object, Type_privateData::Class_));
+ Type_privateData *internal(reinterpret_cast<Type_privateData *>(JSObjectGetPrivate(object)));
+
+ element.type = internal->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 (count != 1)
throw CYJSError(context, "incorrect number of arguments to Type.arrayOf");
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);
+}
+
static JSValueRef Type_callAsFunction_constant(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.constant");
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) { CYTry {
+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)));
- CYPool pool;
+ sig::Type type(*internal->type_);
- sig::Type type;
- type.name = NULL;
- type.flags = 0;
+ 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");
+ }
- type.primitive = sig::function_P;
- type.data.signature.elements = new(pool) sig::Element[1 + count];
- type.data.signature.count = 1 + count;
+ return CYMakeType(context, &type);
+} CYCatch(NULL) }
- type.data.signature.elements[0].name = NULL;
- type.data.signature.elements[0].type = internal->type_;
- type.data.signature.elements[0].offset = _not(size_t);
+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)));
- for (size_t i(0); i != count; ++i) {
- sig::Element &element(type.data.signature.elements[i + 1]);
- element.name = NULL;
- element.offset = _not(size_t);
+ sig::Type type(*internal->type_);
- JSObjectRef object(CYCastJSObject(context, arguments[i]));
- _assert(JSValueIsObjectOfClass(context, object, Type_privateData::Class_));
- Type_privateData *internal(reinterpret_cast<Type_privateData *>(JSObjectGetPrivate(object)));
+ 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");
+ }
- element.type = internal->type_;
+ 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::uchar_P: type.primitive = sig::char_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::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);
+} 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);
+}
+
static JSValueRef Type_callAsFunction_pointerTo(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.pointerTo");
Type_privateData *internal(reinterpret_cast<Type_privateData *>(JSObjectGetPrivate(object)));
if (internal->type_->primitive == sig::function_P)
- return CYMakeFunctor(context, reinterpret_cast<void (*)()>(static_cast<uintptr_t>(CYCastDouble(context, arguments[0]))), internal->type_->data.signature);
+ return CYMakeFunctor(context, arguments[0], internal->type_->data.signature);
sig::Type *type(internal->type_);
ffi_type *ffi(internal->GetFFI());
JSObjectRef Array(CYGetCachedObject(context, CYJSString("Array_prototype")));
JSObjectRef toCYON(CYCastJSObject(context, CYGetProperty(context, Array, toCYON_s)));
return CYCallAsFunction(context, toCYON, _this, count, arguments);
- } else {
+ } else if (internal->type_->type_ == NULL) pointer: {
char string[32];
sprintf(string, "%p", internal->value_);
return CYCastJSValue(context, string);
+ } 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), NULL));
+ } catch (const CYException &e) {
+ goto pointer;
}
} 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_);
+} CYCatch(NULL) }
+
static JSValueRef Functor_getProperty_type(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { CYTry {
cy::Functor *internal(reinterpret_cast<cy::Functor *>(JSObjectGetPrivate(object)));
return CYMakeType(context, &internal->signature_);
{NULL, NULL, 0}
};
+static JSStaticValue Pointer_staticValues[2] = {
+ {"type", &Pointer_getProperty_type, NULL, kJSPropertyAttributeReadOnly | kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
+ {NULL, NULL, NULL, 0}
+};
+
static JSStaticFunction Struct_staticFunctions[2] = {
{"$cya", &Struct_callAsFunction_$cya, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
{NULL, NULL, 0}
{NULL, NULL, NULL, 0}
};
-static JSStaticFunction Type_staticFunctions[9] = {
+static JSStaticFunction Type_staticFunctions[14] = {
{"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}
};
return JSContextGetGlobalObject(context);
}
+class ExecutionHandle {
+ private:
+ JSContextRef context_;
+ void *handle_;
+
+ public:
+ ExecutionHandle(JSContextRef context) :
+ context_(context)
+ {
+ if (hooks_ != NULL && hooks_->ExecuteStart != NULL)
+ handle_ = (*hooks_->ExecuteStart)(context_);
+ else
+ handle_ = NULL;
+ }
+
+ ~ExecutionHandle() {
+ if (hooks_ != NULL && hooks_->ExecuteEnd != NULL)
+ (*hooks_->ExecuteEnd)(context_, handle_);
+ }
+};
+
const char *CYExecute(JSContextRef context, CYPool &pool, CYUTF8String code) {
JSValueRef exception(NULL);
- void *handle;
- if (hooks_ != NULL && hooks_->ExecuteStart != NULL)
- handle = (*hooks_->ExecuteStart)(context);
- else
- handle = NULL;
+ ExecutionHandle handle(context);
- try {
-
- JSValueRef result;
- try {
+ JSValueRef result; try {
result = JSEvaluateScript(context, CYJSString(code), NULL, NULL, 0, &exception);
} catch (const char *error) {
return error;
if (JSValueIsUndefined(context, result))
return NULL;
- const char *json;
- try {
+ const char *json; try {
json = CYPoolCCYON(pool, context, result, &exception);
} catch (const char *error) {
return error;
CYSetProperty(context, CYGetGlobalObject(context), Result_, result);
return json;
-
- } catch (...) {
- if (hooks_ != NULL && hooks_->ExecuteEnd != NULL)
- (*hooks_->ExecuteEnd)(context, handle);
- throw;
- }
-}
-
-extern "C" void CydgetSetupContext(JSGlobalContextRef context) {
- CYSetupContext(context);
}
static bool initialized_ = false;
else return;
JSObjectMakeArray$ = reinterpret_cast<JSObjectRef (*)(JSContextRef, size_t, const JSValueRef[], JSValueRef *)>(dlsym(RTLD_DEFAULT, "JSObjectMakeArray"));
+ JSSynchronousGarbageCollectForDebugging$ = reinterpret_cast<void (*)(JSContextRef)>(dlsym(RTLD_DEFAULT, "JSSynchronousGarbageCollectForDebugging"));
JSClassDefinition definition;
definition = kJSClassDefinitionEmpty;
definition.className = "Pointer";
definition.staticFunctions = Pointer_staticFunctions;
+ definition.staticValues = Pointer_staticValues;
definition.getProperty = &Pointer_getProperty;
definition.setProperty = &Pointer_setProperty;
definition.finalize = &CYFinalize;
Array_s = JSStringCreateWithUTF8CString("Array");
cy_s = JSStringCreateWithUTF8CString("$cy");
+ cyi_s = JSStringCreateWithUTF8CString("$cyi");
length_s = JSStringCreateWithUTF8CString("length");
message_s = JSStringCreateWithUTF8CString("message");
name_s = JSStringCreateWithUTF8CString("name");
CYUTF16String utf16(CYPoolUTF16String(pool, utf8));
munmap(const_cast<char *>(utf8.data), utf8.size);
- if (CydgetMemoryParse(&utf16.data, &utf16.size))
- CYExecute(context, pool, CYPoolUTF8String(pool, utf16));
+ // XXX: this should not be used
+ CydgetMemoryParse(&utf16.data, &utf16.size);
+
+ CYExecute(context, pool, CYPoolUTF8String(pool, utf16));
free(const_cast<uint16_t *>(utf16.data));
}
_syscall(closedir(setups));
}
+static JSValueRef require(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
+ _assert(count == 1);
+ CYPool pool;
+
+ Dl_info addr;
+ _assert(dladdr(reinterpret_cast<void *>(&require), &addr) != 0);
+ char *lib(pool.strdup(addr.dli_fname));
+
+ char *slash(strrchr(lib, '/'));
+ _assert(slash != NULL);
+ *slash = '\0';
+
+ CYJSString property("exports");
+ JSObjectRef module;
+
+ const char *path(pool.strcat(lib, "/cycript/", CYPoolCString(pool, context, arguments[0]), ".cy", NULL));
+ CYJSString key(path);
+ JSObjectRef modules(CYGetCachedObject(context, CYJSString("modules")));
+ JSValueRef cache(CYGetProperty(context, modules, key));
+
+ if (!JSValueIsUndefined(context, cache))
+ module = CYCastJSObject(context, cache);
+ else {
+ CYUTF8String code;
+ code.data = reinterpret_cast<char *>(CYMapFile(path, &code.size));
+
+ std::stringstream wrap;
+ wrap << "(function (exports, require, module) { " << code << "\n});";
+ code = CYPoolCode(pool, wrap.str().c_str());
+
+ JSValueRef value(_jsccall(JSEvaluateScript, context, CYJSString(code), NULL, NULL, 0));
+ JSObjectRef function(CYCastJSObject(context, value));
+
+ module = JSObjectMake(context, NULL, NULL);
+ JSObjectRef exports(JSObjectMake(context, NULL, NULL));
+ CYSetProperty(context, module, property, exports);
+
+ JSValueRef arguments[3] = { exports, JSObjectMakeFunctionWithCallback(context, CYJSString("require"), &require), module };
+ CYCallAsFunction(context, function, NULL, 3, arguments);
+ CYSetProperty(context, modules, key, module);
+ }
+
+ return CYGetProperty(context, module, property);
+} CYCatch(NULL) }
+
extern "C" void CYSetupContext(JSGlobalContextRef context) {
CYInitializeDynamic();
CYSetProperty(context, cycript, CYJSString("Pointer"), JSObjectMakeConstructor(context, Pointer_, &Pointer_new));
CYSetProperty(context, cycript, CYJSString("Type"), JSObjectMakeConstructor(context, Type_privateData::Class_, &Type_new));
+ JSObjectRef modules(JSObjectMake(context, NULL, NULL));
+ CYSetProperty(context, cy, CYJSString("modules"), modules);
+
JSObjectRef all(JSObjectMake(context, All_, NULL));
CYSetProperty(context, cycript, CYJSString("all"), all);
JSObjectRef System(JSObjectMake(context, NULL, NULL));
CYSetProperty(context, cy, CYJSString("System"), System);
+ CYSetProperty(context, all, CYJSString("require"), &require, kJSPropertyAttributeDontEnum);
+
CYSetProperty(context, global, CYJSString("system"), System);
CYSetProperty(context, System, CYJSString("args"), CYJSNull(context));
//CYSetProperty(context, System, CYJSString("global"), global);
CYRunSetups(context);
}
+static JSGlobalContextRef context_;
+
JSGlobalContextRef CYGetJSContext() {
CYInitializeDynamic();
- static JSGlobalContextRef context_;
-
if (context_ == NULL) {
context_ = JSGlobalContextCreate(Global_);
CYSetupContext(context_);
return context_;
}
+
+void CYDestroyContext() {
+ if (context_ == NULL)
+ return;
+ JSGlobalContextRelease(context_);
+ context_ = NULL;
+}
projects / cycript.git / blobdiff