Java/Execute.cpp

   1 /* Cycript - The Truly Universal Scripting Language
   2  * Copyright (C) 2009-2016  Jay Freeman (saurik)
   3 */
   4
   5 /* GNU Affero General Public License, Version 3 {{{ */
   6 /*
   7  * This program is free software: you can redistribute it and/or modify
   8  * it under the terms of the GNU Affero General Public License as published by
   9  * the Free Software Foundation, either version 3 of the License, or
  10  * (at your option) any later version.
  11
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU Affero General Public License for more details.
  16
  17  * You should have received a copy of the GNU Affero General Public License
  18  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19 **/
  20 /* }}} */
  21
  22 #include <map>
  23 #include <sstream>
  24 #include <vector>
  25
  26 #include <dlfcn.h>
  27
  28 #ifdef __APPLE__
  29 #include <JavaVM/jni.h>
  30 #else
  31 #include <jni.h>
  32 #endif
  33
  34 #ifdef __ANDROID__
  35 // XXX: this is deprecated?!?!?!?!?!?!
  36 #include <sys/system_properties.h>
  37 #endif
  38
  39 #include "cycript.hpp"
  40 #include "Error.hpp"
  41 #include "Execute.hpp"
  42 #include "Internal.hpp"
  43 #include "JavaScript.hpp"
  44 #include "Pooling.hpp"
  45
  46 #define _jnicall(expr) ({ \
  47     jint _value(expr); \
  48     if (_value != JNI_OK) \
  49         CYThrow("_jnicall(%s) == %d", #expr, _value); \
  50 })
  51
  52 #define _envcall(jni, expr) ({ \
  53     __typeof__(jni->expr) _value(jni->expr); \
  54     if (jthrowable _error = jni->ExceptionOccurred()) { \
  55         jni->ExceptionClear(); \
  56         throw CYJavaError(CYJavaLocal<jthrowable>(jni, _error)); \
  57     } \
  58 _value; })
  59
  60 #define _envcallv(jni, expr) do { \
  61     jni->expr; \
  62     if (jthrowable _error = jni->ExceptionOccurred()) { \
  63         jni->ExceptionClear(); \
  64         throw CYJavaError(CYJavaLocal<jthrowable>(jni, _error)); \
  65     } \
  66 } while (false)
  67
  68 #define CYJavaTry \
  69     CYJavaEnv jni(env); \
  70     auto &protect(*reinterpret_cast<CYProtect *>(jprotect)); \
  71     _disused JSContextRef context(protect); \
  72     _disused JSObjectRef object(protect); \
  73     try
  74 #define CYJavaCatch(value) \
  75     catch (const CYException &error) { \
  76         jni->Throw(CYCastJavaObject(jni, context, error.CastJSValue(context, "Error")).cast<jthrowable>()); \
  77         return value; \
  78     }
  79
  80 static JNIEnv *GetJNI(JSContextRef context);
  81
  82 #define CYJavaForEachPrimitive \
  83     CYJavaForEachPrimitive_(Z, z, Boolean, Boolean, boolean) \
  84     CYJavaForEachPrimitive_(B, b, Byte, Byte, byte) \
  85     CYJavaForEachPrimitive_(C, c, Char, Character, char) \
  86     CYJavaForEachPrimitive_(S, s, Short, Short, short) \
  87     CYJavaForEachPrimitive_(I, i, Int, Integer, int) \
  88     CYJavaForEachPrimitive_(J, j, Long, Long, long) \
  89     CYJavaForEachPrimitive_(F, f, Float, Float, float) \
  90     CYJavaForEachPrimitive_(D, d, Double, Double, double)
  91
  92 enum CYJavaPrimitive : char {
  93     CYJavaPrimitiveObject,
  94     CYJavaPrimitiveVoid,
  95 #define CYJavaForEachPrimitive_(T, t, Typ, Type, type) \
  96     CYJavaPrimitive ## Type,
  97 CYJavaForEachPrimitive
  98 #undef CYJavaForEachPrimitive_
  99 };
 100
 101 template <typename Type_>
 102 struct IsJavaPrimitive { static const bool value = false; };
 103
 104 #define CYJavaForEachPrimitive_(T, t, Typ, Type, type) \
 105     template <> \
 106     struct IsJavaPrimitive<j ## type> { static const bool value = true; };
 107 CYJavaForEachPrimitive
 108 #undef CYJavaForEachPrimitive_
 109
 110 // Java References {{{
 111 template <typename Value_>
 112 struct CYJavaRef {
 113     JNIEnv *jni_;
 114     Value_ value_;
 115
 116     _finline CYJavaRef(JNIEnv *jni, Value_ value) :
 117         jni_(jni),
 118         value_(value)
 119     {
 120     }
 121
 122     _finline operator Value_() const {
 123         return value_;
 124     }
 125
 126     _finline JNIEnv *jni() const {
 127         return jni_;
 128     }
 129
 130     // XXX: this is only needed to support CYJavaEnv relying on C variadics
 131     _finline Value_ get() const {
 132         return value_;
 133     }
 134
 135     template <typename Other_>
 136     _finline CYJavaRef<Other_> cast() const {
 137         return {jni_, static_cast<Other_>(value_)};
 138     }
 139
 140     // XXX: this should be tied into CYJavaFrame
 141     Value_ leak() {
 142         Value_ value(value_);
 143         value_ = NULL;
 144         return value;
 145     }
 146 };
 147
 148 template <typename Value_, void (JNIEnv::*Delete_)(jobject)>
 149 struct CYJavaDelete :
 150     CYJavaRef<Value_>
 151 {
 152     _finline CYJavaDelete(JNIEnv *jni, Value_ value) :
 153         CYJavaRef<Value_>(jni, value)
 154     {
 155     }
 156
 157     void clear() {
 158         if (this->value_ != NULL)
 159             (this->jni_->*Delete_)(this->value_);
 160         this->value_ = NULL;
 161     }
 162
 163     ~CYJavaDelete() {
 164         clear();
 165     }
 166 };
 167
 168 template <typename Value_>
 169 struct CYJavaGlobal :
 170     CYJavaDelete<Value_, &JNIEnv::DeleteGlobalRef>
 171 {
 172     typedef CYJavaDelete<Value_, &JNIEnv::DeleteGlobalRef> CYJavaBase;
 173
 174     CYJavaGlobal() :
 175         CYJavaBase(NULL, NULL)
 176     {
 177     }
 178
 179     template <typename Other_>
 180     CYJavaGlobal(const CYJavaRef<Other_> &other) :
 181         CYJavaBase(other.jni_, static_cast<Other_>(other.jni_->NewGlobalRef(other.value_)))
 182     {
 183     }
 184
 185     CYJavaGlobal(const CYJavaGlobal<Value_> &other) :
 186         CYJavaGlobal(static_cast<const CYJavaRef<Value_> &>(other))
 187     {
 188     }
 189
 190     CYJavaGlobal(CYJavaGlobal &&value) :
 191         CYJavaBase(value.jni_, value.value_)
 192     {
 193         value.value_ = NULL;
 194     }
 195 };
 196
 197 template <typename Value_>
 198 struct CYJavaLocal :
 199     CYJavaDelete<Value_, &JNIEnv::DeleteLocalRef>
 200 {
 201     typedef CYJavaDelete<Value_, &JNIEnv::DeleteLocalRef> CYJavaBase;
 202
 203     CYJavaLocal() :
 204         CYJavaBase(NULL, NULL)
 205     {
 206     }
 207
 208     CYJavaLocal(JNIEnv *jni, Value_ value) :
 209         CYJavaBase(jni, value)
 210     {
 211     }
 212
 213     template <typename Other_>
 214     CYJavaLocal(const CYJavaRef<Other_> &other) :
 215         CYJavaLocal(other.jni_, static_cast<Other_>(other.jni_->NewLocalRef(other.value_)))
 216     {
 217     }
 218
 219     template <typename Other_>
 220     CYJavaLocal(CYJavaRef<Other_> &&other) :
 221         CYJavaLocal(other.jni_, other.value_)
 222     {
 223         other.value_ = NULL;
 224     }
 225
 226     CYJavaLocal(CYJavaLocal &&other) :
 227         CYJavaLocal(static_cast<CYJavaRef<Value_> &&>(other))
 228     {
 229     }
 230
 231     template <typename Other_>
 232     CYJavaLocal &operator =(CYJavaLocal<Other_> &&other) {
 233         this->clear();
 234         this->jni_ = other.jni_;
 235         this->value_ = other.value_;
 236         other.value_ = NULL;
 237         return *this;
 238     }
 239 };
 240 // }}}
 241 // Java Strings {{{
 242 static CYJavaLocal<jstring> CYCastJavaString(const CYJavaRef<jobject> &value);
 243
 244 class CYJavaUTF8String :
 245     public CYUTF8String
 246 {
 247   private:
 248     const CYJavaRef<jstring> *value_;
 249
 250   public:
 251     CYJavaUTF8String(const CYJavaRef<jstring> &value) :
 252         value_(&value)
 253     {
 254         _assert(value);
 255         JNIEnv *jni(value.jni());
 256         size = jni->GetStringUTFLength(value);
 257         data = jni->GetStringUTFChars(value, NULL);
 258     }
 259
 260     CYJavaUTF8String(const CYJavaRef<jobject> &value) :
 261         CYJavaUTF8String(CYCastJavaString(value))
 262     {
 263     }
 264
 265     ~CYJavaUTF8String() {
 266         if (value_ != NULL) {
 267             JNIEnv *jni(value_->jni());
 268             jni->ReleaseStringUTFChars(*value_, data);
 269         }
 270     }
 271
 272     CYJavaUTF8String(const CYJavaUTF8String &) = delete;
 273
 274     CYJavaUTF8String(CYJavaUTF8String &&rhs) :
 275         value_(rhs.value_)
 276     {
 277         rhs.value_ = NULL;
 278     }
 279 };
 280
 281 CYJavaUTF8String CYCastUTF8String(const CYJavaRef<jstring> &value) {
 282     return CYJavaUTF8String(value);
 283 }
 284
 285 JSStringRef CYCopyJSString(const CYJavaRef<jstring> &value) {
 286     return CYCopyJSString(CYCastUTF8String(value));
 287 }
 288 // }}}
 289 // Java Error {{{
 290 struct CYJavaError :
 291     CYException
 292 {
 293     CYJavaGlobal<jthrowable> value_;
 294
 295     CYJavaError(const CYJavaRef<jthrowable> &value) :
 296         value_(value)
 297     {
 298     }
 299
 300     virtual const char *PoolCString(CYPool &pool) const {
 301         return CYPoolCString(pool, CYJavaUTF8String(value_.cast<jobject>()));
 302     }
 303
 304     virtual JSValueRef CastJSValue(JSContextRef context, const char *name) const;
 305 };
 306 // }}}
 307
 308 struct CYJavaFrame {
 309     JNIEnv *jni_;
 310
 311     CYJavaFrame(JNIEnv *jni, jint capacity) :
 312         jni_(jni)
 313     {
 314         _assert(jni->PushLocalFrame(capacity) == 0);
 315     }
 316
 317     ~CYJavaFrame() {
 318         operator ()(NULL);
 319     }
 320
 321     operator JNIEnv *() const {
 322         return jni_;
 323     }
 324
 325     jobject operator ()(jobject object) {
 326         JNIEnv *jni(jni_);
 327         jni_ = NULL;
 328         return jni->PopLocalFrame(object);
 329     }
 330 };
 331
 332 struct CYJavaEnv {
 333   private:
 334     JNIEnv *jni;
 335
 336   public:
 337     CYJavaEnv(JNIEnv *jni) :
 338         jni(jni)
 339     {
 340     }
 341
 342     template <typename Other_>
 343     CYJavaEnv(const CYJavaRef<Other_> &value) :
 344         jni(value.jni())
 345     {
 346     }
 347
 348     operator JNIEnv *() const {
 349         return jni;
 350     }
 351
 352     JNIEnv *operator ->() const {
 353         return jni;
 354     }
 355
 356     CYJavaLocal<jclass> FindClass(const char *name) const {
 357         return {jni, _envcall(jni, FindClass(name))};
 358     }
 359
 360     CYJavaLocal<jclass> GetObjectClass(jobject object) const {
 361         return {jni, _envcall(jni, GetObjectClass(object))};
 362     }
 363
 364     CYJavaLocal<jclass> GetSuperclass(jclass _class) const {
 365         return {jni, _envcall(jni, GetSuperclass(_class))};
 366     }
 367
 368     CYJavaLocal<jobject> NewObject(jclass _class, jmethodID method, ...) const {
 369         va_list args;
 370         va_start(args, method);
 371         jobject object(_envcall(jni, NewObjectV(_class, method, args)));
 372         va_end(args);
 373         return {jni, object};
 374     }
 375
 376     CYJavaLocal<jobject> NewObjectA(jclass _class, jmethodID method, jvalue *args) const {
 377         return {jni, _envcall(jni, NewObjectA(_class, method, args))};
 378     }
 379
 380     CYJavaLocal<jstring> NewString(const jchar *data, jsize size) const {
 381         return {jni, _envcall(jni, NewString(data, size))};
 382     }
 383
 384 #define CYJavaEnv_(Code) \
 385     template <typename... Args_> \
 386     void Code(Args_ &&... args) const { \
 387         _envcallv(jni, Code(cy::Forward<Args_>(args)...)); \
 388     }
 389
 390 #define CYJavaForEachPrimitive_(T, t, Typ, Type, type) \
 391     CYJavaEnv_(Get ## Typ ## ArrayRegion) \
 392     CYJavaEnv_(Set ## Typ ## Field) \
 393     CYJavaEnv_(SetStatic ## Typ ## Field)
 394 CYJavaForEachPrimitive
 395 #undef CYJavaForEachPrimitive_
 396
 397     CYJavaEnv_(CallVoidMethod)
 398     CYJavaEnv_(CallStaticVoidMethod)
 399     CYJavaEnv_(CallVoidMethodA)
 400     CYJavaEnv_(CallStaticVoidMethodA)
 401     CYJavaEnv_(SetObjectArrayElement)
 402     CYJavaEnv_(SetObjectField)
 403     CYJavaEnv_(SetStaticObjectField)
 404 #undef CYJavaEnv_
 405
 406 #define CYJavaEnv_(Code) \
 407     template <typename... Args_> \
 408     auto Code(Args_ &&... args) const -> decltype(jni->Code(cy::Forward<Args_>(args)...)) { \
 409         return _envcall(jni, Code(cy::Forward<Args_>(args)...)); \
 410     }
 411
 412 #define CYJavaForEachPrimitive_(T, t, Typ, Type, type) \
 413     CYJavaEnv_(Call ## Typ ## Method) \
 414     CYJavaEnv_(CallStatic ## Typ ## Method) \
 415     CYJavaEnv_(Call ## Typ ## MethodA) \
 416     CYJavaEnv_(CallStatic ## Typ ## MethodA) \
 417     CYJavaEnv_(Get ## Typ ## Field) \
 418     CYJavaEnv_(GetStatic ## Typ ## Field)
 419 CYJavaForEachPrimitive
 420 #undef CYJavaForEachPrimitive_
 421
 422     CYJavaEnv_(FromReflectedField)
 423     CYJavaEnv_(FromReflectedMethod)
 424     CYJavaEnv_(GetArrayLength)
 425     CYJavaEnv_(GetMethodID)
 426     CYJavaEnv_(GetStaticMethodID)
 427     CYJavaEnv_(IsSameObject)
 428     CYJavaEnv_(RegisterNatives)
 429 #undef CYJavaEnv_
 430
 431 #define CYJavaEnv_(Code) \
 432     template <typename Other_, typename... Args_> \
 433     auto Code(Args_ &&... args) const -> CYJavaLocal<Other_> { \
 434         return {jni, static_cast<Other_>(_envcall(jni, Code(cy::Forward<Args_>(args)...)))}; \
 435     }
 436
 437     CYJavaEnv_(CallObjectMethod)
 438     CYJavaEnv_(CallStaticObjectMethod)
 439     CYJavaEnv_(CallObjectMethodA)
 440     CYJavaEnv_(CallStaticObjectMethodA)
 441     CYJavaEnv_(GetObjectArrayElement)
 442     CYJavaEnv_(GetObjectField)
 443     CYJavaEnv_(GetStaticObjectField)
 444 #undef CYJavaEnv_
 445 };
 446
 447 static CYJavaLocal<jstring> CYCastJavaString(const CYJavaRef<jobject> &value) {
 448     CYJavaEnv jni(value);
 449     auto Object$(jni.FindClass("java/lang/Object"));
 450     auto Object$toString(jni.GetMethodID(Object$, "toString", "()Ljava/lang/String;"));
 451     return jni.CallObjectMethod<jstring>(value, Object$toString);
 452 }
 453
 454 template <typename Internal_, typename Value_>
 455 struct CYJavaValue :
 456     CYPrivate<Internal_>
 457 {
 458     CYJavaGlobal<Value_> value_;
 459
 460     CYJavaValue(const CYJavaRef<Value_> &value) :
 461         value_(value)
 462     {
 463     }
 464
 465     CYJavaValue(const CYJavaValue &) = delete;
 466 };
 467
 468 static JSValueRef CYCastJSValue(JSContextRef context, const CYJavaRef<jobject> &value);
 469
 470 template <typename Other_>
 471 static _finline JSValueRef CYCastJSValue(JSContextRef context, const CYJavaRef<Other_> &value) {
 472     return CYCastJSValue(context, value.template cast<jobject>());
 473 }
 474
 475 template <typename Type_>
 476 static _finline JSValueRef CYJavaCastJSValue(JSContextRef context, Type_ value) {
 477     return CYCastJSValue(context, value);
 478 }
 479
 480 static _finline JSValueRef CYJavaCastJSValue(JSContextRef context, jboolean value) {
 481     return CYCastJSValue(context, static_cast<bool>(value));
 482 }
 483
 484 JSValueRef CYJavaError::CastJSValue(JSContextRef context, const char *name) const {
 485     return CYCastJSValue(context, value_);
 486 }
 487
 488 static std::map<std::string, CYJavaPrimitive> Primitives_;
 489
 490 static CYJavaPrimitive CYJavaGetPrimitive(JSContextRef context, const CYJavaRef<jclass> &type, jmethodID Class$get$$Name) {
 491     CYJavaEnv jni(type);
 492     auto string(jni.CallObjectMethod<jstring>(type, Class$get$$Name));
 493     _assert(string);
 494
 495     CYJavaUTF8String name(string);
 496     auto primitive(Primitives_.find(name));
 497     return primitive != Primitives_.end() ? primitive->second : CYJavaPrimitiveObject;
 498 }
 499
 500 typedef std::vector<CYJavaPrimitive> CYJavaShorty;
 501
 502 static CYJavaShorty CYJavaGetShorty(JSContextRef context, const CYJavaRef<jobjectArray> &types, jmethodID Class$get$$Name) {
 503     CYJavaEnv jni(types);
 504     size_t count(jni.GetArrayLength(types));
 505     CYJavaShorty shorty(count);
 506     for (size_t index(0); index != count; ++index)
 507         shorty[index] = CYJavaGetPrimitive(context, jni.GetObjectArrayElement<jclass>(types, index), Class$get$$Name);
 508     return shorty;
 509 }
 510
 511 struct CYJavaField {
 512     jfieldID field_;
 513     CYJavaPrimitive primitive_;
 514 };
 515
 516 typedef std::map<std::string, CYJavaField> CYJavaFieldMap;
 517
 518 struct CYJavaSignature {
 519     CYJavaGlobal<jobject> reflected_;
 520     jmethodID method_;
 521     CYJavaPrimitive primitive_;
 522     CYJavaShorty shorty_;
 523
 524     CYJavaSignature(const CYJavaRef<jobject> &reflected, jmethodID method, CYJavaPrimitive primitive, const CYJavaShorty &shorty) :
 525         reflected_(reflected),
 526         method_(method),
 527         primitive_(primitive),
 528         shorty_(shorty)
 529     {
 530     }
 531
 532     CYJavaSignature(unsigned count) :
 533         shorty_(count)
 534     {
 535     }
 536
 537     bool operator <(const CYJavaSignature &rhs) const {
 538         return shorty_.size() < rhs.shorty_.size();
 539     }
 540 };
 541
 542 typedef std::multiset<CYJavaSignature> CYJavaOverload;
 543
 544 struct CYJavaMethod :
 545     CYPrivate<CYJavaMethod>
 546 {
 547     CYJavaOverload overload_;
 548
 549     CYJavaMethod(const CYJavaOverload &overload) :
 550         overload_(overload)
 551     {
 552     }
 553 };
 554
 555 struct CYJavaStaticMethod :
 556     CYPrivate<CYJavaStaticMethod>
 557 {
 558     CYJavaOverload overload_;
 559
 560     CYJavaStaticMethod(const CYJavaOverload &overload) :
 561         overload_(overload)
 562     {
 563     }
 564 };
 565
 566 struct CYJavaClass :
 567     CYJavaValue<CYJavaClass, jclass>
 568 {
 569     bool interface_;
 570
 571     CYJavaFieldMap static_;
 572     CYJavaFieldMap instance_;
 573     CYJavaOverload overload_;
 574
 575     CYJavaClass(const CYJavaRef<jclass> &value, bool interface) :
 576         CYJavaValue(value),
 577         interface_(interface)
 578     {
 579     }
 580 };
 581
 582 static JSObjectRef CYGetJavaClass(JSContextRef context, const CYJavaRef<jclass> &_class);
 583
 584 struct CYJavaObject :
 585     CYJavaValue<CYJavaObject, jobject>
 586 {
 587     CYJavaClass *table_;
 588
 589     CYJavaObject(const CYJavaRef<jobject> &value, CYJavaClass *table) :
 590         CYJavaValue(value),
 591         table_(table)
 592     {
 593     }
 594
 595     JSValueRef GetPrototype(JSContextRef context) const;
 596 };
 597
 598 struct CYJavaInterior :
 599     CYJavaValue<CYJavaInterior, jobject>
 600 {
 601     CYJavaClass *table_;
 602
 603     CYJavaInterior(const CYJavaRef<jobject> &value, CYJavaClass *table) :
 604         CYJavaValue(value),
 605         table_(table)
 606     {
 607     }
 608 };
 609
 610 struct CYJavaStaticInterior :
 611     CYJavaValue<CYJavaStaticInterior, jclass>
 612 {
 613     CYJavaClass *table_;
 614
 615     CYJavaStaticInterior(const CYJavaRef<jclass> &value, CYJavaClass *table) :
 616         CYJavaValue(value),
 617         table_(table)
 618     {
 619     }
 620 };
 621
 622 struct CYJavaArray :
 623     CYJavaValue<CYJavaArray, jarray>
 624 {
 625     CYJavaPrimitive primitive_;
 626
 627     CYJavaArray(const CYJavaRef<jarray> &value, CYJavaPrimitive primitive) :
 628         CYJavaValue(value),
 629         primitive_(primitive)
 630     {
 631     }
 632
 633     JSValueRef GetPrototype(JSContextRef context) const;
 634 };
 635
 636 struct CYJavaPackage :
 637     CYPrivate<CYJavaPackage>
 638 {
 639     typedef std::vector<std::string> Path;
 640     Path package_;
 641
 642     _finline CYJavaPackage(const Path &package) :
 643         package_(package)
 644     {
 645     }
 646 };
 647
 648 JSValueRef CYJavaObject::GetPrototype(JSContextRef context) const {
 649     CYJavaEnv jni(value_);
 650     return CYGetProperty(context, CYGetJavaClass(context, jni.GetObjectClass(value_)), prototype_s);
 651 }
 652
 653 JSValueRef CYJavaArray::GetPrototype(JSContextRef context) const {
 654     return CYGetCachedObject(context, CYJSString("Array_prototype"));
 655 }
 656
 657 static JSValueRef CYCastJSValue(JSContextRef context, const CYJavaRef<jobject> &value) {
 658     if (!value)
 659         return CYJSNull(context);
 660     CYJavaEnv jni(value);
 661
 662     auto _class(jni.GetObjectClass(value));
 663     if (jni.IsSameObject(_class, jni.FindClass("java/lang/String")))
 664         return CYCastJSValue(context, CYJSString(value.cast<jstring>()));
 665
 666     auto Class$(jni.FindClass("java/lang/Class"));
 667     auto Class$isArray(jni.GetMethodID(Class$, "isArray", "()Z"));
 668     if (jni.CallBooleanMethod(_class, Class$isArray)) {
 669         auto Class$getComponentType(jni.GetMethodID(Class$, "getComponentType", "()Ljava/lang/Class;"));
 670         auto component(jni.CallObjectMethod<jclass>(_class, Class$getComponentType));
 671         auto Class$getName(jni.GetMethodID(Class$, "getName", "()Ljava/lang/String;"));
 672         return CYJavaArray::Make(context, value.cast<jarray>(), CYJavaGetPrimitive(context, component, Class$getName));
 673     }
 674
 675     auto Wrapper$(jni.FindClass("Cycript$Wrapper"));
 676     if (jni.IsSameObject(_class, Wrapper$)) {
 677         auto Wrapper$getProtect(jni.GetMethodID(Wrapper$, "getProtect", "()J"));
 678         auto &protect(*reinterpret_cast<CYProtect *>(jni.CallLongMethod(value, Wrapper$getProtect)));
 679         return protect;
 680     }
 681
 682     CYJavaClass *table(reinterpret_cast<CYJavaClass *>(JSObjectGetPrivate(CYGetJavaClass(context, _class))));
 683     return CYJavaObject::Make(context, value, table);
 684 }
 685
 686 static _finline JSObjectRef CYCastJSObject(JSContextRef context, const CYJavaRef<jobject> &value) {
 687     return CYCastJSObject(context, CYCastJSValue(context, value));
 688 }
 689
 690 static CYJavaLocal<jstring> CYCastJavaString(const CYJavaEnv &jni, JSContextRef context, CYUTF16String value) {
 691     return jni.NewString(value.data, value.size);
 692 }
 693
 694 static CYJavaLocal<jstring> CYCastJavaString(const CYJavaEnv &jni, JSContextRef context, JSStringRef value) {
 695     return CYCastJavaString(jni, context, CYCastUTF16String(value));
 696 }
 697
 698 #define CYCastJava$(T, Type, jtype, Cast) \
 699 _disused static CYJavaLocal<jobject> CYCastJava ## Type(const CYJavaEnv &jni, JSContextRef context, JSValueRef value) { \
 700     auto Type$(jni.FindClass("java/lang/" #Type)); \
 701     auto Type$init$(jni.GetMethodID(Type$, "<init>", "(" #T ")V")); \
 702     return jni.NewObject(Type$, Type$init$, static_cast<jtype>(Cast(context, value))); \
 703 }
 704
 705 CYCastJava$(Z, Boolean, jboolean, CYCastBool)
 706 CYCastJava$(B, Byte, jbyte, CYCastDouble)
 707 CYCastJava$(C, Character, jchar, CYCastDouble)
 708 CYCastJava$(S, Short, jshort, CYCastDouble)
 709 CYCastJava$(I, Integer, jint, CYCastDouble)
 710 CYCastJava$(J, Long, jlong, CYCastDouble)
 711 CYCastJava$(F, Float, jfloat, CYCastDouble)
 712 CYCastJava$(D, Double, jdouble, CYCastDouble)
 713
 714 static CYJavaClass *CYGetJavaTable(JSContextRef context, JSObjectRef object) {
 715     if (!JSValueIsObjectOfClass(context, object, CYJavaClass::Class_))
 716         return NULL;
 717     return reinterpret_cast<CYJavaClass *>(JSObjectGetPrivate(object));
 718 }
 719
 720 static CYJavaObject *CYGetJavaObject(JSContextRef context, JSObjectRef object) {
 721     if (!JSValueIsObjectOfClass(context, object, CYJavaObject::Class_))
 722         return NULL;
 723     return reinterpret_cast<CYJavaObject *>(JSObjectGetPrivate(object));
 724 }
 725
 726 static CYJavaLocal<jobject> CYCastJavaObject(const CYJavaEnv &jni, JSContextRef context, JSObjectRef value) {
 727     if (CYJavaObject *internal = CYGetJavaObject(context, value))
 728         return internal->value_;
 729
 730     auto Wrapper$(jni.FindClass("Cycript$Wrapper"));
 731     auto Wrapper$$init$(jni.GetMethodID(Wrapper$, "<init>", "(J)V"));
 732     CYProtect *protect(new CYProtect(context, value));
 733     return jni.NewObject(Wrapper$, Wrapper$$init$, reinterpret_cast<jlong>(protect));
 734 }
 735
 736 static CYJavaLocal<jobject> CYCastJavaObject(const CYJavaEnv &jni, JSContextRef context, JSValueRef value) {
 737     switch (JSValueGetType(context, value)) {
 738         case kJSTypeNull:
 739             return {jni, NULL};
 740         case kJSTypeBoolean:
 741             return CYCastJavaBoolean(jni, context, value);
 742         case kJSTypeNumber:
 743             return CYCastJavaDouble(jni, context, value);
 744         case kJSTypeString:
 745             return CYCastJavaString(jni, context, CYJSString(context, value));
 746         case kJSTypeObject:
 747             return CYCastJavaObject(jni, context, CYCastJSObject(context, value));
 748
 749         case kJSTypeUndefined:
 750             // XXX: I am currently relying on this for dynamic proxy of void method
 751             return {jni, NULL};
 752         default:
 753             _assert(false);
 754     }
 755 }
 756
 757 static JSObjectRef CYGetJavaClass(JSContextRef context, const CYJavaRef<jclass> &value) {
 758     CYJavaEnv jni(value);
 759     CYJavaFrame frame(jni, 64);
 760
 761     JSObjectRef global(CYGetGlobalObject(context));
 762     JSObjectRef cy(CYCastJSObject(context, CYGetProperty(context, global, cy_s)));
 763
 764     auto Class$(jni.FindClass("java/lang/Class"));
 765     auto Class$getName(jni.GetMethodID(Class$, "getName", "()Ljava/lang/String;"));
 766
 767     CYJSString name(jni.CallObjectMethod<jstring>(value, Class$getName));
 768     JSValueRef cached(CYGetProperty(context, cy, name));
 769     if (!JSValueIsUndefined(context, cached))
 770         return CYCastJSObject(context, cached);
 771
 772     JSObjectRef constructor;
 773     JSObjectRef prototype;
 774
 775     {
 776
 777     auto Class$isInterface(jni.GetMethodID(Class$, "isInterface", "()Z"));
 778
 779     auto Class$getDeclaredConstructors(jni.GetMethodID(Class$, "getDeclaredConstructors", "()[Ljava/lang/reflect/Constructor;"));
 780     auto Class$getDeclaredFields(jni.GetMethodID(Class$, "getDeclaredFields", "()[Ljava/lang/reflect/Field;"));
 781     auto Class$getDeclaredMethods(jni.GetMethodID(Class$, "getDeclaredMethods", "()[Ljava/lang/reflect/Method;"));
 782
 783     auto Constructor$(jni.FindClass("java/lang/reflect/Constructor"));
 784     //auto Constructor$getModifiers(jni.GetMethodID(Constructor$, "getModifiers", "()I"));
 785     auto Constructor$getParameterTypes(jni.GetMethodID(Constructor$, "getParameterTypes", "()[Ljava/lang/Class;"));
 786
 787     auto Field$(jni.FindClass("java/lang/reflect/Field"));
 788     auto Field$getModifiers(jni.GetMethodID(Field$, "getModifiers", "()I"));
 789     auto Field$getName(jni.GetMethodID(Field$, "getName", "()Ljava/lang/String;"));
 790     auto Field$getType(jni.GetMethodID(Field$, "getType", "()Ljava/lang/Class;"));
 791
 792     auto Method$(jni.FindClass("java/lang/reflect/Method"));
 793     auto Method$getModifiers(jni.GetMethodID(Method$, "getModifiers", "()I"));
 794     auto Method$getName(jni.GetMethodID(Method$, "getName", "()Ljava/lang/String;"));
 795     auto Method$getParameterTypes(jni.GetMethodID(Method$, "getParameterTypes", "()[Ljava/lang/Class;"));
 796     auto Method$getReturnType(jni.GetMethodID(Method$, "getReturnType", "()Ljava/lang/Class;"));
 797
 798     auto Modifier$(jni.FindClass("java/lang/reflect/Modifier"));
 799     auto Modifier$isStatic(jni.GetStaticMethodID(Modifier$, "isStatic", "(I)Z"));
 800
 801     auto interface(jni.CallBooleanMethod(value, Class$isInterface));
 802     auto table(new CYJavaClass(value, interface));
 803
 804     for (CYJavaLocal<jclass> prototype(value); prototype; prototype = jni.GetSuperclass(prototype)) {
 805         auto fields(jni.CallObjectMethod<jobjectArray>(prototype, Class$getDeclaredFields));
 806
 807         for (jsize i(0), e(jni.GetArrayLength(fields)); i != e; ++i) {
 808             auto field(jni.GetObjectArrayElement<jobject>(fields, e - i - 1));
 809             auto modifiers(jni.CallIntMethod(field, Field$getModifiers));
 810             auto instance(!jni.CallStaticBooleanMethod(Modifier$, Modifier$isStatic, modifiers));
 811             auto &map(instance ? table->instance_ : table->static_);
 812             CYJavaUTF8String name(jni.CallObjectMethod<jstring>(field, Field$getName));
 813             auto id(jni.FromReflectedField(field));
 814             auto type(jni.CallObjectMethod<jclass>(field, Field$getType));
 815             map.insert(std::make_pair(std::string(name), CYJavaField{id, CYJavaGetPrimitive(context, type, Class$getName)}));
 816         }
 817     }
 818
 819     constructor = JSObjectMake(context, CYJavaClass::Class_, table);
 820
 821     prototype = JSObjectMake(context, NULL, NULL);
 822     CYSetProperty(context, constructor, prototype_s, prototype, kJSPropertyAttributeDontEnum);
 823
 824     auto constructors(jni.CallObjectMethod<jobjectArray>(value, Class$getDeclaredConstructors));
 825
 826     for (jsize i(0), e(jni.GetArrayLength(constructors)); i != e; ++i) {
 827         auto constructor(jni.GetObjectArrayElement<jobject>(constructors, i));
 828         auto parameters(jni.CallObjectMethod<jobjectArray>(constructor, Constructor$getParameterTypes));
 829         CYJavaShorty shorty(CYJavaGetShorty(context, parameters, Class$getName));
 830         auto id(jni.FromReflectedMethod(constructor));
 831         table->overload_.insert(CYJavaSignature(constructor, id, CYJavaPrimitiveObject, shorty));
 832     }
 833
 834     auto methods(jni.CallObjectMethod<jobjectArray>(value, Class$getDeclaredMethods));
 835
 836     std::map<std::pair<bool, std::string>, CYJavaOverload> entries;
 837
 838     for (jsize i(0), e(jni.GetArrayLength(methods)); i != e; ++i) {
 839         auto method(jni.GetObjectArrayElement<jobject>(methods, i));
 840         auto modifiers(jni.CallIntMethod(method, Method$getModifiers));
 841         auto instance(!jni.CallStaticBooleanMethod(Modifier$, Modifier$isStatic, modifiers));
 842         CYJavaUTF8String name(jni.CallObjectMethod<jstring>(method, Method$getName));
 843         auto parameters(jni.CallObjectMethod<jobjectArray>(method, Method$getParameterTypes));
 844         CYJavaShorty shorty(CYJavaGetShorty(context, parameters, Class$getName));
 845         auto type(jni.CallObjectMethod<jclass>(method, Method$getReturnType));
 846         auto primitive(CYJavaGetPrimitive(context, type, Class$getName));
 847         auto id(jni.FromReflectedMethod(method));
 848         entries[std::make_pair(instance, std::string(name))].insert(CYJavaSignature(method, id, primitive, shorty));
 849     }
 850
 851     for (const auto &entry : entries) {
 852         bool instance(entry.first.first);
 853         CYJSString name(entry.first.second);
 854         auto &overload(entry.second);
 855         if (instance)
 856             CYSetProperty(context, prototype, name, CYJavaMethod::Make(context, overload), kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete);
 857         else
 858             CYSetProperty(context, constructor, name, CYJavaStaticMethod::Make(context, overload), kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete);
 859     }
 860
 861     }
 862
 863     // XXX: for some reason kJSPropertyAttributeDontEnum doesn't work if there's already a property with the same name
 864     // by not linking the prototypes until after we set the properties, we hide the parent property from this issue :(
 865
 866     if (auto super = jni.GetSuperclass(value)) {
 867         JSObjectRef parent(CYGetJavaClass(context, super));
 868         CYSetPrototype(context, constructor, parent);
 869         CYSetPrototype(context, prototype, CYGetProperty(context, parent, prototype_s));
 870     }
 871
 872     CYSetProperty(context, cy, name, constructor);
 873     return constructor;
 874 }
 875
 876 static void CYCastJavaNumeric(jvalue &value, CYJavaPrimitive primitive, JSContextRef context, JSValueRef argument) {
 877     switch (primitive) {
 878 #define CYJavaForEachPrimitive_(T, t, Typ, Type, type) \
 879         case CYJavaPrimitive ## Type: \
 880             value.t = static_cast<j ## type>(CYCastDouble(context, argument)); \
 881             break;
 882 CYJavaForEachPrimitive
 883 #undef CYJavaForEachPrimitive_
 884         default:
 885             _assert(false);
 886     }
 887 }
 888
 889 static bool CYCastJavaArguments(const CYJavaFrame &frame, const CYJavaShorty &shorty, JSContextRef context, const JSValueRef arguments[], jvalue *array) {
 890     CYJavaEnv jni(frame);
 891
 892     for (size_t index(0); index != shorty.size(); ++index) {
 893         JSValueRef argument(arguments[index]);
 894         JSType type(JSValueGetType(context, argument));
 895         jvalue &value(array[index]);
 896
 897         switch (CYJavaPrimitive primitive = shorty[index]) {
 898             case CYJavaPrimitiveObject:
 899                 // XXX: figure out a way to tie this in to the CYJavaFrame
 900                 value.l = CYCastJavaObject(jni, context, argument).leak();
 901             break;
 902
 903             case CYJavaPrimitiveBoolean:
 904                 if (type != kJSTypeBoolean)
 905                     return false;
 906                 value.z = CYCastBool(context, argument);
 907             break;
 908
 909             case CYJavaPrimitiveCharacter:
 910                 if (type == kJSTypeNumber)
 911                     CYCastJavaNumeric(value, primitive, context, argument);
 912                 else if (type != kJSTypeString)
 913                     return false;
 914                 else {
 915                     CYJSString string(context, argument);
 916                     if (JSStringGetLength(string) != 1)
 917                         return false;
 918                     else
 919                         value.c = JSStringGetCharactersPtr(string)[0];
 920                 }
 921             break;
 922
 923             case CYJavaPrimitiveByte:
 924             case CYJavaPrimitiveShort:
 925             case CYJavaPrimitiveInteger:
 926             case CYJavaPrimitiveLong:
 927             case CYJavaPrimitiveFloat:
 928             case CYJavaPrimitiveDouble:
 929                 if (type != kJSTypeNumber)
 930                     return false;
 931                 CYCastJavaNumeric(value, primitive, context, argument);
 932             break;
 933
 934             default:
 935                 _assert(false);
 936         }
 937     }
 938
 939     return true;
 940 }
 941
 942 static JSValueRef JavaMethod_callAsFunction(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
 943     CYJavaMethod *internal(reinterpret_cast<CYJavaMethod *>(JSObjectGetPrivate(object)));
 944     CYJavaObject *self(CYGetJavaObject(context, _this));
 945     CYJavaEnv jni(self->value_);
 946
 947     CYJavaSignature bound(count);
 948     for (auto overload(internal->overload_.lower_bound(bound)), e(internal->overload_.upper_bound(bound)); overload != e; ++overload) {
 949         CYJavaFrame frame(jni, count + 16);
 950         jvalue array[count];
 951         if (!CYCastJavaArguments(frame, overload->shorty_, context, arguments, array))
 952             continue;
 953         jvalue *values(array);
 954         switch (overload->primitive_) {
 955             case CYJavaPrimitiveObject:
 956                 return CYCastJSValue(context, jni.CallObjectMethodA<jobject>(self->value_, overload->method_, values));
 957             case CYJavaPrimitiveVoid:
 958                 jni.CallVoidMethodA(self->value_, overload->method_, values);
 959                 return CYJSUndefined(context);
 960 #define CYJavaForEachPrimitive_(T, t, Typ, Type, type) \
 961             case CYJavaPrimitive ## Type: \
 962                 return CYJavaCastJSValue(context, jni.Call ## Typ ## MethodA(self->value_, overload->method_, values));
 963 CYJavaForEachPrimitive
 964 #undef CYJavaForEachPrimitive_
 965             default: _assert(false);
 966         }
 967     }
 968
 969     CYThrow("invalid method call");
 970 } CYCatch(NULL) }
 971
 972 static JSValueRef JavaStaticMethod_callAsFunction(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
 973     CYJavaMethod *internal(reinterpret_cast<CYJavaMethod *>(JSObjectGetPrivate(object)));
 974     CYJavaClass *table(CYGetJavaTable(context, _this));
 975     CYJavaEnv jni(table->value_);
 976
 977     CYJavaSignature bound(count);
 978     for (auto overload(internal->overload_.lower_bound(bound)), e(internal->overload_.upper_bound(bound)); overload != e; ++overload) {
 979         CYJavaFrame frame(jni, count + 16);
 980         jvalue array[count];
 981         if (!CYCastJavaArguments(frame, overload->shorty_, context, arguments, array))
 982             continue;
 983         jvalue *values(array);
 984         switch (overload->primitive_) {
 985             case CYJavaPrimitiveObject:
 986                 return CYCastJSValue(context, jni.CallStaticObjectMethodA<jobject>(table->value_, overload->method_, values));
 987             case CYJavaPrimitiveVoid:
 988                 jni.CallStaticVoidMethodA(table->value_, overload->method_, values);
 989                 return CYJSUndefined(context);
 990 #define CYJavaForEachPrimitive_(T, t, Typ, Type, type) \
 991             case CYJavaPrimitive ## Type: \
 992                 return CYJavaCastJSValue(context, jni.CallStatic ## Typ ## MethodA(table->value_, overload->method_, values));
 993 CYJavaForEachPrimitive
 994 #undef CYJavaForEachPrimitive_
 995             default: _assert(false);
 996         }
 997     }
 998
 999     CYThrow("invalid method call");
1000 } CYCatch(NULL) }
1001
1002 static JSObjectRef JavaClass_callAsConstructor(JSContextRef context, JSObjectRef object, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
1003     CYJavaClass *table(reinterpret_cast<CYJavaClass *>(JSObjectGetPrivate(object)));
1004     CYJavaEnv jni(table->value_);
1005     jclass _class(table->value_);
1006
1007     if (table->interface_ && count == 1) {
1008         auto Cycript$(jni.FindClass("Cycript"));
1009         auto Cycript$Make(jni.GetStaticMethodID(Cycript$, "proxy", "(Ljava/lang/Class;LCycript$Wrapper;)Ljava/lang/Object;"));
1010         return CYCastJSObject(context, jni.CallObjectMethod<jobject>(Cycript$, Cycript$Make, _class, CYCastJavaObject(jni, context, CYCastJSObject(context, arguments[0])).get()));
1011     }
1012
1013     CYJavaSignature bound(count);
1014     for (auto overload(table->overload_.lower_bound(bound)), e(table->overload_.upper_bound(bound)); overload != e; ++overload) {
1015         CYJavaFrame frame(jni, count + 16);
1016         jvalue array[count];
1017         if (!CYCastJavaArguments(frame, overload->shorty_, context, arguments, array))
1018             continue;
1019         jvalue *values(array);
1020         auto object(jni.NewObjectA(_class, overload->method_, values));
1021         return CYCastJSObject(context, object);
1022     }
1023
1024     CYThrow("invalid constructor call");
1025 } CYCatch(NULL) }
1026
1027 static bool JavaStaticInterior_hasProperty(JSContextRef context, JSObjectRef object, JSStringRef property) {
1028     CYJavaStaticInterior *internal(reinterpret_cast<CYJavaStaticInterior *>(JSObjectGetPrivate(object)));
1029     CYJavaClass *table(internal->table_);
1030     CYPool pool;
1031     auto name(CYPoolUTF8String(pool, context, property));
1032     auto field(table->static_.find(name));
1033     if (field == table->static_.end())
1034         return false;
1035     return true;
1036 }
1037
1038 static JSValueRef JavaStaticInterior_getProperty(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { CYTry {
1039     CYJavaStaticInterior *internal(reinterpret_cast<CYJavaStaticInterior *>(JSObjectGetPrivate(object)));
1040     CYJavaClass *table(internal->table_);
1041     CYJavaEnv jni(table->value_);
1042     CYPool pool;
1043     auto name(CYPoolUTF8String(pool, context, property));
1044     auto field(table->static_.find(name));
1045     if (field == table->static_.end())
1046         return NULL;
1047
1048     switch (field->second.primitive_) {
1049         case CYJavaPrimitiveObject:
1050             return CYCastJSValue(context, jni.GetStaticObjectField<jobject>(table->value_, field->second.field_));
1051 #define CYJavaForEachPrimitive_(T, t, Typ, Type, type) \
1052         case CYJavaPrimitive ## Type: \
1053             return CYJavaCastJSValue(context, jni.GetStatic ## Typ ## Field(table->value_, field->second.field_));
1054 CYJavaForEachPrimitive
1055 #undef CYJavaForEachPrimitive_
1056         default: _assert(false);
1057     }
1058 } CYCatch(NULL) }
1059
1060 static bool JavaStaticInterior_setProperty(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef value, JSValueRef *exception) { CYTry {
1061     CYJavaStaticInterior *internal(reinterpret_cast<CYJavaStaticInterior *>(JSObjectGetPrivate(object)));
1062     CYJavaClass *table(internal->table_);
1063     CYJavaEnv jni(table->value_);
1064     CYPool pool;
1065     auto name(CYPoolUTF8String(pool, context, property));
1066     auto field(table->static_.find(name));
1067     if (field == table->static_.end())
1068         return false;
1069
1070     switch (field->second.primitive_) {
1071         case CYJavaPrimitiveObject:
1072             jni.SetStaticObjectField(table->value_, field->second.field_, CYCastJavaObject(jni, context, value));
1073 #define CYJavaForEachPrimitive_(T, t, Typ, Type, type) \
1074         case CYJavaPrimitive ## Type: \
1075             jni.SetStatic ## Typ ## Field(table->value_, field->second.field_, CYCastDouble(context, value)); \
1076             break;
1077 CYJavaForEachPrimitive
1078 #undef CYJavaForEachPrimitive_
1079         default: _assert(false);
1080     }
1081
1082     return true;
1083 } CYCatch(false) }
1084
1085 static void JavaStaticInterior_getPropertyNames(JSContextRef context, JSObjectRef object, JSPropertyNameAccumulatorRef names) {
1086     CYJavaStaticInterior *internal(reinterpret_cast<CYJavaStaticInterior *>(JSObjectGetPrivate(object)));
1087     CYJavaClass *table(internal->table_);
1088     for (const auto &field : table->static_)
1089         JSPropertyNameAccumulatorAddName(names, CYJSString(field.first));
1090 }
1091
1092 static JSValueRef JavaClass_getProperty_class(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { CYTry {
1093     CYJavaClass *table(reinterpret_cast<CYJavaClass *>(JSObjectGetPrivate(object)));
1094     return CYCastJSValue(context, table->value_);
1095 } CYCatch(NULL) }
1096
1097 static bool JavaInterior_hasProperty(JSContextRef context, JSObjectRef object, JSStringRef property) {
1098     CYJavaInterior *internal(reinterpret_cast<CYJavaInterior *>(JSObjectGetPrivate(object)));
1099     CYJavaClass *table(internal->table_);
1100     CYPool pool;
1101     auto name(CYPoolUTF8String(pool, context, property));
1102     auto field(table->instance_.find(name));
1103     if (field == table->instance_.end())
1104         return false;
1105     return true;
1106 }
1107
1108 static JSValueRef JavaInterior_getProperty(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { CYTry {
1109     CYJavaInterior *internal(reinterpret_cast<CYJavaInterior *>(JSObjectGetPrivate(object)));
1110     CYJavaEnv jni(internal->value_);
1111     CYJavaClass *table(internal->table_);
1112     CYPool pool;
1113     auto name(CYPoolUTF8String(pool, context, property));
1114     auto field(table->instance_.find(name));
1115     if (field == table->instance_.end())
1116         return NULL;
1117
1118     switch (field->second.primitive_) {
1119         case CYJavaPrimitiveObject:
1120             return CYCastJSValue(context, jni.GetObjectField<jobject>(internal->value_, field->second.field_));
1121 #define CYJavaForEachPrimitive_(T, t, Typ, Type, type) \
1122         case CYJavaPrimitive ## Type: \
1123             return CYJavaCastJSValue(context, jni.Get ## Typ ## Field(internal->value_, field->second.field_));
1124 CYJavaForEachPrimitive
1125 #undef CYJavaForEachPrimitive_
1126         default: _assert(false);
1127     }
1128 } CYCatch(NULL) }
1129
1130 static bool JavaInterior_setProperty(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef value, JSValueRef *exception) { CYTry {
1131     CYJavaInterior *internal(reinterpret_cast<CYJavaInterior *>(JSObjectGetPrivate(object)));
1132     CYJavaEnv jni(internal->value_);
1133     CYJavaClass *table(internal->table_);
1134     CYPool pool;
1135     auto name(CYPoolUTF8String(pool, context, property));
1136     auto field(table->instance_.find(name));
1137     if (field == table->instance_.end())
1138         return false;
1139
1140     switch (field->second.primitive_) {
1141         case CYJavaPrimitiveObject:
1142             jni.SetObjectField(table->value_, field->second.field_, CYCastJavaObject(jni, context, value));
1143 #define CYJavaForEachPrimitive_(T, t, Typ, Type, type) \
1144         case CYJavaPrimitive ## Type: \
1145             jni.Set ## Typ ## Field(table->value_, field->second.field_, CYCastDouble(context, value)); \
1146             break;
1147 CYJavaForEachPrimitive
1148 #undef CYJavaForEachPrimitive_
1149         default: _assert(false);
1150     }
1151
1152     return true;
1153 } CYCatch(false) }
1154
1155 static void JavaInterior_getPropertyNames(JSContextRef context, JSObjectRef object, JSPropertyNameAccumulatorRef names) {
1156     CYJavaInterior *internal(reinterpret_cast<CYJavaInterior *>(JSObjectGetPrivate(object)));
1157     CYJavaClass *table(internal->table_);
1158     for (const auto &field : table->instance_)
1159         JSPropertyNameAccumulatorAddName(names, CYJSString(field.first));
1160 }
1161
1162 static JSValueRef JavaObject_getProperty_constructor(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { CYTry {
1163     CYJavaObject *internal(reinterpret_cast<CYJavaObject *>(JSObjectGetPrivate(object)));
1164     CYJavaEnv jni(internal->value_);
1165     return CYGetJavaClass(context, jni.GetObjectClass(internal->value_));
1166 } CYCatch(NULL) }
1167
1168 static JSValueRef JavaClass_getProperty_$cyi(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { CYTry {
1169     CYJavaClass *internal(reinterpret_cast<CYJavaClass *>(JSObjectGetPrivate(object)));
1170     return CYJavaStaticInterior::Make(context, internal->value_, internal);
1171 } CYCatch(NULL) }
1172
1173 static JSValueRef JavaObject_getProperty_$cyi(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { CYTry {
1174     CYJavaObject *internal(reinterpret_cast<CYJavaObject *>(JSObjectGetPrivate(object)));
1175     return CYJavaInterior::Make(context, internal->value_, internal->table_);
1176 } CYCatch(NULL) }
1177
1178 static JSValueRef JavaClass_callAsFunction_toCYON(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
1179     CYJavaClass *internal(reinterpret_cast<CYJavaClass *>(JSObjectGetPrivate(_this)));
1180     CYJavaEnv jni(internal->value_);
1181     auto Class$(jni.FindClass("java/lang/Class"));
1182     auto Class$getCanonicalName(jni.GetMethodID(Class$, "getCanonicalName", "()Ljava/lang/String;"));
1183     return CYCastJSValue(context, CYJSString(jni.CallObjectMethod<jstring>(internal->value_, Class$getCanonicalName)));
1184 } CYCatch(NULL) }
1185
1186 static JSValueRef JavaMethod_callAsFunction_toCYON(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
1187     std::ostringstream cyon;
1188     return CYCastJSValue(context, CYJSString(cyon.str()));
1189 } CYCatch(NULL) }
1190
1191 static JSValueRef JavaStaticMethod_callAsFunction_toCYON(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
1192     std::ostringstream cyon;
1193     return CYCastJSValue(context, CYJSString(cyon.str()));
1194 } CYCatch(NULL) }
1195
1196 static JSValueRef JavaArray_getProperty(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { CYTry {
1197     CYJavaArray *internal(reinterpret_cast<CYJavaArray *>(JSObjectGetPrivate(object)));
1198     CYJavaEnv jni(internal->value_);
1199     if (JSStringIsEqual(property, length_s))
1200         return CYCastJSValue(context, jni.GetArrayLength(internal->value_));
1201
1202     CYPool pool;
1203     ssize_t offset;
1204     if (!CYGetOffset(pool, context, property, offset))
1205         return NULL;
1206
1207     if (internal->primitive_ == CYJavaPrimitiveObject)
1208         return CYCastJSValue(context, jni.GetObjectArrayElement<jobject>(static_cast<jobjectArray>(internal->value_.value_), offset));
1209     else switch (internal->primitive_) {
1210 #define CYJavaForEachPrimitive_(T, t, Typ, Type, type) \
1211         case CYJavaPrimitive ## Type: { \
1212             j ## type element; \
1213             jni.Get ## Typ ## ArrayRegion(static_cast<j ## type ## Array>(internal->value_.value_), offset, 1, &element); \
1214             return CYJavaCastJSValue(context, element); \
1215         } break;
1216 CYJavaForEachPrimitive
1217 #undef CYJavaForEachPrimitive_
1218         default: _assert(false);
1219     }
1220 } CYCatch(NULL) }
1221
1222 static bool JavaArray_setProperty(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef value, JSValueRef *exception) { CYTry {
1223     CYJavaArray *internal(reinterpret_cast<CYJavaArray *>(JSObjectGetPrivate(object)));
1224     CYJavaEnv jni(internal->value_);
1225
1226     CYPool pool;
1227     ssize_t offset;
1228     if (!CYGetOffset(pool, context, property, offset))
1229         return false;
1230
1231     if (internal->primitive_ == CYJavaPrimitiveObject)
1232         jni.SetObjectArrayElement(static_cast<jobjectArray>(internal->value_.value_), offset, CYCastJavaObject(jni, context, value));
1233     else switch (internal->primitive_) {
1234 #define CYJavaForEachPrimitive_(T, t, Typ, Type, type) \
1235         case CYJavaPrimitive ## Type: { \
1236             j ## type element; \
1237             jni.Get ## Typ ## ArrayRegion(static_cast<j ## type ## Array>(internal->value_.value_), offset, 1, &element); \
1238             return CYJavaCastJSValue(context, element); \
1239         } break;
1240 CYJavaForEachPrimitive
1241 #undef CYJavaForEachPrimitive_
1242         default: _assert(false);
1243     }
1244
1245     return true;
1246 } CYCatch(false) }
1247
1248 static JSValueRef JavaPackage_callAsFunction_toCYON(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
1249     CYJavaPackage *internal(reinterpret_cast<CYJavaPackage *>(JSObjectGetPrivate(_this)));
1250     std::ostringstream name;
1251     for (auto &package : internal->package_)
1252         name << package << '.';
1253     name << '*';
1254     return CYCastJSValue(context, CYJSString(name.str()));
1255 } CYCatch(NULL) }
1256
1257 static bool CYJavaPackage_hasProperty(JSContextRef context, JSObjectRef object, JSStringRef property) {
1258     return true;
1259 }
1260
1261 static JSValueRef CYJavaPackage_getProperty(JSContextRef context, JSObjectRef object, JSStringRef property, JSValueRef *exception) { CYTry {
1262     CYJavaPackage *internal(reinterpret_cast<CYJavaPackage *>(JSObjectGetPrivate(object)));
1263     CYJavaPackage::Path package(internal->package_);
1264
1265     CYPool pool;
1266     const char *next(CYPoolCString(pool, context, property));
1267
1268     std::ostringstream name;
1269     for (auto &package : internal->package_)
1270         name << package << '/';
1271     name << next;
1272
1273     JNIEnv *jni(GetJNI(context));
1274     if (auto _class = jni->FindClass(name.str().c_str()))
1275         return CYGetJavaClass(context, CYJavaLocal<jclass>(jni, _class));
1276     jni->ExceptionClear();
1277
1278     package.push_back(next);
1279     return CYJavaPackage::Make(context, package);
1280 } CYCatch(NULL) }
1281
1282 static void Cycript_delete(JNIEnv *env, jclass api, jlong jprotect) { CYJavaTry {
1283     delete &protect;
1284 } CYJavaCatch() }
1285
1286 static jobject Cycript_handle(JNIEnv *env, jclass api, jlong jprotect, jstring property, jobjectArray jarguments) { CYJavaTry {
1287     JSValueRef function(CYGetProperty(context, object, CYJSString(CYJavaRef<jstring>(jni, property))));
1288     if (JSValueIsUndefined(context, function))
1289         return NULL;
1290
1291     size_t count(jarguments == NULL ? 0 : jni.GetArrayLength(jarguments));
1292     JSValueRef arguments[count];
1293     for (size_t index(0); index != count; ++index)
1294         arguments[index] = CYCastJSValue(context, jni.GetObjectArrayElement<jobject>(jarguments, index));
1295
1296     return CYCastJavaObject(jni, context, CYCallAsFunction(context, CYCastJSObject(context, function), object, count, arguments)).leak();
1297 } CYJavaCatch(NULL) }
1298
1299 static JNINativeMethod Cycript_[] = {
1300     {(char *) "delete", (char *) "(J)V", (void *) &Cycript_delete},
1301     {(char *) "handle", (char *) "(JLjava/lang/String;[Ljava/lang/Object;)Ljava/lang/Object;", (void *) &Cycript_handle},
1302 };
1303
1304 template <typename Type_>
1305 static _finline void dlset(Type_ &function, const char *name, void *handle) {
1306     function = reinterpret_cast<Type_>(dlsym(handle, name));
1307 }
1308
1309 jint CYJavaVersion(JNI_VERSION_1_4);
1310
1311 static JNIEnv *CYGetCreatedJava(jint (*$JNI_GetCreatedJavaVMs)(JavaVM **, jsize, jsize *)) {
1312     jsize capacity(16);
1313     JavaVM *jvms[capacity];
1314     jsize size;
1315     _jnicall($JNI_GetCreatedJavaVMs(jvms, capacity, &size));
1316     if (size == 0)
1317         return NULL;
1318     JavaVM *jvm(jvms[0]);
1319     JNIEnv *jni;
1320     _jnicall(jvm->GetEnv(reinterpret_cast<void **>(&jni), CYJavaVersion));
1321     return jni;
1322 }
1323
1324 static JNIEnv *GetJNI_(JSContextRef context) {
1325     static JavaVM *jvm(NULL);
1326     static JNIEnv *jni(NULL);
1327
1328     if (jni != NULL)
1329         return jni;
1330
1331     CYPool pool;
1332     void *handle(RTLD_DEFAULT);
1333     std::string library;
1334
1335     jint (*$JNI_GetCreatedJavaVMs)(JavaVM **jvms, jsize capacity, jsize *size);
1336     dlset($JNI_GetCreatedJavaVMs, "JNI_GetCreatedJavaVMs", handle);
1337
1338     if ($JNI_GetCreatedJavaVMs != NULL) {
1339         if (JNIEnv *jni = CYGetCreatedJava($JNI_GetCreatedJavaVMs))
1340             return jni;
1341     } else {
1342         std::vector<const char *> guesses;
1343
1344 #ifdef __ANDROID__
1345         char android[PROP_VALUE_MAX];
1346         if (__system_property_get("persist.sys.dalvik.vm.lib", android) != 0)
1347             guesses.push_back(android);
1348 #endif
1349
1350         guesses.push_back("libart.so");
1351         guesses.push_back("libdvm.so");
1352         guesses.push_back("libjvm.so");
1353
1354         for (const char *guess : guesses) {
1355             handle = dlopen(guess, RTLD_LAZY | RTLD_GLOBAL);
1356             if (handle != NULL) {
1357                 library = guess;
1358                 break;
1359             }
1360         }
1361
1362         _assert(library.size() != 0);
1363
1364         dlset($JNI_GetCreatedJavaVMs, "JNI_GetCreatedJavaVMs", handle);
1365         if (JNIEnv *jni = CYGetCreatedJava($JNI_GetCreatedJavaVMs))
1366             return jni;
1367     }
1368
1369     std::vector<JavaVMOption> options;
1370
1371     {
1372         std::ostringstream option;
1373         option << "-Djava.class.path=";
1374         option << CYPoolLibraryPath(pool) << "/libcycript.jar";
1375         if (const char *classpath = getenv("CLASSPATH"))
1376             option << ':' << classpath;
1377         options.push_back(JavaVMOption{pool.strdup(option.str().c_str()), NULL});
1378     }
1379
1380     // To use libnativehelper to access JNI_GetCreatedJavaVMs, you need JniInvocation.
1381     // ...but there can only be one JniInvocation, and assuradely the other VM has it.
1382     // Essentially, this API makes no sense. We need it for AndroidRuntime, though :/.
1383
1384     if (void *libnativehelper = dlopen("libnativehelper.so", RTLD_LAZY | RTLD_GLOBAL)) {
1385         class JniInvocation$;
1386         JniInvocation$ *(*JniInvocation$$init$)(JniInvocation$ *self)(NULL);
1387         bool (*JniInvocation$Init)(JniInvocation$ *self, const char *library)(NULL);
1388         JniInvocation$ *(*JniInvocation$finalize)(JniInvocation$ *self)(NULL);
1389
1390         dlset(JniInvocation$$init$, "_ZN13JniInvocationC1Ev", libnativehelper);
1391         dlset(JniInvocation$Init, "_ZN13JniInvocation4InitEPKc", libnativehelper);
1392         dlset(JniInvocation$finalize, "_ZN13JniInvocationD1Ev", libnativehelper);
1393
1394         // XXX: we should attach a pool to the VM itself and deallocate this there
1395         //auto invocation(pool.calloc<JniInvocation$>(1, 1024));
1396         //_assert(JniInvocation$finalize != NULL);
1397         //pool.atexit(reinterpret_cast<void (*)(void *)>(JniInvocation$finalize), invocation);
1398
1399         auto invocation(static_cast<JniInvocation$ *>(calloc(1, 1024)));
1400
1401         _assert(JniInvocation$$init$ != NULL);
1402         JniInvocation$$init$(invocation);
1403
1404         _assert(JniInvocation$Init != NULL);
1405         JniInvocation$Init(invocation, NULL);
1406
1407         dlset($JNI_GetCreatedJavaVMs, "JNI_GetCreatedJavaVMs", libnativehelper);
1408         if (JNIEnv *jni = CYGetCreatedJava($JNI_GetCreatedJavaVMs))
1409             return jni;
1410     }
1411
1412     if (void *libandroid_runtime = dlopen("libandroid_runtime.so", RTLD_LAZY | RTLD_GLOBAL)) {
1413         class AndroidRuntime$;
1414         AndroidRuntime$ *(*AndroidRuntime$$init$)(AndroidRuntime$ *self, char *args, unsigned int size)(NULL);
1415         int (*AndroidRuntime$startVm)(AndroidRuntime$ *self, JavaVM **jvm, JNIEnv **jni)(NULL);
1416         int (*AndroidRuntime$startReg)(JNIEnv *jni)(NULL);
1417         int (*AndroidRuntime$addOption)(AndroidRuntime$ *self, const char *option, void *extra)(NULL);
1418         int (*AndroidRuntime$addVmArguments)(AndroidRuntime$ *self, int, const char *const argv[])(NULL);
1419         AndroidRuntime$ *(*AndroidRuntime$finalize)(AndroidRuntime$ *self)(NULL);
1420
1421         dlset(AndroidRuntime$$init$, "_ZN7android14AndroidRuntimeC1EPcj", libandroid_runtime);
1422         dlset(AndroidRuntime$startVm, "_ZN7android14AndroidRuntime7startVmEPP7_JavaVMPP7_JNIEnv", libandroid_runtime);
1423         dlset(AndroidRuntime$startReg, "_ZN7android14AndroidRuntime8startRegEP7_JNIEnv", libandroid_runtime);
1424         dlset(AndroidRuntime$addOption, "_ZN7android14AndroidRuntime9addOptionEPKcPv", libandroid_runtime);
1425         dlset(AndroidRuntime$addVmArguments, "_ZN7android14AndroidRuntime14addVmArgumentsEiPKPKc", libandroid_runtime);
1426         dlset(AndroidRuntime$finalize, "_ZN7android14AndroidRuntimeD1Ev", libandroid_runtime);
1427
1428         // XXX: it would also be interesting to attach this to a global pool
1429         AndroidRuntime$ *runtime(pool.calloc<AndroidRuntime$>(1, 1024));
1430
1431         _assert(AndroidRuntime$$init$ != NULL);
1432         AndroidRuntime$$init$(runtime, NULL, 0);
1433
1434         if (AndroidRuntime$addOption == NULL) {
1435             _assert(AndroidRuntime$addVmArguments != NULL);
1436             std::vector<const char *> arguments;
1437             for (const auto &option : options)
1438                 arguments.push_back(option.optionString);
1439             AndroidRuntime$addVmArguments(runtime, arguments.size(), arguments.data());
1440         } else for (const auto &option : options)
1441             AndroidRuntime$addOption(runtime, option.optionString, option.extraInfo);
1442
1443         int failure;
1444
1445         _assert(AndroidRuntime$startVm != NULL);
1446         failure = AndroidRuntime$startVm(runtime, &jvm, &jni);
1447         _assert(failure == 0);
1448
1449         _assert(AndroidRuntime$startReg != NULL);
1450         failure = AndroidRuntime$startReg(jni);
1451         _assert(failure == 0);
1452
1453         return jni;
1454     }
1455
1456     jint (*$JNI_CreateJavaVM)(JavaVM **jvm, void **, void *);
1457     dlset($JNI_CreateJavaVM, "JNI_CreateJavaVM", handle);
1458
1459     JavaVMInitArgs args;
1460     memset(&args, 0, sizeof(args));
1461     args.version = CYJavaVersion;
1462     args.nOptions = options.size();
1463     args.options = options.data();
1464     _jnicall($JNI_CreateJavaVM(&jvm, reinterpret_cast<void **>(&jni), &args));
1465     return jni;
1466 }
1467
1468 static JNIEnv *GetJNI(JSContextRef context) {
1469     CYJavaEnv jni(GetJNI_(context));
1470     auto Cycript$(jni.FindClass("Cycript"));
1471     jni.RegisterNatives(Cycript$, Cycript_, sizeof(Cycript_) / sizeof(Cycript_[0]));
1472     return jni;
1473 }
1474
1475 static JSStaticValue JavaClass_staticValues[3] = {
1476     {"class", &JavaClass_getProperty_class, NULL, kJSPropertyAttributeReadOnly | kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
1477     {"$cyi", &JavaClass_getProperty_$cyi, NULL, kJSPropertyAttributeReadOnly | kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
1478     {NULL, NULL, NULL, 0}
1479 };
1480
1481 static JSStaticFunction JavaClass_staticFunctions[2] = {
1482     {"toCYON", &JavaClass_callAsFunction_toCYON, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
1483     {NULL, NULL, 0}
1484 };
1485
1486 static JSStaticValue JavaObject_staticValues[3] = {
1487     {"constructor", &JavaObject_getProperty_constructor, NULL, kJSPropertyAttributeReadOnly | kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
1488     {"$cyi", &JavaObject_getProperty_$cyi, NULL, kJSPropertyAttributeReadOnly | kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
1489     {NULL, NULL, NULL, 0}
1490 };
1491
1492 static JSStaticFunction JavaMethod_staticFunctions[2] = {
1493     {"toCYON", &JavaMethod_callAsFunction_toCYON, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
1494     {NULL, NULL, 0}
1495 };
1496
1497 static JSStaticFunction JavaStaticMethod_staticFunctions[2] = {
1498     {"toCYON", &JavaStaticMethod_callAsFunction_toCYON, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
1499     {NULL, NULL, 0}
1500 };
1501
1502 static JSStaticFunction JavaPackage_staticFunctions[2] = {
1503     {"toCYON", &JavaPackage_callAsFunction_toCYON, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
1504     {NULL, NULL, 0}
1505 };
1506
1507 void CYJava_Initialize() {
1508     Primitives_.insert(std::make_pair("void", CYJavaPrimitiveVoid));
1509 #define CYJavaForEachPrimitive_(T, t, Typ, Type, type) \
1510     Primitives_.insert(std::make_pair(#type, CYJavaPrimitive ## Type));
1511 CYJavaForEachPrimitive
1512 #undef CYJavaForEachPrimitive_
1513
1514     JSClassDefinition definition;
1515
1516     definition = kJSClassDefinitionEmpty;
1517     definition.className = "JavaClass";
1518     definition.staticValues = JavaClass_staticValues;
1519     definition.staticFunctions = JavaClass_staticFunctions;
1520     definition.callAsConstructor = &JavaClass_callAsConstructor;
1521     definition.finalize = &CYFinalize;
1522     CYJavaClass::Class_ = JSClassCreate(&definition);
1523
1524     definition = kJSClassDefinitionEmpty;
1525     definition.attributes = kJSClassAttributeNoAutomaticPrototype;
1526     definition.className = "JavaInterior";
1527     definition.hasProperty = &JavaInterior_hasProperty;
1528     definition.getProperty = &JavaInterior_getProperty;
1529     definition.setProperty = &JavaInterior_setProperty;
1530     definition.getPropertyNames = &JavaInterior_getPropertyNames;
1531     definition.finalize = &CYFinalize;
1532     CYJavaInterior::Class_ = JSClassCreate(&definition);
1533
1534     definition = kJSClassDefinitionEmpty;
1535     definition.className = "JavaMethod";
1536     definition.staticFunctions = JavaMethod_staticFunctions;
1537     definition.callAsFunction = &JavaMethod_callAsFunction;
1538     definition.finalize = &CYFinalize;
1539     CYJavaMethod::Class_ = JSClassCreate(&definition);
1540
1541     definition = kJSClassDefinitionEmpty;
1542     definition.className = "JavaStaticMethod";
1543     definition.staticFunctions = JavaStaticMethod_staticFunctions;
1544     definition.callAsFunction = &JavaStaticMethod_callAsFunction;
1545     definition.finalize = &CYFinalize;
1546     CYJavaStaticMethod::Class_ = JSClassCreate(&definition);
1547
1548     definition = kJSClassDefinitionEmpty;
1549     definition.attributes = kJSClassAttributeNoAutomaticPrototype;
1550     definition.className = "JavaObject";
1551     definition.staticValues = JavaObject_staticValues;
1552     definition.finalize = &CYFinalize;
1553     CYJavaObject::Class_ = JSClassCreate(&definition);
1554
1555     definition = kJSClassDefinitionEmpty;
1556     definition.className = "JavaArray";
1557     definition.getProperty = &JavaArray_getProperty;
1558     definition.setProperty = &JavaArray_setProperty;
1559     definition.finalize = &CYFinalize;
1560     CYJavaArray::Class_ = JSClassCreate(&definition);
1561
1562     definition = kJSClassDefinitionEmpty;
1563     definition.className = "JavaPackage";
1564     definition.staticFunctions = JavaPackage_staticFunctions;
1565     definition.hasProperty = &CYJavaPackage_hasProperty;
1566     definition.getProperty = &CYJavaPackage_getProperty;
1567     definition.finalize = &CYFinalize;
1568     CYJavaPackage::Class_ = JSClassCreate(&definition);
1569
1570     definition = kJSClassDefinitionEmpty;
1571     definition.attributes = kJSClassAttributeNoAutomaticPrototype;
1572     definition.className = "JavaStaticInterior";
1573     definition.hasProperty = &JavaStaticInterior_hasProperty;
1574     definition.getProperty = &JavaStaticInterior_getProperty;
1575     definition.setProperty = &JavaStaticInterior_setProperty;
1576     definition.getPropertyNames = &JavaStaticInterior_getPropertyNames;
1577     definition.finalize = &CYFinalize;
1578     CYJavaStaticInterior::Class_ = JSClassCreate(&definition);
1579 }
1580
1581 void CYJava_SetupContext(JSContextRef context) {
1582     JSObjectRef global(CYGetGlobalObject(context));
1583     //JSObjectRef cy(CYCastJSObject(context, CYGetProperty(context, global, cy_s)));
1584     JSObjectRef cycript(CYCastJSObject(context, CYGetProperty(context, global, CYJSString("Cycript"))));
1585     JSObjectRef all(CYCastJSObject(context, CYGetProperty(context, cycript, CYJSString("all"))));
1586     //JSObjectRef alls(CYCastJSObject(context, CYGetProperty(context, cycript, CYJSString("alls"))));
1587
1588     JSObjectRef Java(JSObjectMake(context, NULL, NULL));
1589     CYSetProperty(context, cycript, CYJSString("Java"), Java);
1590
1591     JSObjectRef Packages(CYJavaPackage::Make(context, CYJavaPackage::Path()));
1592     CYSetProperty(context, all, CYJSString("Packages"), Packages);
1593
1594     for (auto name : (const char *[]) {"java", "javax", "android", "com", "net", "org"}) {
1595         CYJSString js(name);
1596         CYSetProperty(context, all, js, CYGetProperty(context, Packages, js));
1597     }
1598 }
1599
1600 static CYHook CYJavaHook = {
1601     NULL,
1602     NULL,
1603     NULL,
1604     &CYJava_Initialize,
1605     &CYJava_SetupContext,
1606     NULL,
1607 };
1608
1609 CYRegisterHook CYJava(&CYJavaHook);