#include "Internal.hpp"
#include <dlfcn.h>
+#include <dirent.h>
+#include <fcntl.h>
+#include <unistd.h>
#include "cycript.hpp"
#include "Execute.hpp"
#include <sys/mman.h>
+#include <sys/stat.h>
#include <iostream>
#include <set>
#include "Parser.hpp"
+#include "Decode.hpp"
#include "Error.hpp"
#include "JavaScript.hpp"
#include "String.hpp"
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) }
return JSObjectMake(context, Pointer_, internal);
}
-static JSObjectRef CYMakeFunctor(JSContextRef context, void (*function)(), const char *type) {
- return JSObjectMake(context, Functor_, new cy::Functor(type, function));
+static JSObjectRef CYMakeFunctor(JSContextRef context, void (*function)(), const sig::Signature &signature) {
+ return JSObjectMake(context, Functor_, new cy::Functor(signature, function));
}
-static JSObjectRef CYMakeFunctor(JSContextRef context, const char *symbol, const char *type, void **cache) {
+static JSObjectRef CYMakeFunctor(JSContextRef context, const char *symbol, const char *encoding, void **cache) {
cy::Functor *internal;
if (*cache != NULL)
internal = reinterpret_cast<cy::Functor *>(*cache);
if (function == NULL)
return NULL;
- internal = new cy::Functor(type, function);
+ internal = new cy::Functor(encoding, function);
*cache = internal;
}
CYExecuteClosure(cif, result, arguments, arg, &FunctionAdapter_);
}
-Closure_privateData *CYMakeFunctor_(JSContextRef context, JSObjectRef function, const char *type, void (*callback)(ffi_cif *, void *, void **, void *)) {
+Closure_privateData *CYMakeFunctor_(JSContextRef context, JSObjectRef function, const sig::Signature &signature, void (*callback)(ffi_cif *, void *, void **, void *)) {
// XXX: in case of exceptions this will leak
// XXX: in point of fact, this may /need/ to leak :(
- Closure_privateData *internal(new Closure_privateData(context, function, type));
+ 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;
}
-static JSObjectRef CYMakeFunctor(JSContextRef context, JSObjectRef function, const char *type) {
- Closure_privateData *internal(CYMakeFunctor_(context, function, type, &FunctionClosure_));
+static JSObjectRef CYMakeFunctor(JSContextRef context, JSObjectRef function, const sig::Signature &signature) {
+ Closure_privateData *internal(CYMakeFunctor_(context, function, signature, &FunctionClosure_));
JSObjectRef object(JSObjectMake(context, Functor_, internal));
// XXX: see above notes about needing to leak
JSValueProtect(CYGetJSContext(context), object);
return CYCastJSObject(context, CYGetProperty(context, CYCastJSObject(context, CYGetProperty(context, CYGetGlobalObject(context), cy_s)), name));
}
-static JSObjectRef CYMakeFunctor(JSContextRef context, JSValueRef value, const char *type) {
+static JSObjectRef CYMakeFunctor(JSContextRef context, JSValueRef value, const sig::Signature &signature) {
JSObjectRef Function(CYGetCachedObject(context, CYJSString("Function")));
bool function(_jsccall(JSValueIsInstanceOfConstructor, context, value, Function));
if (function) {
JSObjectRef function(CYCastJSObject(context, value));
- return CYMakeFunctor(context, function, type);
+ return CYMakeFunctor(context, function, signature);
} else {
void (*function)()(CYCastPointer<void (*)()>(context, value));
- return CYMakeFunctor(context, function, type);
+ return CYMakeFunctor(context, function, signature);
}
}
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 CYCallFunction(pool, context, 0, NULL, count, arguments, false, &internal->signature_, &internal->cif_, internal->GetValue());
} CYCatch(NULL) }
-JSObjectRef CYMakeType(JSContextRef context, const char *type) {
- Type_privateData *internal(new Type_privateData(type));
+JSObjectRef CYMakeType(JSContextRef context, const char *encoding) {
+ Type_privateData *internal(new Type_privateData(encoding));
return JSObjectMake(context, Type_privateData::Class_, internal);
}
return JSObjectMake(context, Type_privateData::Class_, internal);
}
+JSObjectRef CYMakeType(JSContextRef context, sig::Signature *signature) {
+ CYPool pool;
+
+ sig::Type type;
+ type.name = NULL;
+ type.flags = 0;
+
+ type.primitive = sig::function_P;
+ sig::Copy(pool, type.data.signature, *signature);
+
+ return CYMakeType(context, &type);
+}
+
static JSValueRef All_getProperty(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { CYTry {
JSObjectRef global(CYGetGlobalObject(context));
JSObjectRef cycript(CYCastJSObject(context, CYGetProperty(context, global, CYJSString("Cycript"))));
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_long(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
+ if (count != 0)
+ throw CYJSError(context, "incorrect number of arguments to Type.long");
+ Type_privateData *internal(reinterpret_cast<Type_privateData *>(JSObjectGetPrivate(_this)));
+
+ sig::Type type(*internal->type_);
+
+ switch (type.primitive) {
+ case sig::short_P: type.primitive = sig::int_P; break;
+ case sig::int_P: type.primitive = sig::long_P; break;
+ case sig::long_P: type.primitive = sig::longlong_P; break;
+ default: throw CYJSError(context, "invalid type argument to Type.long");
+ }
+
+ return CYMakeType(context, &type);
+} CYCatch(NULL) }
+
+static JSValueRef Type_callAsFunction_short(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
+ if (count != 0)
+ throw CYJSError(context, "incorrect number of arguments to Type.short");
+ Type_privateData *internal(reinterpret_cast<Type_privateData *>(JSObjectGetPrivate(_this)));
+
+ sig::Type type(*internal->type_);
+
+ switch (type.primitive) {
+ case sig::int_P: type.primitive = sig::short_P; break;
+ case sig::long_P: type.primitive = sig::int_P; break;
+ case sig::longlong_P: type.primitive = sig::long_P; break;
+ default: throw CYJSError(context, "invalid type argument to Type.short");
+ }
+
+ return CYMakeType(context, &type);
+} CYCatch(NULL) }
+
+static JSValueRef Type_callAsFunction_signed(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
+ if (count != 0)
+ throw CYJSError(context, "incorrect number of arguments to Type.signed");
+ Type_privateData *internal(reinterpret_cast<Type_privateData *>(JSObjectGetPrivate(_this)));
+
+ sig::Type type(*internal->type_);
+
+ switch (type.primitive) {
+ case sig::char_P: case sig::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");
sig::Type type;
type.name = NULL;
- type.flags = 0;
- type.primitive = sig::pointer_P;
- type.data.data.type = internal->type_;
- type.data.data.size = 0;
+ if (internal->type_->primitive == sig::char_P) {
+ type.flags = internal->type_->flags;
+ type.primitive = sig::string_P;
+ type.data.data.type = NULL;
+ type.data.data.size = 0;
+ } else {
+ type.flags = 0;
+ type.primitive = sig::pointer_P;
+ type.data.data.type = internal->type_;
+ type.data.data.size = 0;
+ }
return CYMakeType(context, &type);
} CYCatch(NULL) }
throw CYJSError(context, "incorrect number of arguments to type cast function");
Type_privateData *internal(reinterpret_cast<Type_privateData *>(JSObjectGetPrivate(object)));
+ if (internal->type_->primitive == sig::function_P)
+ return CYMakeFunctor(context, arguments[0], internal->type_->data.signature);
+
sig::Type *type(internal->type_);
ffi_type *ffi(internal->GetFFI());
// XXX: alignment?
type = type->data.data.type;
}
- void *value(malloc(internal->GetFFI()->size));
+ void *value(calloc(1, internal->GetFFI()->size));
return CYMakePointer(context, value, length, type, NULL, NULL);
} CYCatch(NULL) }
if (count != 2)
throw CYJSError(context, "incorrect number of arguments to Functor constructor");
CYPool pool;
- const char *type(CYPoolCString(pool, context, arguments[1]));
- return CYMakeFunctor(context, arguments[0], type);
+ const char *encoding(CYPoolCString(pool, context, arguments[1]));
+ sig::Signature signature;
+ sig::Parse(pool, &signature, encoding, &Structor_);
+ return CYMakeFunctor(context, arguments[0], signature);
} CYCatch(NULL) }
static JSValueRef CYValue_callAsFunction_valueOf(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
JSObjectRef Array(CYGetCachedObject(context, CYJSString("Array_prototype")));
JSObjectRef toCYON(CYCastJSObject(context, CYGetProperty(context, Array, toCYON_s)));
return CYCallAsFunction(context, toCYON, _this, count, arguments);
- } else {
+ } 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)));
- CYPool pool;
- return CYCastJSValue(context, Unparse(pool, &internal->signature_));
+ return CYMakeType(context, &internal->signature_);
} CYCatch(NULL) }
static JSValueRef Type_getProperty_alignment(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { CYTry {
static JSValueRef Type_callAsFunction_toCYON(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
Type_privateData *internal(reinterpret_cast<Type_privateData *>(JSObjectGetPrivate(_this)));
- CYPool pool;
- const char *type(sig::Unparse(pool, internal->type_));
- std::ostringstream str;
- CYStringify(str, type, strlen(type));
- char *cyon(pool.strcat("new Type(", str.str().c_str(), ")", NULL));
- return CYCastJSValue(context, CYJSString(cyon));
+ CYLocalPool pool;
+ std::ostringstream out;
+ CYOptions options;
+ CYOutput output(out, options);
+ (new(pool) CYEncodedType(Decode(pool, internal->type_)))->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) {
{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[8] = {
+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");
return reinterpret_cast<Context *>(JSObjectGetPrivate(CYCastJSObject(context, CYGetProperty(context, CYGetGlobalObject(context), cy_s))))->context_;
}
+extern "C" bool CydgetMemoryParse(const uint16_t **data, size_t *size);
+
+void *CYMapFile(const char *path, size_t *psize) {
+ int fd;
+ _syscall(fd = open(path, O_RDONLY));
+
+ struct stat stat;
+ _syscall(fstat(fd, &stat));
+ size_t size(stat.st_size);
+
+ *psize = size;
+
+ void *base;
+ _syscall(base = mmap(NULL, size, PROT_READ, MAP_SHARED, fd, 0));
+
+ _syscall(close(fd));
+ return base;
+}
+
+static void CYRunSetups(JSContextRef context) {
+ std::string folder("/etc/cycript/setup.d");
+ DIR *setups(opendir(folder.c_str()));
+ if (setups == NULL)
+ return;
+
+ for (;;) {
+ dirent setup;
+ dirent *result;
+ _syscall(readdir_r(setups, &setup, &result));
+
+ if (result == NULL)
+ break;
+ _assert(result == &setup);
+
+ const char *name(setup.d_name);
+ size_t length(strlen(name));
+ if (length < 4)
+ continue;
+
+ if (name[0] == '.')
+ continue;
+ if (memcmp(name + length - 3, ".cy", 3) != 0)
+ continue;
+
+ std::string script(folder + "/" + name);
+ CYUTF8String utf8;
+ utf8.data = reinterpret_cast<char *>(CYMapFile(script.c_str(), &utf8.size));
+
+ CYPool pool;
+ CYUTF16String utf16(CYPoolUTF16String(pool, utf8));
+ munmap(const_cast<char *>(utf8.data), utf8.size);
+
+ // 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);
(*hooks_->SetupContext)(context);
CYArrayPush(context, alls, cycript);
+
+ 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