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