Internal.hpp

   1 /* Cycript - The Truly Universal Scripting Language
   2  * Copyright (C) 2009-2016  Jay Freeman (saurik)
   3 */
   4
   5 /* GNU Affero General Public License, Version 3 {{{ */
   6 /*
   7  * This program is free software: you can redistribute it and/or modify
   8  * it under the terms of the GNU Affero General Public License as published by
   9  * the Free Software Foundation, either version 3 of the License, or
  10  * (at your option) any later version.
  11
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU Affero General Public License for more details.
  16
  17  * You should have received a copy of the GNU Affero General Public License
  18  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19 **/
  20 /* }}} */
  21
  22 #ifndef CYCRIPT_INTERNAL_HPP
  23 #define CYCRIPT_INTERNAL_HPP
  24
  25 #include <sig/parse.hpp>
  26 #include <sig/ffi_type.hpp>
  27
  28 #include <JavaScriptCore/JSBase.h>
  29 #include <JavaScriptCore/JSContextRef.h>
  30 #include <JavaScriptCore/JSObjectRef.h>
  31 #include <JavaScriptCore/JSValueRef.h>
  32
  33 #include "JavaScript.hpp"
  34 #include "Pooling.hpp"
  35 #include "Utility.hpp"
  36
  37 JSGlobalContextRef CYGetJSContext(JSContextRef context);
  38 sig::Type *Structor_(CYPool &pool, sig::Aggregate *aggregate);
  39
  40 extern JSClassRef Functor_;
  41
  42 template <typename Internal_>
  43 struct CYPrivate :
  44     CYData
  45 {
  46     static JSClassRef Class_;
  47
  48     _finline JSValueRef GetPrototype(JSContextRef context) const {
  49         return NULL;
  50     }
  51
  52     template <typename... Args_>
  53     _finline static JSClassRef GetClass(Args_ &&... args) {
  54         return Class_;
  55     }
  56
  57     template <typename... Args_>
  58     static JSObjectRef Make(JSContextRef context, Args_ &&... args) {
  59         Internal_ *internal(new Internal_(cy::Forward<Args_>(args)...));
  60         JSObjectRef object(JSObjectMake(context, Internal_::GetClass(cy::Forward<Args_>(args)...), internal));
  61         if (JSValueRef prototype = internal->GetPrototype(context))
  62             CYSetPrototype(context, object, prototype);
  63         return object;
  64     }
  65
  66     static Internal_ *Get(JSContextRef context, JSObjectRef object) {
  67         _assert(JSValueIsObjectOfClass(context, object, Class_));
  68         return static_cast<Internal_ *>(JSObjectGetPrivate(object));
  69     }
  70 };
  71
  72 struct Type_privateData :
  73     CYPrivate<Type_privateData>
  74 {
  75     ffi_type *ffi_;
  76     sig::Type *type_;
  77
  78     Type_privateData(const char *type) :
  79         ffi_(NULL)
  80     {
  81         sig::Signature signature;
  82         sig::Parse(*pool_, &signature, type, &Structor_);
  83         type_ = signature.elements[0].type;
  84     }
  85
  86     Type_privateData(const sig::Type &type, ffi_type *ffi = NULL) :
  87         type_(type.Copy(*pool_))
  88     {
  89
  90         if (ffi == NULL)
  91             ffi_ = NULL;
  92         else {
  93             ffi_ = new(*pool_) ffi_type;
  94             sig::Copy(*pool_, *ffi_, *ffi);
  95         }
  96     }
  97
  98     ffi_type *GetFFI() {
  99         if (ffi_ == NULL) {
 100             sig::Element element;
 101             element.name = NULL;
 102             element.type = type_;
 103             element.offset = 0;
 104
 105             sig::Signature signature;
 106             signature.elements = &element;
 107             signature.count = 1;
 108
 109             ffi_cif cif;
 110             sig::sig_ffi_cif(*pool_, false, signature, &cif);
 111
 112             ffi_ = new(*pool_) ffi_type;
 113             *ffi_ = *cif.rtype;
 114         }
 115
 116         return ffi_;
 117     }
 118 };
 119
 120 template <typename Internal_>
 121 JSClassRef CYPrivate<Internal_>::Class_;
 122
 123 struct CYProtect {
 124   private:
 125     JSGlobalContextRef context_;
 126     JSObjectRef object_;
 127
 128   public:
 129     CYProtect(JSContextRef context, JSObjectRef object) :
 130         context_(CYGetJSContext(context)),
 131         object_(object)
 132     {
 133         //XXX:JSGlobalContextRetain(context_);
 134         if (object_ != NULL)
 135             JSValueProtect(context_, object_);
 136     }
 137
 138     ~CYProtect() {
 139         if (object_ != NULL)
 140             JSValueUnprotect(context_, object_);
 141         //XXX:JSGlobalContextRelease(context_);
 142     }
 143
 144     operator bool() const {
 145         return object_ != NULL;
 146     }
 147
 148     operator JSContextRef() const {
 149         return context_;
 150     }
 151
 152     operator JSObjectRef() const {
 153         return object_;
 154     }
 155 };
 156
 157 namespace cy {
 158 struct Functor :
 159     CYPrivate<Functor>
 160 {
 161   private:
 162     void set() {
 163         sig::sig_ffi_cif(*pool_, variadic_ ? signature_.count : 0, signature_, &cif_);
 164     }
 165
 166   public:
 167     void (*value_)();
 168     bool variadic_;
 169     sig::Signature signature_;
 170     ffi_cif cif_;
 171
 172     Functor(void (*value)(), bool variadic, const sig::Signature &signature) :
 173         value_(value),
 174         variadic_(variadic)
 175     {
 176         sig::Copy(*pool_, signature_, signature);
 177         set();
 178     }
 179
 180     Functor(void (*value)(), const char *encoding) :
 181         value_(value),
 182         variadic_(false)
 183     {
 184         sig::Parse(*pool_, &signature_, encoding, &Structor_);
 185         set();
 186     }
 187
 188     static JSStaticFunction const * const StaticFunctions;
 189     static JSStaticValue const * const StaticValues;
 190 }; }
 191
 192 struct Closure_privateData :
 193     cy::Functor
 194 {
 195     CYProtect function_;
 196     JSValueRef (*adapter_)(JSContextRef, size_t, JSValueRef[], JSObjectRef);
 197
 198     Closure_privateData(JSContextRef context, JSObjectRef function, JSValueRef (*adapter)(JSContextRef, size_t, JSValueRef[], JSObjectRef), const sig::Signature &signature) :
 199         cy::Functor(NULL, false, signature),
 200         function_(context, function),
 201         adapter_(adapter)
 202     {
 203     }
 204 };
 205
 206 Closure_privateData *CYMakeFunctor_(JSContextRef context, JSObjectRef function, const sig::Signature &signature, JSValueRef (*adapter)(JSContextRef, size_t, JSValueRef[], JSObjectRef));
 207 void CYExecuteClosure(ffi_cif *cif, void *result, void **arguments, void *arg, JSValueRef (*adapter)(JSContextRef, size_t, JSValueRef[], JSObjectRef));
 208
 209 #endif/*CYCRIPT_INTERNAL_HPP*/