Library.mm

   1 /* Cyrker - Remove Execution Server and Disassembler
   2  * Copyright (C) 2009  Jay Freeman (saurik)
   3 */
   4
   5 /* Modified BSD License {{{ */
   6 /*
   7  *        Redistribution and use in source and binary
   8  * forms, with or without modification, are permitted
   9  * provided that the following conditions are met:
  10  *
  11  * 1. Redistributions of source code must retain the
  12  *    above copyright notice, this list of conditions
  13  *    and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the
  15  *    above copyright notice, this list of conditions
  16  *    and the following disclaimer in the documentation
  17  *    and/or other materials provided with the
  18  *    distribution.
  19  * 3. The name of the author may not be used to endorse
  20  *    or promote products derived from this software
  21  *    without specific prior written permission.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS''
  24  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,
  25  * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  26  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  27  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE
  28  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  29  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  30  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  31  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  32  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  33  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
  34  * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
  35  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  36  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  37 */
  38 /* }}} */
  39
  40 #define _GNU_SOURCE
  41
  42 #include <substrate.h>
  43 #include "cycript.hpp"
  44
  45 #include "sig/parse.hpp"
  46 #include "sig/ffi_type.hpp"
  47
  48 #include "Pooling.hpp"
  49 #include "Struct.hpp"
  50
  51 #include <unistd.h>
  52
  53 #include <CoreFoundation/CoreFoundation.h>
  54 #include <CoreFoundation/CFLogUtilities.h>
  55
  56 #include <CFNetwork/CFNetwork.h>
  57
  58 #include <WebKit/WebScriptObject.h>
  59
  60 #include <sys/types.h>
  61 #include <sys/socket.h>
  62 #include <netinet/in.h>
  63 #include <sys/mman.h>
  64
  65 #include <iostream>
  66 #include <ext/stdio_filebuf.h>
  67 #include <set>
  68 #include <map>
  69
  70 #include "Parser.hpp"
  71 #include "Cycript.tab.hh"
  72
  73 #undef _assert
  74 #undef _trace
  75
  76 #define _assert(test) do { \
  77     if (!(test)) \
  78         @throw [NSException exceptionWithName:NSInternalInconsistencyException reason:[NSString stringWithFormat:@"_assert(%s):%s(%u):%s", #test, __FILE__, __LINE__, __FUNCTION__] userInfo:nil]; \
  79 } while (false)
  80
  81 #define _trace() do { \
  82     CFLog(kCFLogLevelNotice, CFSTR("_trace():%u"), __LINE__); \
  83 } while (false)
  84
  85 #define CYPoolTry { \
  86     id _saved(nil); \
  87     NSAutoreleasePool *_pool([[NSAutoreleasePool alloc] init]); \
  88     @try
  89 #define CYPoolCatch(value) \
  90     @catch (NSException *error) { \
  91         _saved = [error retain]; \
  92         @throw; \
  93         return value; \
  94     } @finally { \
  95         [_pool release]; \
  96         if (_saved != nil) \
  97             [_saved autorelease]; \
  98     } \
  99 }
 100
 101 static JSGlobalContextRef Context_;
 102 static JSObjectRef System_;
 103
 104 static JSClassRef Functor_;
 105 static JSClassRef Instance_;
 106 static JSClassRef Pointer_;
 107 static JSClassRef Selector_;
 108
 109 static JSObjectRef Array_;
 110 static JSObjectRef Function_;
 111
 112 static JSStringRef name_;
 113 static JSStringRef message_;
 114 static JSStringRef length_;
 115
 116 static Class NSCFBoolean_;
 117
 118 static NSMutableDictionary *Bridge_;
 119
 120 struct Client {
 121     CFHTTPMessageRef message_;
 122     CFSocketRef socket_;
 123 };
 124
 125 struct ptrData {
 126     apr_pool_t *pool_;
 127     void *value_;
 128     sig::Type type_;
 129
 130     void *operator new(size_t size) {
 131         apr_pool_t *pool;
 132         apr_pool_create(&pool, NULL);
 133         void *data(apr_palloc(pool, size));
 134         reinterpret_cast<ptrData *>(data)->pool_ = pool;
 135         return data;;
 136     }
 137
 138     ptrData(void *value) :
 139         value_(value)
 140     {
 141     }
 142
 143     virtual ~ptrData() {
 144     }
 145 };
 146
 147 struct ffiData : ptrData {
 148     sig::Signature signature_;
 149     ffi_cif cif_;
 150
 151     ffiData(const char *type, void (*value)()) :
 152         ptrData(reinterpret_cast<void *>(value))
 153     {
 154         sig::Parse(pool_, &signature_, type);
 155         sig::sig_ffi_cif(pool_, &sig::ObjectiveC, &signature_, &cif_);
 156     }
 157 };
 158
 159 struct ffoData : ffiData {
 160     JSContextRef context_;
 161     JSObjectRef function_;
 162
 163     ffoData(const char *type) :
 164         ffiData(type, NULL)
 165     {
 166     }
 167 };
 168
 169 struct selData : ptrData {
 170     selData(SEL value) :
 171         ptrData(value)
 172     {
 173     }
 174
 175     SEL GetValue() const {
 176         return reinterpret_cast<SEL>(value_);
 177     }
 178 };
 179
 180 struct jocData : ptrData {
 181     bool transient_;
 182
 183     jocData(id value, bool transient) :
 184         ptrData(value)
 185     {
 186     }
 187
 188     virtual ~jocData() {
 189         if (!transient_)
 190             [GetValue() release];
 191     }
 192
 193     id GetValue() const {
 194         return reinterpret_cast<id>(value_);
 195     }
 196 };
 197
 198 JSObjectRef CYMakeInstance(JSContextRef context, id object, bool transient) {
 199     if (!transient)
 200         object = [object retain];
 201     jocData *data(new jocData(object, transient));
 202     return JSObjectMake(context, Instance_, data);
 203 }
 204
 205 const char *CYPoolCString(apr_pool_t *pool, NSString *value) {
 206     if (pool == NULL)
 207         return [value UTF8String];
 208     else {
 209         size_t size([value maximumLengthOfBytesUsingEncoding:NSUTF8StringEncoding] + 1);
 210         char *string(new(pool) char[size]);
 211         if (![value getCString:string maxLength:size encoding:NSUTF8StringEncoding])
 212             @throw [NSException exceptionWithName:NSInvalidArgumentException reason:@"[NSString getCString:maxLength:encoding:] == NO" userInfo:nil];
 213         return string;
 214     }
 215 }
 216
 217 JSValueRef CYCastJSValue(JSContextRef context, bool value) {
 218     return JSValueMakeBoolean(context, value);
 219 }
 220
 221 JSValueRef CYCastJSValue(JSContextRef context, double value) {
 222     return JSValueMakeNumber(context, value);
 223 }
 224
 225 #define CYCastJSValue_(Type_) \
 226     JSValueRef CYCastJSValue(JSContextRef context, Type_ value) { \
 227         return JSValueMakeNumber(context, static_cast<double>(value)); \
 228     }
 229
 230 CYCastJSValue_(int)
 231 CYCastJSValue_(unsigned int)
 232 CYCastJSValue_(long int)
 233 CYCastJSValue_(long unsigned int)
 234 CYCastJSValue_(long long int)
 235 CYCastJSValue_(long long unsigned int)
 236
 237 JSValueRef CYJSUndefined(JSContextRef context) {
 238     return JSValueMakeUndefined(context);
 239 }
 240
 241 @interface NSMethodSignature (Cycript)
 242 - (NSString *) _typeString;
 243 @end
 244
 245 @interface NSObject (Cycript)
 246 - (bool) cy$isUndefined;
 247 - (NSString *) cy$toJSON;
 248 - (JSValueRef) cy$JSValueInContext:(JSContextRef)context transient:(bool)transient;
 249 @end
 250
 251 @interface NSString (Cycript)
 252 - (void *) cy$symbol;
 253 @end
 254
 255 @interface NSNumber (Cycript)
 256 - (void *) cy$symbol;
 257 @end
 258
 259 @implementation NSObject (Cycript)
 260
 261 - (bool) cy$isUndefined {
 262     return false;
 263 }
 264
 265 - (NSString *) cy$toJSON {
 266     return [self description];
 267 }
 268
 269 - (JSValueRef) cy$JSValueInContext:(JSContextRef)context transient:(bool)transient {
 270     return CYMakeInstance(context, self, transient);
 271 }
 272
 273 @end
 274
 275 @implementation WebUndefined (Cycript)
 276
 277 - (bool) cy$isUndefined {
 278     return true;
 279 }
 280
 281 - (NSString *) cy$toJSON {
 282     return @"undefined";
 283 }
 284
 285 - (JSValueRef) cy$JSValueInContext:(JSContextRef)context transient:(bool)transient {
 286     return CYJSUndefined(context);
 287 }
 288
 289 @end
 290
 291 @implementation NSNull (Cycript)
 292
 293 - (NSString *) cy$toJSON {
 294     return @"null";
 295 }
 296
 297 @end
 298
 299 @implementation NSArray (Cycript)
 300
 301 - (NSString *) cy$toJSON {
 302     NSMutableString *json([[[NSMutableString alloc] init] autorelease]);
 303     [json appendString:@"["];
 304
 305     bool comma(false);
 306     for (id object in self) {
 307         if (comma)
 308             [json appendString:@","];
 309         else
 310             comma = true;
 311         if (![object cy$isUndefined])
 312             [json appendString:[object cy$toJSON]];
 313         else {
 314             [json appendString:@","];
 315             comma = false;
 316         }
 317     }
 318
 319     [json appendString:@"]"];
 320     return json;
 321 }
 322
 323 @end
 324
 325 @implementation NSDictionary (Cycript)
 326
 327 - (NSString *) cy$toJSON {
 328     NSMutableString *json([[[NSMutableString alloc] init] autorelease]);
 329     [json appendString:@"({"];
 330
 331     bool comma(false);
 332     for (id key in self) {
 333         if (comma)
 334             [json appendString:@","];
 335         else
 336             comma = true;
 337         [json appendString:[key cy$toJSON]];
 338         [json appendString:@":"];
 339         NSObject *object([self objectForKey:key]);
 340         [json appendString:[object cy$toJSON]];
 341     }
 342
 343     [json appendString:@"})"];
 344     return json;
 345 }
 346
 347 @end
 348
 349 @implementation NSNumber (Cycript)
 350
 351 - (NSString *) cy$toJSON {
 352     return [self class] != NSCFBoolean_ ? [self stringValue] : [self boolValue] ? @"true" : @"false";
 353 }
 354
 355 - (JSValueRef) cy$JSValueInContext:(JSContextRef)context transient:(bool)transient {
 356     return [self class] != NSCFBoolean_ ? CYCastJSValue(context, [self doubleValue]) : CYCastJSValue(context, [self boolValue]);
 357 }
 358
 359 - (void *) cy$symbol {
 360     return [self pointerValue];
 361 }
 362
 363 @end
 364
 365 @implementation NSString (Cycript)
 366
 367 - (NSString *) cy$toJSON {
 368     CFMutableStringRef json(CFStringCreateMutableCopy(kCFAllocatorDefault, 0, (CFStringRef) self));
 369
 370     CFStringFindAndReplace(json, CFSTR("\\"), CFSTR("\\\\"), CFRangeMake(0, CFStringGetLength(json)), 0);
 371     CFStringFindAndReplace(json, CFSTR("\""), CFSTR("\\\""), CFRangeMake(0, CFStringGetLength(json)), 0);
 372     CFStringFindAndReplace(json, CFSTR("\t"), CFSTR("\\t"), CFRangeMake(0, CFStringGetLength(json)), 0);
 373     CFStringFindAndReplace(json, CFSTR("\r"), CFSTR("\\r"), CFRangeMake(0, CFStringGetLength(json)), 0);
 374     CFStringFindAndReplace(json, CFSTR("\n"), CFSTR("\\n"), CFRangeMake(0, CFStringGetLength(json)), 0);
 375
 376     CFStringInsert(json, 0, CFSTR("\""));
 377     CFStringAppend(json, CFSTR("\""));
 378
 379     return [reinterpret_cast<const NSString *>(json) autorelease];
 380 }
 381
 382 - (void *) cy$symbol {
 383     CYPool pool;
 384     return dlsym(RTLD_DEFAULT, CYPoolCString(pool, self));
 385 }
 386
 387 @end
 388
 389 @interface CYJSObject : NSDictionary {
 390     JSObjectRef object_;
 391     JSContextRef context_;
 392 }
 393
 394 - (id) initWithJSObject:(JSObjectRef)object inContext:(JSContextRef)context;
 395
 396 - (NSUInteger) count;
 397 - (id) objectForKey:(id)key;
 398 - (NSEnumerator *) keyEnumerator;
 399 - (void) setObject:(id)object forKey:(id)key;
 400 - (void) removeObjectForKey:(id)key;
 401
 402 @end
 403
 404 @interface CYJSArray : NSArray {
 405     JSObjectRef object_;
 406     JSContextRef context_;
 407 }
 408
 409 - (id) initWithJSObject:(JSObjectRef)object inContext:(JSContextRef)context;
 410
 411 - (NSUInteger) count;
 412 - (id) objectAtIndex:(NSUInteger)index;
 413
 414 @end
 415
 416 CYRange WordStartRange_(0x1000000000LLU,0x7fffffe87fffffeLLU); // A-Za-z_$
 417 CYRange WordEndRange_(0x3ff001000000000LLU,0x7fffffe87fffffeLLU); // A-Za-z_$0-9
 418
 419 JSGlobalContextRef CYGetJSContext() {
 420     return Context_;
 421 }
 422
 423 #define CYTry \
 424     @try
 425 #define CYCatch \
 426     @catch (id error) { \
 427         NSLog(@"e:%@", error); \
 428         CYThrow(context, error, exception); \
 429         return NULL; \
 430     }
 431
 432 void CYThrow(JSContextRef context, JSValueRef value);
 433
 434 apr_status_t CYPoolRelease_(void *data) {
 435     id object(reinterpret_cast<id>(data));
 436     [object release];
 437     return APR_SUCCESS;
 438 }
 439
 440 id CYPoolRelease(apr_pool_t *pool, id object) {
 441     if (pool == NULL)
 442         return [object autorelease];
 443     else {
 444         apr_pool_cleanup_register(pool, object, &CYPoolRelease_, &apr_pool_cleanup_null);
 445         return object;
 446     }
 447 }
 448
 449 id CYCastNSObject(apr_pool_t *pool, JSContextRef context, JSObjectRef object) {
 450     if (JSValueIsObjectOfClass(context, object, Instance_)) {
 451         jocData *data(reinterpret_cast<jocData *>(JSObjectGetPrivate(object)));
 452         return data->GetValue();
 453     }
 454
 455     JSValueRef exception(NULL);
 456     bool array(JSValueIsInstanceOfConstructor(context, object, Array_, &exception));
 457     CYThrow(context, exception);
 458     id value(array ? [CYJSArray alloc] : [CYJSObject alloc]);
 459     return CYPoolRelease(pool, [value initWithJSObject:object inContext:context]);
 460 }
 461
 462 JSStringRef CYCopyJSString(id value) {
 463     return value == NULL ? NULL : JSStringCreateWithCFString(reinterpret_cast<CFStringRef>([value description]));
 464 }
 465
 466 JSStringRef CYCopyJSString(const char *value) {
 467     return value == NULL ? NULL : JSStringCreateWithUTF8CString(value);
 468 }
 469
 470 JSStringRef CYCopyJSString(JSStringRef value) {
 471     return value == NULL ? NULL : JSStringRetain(value);
 472 }
 473
 474 JSStringRef CYCopyJSString(JSContextRef context, JSValueRef value) {
 475     if (JSValueIsNull(context, value))
 476         return NULL;
 477     JSValueRef exception(NULL);
 478     JSStringRef string(JSValueToStringCopy(context, value, &exception));
 479     CYThrow(context, exception);
 480     return string;
 481 }
 482
 483 class CYJSString {
 484   private:
 485     JSStringRef string_;
 486
 487     void Clear_() {
 488         JSStringRelease(string_);
 489     }
 490
 491   public:
 492     CYJSString(const CYJSString &rhs) :
 493         string_(CYCopyJSString(rhs.string_))
 494     {
 495     }
 496
 497     template <typename Arg0_>
 498     CYJSString(Arg0_ arg0) :
 499         string_(CYCopyJSString(arg0))
 500     {
 501     }
 502
 503     template <typename Arg0_, typename Arg1_>
 504     CYJSString(Arg0_ arg0, Arg1_ arg1) :
 505         string_(CYCopyJSString(arg0, arg1))
 506     {
 507     }
 508
 509     CYJSString &operator =(const CYJSString &rhs) {
 510         Clear_();
 511         string_ = CYCopyJSString(rhs.string_);
 512         return *this;
 513     }
 514
 515     ~CYJSString() {
 516         Clear_();
 517     }
 518
 519     void Clear() {
 520         Clear_();
 521         string_ = NULL;
 522     }
 523
 524     operator JSStringRef() const {
 525         return string_;
 526     }
 527 };
 528
 529 CFStringRef CYCopyCFString(JSStringRef value) {
 530     return JSStringCopyCFString(kCFAllocatorDefault, value);
 531 }
 532
 533 CFStringRef CYCopyCFString(JSContextRef context, JSValueRef value) {
 534     return CYCopyCFString(CYJSString(context, value));
 535 }
 536
 537 double CYCastDouble(JSContextRef context, JSValueRef value) {
 538     JSValueRef exception(NULL);
 539     double number(JSValueToNumber(context, value, &exception));
 540     CYThrow(context, exception);
 541     return number;
 542 }
 543
 544 CFNumberRef CYCopyCFNumber(JSContextRef context, JSValueRef value) {
 545     double number(CYCastDouble(context, value));
 546     return CFNumberCreate(kCFAllocatorDefault, kCFNumberDoubleType, &number);
 547 }
 548
 549 NSString *CYCastNSString(apr_pool_t *pool, JSStringRef value) {
 550     return CYPoolRelease(pool, reinterpret_cast<const NSString *>(CYCopyCFString(value)));
 551 }
 552
 553 bool CYCastBool(JSContextRef context, JSValueRef value) {
 554     return JSValueToBoolean(context, value);
 555 }
 556
 557 CFTypeRef CYCFType(apr_pool_t *pool, JSContextRef context, JSValueRef value, bool cast) {
 558     CFTypeRef object;
 559     bool copy;
 560
 561     switch (JSType type = JSValueGetType(context, value)) {
 562         case kJSTypeUndefined:
 563             object = [WebUndefined undefined];
 564             copy = false;
 565         break;
 566
 567         case kJSTypeNull:
 568             return NULL;
 569         break;
 570
 571         case kJSTypeBoolean:
 572             object = CYCastBool(context, value) ? kCFBooleanTrue : kCFBooleanFalse;
 573             copy = false;
 574         break;
 575
 576         case kJSTypeNumber:
 577             object = CYCopyCFNumber(context, value);
 578             copy = true;
 579         break;
 580
 581         case kJSTypeString:
 582             object = CYCopyCFString(context, value);
 583             copy = true;
 584         break;
 585
 586         case kJSTypeObject:
 587             // XXX: this might could be more efficient
 588             object = (CFTypeRef) CYCastNSObject(pool, context, (JSObjectRef) value);
 589             copy = false;
 590         break;
 591
 592         default:
 593             @throw [NSException exceptionWithName:NSInternalInconsistencyException reason:[NSString stringWithFormat:@"JSValueGetType() == 0x%x", type] userInfo:nil];
 594         break;
 595     }
 596
 597     if (cast != copy)
 598         return object;
 599     else if (copy)
 600         return CYPoolRelease(pool, (id) object);
 601     else
 602         return CFRetain(object);
 603 }
 604
 605 CFTypeRef CYCastCFType(apr_pool_t *pool, JSContextRef context, JSValueRef value) {
 606     return CYCFType(pool, context, value, true);
 607 }
 608
 609 CFTypeRef CYCopyCFType(apr_pool_t *pool, JSContextRef context, JSValueRef value) {
 610     return CYCFType(pool, context, value, false);
 611 }
 612
 613 NSArray *CYCastNSArray(JSPropertyNameArrayRef names) {
 614     CYPool pool;
 615     size_t size(JSPropertyNameArrayGetCount(names));
 616     NSMutableArray *array([NSMutableArray arrayWithCapacity:size]);
 617     for (size_t index(0); index != size; ++index)
 618         [array addObject:CYCastNSString(pool, JSPropertyNameArrayGetNameAtIndex(names, index))];
 619     return array;
 620 }
 621
 622 id CYCastNSObject(apr_pool_t *pool, JSContextRef context, JSValueRef value) {
 623     return reinterpret_cast<const NSObject *>(CYCastCFType(pool, context, value));
 624 }
 625
 626 void CYThrow(JSContextRef context, JSValueRef value) {
 627     if (value == NULL)
 628         return;
 629     @throw CYCastNSObject(NULL, context, value);
 630 }
 631
 632 JSValueRef CYJSNull(JSContextRef context) {
 633     return JSValueMakeNull(context);
 634 }
 635
 636 JSValueRef CYCastJSValue(JSContextRef context, JSStringRef value) {
 637     return value == NULL ? CYJSNull(context) : JSValueMakeString(context, value);
 638 }
 639
 640 JSValueRef CYCastJSValue(JSContextRef context, const char *value) {
 641     return CYCastJSValue(context, CYJSString(value));
 642 }
 643
 644 JSValueRef CYCastJSValue(JSContextRef context, id value, bool transient = true) {
 645     return value == nil ? CYJSNull(context) : [value cy$JSValueInContext:context transient:transient];
 646 }
 647
 648 JSObjectRef CYCastJSObject(JSContextRef context, JSValueRef value) {
 649     JSValueRef exception(NULL);
 650     JSObjectRef object(JSValueToObject(context, value, &exception));
 651     CYThrow(context, exception);
 652     return object;
 653 }
 654
 655 JSValueRef CYGetProperty(JSContextRef context, JSObjectRef object, JSStringRef name) {
 656     JSValueRef exception(NULL);
 657     JSValueRef value(JSObjectGetProperty(context, object, name, &exception));
 658     CYThrow(context, exception);
 659     return value;
 660 }
 661
 662 void CYSetProperty(JSContextRef context, JSObjectRef object, JSStringRef name, JSValueRef value) {
 663     JSValueRef exception(NULL);
 664     JSObjectSetProperty(context, object, name, value, kJSPropertyAttributeNone, &exception);
 665     CYThrow(context, exception);
 666 }
 667
 668 void CYThrow(JSContextRef context, id error, JSValueRef *exception) {
 669     if (exception == NULL)
 670         throw error;
 671     *exception = CYCastJSValue(context, error);
 672 }
 673
 674 @implementation CYJSObject
 675
 676 - (id) initWithJSObject:(JSObjectRef)object inContext:(JSContextRef)context {
 677     if ((self = [super init]) != nil) {
 678         object_ = object;
 679         context_ = context;
 680     } return self;
 681 }
 682
 683 - (NSUInteger) count {
 684     JSPropertyNameArrayRef names(JSObjectCopyPropertyNames(context_, object_));
 685     size_t size(JSPropertyNameArrayGetCount(names));
 686     JSPropertyNameArrayRelease(names);
 687     return size;
 688 }
 689
 690 - (id) objectForKey:(id)key {
 691     return CYCastNSObject(NULL, context_, CYGetProperty(context_, object_, CYJSString(key))) ?: [NSNull null];
 692 }
 693
 694 - (NSEnumerator *) keyEnumerator {
 695     JSPropertyNameArrayRef names(JSObjectCopyPropertyNames(context_, object_));
 696     NSEnumerator *enumerator([CYCastNSArray(names) objectEnumerator]);
 697     JSPropertyNameArrayRelease(names);
 698     return enumerator;
 699 }
 700
 701 - (void) setObject:(id)object forKey:(id)key {
 702     CYSetProperty(context_, object_, CYJSString(key), CYCastJSValue(context_, object));
 703 }
 704
 705 - (void) removeObjectForKey:(id)key {
 706     JSValueRef exception(NULL);
 707     // XXX: this returns a bool... throw exception, or ignore?
 708     JSObjectDeleteProperty(context_, object_, CYJSString(key), &exception);
 709     CYThrow(context_, exception);
 710 }
 711
 712 @end
 713
 714 @implementation CYJSArray
 715
 716 - (id) initWithJSObject:(JSObjectRef)object inContext:(JSContextRef)context {
 717     if ((self = [super init]) != nil) {
 718         object_ = object;
 719         context_ = context;
 720     } return self;
 721 }
 722
 723 - (NSUInteger) count {
 724     return CYCastDouble(context_, CYGetProperty(context_, object_, length_));
 725 }
 726
 727 - (id) objectAtIndex:(NSUInteger)index {
 728     JSValueRef exception(NULL);
 729     JSValueRef value(JSObjectGetPropertyAtIndex(context_, object_, index, &exception));
 730     CYThrow(context_, exception);
 731     return CYCastNSObject(NULL, context_, value) ?: [NSNull null];
 732 }
 733
 734 @end
 735
 736 CFStringRef CYCopyJSONString(JSContextRef context, JSValueRef value, JSValueRef *exception) {
 737     CYTry {
 738         CYPoolTry {
 739             id object(CYCastNSObject(NULL, context, value));
 740             return reinterpret_cast<CFStringRef>([(object == nil ? @"null" : [object cy$toJSON]) retain]);
 741         } CYPoolCatch(NULL)
 742     } CYCatch
 743 }
 744
 745 const char *CYPoolJSONString(apr_pool_t *pool, JSContextRef context, JSValueRef value, JSValueRef *exception) {
 746     if (NSString *json = (NSString *) CYCopyJSONString(context, value, exception)) {
 747         const char *string(CYPoolCString(pool, json));
 748         [json release];
 749         return string;
 750     } else return NULL;
 751 }
 752
 753 static void OnData(CFSocketRef socket, CFSocketCallBackType type, CFDataRef address, const void *value, void *info) {
 754     switch (type) {
 755         case kCFSocketDataCallBack:
 756             CFDataRef data(reinterpret_cast<CFDataRef>(value));
 757             Client *client(reinterpret_cast<Client *>(info));
 758
 759             if (client->message_ == NULL)
 760                 client->message_ = CFHTTPMessageCreateEmpty(kCFAllocatorDefault, TRUE);
 761
 762             if (!CFHTTPMessageAppendBytes(client->message_, CFDataGetBytePtr(data), CFDataGetLength(data)))
 763                 CFLog(kCFLogLevelError, CFSTR("CFHTTPMessageAppendBytes()"));
 764             else if (CFHTTPMessageIsHeaderComplete(client->message_)) {
 765                 CFURLRef url(CFHTTPMessageCopyRequestURL(client->message_));
 766                 Boolean absolute;
 767                 CFStringRef path(CFURLCopyStrictPath(url, &absolute));
 768                 CFRelease(client->message_);
 769
 770                 CFStringRef code(CFURLCreateStringByReplacingPercentEscapes(kCFAllocatorDefault, path, CFSTR("")));
 771                 CFRelease(path);
 772
 773                 JSStringRef script(JSStringCreateWithCFString(code));
 774                 CFRelease(code);
 775
 776                 JSValueRef result(JSEvaluateScript(CYGetJSContext(), script, NULL, NULL, 0, NULL));
 777                 JSStringRelease(script);
 778
 779                 CFHTTPMessageRef response(CFHTTPMessageCreateResponse(kCFAllocatorDefault, 200, NULL, kCFHTTPVersion1_1));
 780                 CFHTTPMessageSetHeaderFieldValue(response, CFSTR("Content-Type"), CFSTR("application/json; charset=utf-8"));
 781
 782                 CFStringRef json(CYCopyJSONString(CYGetJSContext(), result, NULL));
 783                 CFDataRef body(CFStringCreateExternalRepresentation(kCFAllocatorDefault, json, kCFStringEncodingUTF8, NULL));
 784                 CFRelease(json);
 785
 786                 CFStringRef length(CFStringCreateWithFormat(kCFAllocatorDefault, NULL, CFSTR("%u"), CFDataGetLength(body)));
 787                 CFHTTPMessageSetHeaderFieldValue(response, CFSTR("Content-Length"), length);
 788                 CFRelease(length);
 789
 790                 CFHTTPMessageSetBody(response, body);
 791                 CFRelease(body);
 792
 793                 CFDataRef serialized(CFHTTPMessageCopySerializedMessage(response));
 794                 CFRelease(response);
 795
 796                 CFSocketSendData(socket, NULL, serialized, 0);
 797                 CFRelease(serialized);
 798
 799                 CFRelease(url);
 800             }
 801         break;
 802     }
 803 }
 804
 805 static void OnAccept(CFSocketRef socket, CFSocketCallBackType type, CFDataRef address, const void *value, void *info) {
 806     switch (type) {
 807         case kCFSocketAcceptCallBack:
 808             Client *client(new Client());
 809
 810             client->message_ = NULL;
 811
 812             CFSocketContext context;
 813             context.version = 0;
 814             context.info = client;
 815             context.retain = NULL;
 816             context.release = NULL;
 817             context.copyDescription = NULL;
 818
 819             client->socket_ = CFSocketCreateWithNative(kCFAllocatorDefault, *reinterpret_cast<const CFSocketNativeHandle *>(value), kCFSocketDataCallBack, &OnData, &context);
 820
 821             CFRunLoopAddSource(CFRunLoopGetCurrent(), CFSocketCreateRunLoopSource(kCFAllocatorDefault, client->socket_, 0), kCFRunLoopDefaultMode);
 822         break;
 823     }
 824 }
 825
 826 static JSValueRef Instance_getProperty(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) {
 827     CYTry {
 828         CYPool pool;
 829         NSString *name(CYCastNSString(pool, property));
 830         NSLog(@"get:%@", name);
 831         return NULL;
 832     } CYCatch
 833 }
 834
 835 static bool Instance_setProperty(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef value, JSValueRef *exception) {
 836     CYTry {
 837         CYPool pool;
 838         NSString *name(CYCastNSString(pool, property));
 839         NSLog(@"set:%@", name);
 840         return false;
 841     } CYCatch
 842 }
 843
 844 static bool Instance_deleteProperty(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) {
 845     CYTry {
 846         CYPool pool;
 847         NSString *name(CYCastNSString(pool, property));
 848         NSLog(@"delete:%@", name);
 849         return false;
 850     } CYCatch
 851 }
 852
 853 static JSObjectRef Instance_callAsConstructor(JSContextRef context, JSObjectRef object, size_t count, const JSValueRef arguments[], JSValueRef *exception) {
 854     CYTry {
 855         jocData *data(reinterpret_cast<jocData *>(JSObjectGetPrivate(object)));
 856         return CYMakeInstance(context, [data->GetValue() alloc], true);
 857     } CYCatch
 858 }
 859
 860 JSObjectRef CYMakeSelector(JSContextRef context, SEL sel) {
 861     selData *data(new selData(sel));
 862     return JSObjectMake(context, Selector_, data);
 863 }
 864
 865 JSObjectRef CYMakePointer(JSContextRef context, void *pointer) {
 866     ptrData *data(new ptrData(pointer));
 867     return JSObjectMake(context, Pointer_, data);
 868 }
 869
 870 static void Pointer_finalize(JSObjectRef object) {
 871     ptrData *data(reinterpret_cast<ptrData *>(JSObjectGetPrivate(object)));
 872     data->~ptrData();
 873     apr_pool_destroy(data->pool_);
 874 }
 875
 876 JSObjectRef CYMakeFunctor(JSContextRef context, void (*function)(), const char *type) {
 877     ffiData *data(new ffiData(type, function));
 878     return JSObjectMake(context, Functor_, data);
 879 }
 880
 881 const char *CYPoolCString(apr_pool_t *pool, JSStringRef value) {
 882     if (pool == NULL)
 883         return [CYCastNSString(NULL, value) UTF8String];
 884     else {
 885         size_t size(JSStringGetMaximumUTF8CStringSize(value));
 886         char *string(new(pool) char[size]);
 887         JSStringGetUTF8CString(value, string, size);
 888         return string;
 889     }
 890 }
 891
 892 const char *CYPoolCString(apr_pool_t *pool, JSContextRef context, JSValueRef value) {
 893     if (JSValueIsNull(context, value))
 894         return NULL;
 895     return CYPoolCString(pool, CYJSString(context, value));
 896 }
 897
 898 // XXX: this macro is unhygenic
 899 #define CYCastCString(context, value) ({ \
 900     char *utf8; \
 901     if (value == NULL) \
 902         utf8 = NULL; \
 903     else if (JSStringRef string = CYCopyJSString(context, value)) { \
 904         size_t size(JSStringGetMaximumUTF8CStringSize(string)); \
 905         utf8 = reinterpret_cast<char *>(alloca(size)); \
 906         JSStringGetUTF8CString(string, utf8, size); \
 907         JSStringRelease(string); \
 908     } else \
 909         utf8 = NULL; \
 910     utf8; \
 911 })
 912
 913 SEL CYCastSEL(JSContextRef context, JSValueRef value) {
 914     if (JSValueIsNull(context, value))
 915         return NULL;
 916     else if (JSValueIsObjectOfClass(context, value, Selector_)) {
 917         selData *data(reinterpret_cast<selData *>(JSObjectGetPrivate((JSObjectRef) value)));
 918         return reinterpret_cast<SEL>(data->value_);
 919     } else
 920         return sel_registerName(CYCastCString(context, value));
 921 }
 922
 923 void *CYCastPointer_(JSContextRef context, JSValueRef value) {
 924     switch (JSValueGetType(context, value)) {
 925         case kJSTypeNull:
 926             return NULL;
 927         case kJSTypeString:
 928             return dlsym(RTLD_DEFAULT, CYCastCString(context, value));
 929         case kJSTypeObject:
 930             if (JSValueIsObjectOfClass(context, value, Pointer_)) {
 931                 ptrData *data(reinterpret_cast<ptrData *>(JSObjectGetPrivate((JSObjectRef) value)));
 932                 return data->value_;
 933             }
 934         default:
 935             return reinterpret_cast<void *>(static_cast<uintptr_t>(CYCastDouble(context, value)));
 936     }
 937 }
 938
 939 template <typename Type_>
 940 _finline Type_ CYCastPointer(JSContextRef context, JSValueRef value) {
 941     return reinterpret_cast<Type_>(CYCastPointer_(context, value));
 942 }
 943
 944 void CYPoolFFI(apr_pool_t *pool, JSContextRef context, sig::Type *type, void *data, JSValueRef value) {
 945     switch (type->primitive) {
 946         case sig::boolean_P:
 947             *reinterpret_cast<bool *>(data) = JSValueToBoolean(context, value);
 948         break;
 949
 950 #define CYPoolFFI_(primitive, native) \
 951         case sig::primitive ## _P: \
 952             *reinterpret_cast<native *>(data) = CYCastDouble(context, value); \
 953         break;
 954
 955         CYPoolFFI_(uchar, unsigned char)
 956         CYPoolFFI_(char, char)
 957         CYPoolFFI_(ushort, unsigned short)
 958         CYPoolFFI_(short, short)
 959         CYPoolFFI_(ulong, unsigned long)
 960         CYPoolFFI_(long, long)
 961         CYPoolFFI_(uint, unsigned int)
 962         CYPoolFFI_(int, int)
 963         CYPoolFFI_(ulonglong, unsigned long long)
 964         CYPoolFFI_(longlong, long long)
 965         CYPoolFFI_(float, float)
 966         CYPoolFFI_(double, double)
 967
 968         case sig::object_P:
 969         case sig::typename_P:
 970             *reinterpret_cast<id *>(data) = CYCastNSObject(pool, context, value);
 971         break;
 972
 973         case sig::selector_P:
 974             *reinterpret_cast<SEL *>(data) = CYCastSEL(context, value);
 975         break;
 976
 977         case sig::pointer_P:
 978             *reinterpret_cast<void **>(data) = CYCastPointer<void *>(context, value);
 979         break;
 980
 981         case sig::string_P:
 982             *reinterpret_cast<const char **>(data) = CYPoolCString(pool, context, value);
 983         break;
 984
 985         case sig::struct_P:
 986             goto fail;
 987
 988         case sig::void_P:
 989         break;
 990
 991         default: fail:
 992             NSLog(@"CYPoolFFI(%c)\n", type->primitive);
 993             _assert(false);
 994     }
 995 }
 996
 997 JSValueRef CYFromFFI(JSContextRef context, sig::Type *type, void *data) {
 998     JSValueRef value;
 999
1000     switch (type->primitive) {
1001         case sig::boolean_P:
1002             value = CYCastJSValue(context, *reinterpret_cast<bool *>(data));
1003         break;
1004
1005 #define CYFromFFI_(primitive, native) \
1006         case sig::primitive ## _P: \
1007             value = CYCastJSValue(context, *reinterpret_cast<native *>(data)); \
1008         break;
1009
1010         CYFromFFI_(uchar, unsigned char)
1011         CYFromFFI_(char, char)
1012         CYFromFFI_(ushort, unsigned short)
1013         CYFromFFI_(short, short)
1014         CYFromFFI_(ulong, unsigned long)
1015         CYFromFFI_(long, long)
1016         CYFromFFI_(uint, unsigned int)
1017         CYFromFFI_(int, int)
1018         CYFromFFI_(ulonglong, unsigned long long)
1019         CYFromFFI_(longlong, long long)
1020         CYFromFFI_(float, float)
1021         CYFromFFI_(double, double)
1022
1023         case sig::object_P:
1024             value = CYCastJSValue(context, *reinterpret_cast<id *>(data));
1025         break;
1026
1027         case sig::typename_P:
1028             value = CYMakeInstance(context, *reinterpret_cast<Class *>(data), true);
1029         break;
1030
1031         case sig::selector_P:
1032             if (SEL sel = *reinterpret_cast<SEL *>(data))
1033                 value = CYMakeSelector(context, sel);
1034             else goto null;
1035         break;
1036
1037         case sig::pointer_P:
1038             if (void *pointer = *reinterpret_cast<void **>(data))
1039                 value = CYMakePointer(context, pointer);
1040             else goto null;
1041         break;
1042
1043         case sig::string_P:
1044             if (char *utf8 = *reinterpret_cast<char **>(data))
1045                 value = CYCastJSValue(context, utf8);
1046             else goto null;
1047         break;
1048
1049         case sig::struct_P:
1050             goto fail;
1051
1052         case sig::void_P:
1053             value = CYJSUndefined(context);
1054         break;
1055
1056         null:
1057             value = CYJSNull(context);
1058         break;
1059
1060         default: fail:
1061             NSLog(@"CYFromFFI(%c)\n", type->primitive);
1062             _assert(false);
1063     }
1064
1065     return value;
1066 }
1067
1068 static JSValueRef CYCallFunction(JSContextRef context, size_t count, const JSValueRef *arguments, JSValueRef *exception, sig::Signature *signature, ffi_cif *cif, void (*function)()) {
1069     CYTry {
1070         if (count != signature->count - 1)
1071             @throw [NSException exceptionWithName:NSInvalidArgumentException reason:@"incorrect number of arguments to ffi function" userInfo:nil];
1072
1073         CYPool pool;
1074         void *values[count];
1075
1076         for (unsigned index(0); index != count; ++index) {
1077             sig::Element *element(&signature->elements[index + 1]);
1078             // XXX: alignment?
1079             values[index] = new(pool) uint8_t[cif->arg_types[index]->size];
1080             CYPoolFFI(pool, context, element->type, values[index], arguments[index]);
1081         }
1082
1083         uint8_t value[cif->rtype->size];
1084         ffi_call(cif, function, value, values);
1085
1086         return CYFromFFI(context, signature->elements[0].type, value);
1087     } CYCatch
1088 }
1089
1090 void Closure_(ffi_cif *cif, void *result, void **arguments, void *arg) {
1091     ffoData *data(reinterpret_cast<ffoData *>(arg));
1092
1093     JSContextRef context(data->context_);
1094
1095     size_t count(data->cif_.nargs);
1096     JSValueRef values[count];
1097
1098     for (size_t index(0); index != count; ++index)
1099         values[index] = CYFromFFI(context, data->signature_.elements[1 + index].type, arguments[index]);
1100
1101     JSValueRef exception(NULL);
1102     JSValueRef value(JSObjectCallAsFunction(context, data->function_, NULL, count, values, &exception));
1103     CYThrow(context, exception);
1104
1105     CYPoolFFI(NULL, context, data->signature_.elements[0].type, result, value);
1106 }
1107
1108 JSObjectRef CYMakeFunctor(JSContextRef context, JSObjectRef function, const char *type) {
1109     // XXX: in case of exceptions this will leak
1110     ffoData *data(new ffoData(type));
1111
1112     ffi_closure *closure;
1113     _syscall(closure = (ffi_closure *) mmap(
1114         NULL, sizeof(ffi_closure),
1115         PROT_READ | PROT_WRITE, MAP_ANON | MAP_PRIVATE,
1116         -1, 0
1117     ));
1118
1119     ffi_status status(ffi_prep_closure(closure, &data->cif_, &Closure_, data));
1120     _assert(status == FFI_OK);
1121
1122     _syscall(mprotect(closure, sizeof(*closure), PROT_READ | PROT_EXEC));
1123
1124     data->value_ = closure;
1125
1126     data->context_ = CYGetJSContext();
1127     data->function_ = function;
1128
1129     return JSObjectMake(context, Functor_, data);
1130 }
1131
1132 static JSValueRef Global_getProperty(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) {
1133     CYTry {
1134         CYPool pool;
1135         NSString *name(CYCastNSString(pool, property));
1136         if (Class _class = NSClassFromString(name))
1137             return CYMakeInstance(context, _class, true);
1138         if (NSMutableArray *entry = [Bridge_ objectForKey:name])
1139             switch ([[entry objectAtIndex:0] intValue]) {
1140                 case 0:
1141                     return JSEvaluateScript(CYGetJSContext(), CYJSString([entry objectAtIndex:1]), NULL, NULL, 0, NULL);
1142                 case 1:
1143                     return CYMakeFunctor(context, reinterpret_cast<void (*)()>([name cy$symbol]), CYPoolCString(pool, [entry objectAtIndex:1]));
1144                 case 2:
1145                     sig::Signature signature;
1146                     sig::Parse(pool, &signature, CYPoolCString(pool, [entry objectAtIndex:1]));
1147                     return CYFromFFI(context, signature.elements[0].type, [name cy$symbol]);
1148             }
1149         return NULL;
1150     } CYCatch
1151 }
1152
1153 bool stret(ffi_type *ffi_type) {
1154     return ffi_type->type == FFI_TYPE_STRUCT && (
1155         ffi_type->size > OBJC_MAX_STRUCT_BY_VALUE ||
1156         struct_forward_array[ffi_type->size] != 0
1157     );
1158 }
1159
1160 extern "C" {
1161     int *_NSGetArgc(void);
1162     char ***_NSGetArgv(void);
1163     int UIApplicationMain(int argc, char *argv[], NSString *principalClassName, NSString *delegateClassName);
1164 }
1165
1166 static JSValueRef System_print(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) {
1167     CYTry {
1168         NSLog(@"%s", CYCastCString(context, arguments[0]));
1169         return CYJSUndefined(context);
1170     } CYCatch
1171 }
1172
1173 static JSValueRef CYApplicationMain(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) {
1174     CYTry {
1175         CYPool pool;
1176         NSString *name(CYCastNSObject(pool, context, arguments[0]));
1177         int argc(*_NSGetArgc());
1178         char **argv(*_NSGetArgv());
1179         for (int i(0); i != argc; ++i)
1180             NSLog(@"argv[%i]=%s", i, argv[i]);
1181         _pooled
1182         return CYCastJSValue(context, UIApplicationMain(argc, argv, name, name));
1183     } CYCatch
1184 }
1185
1186 static JSValueRef $objc_msgSend(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) {
1187     const char *type;
1188
1189     CYPool pool;
1190
1191     CYTry {
1192         if (count < 2)
1193             @throw [NSException exceptionWithName:NSInvalidArgumentException reason:@"too few arguments to objc_msgSend" userInfo:nil];
1194
1195         id self(CYCastNSObject(pool, context, arguments[0]));
1196         if (self == nil)
1197             return CYJSNull(context);
1198
1199         SEL _cmd(CYCastSEL(context, arguments[1]));
1200
1201         Class _class(object_getClass(self));
1202         if (Method method = class_getInstanceMethod(_class, _cmd))
1203             type = method_getTypeEncoding(method);
1204         else {
1205             CYPoolTry {
1206                 NSMethodSignature *method([self methodSignatureForSelector:_cmd]);
1207                 if (method == nil)
1208                     @throw [NSException exceptionWithName:NSInvalidArgumentException reason:[NSString stringWithFormat:@"unrecognized selector %s sent to object %p", sel_getName(_cmd), self] userInfo:nil];
1209                 type = CYPoolCString(pool, [method _typeString]);
1210             } CYPoolCatch(NULL)
1211         }
1212     } CYCatch
1213
1214     sig::Signature signature;
1215     sig::Parse(pool, &signature, type);
1216
1217     ffi_cif cif;
1218     sig::sig_ffi_cif(pool, &sig::ObjectiveC, &signature, &cif);
1219
1220     void (*function)() = stret(cif.rtype) ? reinterpret_cast<void (*)()>(&objc_msgSend_stret) : reinterpret_cast<void (*)()>(&objc_msgSend);
1221     return CYCallFunction(context, count, arguments, exception, &signature, &cif, function);
1222 }
1223
1224 static JSValueRef Selector_callAsFunction(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) {
1225     JSValueRef setup[count + 2];
1226     setup[0] = _this;
1227     setup[1] = object;
1228     memmove(setup + 2, arguments, sizeof(JSValueRef) * count);
1229     return $objc_msgSend(context, NULL, NULL, count + 2, setup, exception);
1230 }
1231
1232 static JSValueRef Functor_callAsFunction(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) {
1233     ffiData *data(reinterpret_cast<ffiData *>(JSObjectGetPrivate(object)));
1234     return CYCallFunction(context, count, arguments, exception, &data->signature_, &data->cif_, reinterpret_cast<void (*)()>(data->value_));
1235 }
1236
1237 JSObjectRef Selector_new(JSContextRef context, JSObjectRef object, size_t count, const JSValueRef arguments[], JSValueRef *exception) {
1238     CYTry {
1239         if (count != 1)
1240             @throw [NSException exceptionWithName:NSInvalidArgumentException reason:@"incorrect number of arguments to Selector constructor" userInfo:nil];
1241         const char *name(CYCastCString(context, arguments[0]));
1242         return CYMakeSelector(context, sel_registerName(name));
1243     } CYCatch
1244 }
1245
1246 JSObjectRef Functor_new(JSContextRef context, JSObjectRef object, size_t count, const JSValueRef arguments[], JSValueRef *exception) {
1247     CYTry {
1248         if (count != 2)
1249             @throw [NSException exceptionWithName:NSInvalidArgumentException reason:@"incorrect number of arguments to Functor constructor" userInfo:nil];
1250         const char *type(CYCastCString(context, arguments[1]));
1251         JSValueRef exception(NULL);
1252         if (JSValueIsInstanceOfConstructor(context, arguments[0], Function_, &exception)) {
1253             JSObjectRef function(CYCastJSObject(context, arguments[0]));
1254             return CYMakeFunctor(context, function, type);
1255         } else if (exception != NULL) {
1256             return NULL;
1257         } else {
1258             void (*function)()(CYCastPointer<void (*)()>(context, arguments[0]));
1259             return CYMakeFunctor(context, function, type);
1260         }
1261     } CYCatch
1262 }
1263
1264 JSValueRef Pointer_getProperty_value(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) {
1265     ptrData *data(reinterpret_cast<ptrData *>(JSObjectGetPrivate(object)));
1266     return CYCastJSValue(context, reinterpret_cast<uintptr_t>(data->value_));
1267 }
1268
1269 JSValueRef Selector_getProperty_prototype(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) {
1270     return Function_;
1271 }
1272
1273 static JSValueRef Instance_callAsFunction_toString(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) {
1274     CYTry {
1275         jocData *data(reinterpret_cast<jocData *>(JSObjectGetPrivate(_this)));
1276         NSString *description; CYPoolTry {
1277             description = [data->GetValue() description];
1278         } CYPoolCatch(NULL)
1279         return CYCastJSValue(context, CYJSString(description));
1280     } CYCatch
1281 }
1282
1283 static JSValueRef Selector_callAsFunction_toString(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) {
1284     CYTry {
1285         selData *data(reinterpret_cast<selData *>(JSObjectGetPrivate(_this)));
1286         return CYCastJSValue(context, sel_getName(data->GetValue()));
1287     } CYCatch
1288 }
1289
1290 static JSValueRef Selector_callAsFunction_type(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) {
1291     CYTry {
1292         if (count != 2)
1293             @throw [NSException exceptionWithName:NSInvalidArgumentException reason:@"incorrect number of arguments to Selector.type" userInfo:nil];
1294         CYPool pool;
1295         selData *data(reinterpret_cast<selData *>(JSObjectGetPrivate(_this)));
1296         Class _class(CYCastNSObject(pool, context, arguments[0]));
1297         bool instance(CYCastBool(context, arguments[1]));
1298         SEL sel(data->GetValue());
1299         if (Method method = (*(instance ? &class_getInstanceMethod : class_getClassMethod))(_class, sel))
1300             return CYCastJSValue(context, method_getTypeEncoding(method));
1301         else if (NSString *type = [Bridge_ objectForKey:CYPoolRelease(pool, [[NSString alloc] initWithFormat:@":%s", sel_getName(sel)])])
1302             return CYCastJSValue(context, CYJSString(type));
1303         else
1304             return CYJSNull(context);
1305     } CYCatch
1306 }
1307
1308 static JSStaticValue Pointer_staticValues[2] = {
1309     {"value", &Pointer_getProperty_value, NULL, kJSPropertyAttributeReadOnly | kJSPropertyAttributeDontDelete},
1310     {NULL, NULL, NULL, 0}
1311 };
1312
1313 /*static JSStaticValue Selector_staticValues[2] = {
1314     {"prototype", &Selector_getProperty_prototype, NULL, kJSPropertyAttributeReadOnly | kJSPropertyAttributeDontDelete},
1315     {NULL, NULL, NULL, 0}
1316 };*/
1317
1318 static JSStaticFunction Instance_staticFunctions[2] = {
1319     {"toString", &Instance_callAsFunction_toString, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
1320     {NULL, NULL, 0}
1321 };
1322
1323 static JSStaticFunction Selector_staticFunctions[3] = {
1324     {"toString", &Selector_callAsFunction_toString, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
1325     {"type", &Selector_callAsFunction_type, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
1326     {NULL, NULL, 0}
1327 };
1328
1329 CYDriver::CYDriver(const std::string &filename) :
1330     state_(CYClear),
1331     data_(NULL),
1332     size_(0),
1333     filename_(filename),
1334     source_(NULL)
1335 {
1336     ScannerInit();
1337 }
1338
1339 CYDriver::~CYDriver() {
1340     ScannerDestroy();
1341 }
1342
1343 void cy::parser::error(const cy::parser::location_type &location, const std::string &message) {
1344     CYDriver::Error error;
1345     error.location_ = location;
1346     error.message_ = message;
1347     driver.errors_.push_back(error);
1348 }
1349
1350 void CYSetArgs(int argc, const char *argv[]) {
1351     JSContextRef context(CYGetJSContext());
1352     JSValueRef args[argc];
1353     for (int i(0); i != argc; ++i)
1354         args[i] = CYCastJSValue(context, argv[i]);
1355     JSValueRef exception(NULL);
1356     JSObjectRef array(JSObjectMakeArray(context, argc, args, &exception));
1357     CYThrow(context, exception);
1358     CYSetProperty(context, System_, CYJSString("args"), array);
1359 }
1360
1361 MSInitialize { _pooled
1362     apr_initialize();
1363
1364     NSCFBoolean_ = objc_getClass("NSCFBoolean");
1365
1366     pid_t pid(getpid());
1367
1368     struct sockaddr_in address;
1369     address.sin_len = sizeof(address);
1370     address.sin_family = AF_INET;
1371     address.sin_addr.s_addr = INADDR_ANY;
1372     address.sin_port = htons(10000 + pid);
1373
1374     CFDataRef data(CFDataCreate(kCFAllocatorDefault, reinterpret_cast<UInt8 *>(&address), sizeof(address)));
1375
1376     CFSocketSignature signature;
1377     signature.protocolFamily = AF_INET;
1378     signature.socketType = SOCK_STREAM;
1379     signature.protocol = IPPROTO_TCP;
1380     signature.address = data;
1381
1382     CFSocketRef socket(CFSocketCreateWithSocketSignature(kCFAllocatorDefault, &signature, kCFSocketAcceptCallBack, &OnAccept, NULL));
1383     CFRunLoopAddSource(CFRunLoopGetCurrent(), CFSocketCreateRunLoopSource(kCFAllocatorDefault, socket, 0), kCFRunLoopDefaultMode);
1384
1385     JSClassDefinition definition;
1386
1387     definition = kJSClassDefinitionEmpty;
1388     definition.className = "Pointer";
1389     definition.staticValues = Pointer_staticValues;
1390     definition.finalize = &Pointer_finalize;
1391     Pointer_ = JSClassCreate(&definition);
1392
1393     definition = kJSClassDefinitionEmpty;
1394     definition.className = "Functor";
1395     definition.parentClass = Pointer_;
1396     definition.callAsFunction = &Functor_callAsFunction;
1397     Functor_ = JSClassCreate(&definition);
1398
1399     definition = kJSClassDefinitionEmpty;
1400     definition.className = "Selector";
1401     definition.parentClass = Pointer_;
1402     //definition.staticValues = Selector_staticValues;
1403     definition.staticFunctions = Selector_staticFunctions;
1404     definition.callAsFunction = &Selector_callAsFunction;
1405     Selector_ = JSClassCreate(&definition);
1406
1407     definition = kJSClassDefinitionEmpty;
1408     definition.className = "Instance";
1409     definition.parentClass = Pointer_;
1410     definition.staticFunctions = Instance_staticFunctions;
1411     definition.getProperty = &Instance_getProperty;
1412     definition.setProperty = &Instance_setProperty;
1413     definition.deleteProperty = &Instance_deleteProperty;
1414     definition.callAsConstructor = &Instance_callAsConstructor;
1415     Instance_ = JSClassCreate(&definition);
1416
1417     definition = kJSClassDefinitionEmpty;
1418     definition.getProperty = &Global_getProperty;
1419     JSClassRef Global(JSClassCreate(&definition));
1420
1421     JSGlobalContextRef context(JSGlobalContextCreate(Global));
1422     Context_ = context;
1423
1424     JSObjectRef global(JSContextGetGlobalObject(context));
1425
1426     CYSetProperty(context, global, CYJSString("Selector"), JSObjectMakeConstructor(context, Selector_, &Selector_new));
1427     CYSetProperty(context, global, CYJSString("Functor"), JSObjectMakeConstructor(context, Functor_, &Functor_new));
1428
1429     CYSetProperty(context, global, CYJSString("CYApplicationMain"), JSObjectMakeFunctionWithCallback(context, CYJSString("CYApplicationMain"), &CYApplicationMain));
1430     CYSetProperty(context, global, CYJSString("objc_msgSend"), JSObjectMakeFunctionWithCallback(context, CYJSString("objc_msgSend"), &$objc_msgSend));
1431
1432     System_ = JSObjectMake(context, NULL, NULL);
1433     CYSetProperty(context, global, CYJSString("system"), System_);
1434     CYSetProperty(context, System_, CYJSString("args"), CYJSNull(context));
1435     CYSetProperty(context, System_, CYJSString("global"), global);
1436
1437     CYSetProperty(context, System_, CYJSString("print"), JSObjectMakeFunctionWithCallback(context, CYJSString("print"), &System_print));
1438
1439     Bridge_ = [[NSMutableDictionary dictionaryWithContentsOfFile:@"/usr/lib/libcycript.plist"] retain];
1440
1441     name_ = JSStringCreateWithUTF8CString("name");
1442     message_ = JSStringCreateWithUTF8CString("message");
1443     length_ = JSStringCreateWithUTF8CString("length");
1444
1445     Array_ = CYCastJSObject(context, CYGetProperty(context, global, CYJSString("Array")));
1446     Function_ = CYCastJSObject(context, CYGetProperty(context, global, CYJSString("Function")));
1447 }