#include "sig/parse.hpp"
#include "sig/ffi_type.hpp"
+#include "Bridge.hpp"
#include "Code.hpp"
#include "Decode.hpp"
#include "Error.hpp"
if (CYIsStrictEqual(context, theory, practice)) {
JSValueRef name(CYGetProperty(context, constructor, name_s));
- if (!JSValueIsUndefined(context, name))
- str << "new" << ' ' << CYPoolUTF8String(pool, context, CYJSString(context, name));
+ if (!JSValueIsUndefined(context, name)) {
+ auto utf8(CYPoolUTF8String(pool, context, CYJSString(context, name)));
+ if (utf8 != "Object")
+ str << "new" << ' ' << utf8;
+ }
}
}
CYArrayCopy(pool, context, base, size, type, ffi->elements[0], value, object);
}
+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);
return 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 Struct_privateData::Make(context, data, *this, ffi, context, owner);
}
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;
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));
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);
{NULL, NULL, NULL, 0}
};
-static JSStaticFunction Type_staticFunctions[9] = {
+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},
return reinterpret_cast<Context *>(JSObjectGetPrivate(CYCastJSObject(context, CYGetProperty(context, CYGetGlobalObject(context), cy_s))))->context_;
}
-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, '/'));
if (slash == NULL)
*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;
}
projects / cycript.git / blobdiff