}
JSStringRef CYCopyJSString(CYUTF8String value) {
- // XXX: this is very wrong; it needs to convert to UTF16 and then create from there
- return CYCopyJSString(value.data);
+ if (memchr(value.data, '\0', value.size) != NULL) {
+ CYPool pool;
+ return CYCopyJSString(pool.memdup(value.data, value.size));
+ } else if (value.data[value.size] != '\0') {
+ CYPool pool;
+ return CYCopyJSString(CYPoolUTF16String(pool, value));
+ } else {
+ return CYCopyJSString(value.data);
+ }
+}
+
+JSStringRef CYCopyJSString(CYUTF16String value) {
+ return JSStringCreateWithCharacters(value.data, value.size);
}
JSStringRef CYCopyJSString(JSContextRef context, JSValueRef value) {
static JSClassRef All_;
static JSClassRef Context_;
+static JSClassRef CString_;
JSClassRef Functor_;
static JSClassRef Global_;
static JSClassRef Pointer_;
}
};
+struct CString :
+ CYOwned
+{
+ CString(char *value, JSContextRef context, JSObjectRef owner) :
+ CYOwned(value, context, owner)
+ {
+ }
+};
+
struct Pointer :
CYOwned
{
#define CYCastJSValue_(Type_) \
JSValueRef CYCastJSValue(JSContextRef context, Type_ value) { \
+ _assert(static_cast<Type_>(static_cast<double>(value)) == value); \
return JSValueMakeNumber(context, static_cast<double>(value)); \
}
return CYCastJSValue(context, CYJSString(CYUTF8String(value.c_str(), value.size())));
} CYCatch(NULL) }
-static JSValueRef Error_callAsFunction_toCYON(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
- CYPool pool;
- std::ostringstream str;
-
- str << "new " << CYPoolUTF8String(pool, context, CYJSString(context, CYGetProperty(context, _this, name_s))) << "(";
-
- CYUTF8String string(CYPoolUTF8String(pool, context, CYJSString(context, CYGetProperty(context, _this, message_s))));
- CYStringify(str, string.data, string.size);
-
- str << ")";
-
- std::string value(str.str());
- return CYCastJSValue(context, CYJSString(CYUTF8String(value.c_str(), value.size())));
-} CYCatch(NULL) }
-
static JSValueRef String_callAsFunction_toCYON(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
CYPool pool;
std::ostringstream str;
return JSObjectMake(context, Pointer_, internal);
}
+JSObjectRef CYMakeCString(JSContextRef context, char *pointer, JSObjectRef owner) {
+ CString *internal(new CString(pointer, context, owner));
+ return JSObjectMake(context, CString_, internal);
+}
+
static JSObjectRef CYMakeFunctor(JSContextRef context, void (*function)(), const sig::Signature &signature) {
return JSObjectMake(context, Functor_, new cy::Functor(signature, function));
}
return CYGetOffset(CYPoolCString(pool, context, value), index);
}
-void *CYCastPointer_(JSContextRef context, JSValueRef value) {
+void *CYCastPointer_(JSContextRef context, JSValueRef value, bool *guess) {
if (value == NULL)
return NULL;
else switch (JSValueGetType(context, value)) {
if (CYIsCallable(context, toPointer)) {
JSValueRef value(CYCallAsFunction(context, (JSObjectRef) toPointer, object, 0, NULL));
_assert(value != NULL);
- return CYCastPointer_(context, value);
+ return CYCastPointer_(context, value, guess);
}
} default:
+ if (guess != NULL)
+ *guess = true;
+ case kJSTypeNumber:
double number(CYCastDouble(context, value));
- if (std::isnan(number))
+ if (!std::isnan(number))
+ return reinterpret_cast<void *>(static_cast<uintptr_t>(static_cast<long long>(number)));
+ if (guess == NULL)
throw CYJSError(context, "cannot convert value to pointer");
- return reinterpret_cast<void *>(static_cast<uintptr_t>(static_cast<long long>(number)));
+ else {
+ *guess = true;
+ return NULL;
+ }
}
}
*reinterpret_cast<void **>(data) = CYCastPointer<void *>(context, value);
break;
- case sig::string_P:
- _assert(pool != NULL);
- *reinterpret_cast<const char **>(data) = CYPoolCString(*pool, context, value);
- break;
+ case sig::string_P: {
+ bool guess(false);
+ *reinterpret_cast<const char **>(data) = CYCastPointer<const char *>(context, value, &guess);
+ if (guess && pool != NULL)
+ *reinterpret_cast<const char **>(data) = CYPoolCString(*pool, context, value);
+ } break;
case sig::struct_P: {
uint8_t *base(reinterpret_cast<uint8_t *>(data));
else goto null;
case sig::string_P:
- if (char *utf8 = *reinterpret_cast<char **>(data))
- return CYCastJSValue(context, utf8);
+ if (char *pointer = *reinterpret_cast<char **>(data))
+ return CYMakeCString(context, pointer, owner);
else goto null;
case sig::struct_P:
}
}
+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))
+ return NULL;
+
+ return CYCastJSValue(context, CYJSString(CYUTF8String(&string[offset], 1)));
+} 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))
+ return false;
+
+ const char *data(CYPoolCString(pool, context, value));
+ string[offset] = *data;
+ return true;
+} CYCatch(false) }
+
static bool Index_(CYPool &pool, JSContextRef context, Struct_privateData *internal, JSStringRef property, ssize_t &index, uint8_t *&base) {
Type_privateData *typical(internal->type_);
sig::Type *type(typical->type_);
}
}
+static JSObjectRef CString_new(JSContextRef context, JSObjectRef object, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
+ if (count != 1)
+ throw CYJSError(context, "incorrect number of arguments to CString constructor");
+ char *value(CYCastPointer<char *>(context, arguments[0]));
+ return CYMakeCString(context, value, NULL);
+} CYCatch(NULL) }
+
static JSObjectRef Pointer_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 Pointer constructor");
return CYMakeFunctor(context, arguments[0], signature);
} CYCatch(NULL) }
+static JSValueRef CString_callAsFunction_toPointer(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
+ CString *internal(reinterpret_cast<CString *>(JSObjectGetPrivate(_this)));
+
+ sig::Type type;
+ type.name = NULL;
+ type.flags = 0;
+
+ type.primitive = sig::char_P;
+ type.data.data.type = NULL;
+ type.data.data.size = 0;
+
+ return CYMakePointer(context, internal->value_, _not(size_t), &type, NULL, NULL);
+} CYCatch(NULL) }
+
+static JSValueRef Functor_callAsFunction_toPointer(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
+ CYPool pool;
+ cy::Functor *internal(reinterpret_cast<cy::Functor *>(JSObjectGetPrivate(_this)));
+
+ sig::Type type;
+ type.name = NULL;
+ type.flags = 0;
+
+ type.primitive = sig::function_P;
+ sig::Copy(pool, type.data.signature, internal->signature_);
+
+ return CYMakePointer(context, internal->value_, _not(size_t), &type, NULL, NULL);
+} CYCatch(NULL) }
+
+static JSValueRef Pointer_callAsFunction_toPointer(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
+ 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)));
return CYCastJSValue(context, reinterpret_cast<uintptr_t>(internal->value_));
JSObjectRef toCYON(CYCastJSObject(context, CYGetProperty(context, Array, toCYON_s)));
return CYCallAsFunction(context, toCYON, _this, count, arguments);
} else if (internal->type_->type_ == NULL) pointer: {
- char string[32];
- sprintf(string, "%p", internal->value_);
- return CYCastJSValue(context, string);
- } try {
+ CYLocalPool pool;
+ std::ostringstream str;
+
+ sig::Type type;
+ type.name = NULL;
+ type.flags = 0;
+
+ type.primitive = sig::pointer_P;
+ type.data.data.type = internal->type_->type_;
+ type.data.data.size = 0;
+
+ CYOptions options;
+ CYOutput output(*str.rdbuf(), options);
+ (new(pool) CYTypeExpression(Decode(pool, &type)))->Output(output, CYNoFlags);
+
+ str << "(" << internal->value_ << ")";
+ std::string value(str.str());
+ return CYCastJSValue(context, CYJSString(CYUTF8String(value.c_str(), value.size())));
+ } else try {
JSValueRef value(CYGetProperty(context, _this, cyi_s));
if (JSValueIsUndefined(context, value))
goto pointer;
}
} CYCatch(NULL) }
+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));
+} CYCatch(NULL) }
+
+static JSValueRef CString_getProperty_type(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { CYTry {
+ sig::Type type;
+ type.name = NULL;
+ type.flags = 0;
+
+ type.primitive = sig::char_P;
+ type.data.data.type = NULL;
+ type.data.data.size = 0;
+
+ return CYMakeType(context, &type);
+} 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 CString_callAsFunction_toCYON(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
+ Pointer *internal(reinterpret_cast<Pointer *>(JSObjectGetPrivate(_this)));
+ const char *string(static_cast<const char *>(internal->value_));
+ std::ostringstream str;
+ str << "&";
+ CYStringify(str, string, strlen(string), true);
+ 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);
+} 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_);
return Type_callAsFunction_toString(context, object, _this, count, arguments, exception);
}
-static JSStaticFunction Pointer_staticFunctions[4] = {
+static JSStaticFunction CString_staticFunctions[6] = {
+ {"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},
+ {NULL, NULL, 0}
+};
+
+static JSStaticValue CString_staticValues[3] = {
+ {"length", &CString_getProperty_length, NULL, kJSPropertyAttributeReadOnly | kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
+ {"type", &CString_getProperty_type, NULL, kJSPropertyAttributeReadOnly | kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
+ {NULL, NULL, NULL, 0}
+};
+
+static JSStaticFunction Pointer_staticFunctions[5] = {
{"toCYON", &Pointer_callAsFunction_toCYON, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
{"toJSON", &CYValue_callAsFunction_toJSON, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
+ {"toPointer", &Pointer_callAsFunction_toPointer, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
{"valueOf", &CYValue_callAsFunction_valueOf, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
{NULL, NULL, 0}
};
{NULL, NULL, 0}
};
-static JSStaticFunction Functor_staticFunctions[4] = {
+static JSStaticFunction Functor_staticFunctions[5] = {
{"toCYON", &CYValue_callAsFunction_toCYON, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
{"toJSON", &CYValue_callAsFunction_toJSON, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
+ {"toPointer", &Functor_callAsFunction_toPointer, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
{"valueOf", &CYValue_callAsFunction_valueOf, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
{NULL, NULL, 0}
};
definition.finalize = &CYFinalize;
Context_ = JSClassCreate(&definition);
+ definition = kJSClassDefinitionEmpty;
+ definition.className = "CString";
+ definition.staticFunctions = CString_staticFunctions;
+ definition.staticValues = CString_staticValues;
+ definition.getProperty = &CString_getProperty;
+ definition.setProperty = &CString_setProperty;
+ definition.finalize = &CYFinalize;
+ CString_ = JSClassCreate(&definition);
+
definition = kJSClassDefinitionEmpty;
definition.className = "Functor";
definition.staticFunctions = cy::Functor::StaticFunctions;
return reinterpret_cast<Context *>(JSObjectGetPrivate(CYCastJSObject(context, CYGetProperty(context, CYGetGlobalObject(context), cy_s))))->context_;
}
-void *CYMapFile(const char *path, size_t *psize) {
+struct CYFile {
+ void *data_;
+ size_t size_;
+
+ CYFile(void *data, size_t size) :
+ data_(data),
+ size_(size)
+ {
+ }
+};
+
+static void CYFileExit(void *data) {
+ CYFile *file(reinterpret_cast<CYFile *>(data));
+ _syscall(munmap(file->data_, file->size_));
+}
+
+static void *CYPoolFile(CYPool &pool, const char *path, size_t *psize) {
int fd(_syscall_(open(path, O_RDONLY), 1, ENOENT));
if (fd == -1)
return NULL;
void *base;
_syscall(base = mmap(NULL, size, PROT_READ, MAP_SHARED, fd, 0));
+ CYFile *file(new (pool) CYFile(base, size));
+ pool.atexit(&CYFileExit, file);
+
_syscall(close(fd));
return base;
}
-static JSValueRef require(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
- _assert(count == 1);
- CYPool pool;
+static CYUTF8String CYPoolFileUTF8String(CYPool &pool, const char *path) {
+ CYUTF8String data;
+ data.data = reinterpret_cast<char *>(CYPoolFile(pool, path, &data.size));
+ return data;
+}
+static const char *CYPoolLibraryPath(CYPool &pool) {
Dl_info addr;
- _assert(dladdr(reinterpret_cast<void *>(&require), &addr) != 0);
+ _assert(dladdr(reinterpret_cast<void *>(&CYPoolLibraryPath), &addr) != 0);
char *lib(pool.strdup(addr.dli_fname));
char *slash(strrchr(lib, '/'));
_assert(slash != NULL);
*slash = '\0';
+ return lib;
+}
+
+static JSValueRef require(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
+ _assert(count == 1);
+ CYPool pool;
+
+ const char *lib(CYPoolLibraryPath(pool));
+
CYJSString property("exports");
JSObjectRef module;
if (!JSValueIsUndefined(context, cache))
module = CYCastJSObject(context, cache);
else {
- CYUTF8String code;
- code.data = reinterpret_cast<char *>(CYMapFile(path, &code.size));
+ CYUTF8String code(CYPoolFileUTF8String(pool, path));
if (code.data == NULL) {
if (strchr(name, '/') == NULL && (
return CYGetProperty(context, module, property);
} CYCatch(NULL) }
+static bool CYRunScript(JSGlobalContextRef context, const char *path) {
+ CYPool pool;
+ CYUTF8String code(CYPoolFileUTF8String(pool, path));
+ if (code.data == NULL)
+ return false;
+
+ CYStream stream(code.data, code.data + code.size);
+ code = CYPoolCode(pool, stream);
+ _jsccall(JSEvaluateScript, context, CYJSString(code), NULL, NULL, 0);
+ return true;
+}
+
extern "C" void CYDestroyWeak(JSWeakObjectMapRef weak, void *data) {
}
JSObjectRef Error(CYCastJSObject(context, CYGetProperty(context, global, CYJSString("Error"))));
CYSetProperty(context, cy, CYJSString("Error"), Error);
- JSObjectRef Error_prototype(CYCastJSObject(context, CYGetProperty(context, Error, prototype_s)));
- CYSetProperty(context, cy, CYJSString("Error_prototype"), Error_prototype);
-
JSObjectRef Function(CYCastJSObject(context, CYGetProperty(context, global, CYJSString("Function"))));
CYSetProperty(context, cy, CYJSString("Function"), Function);
/* }}} */
CYSetProperty(context, Array_prototype, toCYON_s, &Array_callAsFunction_toCYON, kJSPropertyAttributeDontEnum);
- CYSetProperty(context, Error_prototype, toCYON_s, &Error_callAsFunction_toCYON, kJSPropertyAttributeDontEnum);
CYSetProperty(context, String_prototype, toCYON_s, &String_callAsFunction_toCYON, kJSPropertyAttributeDontEnum);
JSObjectRef cycript(JSObjectMake(context, NULL, NULL));
CYSetProperty(context, cycript, CYJSString("compile"), &Cycript_compile_callAsFunction);
CYSetProperty(context, cycript, CYJSString("gc"), &Cycript_gc_callAsFunction);
+ JSObjectRef CString(JSObjectMakeConstructor(context, CString_, &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);
CYSetProperty(context, cycript, CYJSString("Functor"), Functor);
if (CYBridgeEntry *entry = CYBridgeHash("1dlerror", 8))
entry->cache_ = new cy::Functor(entry->value_, reinterpret_cast<void (*)()>(&dlerror));
+ CYRunScript(context, "libcycript.cy");
+
for (CYHook *hook : GetHooks())
if (hook->SetupContext != NULL)
(*hook->SetupContext)(context);
projects / cycript.git / blobdiff