X-Git-Url: https://git.saurik.com/cycript.git/blobdiff_plain/4b645e23d2abde4de1ced347750b070f89b685c3..3e3acd8b6cb59a34b7819f6887e5386f6b8a30c6:/Execute.cpp diff --git a/Execute.cpp b/Execute.cpp index 0b11fe6..78aaf1b 100644 --- a/Execute.cpp +++ b/Execute.cpp @@ -1,5 +1,5 @@ -/* Cycript - Optimizing JavaScript Compiler/Runtime - * Copyright (C) 2009-2015 Jay Freeman (saurik) +/* Cycript - The Truly Universal Scripting Language + * Copyright (C) 2009-2016 Jay Freeman (saurik) */ /* GNU Affero General Public License, Version 3 {{{ */ @@ -41,6 +41,7 @@ #include "sig/parse.hpp" #include "sig/ffi_type.hpp" +#include "Bridge.hpp" #include "Code.hpp" #include "Decode.hpp" #include "Error.hpp" @@ -143,6 +144,18 @@ CYUTF16String CYCastUTF16String(JSStringRef value) { return CYUTF16String(JSStringGetCharactersPtr(value), JSStringGetLength(value)); } +const char *CYPoolCString(CYPool &pool, CYUTF8String utf8) { + return pool.strndup(utf8.data, utf8.size); +} + +CYUTF8String CYPoolUTF8String(CYPool &pool, CYUTF8String utf8) { + return {pool.strndup(utf8.data, utf8.size), utf8.size}; +} + +_visible CYUTF8String CYPoolUTF8String(CYPool &pool, const std::string &value) { + return {pool.strndup(value.data(), value.size()), value.size()}; +} + CYUTF8String CYPoolUTF8String(CYPool &pool, JSContextRef context, JSStringRef value) { return CYPoolUTF8String(pool, CYCastUTF16String(value)); } @@ -180,6 +193,7 @@ JSClassRef Functor_; static JSClassRef Global_; JSStringRef Array_s; +JSStringRef constructor_s; JSStringRef cy_s; JSStringRef cyi_s; JSStringRef cyt_s; @@ -331,6 +345,11 @@ CYCastJSValue_(unsigned long int) CYCastJSValue_(signed long long int) CYCastJSValue_(unsigned long long int) +#ifdef __SIZEOF_INT128__ +CYCastJSValue_(signed __int128) +CYCastJSValue_(unsigned __int128) +#endif + JSValueRef CYJSUndefined(JSContextRef context) { return JSValueMakeUndefined(context); } @@ -416,8 +435,7 @@ _visible void CYGarbageCollect(JSContextRef context) { static JSValueRef Cycript_compile_callAsFunction(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry { CYPool pool; CYUTF8String before(CYPoolUTF8String(pool, context, CYJSString(context, arguments[0]))); - std::stringbuf value(std::string(before.data, before.size)); - CYUTF8String after(CYPoolCode(pool, value)); + CYUTF8String after(CYPoolCode(pool, before)); return CYCastJSValue(context, CYJSString(after)); } CYCatch_(NULL, "SyntaxError") } @@ -500,6 +518,22 @@ const char *CYPoolCCYON(CYPool &pool, JSContextRef context, JSObjectRef object, std::ostringstream str; + JSValueRef value(CYGetProperty(context, object, constructor_s)); + if (JSValueIsObject(context, value)) { + JSObjectRef constructor(CYCastJSObject(context, value)); + JSValueRef theory(CYGetProperty(context, constructor, prototype_s)); + JSValueRef practice(JSObjectGetPrototype(context, object)); + + if (CYIsStrictEqual(context, theory, practice)) { + JSValueRef name(CYGetProperty(context, constructor, name_s)); + if (!JSValueIsUndefined(context, name)) { + auto utf8(CYPoolUTF8String(pool, context, CYJSString(context, name))); + if (utf8 != "Object") + str << "new" << ' ' << utf8; + } + } + } + str << '{'; // XXX: this is, sadly, going to leak @@ -681,6 +715,11 @@ CYPoolFFI_(unsigned long int) CYPoolFFI_(unsigned long long int) CYPoolFFI_(unsigned short int) +#ifdef __SIZEOF_INT128__ +CYPoolFFI_(signed __int128) +CYPoolFFI_(unsigned __int128) +#endif + void Void::PoolFFI(CYPool *pool, JSContextRef context, ffi_type *ffi, void *data, JSValueRef value) const { _assert(false); } @@ -740,8 +779,13 @@ void Array::PoolFFI(CYPool *pool, JSContextRef context, ffi_type *ffi, void *dat 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); + _assert(signature.count != _not(size_t)); size_t offset(0); uint8_t *base(reinterpret_cast(data)); @@ -796,6 +840,11 @@ CYFromFFI_(unsigned long int) CYFromFFI_(unsigned long long int) CYFromFFI_(unsigned short int) +#ifdef __SIZEOF_INT128__ +CYFromFFI_(signed __int128) +CYFromFFI_(unsigned __int128) +#endif + JSValueRef Void::FromFFI(JSContextRef context, ffi_type *ffi, void *data, bool initialize, JSObjectRef owner) const { return CYJSUndefined(context); } @@ -824,7 +873,13 @@ JSValueRef Array::FromFFI(JSContextRef context, ffi_type *ffi, void *data, bool 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 { + _assert(!overlap); + _assert(signature.count != _not(size_t)); return Struct_privateData::Make(context, data, *this, ffi, context, owner); } @@ -930,7 +985,9 @@ static JSValueRef CString_getProperty(JSContextRef context, JSObjectRef object, CString *internal(reinterpret_cast(JSObjectGetPrivate(object))); ssize_t offset; - if (!CYGetOffset(pool, context, property, offset)) + if (JSStringIsEqualToUTF8CString(property, "$cyi")) + offset = 0; + else if (!CYGetOffset(pool, context, property, offset)) return NULL; return CYCastJSValue(context, CYJSString(CYUTF8String(&internal->value_[offset], 1))); @@ -941,7 +998,9 @@ static bool CString_setProperty(JSContextRef context, JSObjectRef object, JSStri CString *internal(reinterpret_cast(JSObjectGetPrivate(object))); ssize_t offset; - if (!CYGetOffset(pool, context, property, offset)) + if (JSStringIsEqualToUTF8CString(property, "$cyi")) + offset = 0; + else if (!CYGetOffset(pool, context, property, offset)) return false; const char *data(CYPoolCString(pool, context, value)); @@ -1190,7 +1249,7 @@ JSValueRef CYCallFunction(CYPool &pool, JSContextRef context, size_t setups, voi element.type->PoolFFI(&pool, context, ffi, values[index], arguments[index - setups]); } - uint8_t value[cif->rtype->size]; + uint8_t *value(pool.malloc(std::max(cif->rtype->size, sizeof(ffi_arg)), std::max(cif->rtype->alignment, alignof(ffi_arg)))); void (*call)(CYPool &, JSContextRef, ffi_cif *, void (*)(), void *, void **) = &CYCallFunction; // XXX: this only supports one hook, but it is a bad idea anyway @@ -1297,14 +1356,37 @@ static JSValueRef All_getProperty(JSContextRef context, JSObjectRef object, JSSt 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; @@ -1387,10 +1469,22 @@ static JSObjectRef Type_new(JSContextRef context, JSObjectRef object, size_t cou 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)); @@ -1415,6 +1509,7 @@ static JSObjectRef Type_new(JSContextRef context, JSObjectRef object, size_t cou _assert(JSValueIsObjectOfClass(context, object, Type_privateData::Class_)); Type_privateData *internal(reinterpret_cast(JSObjectGetPrivate(object))); element.type = internal->type_; + _assert(element.type != NULL); } return CYMakeType(context, type); @@ -1465,8 +1560,12 @@ static JSValueRef Type_callAsFunction_arrayOf(JSContextRef context, JSObjectRef } CYCatch(NULL) } static JSValueRef Type_callAsFunction_blockWith(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { +#ifdef CY_OBJECTIVEC sig::Block type; return Type_callAsFunction_$With(context, object, _this, count, arguments, type, exception); +#else + _assert(false); +#endif } static JSValueRef Type_callAsFunction_constant(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry { @@ -1480,6 +1579,37 @@ static JSValueRef Type_callAsFunction_constant(JSContextRef context, JSObjectRef 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(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); @@ -1515,10 +1645,11 @@ static JSValueRef Type_callAsFunction(JSContextRef context, JSObjectRef object, return CYMakeFunctor(context, arguments[0], function->variadic, function->signature); CYPool pool; + sig::Type *type(internal->type_); ffi_type *ffi(internal->GetFFI()); - void *data(pool.malloc(ffi->size, ffi->alignment)); + type->PoolFFI(&pool, context, ffi, data, arguments[0]); JSValueRef value(type->FromFFI(context, ffi, data)); @@ -1532,15 +1663,22 @@ static JSValueRef Type_callAsFunction(JSContextRef context, JSObjectRef object, } CYCatch(NULL) } static JSObjectRef Type_callAsConstructor(JSContextRef context, JSObjectRef object, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry { - if (count != 0) + if (count > 1) throw CYJSError(context, "incorrect number of arguments to Type allocator"); Type_privateData *internal(reinterpret_cast(JSObjectGetPrivate(object))); JSObjectRef pointer(CYMakePointer(context, NULL, *internal->type_, NULL, NULL)); Pointer *value(reinterpret_cast(JSObjectGetPrivate(pointer))); + + sig::Type *type(internal->type_); ffi_type *ffi(internal->GetFFI()); value->value_ = value->pool_->malloc(ffi->size, ffi->alignment); - memset(value->value_, 0, ffi->size); + + if (count == 0) + memset(value->value_, 0, ffi->size); + else + type->PoolFFI(value->pool_, context, ffi, value->value_, arguments[0]); + return pointer; } CYCatch(NULL) } @@ -1598,18 +1736,36 @@ static JSValueRef Functor_callAsFunction_valueOf(JSContextRef context, JSObjectR static JSValueRef Functor_callAsFunction_toCYON(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry { cy::Functor *internal(reinterpret_cast(JSObjectGetPrivate(_this))); uint8_t *value(reinterpret_cast(internal->value_)); - std::ostringstream str; - Dl_info info; - if (internal->value_ == NULL) - str << "NULL"; - else if (dladdr(value, &info) == 0) - str << internal->value_; - else { - str << info.dli_sname; - off_t offset(value - reinterpret_cast(info.dli_saddr)); - if (offset != 0) - str << "+0x" << std::hex << offset; + + CYLocalPool pool; + + sig::Function function(internal->variadic_); + sig::Copy(pool, function.signature, internal->signature_); + + CYString *name; + + auto typed(CYDecodeType(pool, &function)); { + std::ostringstream str; + Dl_info info; + if (internal->value_ == NULL) + str << "NULL"; + else if (dladdr(value, &info) == 0) + str << internal->value_; + else { + str << info.dli_sname; + off_t offset(value - reinterpret_cast(info.dli_saddr)); + if (offset != 0) + str << "+0x" << std::hex << offset; + } + + name = new(pool) CYString(pool.strdup(str.str().c_str())); } + + std::ostringstream str; + CYOptions options; + CYOutput output(*str.rdbuf(), options); + output.pretty_ = true; + (new(pool) CYExternalExpression(new(pool) CYString("C"), typed, name))->Output(output, CYNoFlags); return CYCastJSValue(context, CYJSString(str.str())); } CYCatch(NULL) } @@ -1718,7 +1874,8 @@ static JSValueRef Type_callAsFunction_toCYON(JSContextRef context, JSObjectRef o std::stringbuf out; CYOptions options; CYOutput output(out, options); - (new(pool) CYTypeExpression(CYDecodeType(pool, internal->type_)))->Output(output, CYNoFlags); + output.pretty_ = true; + (new(pool) CYTypeExpression(CYDecodeType(pool, internal->type_->Copy(pool, ""))))->Output(output, CYNoFlags); return CYCastJSValue(context, CYJSString(out.str().c_str())); } CYCatch(NULL) } @@ -1801,10 +1958,11 @@ static JSStaticValue Type_staticValues[4] = { {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}, @@ -1857,18 +2015,22 @@ class ExecutionHandle { } }; +#ifndef __ANDROID__ static volatile bool cancel_; static bool CYShouldTerminate(JSContextRef context, void *arg) { return cancel_; } +#endif _visible const char *CYExecute(JSContextRef context, CYPool &pool, CYUTF8String code) { ExecutionHandle handle(context); +#ifndef __ANDROID__ cancel_ = false; if (&JSContextGroupSetExecutionTimeLimit != NULL) JSContextGroupSetExecutionTimeLimit(JSContextGetGroup(context), 0.5, &CYShouldTerminate, NULL); +#endif try { JSValueRef result(_jsccall(JSEvaluateScript, context, CYJSString(code), NULL, NULL, 0)); @@ -1885,11 +2047,13 @@ _visible const char *CYExecute(JSContextRef context, CYPool &pool, CYUTF8String } } +#ifndef __ANDROID__ _visible void CYCancel() { cancel_ = true; } +#endif -static const char *CYPoolLibraryPath(CYPool &pool); +const char *CYPoolLibraryPath(CYPool &pool); static bool initialized_ = false; @@ -1981,6 +2145,7 @@ void CYInitializeDynamic() { Global_ = JSClassCreate(&definition); Array_s = JSStringCreateWithUTF8CString("Array"); + constructor_s = JSStringCreateWithUTF8CString("constructor"); cy_s = JSStringCreateWithUTF8CString("$cy"); cyi_s = JSStringCreateWithUTF8CString("$cyi"); cyt_s = JSStringCreateWithUTF8CString("$cyt"); @@ -2048,18 +2213,47 @@ JSGlobalContextRef CYGetJSContext(JSContextRef context) { return reinterpret_cast(JSObjectGetPrivate(CYCastJSObject(context, CYGetProperty(context, CYGetGlobalObject(context), cy_s))))->context_; } -static 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(&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(&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, '/')); - _assert(slash != NULL); + if (slash == NULL) + return "."; *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; } @@ -2068,17 +2262,43 @@ static JSValueRef require_callAsFunction(JSContextRef context, JSObjectRef objec _assert(count == 1); CYPool pool; - const char *name(CYPoolCString(pool, context, arguments[0])); - if (strchr(name, '/') == NULL && ( + CYUTF8String name(CYPoolUTF8String(pool, context, CYJSString(context, arguments[0]))); + if (memchr(name.data, '/', name.size) == NULL && ( #ifdef __APPLE__ - 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 || + dlopen(pool.strcat("/System/Library/Frameworks/", name.data, ".framework/", name.data, NULL), RTLD_LAZY | RTLD_GLOBAL) != NULL || + dlopen(pool.strcat("/System/Library/PrivateFrameworks/", name.data, ".framework/", name.data, NULL), RTLD_LAZY | RTLD_GLOBAL) != NULL || #endif false)) return CYJSUndefined(context); - JSObjectRef resolve(CYCastJSObject(context, CYGetProperty(context, object, CYJSString("resolve")))); - CYJSString path(context, CYCallAsFunction(context, resolve, NULL, 1, arguments)); + CYJSString path; + CYUTF8String code; + + sqlite3_stmt *statement; + + _sqlcall(sqlite3_prepare(database_, + "select " + "\"module\".\"code\", " + "\"module\".\"flags\" " + "from \"module\" " + "where" + " \"module\".\"name\" = ?" + " limit 1" + , -1, &statement, NULL)); + + _sqlcall(sqlite3_bind_text(statement, 1, name.data, name.size, SQLITE_STATIC)); + + if (_sqlcall(sqlite3_step(statement)) != SQLITE_DONE) { + code.data = static_cast(sqlite3_column_blob(statement, 0)); + code.size = sqlite3_column_bytes(statement, 0); + path = CYJSString(name); + code = CYPoolUTF8String(pool, code); + } else { + JSObjectRef resolve(CYCastJSObject(context, CYGetProperty(context, object, CYJSString("resolve")))); + path = CYJSString(context, CYCallAsFunction(context, resolve, NULL, 1, arguments)); + } + + _sqlcall(sqlite3_finalize(statement)); CYJSString property("exports"); @@ -2090,11 +2310,13 @@ static JSValueRef require_callAsFunction(JSContextRef context, JSObjectRef objec JSObjectRef module(CYCastJSObject(context, cache)); result = CYGetProperty(context, module, property); } else { - CYUTF8String code(CYPoolFileUTF8String(pool, CYPoolCString(pool, context, path))); - _assert(code.data != NULL); + if (code.data == NULL) { + code = CYPoolFileUTF8String(pool, CYPoolCString(pool, context, path)); + _assert(code.data != NULL); + } - size_t length(strlen(name)); - if (length >= 5 && strcmp(name + length - 5, ".json") == 0) { + size_t length(name.size); + if (length >= 5 && strncmp(name.data + length - 5, ".json", 5) == 0) { JSObjectRef JSON(CYGetCachedObject(context, CYJSString("JSON"))); JSObjectRef parse(CYCastJSObject(context, CYGetProperty(context, JSON, CYJSString("parse")))); JSValueRef arguments[1] = { CYCastJSValue(context, CYJSString(code)) }; @@ -2283,6 +2505,11 @@ extern "C" void CYSetupContext(JSGlobalContextRef context) { CYSetProperty(context, cache, CYJSString("ulong"), CYMakeType(context, sig::Primitive()), kJSPropertyAttributeDontEnum); CYSetProperty(context, cache, CYJSString("ulonglong"), CYMakeType(context, sig::Primitive()), kJSPropertyAttributeDontEnum); +#ifdef __SIZEOF_INT128__ + CYSetProperty(context, cache, CYJSString("int128"), CYMakeType(context, sig::Primitive<__int128>()), kJSPropertyAttributeDontEnum); + CYSetProperty(context, cache, CYJSString("uint128"), CYMakeType(context, sig::Primitive()), kJSPropertyAttributeDontEnum); +#endif + CYSetProperty(context, cache, CYJSString("float"), CYMakeType(context, sig::Primitive()), kJSPropertyAttributeDontEnum); CYSetProperty(context, cache, CYJSString("double"), CYMakeType(context, sig::Primitive()), kJSPropertyAttributeDontEnum);