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 struct CYRoot :
  43     CYData
  44 {
  45     _finline JSValueRef GetPrototype(JSContextRef context) const {
  46         return NULL;
  47     }
  48 };
  49
  50 template <typename Internal_, typename Base_ = CYRoot>
  51 struct CYPrivateOld :
  52     Base_
  53 {
  54     static JSClassRef Class_;
  55
  56     template <typename... Args_>
  57     _finline static JSClassRef GetClass(Args_ &&... args) {
  58         return Class_;
  59     }
  60
  61     template <typename... Args_>
  62     static JSObjectRef Make(JSContextRef context, Args_ &&... args) {
  63         Internal_ *internal(new Internal_(cy::Forward<Args_>(args)...));
  64         JSObjectRef object(JSObjectMake(context, Internal_::GetClass(cy::Forward<Args_>(args)...), internal));
  65         if (JSValueRef prototype = internal->GetPrototype(context))
  66             CYSetPrototype(context, object, prototype);
  67         return object;
  68     }
  69
  70     static Internal_ *Get(JSContextRef context, JSObjectRef object) {
  71         _assert(JSValueIsObjectOfClass(context, object, Class_));
  72         return static_cast<Internal_ *>(JSObjectGetPrivate(object));
  73     }
  74 };
  75
  76 template <typename Internal_, typename Base_>
  77 JSClassRef CYPrivateOld<Internal_, Base_>::Class_;
  78
  79 template <typename Internal_>
  80 struct CYPrivate {
  81     static JSClassRef Class_;
  82
  83     template <typename... Args_>
  84     static JSObjectRef Make(JSContextRef context, Args_ &&... args) {
  85         Internal_ *internal(new Internal_(cy::Forward<Args_>(args)...));
  86         JSObjectRef object(JSObjectMake(context, Class_, internal));
  87         if (JSValueRef prototype = internal->GetPrototype(context))
  88             CYSetPrototype(context, object, prototype);
  89         return object;
  90     }
  91
  92     template <typename Arg_>
  93     static JSObjectRef Cache(JSContextRef context, Arg_ *arg) {
  94         JSObjectRef global(CYGetGlobalObject(context));
  95         JSObjectRef cy(CYCastJSObject(context, CYGetProperty(context, global, cy_s)));
  96
  97         char label[32];
  98         sprintf(label, "%s%p", Internal_::Cache_, arg);
  99         CYJSString name(label);
 100
 101         JSValueRef value(CYGetProperty(context, cy, name));
 102         if (!JSValueIsUndefined(context, value))
 103             return CYCastJSObject(context, value);
 104
 105         JSObjectRef object(Make(context, arg));
 106         CYSetProperty(context, cy, name, object);
 107         return object;
 108     }
 109
 110     static Internal_ *Get(JSContextRef context, JSObjectRef object) {
 111         _assert(JSValueIsObjectOfClass(context, object, Class_));
 112         return static_cast<Internal_ *>(JSObjectGetPrivate(object));
 113     }
 114 };
 115
 116 template <typename Internal_>
 117 JSClassRef CYPrivate<Internal_>::Class_;
 118
 119 struct Type_privateData :
 120     CYRoot
 121 {
 122     ffi_type *ffi_;
 123     sig::Type *type_;
 124
 125     Type_privateData(const char *type) :
 126         ffi_(NULL)
 127     {
 128         sig::Signature signature;
 129         sig::Parse(*pool_, &signature, type, &Structor_);
 130         type_ = signature.elements[0].type;
 131     }
 132
 133     Type_privateData(const sig::Type &type, ffi_type *ffi = NULL) :
 134         type_(type.Copy(*pool_))
 135     {
 136
 137         if (ffi == NULL)
 138             ffi_ = NULL;
 139         else {
 140             ffi_ = new(*pool_) ffi_type;
 141             sig::Copy(*pool_, *ffi_, *ffi);
 142         }
 143     }
 144
 145     ffi_type *GetFFI() {
 146         if (ffi_ == NULL) {
 147             sig::Element element;
 148             element.name = NULL;
 149             element.type = type_;
 150             element.offset = 0;
 151
 152             sig::Signature signature;
 153             signature.elements = &element;
 154             signature.count = 1;
 155
 156             ffi_cif cif;
 157             sig::sig_ffi_cif(*pool_, false, signature, &cif);
 158
 159             ffi_ = new(*pool_) ffi_type;
 160             *ffi_ = *cif.rtype;
 161         }
 162
 163         return ffi_;
 164     }
 165 };
 166
 167 struct CYProtect {
 168   private:
 169     JSGlobalContextRef context_;
 170     JSObjectRef object_;
 171
 172   public:
 173     CYProtect(JSContextRef context, JSObjectRef object) :
 174         context_(CYGetJSContext(context)),
 175         object_(object)
 176     {
 177         //XXX:JSGlobalContextRetain(context_);
 178         if (object_ != NULL)
 179             JSValueProtect(context_, object_);
 180     }
 181
 182     ~CYProtect() {
 183         if (object_ != NULL)
 184             JSValueUnprotect(context_, object_);
 185         //XXX:JSGlobalContextRelease(context_);
 186     }
 187
 188     operator bool() const {
 189         return object_ != NULL;
 190     }
 191
 192     operator JSContextRef() const {
 193         return context_;
 194     }
 195
 196     operator JSObjectRef() const {
 197         return object_;
 198     }
 199 };
 200
 201 namespace cy {
 202 struct Functor :
 203     CYRoot
 204 {
 205   private:
 206     void set() {
 207         sig::sig_ffi_cif(*pool_, variadic_ ? signature_.count : 0, signature_, &cif_);
 208     }
 209
 210   public:
 211     void (*value_)();
 212     bool variadic_;
 213     sig::Signature signature_;
 214     ffi_cif cif_;
 215
 216     Functor(void (*value)(), bool variadic, const sig::Signature &signature) :
 217         value_(value),
 218         variadic_(variadic)
 219     {
 220         sig::Copy(*pool_, signature_, signature);
 221         set();
 222     }
 223
 224     Functor(void (*value)(), const char *encoding) :
 225         value_(value),
 226         variadic_(false)
 227     {
 228         sig::Parse(*pool_, &signature_, encoding, &Structor_);
 229         set();
 230     }
 231
 232     static JSStaticFunction const * const StaticFunctions;
 233     static JSStaticValue const * const StaticValues;
 234 }; }
 235
 236 struct Closure_privateData :
 237     cy::Functor
 238 {
 239     CYProtect function_;
 240     JSValueRef (*adapter_)(JSContextRef, size_t, JSValueRef[], JSObjectRef);
 241
 242     Closure_privateData(JSContextRef context, JSObjectRef function, JSValueRef (*adapter)(JSContextRef, size_t, JSValueRef[], JSObjectRef), const sig::Signature &signature) :
 243         cy::Functor(NULL, false, signature),
 244         function_(context, function),
 245         adapter_(adapter)
 246     {
 247     }
 248 };
 249
 250 Closure_privateData *CYMakeFunctor_(JSContextRef context, JSObjectRef function, const sig::Signature &signature, JSValueRef (*adapter)(JSContextRef, size_t, JSValueRef[], JSObjectRef));
 251 void CYExecuteClosure(ffi_cif *cif, void *result, void **arguments, void *arg, JSValueRef (*adapter)(JSContextRef, size_t, JSValueRef[], JSObjectRef));
 252
 253 #endif/*CYCRIPT_INTERNAL_HPP*/