Execute.cpp

   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 #include "cycript.hpp"
  23
  24 #include <iostream>
  25 #include <set>
  26 #include <map>
  27 #include <iomanip>
  28 #include <sstream>
  29 #include <cmath>
  30
  31 #include <dlfcn.h>
  32 #include <dirent.h>
  33 #include <fcntl.h>
  34 #include <unistd.h>
  35
  36 #include <sys/mman.h>
  37 #include <sys/stat.h>
  38
  39 #include <sqlite3.h>
  40
  41 #include "sig/parse.hpp"
  42 #include "sig/ffi_type.hpp"
  43
  44 #include "Code.hpp"
  45 #include "Decode.hpp"
  46 #include "Error.hpp"
  47 #include "Execute.hpp"
  48 #include "Internal.hpp"
  49 #include "JavaScript.hpp"
  50 #include "Pooling.hpp"
  51 #include "String.hpp"
  52
  53 const char *sqlite3_column_string(sqlite3_stmt *stmt, int n) {
  54     return reinterpret_cast<const char *>(sqlite3_column_text(stmt, n));
  55 }
  56
  57 char *sqlite3_column_pooled(CYPool &pool, sqlite3_stmt *stmt, int n) {
  58     if (const char *value = sqlite3_column_string(stmt, n))
  59         return pool.strdup(value);
  60     else return NULL;
  61 }
  62
  63 static std::vector<CYHook *> &GetHooks() {
  64     static std::vector<CYHook *> hooks;
  65     return hooks;
  66 }
  67
  68 CYRegisterHook::CYRegisterHook(CYHook *hook) {
  69     GetHooks().push_back(hook);
  70 }
  71
  72 /* JavaScript Properties {{{ */
  73 bool CYHasProperty(JSContextRef context, JSObjectRef object, JSStringRef name) {
  74     return JSObjectHasProperty(context, object, name);
  75 }
  76
  77 JSValueRef CYGetProperty(JSContextRef context, JSObjectRef object, size_t index) {
  78     return _jsccall(JSObjectGetPropertyAtIndex, context, object, index);
  79 }
  80
  81 JSValueRef CYGetProperty(JSContextRef context, JSObjectRef object, JSStringRef name) {
  82     return _jsccall(JSObjectGetProperty, context, object, name);
  83 }
  84
  85 void CYSetProperty(JSContextRef context, JSObjectRef object, size_t index, JSValueRef value) {
  86     _jsccall(JSObjectSetPropertyAtIndex, context, object, index, value);
  87 }
  88
  89 void CYSetProperty(JSContextRef context, JSObjectRef object, JSStringRef name, JSValueRef value, JSPropertyAttributes attributes) {
  90     _jsccall(JSObjectSetProperty, context, object, name, value, attributes);
  91 }
  92
  93 void CYSetProperty(JSContextRef context, JSObjectRef object, JSStringRef name, JSValueRef (*callback)(JSContextRef, JSObjectRef, JSObjectRef, size_t, const JSValueRef[], JSValueRef *), JSPropertyAttributes attributes) {
  94     CYSetProperty(context, object, name, JSObjectMakeFunctionWithCallback(context, name, callback), attributes);
  95 }
  96
  97 JSObjectRef CYGetPrototype(JSContextRef context, JSObjectRef object) {
  98     return CYCastJSObject(context, JSObjectGetPrototype(context, object));
  99 }
 100
 101 void CYSetPrototype(JSContextRef context, JSObjectRef object, JSValueRef value) {
 102     _assert(!JSValueIsUndefined(context, value));
 103     JSObjectSetPrototype(context, object, value);
 104     _assert(CYIsStrictEqual(context, JSObjectGetPrototype(context, object), value));
 105 }
 106 /* }}} */
 107 /* JavaScript Strings {{{ */
 108 JSStringRef CYCopyJSString(const char *value) {
 109     return value == NULL ? NULL : JSStringCreateWithUTF8CString(value);
 110 }
 111
 112 JSStringRef CYCopyJSString(JSStringRef value) {
 113     return value == NULL ? NULL : JSStringRetain(value);
 114 }
 115
 116 JSStringRef CYCopyJSString(CYUTF8String value) {
 117     if (memchr(value.data, '\0', value.size) != NULL) {
 118         CYPool pool;
 119         return CYCopyJSString(CYPoolUTF16String(pool, value));
 120     } else if (value.data[value.size] != '\0') {
 121         CYPool pool;
 122         return CYCopyJSString(pool.strmemdup(value.data, value.size));
 123     } else {
 124         return CYCopyJSString(value.data);
 125     }
 126 }
 127
 128 JSStringRef CYCopyJSString(const std::string &value) {
 129     return CYCopyJSString(CYUTF8String(value.c_str(), value.size()));
 130 }
 131
 132 JSStringRef CYCopyJSString(CYUTF16String value) {
 133     return JSStringCreateWithCharacters(value.data, value.size);
 134 }
 135
 136 JSStringRef CYCopyJSString(JSContextRef context, JSValueRef value) {
 137     if (JSValueIsNull(context, value))
 138         return NULL;
 139     return _jsccall(JSValueToStringCopy, context, value);
 140 }
 141
 142 CYUTF16String CYCastUTF16String(JSStringRef value) {
 143     return CYUTF16String(JSStringGetCharactersPtr(value), JSStringGetLength(value));
 144 }
 145
 146 const char *CYPoolCString(CYPool &pool, CYUTF8String utf8) {
 147     return pool.strndup(utf8.data, utf8.size);
 148 }
 149
 150 CYUTF8String CYPoolUTF8String(CYPool &pool, JSContextRef context, JSStringRef value) {
 151     return CYPoolUTF8String(pool, CYCastUTF16String(value));
 152 }
 153
 154 const char *CYPoolCString(CYPool &pool, JSContextRef context, JSStringRef value) {
 155     CYUTF8String utf8(CYPoolUTF8String(pool, context, value));
 156     _assert(memchr(utf8.data, '\0', utf8.size) == NULL);
 157     return utf8.data;
 158 }
 159
 160 const char *CYPoolCString(CYPool &pool, JSContextRef context, JSValueRef value) {
 161     return JSValueIsNull(context, value) ? NULL : CYPoolCString(pool, context, CYJSString(context, value));
 162 }
 163 /* }}} */
 164 /* Index Offsets {{{ */
 165 size_t CYGetIndex(CYPool &pool, JSContextRef context, JSStringRef value) {
 166     return CYGetIndex(CYPoolUTF8String(pool, context, value));
 167 }
 168 /* }}} */
 169
 170 static JSObjectRef (*JSObjectMakeArray$)(JSContextRef, size_t, const JSValueRef[], JSValueRef *);
 171
 172 JSObjectRef CYObjectMakeArray(JSContextRef context, size_t length, const JSValueRef values[]) {
 173     if (JSObjectMakeArray$ != NULL)
 174         return _jsccall(*JSObjectMakeArray$, context, length, values);
 175     else {
 176         JSObjectRef Array(CYGetCachedObject(context, CYJSString("Array")));
 177         JSValueRef value(CYCallAsFunction(context, Array, NULL, length, values));
 178         return CYCastJSObject(context, value);
 179     }
 180 }
 181
 182 static JSClassRef All_;
 183 JSClassRef Functor_;
 184 static JSClassRef Global_;
 185
 186 JSStringRef Array_s;
 187 JSStringRef cy_s;
 188 JSStringRef cyi_s;
 189 JSStringRef cyt_s;
 190 JSStringRef length_s;
 191 JSStringRef message_s;
 192 JSStringRef name_s;
 193 JSStringRef pop_s;
 194 JSStringRef prototype_s;
 195 JSStringRef push_s;
 196 JSStringRef splice_s;
 197 JSStringRef toCYON_s;
 198 JSStringRef toJSON_s;
 199 JSStringRef toPointer_s;
 200 JSStringRef toString_s;
 201 JSStringRef weak_s;
 202
 203 static sqlite3 *database_;
 204
 205 static JSStringRef Result_;
 206
 207 void CYFinalize(JSObjectRef object) {
 208     CYData *internal(reinterpret_cast<CYData *>(JSObjectGetPrivate(object)));
 209     _assert(internal->count_ != _not(unsigned));
 210     if (--internal->count_ == 0)
 211         delete internal;
 212 }
 213
 214 sig::Type *Structor_(CYPool &pool, sig::Aggregate *aggregate) {
 215     //_assert(false);
 216     return aggregate;
 217 }
 218
 219 struct Context :
 220     CYPrivate<Context>
 221 {
 222     JSGlobalContextRef context_;
 223
 224     Context(JSGlobalContextRef context) :
 225         context_(context)
 226     {
 227     }
 228 };
 229
 230 struct CArray :
 231     CYValue<CArray, void *>
 232 {
 233     CYProtect owner_;
 234     Type_privateData *type_;
 235     size_t length_;
 236
 237     CArray(void *value, size_t length, const sig::Type &type, ffi_type *ffi, JSContextRef context, JSObjectRef owner) :
 238         CYValue(value),
 239         owner_(context, owner),
 240         type_(new(*pool_) Type_privateData(type, ffi)),
 241         length_(length)
 242     {
 243         if (owner == NULL) {
 244             size_t size(ffi->size * length);
 245             void *copy(pool_->malloc<void>(size, ffi->alignment));
 246             memcpy(copy, value_, size);
 247             value_ = copy;
 248         }
 249     }
 250 };
 251
 252 struct CString :
 253     CYValue<CString, char *>
 254 {
 255     CYProtect owner_;
 256
 257     CString(char *value, JSContextRef context, JSObjectRef owner) :
 258         CYValue(value),
 259         owner_(context, owner)
 260     {
 261         if (owner == NULL)
 262             value_ = pool_->strdup(value_);
 263     }
 264 };
 265
 266 struct Pointer :
 267     CYValue<Pointer, void *>
 268 {
 269     CYProtect owner_;
 270     Type_privateData *type_;
 271
 272     Pointer(void *value, const sig::Type &type, JSContextRef context, JSObjectRef owner) :
 273         CYValue(value),
 274         owner_(context, owner),
 275         type_(new(*pool_) Type_privateData(type))
 276     {
 277     }
 278
 279     Pointer(void *value, const char *encoding, JSContextRef context, JSObjectRef owner) :
 280         CYValue(value),
 281         owner_(context, owner),
 282         type_(new(*pool_) Type_privateData(encoding))
 283     {
 284     }
 285 };
 286
 287 struct Struct_privateData :
 288     CYValue<Struct_privateData, void *>
 289 {
 290     CYProtect owner_;
 291     Type_privateData *type_;
 292
 293     Struct_privateData(void *value, const sig::Type &type, ffi_type *ffi, JSContextRef context, JSObjectRef owner) :
 294         CYValue(value),
 295         owner_(context, owner),
 296         type_(new(*pool_) Type_privateData(type, ffi))
 297     {
 298         if (owner == NULL) {
 299             size_t size(ffi->size);
 300             void *copy(pool_->malloc<void>(size, ffi->alignment));
 301             memcpy(copy, value_, size);
 302             value_ = copy;
 303         }
 304     }
 305 };
 306
 307 static void *CYCastSymbol(const char *name) {
 308     for (CYHook *hook : GetHooks())
 309         if (hook->CastSymbol != NULL)
 310             if (void *value = (*hook->CastSymbol)(name))
 311                 return value;
 312     return dlsym(RTLD_DEFAULT, name);
 313 }
 314
 315 JSValueRef CYCastJSValue(JSContextRef context, bool value) {
 316     return JSValueMakeBoolean(context, value);
 317 }
 318
 319 JSValueRef CYCastJSValue(JSContextRef context, double value) {
 320     return JSValueMakeNumber(context, value);
 321 }
 322
 323 #define CYCastJSValue_(Type_) \
 324     JSValueRef CYCastJSValue(JSContextRef context, Type_ value) { \
 325         _assert(static_cast<Type_>(static_cast<double>(value)) == value); \
 326         return JSValueMakeNumber(context, static_cast<double>(value)); \
 327     }
 328
 329 CYCastJSValue_(signed short int)
 330 CYCastJSValue_(unsigned short int)
 331 CYCastJSValue_(signed int)
 332 CYCastJSValue_(unsigned int)
 333 CYCastJSValue_(signed long int)
 334 CYCastJSValue_(unsigned long int)
 335 CYCastJSValue_(signed long long int)
 336 CYCastJSValue_(unsigned long long int)
 337
 338 JSValueRef CYJSUndefined(JSContextRef context) {
 339     return JSValueMakeUndefined(context);
 340 }
 341
 342 double CYCastDouble(JSContextRef context, JSValueRef value) {
 343     return _jsccall(JSValueToNumber, context, value);
 344 }
 345
 346 bool CYCastBool(JSContextRef context, JSValueRef value) {
 347     return JSValueToBoolean(context, value);
 348 }
 349
 350 JSValueRef CYJSNull(JSContextRef context) {
 351     return JSValueMakeNull(context);
 352 }
 353
 354 JSValueRef CYCastJSValue(JSContextRef context, JSStringRef value) {
 355     return value == NULL ? CYJSNull(context) : JSValueMakeString(context, value);
 356 }
 357
 358 JSValueRef CYCastJSValue(JSContextRef context, const char *value) {
 359     return CYCastJSValue(context, CYJSString(value));
 360 }
 361
 362 JSObjectRef CYCastJSObject(JSContextRef context, JSValueRef value) {
 363     return _jsccall(JSValueToObject, context, value);
 364 }
 365
 366 JSValueRef CYCallAsFunction(JSContextRef context, JSObjectRef function, JSObjectRef _this, size_t count, const JSValueRef arguments[]) {
 367     return _jsccall(JSObjectCallAsFunction, context, function, _this, count, arguments);
 368 }
 369
 370 bool CYIsCallable(JSContextRef context, JSValueRef value) {
 371     return value != NULL && JSValueIsObject(context, value) && JSObjectIsFunction(context, (JSObjectRef) value);
 372 }
 373
 374 bool CYIsEqual(JSContextRef context, JSValueRef lhs, JSValueRef rhs) {
 375     return _jsccall(JSValueIsEqual, context, lhs, rhs);
 376 }
 377
 378 bool CYIsStrictEqual(JSContextRef context, JSValueRef lhs, JSValueRef rhs) {
 379     return JSValueIsStrictEqual(context, lhs, rhs);
 380 }
 381
 382 size_t CYArrayLength(JSContextRef context, JSObjectRef array) {
 383     return CYCastDouble(context, CYGetProperty(context, array, length_s));
 384 }
 385
 386 JSValueRef CYArrayGet(JSContextRef context, JSObjectRef array, size_t index) {
 387     return _jsccall(JSObjectGetPropertyAtIndex, context, array, index);
 388 }
 389
 390 void CYArrayPush(JSContextRef context, JSObjectRef array, size_t length, const JSValueRef arguments[]) {
 391     JSObjectRef Array(CYGetCachedObject(context, CYJSString("Array_prototype")));
 392     _jsccall(JSObjectCallAsFunction, context, CYCastJSObject(context, CYGetProperty(context, Array, push_s)), array, length, arguments);
 393 }
 394
 395 void CYArrayPush(JSContextRef context, JSObjectRef array, JSValueRef value) {
 396     return CYArrayPush(context, array, 1, &value);
 397 }
 398
 399 static JSValueRef System_print(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
 400     FILE *file(stdout);
 401
 402     if (count == 0)
 403         fputc('\n', file);
 404     else {
 405         CYPool pool;
 406         CYUTF8String string(CYPoolUTF8String(pool, context, CYJSString(context, arguments[0])));
 407         fwrite(string.data, string.size, 1, file);
 408     }
 409
 410     fflush(file);
 411     return CYJSUndefined(context);
 412 } CYCatch(NULL) }
 413
 414 static void (*JSSynchronousGarbageCollectForDebugging$)(JSContextRef);
 415
 416 _visible void CYGarbageCollect(JSContextRef context) {
 417     (JSSynchronousGarbageCollectForDebugging$ ?: &JSGarbageCollect)(context);
 418 }
 419
 420 static JSValueRef Cycript_compile_callAsFunction(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
 421     CYPool pool;
 422     CYUTF8String before(CYPoolUTF8String(pool, context, CYJSString(context, arguments[0])));
 423     CYUTF8String after(CYPoolCode(pool, before));
 424     return CYCastJSValue(context, CYJSString(after));
 425 } CYCatch_(NULL, "SyntaxError") }
 426
 427 static JSValueRef Cycript_gc_callAsFunction(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
 428     CYGarbageCollect(context);
 429     return CYJSUndefined(context);
 430 } CYCatch(NULL) }
 431
 432 const char *CYPoolCCYON(CYPool &pool, JSContextRef context, JSValueRef value, std::set<void *> &objects, JSValueRef *exception) { CYTry {
 433     switch (JSType type = JSValueGetType(context, value)) {
 434         case kJSTypeUndefined:
 435             return "undefined";
 436         case kJSTypeNull:
 437             return "null";
 438         case kJSTypeBoolean:
 439             return CYCastBool(context, value) ? "true" : "false";
 440
 441         case kJSTypeNumber: {
 442             std::ostringstream str;
 443             CYNumerify(str, CYCastDouble(context, value));
 444             std::string value(str.str());
 445             return pool.strmemdup(value.c_str(), value.size());
 446         } break;
 447
 448         case kJSTypeString: {
 449             std::ostringstream str;
 450             CYUTF8String string(CYPoolUTF8String(pool, context, CYJSString(context, value)));
 451             CYStringify(str, string.data, string.size);
 452             std::string value(str.str());
 453             return pool.strmemdup(value.c_str(), value.size());
 454         } break;
 455
 456         case kJSTypeObject:
 457             return CYPoolCCYON(pool, context, (JSObjectRef) value, objects);
 458         default:
 459             throw CYJSError(context, "JSValueGetType() == 0x%x", type);
 460     }
 461 } CYCatch(NULL) }
 462
 463 const char *CYPoolCCYON(CYPool &pool, JSContextRef context, JSValueRef value, std::set<void *> &objects) {
 464     return _jsccall(CYPoolCCYON, pool, context, value, objects);
 465 }
 466
 467 const char *CYPoolCCYON(CYPool &pool, JSContextRef context, JSValueRef value, std::set<void *> *objects) {
 468     if (objects != NULL)
 469         return CYPoolCCYON(pool, context, value, *objects);
 470     else {
 471         std::set<void *> objects;
 472         return CYPoolCCYON(pool, context, value, objects);
 473     }
 474 }
 475
 476 const char *CYPoolCCYON(CYPool &pool, JSContextRef context, JSObjectRef object, std::set<void *> &objects) {
 477     JSValueRef toCYON(CYGetProperty(context, object, toCYON_s));
 478     if (CYIsCallable(context, toCYON)) {
 479         // XXX: this needs to be abstracted behind some kind of function
 480         JSValueRef arguments[1] = {CYCastJSValue(context, reinterpret_cast<uintptr_t>(&objects))};
 481         JSValueRef value(CYCallAsFunction(context, (JSObjectRef) toCYON, object, 1, arguments));
 482         _assert(value != NULL);
 483         return CYPoolCString(pool, context, value);
 484     }
 485
 486     JSValueRef toJSON(CYGetProperty(context, object, toJSON_s));
 487     if (CYIsCallable(context, toJSON)) {
 488         JSValueRef arguments[1] = {CYCastJSValue(context, CYJSString(""))};
 489         return _jsccall(CYPoolCCYON, pool, context, CYCallAsFunction(context, (JSObjectRef) toJSON, object, 1, arguments), objects);
 490     }
 491
 492     if (JSObjectIsFunction(context, object)) {
 493         JSValueRef toString(CYGetProperty(context, object, toString_s));
 494         if (CYIsCallable(context, toString)) {
 495             JSValueRef arguments[1] = {CYCastJSValue(context, CYJSString(""))};
 496             JSValueRef value(CYCallAsFunction(context, (JSObjectRef) toString, object, 1, arguments));
 497             _assert(value != NULL);
 498             return CYPoolCString(pool, context, value);
 499         }
 500     }
 501
 502     _assert(objects.insert(object).second);
 503
 504     std::ostringstream str;
 505
 506     str << '{';
 507
 508     // XXX: this is, sadly, going to leak
 509     JSPropertyNameArrayRef names(JSObjectCopyPropertyNames(context, object));
 510
 511     bool comma(false);
 512
 513     for (size_t index(0), count(JSPropertyNameArrayGetCount(names)); index != count; ++index) {
 514         if (comma)
 515             str << ',';
 516         else
 517             comma = true;
 518
 519         JSStringRef name(JSPropertyNameArrayGetNameAtIndex(names, index));
 520         CYUTF8String string(CYPoolUTF8String(pool, context, name));
 521
 522         if (CYIsKey(string))
 523             str << string.data;
 524         else
 525             CYStringify(str, string.data, string.size);
 526
 527         str << ':';
 528
 529         try {
 530             JSValueRef value(CYGetProperty(context, object, name));
 531             str << CYPoolCCYON(pool, context, value, objects);
 532         } catch (const CYException &error) {
 533             str << "@error";
 534         }
 535     }
 536
 537     JSPropertyNameArrayRelease(names);
 538
 539     str << '}';
 540
 541     std::string string(str.str());
 542     return pool.strmemdup(string.c_str(), string.size());
 543 }
 544
 545 std::set<void *> *CYCastObjects(JSContextRef context, JSObjectRef _this, size_t count, const JSValueRef arguments[]) {
 546     if (count == 0)
 547         return NULL;
 548     return CYCastPointer<std::set<void *> *>(context, arguments[0]);
 549 }
 550
 551 static JSValueRef Array_callAsFunction_toCYON(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
 552     std::set<void *> *objects(CYCastObjects(context, _this, count, arguments));
 553     // XXX: this is horribly inefficient
 554     std::set<void *> backup;
 555     if (objects == NULL)
 556         objects = &backup;
 557
 558     CYPool pool;
 559     std::ostringstream str;
 560
 561     str << '[';
 562
 563     JSValueRef length(CYGetProperty(context, _this, length_s));
 564     bool comma(false);
 565
 566     for (size_t index(0), count(CYCastDouble(context, length)); index != count; ++index) {
 567         if (comma)
 568             str << ',';
 569         else
 570             comma = true;
 571
 572         try {
 573             JSValueRef value(CYGetProperty(context, _this, index));
 574             if (!JSValueIsUndefined(context, value))
 575                 str << CYPoolCCYON(pool, context, value, *objects);
 576             else {
 577                 str << ',';
 578                 comma = false;
 579             }
 580         } catch (const CYException &error) {
 581             str << "@error";
 582         }
 583     }
 584
 585     str << ']';
 586
 587     std::string value(str.str());
 588     return CYCastJSValue(context, CYJSString(CYUTF8String(value.c_str(), value.size())));
 589 } CYCatch(NULL) }
 590
 591 static JSValueRef String_callAsFunction_toCYON(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
 592     CYPool pool;
 593     std::ostringstream str;
 594
 595     CYUTF8String string(CYPoolUTF8String(pool, context, CYJSString(context, _this)));
 596     CYStringify(str, string.data, string.size);
 597
 598     std::string value(str.str());
 599     return CYCastJSValue(context, CYJSString(CYUTF8String(value.c_str(), value.size())));
 600 } CYCatch(NULL) }
 601
 602 JSObjectRef CYMakePointer(JSContextRef context, void *pointer, const sig::Type &type, ffi_type *ffi, JSObjectRef owner) {
 603     return Pointer::Make(context, pointer, type, context, owner);
 604 }
 605
 606 static JSObjectRef CYMakeFunctor(JSContextRef context, void (*function)(), bool variadic, const sig::Signature &signature) {
 607     return JSObjectMake(context, Functor_, new cy::Functor(function, variadic, signature));
 608 }
 609
 610 static JSObjectRef CYMakeFunctor(JSContextRef context, const char *symbol, const char *encoding) {
 611     void (*function)()(reinterpret_cast<void (*)()>(CYCastSymbol(symbol)));
 612     if (function == NULL)
 613         return NULL;
 614
 615     cy::Functor *internal(new cy::Functor(function, encoding));
 616     ++internal->count_;
 617     return JSObjectMake(context, Functor_, internal);
 618 }
 619
 620 bool CYGetOffset(CYPool &pool, JSContextRef context, JSStringRef value, ssize_t &index) {
 621     return CYGetOffset(CYPoolCString(pool, context, value), index);
 622 }
 623
 624 void *CYCastPointer_(JSContextRef context, JSValueRef value, bool *guess) {
 625     if (value == NULL)
 626         return NULL;
 627     else switch (JSValueGetType(context, value)) {
 628         case kJSTypeNull:
 629             return NULL;
 630         case kJSTypeObject: {
 631             JSObjectRef object((JSObjectRef) value);
 632             if (JSValueIsObjectOfClass(context, value, Pointer::Class_)) {
 633                 Pointer *internal(reinterpret_cast<Pointer *>(JSObjectGetPrivate(object)));
 634                 return internal->value_;
 635             }
 636             JSValueRef toPointer(CYGetProperty(context, object, toPointer_s));
 637             if (CYIsCallable(context, toPointer)) {
 638                 JSValueRef value(CYCallAsFunction(context, (JSObjectRef) toPointer, object, 0, NULL));
 639                 _assert(value != NULL);
 640                 return CYCastPointer_(context, value, guess);
 641             }
 642         } default:
 643             if (guess != NULL)
 644                 *guess = true;
 645         case kJSTypeNumber:
 646             double number(CYCastDouble(context, value));
 647             if (!std::isnan(number))
 648                 return reinterpret_cast<void *>(static_cast<uintptr_t>(static_cast<long long>(number)));
 649             if (guess == NULL)
 650                 throw CYJSError(context, "cannot convert value to pointer");
 651             else {
 652                 *guess = true;
 653                 return NULL;
 654             }
 655     }
 656 }
 657
 658 namespace sig {
 659
 660 // XXX: this is somehow not quite a template :/
 661
 662 template <>
 663 void Primitive<bool>::PoolFFI(CYPool *pool, JSContextRef context, ffi_type *ffi, void *data, JSValueRef value) const {
 664     *reinterpret_cast<bool *>(data) = JSValueToBoolean(context, value);
 665 }
 666
 667 #define CYPoolFFI_(Type_) \
 668 template <> \
 669 void Primitive<Type_>::PoolFFI(CYPool *pool, JSContextRef context, ffi_type *ffi, void *data, JSValueRef value) const { \
 670     *reinterpret_cast<Type_ *>(data) = CYCastDouble(context, value); \
 671 }
 672
 673 CYPoolFFI_(char)
 674 CYPoolFFI_(double)
 675 CYPoolFFI_(float)
 676 CYPoolFFI_(signed char)
 677 CYPoolFFI_(signed int)
 678 CYPoolFFI_(signed long int)
 679 CYPoolFFI_(signed long long int)
 680 CYPoolFFI_(signed short int)
 681 CYPoolFFI_(unsigned char)
 682 CYPoolFFI_(unsigned int)
 683 CYPoolFFI_(unsigned long int)
 684 CYPoolFFI_(unsigned long long int)
 685 CYPoolFFI_(unsigned short int)
 686
 687 void Void::PoolFFI(CYPool *pool, JSContextRef context, ffi_type *ffi, void *data, JSValueRef value) const {
 688     _assert(false);
 689 }
 690
 691 void Unknown::PoolFFI(CYPool *pool, JSContextRef context, ffi_type *ffi, void *data, JSValueRef value) const {
 692     _assert(false);
 693 }
 694
 695 void String::PoolFFI(CYPool *pool, JSContextRef context, ffi_type *ffi, void *data, JSValueRef value) const {
 696     bool guess(false);
 697     *reinterpret_cast<const char **>(data) = CYCastPointer<const char *>(context, value, &guess);
 698     if (guess && pool != NULL)
 699         *reinterpret_cast<const char **>(data) = CYPoolCString(*pool, context, value);
 700 }
 701
 702 void Bits::PoolFFI(CYPool *pool, JSContextRef context, ffi_type *ffi, void *data, JSValueRef value) const {
 703     _assert(false);
 704 }
 705
 706 static void CYArrayCopy(CYPool *pool, JSContextRef context, uint8_t *base, size_t length, const sig::Type &type, ffi_type *ffi, JSValueRef value, JSObjectRef object) {
 707     for (size_t index(0); index != length; ++index) {
 708         JSValueRef rhs;
 709         if (object == NULL)
 710             rhs = value;
 711         else {
 712             rhs = CYGetProperty(context, object, index);
 713             if (JSValueIsUndefined(context, rhs))
 714                 throw CYJSError(context, "unable to extract array value");
 715         }
 716
 717         type.PoolFFI(pool, context, ffi, base, rhs);
 718         base += ffi->size;
 719     }
 720 }
 721
 722 void Pointer::PoolFFI(CYPool *pool, JSContextRef context, ffi_type *ffi, void *data, JSValueRef value) const {
 723     bool guess(false);
 724     *reinterpret_cast<void **>(data) = CYCastPointer<void *>(context, value, &guess);
 725     if (!guess || pool == NULL || !JSValueIsObject(context, value))
 726         return;
 727     JSObjectRef object(CYCastJSObject(context, value));
 728     if (CYHasProperty(context, object, length_s)) {
 729         size_t length(CYArrayLength(context, object));
 730         ffi_type *element(type.GetFFI(*pool));
 731         size_t size(element->size * length);
 732         uint8_t *base(pool->malloc<uint8_t>(size, element->alignment));
 733         CYArrayCopy(pool, context, base, length, type, element, value, object);
 734         *reinterpret_cast<void **>(data) = base;
 735     }
 736 }
 737
 738 void Array::PoolFFI(CYPool *pool, JSContextRef context, ffi_type *ffi, void *data, JSValueRef value) const {
 739     if (size == 0)
 740         return;
 741     uint8_t *base(reinterpret_cast<uint8_t *>(data));
 742     JSObjectRef object(JSValueIsObject(context, value) ? (JSObjectRef) value : NULL);
 743     CYArrayCopy(pool, context, base, size, type, ffi->elements[0], value, object);
 744 }
 745
 746 void Aggregate::PoolFFI(CYPool *pool, JSContextRef context, ffi_type *ffi, void *data, JSValueRef value) const {
 747     _assert(!overlap);
 748
 749     size_t offset(0);
 750     uint8_t *base(reinterpret_cast<uint8_t *>(data));
 751     JSObjectRef aggregate(JSValueIsObject(context, value) ? (JSObjectRef) value : NULL);
 752     for (size_t index(0); index != signature.count; ++index) {
 753         sig::Element *element(&signature.elements[index]);
 754         ffi_type *field(ffi->elements[index]);
 755
 756         JSValueRef rhs;
 757         if (aggregate == NULL)
 758             rhs = value;
 759         else {
 760             rhs = CYGetProperty(context, aggregate, index);
 761             if (JSValueIsUndefined(context, rhs)) {
 762                 if (element->name != NULL)
 763                     rhs = CYGetProperty(context, aggregate, CYJSString(element->name));
 764                 else
 765                     goto undefined;
 766                 if (JSValueIsUndefined(context, rhs)) undefined:
 767                     throw CYJSError(context, "unable to extract structure value");
 768             }
 769         }
 770
 771         element->type->PoolFFI(pool, context, field, base + offset, rhs);
 772         offset += field->size;
 773         CYAlign(offset, field->alignment);
 774     }
 775 }
 776
 777 void Function::PoolFFI(CYPool *pool, JSContextRef context, ffi_type *ffi, void *data, JSValueRef value) const {
 778     _assert(false);
 779 }
 780
 781 #define CYFromFFI_(Type_) \
 782 template <> \
 783 JSValueRef Primitive<Type_>::FromFFI(JSContextRef context, ffi_type *ffi, void *data, bool initialize, JSObjectRef owner) const { \
 784     return CYCastJSValue(context, *reinterpret_cast<Type_ *>(data)); \
 785 }
 786
 787 CYFromFFI_(bool)
 788 CYFromFFI_(char)
 789 CYFromFFI_(double)
 790 CYFromFFI_(float)
 791 CYFromFFI_(signed char)
 792 CYFromFFI_(signed int)
 793 CYFromFFI_(signed long int)
 794 CYFromFFI_(signed long long int)
 795 CYFromFFI_(signed short int)
 796 CYFromFFI_(unsigned char)
 797 CYFromFFI_(unsigned int)
 798 CYFromFFI_(unsigned long int)
 799 CYFromFFI_(unsigned long long int)
 800 CYFromFFI_(unsigned short int)
 801
 802 JSValueRef Void::FromFFI(JSContextRef context, ffi_type *ffi, void *data, bool initialize, JSObjectRef owner) const {
 803     return CYJSUndefined(context);
 804 }
 805
 806 JSValueRef Unknown::FromFFI(JSContextRef context, ffi_type *ffi, void *data, bool initialize, JSObjectRef owner) const {
 807     _assert(false);
 808 }
 809
 810 JSValueRef String::FromFFI(JSContextRef context, ffi_type *ffi, void *data, bool initialize, JSObjectRef owner) const {
 811     if (char *value = *reinterpret_cast<char **>(data))
 812         return CString::Make(context, value, context, owner);
 813     return CYJSNull(context);
 814 }
 815
 816 JSValueRef Bits::FromFFI(JSContextRef context, ffi_type *ffi, void *data, bool initialize, JSObjectRef owner) const {
 817     _assert(false);
 818 }
 819
 820 JSValueRef Pointer::FromFFI(JSContextRef context, ffi_type *ffi, void *data, bool initialize, JSObjectRef owner) const {
 821     if (void *value = *reinterpret_cast<void **>(data))
 822         return CYMakePointer(context, value, type, NULL, owner);
 823     return CYJSNull(context);
 824 }
 825
 826 JSValueRef Array::FromFFI(JSContextRef context, ffi_type *ffi, void *data, bool initialize, JSObjectRef owner) const {
 827     return CArray::Make(context, data, size, type, ffi->elements[0], context, owner);
 828 }
 829
 830 JSValueRef Aggregate::FromFFI(JSContextRef context, ffi_type *ffi, void *data, bool initialize, JSObjectRef owner) const {
 831     return Struct_privateData::Make(context, data, *this, ffi, context, owner);
 832 }
 833
 834 JSValueRef Function::FromFFI(JSContextRef context, ffi_type *ffi, void *data, bool initialize, JSObjectRef owner) const {
 835     return CYMakeFunctor(context, reinterpret_cast<void (*)()>(data), variadic, signature);
 836 }
 837
 838 }
 839
 840 void CYExecuteClosure(ffi_cif *cif, void *result, void **arguments, void *arg) {
 841     Closure_privateData *internal(reinterpret_cast<Closure_privateData *>(arg));
 842
 843     JSContextRef context(internal->function_);
 844
 845     size_t count(internal->cif_.nargs);
 846     JSValueRef values[count];
 847
 848     for (size_t index(0); index != count; ++index)
 849         values[index] = internal->signature_.elements[1 + index].type->FromFFI(context, internal->cif_.arg_types[index], arguments[index]);
 850
 851     JSValueRef value(internal->adapter_(context, count, values, internal->function_));
 852     if (internal->cif_.rtype != &ffi_type_void)
 853         internal->signature_.elements[0].type->PoolFFI(NULL, context, internal->cif_.rtype, result, value);
 854 }
 855
 856 static JSValueRef FunctionAdapter_(JSContextRef context, size_t count, JSValueRef values[], JSObjectRef function) {
 857     return CYCallAsFunction(context, function, NULL, count, values);
 858 }
 859
 860 #if defined(__APPLE__) && (defined(__arm__) || defined(__arm64__))
 861 static void CYFreeFunctor(void *data) {
 862     ffi_closure_free(data);
 863 }
 864 #else
 865 static void CYFreeFunctor(void *data) {
 866     _syscall(munmap(data, sizeof(ffi_closure)));
 867 }
 868 #endif
 869
 870 Closure_privateData *CYMakeFunctor_(JSContextRef context, JSObjectRef function, const sig::Signature &signature, JSValueRef (*adapter)(JSContextRef, size_t, JSValueRef[], JSObjectRef)) {
 871     // XXX: in case of exceptions this will leak
 872     Closure_privateData *internal(new Closure_privateData(context, function, adapter, signature));
 873
 874 #if defined(__APPLE__) && (defined(__arm__) || defined(__arm64__))
 875     void *executable;
 876     ffi_closure *writable(reinterpret_cast<ffi_closure *>(ffi_closure_alloc(sizeof(ffi_closure), &executable)));
 877
 878     ffi_status status(ffi_prep_closure_loc(writable, &internal->cif_, &CYExecuteClosure, internal, executable));
 879     _assert(status == FFI_OK);
 880
 881     internal->pool_->atexit(&CYFreeFunctor, writable);
 882     internal->value_ = reinterpret_cast<void (*)()>(executable);
 883 #else
 884     ffi_closure *closure((ffi_closure *) _syscall(mmap(
 885         NULL, sizeof(ffi_closure),
 886         PROT_READ | PROT_WRITE, MAP_ANON | MAP_PRIVATE,
 887         -1, 0
 888     )));
 889
 890     ffi_status status(ffi_prep_closure(closure, &internal->cif_, &CYExecuteClosure, internal));
 891     _assert(status == FFI_OK);
 892
 893     _syscall(mprotect(closure, sizeof(*closure), PROT_READ | PROT_EXEC));
 894
 895     internal->pool_->atexit(&CYFreeFunctor, closure);
 896     internal->value_ = reinterpret_cast<void (*)()>(closure);
 897 #endif
 898
 899     return internal;
 900 }
 901
 902 static JSObjectRef CYMakeFunctor(JSContextRef context, JSObjectRef function, const sig::Signature &signature) {
 903     Closure_privateData *internal(CYMakeFunctor_(context, function, signature, &FunctionAdapter_));
 904     JSObjectRef object(JSObjectMake(context, Functor_, internal));
 905     // XXX: see above notes about needing to leak
 906     JSValueProtect(CYGetJSContext(context), object);
 907     return object;
 908 }
 909
 910 JSValueRef CYGetCachedValue(JSContextRef context, JSStringRef name) {
 911     return CYGetProperty(context, CYCastJSObject(context, CYGetProperty(context, CYGetGlobalObject(context), cy_s)), name);
 912 }
 913
 914 JSObjectRef CYGetCachedObject(JSContextRef context, JSStringRef name) {
 915     return CYCastJSObject(context, CYGetCachedValue(context, name));
 916 }
 917
 918 static JSObjectRef CYMakeFunctor(JSContextRef context, JSValueRef value, bool variadic, const sig::Signature &signature) {
 919     JSObjectRef Function(CYGetCachedObject(context, CYJSString("Function")));
 920
 921     bool function(_jsccall(JSValueIsInstanceOfConstructor, context, value, Function));
 922     if (function) {
 923         JSObjectRef function(CYCastJSObject(context, value));
 924         return CYMakeFunctor(context, function, signature);
 925     } else {
 926         void (*function)()(CYCastPointer<void (*)()>(context, value));
 927         return CYMakeFunctor(context, function, variadic, signature);
 928     }
 929 }
 930
 931 static JSValueRef CString_getProperty(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { CYTry {
 932     CYPool pool;
 933     CString *internal(reinterpret_cast<CString *>(JSObjectGetPrivate(object)));
 934
 935     ssize_t offset;
 936     if (!CYGetOffset(pool, context, property, offset))
 937         return NULL;
 938
 939     return CYCastJSValue(context, CYJSString(CYUTF8String(&internal->value_[offset], 1)));
 940 } CYCatch(NULL) }
 941
 942 static bool CString_setProperty(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef value, JSValueRef *exception) { CYTry {
 943     CYPool pool;
 944     CString *internal(reinterpret_cast<CString *>(JSObjectGetPrivate(object)));
 945
 946     ssize_t offset;
 947     if (!CYGetOffset(pool, context, property, offset))
 948         return false;
 949
 950     const char *data(CYPoolCString(pool, context, value));
 951     internal->value_[offset] = *data;
 952     return true;
 953 } CYCatch(false) }
 954
 955 static bool Index_(CYPool &pool, JSContextRef context, Struct_privateData *internal, JSStringRef property, ssize_t &index, uint8_t *&base) {
 956     Type_privateData *typical(internal->type_);
 957     sig::Aggregate *type(static_cast<sig::Aggregate *>(typical->type_));
 958     if (type == NULL)
 959         return false;
 960
 961     const char *name(CYPoolCString(pool, context, property));
 962     size_t length(strlen(name));
 963     double number(CYCastDouble(name, length));
 964
 965     size_t count(type->signature.count);
 966
 967     if (std::isnan(number)) {
 968         if (property == NULL)
 969             return false;
 970
 971         sig::Element *elements(type->signature.elements);
 972
 973         for (size_t local(0); local != count; ++local) {
 974             sig::Element *element(&elements[local]);
 975             if (element->name != NULL && strcmp(name, element->name) == 0) {
 976                 index = local;
 977                 goto base;
 978             }
 979         }
 980
 981         return false;
 982     } else {
 983         index = static_cast<ssize_t>(number);
 984         if (index != number || index < 0 || static_cast<size_t>(index) >= count)
 985             return false;
 986     }
 987
 988   base:
 989     ffi_type **elements(typical->GetFFI()->elements);
 990
 991     size_t offset(0);
 992     for (ssize_t local(0); local != index; ++local) {
 993         offset += elements[local]->size;
 994         CYAlign(offset, elements[local + 1]->alignment);
 995     }
 996
 997     base = reinterpret_cast<uint8_t *>(internal->value_) + offset;
 998     return true;
 999 }
1000
1001 static void *Offset_(CYPool &pool, JSContextRef context, JSStringRef property, void *data, ffi_type *ffi) {
1002     ssize_t offset;
1003     if (JSStringIsEqualToUTF8CString(property, "$cyi"))
1004         offset = 0;
1005     else if (!CYGetOffset(pool, context, property, offset))
1006         return NULL;
1007     return reinterpret_cast<uint8_t *>(data) + ffi->size * offset;
1008 }
1009
1010 static JSValueRef Offset_getProperty(CYPool &pool, JSContextRef context, JSStringRef property, void *data, Type_privateData *typical, JSObjectRef owner) {
1011     ffi_type *ffi(typical->GetFFI());
1012     void *base(Offset_(pool, context, property, data, ffi));
1013     if (base == NULL)
1014         return NULL;
1015     return typical->type_->FromFFI(context, ffi, base, false, owner);
1016 }
1017
1018 static bool Offset_setProperty(CYPool &pool, JSContextRef context, JSStringRef property, void *data, Type_privateData *typical, JSValueRef value) {
1019     ffi_type *ffi(typical->GetFFI());
1020     void *base(Offset_(pool, context, property, data, ffi));
1021     if (base == NULL)
1022         return false;
1023
1024     typical->type_->PoolFFI(NULL, context, ffi, base, value);
1025     return true;
1026 }
1027
1028 static JSValueRef CArray_getProperty(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { CYTry {
1029     CYPool pool;
1030     CArray *internal(reinterpret_cast<CArray *>(JSObjectGetPrivate(object)));
1031     if (JSStringIsEqual(property, length_s))
1032         return CYCastJSValue(context, internal->length_);
1033     Type_privateData *typical(internal->type_);
1034     JSObjectRef owner(internal->owner_ ?: object);
1035     return Offset_getProperty(pool, context, property, internal->value_, typical, owner);
1036 } CYCatch(NULL) }
1037
1038 static bool CArray_setProperty(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef value, JSValueRef *exception) { CYTry {
1039     CYPool pool;
1040     Pointer *internal(reinterpret_cast<Pointer *>(JSObjectGetPrivate(object)));
1041     Type_privateData *typical(internal->type_);
1042     return Offset_setProperty(pool, context, property, internal->value_, typical, value);
1043 } CYCatch(false) }
1044
1045 static JSValueRef Pointer_getProperty(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { CYTry {
1046     CYPool pool;
1047     Pointer *internal(reinterpret_cast<Pointer *>(JSObjectGetPrivate(object)));
1048
1049     Type_privateData *typical(internal->type_);
1050
1051     if (sig::Function *function = dynamic_cast<sig::Function *>(typical->type_)) {
1052         if (!JSStringIsEqualToUTF8CString(property, "$cyi"))
1053             return NULL;
1054         return CYMakeFunctor(context, reinterpret_cast<void (*)()>(internal->value_), function->variadic, function->signature);
1055     }
1056
1057     JSObjectRef owner(internal->owner_ ?: object);
1058     return Offset_getProperty(pool, context, property, internal->value_, typical, owner);
1059 } CYCatch(NULL) }
1060
1061 static bool Pointer_setProperty(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef value, JSValueRef *exception) { CYTry {
1062     CYPool pool;
1063     Pointer *internal(reinterpret_cast<Pointer *>(JSObjectGetPrivate(object)));
1064     Type_privateData *typical(internal->type_);
1065     return Offset_setProperty(pool, context, property, internal->value_, typical, value);
1066 } CYCatch(false) }
1067
1068 static JSValueRef Struct_callAsFunction_$cya(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
1069     Struct_privateData *internal(reinterpret_cast<Struct_privateData *>(JSObjectGetPrivate(_this)));
1070     Type_privateData *typical(internal->type_);
1071     return CYMakePointer(context, internal->value_, *typical->type_, typical->ffi_, _this);
1072 } CYCatch(NULL) }
1073
1074 static JSValueRef Struct_getProperty_$cyt(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { CYTry {
1075     Struct_privateData *internal(reinterpret_cast<Struct_privateData *>(JSObjectGetPrivate(object)));
1076     return CYMakeType(context, *internal->type_->type_);
1077 } CYCatch(NULL) }
1078
1079 static JSValueRef Struct_getProperty(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { CYTry {
1080     CYPool pool;
1081     Struct_privateData *internal(reinterpret_cast<Struct_privateData *>(JSObjectGetPrivate(object)));
1082     Type_privateData *typical(internal->type_);
1083     sig::Aggregate *type(static_cast<sig::Aggregate *>(typical->type_));
1084
1085     ssize_t index;
1086     uint8_t *base;
1087
1088     if (!Index_(pool, context, internal, property, index, base))
1089         return NULL;
1090
1091     JSObjectRef owner(internal->owner_ ?: object);
1092
1093     return type->signature.elements[index].type->FromFFI(context, typical->GetFFI()->elements[index], base, false, owner);
1094 } CYCatch(NULL) }
1095
1096 static bool Struct_setProperty(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef value, JSValueRef *exception) { CYTry {
1097     CYPool pool;
1098     Struct_privateData *internal(reinterpret_cast<Struct_privateData *>(JSObjectGetPrivate(object)));
1099     Type_privateData *typical(internal->type_);
1100     sig::Aggregate *type(static_cast<sig::Aggregate *>(typical->type_));
1101
1102     ssize_t index;
1103     uint8_t *base;
1104
1105     if (!Index_(pool, context, internal, property, index, base))
1106         return false;
1107
1108     type->signature.elements[index].type->PoolFFI(NULL, context, typical->GetFFI()->elements[index], base, value);
1109     return true;
1110 } CYCatch(false) }
1111
1112 static void Struct_getPropertyNames(JSContextRef context, JSObjectRef object, JSPropertyNameAccumulatorRef names) {
1113     Struct_privateData *internal(reinterpret_cast<Struct_privateData *>(JSObjectGetPrivate(object)));
1114     Type_privateData *typical(internal->type_);
1115     sig::Aggregate *type(static_cast<sig::Aggregate *>(typical->type_));
1116
1117     if (type == NULL)
1118         return;
1119
1120     size_t count(type->signature.count);
1121     sig::Element *elements(type->signature.elements);
1122
1123     char number[32];
1124
1125     for (size_t index(0); index != count; ++index) {
1126         const char *name;
1127         name = elements[index].name;
1128
1129         if (name == NULL) {
1130             sprintf(number, "%zu", index);
1131             name = number;
1132         }
1133
1134         JSPropertyNameAccumulatorAddName(names, CYJSString(name));
1135     }
1136 }
1137
1138 static sig::Void Void_;
1139 static sig::Pointer PointerToVoid_(Void_);
1140
1141 static sig::Type *CYGetType(CYPool &pool, JSContextRef context, JSValueRef value) {
1142     if (JSValueIsNull(context, value))
1143         return &PointerToVoid_;
1144     JSObjectRef object(CYCastJSObject(context, value));
1145     JSObjectRef type(CYCastJSObject(context, CYGetProperty(context, object, cyt_s)));
1146     _assert(JSValueIsObjectOfClass(context, type, Type_privateData::Class_));
1147     Type_privateData *internal(reinterpret_cast<Type_privateData *>(JSObjectGetPrivate(type)));
1148     return internal->type_;
1149 }
1150
1151 void CYCallFunction(CYPool &pool, JSContextRef context, ffi_cif *cif, void (*function)(), void *value, void **values) {
1152     ffi_call(cif, function, value, values);
1153 }
1154
1155 JSValueRef CYCallFunction(CYPool &pool, JSContextRef context, size_t setups, void *setup[], size_t count, const JSValueRef arguments[], bool initialize, bool variadic, const sig::Signature &signature, ffi_cif *cif, void (*function)()) {
1156     size_t have(setups + count);
1157     size_t need(signature.count - 1);
1158
1159     if (have < need)
1160         throw CYJSError(context, "insufficient number of arguments to ffi function");
1161
1162     ffi_cif corrected;
1163     sig::Element *elements(signature.elements);
1164
1165     if (have > need) {
1166         if (!variadic)
1167             throw CYJSError(context, "exorbitant number of arguments to ffi function");
1168
1169         elements = new (pool) sig::Element[have + 1];
1170         memcpy(elements, signature.elements, sizeof(sig::Element) * (need + 1));
1171
1172         for (size_t index(need); index != have; ++index) {
1173             sig::Element &element(elements[index + 1]);
1174             element.name = NULL;
1175             element.offset = _not(size_t);
1176             element.type = CYGetType(pool, context, arguments[index - setups]);
1177         }
1178
1179         sig::Signature extended;
1180         extended.elements = elements;
1181         extended.count = have + 1;
1182         sig::sig_ffi_cif(pool, signature.count, extended, &corrected);
1183         cif = &corrected;
1184     }
1185
1186     void *values[have];
1187     memcpy(values, setup, sizeof(void *) * setups);
1188
1189     for (size_t index(setups); index != have; ++index) {
1190         sig::Element &element(elements[index + 1]);
1191         ffi_type *ffi(cif->arg_types[index]);
1192         values[index] = pool.malloc<uint8_t>(ffi->size, ffi->alignment);
1193         element.type->PoolFFI(&pool, context, ffi, values[index], arguments[index - setups]);
1194     }
1195
1196     uint8_t value[cif->rtype->size];
1197
1198     void (*call)(CYPool &, JSContextRef, ffi_cif *, void (*)(), void *, void **) = &CYCallFunction;
1199     // XXX: this only supports one hook, but it is a bad idea anyway
1200     for (CYHook *hook : GetHooks())
1201         if (hook->CallFunction != NULL)
1202             call = hook->CallFunction;
1203
1204     call(pool, context, cif, function, value, values);
1205     return signature.elements[0].type->FromFFI(context, cif->rtype, value, initialize);
1206 }
1207
1208 static JSValueRef Functor_callAsFunction(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
1209     CYPool pool;
1210     cy::Functor *internal(reinterpret_cast<cy::Functor *>(JSObjectGetPrivate(object)));
1211     return CYCallFunction(pool, context, 0, NULL, count, arguments, false, internal->variadic_, internal->signature_, &internal->cif_, internal->value_);
1212 } CYCatch(NULL) }
1213
1214 static JSValueRef Pointer_callAsFunction(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
1215     Pointer *internal(reinterpret_cast<Pointer *>(JSObjectGetPrivate(object)));
1216     if (dynamic_cast<sig::Function *>(internal->type_->type_) == NULL)
1217         throw CYJSError(context, "cannot call a pointer to non-function");
1218     JSObjectRef functor(CYCastJSObject(context, CYGetProperty(context, object, cyi_s)));
1219     return CYCallAsFunction(context, functor, _this, count, arguments);
1220 } CYCatch(NULL) }
1221
1222 JSObjectRef CYMakeType(JSContextRef context, const sig::Type &type) {
1223     return Type_privateData::Make(context, type);
1224 }
1225
1226 extern "C" bool CYBridgeHash(CYPool &pool, CYUTF8String name, const char *&code, unsigned &flags) {
1227     sqlite3_stmt *statement;
1228
1229     _sqlcall(sqlite3_prepare(database_,
1230         "select "
1231             "\"cache\".\"code\", "
1232             "\"cache\".\"flags\" "
1233         "from \"cache\" "
1234         "where"
1235             " \"cache\".\"system\" & " CY_SYSTEM " == " CY_SYSTEM " and"
1236             " \"cache\".\"name\" = ?"
1237         " limit 1"
1238     , -1, &statement, NULL));
1239
1240     _sqlcall(sqlite3_bind_text(statement, 1, name.data, name.size, SQLITE_STATIC));
1241
1242     bool success;
1243     if (_sqlcall(sqlite3_step(statement)) == SQLITE_DONE)
1244         success = false;
1245     else {
1246         success = true;
1247         code = sqlite3_column_pooled(pool, statement, 0);
1248         flags = sqlite3_column_int(statement, 1);
1249     }
1250
1251     _sqlcall(sqlite3_finalize(statement));
1252     return success;
1253 }
1254
1255 static bool All_hasProperty(JSContextRef context, JSObjectRef object, JSStringRef property) {
1256     if (JSStringIsEqualToUTF8CString(property, "errno"))
1257         return true;
1258
1259     JSObjectRef global(CYGetGlobalObject(context));
1260     JSObjectRef cycript(CYCastJSObject(context, CYGetProperty(context, global, CYJSString("Cycript"))));
1261     JSObjectRef alls(CYCastJSObject(context, CYGetProperty(context, cycript, CYJSString("alls"))));
1262
1263     for (size_t i(0), count(CYArrayLength(context, alls)); i != count; ++i)
1264         if (JSObjectRef space = CYCastJSObject(context, CYArrayGet(context, alls, count - i - 1)))
1265             if (CYHasProperty(context, space, property))
1266                 return true;
1267
1268     CYPool pool;
1269     const char *code;
1270     unsigned flags;
1271     if (CYBridgeHash(pool, CYPoolUTF8String(pool, context, property), code, flags))
1272         return true;
1273
1274     return false;
1275 }
1276
1277 static JSValueRef All_getProperty(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { CYTry {
1278     if (JSStringIsEqualToUTF8CString(property, "errno"))
1279         return CYCastJSValue(context, errno);
1280
1281     JSObjectRef global(CYGetGlobalObject(context));
1282     JSObjectRef cycript(CYCastJSObject(context, CYGetProperty(context, global, CYJSString("Cycript"))));
1283     JSObjectRef alls(CYCastJSObject(context, CYGetProperty(context, cycript, CYJSString("alls"))));
1284
1285     for (size_t i(0), count(CYArrayLength(context, alls)); i != count; ++i)
1286         if (JSObjectRef space = CYCastJSObject(context, CYArrayGet(context, alls, count - i - 1)))
1287             if (JSValueRef value = CYGetProperty(context, space, property))
1288                 if (!JSValueIsUndefined(context, value))
1289                     return value;
1290
1291     CYPool pool;
1292     const char *code;
1293     unsigned flags;
1294     if (CYBridgeHash(pool, CYPoolUTF8String(pool, context, property), code, flags)) {
1295         CYUTF8String parsed;
1296
1297         try {
1298             parsed = CYPoolCode(pool, code);
1299         } catch (const CYException &error) {
1300             CYThrow("%s", pool.strcat("error caching ", CYPoolCString(pool, context, property), ": ", error.PoolCString(pool), NULL));
1301         }
1302
1303         JSValueRef result(_jsccall(JSEvaluateScript, context, CYJSString(parsed), NULL, NULL, 0));
1304
1305         if (flags == 0) {
1306             JSObjectRef cache(CYGetCachedObject(context, CYJSString("cache")));
1307             CYSetProperty(context, cache, property, result);
1308         }
1309
1310         return result;
1311     }
1312
1313     return NULL;
1314 } CYCatch(NULL) }
1315
1316 static JSValueRef All_complete_callAsFunction(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
1317     _assert(count == 1);
1318     CYPool pool;
1319     CYUTF8String prefix(CYPoolUTF8String(pool, context, CYJSString(context, arguments[0])));
1320
1321     JSObjectRef array(NULL);
1322
1323     {
1324     CYArrayBuilder<1024> values(context, array);
1325
1326     sqlite3_stmt *statement;
1327
1328     if (prefix.size == 0)
1329         _sqlcall(sqlite3_prepare(database_,
1330             "select "
1331                 "\"cache\".\"name\" "
1332             "from \"cache\" "
1333             "where"
1334                 " \"cache\".\"system\" & " CY_SYSTEM " == " CY_SYSTEM
1335         , -1, &statement, NULL));
1336     else {
1337         _sqlcall(sqlite3_prepare(database_,
1338             "select "
1339                 "\"cache\".\"name\" "
1340             "from \"cache\" "
1341             "where"
1342                 " \"cache\".\"name\" >= ? and \"cache\".\"name\" < ? and "
1343                 " \"cache\".\"system\" & " CY_SYSTEM " == " CY_SYSTEM
1344         , -1, &statement, NULL));
1345
1346         _sqlcall(sqlite3_bind_text(statement, 1, prefix.data, prefix.size, SQLITE_STATIC));
1347
1348         char *after(pool.strndup(prefix.data, prefix.size));
1349         ++after[prefix.size - 1];
1350         _sqlcall(sqlite3_bind_text(statement, 2, after, prefix.size, SQLITE_STATIC));
1351     }
1352
1353     while (_sqlcall(sqlite3_step(statement)) != SQLITE_DONE)
1354         values(CYCastJSValue(context, CYJSString(sqlite3_column_string(statement, 0))));
1355
1356     _sqlcall(sqlite3_finalize(statement));
1357     }
1358
1359     return array;
1360 } CYCatch(NULL) }
1361
1362 static void All_getPropertyNames(JSContextRef context, JSObjectRef object, JSPropertyNameAccumulatorRef names) {
1363     JSObjectRef global(CYGetGlobalObject(context));
1364     JSObjectRef cycript(CYCastJSObject(context, CYGetProperty(context, global, CYJSString("Cycript"))));
1365     JSObjectRef alls(CYCastJSObject(context, CYGetProperty(context, cycript, CYJSString("alls"))));
1366
1367     for (size_t i(0), count(CYArrayLength(context, alls)); i != count; ++i)
1368         if (JSObjectRef space = CYCastJSObject(context, CYArrayGet(context, alls, count - i - 1))) {
1369             JSPropertyNameArrayRef subset(JSObjectCopyPropertyNames(context, space));
1370             for (size_t index(0), count(JSPropertyNameArrayGetCount(subset)); index != count; ++index)
1371                 JSPropertyNameAccumulatorAddName(names, JSPropertyNameArrayGetNameAtIndex(subset, index));
1372             JSPropertyNameArrayRelease(subset);
1373         }
1374 }
1375
1376 static JSObjectRef CArray_new(JSContextRef context, JSObjectRef object, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
1377     _assert(false);
1378 } CYCatch(NULL) }
1379
1380 static JSObjectRef CString_new(JSContextRef context, JSObjectRef object, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
1381     _assert(false);
1382 } CYCatch(NULL) }
1383
1384 static JSObjectRef Pointer_new(JSContextRef context, JSObjectRef object, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
1385     _assert(false);
1386 } CYCatch(NULL) }
1387
1388 static JSObjectRef Type_new(JSContextRef context, JSObjectRef object, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
1389     CYPool pool;
1390
1391     if (false) {
1392     } else if (count == 1) {
1393         const char *encoding(CYPoolCString(pool, context, arguments[0]));
1394         sig::Signature signature;
1395         sig::Parse(pool, &signature, encoding, &Structor_);
1396         return CYMakeType(context, *signature.elements[0].type);
1397     } else if (count == 2) {
1398         JSObjectRef types(CYCastJSObject(context, arguments[0]));
1399         size_t count(CYArrayLength(context, types));
1400
1401         JSObjectRef names(CYCastJSObject(context, arguments[1]));
1402
1403         sig::Aggregate type(false);
1404         type.signature.elements = new(pool) sig::Element[count];
1405         type.signature.count = count;
1406
1407         for (size_t i(0); i != count; ++i) {
1408             sig::Element &element(type.signature.elements[i]);
1409             element.offset = _not(size_t);
1410
1411             JSValueRef name(CYArrayGet(context, names, i));
1412             if (JSValueIsUndefined(context, name))
1413                 element.name = NULL;
1414             else
1415                 element.name = CYPoolCString(pool, context, name);
1416
1417             JSObjectRef object(CYCastJSObject(context, CYArrayGet(context, types, i)));
1418             _assert(JSValueIsObjectOfClass(context, object, Type_privateData::Class_));
1419             Type_privateData *internal(reinterpret_cast<Type_privateData *>(JSObjectGetPrivate(object)));
1420             element.type = internal->type_;
1421         }
1422
1423         return CYMakeType(context, type);
1424     } else {
1425         throw CYJSError(context, "incorrect number of arguments to Type constructor");
1426     }
1427 } CYCatch(NULL) }
1428
1429 static JSValueRef Type_callAsFunction_$With(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], sig::Callable &type, JSValueRef *exception) { CYTry {
1430     Type_privateData *internal(reinterpret_cast<Type_privateData *>(JSObjectGetPrivate(_this)));
1431
1432     CYPool pool;
1433
1434     type.signature.elements = new(pool) sig::Element[1 + count];
1435     type.signature.count = 1 + count;
1436
1437     type.signature.elements[0].name = NULL;
1438     type.signature.elements[0].type = internal->type_;
1439     type.signature.elements[0].offset = _not(size_t);
1440
1441     for (size_t i(0); i != count; ++i) {
1442         sig::Element &element(type.signature.elements[i + 1]);
1443         element.name = NULL;
1444         element.offset = _not(size_t);
1445
1446         JSObjectRef object(CYCastJSObject(context, arguments[i]));
1447         _assert(JSValueIsObjectOfClass(context, object, Type_privateData::Class_));
1448         Type_privateData *internal(reinterpret_cast<Type_privateData *>(JSObjectGetPrivate(object)));
1449
1450         element.type = internal->type_;
1451     }
1452
1453     return CYMakeType(context, type);
1454 } CYCatch(NULL) }
1455
1456 static JSValueRef Type_callAsFunction_arrayOf(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
1457     if (count != 1)
1458         throw CYJSError(context, "incorrect number of arguments to Type.arrayOf");
1459     Type_privateData *internal(reinterpret_cast<Type_privateData *>(JSObjectGetPrivate(_this)));
1460
1461     CYPool pool;
1462     size_t index(CYGetIndex(pool, context, CYJSString(context, arguments[0])));
1463     if (index == _not(size_t))
1464         throw CYJSError(context, "invalid array size used with Type.arrayOf");
1465
1466     sig::Array type(*internal->type_, index);
1467     return CYMakeType(context, type);
1468 } CYCatch(NULL) }
1469
1470 static JSValueRef Type_callAsFunction_blockWith(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) {
1471 #ifdef CY_OBJECTIVEC
1472     sig::Block type;
1473     return Type_callAsFunction_$With(context, object, _this, count, arguments, type, exception);
1474 #else
1475     _assert(false);
1476 #endif
1477 }
1478
1479 static JSValueRef Type_callAsFunction_constant(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
1480     if (count != 0)
1481         throw CYJSError(context, "incorrect number of arguments to Type.constant");
1482     Type_privateData *internal(reinterpret_cast<Type_privateData *>(JSObjectGetPrivate(_this)));
1483
1484     CYPool pool;
1485     sig::Type *type(internal->type_->Copy(pool));
1486     type->flags |= JOC_TYPE_CONST;
1487     return CYMakeType(context, *type);
1488 } CYCatch(NULL) }
1489
1490 static JSValueRef Type_callAsFunction_functionWith(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) {
1491     bool variadic(count != 0 && JSValueIsNull(context, arguments[count - 1]));
1492     sig::Function type(variadic);
1493     return Type_callAsFunction_$With(context, object, _this, variadic ? count - 1 : count, arguments, type, exception);
1494 }
1495
1496 static JSValueRef Type_callAsFunction_pointerTo(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
1497     if (count != 0)
1498         throw CYJSError(context, "incorrect number of arguments to Type.pointerTo");
1499     Type_privateData *internal(reinterpret_cast<Type_privateData *>(JSObjectGetPrivate(_this)));
1500
1501     if (dynamic_cast<sig::Primitive<char> *>(internal->type_) != NULL)
1502         return CYMakeType(context, sig::String());
1503     else
1504         return CYMakeType(context, sig::Pointer(*internal->type_));
1505 } CYCatch(NULL) }
1506
1507 static JSValueRef Type_callAsFunction_withName(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
1508     if (count != 1)
1509         throw CYJSError(context, "incorrect number of arguments to Type.withName");
1510     Type_privateData *internal(reinterpret_cast<Type_privateData *>(JSObjectGetPrivate(_this)));
1511
1512     CYPool pool;
1513     return CYMakeType(context, *internal->type_->Copy(pool, CYPoolCString(pool, context, arguments[0])));
1514 } CYCatch(NULL) }
1515
1516 static JSValueRef Type_callAsFunction(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
1517     if (count != 1)
1518         throw CYJSError(context, "incorrect number of arguments to type cast function");
1519     Type_privateData *internal(reinterpret_cast<Type_privateData *>(JSObjectGetPrivate(object)));
1520
1521     if (sig::Function *function = dynamic_cast<sig::Function *>(internal->type_))
1522         return CYMakeFunctor(context, arguments[0], function->variadic, function->signature);
1523
1524     CYPool pool;
1525     sig::Type *type(internal->type_);
1526     ffi_type *ffi(internal->GetFFI());
1527
1528     void *data(pool.malloc<void>(ffi->size, ffi->alignment));
1529     type->PoolFFI(&pool, context, ffi, data, arguments[0]);
1530     JSValueRef value(type->FromFFI(context, ffi, data));
1531
1532     if (JSValueGetType(context, value) == kJSTypeNumber) {
1533         JSObjectRef typed(_jsccall(JSObjectCallAsConstructor, context, CYGetCachedObject(context, CYJSString("Number")), 1, &value));
1534         CYSetProperty(context, typed, cyt_s, object, kJSPropertyAttributeDontEnum);
1535         value = typed;
1536     }
1537
1538     return value;
1539 } CYCatch(NULL) }
1540
1541 static JSObjectRef Type_callAsConstructor(JSContextRef context, JSObjectRef object, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
1542     if (count != 0)
1543         throw CYJSError(context, "incorrect number of arguments to Type allocator");
1544     Type_privateData *internal(reinterpret_cast<Type_privateData *>(JSObjectGetPrivate(object)));
1545
1546     JSObjectRef pointer(CYMakePointer(context, NULL, *internal->type_, NULL, NULL));
1547     Pointer *value(reinterpret_cast<Pointer *>(JSObjectGetPrivate(pointer)));
1548     ffi_type *ffi(internal->GetFFI());
1549     value->value_ = value->pool_->malloc<void>(ffi->size, ffi->alignment);
1550     memset(value->value_, 0, ffi->size);
1551     return pointer;
1552 } CYCatch(NULL) }
1553
1554 static JSObjectRef Functor_new(JSContextRef context, JSObjectRef object, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
1555     if (count != 2)
1556         throw CYJSError(context, "incorrect number of arguments to Functor constructor");
1557     CYPool pool;
1558     const char *encoding(CYPoolCString(pool, context, arguments[1]));
1559     sig::Signature signature;
1560     sig::Parse(pool, &signature, encoding, &Structor_);
1561     return CYMakeFunctor(context, arguments[0], false, signature);
1562 } CYCatch(NULL) }
1563
1564 static JSValueRef CArray_callAsFunction_toPointer(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
1565     CArray *internal(reinterpret_cast<CArray *>(JSObjectGetPrivate(_this)));
1566     JSObjectRef owner(internal->owner_ ?: object);
1567     return CYMakePointer(context, internal->value_, *internal->type_->type_, NULL, owner);
1568 } CYCatch(NULL) }
1569
1570 static JSValueRef CString_callAsFunction_toPointer(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
1571     CString *internal(reinterpret_cast<CString *>(JSObjectGetPrivate(_this)));
1572     JSObjectRef owner(internal->owner_ ?: object);
1573     return CYMakePointer(context, internal->value_, sig::Primitive<char>(), NULL, owner);
1574 } CYCatch(NULL) }
1575
1576 static JSValueRef Functor_callAsFunction_$cya(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
1577     CYPool pool;
1578     cy::Functor *internal(reinterpret_cast<cy::Functor *>(JSObjectGetPrivate(_this)));
1579
1580     sig::Function type(internal->variadic_);
1581     sig::Copy(pool, type.signature, internal->signature_);
1582
1583     return CYMakePointer(context, reinterpret_cast<void *>(internal->value_), type, NULL, NULL);
1584 } CYCatch(NULL) }
1585
1586 static JSValueRef Pointer_callAsFunction_toPointer(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
1587     return _this;
1588 } CYCatch(NULL) }
1589
1590 static JSValueRef CArray_callAsFunction_valueOf(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
1591     CArray *internal(reinterpret_cast<CArray *>(JSObjectGetPrivate(_this)));
1592     return CYCastJSValue(context, reinterpret_cast<uintptr_t>(internal->value_));
1593 } CYCatch(NULL) }
1594
1595 static JSValueRef Pointer_callAsFunction_valueOf(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
1596     Pointer *internal(reinterpret_cast<Pointer *>(JSObjectGetPrivate(_this)));
1597     return CYCastJSValue(context, reinterpret_cast<uintptr_t>(internal->value_));
1598 } CYCatch(NULL) }
1599
1600 static JSValueRef Functor_callAsFunction_valueOf(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
1601     cy::Functor *internal(reinterpret_cast<cy::Functor *>(JSObjectGetPrivate(_this)));
1602     return CYCastJSValue(context, reinterpret_cast<uintptr_t>(internal->value_));
1603 } CYCatch(NULL) }
1604
1605 static JSValueRef Functor_callAsFunction_toCYON(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
1606     cy::Functor *internal(reinterpret_cast<cy::Functor *>(JSObjectGetPrivate(_this)));
1607     uint8_t *value(reinterpret_cast<uint8_t *>(internal->value_));
1608     std::ostringstream str;
1609     Dl_info info;
1610     if (internal->value_ == NULL)
1611         str << "NULL";
1612     else if (dladdr(value, &info) == 0)
1613         str << internal->value_;
1614     else {
1615         str << info.dli_sname;
1616         off_t offset(value - reinterpret_cast<uint8_t *>(info.dli_saddr));
1617         if (offset != 0)
1618             str << "+0x" << std::hex << offset;
1619     }
1620     return CYCastJSValue(context, CYJSString(str.str()));
1621 } CYCatch(NULL) }
1622
1623 static JSValueRef Pointer_callAsFunction_toCYON(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
1624     std::set<void *> *objects(CYCastObjects(context, _this, count, arguments));
1625
1626     Pointer *internal(reinterpret_cast<Pointer *>(JSObjectGetPrivate(_this)));
1627
1628     try {
1629         JSValueRef value(CYGetProperty(context, _this, cyi_s));
1630         if (!JSValueIsUndefined(context, value)) {
1631             CYPool pool;
1632             return CYCastJSValue(context, pool.strcat("&", CYPoolCCYON(pool, context, value, objects), NULL));
1633         }
1634     } catch (const CYException &e) {
1635         // XXX: it might be interesting to include this error
1636     }
1637
1638     CYLocalPool pool;
1639     std::ostringstream str;
1640
1641     sig::Pointer type(*internal->type_->type_);
1642
1643     CYOptions options;
1644     CYOutput output(*str.rdbuf(), options);
1645     (new(pool) CYTypeExpression(CYDecodeType(pool, &type)))->Output(output, CYNoFlags);
1646
1647     str << "(" << internal->value_ << ")";
1648     std::string value(str.str());
1649     return CYCastJSValue(context, CYJSString(CYUTF8String(value.c_str(), value.size())));
1650 } CYCatch(NULL) }
1651
1652 static JSValueRef CString_getProperty_length(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { CYTry {
1653     CString *internal(reinterpret_cast<CString *>(JSObjectGetPrivate(object)));
1654     return CYCastJSValue(context, strlen(internal->value_));
1655 } CYCatch(NULL) }
1656
1657 static JSValueRef CString_getProperty_$cyt(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { CYTry {
1658     return CYMakeType(context, sig::String());
1659 } CYCatch(NULL) }
1660
1661 static JSValueRef CArray_getProperty_$cyt(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { CYTry {
1662     CArray *internal(reinterpret_cast<CArray *>(JSObjectGetPrivate(object)));
1663     sig::Array type(*internal->type_->type_, internal->length_);
1664     return CYMakeType(context, type);
1665 } CYCatch(NULL) }
1666
1667 static JSValueRef Pointer_getProperty_$cyt(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { CYTry {
1668     Pointer *internal(reinterpret_cast<Pointer *>(JSObjectGetPrivate(object)));
1669     sig::Pointer type(*internal->type_->type_);
1670     return CYMakeType(context, type);
1671 } CYCatch(NULL) }
1672
1673 static JSValueRef CString_callAsFunction_toCYON(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
1674     CString *internal(reinterpret_cast<CString *>(JSObjectGetPrivate(_this)));
1675     const char *string(internal->value_);
1676     std::ostringstream str;
1677     if (string == NULL)
1678         str << "NULL";
1679     else {
1680         str << "&";
1681         CYStringify(str, string, strlen(string), true);
1682     }
1683     std::string value(str.str());
1684     return CYCastJSValue(context, CYJSString(CYUTF8String(value.c_str(), value.size())));
1685 } CYCatch(NULL) }
1686
1687 static JSValueRef CString_callAsFunction_toString(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
1688     CString *internal(reinterpret_cast<CString *>(JSObjectGetPrivate(_this)));
1689     return CYCastJSValue(context, internal->value_);
1690 } CYCatch(NULL) }
1691
1692 static JSValueRef Functor_getProperty_$cyt(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { CYTry {
1693     cy::Functor *internal(reinterpret_cast<cy::Functor *>(JSObjectGetPrivate(object)));
1694     CYPool pool;
1695     sig::Function type(internal->variadic_);
1696     sig::Copy(pool, type.signature, internal->signature_);
1697     return CYMakeType(context, type);
1698 } CYCatch(NULL) }
1699
1700 static JSValueRef Type_getProperty_alignment(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { CYTry {
1701     Type_privateData *internal(reinterpret_cast<Type_privateData *>(JSObjectGetPrivate(object)));
1702     return CYCastJSValue(context, internal->GetFFI()->alignment);
1703 } CYCatch(NULL) }
1704
1705 static JSValueRef Type_getProperty_name(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { CYTry {
1706     Type_privateData *internal(reinterpret_cast<Type_privateData *>(JSObjectGetPrivate(object)));
1707     return CYCastJSValue(context, internal->type_->GetName());
1708 } CYCatch(NULL) }
1709
1710 static JSValueRef Type_getProperty_size(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { CYTry {
1711     Type_privateData *internal(reinterpret_cast<Type_privateData *>(JSObjectGetPrivate(object)));
1712     return CYCastJSValue(context, internal->GetFFI()->size);
1713 } CYCatch(NULL) }
1714
1715 static JSValueRef Type_callAsFunction_toString(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
1716     Type_privateData *internal(reinterpret_cast<Type_privateData *>(JSObjectGetPrivate(_this)));
1717     CYPool pool;
1718     const char *type(sig::Unparse(pool, internal->type_));
1719     return CYCastJSValue(context, CYJSString(type));
1720 } CYCatch(NULL) }
1721
1722 static JSValueRef Type_callAsFunction_toCYON(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
1723     Type_privateData *internal(reinterpret_cast<Type_privateData *>(JSObjectGetPrivate(_this)));
1724     CYLocalPool pool;
1725     std::stringbuf out;
1726     CYOptions options;
1727     CYOutput output(out, options);
1728     (new(pool) CYTypeExpression(CYDecodeType(pool, internal->type_)))->Output(output, CYNoFlags);
1729     return CYCastJSValue(context, CYJSString(out.str().c_str()));
1730 } CYCatch(NULL) }
1731
1732 static JSStaticFunction All_staticFunctions[2] = {
1733     {"cy$complete", &All_complete_callAsFunction, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
1734     {NULL, NULL, 0}
1735 };
1736
1737 static JSStaticFunction CArray_staticFunctions[3] = {
1738     {"toPointer", &CArray_callAsFunction_toPointer, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
1739     {"valueOf", &CArray_callAsFunction_valueOf, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
1740     {NULL, NULL, 0}
1741 };
1742
1743 static JSStaticValue CArray_staticValues[2] = {
1744     {"$cyt", &CArray_getProperty_$cyt, NULL, kJSPropertyAttributeReadOnly | kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
1745     {NULL, NULL, NULL, 0}
1746 };
1747
1748 static JSStaticFunction CString_staticFunctions[5] = {
1749     {"toCYON", &CString_callAsFunction_toCYON, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
1750     {"toPointer", &CString_callAsFunction_toPointer, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
1751     {"toString", &CString_callAsFunction_toString, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
1752     {"valueOf", &CString_callAsFunction_toString, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
1753     {NULL, NULL, 0}
1754 };
1755
1756 static JSStaticValue CString_staticValues[3] = {
1757     {"length", &CString_getProperty_length, NULL, kJSPropertyAttributeReadOnly | kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
1758     {"$cyt", &CString_getProperty_$cyt, NULL, kJSPropertyAttributeReadOnly | kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
1759     {NULL, NULL, NULL, 0}
1760 };
1761
1762 static JSStaticFunction Pointer_staticFunctions[4] = {
1763     {"toCYON", &Pointer_callAsFunction_toCYON, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
1764     {"toPointer", &Pointer_callAsFunction_toPointer, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
1765     {"valueOf", &Pointer_callAsFunction_valueOf, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
1766     {NULL, NULL, 0}
1767 };
1768
1769 static JSStaticValue Pointer_staticValues[2] = {
1770     {"$cyt", &Pointer_getProperty_$cyt, NULL, kJSPropertyAttributeReadOnly | kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
1771     {NULL, NULL, NULL, 0}
1772 };
1773
1774 static JSStaticFunction Struct_staticFunctions[2] = {
1775     {"$cya", &Struct_callAsFunction_$cya, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
1776     {NULL, NULL, 0}
1777 };
1778
1779 static JSStaticValue Struct_staticValues[2] = {
1780     {"$cyt", &Struct_getProperty_$cyt, NULL, kJSPropertyAttributeReadOnly | kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
1781     {NULL, NULL, NULL, 0}
1782 };
1783
1784 static JSStaticFunction Functor_staticFunctions[4] = {
1785     {"$cya", &Functor_callAsFunction_$cya, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
1786     {"toCYON", &Functor_callAsFunction_toCYON, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
1787     {"valueOf", &Functor_callAsFunction_valueOf, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
1788     {NULL, NULL, 0}
1789 };
1790
1791 namespace cy {
1792     JSStaticFunction const * const Functor::StaticFunctions = Functor_staticFunctions;
1793 }
1794
1795 static JSStaticValue Functor_staticValues[2] = {
1796     {"$cyt", &Functor_getProperty_$cyt, NULL, kJSPropertyAttributeReadOnly | kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
1797     {NULL, NULL, NULL, 0}
1798 };
1799
1800 namespace cy {
1801     JSStaticValue const * const Functor::StaticValues = Functor_staticValues;
1802 }
1803
1804 static JSStaticValue Type_staticValues[4] = {
1805     {"alignment", &Type_getProperty_alignment, NULL, kJSPropertyAttributeReadOnly | kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
1806     {"name", &Type_getProperty_name, NULL, kJSPropertyAttributeReadOnly | kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
1807     {"size", &Type_getProperty_size, NULL, kJSPropertyAttributeReadOnly | kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
1808     {NULL, NULL, NULL, 0}
1809 };
1810
1811 static JSStaticFunction Type_staticFunctions[9] = {
1812     {"arrayOf", &Type_callAsFunction_arrayOf, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
1813     {"blockWith", &Type_callAsFunction_blockWith, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
1814     {"constant", &Type_callAsFunction_constant, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
1815     {"functionWith", &Type_callAsFunction_functionWith, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
1816     {"pointerTo", &Type_callAsFunction_pointerTo, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
1817     {"withName", &Type_callAsFunction_withName, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
1818     {"toCYON", &Type_callAsFunction_toCYON, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
1819     {"toString", &Type_callAsFunction_toString, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
1820     {NULL, NULL, 0}
1821 };
1822
1823 _visible void CYSetArgs(int argc, const char *argv[]) {
1824     JSContextRef context(CYGetJSContext());
1825     JSValueRef args[argc];
1826     for (int i(0); i != argc; ++i)
1827         args[i] = CYCastJSValue(context, argv[i]);
1828
1829     JSObjectRef array(CYObjectMakeArray(context, argc, args));
1830     JSObjectRef System(CYGetCachedObject(context, CYJSString("System")));
1831     CYSetProperty(context, System, CYJSString("args"), array);
1832 }
1833
1834 JSObjectRef CYGetGlobalObject(JSContextRef context) {
1835     return JSContextGetGlobalObject(context);
1836 }
1837
1838 // XXX: this is neither exceptin safe nor even terribly sane
1839 class ExecutionHandle {
1840   private:
1841     JSContextRef context_;
1842     std::vector<void *> handles_;
1843
1844   public:
1845     ExecutionHandle(JSContextRef context) :
1846         context_(context)
1847     {
1848         handles_.resize(GetHooks().size());
1849         for (size_t i(0); i != GetHooks().size(); ++i) {
1850             CYHook *hook(GetHooks()[i]);
1851             if (hook->ExecuteStart != NULL)
1852                 handles_[i] = (*hook->ExecuteStart)(context_);
1853             else
1854                 handles_[i] = NULL;
1855         }
1856     }
1857
1858     ~ExecutionHandle() {
1859         for (size_t i(GetHooks().size()); i != 0; --i) {
1860             CYHook *hook(GetHooks()[i-1]);
1861             if (hook->ExecuteEnd != NULL)
1862                 (*hook->ExecuteEnd)(context_, handles_[i-1]);
1863         }
1864     }
1865 };
1866
1867 #ifndef __ANDROID__
1868 static volatile bool cancel_;
1869
1870 static bool CYShouldTerminate(JSContextRef context, void *arg) {
1871     return cancel_;
1872 }
1873 #endif
1874
1875 _visible const char *CYExecute(JSContextRef context, CYPool &pool, CYUTF8String code) {
1876     ExecutionHandle handle(context);
1877
1878 #ifndef __ANDROID__
1879     cancel_ = false;
1880     if (&JSContextGroupSetExecutionTimeLimit != NULL)
1881         JSContextGroupSetExecutionTimeLimit(JSContextGetGroup(context), 0.5, &CYShouldTerminate, NULL);
1882 #endif
1883
1884     try {
1885         JSValueRef result(_jsccall(JSEvaluateScript, context, CYJSString(code), NULL, NULL, 0));
1886         if (JSValueIsUndefined(context, result))
1887             return NULL;
1888
1889         std::set<void *> objects;
1890         const char *json(_jsccall(CYPoolCCYON, pool, context, result, objects));
1891         CYSetProperty(context, CYGetGlobalObject(context), Result_, result);
1892
1893         return json;
1894     } catch (const CYException &error) {
1895         return pool.strcat("throw ", error.PoolCString(pool), NULL);
1896     }
1897 }
1898
1899 #ifndef __ANDROID__
1900 _visible void CYCancel() {
1901     cancel_ = true;
1902 }
1903 #endif
1904
1905 const char *CYPoolLibraryPath(CYPool &pool);
1906
1907 static bool initialized_ = false;
1908
1909 void CYInitializeDynamic() {
1910     if (!initialized_)
1911         initialized_ = true;
1912     else return;
1913
1914     CYPool pool;
1915     const char *db(pool.strcat(CYPoolLibraryPath(pool), "/libcycript.db", NULL));
1916     _sqlcall(sqlite3_open_v2(db, &database_, SQLITE_OPEN_READONLY, NULL));
1917
1918     JSObjectMakeArray$ = reinterpret_cast<JSObjectRef (*)(JSContextRef, size_t, const JSValueRef[], JSValueRef *)>(dlsym(RTLD_DEFAULT, "JSObjectMakeArray"));
1919     JSSynchronousGarbageCollectForDebugging$ = reinterpret_cast<void (*)(JSContextRef)>(dlsym(RTLD_DEFAULT, "JSSynchronousGarbageCollectForDebugging"));
1920
1921     JSClassDefinition definition;
1922
1923     definition = kJSClassDefinitionEmpty;
1924     definition.className = "All";
1925     definition.staticFunctions = All_staticFunctions;
1926     definition.hasProperty = &All_hasProperty;
1927     definition.getProperty = &All_getProperty;
1928     definition.getPropertyNames = &All_getPropertyNames;
1929     All_ = JSClassCreate(&definition);
1930
1931     definition = kJSClassDefinitionEmpty;
1932     definition.className = "Context";
1933     definition.finalize = &CYFinalize;
1934     Context::Class_ = JSClassCreate(&definition);
1935
1936     definition = kJSClassDefinitionEmpty;
1937     definition.className = "CArray";
1938     definition.staticFunctions = CArray_staticFunctions;
1939     definition.staticValues = CArray_staticValues;
1940     definition.getProperty = &CArray_getProperty;
1941     definition.setProperty = &CArray_setProperty;
1942     definition.finalize = &CYFinalize;
1943     CArray::Class_ = JSClassCreate(&definition);
1944
1945     definition = kJSClassDefinitionEmpty;
1946     definition.className = "CString";
1947     definition.staticFunctions = CString_staticFunctions;
1948     definition.staticValues = CString_staticValues;
1949     definition.getProperty = &CString_getProperty;
1950     definition.setProperty = &CString_setProperty;
1951     definition.finalize = &CYFinalize;
1952     CString::Class_ = JSClassCreate(&definition);
1953
1954     definition = kJSClassDefinitionEmpty;
1955     definition.className = "Functor";
1956     definition.staticFunctions = cy::Functor::StaticFunctions;
1957     definition.staticValues = Functor_staticValues;
1958     definition.callAsFunction = &Functor_callAsFunction;
1959     definition.finalize = &CYFinalize;
1960     Functor_ = JSClassCreate(&definition);
1961
1962     definition = kJSClassDefinitionEmpty;
1963     definition.className = "Pointer";
1964     definition.staticFunctions = Pointer_staticFunctions;
1965     definition.staticValues = Pointer_staticValues;
1966     definition.callAsFunction = &Pointer_callAsFunction;
1967     definition.getProperty = &Pointer_getProperty;
1968     definition.setProperty = &Pointer_setProperty;
1969     definition.finalize = &CYFinalize;
1970     Pointer::Class_ = JSClassCreate(&definition);
1971
1972     definition = kJSClassDefinitionEmpty;
1973     definition.className = "Struct";
1974     definition.staticFunctions = Struct_staticFunctions;
1975     definition.staticValues = Struct_staticValues;
1976     definition.getProperty = &Struct_getProperty;
1977     definition.setProperty = &Struct_setProperty;
1978     definition.getPropertyNames = &Struct_getPropertyNames;
1979     definition.finalize = &CYFinalize;
1980     Struct_privateData::Class_ = JSClassCreate(&definition);
1981
1982     definition = kJSClassDefinitionEmpty;
1983     definition.className = "Type";
1984     definition.staticValues = Type_staticValues;
1985     definition.staticFunctions = Type_staticFunctions;
1986     definition.callAsFunction = &Type_callAsFunction;
1987     definition.callAsConstructor = &Type_callAsConstructor;
1988     definition.finalize = &CYFinalize;
1989     Type_privateData::Class_ = JSClassCreate(&definition);
1990
1991     definition = kJSClassDefinitionEmpty;
1992     definition.className = "Global";
1993     //definition.getProperty = &Global_getProperty;
1994     Global_ = JSClassCreate(&definition);
1995
1996     Array_s = JSStringCreateWithUTF8CString("Array");
1997     cy_s = JSStringCreateWithUTF8CString("$cy");
1998     cyi_s = JSStringCreateWithUTF8CString("$cyi");
1999     cyt_s = JSStringCreateWithUTF8CString("$cyt");
2000     length_s = JSStringCreateWithUTF8CString("length");
2001     message_s = JSStringCreateWithUTF8CString("message");
2002     name_s = JSStringCreateWithUTF8CString("name");
2003     pop_s = JSStringCreateWithUTF8CString("pop");
2004     prototype_s = JSStringCreateWithUTF8CString("prototype");
2005     push_s = JSStringCreateWithUTF8CString("push");
2006     splice_s = JSStringCreateWithUTF8CString("splice");
2007     toCYON_s = JSStringCreateWithUTF8CString("toCYON");
2008     toJSON_s = JSStringCreateWithUTF8CString("toJSON");
2009     toPointer_s = JSStringCreateWithUTF8CString("toPointer");
2010     toString_s = JSStringCreateWithUTF8CString("toString");
2011     weak_s = JSStringCreateWithUTF8CString("weak");
2012
2013     Result_ = JSStringCreateWithUTF8CString("_");
2014
2015     for (CYHook *hook : GetHooks())
2016         if (hook->Initialize != NULL)
2017             (*hook->Initialize)();
2018 }
2019
2020 void CYThrow(JSContextRef context, JSValueRef value) {
2021     if (value != NULL)
2022         throw CYJSError(context, value);
2023 }
2024
2025 const char *CYJSError::PoolCString(CYPool &pool) const {
2026     std::set<void *> objects;
2027     // XXX: this used to be CYPoolCString
2028     return CYPoolCCYON(pool, context_, value_, objects);
2029 }
2030
2031 JSValueRef CYJSError::CastJSValue(JSContextRef context, const char *name) const {
2032     // XXX: what if the context is different? or the name? I dunno. ("epic" :/)
2033     return value_;
2034 }
2035
2036 JSValueRef CYCastJSError(JSContextRef context, const char *name, const char *message) {
2037     JSObjectRef Error(CYGetCachedObject(context, CYJSString(name)));
2038     JSValueRef arguments[1] = {CYCastJSValue(context, message)};
2039     return _jsccall(JSObjectCallAsConstructor, context, Error, 1, arguments);
2040 }
2041
2042 JSValueRef CYPoolError::CastJSValue(JSContextRef context, const char *name) const {
2043     return CYCastJSError(context, name, message_);
2044 }
2045
2046 CYJSError::CYJSError(JSContextRef context, const char *format, ...) {
2047     _assert(context != NULL);
2048
2049     CYPool pool;
2050
2051     va_list args;
2052     va_start(args, format);
2053     // XXX: there might be a beter way to think about this
2054     const char *message(pool.vsprintf(64, format, args));
2055     va_end(args);
2056
2057     value_ = CYCastJSError(context, "Error", message);
2058 }
2059
2060 JSGlobalContextRef CYGetJSContext(JSContextRef context) {
2061     return reinterpret_cast<Context *>(JSObjectGetPrivate(CYCastJSObject(context, CYGetProperty(context, CYGetGlobalObject(context), cy_s))))->context_;
2062 }
2063
2064 const char *CYPoolLibraryPath(CYPool &pool) {
2065     Dl_info addr;
2066     _assert(dladdr(reinterpret_cast<void *>(&CYPoolLibraryPath), &addr) != 0);
2067     char *lib(pool.strdup(addr.dli_fname));
2068
2069     char *slash(strrchr(lib, '/'));
2070     if (slash == NULL)
2071         return ".";
2072     *slash = '\0';
2073
2074     slash = strrchr(lib, '/');
2075     if (slash != NULL && strcmp(slash, "/.libs") == 0)
2076         *slash = '\0';
2077
2078     return lib;
2079 }
2080
2081 static JSValueRef require_callAsFunction(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
2082     _assert(count == 1);
2083     CYPool pool;
2084
2085     const char *name(CYPoolCString(pool, context, arguments[0]));
2086     if (strchr(name, '/') == NULL && (
2087 #ifdef __APPLE__
2088         dlopen(pool.strcat("/System/Library/Frameworks/", name, ".framework/", name, NULL), RTLD_LAZY | RTLD_GLOBAL) != NULL ||
2089         dlopen(pool.strcat("/System/Library/PrivateFrameworks/", name, ".framework/", name, NULL), RTLD_LAZY | RTLD_GLOBAL) != NULL ||
2090 #endif
2091     false))
2092         return CYJSUndefined(context);
2093
2094     JSObjectRef resolve(CYCastJSObject(context, CYGetProperty(context, object, CYJSString("resolve"))));
2095     CYJSString path(context, CYCallAsFunction(context, resolve, NULL, 1, arguments));
2096
2097     CYJSString property("exports");
2098
2099     JSObjectRef modules(CYGetCachedObject(context, CYJSString("modules")));
2100     JSValueRef cache(CYGetProperty(context, modules, path));
2101
2102     JSValueRef result;
2103     if (!JSValueIsUndefined(context, cache)) {
2104         JSObjectRef module(CYCastJSObject(context, cache));
2105         result = CYGetProperty(context, module, property);
2106     } else {
2107         CYUTF8String code(CYPoolFileUTF8String(pool, CYPoolCString(pool, context, path)));
2108         _assert(code.data != NULL);
2109
2110         size_t length(strlen(name));
2111         if (length >= 5 && strcmp(name + length - 5, ".json") == 0) {
2112             JSObjectRef JSON(CYGetCachedObject(context, CYJSString("JSON")));
2113             JSObjectRef parse(CYCastJSObject(context, CYGetProperty(context, JSON, CYJSString("parse"))));
2114             JSValueRef arguments[1] = { CYCastJSValue(context, CYJSString(code)) };
2115             result = CYCallAsFunction(context, parse, JSON, 1, arguments);
2116         } else {
2117             JSObjectRef module(JSObjectMake(context, NULL, NULL));
2118             CYSetProperty(context, modules, path, module);
2119
2120             JSObjectRef exports(JSObjectMake(context, NULL, NULL));
2121             CYSetProperty(context, module, property, exports);
2122
2123             std::stringstream wrap;
2124             wrap << "(function (exports, require, module, __filename) { " << code << "\n});";
2125             code = CYPoolCode(pool, *wrap.rdbuf());
2126
2127             JSValueRef value(_jsccall(JSEvaluateScript, context, CYJSString(code), NULL, NULL, 0));
2128             JSObjectRef function(CYCastJSObject(context, value));
2129
2130             JSValueRef arguments[4] = { exports, object, module, CYCastJSValue(context, path) };
2131             CYCallAsFunction(context, function, NULL, 4, arguments);
2132             result = CYGetProperty(context, module, property);
2133         }
2134     }
2135
2136     return result;
2137 } CYCatch(NULL) }
2138
2139 static bool CYRunScript(JSGlobalContextRef context, const char *path) {
2140     CYPool pool;
2141     CYUTF8String code(CYPoolFileUTF8String(pool, pool.strcat(CYPoolLibraryPath(pool), path, NULL)));
2142     if (code.data == NULL)
2143         return false;
2144
2145     code = CYPoolCode(pool, code);
2146     _jsccall(JSEvaluateScript, context, CYJSString(code), NULL, NULL, 0);
2147     return true;
2148 }
2149
2150 extern "C" void CYDestroyWeak(JSWeakObjectMapRef weak, void *data) {
2151 }
2152
2153 extern "C" void CYSetupContext(JSGlobalContextRef context) {
2154     CYInitializeDynamic();
2155
2156     JSObjectRef global(CYGetGlobalObject(context));
2157
2158     JSObjectRef cy(Context::Make(context, context));
2159     CYSetProperty(context, global, cy_s, cy, kJSPropertyAttributeDontEnum);
2160
2161 /* Cache Globals {{{ */
2162     JSObjectRef Array(CYCastJSObject(context, CYGetProperty(context, global, CYJSString("Array"))));
2163     CYSetProperty(context, cy, CYJSString("Array"), Array);
2164
2165     JSObjectRef Array_prototype(CYCastJSObject(context, CYGetProperty(context, Array, prototype_s)));
2166     CYSetProperty(context, cy, CYJSString("Array_prototype"), Array_prototype);
2167
2168     JSObjectRef Boolean(CYCastJSObject(context, CYGetProperty(context, global, CYJSString("Boolean"))));
2169     CYSetProperty(context, cy, CYJSString("Boolean"), Boolean);
2170
2171     JSObjectRef Boolean_prototype(CYCastJSObject(context, CYGetProperty(context, Boolean, prototype_s)));
2172     CYSetProperty(context, cy, CYJSString("Boolean_prototype"), Boolean_prototype);
2173
2174     JSObjectRef Error(CYCastJSObject(context, CYGetProperty(context, global, CYJSString("Error"))));
2175     CYSetProperty(context, cy, CYJSString("Error"), Error);
2176
2177     JSObjectRef Function(CYCastJSObject(context, CYGetProperty(context, global, CYJSString("Function"))));
2178     CYSetProperty(context, cy, CYJSString("Function"), Function);
2179
2180     JSObjectRef Function_prototype(CYCastJSObject(context, CYGetProperty(context, Function, prototype_s)));
2181     CYSetProperty(context, cy, CYJSString("Function_prototype"), Function_prototype);
2182
2183     JSObjectRef JSON(CYCastJSObject(context, CYGetProperty(context, global, CYJSString("JSON"))));
2184     CYSetProperty(context, cy, CYJSString("JSON"), JSON);
2185
2186     JSObjectRef Number(CYCastJSObject(context, CYGetProperty(context, global, CYJSString("Number"))));
2187     CYSetProperty(context, cy, CYJSString("Number"), Number);
2188
2189     JSObjectRef Number_prototype(CYCastJSObject(context, CYGetProperty(context, Number, prototype_s)));
2190     CYSetProperty(context, cy, CYJSString("Number_prototype"), Number_prototype);
2191
2192     JSObjectRef Object(CYCastJSObject(context, CYGetProperty(context, global, CYJSString("Object"))));
2193     CYSetProperty(context, cy, CYJSString("Object"), Object);
2194
2195     JSObjectRef Object_prototype(CYCastJSObject(context, CYGetProperty(context, Object, prototype_s)));
2196     CYSetProperty(context, cy, CYJSString("Object_prototype"), Object_prototype);
2197
2198     JSObjectRef String(CYCastJSObject(context, CYGetProperty(context, global, CYJSString("String"))));
2199     CYSetProperty(context, cy, CYJSString("String"), String);
2200
2201     JSObjectRef String_prototype(CYCastJSObject(context, CYGetProperty(context, String, prototype_s)));
2202     CYSetProperty(context, cy, CYJSString("String_prototype"), String_prototype);
2203
2204     JSObjectRef SyntaxError(CYCastJSObject(context, CYGetProperty(context, global, CYJSString("SyntaxError"))));
2205     CYSetProperty(context, cy, CYJSString("SyntaxError"), SyntaxError);
2206 /* }}} */
2207
2208     CYSetProperty(context, Array_prototype, toCYON_s, &Array_callAsFunction_toCYON, kJSPropertyAttributeDontEnum);
2209     CYSetProperty(context, String_prototype, toCYON_s, &String_callAsFunction_toCYON, kJSPropertyAttributeDontEnum);
2210
2211     JSObjectRef cycript(JSObjectMake(context, NULL, NULL));
2212     CYSetProperty(context, global, CYJSString("Cycript"), cycript);
2213     CYSetProperty(context, cycript, CYJSString("compile"), &Cycript_compile_callAsFunction);
2214     CYSetProperty(context, cycript, CYJSString("gc"), &Cycript_gc_callAsFunction);
2215
2216     JSObjectRef CArray(JSObjectMakeConstructor(context, CArray::Class_, &CArray_new));
2217     CYSetPrototype(context, CYCastJSObject(context, CYGetProperty(context, CArray, prototype_s)), Array_prototype);
2218     CYSetProperty(context, cycript, CYJSString("CArray"), CArray);
2219
2220     JSObjectRef CString(JSObjectMakeConstructor(context, CString::Class_, &CString_new));
2221     CYSetPrototype(context, CYCastJSObject(context, CYGetProperty(context, CString, prototype_s)), String_prototype);
2222     CYSetProperty(context, cycript, CYJSString("CString"), CString);
2223
2224     JSObjectRef Functor(JSObjectMakeConstructor(context, Functor_, &Functor_new));
2225     CYSetPrototype(context, CYCastJSObject(context, CYGetProperty(context, Functor, prototype_s)), Function_prototype);
2226     CYSetProperty(context, cycript, CYJSString("Functor"), Functor);
2227
2228     CYSetProperty(context, cycript, CYJSString("Pointer"), JSObjectMakeConstructor(context, Pointer::Class_, &Pointer_new));
2229     CYSetProperty(context, cycript, CYJSString("Type"), JSObjectMakeConstructor(context, Type_privateData::Class_, &Type_new));
2230
2231     JSObjectRef modules(JSObjectMake(context, NULL, NULL));
2232     CYSetProperty(context, cy, CYJSString("modules"), modules);
2233
2234     JSObjectRef all(JSObjectMake(context, All_, NULL));
2235     CYSetProperty(context, cycript, CYJSString("all"), all);
2236
2237     JSObjectRef cache(JSObjectMake(context, NULL, NULL));
2238     CYSetProperty(context, cy, CYJSString("cache"), cache);
2239     CYSetPrototype(context, cache, all);
2240
2241     JSObjectRef alls(_jsccall(JSObjectCallAsConstructor, context, Array, 0, NULL));
2242     CYSetProperty(context, cycript, CYJSString("alls"), alls);
2243
2244     if (true) {
2245         JSObjectRef last(NULL), curr(global);
2246
2247         goto next; for (JSValueRef next;;) {
2248             if (JSValueIsNull(context, next))
2249                 break;
2250             last = curr;
2251             curr = CYCastJSObject(context, next);
2252           next:
2253             next = JSObjectGetPrototype(context, curr);
2254         }
2255
2256         CYSetPrototype(context, last, cache);
2257     }
2258
2259     JSObjectRef System(JSObjectMake(context, NULL, NULL));
2260     CYSetProperty(context, cy, CYJSString("System"), System);
2261
2262     CYSetProperty(context, global, CYJSString("require"), &require_callAsFunction, kJSPropertyAttributeDontEnum);
2263
2264     CYSetProperty(context, global, CYJSString("system"), System);
2265     CYSetProperty(context, System, CYJSString("args"), CYJSNull(context));
2266     CYSetProperty(context, System, CYJSString("print"), &System_print);
2267
2268     CYSetProperty(context, global, CYJSString("global"), global);
2269
2270 #ifdef __APPLE__
2271     if (&JSWeakObjectMapCreate != NULL) {
2272         JSWeakObjectMapRef weak(JSWeakObjectMapCreate(context, NULL, &CYDestroyWeak));
2273         CYSetProperty(context, cy, weak_s, CYCastJSValue(context, reinterpret_cast<uintptr_t>(weak)));
2274     }
2275 #endif
2276
2277     CYSetProperty(context, String_prototype, cyt_s, CYMakeType(context, sig::String()), kJSPropertyAttributeDontEnum);
2278
2279     CYSetProperty(context, cache, CYJSString("dlerror"), CYMakeFunctor(context, "dlerror", "*"), kJSPropertyAttributeDontEnum);
2280     CYSetProperty(context, cache, CYJSString("RTLD_DEFAULT"), CYCastJSValue(context, reinterpret_cast<intptr_t>(RTLD_DEFAULT)), kJSPropertyAttributeDontEnum);
2281     CYSetProperty(context, cache, CYJSString("dlsym"), CYMakeFunctor(context, "dlsym", "^v^v*"), kJSPropertyAttributeDontEnum);
2282
2283     CYSetProperty(context, cache, CYJSString("NULL"), CYJSNull(context), kJSPropertyAttributeDontEnum);
2284
2285     CYSetProperty(context, cache, CYJSString("bool"), CYMakeType(context, sig::Primitive<bool>()), kJSPropertyAttributeDontEnum);
2286     CYSetProperty(context, cache, CYJSString("char"), CYMakeType(context, sig::Primitive<char>()), kJSPropertyAttributeDontEnum);
2287     CYSetProperty(context, cache, CYJSString("schar"), CYMakeType(context, sig::Primitive<signed char>()), kJSPropertyAttributeDontEnum);
2288     CYSetProperty(context, cache, CYJSString("uchar"), CYMakeType(context, sig::Primitive<unsigned char>()), kJSPropertyAttributeDontEnum);
2289
2290     CYSetProperty(context, cache, CYJSString("short"), CYMakeType(context, sig::Primitive<short>()), kJSPropertyAttributeDontEnum);
2291     CYSetProperty(context, cache, CYJSString("int"), CYMakeType(context, sig::Primitive<int>()), kJSPropertyAttributeDontEnum);
2292     CYSetProperty(context, cache, CYJSString("long"), CYMakeType(context, sig::Primitive<long>()), kJSPropertyAttributeDontEnum);
2293     CYSetProperty(context, cache, CYJSString("longlong"), CYMakeType(context, sig::Primitive<long long>()), kJSPropertyAttributeDontEnum);
2294
2295     CYSetProperty(context, cache, CYJSString("ushort"), CYMakeType(context, sig::Primitive<unsigned short>()), kJSPropertyAttributeDontEnum);
2296     CYSetProperty(context, cache, CYJSString("uint"), CYMakeType(context, sig::Primitive<unsigned int>()), kJSPropertyAttributeDontEnum);
2297     CYSetProperty(context, cache, CYJSString("ulong"), CYMakeType(context, sig::Primitive<unsigned long>()), kJSPropertyAttributeDontEnum);
2298     CYSetProperty(context, cache, CYJSString("ulonglong"), CYMakeType(context, sig::Primitive<unsigned long long>()), kJSPropertyAttributeDontEnum);
2299
2300     CYSetProperty(context, cache, CYJSString("float"), CYMakeType(context, sig::Primitive<float>()), kJSPropertyAttributeDontEnum);
2301     CYSetProperty(context, cache, CYJSString("double"), CYMakeType(context, sig::Primitive<double>()), kJSPropertyAttributeDontEnum);
2302
2303     for (CYHook *hook : GetHooks())
2304         if (hook->SetupContext != NULL)
2305             (*hook->SetupContext)(context);
2306
2307     CYArrayPush(context, alls, cycript);
2308
2309     CYRunScript(context, "/libcycript.cy");
2310 }
2311
2312 static JSGlobalContextRef context_;
2313
2314 _visible JSGlobalContextRef CYGetJSContext() {
2315     CYInitializeDynamic();
2316
2317     if (context_ == NULL) {
2318         context_ = JSGlobalContextCreate(Global_);
2319         CYSetupContext(context_);
2320     }
2321
2322     return context_;
2323 }
2324
2325 _visible void CYDestroyContext() {
2326     if (context_ == NULL)
2327         return;
2328     JSGlobalContextRelease(context_);
2329     context_ = NULL;
2330 }