X-Git-Url: https://git.saurik.com/cycript.git/blobdiff_plain/88c31c1e00d8a528f46aabe2e4886a78c8eedd3b..0c172698f8957c8238cd9915ca09eb8a2b68db97:/Execute.cpp?ds=sidebyside

diff --git a/Execute.cpp b/Execute.cpp
index f620f38..3399c86 100644
--- a/Execute.cpp
+++ b/Execute.cpp
@@ -181,15 +181,16 @@ static JSObjectRef (*JSObjectMakeArray$)(JSContextRef, size_t, const JSValueRef[
 JSObjectRef CYObjectMakeArray(JSContextRef context, size_t length, const JSValueRef values[]) {
     if (JSObjectMakeArray$ != NULL)
         return _jsccall(*JSObjectMakeArray$, context, length, values);
-    else {
-        JSObjectRef Array(CYGetCachedObject(context, CYJSString("Array")));
-        JSValueRef value(CYCallAsFunction(context, Array, NULL, length, values));
-        return CYCastJSObject(context, value);
-    }
+    JSObjectRef Array(CYGetCachedObject(context, CYJSString("Array")));
+    bool wat(length == 1 && JSValueGetType(context, values[0]) == kJSTypeNumber);
+    JSValueRef value(CYCallAsFunction(context, Array, NULL, wat ? 0 : length, values));
+    JSObjectRef object(CYCastJSObject(context, value));
+    if (wat) CYArrayPush(context, object, 1, values);
+    return object;
 }
 
 static JSClassRef All_;
-JSClassRef Functor_;
+JSClassRef cy::Functor::Class_;
 static JSClassRef Global_;
 
 JSStringRef Array_s;
@@ -227,7 +228,7 @@ sig::Type *Structor_(CYPool &pool, sig::Aggregate *aggregate) {
 }
 
 struct Context :
-    CYPrivate<Context>
+    CYRoot
 {
     JSGlobalContextRef context_;
 
@@ -238,7 +239,7 @@ struct Context :
 };
 
 struct CArray :
-    CYPrivate<CArray>
+    CYRoot
 {
     void *value_;
     CYProtect owner_;
@@ -251,17 +252,11 @@ struct CArray :
         type_(new(*pool_) Type_privateData(type, ffi)),
         length_(length)
     {
-        if (owner == NULL) {
-            size_t size(ffi->size * length);
-            void *copy(pool_->malloc<void>(size, ffi->alignment));
-            memcpy(copy, value_, size);
-            value_ = copy;
-        }
     }
 };
 
 struct CString :
-    CYPrivate<CString>
+    CYRoot
 {
     char *value_;
     CYProtect owner_;
@@ -270,13 +265,11 @@ struct CString :
         value_(value),
         owner_(context, owner)
     {
-        if (owner == NULL)
-            value_ = pool_->strdup(value_);
     }
 };
 
 struct Pointer :
-    CYPrivate<Pointer>
+    CYRoot
 {
     void *value_;
     CYProtect owner_;
@@ -298,7 +291,7 @@ struct Pointer :
 };
 
 struct Struct_privateData :
-    CYPrivate<Struct_privateData>
+    CYRoot
 {
     void *value_;
     CYProtect owner_;
@@ -340,6 +333,7 @@ JSValueRef CYCastJSValue(JSContextRef context, double value) {
         return JSValueMakeNumber(context, static_cast<double>(value)); \
     }
 
+CYCastJSValue_(long double)
 CYCastJSValue_(signed short int)
 CYCastJSValue_(unsigned short int)
 CYCastJSValue_(signed int)
@@ -430,6 +424,22 @@ static JSValueRef System_print(JSContextRef context, JSObjectRef object, JSObjec
     return CYJSUndefined(context);
 } CYCatch(NULL) }
 
+static JSValueRef Global_print(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
+    FILE *file(stdout);
+    CYPool pool;
+
+    for (size_t i(0); i != count; ++i) {
+        if (i != 0)
+            fputc(' ', file);
+        CYUTF8String string(CYPoolUTF8String(pool, context, CYJSString(context, arguments[i])));
+        fwrite(string.data, string.size, 1, file);
+    }
+
+    fputc('\n', file);
+    fflush(file);
+    return CYJSUndefined(context);
+} CYCatch(NULL) }
+
 static void (*JSSynchronousGarbageCollectForDebugging$)(JSContextRef);
 
 _visible void CYGarbageCollect(JSContextRef context) {
@@ -467,7 +477,7 @@ const char *CYPoolCCYON(CYPool &pool, JSContextRef context, JSValueRef value, st
         case kJSTypeString: {
             std::ostringstream str;
             CYUTF8String string(CYPoolUTF8String(pool, context, CYJSString(context, value)));
-            CYStringify(str, string.data, string.size);
+            CYStringify(str, string.data, string.size, CYStringifyModeCycript);
             std::string value(str.str());
             return pool.strmemdup(value.c_str(), value.size());
         } break;
@@ -557,7 +567,7 @@ const char *CYPoolCCYON(CYPool &pool, JSContextRef context, JSObjectRef object,
         if (CYIsKey(string))
             str << string.data;
         else
-            CYStringify(str, string.data, string.size);
+            CYStringify(str, string.data, string.size, CYStringifyModeLegacy);
 
         str << ':';
 
@@ -628,20 +638,20 @@ static JSValueRef String_callAsFunction_toCYON(JSContextRef context, JSObjectRef
     std::ostringstream str;
 
     CYUTF8String string(CYPoolUTF8String(pool, context, CYJSString(context, _this)));
-    CYStringify(str, string.data, string.size);
+    CYStringify(str, string.data, string.size, CYStringifyModeCycript);
 
     std::string value(str.str());
     return CYCastJSValue(context, CYJSString(CYUTF8String(value.c_str(), value.size())));
 } CYCatch(NULL) }
 
 JSObjectRef CYMakePointer(JSContextRef context, void *pointer, const sig::Type &type, ffi_type *ffi, JSObjectRef owner) {
-    return Pointer::Make(context, pointer, type, context, owner);
+    return CYPrivate<Pointer>::Make(context, pointer, type, context, owner);
 }
 
 static JSValueRef CYMakeFunctor(JSContextRef context, void (*function)(), bool variadic, const sig::Signature &signature) {
     if (function == NULL)
         return CYJSNull(context);
-    return JSObjectMake(context, Functor_, new cy::Functor(function, variadic, signature));
+    return JSObjectMake(context, cy::Functor::Class_, new cy::Functor(function, variadic, signature));
 }
 
 // XXX: remove this, as it is really stupid
@@ -652,7 +662,7 @@ static JSObjectRef CYMakeFunctor(JSContextRef context, const char *symbol, const
 
     cy::Functor *internal(new cy::Functor(function, encoding));
     ++internal->count_;
-    return JSObjectMake(context, Functor_, internal);
+    return JSObjectMake(context, cy::Functor::Class_, internal);
 }
 
 bool CYGetOffset(CYPool &pool, JSContextRef context, JSStringRef value, ssize_t &index) {
@@ -667,7 +677,7 @@ void *CYCastPointer_(JSContextRef context, JSValueRef value, bool *guess) {
             return NULL;
         case kJSTypeObject: {
             JSObjectRef object((JSObjectRef) value);
-            if (JSValueIsObjectOfClass(context, value, Pointer::Class_)) {
+            if (JSValueIsObjectOfClass(context, value, CYPrivate<Pointer>::Class_)) {
                 Pointer *internal(reinterpret_cast<Pointer *>(JSObjectGetPrivate(object)));
                 return internal->value_;
             }
@@ -708,14 +718,17 @@ void Primitive<Type_>::PoolFFI(CYPool *pool, JSContextRef context, ffi_type *ffi
     *reinterpret_cast<Type_ *>(data) = CYCastDouble(context, value); \
 }
 
-CYPoolFFI_(char)
-CYPoolFFI_(double)
+CYPoolFFI_(wchar_t)
 CYPoolFFI_(float)
+CYPoolFFI_(double)
+CYPoolFFI_(long double)
+
 CYPoolFFI_(signed char)
 CYPoolFFI_(signed int)
 CYPoolFFI_(signed long int)
 CYPoolFFI_(signed long long int)
 CYPoolFFI_(signed short int)
+
 CYPoolFFI_(unsigned char)
 CYPoolFFI_(unsigned int)
 CYPoolFFI_(unsigned long int)
@@ -727,6 +740,18 @@ CYPoolFFI_(signed __int128)
 CYPoolFFI_(unsigned __int128)
 #endif
 
+template <>
+void Primitive<char>::PoolFFI(CYPool *pool, JSContextRef context, ffi_type *ffi, void *data, JSValueRef value) const {
+    if (JSValueGetType(context, value) != kJSTypeString)
+        *reinterpret_cast<char *>(data) = CYCastDouble(context, value);
+    else {
+        CYJSString script(context, value);
+        auto string(CYCastUTF16String(script));
+        _assert(string.size == 1);
+        *reinterpret_cast<char *>(data) = string.data[0];
+    }
+}
+
 void Void::PoolFFI(CYPool *pool, JSContextRef context, ffi_type *ffi, void *data, JSValueRef value) const {
     _assert(false);
 }
@@ -833,14 +858,17 @@ JSValueRef Primitive<Type_>::FromFFI(JSContextRef context, ffi_type *ffi, void *
 }
 
 CYFromFFI_(bool)
-CYFromFFI_(char)
-CYFromFFI_(double)
+CYFromFFI_(wchar_t)
 CYFromFFI_(float)
+CYFromFFI_(double)
+CYFromFFI_(long double)
+
 CYFromFFI_(signed char)
 CYFromFFI_(signed int)
 CYFromFFI_(signed long int)
 CYFromFFI_(signed long long int)
 CYFromFFI_(signed short int)
+
 CYFromFFI_(unsigned char)
 CYFromFFI_(unsigned int)
 CYFromFFI_(unsigned long int)
@@ -852,6 +880,16 @@ CYFromFFI_(signed __int128)
 CYFromFFI_(unsigned __int128)
 #endif
 
+template <>
+JSValueRef Primitive<char>::FromFFI(JSContextRef context, ffi_type *ffi, void *data, bool initialize, JSObjectRef owner) const {
+    uint16_t string(uint8_t(*reinterpret_cast<char *>(data)));
+    JSValueRef value(CYCastJSValue(context, CYJSString(CYUTF16String(&string, 1))));
+    JSObjectRef typed(_jsccall(JSObjectCallAsConstructor, context, CYGetCachedObject(context, CYJSString("String")), 1, &value));
+    CYSetProperty(context, typed, cyt_s, CYMakeType(context, sig::Primitive<char>()), kJSPropertyAttributeDontEnum);
+    CYSetPrototype(context, typed, CYGetCachedValue(context, CYJSString("Character_prototype")));
+    return typed;
+}
+
 JSValueRef Void::FromFFI(JSContextRef context, ffi_type *ffi, void *data, bool initialize, JSObjectRef owner) const {
     return CYJSUndefined(context);
 }
@@ -862,7 +900,7 @@ JSValueRef Unknown::FromFFI(JSContextRef context, ffi_type *ffi, void *data, boo
 
 JSValueRef String::FromFFI(JSContextRef context, ffi_type *ffi, void *data, bool initialize, JSObjectRef owner) const {
     if (char *value = *reinterpret_cast<char **>(data))
-        return CString::Make(context, value, context, owner);
+        return CYPrivate<CString>::Make(context, value, context, owner);
     return CYJSNull(context);
 }
 
@@ -877,7 +915,7 @@ JSValueRef Pointer::FromFFI(JSContextRef context, ffi_type *ffi, void *data, boo
 }
 
 JSValueRef Array::FromFFI(JSContextRef context, ffi_type *ffi, void *data, bool initialize, JSObjectRef owner) const {
-    return CArray::Make(context, data, size, type, ffi->elements[0], context, owner);
+    return CYPrivate<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 {
@@ -887,7 +925,7 @@ JSValueRef Enum::FromFFI(JSContextRef context, ffi_type *ffi, void *data, bool i
 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);
+    return CYPrivate<Struct_privateData>::Make(context, data, *this, ffi, context, owner);
 }
 
 JSValueRef Function::FromFFI(JSContextRef context, ffi_type *ffi, void *data, bool initialize, JSObjectRef owner) const {
@@ -960,7 +998,7 @@ Closure_privateData *CYMakeFunctor_(JSContextRef context, JSObjectRef function,
 
 static JSObjectRef CYMakeFunctor(JSContextRef context, JSObjectRef function, const sig::Signature &signature) {
     Closure_privateData *internal(CYMakeFunctor_(context, function, signature, &FunctionAdapter_));
-    JSObjectRef object(JSObjectMake(context, Functor_, internal));
+    JSObjectRef object(JSObjectMake(context, cy::Functor::Class_, internal));
     // XXX: see above notes about needing to leak
     JSValueProtect(CYGetJSContext(context), object);
     return object;
@@ -997,7 +1035,8 @@ static JSValueRef CString_getProperty(JSContextRef context, JSObjectRef object,
     else if (!CYGetOffset(pool, context, property, offset))
         return NULL;
 
-    return CYCastJSValue(context, CYJSString(CYUTF8String(&internal->value_[offset], 1)));
+    sig::Primitive<char> type;
+    return type.FromFFI(context, type.GetFFI(pool), internal->value_ + offset, false, NULL);
 } CYCatch(NULL) }
 
 static bool CString_setProperty(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef value, JSValueRef *exception) { CYTry {
@@ -1010,8 +1049,8 @@ static bool CString_setProperty(JSContextRef context, JSObjectRef object, JSStri
     else if (!CYGetOffset(pool, context, property, offset))
         return false;
 
-    const char *data(CYPoolCString(pool, context, value));
-    internal->value_[offset] = *data;
+    sig::Primitive<char> type;
+    type.PoolFFI(NULL, context, type.GetFFI(pool), internal->value_ + offset, value);
     return true;
 } CYCatch(false) }
 
@@ -1206,7 +1245,7 @@ static sig::Type *CYGetType(CYPool &pool, JSContextRef context, JSValueRef value
         return &PointerToVoid_;
     JSObjectRef object(CYCastJSObject(context, value));
     JSObjectRef type(CYCastJSObject(context, CYGetProperty(context, object, cyt_s)));
-    _assert(JSValueIsObjectOfClass(context, type, Type_privateData::Class_));
+    _assert(JSValueIsObjectOfClass(context, type, CYPrivate<Type_privateData>::Class_));
     Type_privateData *internal(reinterpret_cast<Type_privateData *>(JSObjectGetPrivate(type)));
     return internal->type_;
 }
@@ -1256,7 +1295,8 @@ JSValueRef CYCallFunction(CYPool &pool, JSContextRef context, size_t setups, voi
         element.type->PoolFFI(&pool, context, ffi, values[index], arguments[index - setups]);
     }
 
-    uint8_t *value(pool.malloc<uint8_t>(std::max<size_t>(cif->rtype->size, sizeof(ffi_arg)), std::max<size_t>(cif->rtype->alignment, alignof(ffi_arg))));
+    CYBuffer buffer(context);
+    uint8_t *value(buffer->malloc<uint8_t>(std::max<size_t>(cif->rtype->size, sizeof(ffi_arg)), std::max<size_t>(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
@@ -1265,7 +1305,7 @@ JSValueRef CYCallFunction(CYPool &pool, JSContextRef context, size_t setups, voi
             call = hook->CallFunction;
 
     call(pool, context, cif, function, value, values);
-    return signature.elements[0].type->FromFFI(context, cif->rtype, value, initialize);
+    return signature.elements[0].type->FromFFI(context, cif->rtype, value, initialize, buffer);
 }
 
 static JSValueRef Functor_callAsFunction(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
@@ -1283,7 +1323,7 @@ static JSValueRef Pointer_callAsFunction(JSContextRef context, JSObjectRef objec
 } CYCatch(NULL) }
 
 JSObjectRef CYMakeType(JSContextRef context, const sig::Type &type) {
-    return Type_privateData::Make(context, type);
+    return CYPrivate<Type_privateData>::Make(context, type);
 }
 
 extern "C" bool CYBridgeHash(CYPool &pool, CYUTF8String name, const char *&code, unsigned &flags) {
@@ -1400,7 +1440,7 @@ static JSValueRef All_getProperty(JSContextRef context, JSObjectRef object, JSSt
 } CYCatch(NULL) }
 
 static JSValueRef All_complete_callAsFunction(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
-    _assert(count == 1);
+    _assert(count == 1 || count == 2);
     CYPool pool;
     CYUTF8String prefix(CYPoolUTF8String(pool, context, CYJSString(context, arguments[0])));
 
@@ -1461,15 +1501,15 @@ static void All_getPropertyNames(JSContextRef context, JSObjectRef object, JSPro
 
 static JSObjectRef CArray_new(JSContextRef context, JSObjectRef object, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
     _assert(false);
-} CYCatch(NULL) }
+} CYCatchObject() }
 
 static JSObjectRef CString_new(JSContextRef context, JSObjectRef object, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
     _assert(false);
-} CYCatch(NULL) }
+} CYCatchObject() }
 
 static JSObjectRef Pointer_new(JSContextRef context, JSObjectRef object, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
     _assert(false);
-} CYCatch(NULL) }
+} CYCatchObject() }
 
 static JSObjectRef Type_new(JSContextRef context, JSObjectRef object, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
     CYPool pool;
@@ -1513,7 +1553,7 @@ static JSObjectRef Type_new(JSContextRef context, JSObjectRef object, size_t cou
                 element.name = CYPoolCString(pool, context, name);
 
             JSObjectRef object(CYCastJSObject(context, CYArrayGet(context, types, i)));
-            _assert(JSValueIsObjectOfClass(context, object, Type_privateData::Class_));
+            _assert(JSValueIsObjectOfClass(context, object, CYPrivate<Type_privateData>::Class_));
             Type_privateData *internal(reinterpret_cast<Type_privateData *>(JSObjectGetPrivate(object)));
             element.type = internal->type_;
             _assert(element.type != NULL);
@@ -1523,7 +1563,7 @@ static JSObjectRef Type_new(JSContextRef context, JSObjectRef object, size_t cou
     } else {
         throw CYJSError(context, "incorrect number of arguments to Type constructor");
     }
-} CYCatch(NULL) }
+} CYCatchObject() }
 
 static JSValueRef Type_callAsFunction_$With(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], sig::Callable &type, JSValueRef *exception) { CYTry {
     Type_privateData *internal(reinterpret_cast<Type_privateData *>(JSObjectGetPrivate(_this)));
@@ -1543,7 +1583,7 @@ static JSValueRef Type_callAsFunction_$With(JSContextRef context, JSObjectRef ob
         element.offset = _not(size_t);
 
         JSObjectRef object(CYCastJSObject(context, arguments[i]));
-        _assert(JSValueIsObjectOfClass(context, object, Type_privateData::Class_));
+        _assert(JSValueIsObjectOfClass(context, object, CYPrivate<Type_privateData>::Class_));
         Type_privateData *internal(reinterpret_cast<Type_privateData *>(JSObjectGetPrivate(object)));
 
         element.type = internal->type_;
@@ -1651,14 +1691,21 @@ static JSValueRef Type_callAsFunction(JSContextRef context, JSObjectRef object,
     if (sig::Function *function = dynamic_cast<sig::Function *>(internal->type_))
         return CYMakeFunctor(context, arguments[0], function->variadic, function->signature);
 
-    CYPool pool;
+    CYBuffer buffer(context);
 
     sig::Type *type(internal->type_);
     ffi_type *ffi(internal->GetFFI());
-    void *data(pool.malloc<void>(ffi->size, ffi->alignment));
 
-    type->PoolFFI(&pool, context, ffi, data, arguments[0]);
-    JSValueRef value(type->FromFFI(context, ffi, data));
+    void *data;
+    if (_this == NULL || CYIsStrictEqual(context, _this, CYGetGlobalObject(context)))
+        data = buffer->malloc<void>(ffi->size, ffi->alignment);
+    else {
+        CYSetProperty(context, buffer, CYJSString("$cyo"), _this, kJSPropertyAttributeDontEnum);
+        data = CYCastPointer<void *>(context, _this);
+    }
+
+    type->PoolFFI(buffer, context, ffi, data, arguments[0]);
+    JSValueRef value(type->FromFFI(context, ffi, data, false, buffer));
 
     if (JSValueGetType(context, value) == kJSTypeNumber) {
         JSObjectRef typed(_jsccall(JSObjectCallAsConstructor, context, CYGetCachedObject(context, CYJSString("Number")), 1, &value));
@@ -1687,7 +1734,7 @@ static JSObjectRef Type_callAsConstructor(JSContextRef context, JSObjectRef obje
         type->PoolFFI(value->pool_, context, ffi, value->value_, arguments[0]);
 
     return pointer;
-} CYCatch(NULL) }
+} CYCatchObject() }
 
 // XXX: I don't even think the user should be allowed to do this
 static JSObjectRef Functor_new(JSContextRef context, JSObjectRef object, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
@@ -1699,7 +1746,7 @@ static JSObjectRef Functor_new(JSContextRef context, JSObjectRef object, size_t
     sig::Parse(pool, &signature, encoding, &Structor_);
     // XXX: this can try to return null, and I guess then it just fails
     return CYCastJSObject(context, CYMakeFunctor(context, arguments[0], false, signature));
-} CYCatch(NULL) }
+} CYCatchObject() }
 
 static JSValueRef CArray_callAsFunction_toPointer(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
     CArray *internal(reinterpret_cast<CArray *>(JSObjectGetPrivate(_this)));
@@ -1745,30 +1792,15 @@ 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<cy::Functor *>(JSObjectGetPrivate(_this)));
     uint8_t *value(reinterpret_cast<uint8_t *>(internal->value_));
+    _assert(value != NULL);
 
     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<uint8_t *>(info.dli_saddr));
-            if (offset != 0)
-                str << "+0x" << std::hex << offset;
-        }
-
-        name = new(pool) CYString(pool.strdup(str.str().c_str()));
-    }
+    CYPropertyName *name(internal->GetName(pool));
+    auto typed(CYDecodeType(pool, &function));
 
     std::ostringstream str;
     CYOptions options;
@@ -1778,6 +1810,19 @@ static JSValueRef Functor_callAsFunction_toCYON(JSContextRef context, JSObjectRe
     return CYCastJSValue(context, CYJSString(str.str()));
 } CYCatch(NULL) }
 
+CYPropertyName *cy::Functor::GetName(CYPool &pool) const {
+    Dl_info info;
+    if (dladdr(reinterpret_cast<void *>(value_), &info) == 0 || strcmp(info.dli_sname, "<redacted>") == 0)
+        return new(pool) CYNumber(reinterpret_cast<uintptr_t>(value_));
+
+    std::ostringstream str;
+    str << info.dli_sname;
+    off_t offset(reinterpret_cast<uint8_t *>(value_) - reinterpret_cast<uint8_t *>(info.dli_saddr));
+    if (offset != 0)
+        str << "+0x" << std::hex << offset;
+    return new(pool) CYString(pool.strdup(str.str().c_str()));
+}
+
 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));
 
@@ -1836,7 +1881,7 @@ static JSValueRef CString_callAsFunction_toCYON(JSContextRef context, JSObjectRe
         str << "NULL";
     else {
         str << "&";
-        CYStringify(str, string, strlen(string), true);
+        CYStringify(str, string, strlen(string), CYStringifyModeNative);
     }
     std::string value(str.str());
     return CYCastJSValue(context, CYJSString(CYUTF8String(value.c_str(), value.size())));
@@ -1947,19 +1992,11 @@ static JSStaticFunction Functor_staticFunctions[4] = {
     {NULL, NULL, 0}
 };
 
-namespace cy {
-    JSStaticFunction const * const Functor::StaticFunctions = Functor_staticFunctions;
-}
-
 static JSStaticValue Functor_staticValues[2] = {
     {"$cyt", &Functor_getProperty_$cyt, NULL, kJSPropertyAttributeReadOnly | kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
     {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},
@@ -1980,15 +2017,24 @@ static JSStaticFunction Type_staticFunctions[10] = {
     {NULL, NULL, 0}
 };
 
-_visible void CYSetArgs(int argc, const char *argv[]) {
+_visible void CYSetArgs(const char *argv0, const char *script, int argc, const char *argv[]) {
     JSContextRef context(CYGetJSContext());
-    JSValueRef args[argc];
+    JSValueRef args[argc + 2];
     for (int i(0); i != argc; ++i)
-        args[i] = CYCastJSValue(context, argv[i]);
+        args[i + 2] = CYCastJSValue(context, argv[i]);
+
+    size_t offset;
+    if (script == NULL)
+        offset = 1;
+    else {
+        offset = 0;
+        args[1] = CYCastJSValue(context, CYJSString(script));
+    }
 
-    JSObjectRef array(CYObjectMakeArray(context, argc, args));
-    JSObjectRef System(CYGetCachedObject(context, CYJSString("System")));
-    CYSetProperty(context, System, CYJSString("args"), array);
+    args[offset] = CYCastJSValue(context, CYJSString(argv0));
+
+    CYSetProperty(context, CYGetCachedObject(context, CYJSString("System")), CYJSString("args"), CYObjectMakeArray(context, argc, args + 2));
+    CYSetProperty(context, CYGetCachedObject(context, CYJSString("process")), CYJSString("argv"), CYObjectMakeArray(context, argc + 2 - offset, args + offset));
 }
 
 JSObjectRef CYGetGlobalObject(JSContextRef context) {
@@ -2091,7 +2137,7 @@ void CYInitializeDynamic() {
     definition = kJSClassDefinitionEmpty;
     definition.className = "Context";
     definition.finalize = &CYFinalize;
-    Context::Class_ = JSClassCreate(&definition);
+    CYPrivate<Context>::Class_ = JSClassCreate(&definition);
 
     definition = kJSClassDefinitionEmpty;
     definition.className = "CArray";
@@ -2100,7 +2146,7 @@ void CYInitializeDynamic() {
     definition.getProperty = &CArray_getProperty;
     definition.setProperty = &CArray_setProperty;
     definition.finalize = &CYFinalize;
-    CArray::Class_ = JSClassCreate(&definition);
+    CYPrivate<CArray>::Class_ = JSClassCreate(&definition);
 
     definition = kJSClassDefinitionEmpty;
     definition.className = "CString";
@@ -2109,15 +2155,15 @@ void CYInitializeDynamic() {
     definition.getProperty = &CString_getProperty;
     definition.setProperty = &CString_setProperty;
     definition.finalize = &CYFinalize;
-    CString::Class_ = JSClassCreate(&definition);
+    CYPrivate<CString>::Class_ = JSClassCreate(&definition);
 
     definition = kJSClassDefinitionEmpty;
     definition.className = "Functor";
-    definition.staticFunctions = cy::Functor::StaticFunctions;
+    definition.staticFunctions = Functor_staticFunctions;
     definition.staticValues = Functor_staticValues;
     definition.callAsFunction = &Functor_callAsFunction;
     definition.finalize = &CYFinalize;
-    Functor_ = JSClassCreate(&definition);
+    cy::Functor::Class_ = JSClassCreate(&definition);
 
     definition = kJSClassDefinitionEmpty;
     definition.className = "Pointer";
@@ -2127,7 +2173,12 @@ void CYInitializeDynamic() {
     definition.getProperty = &Pointer_getProperty;
     definition.setProperty = &Pointer_setProperty;
     definition.finalize = &CYFinalize;
-    Pointer::Class_ = JSClassCreate(&definition);
+    CYPrivate<Pointer>::Class_ = JSClassCreate(&definition);
+
+    definition = kJSClassDefinitionEmpty;
+    definition.className = "Root";
+    definition.finalize = &CYFinalize;
+    CYPrivate<CYRoot>::Class_ = JSClassCreate(&definition);
 
     definition = kJSClassDefinitionEmpty;
     definition.className = "Struct";
@@ -2137,7 +2188,7 @@ void CYInitializeDynamic() {
     definition.setProperty = &Struct_setProperty;
     definition.getPropertyNames = &Struct_getPropertyNames;
     definition.finalize = &CYFinalize;
-    Struct_privateData::Class_ = JSClassCreate(&definition);
+    CYPrivate<Struct_privateData>::Class_ = JSClassCreate(&definition);
 
     definition = kJSClassDefinitionEmpty;
     definition.className = "Type";
@@ -2146,7 +2197,7 @@ void CYInitializeDynamic() {
     definition.callAsFunction = &Type_callAsFunction;
     definition.callAsConstructor = &Type_callAsConstructor;
     definition.finalize = &CYFinalize;
-    Type_privateData::Class_ = JSClassCreate(&definition);
+    CYPrivate<Type_privateData>::Class_ = JSClassCreate(&definition);
 
     definition = kJSClassDefinitionEmpty;
     definition.className = "Global";
@@ -2372,7 +2423,7 @@ extern "C" void CYSetupContext(JSGlobalContextRef context) {
 
     JSObjectRef global(CYGetGlobalObject(context));
 
-    JSObjectRef cy(Context::Make(context, context));
+    JSObjectRef cy(CYPrivate<Context>::Make(context, context));
     CYSetProperty(context, global, cy_s, cy, kJSPropertyAttributeDontEnum);
 
 /* Cache Globals {{{ */
@@ -2430,20 +2481,32 @@ extern "C" void CYSetupContext(JSGlobalContextRef context) {
     CYSetProperty(context, cycript, CYJSString("compile"), &Cycript_compile_callAsFunction);
     CYSetProperty(context, cycript, CYJSString("gc"), &Cycript_gc_callAsFunction);
 
-    JSObjectRef CArray(JSObjectMakeConstructor(context, CArray::Class_, &CArray_new));
+    JSObjectRef CArray(JSObjectMakeConstructor(context, CYPrivate<::CArray>::Class_, &CArray_new));
     CYSetPrototype(context, CYCastJSObject(context, CYGetProperty(context, CArray, prototype_s)), Array_prototype);
     CYSetProperty(context, cycript, CYJSString("CArray"), CArray);
 
-    JSObjectRef CString(JSObjectMakeConstructor(context, CString::Class_, &CString_new));
+    JSObjectRef CString(JSObjectMakeConstructor(context, CYPrivate<::CString>::Class_, &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);
+    JSObjectRef Functor(JSObjectMakeConstructor(context, cy::Functor::Class_, &Functor_new));
+    JSObjectRef Functor_prototype(CYCastJSObject(context, CYGetProperty(context, Functor, prototype_s)));
+    CYSetPrototype(context, Functor_prototype, Function_prototype);
+    CYSetProperty(context, cy, CYJSString("Functor_prototype"), Functor_prototype);
     CYSetProperty(context, cycript, CYJSString("Functor"), Functor);
 
-    CYSetProperty(context, cycript, CYJSString("Pointer"), JSObjectMakeConstructor(context, Pointer::Class_, &Pointer_new));
-    CYSetProperty(context, cycript, CYJSString("Type"), JSObjectMakeConstructor(context, Type_privateData::Class_, &Type_new));
+    CYSetProperty(context, cycript, CYJSString("Pointer"), JSObjectMakeConstructor(context, CYPrivate<Pointer>::Class_, &Pointer_new));
+
+    JSObjectRef Type(JSObjectMakeConstructor(context, CYPrivate<Type_privateData>::Class_, &Type_new));
+    JSObjectRef Type_prototype(CYCastJSObject(context, CYGetProperty(context, Type, prototype_s)));
+    CYSetPrototype(context, Type_prototype, Function_prototype);
+    CYSetProperty(context, cy, CYJSString("Type_prototype"), Type_prototype);
+    CYSetProperty(context, cycript, CYJSString("Type"), Type);
+
+    JSObjectRef Character_prototype(JSObjectMake(context, NULL, NULL));
+    CYSetPrototype(context, Character_prototype, String_prototype);
+    CYSetProperty(context, cy, CYJSString("Character_prototype"), Character_prototype);
+    CYSetProperty(context, Character_prototype, CYJSString("valueOf"), _jsccall(JSEvaluateScript, context, CYJSString("(function(){return this.charCodeAt(0);})"), NULL, NULL, 0));
 
     JSObjectRef modules(JSObjectMake(context, NULL, NULL));
     CYSetProperty(context, cy, CYJSString("modules"), modules);
@@ -2473,17 +2536,6 @@ extern "C" void CYSetupContext(JSGlobalContextRef context) {
         CYSetPrototype(context, last, cache);
     }
 
-    JSObjectRef System(JSObjectMake(context, NULL, NULL));
-    CYSetProperty(context, cy, CYJSString("System"), System);
-
-    CYSetProperty(context, global, CYJSString("require"), &require_callAsFunction, kJSPropertyAttributeDontEnum);
-
-    CYSetProperty(context, global, CYJSString("system"), System);
-    CYSetProperty(context, System, CYJSString("args"), CYJSNull(context));
-    CYSetProperty(context, System, CYJSString("print"), &System_print);
-
-    CYSetProperty(context, global, CYJSString("global"), global);
-
 #ifdef __APPLE__
     if (&JSWeakObjectMapCreate != NULL) {
         JSWeakObjectMapRef weak(JSWeakObjectMapCreate(context, NULL, &CYDestroyWeak));
@@ -2521,6 +2573,24 @@ extern "C" void CYSetupContext(JSGlobalContextRef context) {
 
     CYSetProperty(context, cache, CYJSString("float"), CYMakeType(context, sig::Primitive<float>()), kJSPropertyAttributeDontEnum);
     CYSetProperty(context, cache, CYJSString("double"), CYMakeType(context, sig::Primitive<double>()), kJSPropertyAttributeDontEnum);
+    CYSetProperty(context, cache, CYJSString("longdouble"), CYMakeType(context, sig::Primitive<long double>()), kJSPropertyAttributeDontEnum);
+
+    CYSetProperty(context, global, CYJSString("require"), &require_callAsFunction, kJSPropertyAttributeDontEnum);
+
+    JSObjectRef System(JSObjectMake(context, NULL, NULL));
+    CYSetProperty(context, all, CYJSString("system"), System);
+    System = CYCastJSObject(context, CYGetProperty(context, global, CYJSString("system")));
+    CYSetProperty(context, cy, CYJSString("System"), System);
+
+    JSObjectRef process(JSObjectMake(context, NULL, NULL));
+    CYSetProperty(context, global, CYJSString("process"), process);
+    CYSetProperty(context, cy, CYJSString("process"), process);
+
+    CYSetProperty(context, System, CYJSString("args"), CYJSNull(context));
+    CYSetProperty(context, System, CYJSString("print"), &System_print);
+
+    CYSetProperty(context, global, CYJSString("global"), global);
+    CYSetProperty(context, global, CYJSString("print"), &Global_print);
 
     for (CYHook *hook : GetHooks())
         if (hook->SetupContext != NULL)