X-Git-Url: https://git.saurik.com/cycript.git/blobdiff_plain/b799113bd4ec270504dd9f552142c1adfd6e583a..cb7b4fadaaa220075603c9c63860e22ff7ebcac1:/Internal.hpp diff --git a/Internal.hpp b/Internal.hpp index f7ad60d..9228379 100644 --- a/Internal.hpp +++ b/Internal.hpp @@ -1,21 +1,21 @@ -/* Cycript - Optimizing JavaScript Compiler/Runtime - * Copyright (C) 2009-2013 Jay Freeman (saurik) +/* Cycript - The Truly Universal Scripting Language + * Copyright (C) 2009-2016 Jay Freeman (saurik) */ -/* GNU General Public License, Version 3 {{{ */ +/* GNU Affero General Public License, Version 3 {{{ */ /* - * Cycript is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published - * by the Free Software Foundation, either version 3 of the License, - * or (at your option) any later version. - * - * Cycript is distributed in the hope that it will be useful, but - * WITHOUT ANY WARRANTY; without even the implied warranty of + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Affero General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Cycript. If not, see . + * GNU Affero General Public License for more details. + + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . **/ /* }}} */ @@ -30,37 +30,45 @@ #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, const char *type); -JSObjectRef CYMakeType(JSContextRef context, sig::Type *type); +sig::Type *Structor_(CYPool &pool, sig::Aggregate *aggregate); extern JSClassRef Functor_; -struct Type_privateData : +template +struct CYPrivate : CYData { static JSClassRef Class_; - ffi_type *ffi_; - sig::Type *type_; + _finline JSValueRef GetPrototype(JSContextRef context) const { + return NULL; + } - void Set(sig::Type *type) { - type_ = new(*pool_) sig::Type; - sig::Copy(*pool_, *type_, *type); + template + _finline static JSClassRef GetClass(Args_ &&... args) { + return Class_; } - Type_privateData(CYPool &pool, const char *type) : - CYData(pool), - ffi_(NULL) - { - sig::Signature signature; - sig::Parse(*pool_, &signature, type, &Structor_); - type_ = signature.elements[0].type; + template + static JSObjectRef Make(JSContextRef context, Args_ &&... args) { + Internal_ *internal(new Internal_(cy::Forward(args)...)); + JSObjectRef object(JSObjectMake(context, Internal_::GetClass(cy::Forward(args)...), internal)); + if (JSValueRef prototype = internal->GetPrototype(context)) + CYSetPrototype(context, object, prototype); + return object; } +}; + +struct Type_privateData : + CYPrivate +{ + ffi_type *ffi_; + sig::Type *type_; Type_privateData(const char *type) : ffi_(NULL) @@ -70,23 +78,20 @@ struct Type_privateData : type_ = signature.elements[0].type; } - Type_privateData(sig::Type *type) : - ffi_(NULL) + Type_privateData(const sig::Type &type, ffi_type *ffi = NULL) : + type_(type.Copy(*pool_)) { - if (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() { if (ffi_ == NULL) { - ffi_ = new(*pool_) ffi_type; - sig::Element element; element.name = NULL; element.type = type_; @@ -97,7 +102,9 @@ 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,16 +112,17 @@ struct Type_privateData : } }; +template struct CYValue : - CYData + CYPrivate { - void *value_; + Value_ value_; CYValue() { } - CYValue(const void *value) : - value_(const_cast(value)) + CYValue(const Value_ &value) : + value_(value) { } @@ -122,84 +130,94 @@ struct CYValue : value_(rhs.value_) { } - - virtual Type_privateData *GetType() const { - return NULL; - } }; -struct CYOwned : - CYValue -{ +template +JSClassRef CYPrivate::Class_; + +struct CYProtect { private: JSGlobalContextRef context_; - JSObjectRef owner_; + JSObjectRef object_; public: - CYOwned(void *value, JSContextRef context, JSObjectRef owner) : - CYValue(value), + CYProtect(JSContextRef context, JSObjectRef object) : context_(CYGetJSContext(context)), - owner_(owner) + object_(object) { //XXX:JSGlobalContextRetain(context_); - if (owner_ != NULL) - JSValueProtect(context_, owner_); + if (object_ != NULL) + JSValueProtect(context_, object_); } - virtual ~CYOwned() { - if (owner_ != NULL) - JSValueUnprotect(context_, owner_); + ~CYProtect() { + if (object_ != NULL) + JSValueUnprotect(context_, object_); //XXX:JSGlobalContextRelease(context_); } - JSObjectRef GetOwner() const { - return owner_; + operator bool() const { + return object_ != NULL; + } + + operator JSContextRef() const { + return context_; + } + + operator JSObjectRef() const { + return object_; } }; namespace cy { struct Functor : - CYValue + CYValue { + private: + void set() { + sig::sig_ffi_cif(*pool_, variadic_ ? signature_.count : 0, signature_, &cif_); + } + + public: + bool variadic_; sig::Signature signature_; ffi_cif cif_; - Functor(const char *type, void (*value)()) : - CYValue(reinterpret_cast(value)) + Functor(void (*value)(), bool variadic, const sig::Signature &signature) : + CYValue(value), + variadic_(variadic) { - sig::Parse(*pool_, &signature_, type, &Structor_); - sig::sig_ffi_cif(*pool_, &sig::ObjectiveC, &signature_, &cif_); + sig::Copy(*pool_, signature_, signature); + set(); } - void (*GetValue() const)() { - return reinterpret_cast(value_); + Functor(void (*value)(), const char *encoding) : + CYValue(value), + variadic_(false) + { + sig::Parse(*pool_, &signature_, encoding, &Structor_); + set(); } static JSStaticFunction const * const StaticFunctions; + static JSStaticValue const * const StaticValues; }; } struct Closure_privateData : cy::Functor { - JSGlobalContextRef context_; - JSObjectRef function_; + CYProtect function_; + JSValueRef (*adapter_)(JSContextRef, size_t, JSValueRef[], JSObjectRef); - Closure_privateData(JSContextRef context, JSObjectRef function, const char *type) : - cy::Functor(type, NULL), - context_(CYGetJSContext(context)), - function_(function) + Closure_privateData(JSContextRef context, JSObjectRef function, JSValueRef (*adapter)(JSContextRef, size_t, JSValueRef[], JSObjectRef), const sig::Signature &signature) : + 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_); } }; -Closure_privateData *CYMakeFunctor_(JSContextRef context, JSObjectRef function, const char *type, void (*callback)(ffi_cif *, void *, void **, void *)); +Closure_privateData *CYMakeFunctor_(JSContextRef context, JSObjectRef function, const sig::Signature &signature, JSValueRef (*adapter)(JSContextRef, size_t, JSValueRef[], JSObjectRef)); void CYExecuteClosure(ffi_cif *cif, void *result, void **arguments, void *arg, JSValueRef (*adapter)(JSContextRef, size_t, JSValueRef[], JSObjectRef)); #endif/*CYCRIPT_INTERNAL_HPP*/