X-Git-Url: https://git.saurik.com/cycript.git/blobdiff_plain/d6848e7305f443c0d55fc83ad93beccdb8a572ea..0abb2a2f9d5b1c7fbe7a43619bab5291d7e55f87:/Internal.hpp diff --git a/Internal.hpp b/Internal.hpp index 9819b53..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 {{{ */ @@ -34,16 +34,68 @@ #include "Pooling.hpp" #include "Utility.hpp" +struct CYPropertyName; + JSGlobalContextRef CYGetJSContext(JSContextRef context); sig::Type *Structor_(CYPool &pool, sig::Aggregate *aggregate); -extern JSClassRef Functor_; - -struct Type_privateData : +struct CYRoot : CYData { + // XXX: without this, CYData is zero-initialized?! + CYRoot() : + CYData() + { + } + + _finline JSValueRef GetPrototype(JSContextRef context) const { + return NULL; + } +}; + +template <typename Internal_> +struct CYPrivate { static JSClassRef Class_; + template <typename... Args_> + static JSObjectRef Make(JSContextRef context, Args_ &&... args) { + Internal_ *internal(new Internal_(cy::Forward<Args_>(args)...)); + JSObjectRef object(JSObjectMake(context, Class_, internal)); + if (JSValueRef prototype = internal->GetPrototype(context)) + CYSetPrototype(context, object, prototype); + return object; + } + + template <typename Arg_> + 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); + + 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<Internal_ *>(JSObjectGetPrivate(object)); + } +}; + +template <typename Internal_> +JSClassRef CYPrivate<Internal_>::Class_; + +struct Type_privateData : + CYRoot +{ ffi_type *ffi_; sig::Type *type_; @@ -89,71 +141,6 @@ struct Type_privateData : } }; -struct CYValue : - CYData -{ - void *value_; - - CYValue() { - } - - CYValue(const void *value) : - value_(const_cast<void *>(value)) - { - } - - CYValue(const CYValue &rhs) : - value_(rhs.value_) - { - } - - virtual Type_privateData *GetType() const { - return NULL; - } -}; - -template <typename Internal_, typename Value_> -struct CYValue_ : - CYValue -{ - static JSClassRef Class_; - static Type_privateData *Type_; - - using CYValue::CYValue; - - _finline Value_ GetValue() const { - return reinterpret_cast<Value_>(value_); - } - - virtual Type_privateData *GetType() const { - return Type_; - } - - _finline JSValueRef GetPrototype(JSContextRef context) const { - return NULL; - } - - template <typename... Args_> - _finline static JSClassRef GetClass(Args_ &&... args) { - return Class_; - } - - template <typename... Args_> - static JSObjectRef Make(JSContextRef context, Args_ &&... args) { - Internal_ *internal(new Internal_(cy::Forward<Args_>(args)...)); - JSObjectRef object(JSObjectMake(context, Internal_::GetClass(cy::Forward<Args_>(args)...), internal)); - if (JSValueRef prototype = internal->GetPrototype(context)) - CYSetPrototype(context, object, prototype); - return object; - } -}; - -template <typename Internal_, typename Value_> -JSClassRef CYValue_<Internal_, Value_>::Class_; - -template <typename Internal_, typename Value_> -Type_privateData *CYValue_<Internal_, Value_>::Type_; - struct CYProtect { private: JSGlobalContextRef context_; @@ -175,27 +162,66 @@ struct CYProtect { //XXX:JSGlobalContextRelease(context_); } + operator bool() const { + return object_ != NULL; + } + + operator JSContextRef() const { + return context_; + } + operator JSObjectRef() const { return object_; } }; +class CYBuffer { + private: + JSObjectRef owner_; + CYPool *pool_; + + public: + CYBuffer(JSContextRef context) : + owner_(CYPrivate<CYRoot>::Make(context)), + pool_(CYPrivate<CYRoot>::Get(context, owner_)->pool_) + { + auto internal(CYPrivate<CYRoot>::Get(context, owner_)); + internal->pool_->malloc<int>(10); + } + + operator JSObjectRef() 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_, variadic_ ? signature_.count : 0, signature_, &cif_); } public: + void (*value_)(); bool variadic_; sig::Signature signature_; ffi_cif cif_; Functor(void (*value)(), bool variadic, const sig::Signature &signature) : - CYValue(reinterpret_cast<void *>(value)), + value_(value), variadic_(variadic) { sig::Copy(*pool_, signature_, signature); @@ -203,41 +229,27 @@ struct Functor : } Functor(void (*value)(), const char *encoding) : - CYValue(reinterpret_cast<void *>(value)), + value_(value), variadic_(false) { sig::Parse(*pool_, &signature_, encoding, &Structor_); set(); } - void (*GetValue() const)() { - return reinterpret_cast<void (*)()>(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(NULL, false, signature), - context_(CYGetJSContext(context)), - function_(function), + function_(context, function), adapter_(adapter) { - //XXX:JSGlobalContextRetain(context_); - JSValueProtect(context_, function_); - } - - virtual ~Closure_privateData() { - JSValueUnprotect(context_, function_); - //XXX:JSGlobalContextRelease(context_); } };