Internal.hpp

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