1 /* Cycript - The Truly Universal Scripting Language
2 * Copyright (C) 2009-2016 Jay Freeman (saurik)
5 /* GNU Affero General Public License, Version 3 {{{ */
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.
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.
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/>.
22 #include "cycript.hpp"
41 #include "sig/parse.hpp"
42 #include "sig/ffi_type.hpp"
47 #include "Execute.hpp"
48 #include "Internal.hpp"
49 #include "JavaScript.hpp"
50 #include "Pooling.hpp"
53 const char *sqlite3_column_string(sqlite3_stmt
*stmt
, int n
) {
54 return reinterpret_cast<const char *>(sqlite3_column_text(stmt
, n
));
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
);
63 static std::vector
<CYHook
*> &GetHooks() {
64 static std::vector
<CYHook
*> hooks
;
68 CYRegisterHook::CYRegisterHook(CYHook
*hook
) {
69 GetHooks().push_back(hook
);
72 /* JavaScript Properties {{{ */
73 bool CYHasProperty(JSContextRef context
, JSObjectRef object
, JSStringRef name
) {
74 return JSObjectHasProperty(context
, object
, name
);
77 JSValueRef
CYGetProperty(JSContextRef context
, JSObjectRef object
, size_t index
) {
78 return _jsccall(JSObjectGetPropertyAtIndex
, context
, object
, index
);
81 JSValueRef
CYGetProperty(JSContextRef context
, JSObjectRef object
, JSStringRef name
) {
82 return _jsccall(JSObjectGetProperty
, context
, object
, name
);
85 void CYSetProperty(JSContextRef context
, JSObjectRef object
, size_t index
, JSValueRef value
) {
86 _jsccall(JSObjectSetPropertyAtIndex
, context
, object
, index
, value
);
89 void CYSetProperty(JSContextRef context
, JSObjectRef object
, JSStringRef name
, JSValueRef value
, JSPropertyAttributes attributes
) {
90 _jsccall(JSObjectSetProperty
, context
, object
, name
, value
, attributes
);
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
);
97 JSObjectRef
CYGetPrototype(JSContextRef context
, JSObjectRef object
) {
98 return CYCastJSObject(context
, JSObjectGetPrototype(context
, object
));
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
));
107 /* JavaScript Strings {{{ */
108 JSStringRef
CYCopyJSString(const char *value
) {
109 return value
== NULL
? NULL
: JSStringCreateWithUTF8CString(value
);
112 JSStringRef
CYCopyJSString(JSStringRef value
) {
113 return value
== NULL
? NULL
: JSStringRetain(value
);
116 JSStringRef
CYCopyJSString(CYUTF8String value
) {
117 if (memchr(value
.data
, '\0', value
.size
) != NULL
) {
119 return CYCopyJSString(CYPoolUTF16String(pool
, value
));
120 } else if (value
.data
[value
.size
] != '\0') {
122 return CYCopyJSString(pool
.strmemdup(value
.data
, value
.size
));
124 return CYCopyJSString(value
.data
);
128 JSStringRef
CYCopyJSString(const std::string
&value
) {
129 return CYCopyJSString(CYUTF8String(value
.c_str(), value
.size()));
132 JSStringRef
CYCopyJSString(CYUTF16String value
) {
133 return JSStringCreateWithCharacters(value
.data
, value
.size
);
136 JSStringRef
CYCopyJSString(JSContextRef context
, JSValueRef value
) {
137 if (JSValueIsNull(context
, value
))
139 return _jsccall(JSValueToStringCopy
, context
, value
);
142 CYUTF16String
CYCastUTF16String(JSStringRef value
) {
143 return CYUTF16String(JSStringGetCharactersPtr(value
), JSStringGetLength(value
));
146 const char *CYPoolCString(CYPool
&pool
, CYUTF8String utf8
) {
147 return pool
.strndup(utf8
.data
, utf8
.size
);
150 CYUTF8String
CYPoolUTF8String(CYPool
&pool
, JSContextRef context
, JSStringRef value
) {
151 return CYPoolUTF8String(pool
, CYCastUTF16String(value
));
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
);
160 const char *CYPoolCString(CYPool
&pool
, JSContextRef context
, JSValueRef value
) {
161 return JSValueIsNull(context
, value
) ? NULL
: CYPoolCString(pool
, context
, CYJSString(context
, value
));
164 /* Index Offsets {{{ */
165 size_t CYGetIndex(CYPool
&pool
, JSContextRef context
, JSStringRef value
) {
166 return CYGetIndex(CYPoolUTF8String(pool
, context
, value
));
170 static JSObjectRef (*JSObjectMakeArray$
)(JSContextRef
, size_t, const JSValueRef
[], JSValueRef
*);
172 JSObjectRef
CYObjectMakeArray(JSContextRef context
, size_t length
, const JSValueRef values
[]) {
173 if (JSObjectMakeArray$
!= NULL
)
174 return _jsccall(*JSObjectMakeArray$
, context
, length
, values
);
176 JSObjectRef
Array(CYGetCachedObject(context
, CYJSString("Array")));
177 JSValueRef
value(CYCallAsFunction(context
, Array
, NULL
, length
, values
));
178 return CYCastJSObject(context
, value
);
182 static JSClassRef All_
;
184 static JSClassRef Global_
;
187 JSStringRef constructor_s
;
191 JSStringRef length_s
;
192 JSStringRef message_s
;
195 JSStringRef prototype_s
;
197 JSStringRef splice_s
;
198 JSStringRef toCYON_s
;
199 JSStringRef toJSON_s
;
200 JSStringRef toPointer_s
;
201 JSStringRef toString_s
;
204 static sqlite3
*database_
;
206 static JSStringRef Result_
;
208 void CYFinalize(JSObjectRef object
) {
209 CYData
*internal(reinterpret_cast<CYData
*>(JSObjectGetPrivate(object
)));
210 _assert(internal
->count_
!= _not(unsigned));
211 if (--internal
->count_
== 0)
215 sig::Type
*Structor_(CYPool
&pool
, sig::Aggregate
*aggregate
) {
223 JSGlobalContextRef context_
;
225 Context(JSGlobalContextRef context
) :
232 CYValue
<CArray
, void *>
235 Type_privateData
*type_
;
238 CArray(void *value
, size_t length
, const sig::Type
&type
, ffi_type
*ffi
, JSContextRef context
, JSObjectRef owner
) :
240 owner_(context
, owner
),
241 type_(new(*pool_
) Type_privateData(type
, ffi
)),
245 size_t size(ffi
->size
* length
);
246 void *copy(pool_
->malloc
<void>(size
, ffi
->alignment
));
247 memcpy(copy
, value_
, size
);
254 CYValue
<CString
, char *>
258 CString(char *value
, JSContextRef context
, JSObjectRef owner
) :
260 owner_(context
, owner
)
263 value_
= pool_
->strdup(value_
);
268 CYValue
<Pointer
, void *>
271 Type_privateData
*type_
;
273 Pointer(void *value
, const sig::Type
&type
, JSContextRef context
, JSObjectRef owner
) :
275 owner_(context
, owner
),
276 type_(new(*pool_
) Type_privateData(type
))
280 Pointer(void *value
, const char *encoding
, JSContextRef context
, JSObjectRef owner
) :
282 owner_(context
, owner
),
283 type_(new(*pool_
) Type_privateData(encoding
))
288 struct Struct_privateData
:
289 CYValue
<Struct_privateData
, void *>
292 Type_privateData
*type_
;
294 Struct_privateData(void *value
, const sig::Type
&type
, ffi_type
*ffi
, JSContextRef context
, JSObjectRef owner
) :
296 owner_(context
, owner
),
297 type_(new(*pool_
) Type_privateData(type
, ffi
))
300 size_t size(ffi
->size
);
301 void *copy(pool_
->malloc
<void>(size
, ffi
->alignment
));
302 memcpy(copy
, value_
, size
);
308 static void *CYCastSymbol(const char *name
) {
309 for (CYHook
*hook
: GetHooks())
310 if (hook
->CastSymbol
!= NULL
)
311 if (void *value
= (*hook
->CastSymbol
)(name
))
313 return dlsym(RTLD_DEFAULT
, name
);
316 JSValueRef
CYCastJSValue(JSContextRef context
, bool value
) {
317 return JSValueMakeBoolean(context
, value
);
320 JSValueRef
CYCastJSValue(JSContextRef context
, double value
) {
321 return JSValueMakeNumber(context
, value
);
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)); \
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)
339 JSValueRef
CYJSUndefined(JSContextRef context
) {
340 return JSValueMakeUndefined(context
);
343 double CYCastDouble(JSContextRef context
, JSValueRef value
) {
344 return _jsccall(JSValueToNumber
, context
, value
);
347 bool CYCastBool(JSContextRef context
, JSValueRef value
) {
348 return JSValueToBoolean(context
, value
);
351 JSValueRef
CYJSNull(JSContextRef context
) {
352 return JSValueMakeNull(context
);
355 JSValueRef
CYCastJSValue(JSContextRef context
, JSStringRef value
) {
356 return value
== NULL
? CYJSNull(context
) : JSValueMakeString(context
, value
);
359 JSValueRef
CYCastJSValue(JSContextRef context
, const char *value
) {
360 return CYCastJSValue(context
, CYJSString(value
));
363 JSObjectRef
CYCastJSObject(JSContextRef context
, JSValueRef value
) {
364 return _jsccall(JSValueToObject
, context
, value
);
367 JSValueRef
CYCallAsFunction(JSContextRef context
, JSObjectRef function
, JSObjectRef _this
, size_t count
, const JSValueRef arguments
[]) {
368 return _jsccall(JSObjectCallAsFunction
, context
, function
, _this
, count
, arguments
);
371 bool CYIsCallable(JSContextRef context
, JSValueRef value
) {
372 return value
!= NULL
&& JSValueIsObject(context
, value
) && JSObjectIsFunction(context
, (JSObjectRef
) value
);
375 bool CYIsEqual(JSContextRef context
, JSValueRef lhs
, JSValueRef rhs
) {
376 return _jsccall(JSValueIsEqual
, context
, lhs
, rhs
);
379 bool CYIsStrictEqual(JSContextRef context
, JSValueRef lhs
, JSValueRef rhs
) {
380 return JSValueIsStrictEqual(context
, lhs
, rhs
);
383 size_t CYArrayLength(JSContextRef context
, JSObjectRef array
) {
384 return CYCastDouble(context
, CYGetProperty(context
, array
, length_s
));
387 JSValueRef
CYArrayGet(JSContextRef context
, JSObjectRef array
, size_t index
) {
388 return _jsccall(JSObjectGetPropertyAtIndex
, context
, array
, index
);
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
);
396 void CYArrayPush(JSContextRef context
, JSObjectRef array
, JSValueRef value
) {
397 return CYArrayPush(context
, array
, 1, &value
);
400 static JSValueRef
System_print(JSContextRef context
, JSObjectRef object
, JSObjectRef _this
, size_t count
, const JSValueRef arguments
[], JSValueRef
*exception
) { CYTry
{
407 CYUTF8String
string(CYPoolUTF8String(pool
, context
, CYJSString(context
, arguments
[0])));
408 fwrite(string
.data
, string
.size
, 1, file
);
412 return CYJSUndefined(context
);
415 static void (*JSSynchronousGarbageCollectForDebugging$
)(JSContextRef
);
417 _visible
void CYGarbageCollect(JSContextRef context
) {
418 (JSSynchronousGarbageCollectForDebugging$
?: &JSGarbageCollect
)(context
);
421 static JSValueRef
Cycript_compile_callAsFunction(JSContextRef context
, JSObjectRef object
, JSObjectRef _this
, size_t count
, const JSValueRef arguments
[], JSValueRef
*exception
) { CYTry
{
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") }
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
);
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
:
440 return CYCastBool(context
, value
) ? "true" : "false";
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());
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());
458 return CYPoolCCYON(pool
, context
, (JSObjectRef
) value
, objects
);
460 throw CYJSError(context
, "JSValueGetType() == 0x%x", type
);
464 const char *CYPoolCCYON(CYPool
&pool
, JSContextRef context
, JSValueRef value
, std::set
<void *> &objects
) {
465 return _jsccall(CYPoolCCYON
, pool
, context
, value
, objects
);
468 const char *CYPoolCCYON(CYPool
&pool
, JSContextRef context
, JSValueRef value
, std::set
<void *> *objects
) {
470 return CYPoolCCYON(pool
, context
, value
, *objects
);
472 std::set
<void *> objects
;
473 return CYPoolCCYON(pool
, context
, value
, objects
);
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
);
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
);
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
);
503 _assert(objects
.insert(object
).second
);
505 std::ostringstream str
;
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
));
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
));
522 // XXX: this is, sadly, going to leak
523 JSPropertyNameArrayRef
names(JSObjectCopyPropertyNames(context
, object
));
527 for (size_t index(0), count(JSPropertyNameArrayGetCount(names
)); index
!= count
; ++index
) {
533 JSStringRef
name(JSPropertyNameArrayGetNameAtIndex(names
, index
));
534 CYUTF8String
string(CYPoolUTF8String(pool
, context
, name
));
539 CYStringify(str
, string
.data
, string
.size
);
544 JSValueRef
value(CYGetProperty(context
, object
, name
));
545 str
<< CYPoolCCYON(pool
, context
, value
, objects
);
546 } catch (const CYException
&error
) {
551 JSPropertyNameArrayRelease(names
);
555 std::string
string(str
.str());
556 return pool
.strmemdup(string
.c_str(), string
.size());
559 std::set
<void *> *CYCastObjects(JSContextRef context
, JSObjectRef _this
, size_t count
, const JSValueRef arguments
[]) {
562 return CYCastPointer
<std::set
<void *> *>(context
, arguments
[0]);
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
;
573 std::ostringstream str
;
577 JSValueRef
length(CYGetProperty(context
, _this
, length_s
));
580 for (size_t index(0), count(CYCastDouble(context
, length
)); index
!= count
; ++index
) {
587 JSValueRef
value(CYGetProperty(context
, _this
, index
));
588 if (!JSValueIsUndefined(context
, value
))
589 str
<< CYPoolCCYON(pool
, context
, value
, *objects
);
594 } catch (const CYException
&error
) {
601 std::string
value(str
.str());
602 return CYCastJSValue(context
, CYJSString(CYUTF8String(value
.c_str(), value
.size())));
605 static JSValueRef
String_callAsFunction_toCYON(JSContextRef context
, JSObjectRef object
, JSObjectRef _this
, size_t count
, const JSValueRef arguments
[], JSValueRef
*exception
) { CYTry
{
607 std::ostringstream str
;
609 CYUTF8String
string(CYPoolUTF8String(pool
, context
, CYJSString(context
, _this
)));
610 CYStringify(str
, string
.data
, string
.size
);
612 std::string
value(str
.str());
613 return CYCastJSValue(context
, CYJSString(CYUTF8String(value
.c_str(), value
.size())));
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
);
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
));
624 static JSObjectRef
CYMakeFunctor(JSContextRef context
, const char *symbol
, const char *encoding
) {
625 void (*function
)()(reinterpret_cast<void (*)()>(CYCastSymbol(symbol
)));
626 if (function
== NULL
)
629 cy::Functor
*internal(new cy::Functor(function
, encoding
));
631 return JSObjectMake(context
, Functor_
, internal
);
634 bool CYGetOffset(CYPool
&pool
, JSContextRef context
, JSStringRef value
, ssize_t
&index
) {
635 return CYGetOffset(CYPoolCString(pool
, context
, value
), index
);
638 void *CYCastPointer_(JSContextRef context
, JSValueRef value
, bool *guess
) {
641 else switch (JSValueGetType(context
, value
)) {
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_
;
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
);
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
)));
664 throw CYJSError(context
, "cannot convert value to pointer");
674 // XXX: this is somehow not quite a 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
);
681 #define CYPoolFFI_(Type_) \
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); \
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)
701 void Void::PoolFFI(CYPool
*pool
, JSContextRef context
, ffi_type
*ffi
, void *data
, JSValueRef value
) const {
705 void Unknown::PoolFFI(CYPool
*pool
, JSContextRef context
, ffi_type
*ffi
, void *data
, JSValueRef value
) const {
709 void String::PoolFFI(CYPool
*pool
, JSContextRef context
, ffi_type
*ffi
, void *data
, JSValueRef value
) const {
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
);
716 void Bits::PoolFFI(CYPool
*pool
, JSContextRef context
, ffi_type
*ffi
, void *data
, JSValueRef value
) const {
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
) {
726 rhs
= CYGetProperty(context
, object
, index
);
727 if (JSValueIsUndefined(context
, rhs
))
728 throw CYJSError(context
, "unable to extract array value");
731 type
.PoolFFI(pool
, context
, ffi
, base
, rhs
);
736 void Pointer::PoolFFI(CYPool
*pool
, JSContextRef context
, ffi_type
*ffi
, void *data
, JSValueRef value
) const {
738 *reinterpret_cast<void **>(data
) = CYCastPointer
<void *>(context
, value
, &guess
);
739 if (!guess
|| pool
== NULL
|| !JSValueIsObject(context
, value
))
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
;
752 void Array::PoolFFI(CYPool
*pool
, JSContextRef context
, ffi_type
*ffi
, void *data
, JSValueRef value
) const {
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
);
760 void Aggregate::PoolFFI(CYPool
*pool
, JSContextRef context
, ffi_type
*ffi
, void *data
, JSValueRef value
) const {
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
]);
771 if (aggregate
== NULL
)
774 rhs
= CYGetProperty(context
, aggregate
, index
);
775 if (JSValueIsUndefined(context
, rhs
)) {
776 if (element
->name
!= NULL
)
777 rhs
= CYGetProperty(context
, aggregate
, CYJSString(element
->name
));
780 if (JSValueIsUndefined(context
, rhs
)) undefined
:
781 throw CYJSError(context
, "unable to extract structure value");
785 element
->type
->PoolFFI(pool
, context
, field
, base
+ offset
, rhs
);
786 offset
+= field
->size
;
787 CYAlign(offset
, field
->alignment
);
791 void Function::PoolFFI(CYPool
*pool
, JSContextRef context
, ffi_type
*ffi
, void *data
, JSValueRef value
) const {
795 #define CYFromFFI_(Type_) \
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)); \
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)
816 JSValueRef
Void::FromFFI(JSContextRef context
, ffi_type
*ffi
, void *data
, bool initialize
, JSObjectRef owner
) const {
817 return CYJSUndefined(context
);
820 JSValueRef
Unknown::FromFFI(JSContextRef context
, ffi_type
*ffi
, void *data
, bool initialize
, JSObjectRef owner
) const {
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
);
830 JSValueRef
Bits::FromFFI(JSContextRef context
, ffi_type
*ffi
, void *data
, bool initialize
, JSObjectRef owner
) const {
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
);
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
);
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
);
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
);
854 void CYExecuteClosure(ffi_cif
*cif
, void *result
, void **arguments
, void *arg
) {
855 Closure_privateData
*internal(reinterpret_cast<Closure_privateData
*>(arg
));
857 JSContextRef
context(internal
->function_
);
859 size_t count(internal
->cif_
.nargs
);
860 JSValueRef values
[count
];
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
]);
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
);
870 static JSValueRef
FunctionAdapter_(JSContextRef context
, size_t count
, JSValueRef values
[], JSObjectRef function
) {
871 return CYCallAsFunction(context
, function
, NULL
, count
, values
);
874 #if defined(__APPLE__) && (defined(__arm__) || defined(__arm64__))
875 static void CYFreeFunctor(void *data
) {
876 ffi_closure_free(data
);
879 static void CYFreeFunctor(void *data
) {
880 _syscall(munmap(data
, sizeof(ffi_closure
)));
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
));
888 #if defined(__APPLE__) && (defined(__arm__) || defined(__arm64__))
890 ffi_closure
*writable(reinterpret_cast<ffi_closure
*>(ffi_closure_alloc(sizeof(ffi_closure
), &executable
)));
892 ffi_status
status(ffi_prep_closure_loc(writable
, &internal
->cif_
, &CYExecuteClosure
, internal
, executable
));
893 _assert(status
== FFI_OK
);
895 internal
->pool_
->atexit(&CYFreeFunctor
, writable
);
896 internal
->value_
= reinterpret_cast<void (*)()>(executable
);
898 ffi_closure
*closure((ffi_closure
*) _syscall(mmap(
899 NULL
, sizeof(ffi_closure
),
900 PROT_READ
| PROT_WRITE
, MAP_ANON
| MAP_PRIVATE
,
904 ffi_status
status(ffi_prep_closure(closure
, &internal
->cif_
, &CYExecuteClosure
, internal
));
905 _assert(status
== FFI_OK
);
907 _syscall(mprotect(closure
, sizeof(*closure
), PROT_READ
| PROT_EXEC
));
909 internal
->pool_
->atexit(&CYFreeFunctor
, closure
);
910 internal
->value_
= reinterpret_cast<void (*)()>(closure
);
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
);
924 JSValueRef
CYGetCachedValue(JSContextRef context
, JSStringRef name
) {
925 return CYGetProperty(context
, CYCastJSObject(context
, CYGetProperty(context
, CYGetGlobalObject(context
), cy_s
)), name
);
928 JSObjectRef
CYGetCachedObject(JSContextRef context
, JSStringRef name
) {
929 return CYCastJSObject(context
, CYGetCachedValue(context
, name
));
932 static JSObjectRef
CYMakeFunctor(JSContextRef context
, JSValueRef value
, bool variadic
, const sig::Signature
&signature
) {
933 JSObjectRef
Function(CYGetCachedObject(context
, CYJSString("Function")));
935 bool function(_jsccall(JSValueIsInstanceOfConstructor
, context
, value
, Function
));
937 JSObjectRef
function(CYCastJSObject(context
, value
));
938 return CYMakeFunctor(context
, function
, signature
);
940 void (*function
)()(CYCastPointer
<void (*)()>(context
, value
));
941 return CYMakeFunctor(context
, function
, variadic
, signature
);
945 static JSValueRef
CString_getProperty(JSContextRef context
, JSObjectRef object
, JSStringRef property
, JSValueRef
*exception
) { CYTry
{
947 CString
*internal(reinterpret_cast<CString
*>(JSObjectGetPrivate(object
)));
950 if (!CYGetOffset(pool
, context
, property
, offset
))
953 return CYCastJSValue(context
, CYJSString(CYUTF8String(&internal
->value_
[offset
], 1)));
956 static bool CString_setProperty(JSContextRef context
, JSObjectRef object
, JSStringRef property
, JSValueRef value
, JSValueRef
*exception
) { CYTry
{
958 CString
*internal(reinterpret_cast<CString
*>(JSObjectGetPrivate(object
)));
961 if (!CYGetOffset(pool
, context
, property
, offset
))
964 const char *data(CYPoolCString(pool
, context
, value
));
965 internal
->value_
[offset
] = *data
;
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_
));
975 const char *name(CYPoolCString(pool
, context
, property
));
976 size_t length(strlen(name
));
977 double number(CYCastDouble(name
, length
));
979 size_t count(type
->signature
.count
);
981 if (std::isnan(number
)) {
982 if (property
== NULL
)
985 sig::Element
*elements(type
->signature
.elements
);
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) {
997 index
= static_cast<ssize_t
>(number
);
998 if (index
!= number
|| index
< 0 || static_cast<size_t>(index
) >= count
)
1003 ffi_type
**elements(typical
->GetFFI()->elements
);
1006 for (ssize_t
local(0); local
!= index
; ++local
) {
1007 offset
+= elements
[local
]->size
;
1008 CYAlign(offset
, elements
[local
+ 1]->alignment
);
1011 base
= reinterpret_cast<uint8_t *>(internal
->value_
) + offset
;
1015 static void *Offset_(CYPool
&pool
, JSContextRef context
, JSStringRef property
, void *data
, ffi_type
*ffi
) {
1017 if (JSStringIsEqualToUTF8CString(property
, "$cyi"))
1019 else if (!CYGetOffset(pool
, context
, property
, offset
))
1021 return reinterpret_cast<uint8_t *>(data
) + ffi
->size
* offset
;
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
));
1029 return typical
->type_
->FromFFI(context
, ffi
, base
, false, owner
);
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
));
1038 typical
->type_
->PoolFFI(NULL
, context
, ffi
, base
, value
);
1042 static JSValueRef
CArray_getProperty(JSContextRef context
, JSObjectRef object
, JSStringRef property
, JSValueRef
*exception
) { CYTry
{
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
);
1052 static bool CArray_setProperty(JSContextRef context
, JSObjectRef object
, JSStringRef property
, JSValueRef value
, JSValueRef
*exception
) { CYTry
{
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
);
1059 static JSValueRef
Pointer_getProperty(JSContextRef context
, JSObjectRef object
, JSStringRef property
, JSValueRef
*exception
) { CYTry
{
1061 Pointer
*internal(reinterpret_cast<Pointer
*>(JSObjectGetPrivate(object
)));
1063 Type_privateData
*typical(internal
->type_
);
1065 if (sig::Function
*function
= dynamic_cast<sig::Function
*>(typical
->type_
)) {
1066 if (!JSStringIsEqualToUTF8CString(property
, "$cyi"))
1068 return CYMakeFunctor(context
, reinterpret_cast<void (*)()>(internal
->value_
), function
->variadic
, function
->signature
);
1071 JSObjectRef
owner(internal
->owner_
?: object
);
1072 return Offset_getProperty(pool
, context
, property
, internal
->value_
, typical
, owner
);
1075 static bool Pointer_setProperty(JSContextRef context
, JSObjectRef object
, JSStringRef property
, JSValueRef value
, JSValueRef
*exception
) { CYTry
{
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
);
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
);
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_
);
1093 static JSValueRef
Struct_getProperty(JSContextRef context
, JSObjectRef object
, JSStringRef property
, JSValueRef
*exception
) { CYTry
{
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_
));
1102 if (!Index_(pool
, context
, internal
, property
, index
, base
))
1105 JSObjectRef
owner(internal
->owner_
?: object
);
1107 return type
->signature
.elements
[index
].type
->FromFFI(context
, typical
->GetFFI()->elements
[index
], base
, false, owner
);
1110 static bool Struct_setProperty(JSContextRef context
, JSObjectRef object
, JSStringRef property
, JSValueRef value
, JSValueRef
*exception
) { CYTry
{
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_
));
1119 if (!Index_(pool
, context
, internal
, property
, index
, base
))
1122 type
->signature
.elements
[index
].type
->PoolFFI(NULL
, context
, typical
->GetFFI()->elements
[index
], base
, value
);
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_
));
1134 size_t count(type
->signature
.count
);
1135 sig::Element
*elements(type
->signature
.elements
);
1139 for (size_t index(0); index
!= count
; ++index
) {
1141 name
= elements
[index
].name
;
1144 sprintf(number
, "%zu", index
);
1148 JSPropertyNameAccumulatorAddName(names
, CYJSString(name
));
1152 static sig::Void Void_
;
1153 static sig::Pointer
PointerToVoid_(Void_
);
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_
;
1165 void CYCallFunction(CYPool
&pool
, JSContextRef context
, ffi_cif
*cif
, void (*function
)(), void *value
, void **values
) {
1166 ffi_call(cif
, function
, value
, values
);
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);
1174 throw CYJSError(context
, "insufficient number of arguments to ffi function");
1177 sig::Element
*elements(signature
.elements
);
1181 throw CYJSError(context
, "exorbitant number of arguments to ffi function");
1183 elements
= new (pool
) sig::Element
[have
+ 1];
1184 memcpy(elements
, signature
.elements
, sizeof(sig::Element
) * (need
+ 1));
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
]);
1193 sig::Signature extended
;
1194 extended
.elements
= elements
;
1195 extended
.count
= have
+ 1;
1196 sig::sig_ffi_cif(pool
, signature
.count
, extended
, &corrected
);
1201 memcpy(values
, setup
, sizeof(void *) * setups
);
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
]);
1210 uint8_t value
[cif
->rtype
->size
];
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
;
1218 call(pool
, context
, cif
, function
, value
, values
);
1219 return signature
.elements
[0].type
->FromFFI(context
, cif
->rtype
, value
, initialize
);
1222 static JSValueRef
Functor_callAsFunction(JSContextRef context
, JSObjectRef object
, JSObjectRef _this
, size_t count
, const JSValueRef arguments
[], JSValueRef
*exception
) { CYTry
{
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_
);
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
);
1236 JSObjectRef
CYMakeType(JSContextRef context
, const sig::Type
&type
) {
1237 return Type_privateData::Make(context
, type
);
1240 extern "C" bool CYBridgeHash(CYPool
&pool
, CYUTF8String name
, const char *&code
, unsigned &flags
) {
1241 sqlite3_stmt
*statement
;
1243 _sqlcall(sqlite3_prepare(database_
,
1245 "\"cache\".\"code\", "
1246 "\"cache\".\"flags\" "
1249 " \"cache\".\"system\" & " CY_SYSTEM
" == " CY_SYSTEM
" and"
1250 " \"cache\".\"name\" = ?"
1252 , -1, &statement
, NULL
));
1254 _sqlcall(sqlite3_bind_text(statement
, 1, name
.data
, name
.size
, SQLITE_STATIC
));
1257 if (_sqlcall(sqlite3_step(statement
)) == SQLITE_DONE
)
1261 code
= sqlite3_column_pooled(pool
, statement
, 0);
1262 flags
= sqlite3_column_int(statement
, 1);
1265 _sqlcall(sqlite3_finalize(statement
));
1269 static bool All_hasProperty(JSContextRef context
, JSObjectRef object
, JSStringRef property
) {
1270 if (JSStringIsEqualToUTF8CString(property
, "errno"))
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"))));
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
))
1285 if (CYBridgeHash(pool
, CYPoolUTF8String(pool
, context
, property
), code
, flags
))
1291 static JSValueRef
All_getProperty(JSContextRef context
, JSObjectRef object
, JSStringRef property
, JSValueRef
*exception
) { CYTry
{
1292 if (JSStringIsEqualToUTF8CString(property
, "errno"))
1293 return CYCastJSValue(context
, errno
);
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"))));
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
))
1308 if (CYBridgeHash(pool
, CYPoolUTF8String(pool
, context
, property
), code
, flags
)) {
1309 CYUTF8String parsed
;
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
));
1317 JSValueRef
result(_jsccall(JSEvaluateScript
, context
, CYJSString(parsed
), NULL
, NULL
, 0));
1320 JSObjectRef
cache(CYGetCachedObject(context
, CYJSString("cache")));
1321 CYSetProperty(context
, cache
, property
, result
);
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);
1333 CYUTF8String
prefix(CYPoolUTF8String(pool
, context
, CYJSString(context
, arguments
[0])));
1335 JSObjectRef
array(NULL
);
1338 CYArrayBuilder
<1024> values(context
, array
);
1340 sqlite3_stmt
*statement
;
1342 if (prefix
.size
== 0)
1343 _sqlcall(sqlite3_prepare(database_
,
1345 "\"cache\".\"name\" "
1348 " \"cache\".\"system\" & " CY_SYSTEM
" == " CY_SYSTEM
1349 , -1, &statement
, NULL
));
1351 _sqlcall(sqlite3_prepare(database_
,
1353 "\"cache\".\"name\" "
1356 " \"cache\".\"name\" >= ? and \"cache\".\"name\" < ? and "
1357 " \"cache\".\"system\" & " CY_SYSTEM
" == " CY_SYSTEM
1358 , -1, &statement
, NULL
));
1360 _sqlcall(sqlite3_bind_text(statement
, 1, prefix
.data
, prefix
.size
, SQLITE_STATIC
));
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
));
1367 while (_sqlcall(sqlite3_step(statement
)) != SQLITE_DONE
)
1368 values(CYCastJSValue(context
, CYJSString(sqlite3_column_string(statement
, 0))));
1370 _sqlcall(sqlite3_finalize(statement
));
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"))));
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
);
1390 static JSObjectRef
CArray_new(JSContextRef context
, JSObjectRef object
, size_t count
, const JSValueRef arguments
[], JSValueRef
*exception
) { CYTry
{
1394 static JSObjectRef
CString_new(JSContextRef context
, JSObjectRef object
, size_t count
, const JSValueRef arguments
[], JSValueRef
*exception
) { CYTry
{
1398 static JSObjectRef
Pointer_new(JSContextRef context
, JSObjectRef object
, size_t count
, const JSValueRef arguments
[], JSValueRef
*exception
) { CYTry
{
1402 static JSObjectRef
Type_new(JSContextRef context
, JSObjectRef object
, size_t count
, const JSValueRef arguments
[], JSValueRef
*exception
) { CYTry
{
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
));
1415 JSObjectRef
names(CYCastJSObject(context
, arguments
[1]));
1417 sig::Aggregate
type(false);
1418 type
.signature
.elements
= new(pool
) sig::Element
[count
];
1419 type
.signature
.count
= count
;
1421 for (size_t i(0); i
!= count
; ++i
) {
1422 sig::Element
&element(type
.signature
.elements
[i
]);
1423 element
.offset
= _not(size_t);
1425 JSValueRef
name(CYArrayGet(context
, names
, i
));
1426 if (JSValueIsUndefined(context
, name
))
1427 element
.name
= NULL
;
1429 element
.name
= CYPoolCString(pool
, context
, name
);
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_
;
1437 return CYMakeType(context
, type
);
1439 throw CYJSError(context
, "incorrect number of arguments to Type constructor");
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
)));
1448 type
.signature
.elements
= new(pool
) sig::Element
[1 + count
];
1449 type
.signature
.count
= 1 + count
;
1451 type
.signature
.elements
[0].name
= NULL
;
1452 type
.signature
.elements
[0].type
= internal
->type_
;
1453 type
.signature
.elements
[0].offset
= _not(size_t);
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);
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
)));
1464 element
.type
= internal
->type_
;
1467 return CYMakeType(context
, type
);
1470 static JSValueRef
Type_callAsFunction_arrayOf(JSContextRef context
, JSObjectRef object
, JSObjectRef _this
, size_t count
, const JSValueRef arguments
[], JSValueRef
*exception
) { CYTry
{
1472 throw CYJSError(context
, "incorrect number of arguments to Type.arrayOf");
1473 Type_privateData
*internal(reinterpret_cast<Type_privateData
*>(JSObjectGetPrivate(_this
)));
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");
1480 sig::Array
type(*internal
->type_
, index
);
1481 return CYMakeType(context
, type
);
1484 static JSValueRef
Type_callAsFunction_blockWith(JSContextRef context
, JSObjectRef object
, JSObjectRef _this
, size_t count
, const JSValueRef arguments
[], JSValueRef
*exception
) {
1485 #ifdef CY_OBJECTIVEC
1487 return Type_callAsFunction_$
With(context
, object
, _this
, count
, arguments
, type
, exception
);
1493 static JSValueRef
Type_callAsFunction_constant(JSContextRef context
, JSObjectRef object
, JSObjectRef _this
, size_t count
, const JSValueRef arguments
[], JSValueRef
*exception
) { CYTry
{
1495 throw CYJSError(context
, "incorrect number of arguments to Type.constant");
1496 Type_privateData
*internal(reinterpret_cast<Type_privateData
*>(JSObjectGetPrivate(_this
)));
1499 sig::Type
*type(internal
->type_
->Copy(pool
));
1500 type
->flags
|= JOC_TYPE_CONST
;
1501 return CYMakeType(context
, *type
);
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
);
1510 static JSValueRef
Type_callAsFunction_pointerTo(JSContextRef context
, JSObjectRef object
, JSObjectRef _this
, size_t count
, const JSValueRef arguments
[], JSValueRef
*exception
) { CYTry
{
1512 throw CYJSError(context
, "incorrect number of arguments to Type.pointerTo");
1513 Type_privateData
*internal(reinterpret_cast<Type_privateData
*>(JSObjectGetPrivate(_this
)));
1515 if (dynamic_cast<sig::Primitive
<char> *>(internal
->type_
) != NULL
)
1516 return CYMakeType(context
, sig::String());
1518 return CYMakeType(context
, sig::Pointer(*internal
->type_
));
1521 static JSValueRef
Type_callAsFunction_withName(JSContextRef context
, JSObjectRef object
, JSObjectRef _this
, size_t count
, const JSValueRef arguments
[], JSValueRef
*exception
) { CYTry
{
1523 throw CYJSError(context
, "incorrect number of arguments to Type.withName");
1524 Type_privateData
*internal(reinterpret_cast<Type_privateData
*>(JSObjectGetPrivate(_this
)));
1527 return CYMakeType(context
, *internal
->type_
->Copy(pool
, CYPoolCString(pool
, context
, arguments
[0])));
1530 static JSValueRef
Type_callAsFunction(JSContextRef context
, JSObjectRef object
, JSObjectRef _this
, size_t count
, const JSValueRef arguments
[], JSValueRef
*exception
) { CYTry
{
1532 throw CYJSError(context
, "incorrect number of arguments to type cast function");
1533 Type_privateData
*internal(reinterpret_cast<Type_privateData
*>(JSObjectGetPrivate(object
)));
1535 if (sig::Function
*function
= dynamic_cast<sig::Function
*>(internal
->type_
))
1536 return CYMakeFunctor(context
, arguments
[0], function
->variadic
, function
->signature
);
1540 sig::Type
*type(internal
->type_
);
1541 ffi_type
*ffi(internal
->GetFFI());
1542 void *data(pool
.malloc
<void>(ffi
->size
, ffi
->alignment
));
1544 type
->PoolFFI(&pool
, context
, ffi
, data
, arguments
[0]);
1545 JSValueRef
value(type
->FromFFI(context
, ffi
, data
));
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
);
1556 static JSObjectRef
Type_callAsConstructor(JSContextRef context
, JSObjectRef object
, size_t count
, const JSValueRef arguments
[], JSValueRef
*exception
) { CYTry
{
1558 throw CYJSError(context
, "incorrect number of arguments to Type allocator");
1559 Type_privateData
*internal(reinterpret_cast<Type_privateData
*>(JSObjectGetPrivate(object
)));
1561 JSObjectRef
pointer(CYMakePointer(context
, NULL
, *internal
->type_
, NULL
, NULL
));
1562 Pointer
*value(reinterpret_cast<Pointer
*>(JSObjectGetPrivate(pointer
)));
1564 sig::Type
*type(internal
->type_
);
1565 ffi_type
*ffi(internal
->GetFFI());
1566 value
->value_
= value
->pool_
->malloc
<void>(ffi
->size
, ffi
->alignment
);
1569 memset(value
->value_
, 0, ffi
->size
);
1571 type
->PoolFFI(value
->pool_
, context
, ffi
, value
->value_
, arguments
[0]);
1576 static JSObjectRef
Functor_new(JSContextRef context
, JSObjectRef object
, size_t count
, const JSValueRef arguments
[], JSValueRef
*exception
) { CYTry
{
1578 throw CYJSError(context
, "incorrect number of arguments to Functor constructor");
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
);
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
);
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
);
1598 static JSValueRef Functor_callAsFunction_$
cya(JSContextRef context
, JSObjectRef object
, JSObjectRef _this
, size_t count
, const JSValueRef arguments
[], JSValueRef
*exception
) { CYTry
{
1600 cy::Functor
*internal(reinterpret_cast<cy::Functor
*>(JSObjectGetPrivate(_this
)));
1602 sig::Function
type(internal
->variadic_
);
1603 sig::Copy(pool
, type
.signature
, internal
->signature_
);
1605 return CYMakePointer(context
, reinterpret_cast<void *>(internal
->value_
), type
, NULL
, NULL
);
1608 static JSValueRef
Pointer_callAsFunction_toPointer(JSContextRef context
, JSObjectRef object
, JSObjectRef _this
, size_t count
, const JSValueRef arguments
[], JSValueRef
*exception
) { CYTry
{
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_
));
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_
));
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_
));
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_
));
1633 sig::Function
function(internal
->variadic_
);
1634 sig::Copy(pool
, function
.signature
, internal
->signature_
);
1636 auto typed(CYDecodeType(pool
, &function
)); {
1637 std::ostringstream str
;
1639 if (internal
->value_
== NULL
)
1641 else if (dladdr(value
, &info
) == 0)
1642 str
<< internal
->value_
;
1644 str
<< info
.dli_sname
;
1645 off_t
offset(value
- reinterpret_cast<uint8_t *>(info
.dli_saddr
));
1647 str
<< "+0x" << std::hex
<< offset
;
1650 typed
->identifier_
= new(pool
) CYIdentifier(pool
.strdup(str
.str().c_str()));
1653 std::ostringstream str
;
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()));
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
));
1664 Pointer
*internal(reinterpret_cast<Pointer
*>(JSObjectGetPrivate(_this
)));
1667 JSValueRef
value(CYGetProperty(context
, _this
, cyi_s
));
1668 if (!JSValueIsUndefined(context
, value
)) {
1670 return CYCastJSValue(context
, pool
.strcat("&", CYPoolCCYON(pool
, context
, value
, objects
), NULL
));
1672 } catch (const CYException
&e
) {
1673 // XXX: it might be interesting to include this error
1677 std::ostringstream str
;
1679 sig::Pointer
type(*internal
->type_
->type_
);
1682 CYOutput
output(*str
.rdbuf(), options
);
1683 (new(pool
) CYTypeExpression(CYDecodeType(pool
, &type
)))->Output(output
, CYNoFlags
);
1685 str
<< "(" << internal
->value_
<< ")";
1686 std::string
value(str
.str());
1687 return CYCastJSValue(context
, CYJSString(CYUTF8String(value
.c_str(), value
.size())));
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_
));
1695 static JSValueRef CString_getProperty_$
cyt(JSContextRef context
, JSObjectRef object
, JSStringRef property
, JSValueRef
*exception
) { CYTry
{
1696 return CYMakeType(context
, sig::String());
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
);
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
);
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
;
1719 CYStringify(str
, string
, strlen(string
), true);
1721 std::string
value(str
.str());
1722 return CYCastJSValue(context
, CYJSString(CYUTF8String(value
.c_str(), value
.size())));
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_
);
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
)));
1733 sig::Function
type(internal
->variadic_
);
1734 sig::Copy(pool
, type
.signature
, internal
->signature_
);
1735 return CYMakeType(context
, type
);
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
);
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());
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
);
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
)));
1756 const char *type(sig::Unparse(pool
, internal
->type_
));
1757 return CYCastJSValue(context
, CYJSString(type
));
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
)));
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()));
1771 static JSStaticFunction All_staticFunctions
[2] = {
1772 {"cy$complete", &All_complete_callAsFunction
, kJSPropertyAttributeDontEnum
| kJSPropertyAttributeDontDelete
},
1776 static JSStaticFunction CArray_staticFunctions
[3] = {
1777 {"toPointer", &CArray_callAsFunction_toPointer
, kJSPropertyAttributeDontEnum
| kJSPropertyAttributeDontDelete
},
1778 {"valueOf", &CArray_callAsFunction_valueOf
, kJSPropertyAttributeDontEnum
| kJSPropertyAttributeDontDelete
},
1782 static JSStaticValue CArray_staticValues
[2] = {
1783 {"$cyt", &CArray_getProperty_$cyt
, NULL
, kJSPropertyAttributeReadOnly
| kJSPropertyAttributeDontEnum
| kJSPropertyAttributeDontDelete
},
1784 {NULL
, NULL
, NULL
, 0}
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
},
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}
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
},
1808 static JSStaticValue Pointer_staticValues
[2] = {
1809 {"$cyt", &Pointer_getProperty_$cyt
, NULL
, kJSPropertyAttributeReadOnly
| kJSPropertyAttributeDontEnum
| kJSPropertyAttributeDontDelete
},
1810 {NULL
, NULL
, NULL
, 0}
1813 static JSStaticFunction Struct_staticFunctions
[2] = {
1814 {"$cya", &Struct_callAsFunction_$cya
, kJSPropertyAttributeDontEnum
| kJSPropertyAttributeDontDelete
},
1818 static JSStaticValue Struct_staticValues
[2] = {
1819 {"$cyt", &Struct_getProperty_$cyt
, NULL
, kJSPropertyAttributeReadOnly
| kJSPropertyAttributeDontEnum
| kJSPropertyAttributeDontDelete
},
1820 {NULL
, NULL
, NULL
, 0}
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
},
1831 JSStaticFunction
const * const Functor::StaticFunctions
= Functor_staticFunctions
;
1834 static JSStaticValue Functor_staticValues
[2] = {
1835 {"$cyt", &Functor_getProperty_$cyt
, NULL
, kJSPropertyAttributeReadOnly
| kJSPropertyAttributeDontEnum
| kJSPropertyAttributeDontDelete
},
1836 {NULL
, NULL
, NULL
, 0}
1840 JSStaticValue
const * const Functor::StaticValues
= Functor_staticValues
;
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}
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
},
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
]);
1868 JSObjectRef
array(CYObjectMakeArray(context
, argc
, args
));
1869 JSObjectRef
System(CYGetCachedObject(context
, CYJSString("System")));
1870 CYSetProperty(context
, System
, CYJSString("args"), array
);
1873 JSObjectRef
CYGetGlobalObject(JSContextRef context
) {
1874 return JSContextGetGlobalObject(context
);
1877 // XXX: this is neither exceptin safe nor even terribly sane
1878 class ExecutionHandle
{
1880 JSContextRef context_
;
1881 std::vector
<void *> handles_
;
1884 ExecutionHandle(JSContextRef context
) :
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_
);
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]);
1907 static volatile bool cancel_
;
1909 static bool CYShouldTerminate(JSContextRef context
, void *arg
) {
1914 _visible
const char *CYExecute(JSContextRef context
, CYPool
&pool
, CYUTF8String code
) {
1915 ExecutionHandle
handle(context
);
1919 if (&JSContextGroupSetExecutionTimeLimit
!= NULL
)
1920 JSContextGroupSetExecutionTimeLimit(JSContextGetGroup(context
), 0.5, &CYShouldTerminate
, NULL
);
1924 JSValueRef
result(_jsccall(JSEvaluateScript
, context
, CYJSString(code
), NULL
, NULL
, 0));
1925 if (JSValueIsUndefined(context
, result
))
1928 std::set
<void *> objects
;
1929 const char *json(_jsccall(CYPoolCCYON
, pool
, context
, result
, objects
));
1930 CYSetProperty(context
, CYGetGlobalObject(context
), Result_
, result
);
1933 } catch (const CYException
&error
) {
1934 return pool
.strcat("throw ", error
.PoolCString(pool
), NULL
);
1939 _visible
void CYCancel() {
1944 const char *CYPoolLibraryPath(CYPool
&pool
);
1946 static bool initialized_
= false;
1948 void CYInitializeDynamic() {
1950 initialized_
= true;
1954 const char *db(pool
.strcat(CYPoolLibraryPath(pool
), "/libcycript.db", NULL
));
1955 _sqlcall(sqlite3_open_v2(db
, &database_
, SQLITE_OPEN_READONLY
, NULL
));
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"));
1960 JSClassDefinition definition
;
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
);
1970 definition
= kJSClassDefinitionEmpty
;
1971 definition
.className
= "Context";
1972 definition
.finalize
= &CYFinalize
;
1973 Context::Class_
= JSClassCreate(&definition
);
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
);
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
);
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
);
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
);
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
);
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
);
2030 definition
= kJSClassDefinitionEmpty
;
2031 definition
.className
= "Global";
2032 //definition.getProperty = &Global_getProperty;
2033 Global_
= JSClassCreate(&definition
);
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");
2053 Result_
= JSStringCreateWithUTF8CString("_");
2055 for (CYHook
*hook
: GetHooks())
2056 if (hook
->Initialize
!= NULL
)
2057 (*hook
->Initialize
)();
2060 void CYThrow(JSContextRef context
, JSValueRef value
) {
2062 throw CYJSError(context
, value
);
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
);
2071 JSValueRef
CYJSError::CastJSValue(JSContextRef context
, const char *name
) const {
2072 // XXX: what if the context is different? or the name? I dunno. ("epic" :/)
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
);
2082 JSValueRef
CYPoolError::CastJSValue(JSContextRef context
, const char *name
) const {
2083 return CYCastJSError(context
, name
, message_
);
2086 CYJSError::CYJSError(JSContextRef context
, const char *format
, ...) {
2087 _assert(context
!= NULL
);
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
));
2097 value_
= CYCastJSError(context
, "Error", message
);
2100 JSGlobalContextRef
CYGetJSContext(JSContextRef context
) {
2101 return reinterpret_cast<Context
*>(JSObjectGetPrivate(CYCastJSObject(context
, CYGetProperty(context
, CYGetGlobalObject(context
), cy_s
))))->context_
;
2104 const char *CYPoolLibraryPath(CYPool
&pool
) {
2106 _assert(dladdr(reinterpret_cast<void *>(&CYPoolLibraryPath
), &addr
) != 0);
2107 char *lib(pool
.strdup(addr
.dli_fname
));
2109 char *slash(strrchr(lib
, '/'));
2114 slash
= strrchr(lib
, '/');
2115 if (slash
!= NULL
&& strcmp(slash
, "/.libs") == 0)
2121 static JSValueRef
require_callAsFunction(JSContextRef context
, JSObjectRef object
, JSObjectRef _this
, size_t count
, const JSValueRef arguments
[], JSValueRef
*exception
) { CYTry
{
2122 _assert(count
== 1);
2125 const char *name(CYPoolCString(pool
, context
, arguments
[0]));
2126 if (strchr(name
, '/') == NULL
&& (
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
||
2132 return CYJSUndefined(context
);
2134 JSObjectRef
resolve(CYCastJSObject(context
, CYGetProperty(context
, object
, CYJSString("resolve"))));
2135 CYJSString
path(context
, CYCallAsFunction(context
, resolve
, NULL
, 1, arguments
));
2137 CYJSString
property("exports");
2139 JSObjectRef
modules(CYGetCachedObject(context
, CYJSString("modules")));
2140 JSValueRef
cache(CYGetProperty(context
, modules
, path
));
2143 if (!JSValueIsUndefined(context
, cache
)) {
2144 JSObjectRef
module(CYCastJSObject(context
, cache
));
2145 result
= CYGetProperty(context
, module, property
);
2147 CYUTF8String
code(CYPoolFileUTF8String(pool
, CYPoolCString(pool
, context
, path
)));
2148 _assert(code
.data
!= NULL
);
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
);
2157 JSObjectRef
module(JSObjectMake(context
, NULL
, NULL
));
2158 CYSetProperty(context
, modules
, path
, module);
2160 JSObjectRef
exports(JSObjectMake(context
, NULL
, NULL
));
2161 CYSetProperty(context
, module, property
, exports
);
2163 std::stringstream wrap
;
2164 wrap
<< "(function (exports, require, module, __filename) { " << code
<< "\n});";
2165 code
= CYPoolCode(pool
, *wrap
.rdbuf());
2167 JSValueRef
value(_jsccall(JSEvaluateScript
, context
, CYJSString(code
), NULL
, NULL
, 0));
2168 JSObjectRef
function(CYCastJSObject(context
, value
));
2170 JSValueRef arguments
[4] = { exports
, object
, module, CYCastJSValue(context
, path
) };
2171 CYCallAsFunction(context
, function
, NULL
, 4, arguments
);
2172 result
= CYGetProperty(context
, module, property
);
2179 static bool CYRunScript(JSGlobalContextRef context
, const char *path
) {
2181 CYUTF8String
code(CYPoolFileUTF8String(pool
, pool
.strcat(CYPoolLibraryPath(pool
), path
, NULL
)));
2182 if (code
.data
== NULL
)
2185 code
= CYPoolCode(pool
, code
);
2186 _jsccall(JSEvaluateScript
, context
, CYJSString(code
), NULL
, NULL
, 0);
2190 extern "C" void CYDestroyWeak(JSWeakObjectMapRef weak
, void *data
) {
2193 extern "C" void CYSetupContext(JSGlobalContextRef context
) {
2194 CYInitializeDynamic();
2196 JSObjectRef
global(CYGetGlobalObject(context
));
2198 JSObjectRef
cy(Context::Make(context
, context
));
2199 CYSetProperty(context
, global
, cy_s
, cy
, kJSPropertyAttributeDontEnum
);
2201 /* Cache Globals {{{ */
2202 JSObjectRef
Array(CYCastJSObject(context
, CYGetProperty(context
, global
, CYJSString("Array"))));
2203 CYSetProperty(context
, cy
, CYJSString("Array"), Array
);
2205 JSObjectRef
Array_prototype(CYCastJSObject(context
, CYGetProperty(context
, Array
, prototype_s
)));
2206 CYSetProperty(context
, cy
, CYJSString("Array_prototype"), Array_prototype
);
2208 JSObjectRef
Boolean(CYCastJSObject(context
, CYGetProperty(context
, global
, CYJSString("Boolean"))));
2209 CYSetProperty(context
, cy
, CYJSString("Boolean"), Boolean
);
2211 JSObjectRef
Boolean_prototype(CYCastJSObject(context
, CYGetProperty(context
, Boolean
, prototype_s
)));
2212 CYSetProperty(context
, cy
, CYJSString("Boolean_prototype"), Boolean_prototype
);
2214 JSObjectRef
Error(CYCastJSObject(context
, CYGetProperty(context
, global
, CYJSString("Error"))));
2215 CYSetProperty(context
, cy
, CYJSString("Error"), Error
);
2217 JSObjectRef
Function(CYCastJSObject(context
, CYGetProperty(context
, global
, CYJSString("Function"))));
2218 CYSetProperty(context
, cy
, CYJSString("Function"), Function
);
2220 JSObjectRef
Function_prototype(CYCastJSObject(context
, CYGetProperty(context
, Function
, prototype_s
)));
2221 CYSetProperty(context
, cy
, CYJSString("Function_prototype"), Function_prototype
);
2223 JSObjectRef
JSON(CYCastJSObject(context
, CYGetProperty(context
, global
, CYJSString("JSON"))));
2224 CYSetProperty(context
, cy
, CYJSString("JSON"), JSON
);
2226 JSObjectRef
Number(CYCastJSObject(context
, CYGetProperty(context
, global
, CYJSString("Number"))));
2227 CYSetProperty(context
, cy
, CYJSString("Number"), Number
);
2229 JSObjectRef
Number_prototype(CYCastJSObject(context
, CYGetProperty(context
, Number
, prototype_s
)));
2230 CYSetProperty(context
, cy
, CYJSString("Number_prototype"), Number_prototype
);
2232 JSObjectRef
Object(CYCastJSObject(context
, CYGetProperty(context
, global
, CYJSString("Object"))));
2233 CYSetProperty(context
, cy
, CYJSString("Object"), Object
);
2235 JSObjectRef
Object_prototype(CYCastJSObject(context
, CYGetProperty(context
, Object
, prototype_s
)));
2236 CYSetProperty(context
, cy
, CYJSString("Object_prototype"), Object_prototype
);
2238 JSObjectRef
String(CYCastJSObject(context
, CYGetProperty(context
, global
, CYJSString("String"))));
2239 CYSetProperty(context
, cy
, CYJSString("String"), String
);
2241 JSObjectRef
String_prototype(CYCastJSObject(context
, CYGetProperty(context
, String
, prototype_s
)));
2242 CYSetProperty(context
, cy
, CYJSString("String_prototype"), String_prototype
);
2244 JSObjectRef
SyntaxError(CYCastJSObject(context
, CYGetProperty(context
, global
, CYJSString("SyntaxError"))));
2245 CYSetProperty(context
, cy
, CYJSString("SyntaxError"), SyntaxError
);
2248 CYSetProperty(context
, Array_prototype
, toCYON_s
, &Array_callAsFunction_toCYON
, kJSPropertyAttributeDontEnum
);
2249 CYSetProperty(context
, String_prototype
, toCYON_s
, &String_callAsFunction_toCYON
, kJSPropertyAttributeDontEnum
);
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
);
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
);
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
);
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
);
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
));
2271 JSObjectRef
modules(JSObjectMake(context
, NULL
, NULL
));
2272 CYSetProperty(context
, cy
, CYJSString("modules"), modules
);
2274 JSObjectRef
all(JSObjectMake(context
, All_
, NULL
));
2275 CYSetProperty(context
, cycript
, CYJSString("all"), all
);
2277 JSObjectRef
cache(JSObjectMake(context
, NULL
, NULL
));
2278 CYSetProperty(context
, cy
, CYJSString("cache"), cache
);
2279 CYSetPrototype(context
, cache
, all
);
2281 JSObjectRef
alls(_jsccall(JSObjectCallAsConstructor
, context
, Array
, 0, NULL
));
2282 CYSetProperty(context
, cycript
, CYJSString("alls"), alls
);
2285 JSObjectRef
last(NULL
), curr(global
);
2287 goto next
; for (JSValueRef next
;;) {
2288 if (JSValueIsNull(context
, next
))
2291 curr
= CYCastJSObject(context
, next
);
2293 next
= JSObjectGetPrototype(context
, curr
);
2296 CYSetPrototype(context
, last
, cache
);
2299 JSObjectRef
System(JSObjectMake(context
, NULL
, NULL
));
2300 CYSetProperty(context
, cy
, CYJSString("System"), System
);
2302 CYSetProperty(context
, global
, CYJSString("require"), &require_callAsFunction
, kJSPropertyAttributeDontEnum
);
2304 CYSetProperty(context
, global
, CYJSString("system"), System
);
2305 CYSetProperty(context
, System
, CYJSString("args"), CYJSNull(context
));
2306 CYSetProperty(context
, System
, CYJSString("print"), &System_print
);
2308 CYSetProperty(context
, global
, CYJSString("global"), global
);
2311 if (&JSWeakObjectMapCreate
!= NULL
) {
2312 JSWeakObjectMapRef
weak(JSWeakObjectMapCreate(context
, NULL
, &CYDestroyWeak
));
2313 CYSetProperty(context
, cy
, weak_s
, CYCastJSValue(context
, reinterpret_cast<uintptr_t>(weak
)));
2317 CYSetProperty(context
, String_prototype
, cyt_s
, CYMakeType(context
, sig::String()), kJSPropertyAttributeDontEnum
);
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
);
2323 CYSetProperty(context
, cache
, CYJSString("NULL"), CYJSNull(context
), kJSPropertyAttributeDontEnum
);
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
);
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
);
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
);
2340 CYSetProperty(context
, cache
, CYJSString("float"), CYMakeType(context
, sig::Primitive
<float>()), kJSPropertyAttributeDontEnum
);
2341 CYSetProperty(context
, cache
, CYJSString("double"), CYMakeType(context
, sig::Primitive
<double>()), kJSPropertyAttributeDontEnum
);
2343 for (CYHook
*hook
: GetHooks())
2344 if (hook
->SetupContext
!= NULL
)
2345 (*hook
->SetupContext
)(context
);
2347 CYArrayPush(context
, alls
, cycript
);
2349 CYRunScript(context
, "/libcycript.cy");
2352 static JSGlobalContextRef context_
;
2354 _visible JSGlobalContextRef
CYGetJSContext() {
2355 CYInitializeDynamic();
2357 if (context_
== NULL
) {
2358 context_
= JSGlobalContextCreate(Global_
);
2359 CYSetupContext(context_
);
2365 _visible
void CYDestroyContext() {
2366 if (context_
== NULL
)
2368 JSGlobalContextRelease(context_
);