X-Git-Url: https://git.saurik.com/cycript.git/blobdiff_plain/24e7b1a688a2ff1cac094026d20cc6001f062581..59ffbc36a6b9383533e87321fc7769e8f3fd5a8a:/Internal.hpp?ds=sidebyside diff --git a/Internal.hpp b/Internal.hpp index 87ff055..e6f2d45 100644 --- a/Internal.hpp +++ b/Internal.hpp @@ -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 {{{ */ @@ -30,28 +30,75 @@ #include #include +#include "JavaScript.hpp" #include "Pooling.hpp" +#include "Utility.hpp" -JSGlobalContextRef CYGetJSContext(JSContextRef context); -void Structor_(CYPool &pool, sig::Type *&type); - -JSObjectRef CYMakeType(JSContextRef context, sig::Type *type); +struct CYPropertyName; -extern JSClassRef Functor_; +JSGlobalContextRef CYGetJSContext(JSContextRef context); +sig::Type *Structor_(CYPool &pool, sig::Aggregate *aggregate); -struct Type_privateData : +struct CYRoot : CYData { + // XXX: without this, CYData is zero-initialized?! + CYRoot() : + CYData() + { + } + + _finline JSValueRef GetPrototype(JSContextRef context) const { + return NULL; + } +}; + +template +struct CYPrivate { static JSClassRef Class_; - ffi_type *ffi_; - sig::Type *type_; + template + static JSObjectRef Make(JSContextRef context, Args_ &&... args) { + Internal_ *internal(new Internal_(cy::Forward(args)...)); + JSObjectRef object(JSObjectMake(context, Class_, internal)); + if (JSValueRef prototype = internal->GetPrototype(context)) + CYSetPrototype(context, object, prototype); + return object; + } + + template + static JSObjectRef Cache(JSContextRef context, Arg_ *arg) { + JSObjectRef global(CYGetGlobalObject(context)); + JSObjectRef cy(CYCastJSObject(context, CYGetProperty(context, global, cy_s))); + + char label[32]; + sprintf(label, "%s%p", Internal_::Cache_, arg); + CYJSString name(label); + + JSValueRef value(CYGetProperty(context, cy, name)); + if (!JSValueIsUndefined(context, value)) + return CYCastJSObject(context, value); - void Set(sig::Type *type) { - type_ = new(*pool_) sig::Type; - sig::Copy(*pool_, *type_, *type); + JSObjectRef object(Make(context, arg)); + CYSetProperty(context, cy, name, object); + return object; } + static Internal_ *Get(JSContextRef context, JSObjectRef object) { + _assert(JSValueIsObjectOfClass(context, object, Class_)); + return static_cast(JSObjectGetPrivate(object)); + } +}; + +template +JSClassRef CYPrivate::Class_; + +struct Type_privateData : + CYRoot +{ + ffi_type *ffi_; + sig::Type *type_; + Type_privateData(const char *type) : ffi_(NULL) { @@ -60,27 +107,16 @@ struct Type_privateData : type_ = signature.elements[0].type; } - Type_privateData(sig::Primitive primitive) : - ffi_(NULL) - { - sig::Type type; - memset(&type, 0, sizeof(type)); - type.primitive = primitive; - Set(&type); - } - - Type_privateData(sig::Type *type) : - ffi_(NULL) + Type_privateData(const sig::Type &type, ffi_type *ffi = NULL) : + type_(type.Copy(*pool_)) { - // XXX: just in case I messed up migrating - _assert(type != NULL); - Set(type); - } - Type_privateData(sig::Type *type, ffi_type *ffi) { - ffi_ = new(*pool_) ffi_type; - sig::Copy(*pool_, *ffi_, *ffi); - Set(type); + if (ffi == NULL) + ffi_ = NULL; + else { + ffi_ = new(*pool_) ffi_type; + sig::Copy(*pool_, *ffi_, *ffi); + } } ffi_type *GetFFI() { @@ -95,7 +131,7 @@ struct Type_privateData : signature.count = 1; ffi_cif cif; - sig::sig_ffi_cif(*pool_, &sig::ObjectiveC, &signature, &cif); + sig::sig_ffi_cif(*pool_, false, signature, &cif); ffi_ = new(*pool_) ffi_type; *ffi_ = *cif.rtype; @@ -105,113 +141,115 @@ struct Type_privateData : } }; -struct CYValue : - CYData -{ - void *value_; +struct CYProtect { + private: + JSGlobalContextRef context_; + JSObjectRef object_; - CYValue() { + public: + CYProtect(JSContextRef context, JSObjectRef object) : + context_(CYGetJSContext(context)), + object_(object) + { + //XXX:JSGlobalContextRetain(context_); + if (object_ != NULL) + JSValueProtect(context_, object_); } - CYValue(const void *value) : - value_(const_cast(value)) - { + ~CYProtect() { + if (object_ != NULL) + JSValueUnprotect(context_, object_); + //XXX:JSGlobalContextRelease(context_); } - CYValue(const CYValue &rhs) : - value_(rhs.value_) - { + operator bool() const { + return object_ != NULL; } - virtual Type_privateData *GetType() const { - return NULL; + operator JSContextRef() const { + return context_; + } + + operator JSObjectRef() const { + return object_; } }; -struct CYOwned : - CYValue -{ +class CYBuffer { private: - JSGlobalContextRef context_; JSObjectRef owner_; + CYPool *pool_; public: - CYOwned(void *value, JSContextRef context, JSObjectRef owner) : - CYValue(value), - context_(CYGetJSContext(context)), - owner_(owner) + CYBuffer(JSContextRef context) : + owner_(CYPrivate::Make(context)), + pool_(CYPrivate::Get(context, owner_)->pool_) { - //XXX:JSGlobalContextRetain(context_); - if (owner_ != NULL) - JSValueProtect(context_, owner_); + auto internal(CYPrivate::Get(context, owner_)); + internal->pool_->malloc(10); } - virtual ~CYOwned() { - if (owner_ != NULL) - JSValueUnprotect(context_, owner_); - //XXX:JSGlobalContextRelease(context_); + operator JSObjectRef() const { + return owner_; } - JSObjectRef GetOwner() const { - return owner_; + operator CYPool *() const { + return pool_; + } + + CYPool *operator ->() const { + return pool_; } }; namespace cy { struct Functor : - CYValue + CYRoot { + public: + static JSClassRef Class_; + private: void set() { - sig::sig_ffi_cif(*pool_, &sig::ObjectiveC, &signature_, &cif_); + sig::sig_ffi_cif(*pool_, variadic_ ? signature_.count : 0, signature_, &cif_); } public: + void (*value_)(); + bool variadic_; sig::Signature signature_; ffi_cif cif_; - Functor(const sig::Signature &signature, void (*value)()) : - CYValue(reinterpret_cast(value)) + Functor(void (*value)(), bool variadic, const sig::Signature &signature) : + value_(value), + variadic_(variadic) { sig::Copy(*pool_, signature_, signature); set(); } - Functor(const char *encoding, void (*value)()) : - CYValue(reinterpret_cast(value)) + Functor(void (*value)(), const char *encoding) : + value_(value), + variadic_(false) { sig::Parse(*pool_, &signature_, encoding, &Structor_); set(); } - void (*GetValue() const)() { - return reinterpret_cast(value_); - } - - static JSStaticFunction const * const StaticFunctions; - static JSStaticValue const * const StaticValues; + virtual CYPropertyName *GetName(CYPool &pool) const; }; } struct Closure_privateData : cy::Functor { - JSGlobalContextRef context_; - JSObjectRef function_; + CYProtect function_; JSValueRef (*adapter_)(JSContextRef, size_t, JSValueRef[], JSObjectRef); Closure_privateData(JSContextRef context, JSObjectRef function, JSValueRef (*adapter)(JSContextRef, size_t, JSValueRef[], JSObjectRef), const sig::Signature &signature) : - cy::Functor(signature, NULL), - context_(CYGetJSContext(context)), - function_(function), + cy::Functor(NULL, false, signature), + function_(context, function), adapter_(adapter) { - //XXX:JSGlobalContextRetain(context_); - JSValueProtect(context_, function_); - } - - virtual ~Closure_privateData() { - JSValueUnprotect(context_, function_); - //XXX:JSGlobalContextRelease(context_); } };