#include <sstream>
#include <cmath>
-#include "Parser.hpp"
-
+#include "Code.hpp"
#include "Decode.hpp"
#include "Error.hpp"
#include "JavaScript.hpp"
struct CYHooks *hooks_;
/* JavaScript Properties {{{ */
+bool CYHasProperty(JSContextRef context, JSObjectRef object, JSStringRef name) {
+ return JSObjectHasProperty(context, object, name);
+}
+
JSValueRef CYGetProperty(JSContextRef context, JSObjectRef object, size_t index) {
return _jsccall(JSObjectGetPropertyAtIndex, context, object, index);
}
void CYSetProperty(JSContextRef context, JSObjectRef object, JSStringRef name, JSValueRef (*callback)(JSContextRef, JSObjectRef, JSObjectRef, size_t, const JSValueRef[], JSValueRef *), JSPropertyAttributes attributes) {
CYSetProperty(context, object, name, JSObjectMakeFunctionWithCallback(context, name, callback), attributes);
}
+
+void CYSetPrototype(JSContextRef context, JSObjectRef object, JSValueRef value) {
+ JSObjectSetPrototype(context, object, value);
+ _assert(JSObjectGetPrototype(context, object) == value);
+}
/* }}} */
/* JavaScript Strings {{{ */
JSStringRef CYCopyJSString(const char *value) {
void Structor_(CYPool &pool, sig::Type *&type) {
if (
type->primitive == sig::pointer_P &&
- type->data.data.type != NULL &&
type->data.data.type->primitive == sig::struct_P &&
type->data.data.type->name != NULL &&
strcmp(type->data.data.type->name, "_objc_class") == 0
return CYJSUndefined(context);
} CYCatch(NULL) }
-const char *CYPoolCCYON(CYPool &pool, JSContextRef context, JSValueRef value, JSValueRef *exception) { CYTry {
+const char *CYPoolCCYON(CYPool &pool, JSContextRef context, JSValueRef value, std::set<void *> &objects, JSValueRef *exception) { CYTry {
switch (JSType type = JSValueGetType(context, value)) {
case kJSTypeUndefined:
return "undefined";
} break;
case kJSTypeObject:
- return CYPoolCCYON(pool, context, (JSObjectRef) value);
+ return CYPoolCCYON(pool, context, (JSObjectRef) value, objects);
default:
throw CYJSError(context, "JSValueGetType() == 0x%x", type);
}
} CYCatch(NULL) }
-const char *CYPoolCCYON(CYPool &pool, JSContextRef context, JSValueRef value) {
- return _jsccall(CYPoolCCYON, pool, context, value);
+const char *CYPoolCCYON(CYPool &pool, JSContextRef context, JSValueRef value, std::set<void *> &objects) {
+ return _jsccall(CYPoolCCYON, pool, context, value, objects);
}
-const char *CYPoolCCYON(CYPool &pool, JSContextRef context, JSObjectRef object) {
+const char *CYPoolCCYON(CYPool &pool, JSContextRef context, JSValueRef value, std::set<void *> *objects) {
+ if (objects != NULL)
+ return CYPoolCCYON(pool, context, value, *objects);
+ else {
+ std::set<void *> objects;
+ return CYPoolCCYON(pool, context, value, objects);
+ }
+}
+
+const char *CYPoolCCYON(CYPool &pool, JSContextRef context, JSObjectRef object, std::set<void *> &objects) {
JSValueRef toCYON(CYGetProperty(context, object, toCYON_s));
if (CYIsCallable(context, toCYON)) {
- JSValueRef value(CYCallAsFunction(context, (JSObjectRef) toCYON, object, 0, NULL));
+ // XXX: this needs to be abstracted behind some kind of function
+ JSValueRef arguments[1] = {CYCastJSValue(context, static_cast<double>(reinterpret_cast<uintptr_t>(&objects)))};
+ JSValueRef value(CYCallAsFunction(context, (JSObjectRef) toCYON, object, 1, arguments));
_assert(value != NULL);
return CYPoolCString(pool, context, value);
}
JSValueRef toJSON(CYGetProperty(context, object, toJSON_s));
if (CYIsCallable(context, toJSON)) {
JSValueRef arguments[1] = {CYCastJSValue(context, CYJSString(""))};
- return _jsccall(CYPoolCCYON, pool, context, CYCallAsFunction(context, (JSObjectRef) toJSON, object, 1, arguments));
+ return _jsccall(CYPoolCCYON, pool, context, CYCallAsFunction(context, (JSObjectRef) toJSON, object, 1, arguments), objects);
}
if (JSObjectIsFunction(context, object)) {
}
}
+ _assert(objects.insert(object).second);
+
std::ostringstream str;
str << '{';
try {
JSValueRef value(CYGetProperty(context, object, name));
- str << CYPoolCCYON(pool, context, value);
+ str << CYPoolCCYON(pool, context, value, objects);
} catch (const CYException &error) {
str << "@error";
}
return pool.strmemdup(string.c_str(), string.size());
}
+std::set<void *> *CYCastObjects(JSContextRef context, JSObjectRef _this, size_t count, const JSValueRef arguments[]) {
+ if (count == 0)
+ return NULL;
+ return CYCastPointer<std::set<void *> *>(context, arguments[0]);
+}
+
static JSValueRef Array_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));
+ // XXX: this is horribly inefficient
+ std::set<void *> backup;
+ if (objects == NULL)
+ objects = &backup;
+
CYPool pool;
std::ostringstream str;
try {
JSValueRef value(CYGetProperty(context, _this, index));
if (!JSValueIsUndefined(context, value))
- str << CYPoolCCYON(pool, context, value);
+ str << CYPoolCCYON(pool, context, value, *objects);
else {
str << ',';
comma = false;
return CYMakeType(context, &type);
}
+static bool All_hasProperty(JSContextRef context, JSObjectRef object, JSStringRef property) {
+ JSObjectRef global(CYGetGlobalObject(context));
+ JSObjectRef cycript(CYCastJSObject(context, CYGetProperty(context, global, CYJSString("Cycript"))));
+ JSObjectRef alls(CYCastJSObject(context, CYGetProperty(context, cycript, CYJSString("alls"))));
+
+ for (size_t i(0), count(CYArrayLength(context, alls)); i != count; ++i)
+ if (JSObjectRef space = CYCastJSObject(context, CYArrayGet(context, alls, count - i - 1)))
+ if (CYHasProperty(context, space, property))
+ return true;
+
+ CYPool pool;
+ CYUTF8String name(CYPoolUTF8String(pool, context, property));
+
+ size_t length(name.size);
+ char keyed[length + 2];
+ memcpy(keyed + 1, name.data, length + 1);
+
+ static const char *modes = "0124";
+ for (size_t i(0); i != 4; ++i) {
+ keyed[0] = modes[i];
+ if (CYBridgeHash(keyed, length + 1) != NULL)
+ return true;
+ }
+
+ return false;
+}
+
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_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);
}
} CYCatch(NULL) }
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));
+
Pointer *internal(reinterpret_cast<Pointer *>(JSObjectGetPrivate(_this)));
if (internal->length_ != _not(size_t)) {
JSObjectRef Array(CYGetCachedObject(context, CYJSString("Array_prototype")));
if (JSValueIsUndefined(context, value))
goto pointer;
CYPool pool;
- return CYCastJSValue(context, pool.strcat("&", CYPoolCCYON(pool, context, value), NULL));
+ return CYCastJSValue(context, pool.strcat("&", CYPoolCCYON(pool, context, value, objects), NULL));
} catch (const CYException &e) {
goto pointer;
}
{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},
{NULL, NULL, NULL, 0}
};
-static JSStaticFunction Type_staticFunctions[10] = {
+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 NULL;
const char *json; try {
- json = CYPoolCCYON(pool, context, result, &exception);
+ std::set<void *> objects;
+ json = CYPoolCCYON(pool, context, result, objects, &exception);
} catch (const char *error) {
return error;
}
definition = kJSClassDefinitionEmpty;
definition.className = "All";
+ definition.hasProperty = &All_hasProperty;
definition.getProperty = &All_getProperty;
definition.getPropertyNames = &All_getPropertyNames;
All_ = JSClassCreate(&definition);
}
const char *CYJSError::PoolCString(CYPool &pool) const {
+ std::set<void *> objects;
// XXX: this used to be CYPoolCString
- return CYPoolCCYON(pool, context_, value_);
+ return CYPoolCCYON(pool, context_, value_, objects);
}
JSValueRef CYJSError::CastJSValue(JSContextRef context) const {
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));
+ int fd(_syscall_(open(path, O_RDONLY), 1, {ENOENT}));
+ if (fd == -1)
+ return NULL;
struct stat stat;
_syscall(fstat(fd, &stat));
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;
CYJSString property("exports");
JSObjectRef module;
- const char *path(pool.strcat(lib, "/cycript/", CYPoolCString(pool, context, arguments[0]), ".cy", NULL));
+ const char *name(CYPoolCString(pool, context, arguments[0]));
+ const char *path(pool.strcat(lib, "/cycript0.9/", name, ".cy", NULL));
+
CYJSString key(path);
JSObjectRef modules(CYGetCachedObject(context, CYJSString("modules")));
JSValueRef cache(CYGetProperty(context, modules, key));
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());
+ if (code.data == NULL) {
+ if (strchr(name, '/') == NULL && (
+ 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 ||
+ false))
+ return CYJSUndefined(NULL);
- JSValueRef value(_jsccall(JSEvaluateScript, context, CYJSString(code), NULL, NULL, 0));
- JSObjectRef function(CYCastJSObject(context, value));
+ CYThrow("Can't find module: %s", name);
+ }
module = JSObjectMake(context, NULL, NULL);
+ CYSetProperty(context, modules, key, module);
+
JSObjectRef exports(JSObjectMake(context, NULL, NULL));
CYSetProperty(context, module, property, exports);
+ std::stringstream wrap;
+ wrap << "(function (exports, require, module) { " << code << "\n});";
+ code = CYPoolCode(pool, wrap);
+
+ JSValueRef value(_jsccall(JSEvaluateScript, context, CYJSString(code), NULL, NULL, 0));
+ JSObjectRef function(CYCastJSObject(context, value));
+
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);
JSObjectRef Array_prototype(CYCastJSObject(context, CYGetProperty(context, Array, prototype_s)));
CYSetProperty(context, cy, CYJSString("Array_prototype"), Array_prototype);
+ JSObjectRef Boolean(CYCastJSObject(context, CYGetProperty(context, global, CYJSString("Boolean"))));
+ CYSetProperty(context, cy, CYJSString("Boolean"), Boolean);
+
+ JSObjectRef Boolean_prototype(CYCastJSObject(context, CYGetProperty(context, Boolean, prototype_s)));
+ CYSetProperty(context, cy, CYJSString("Boolean_prototype"), Boolean_prototype);
+
JSObjectRef Error(CYCastJSObject(context, CYGetProperty(context, global, CYJSString("Error"))));
CYSetProperty(context, cy, CYJSString("Error"), Error);
JSObjectRef Function_prototype(CYCastJSObject(context, CYGetProperty(context, Function, prototype_s)));
CYSetProperty(context, cy, CYJSString("Function_prototype"), Function_prototype);
+ JSObjectRef Number(CYCastJSObject(context, CYGetProperty(context, global, CYJSString("Number"))));
+ CYSetProperty(context, cy, CYJSString("Number"), Number);
+
+ JSObjectRef Number_prototype(CYCastJSObject(context, CYGetProperty(context, Number, prototype_s)));
+ CYSetProperty(context, cy, CYJSString("Number_prototype"), Number_prototype);
+
JSObjectRef Object(CYCastJSObject(context, CYGetProperty(context, global, CYJSString("Object"))));
CYSetProperty(context, cy, CYJSString("Object"), Object);
CYSetProperty(context, cycript, CYJSString("gc"), &Cycript_gc_callAsFunction);
JSObjectRef Functor(JSObjectMakeConstructor(context, Functor_, &Functor_new));
- JSObjectSetPrototype(context, CYCastJSObject(context, CYGetProperty(context, Functor, prototype_s)), Function_prototype);
+ CYSetPrototype(context, CYCastJSObject(context, CYGetProperty(context, Functor, prototype_s)), Function_prototype);
CYSetProperty(context, cycript, CYJSString("Functor"), Functor);
CYSetProperty(context, cycript, CYJSString("Pointer"), JSObjectMakeConstructor(context, Pointer_, &Pointer_new));
next = JSObjectGetPrototype(context, curr);
}
- JSObjectSetPrototype(context, last, all);
+ CYSetPrototype(context, last, all);
}
CYSetProperty(context, global, CYJSString("$cyq"), &$cyq, kJSPropertyAttributeDontEnum);
(*hooks_->SetupContext)(context);
CYArrayPush(context, alls, cycript);
-
- CYRunSetups(context);
}
static JSGlobalContextRef context_;
projects / cycript.git / blobdiff