2 * Licensed under the Apache License, Version 2.0 (the "License");
3 * you may not use this file except in compliance with the License.
4 * You may obtain a copy of the License at
6 * http://www.apache.org/licenses/LICENSE-2.0
8 * Unless required by applicable law or agreed to in writing, software
9 * distributed under the License is distributed on an "AS IS" BASIS,
10 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
11 * See the License for the specific language governing permissions and
12 * limitations under the License.
18 #include "java/lang/Object.h"
19 #include "java/lang/Class.h"
20 #include "java/lang/String.h"
21 #include "java/lang/Throwable.h"
22 #include "java/lang/Boolean.h"
23 #include "java/lang/Byte.h"
24 #include "java/lang/Character.h"
25 #include "java/lang/Double.h"
26 #include "java/lang/Float.h"
27 #include "java/lang/Integer.h"
28 #include "java/lang/Long.h"
29 #include "java/lang/Short.h"
30 #include "java/util/Iterator.h"
32 #include "functions.h"
35 using namespace java::lang;
36 using namespace java::util;
38 PyObject *PyExc_JavaError = PyExc_ValueError;
39 PyObject *PyExc_InvalidArgsError = PyExc_ValueError;
41 PyObject *_set_exception_types(PyObject *self, PyObject *args)
43 if (!PyArg_ParseTuple(args, "OO",
44 &PyExc_JavaError, &PyExc_InvalidArgsError))
50 PyObject *_set_function_self(PyObject *self, PyObject *args)
52 PyObject *object, *module;
54 if (!PyArg_ParseTuple(args, "OO", &object, &module))
57 if (!PyCFunction_Check(object))
59 PyErr_SetObject(PyExc_TypeError, object);
63 PyCFunctionObject *cfn = (PyCFunctionObject *) object;
66 Py_XDECREF(cfn->m_self);
72 PyObject *findClass(PyObject *self, PyObject *args)
76 if (!PyArg_ParseTuple(args, "s", &className))
80 jclass cls = env->findClass(className);
83 return t_Class::wrap_Object(Class(cls));
89 return PyErr_SetJavaError();
98 static boxfn get_boxfn(PyTypeObject *type)
100 static PyObject *boxfn_ = PyString_FromString("boxfn_");
101 PyObject *cobj = PyObject_GetAttr((PyObject *) type, boxfn_);
107 fn = (boxfn) PyCObject_AsVoidPtr(cobj);
113 static int is_instance_of(PyObject *arg, PyTypeObject *type)
115 static PyObject *class_ = PyString_FromString("class_");
116 PyObject *clsObj = PyObject_GetAttr((PyObject *) type, class_);
122 result = env->get_vm_env()->
123 IsInstanceOf(((t_Object *) arg)->object.this$,
124 (jclass) ((t_Object *) clsObj)->object.this$);
131 #if defined(_MSC_VER) || defined(__SUNPRO_CC)
132 int __parseArgs(PyObject *args, char *types, ...)
134 int count = ((PyTupleObject *)(args))->ob_size;
137 va_start(list, types);
138 va_start(check, types);
140 return _parseArgs(((PyTupleObject *)(args))->ob_item, count, types,
144 int __parseArg(PyObject *arg, char *types, ...)
148 va_start(list, types);
149 va_start(check, types);
151 return _parseArgs(&arg, 1, types, list, check);
154 int _parseArgs(PyObject **args, unsigned int count, char *types,
155 va_list list, va_list check)
157 unsigned int typeCount = strlen(types);
159 if (count > typeCount)
163 int _parseArgs(PyObject **args, unsigned int count, char *types, ...)
165 unsigned int typeCount = strlen(types);
168 if (count > typeCount)
171 va_start(list, types);
172 va_start(check, types);
177 PyErr_SetString(PyExc_RuntimeError, "initVM() must be called first");
181 JNIEnv *vm_env = env->get_vm_env();
185 PyErr_SetString(PyExc_RuntimeError, "attachCurrentThread() must be called first");
189 unsigned int pos = 0;
192 for (unsigned int a = 0; a < count; a++, pos++) {
193 PyObject *arg = args[a];
195 switch (types[pos]) {
205 case 'j': /* Java object, with class$ */
206 case 'k': /* Java object, with initializeClass */
207 case 'K': /* Java object, with initializeClass and params */
211 switch (types[pos]) {
213 cls = (jclass) va_arg(list, Class *)->this$;
218 getclassfn initializeClass = va_arg(list, getclassfn);
219 cls = (*initializeClass)();
225 PyErr_SetJavaError();
237 /* ensure that class Class is initialized (which may not be the
238 * case because of earlier recursion avoidance (JObject(cls)).
241 Class::initializeClass();
245 if (PyObject_TypeCheck(arg, PY_TYPE(JArrayObject)))
248 if (PySequence_Check(arg) &&
249 !PyString_Check(arg) && !PyUnicode_Check(arg))
251 if (PySequence_Length(arg) > 0)
253 PyObject *obj = PySequence_GetItem(arg, 0);
258 else if (PyObject_TypeCheck(obj, &PY_TYPE(Object)) &&
259 vm_env->IsInstanceOf(((t_Object *) obj)->object.this$, cls))
261 else if (PyObject_TypeCheck(obj, &PY_TYPE(FinalizerProxy)))
263 PyObject *o = ((t_fp *) obj)->object;
265 if (PyObject_TypeCheck(o, &PY_TYPE(Object)) &&
266 vm_env->IsInstanceOf(((t_Object *) o)->object.this$, cls))
278 else if (PyObject_TypeCheck(arg, &PY_TYPE(Object)) &&
279 vm_env->IsInstanceOf(((t_Object *) arg)->object.this$, cls))
281 else if (PyObject_TypeCheck(arg, &PY_TYPE(FinalizerProxy)))
283 arg = ((t_fp *) arg)->object;
284 if (PyObject_TypeCheck(arg, &PY_TYPE(Object)) &&
285 vm_env->IsInstanceOf(((t_Object *) arg)->object.this$, cls))
292 case 'Z': /* boolean, strict */
299 if (PyObject_TypeCheck(arg, PY_TYPE(JArrayBool)))
302 if (PySequence_Check(arg))
304 if (PySequence_Length(arg) > 0)
306 PyObject *obj = PySequence_GetItem(arg, 0);
307 int ok = obj == Py_True || obj == Py_False;
317 else if (arg == Py_True || arg == Py_False)
329 if (PyObject_TypeCheck(arg, PY_TYPE(JArrayByte)))
332 else if (PyString_Check(arg) && (PyString_Size(arg) == 1))
334 else if (PyInt_CheckExact(arg))
346 if (PyObject_TypeCheck(arg, PY_TYPE(JArrayChar)))
349 else if (PyUnicode_Check(arg) && PyUnicode_GET_SIZE(arg) == 1)
361 if (PyObject_TypeCheck(arg, PY_TYPE(JArrayInt)))
364 if (PySequence_Check(arg))
366 if (PySequence_Length(arg) > 0)
368 PyObject *obj = PySequence_GetItem(arg, 0);
369 int ok = PyInt_CheckExact(obj);
379 else if (PyInt_CheckExact(arg))
385 case 'S': /* short */
392 if (PyObject_TypeCheck(arg, PY_TYPE(JArrayShort)))
395 if (PySequence_Check(arg))
397 if (PySequence_Length(arg) > 0)
399 PyObject *obj = PySequence_GetItem(arg, 0);
400 int ok = PyInt_CheckExact(obj);
410 else if (PyInt_CheckExact(arg))
416 case 'D': /* double */
423 if (PyObject_TypeCheck(arg, PY_TYPE(JArrayDouble)))
426 if (PySequence_Check(arg))
428 if (PySequence_Length(arg) > 0)
430 PyObject *obj = PySequence_GetItem(arg, 0);
431 int ok = PyFloat_CheckExact(obj);
441 else if (PyFloat_CheckExact(arg))
447 case 'F': /* float */
454 if (PyObject_TypeCheck(arg, PY_TYPE(JArrayFloat)))
457 if (PySequence_Check(arg))
459 if (PySequence_Length(arg) > 0)
461 PyObject *obj = PySequence_GetItem(arg, 0);
462 int ok = PyFloat_CheckExact(obj);
472 else if (PyFloat_CheckExact(arg))
478 case 'J': /* long long */
485 if (PyObject_TypeCheck(arg, PY_TYPE(JArrayLong)))
488 if (PySequence_Check(arg))
490 if (PySequence_Length(arg) > 0)
492 PyObject *obj = PySequence_GetItem(arg, 0);
493 int ok = PyLong_CheckExact(obj);
503 else if (PyLong_CheckExact(arg))
509 case 's': /* string */
516 if (PyObject_TypeCheck(arg, PY_TYPE(JArrayString)))
519 if (PySequence_Check(arg) &&
520 !PyString_Check(arg) && !PyUnicode_Check(arg))
522 if (PySequence_Length(arg) > 0)
524 PyObject *obj = PySequence_GetItem(arg, 0);
527 PyString_Check(obj) || PyUnicode_Check(obj));
537 else if (arg == Py_None ||
538 PyString_Check(arg) || PyUnicode_Check(arg))
544 case 'o': /* java.lang.Object */
547 case 'O': /* java.lang.Object with type param */
549 PyTypeObject *type = va_arg(list, PyTypeObject *);
553 boxfn fn = get_boxfn(type);
555 if (fn == NULL || fn(type, arg, NULL) < 0)
561 case 'T': /* tuple of python types with wrapfn_ */
563 static PyObject *wrapfn_ = PyString_FromString("wrapfn_");
564 int len = va_arg(list, int);
566 if (PyTuple_Check(arg))
568 if (PyTuple_GET_SIZE(arg) != len)
571 for (int i = 0; i < len; i++) {
572 PyObject *type = PyTuple_GET_ITEM(arg, i);
574 if (!(type == Py_None ||
575 (PyType_Check(type) &&
576 PyObject_HasAttr(type, wrapfn_))))
588 if (types[pos] != '[')
597 for (unsigned int a = 0; a < count; a++, pos++) {
598 PyObject *arg = args[a];
600 switch (types[pos]) {
610 case 'j': /* Java object except String and Object */
611 case 'k': /* Java object, with initializeClass */
612 case 'K': /* Java object, with initializeClass and params */
616 switch (types[pos]) {
618 cls = (jclass) va_arg(check, Class *)->this$;
622 getclassfn initializeClass = va_arg(check, getclassfn);
623 cls = (*initializeClass)();
629 JArray<jobject> *array = va_arg(list, JArray<jobject> *);
631 #ifdef _java_generics
632 if (types[pos] == 'K')
634 PyTypeObject ***tp = va_arg(list, PyTypeObject ***);
636 va_arg(list, getparametersfn);
641 *array = JArray<jobject>((jobject) NULL);
642 else if (PyObject_TypeCheck(arg, PY_TYPE(JArrayObject)))
643 *array = ((t_JArray<jobject> *) arg)->array;
645 *array = JArray<jobject>(cls, arg);
647 if (PyErr_Occurred())
652 Object *obj = va_arg(list, Object *);
654 if (PyObject_TypeCheck(arg, &PY_TYPE(FinalizerProxy)))
655 arg = ((t_fp *) arg)->object;
657 #ifdef _java_generics
658 if (types[pos] == 'K')
660 PyTypeObject ***tp = va_arg(list, PyTypeObject ***);
661 PyTypeObject **(*parameters_)(void *) =
662 va_arg(list, getparametersfn);
667 *tp = (*parameters_)(arg);
671 *obj = arg == Py_None
673 : ((t_Object *) arg)->object;
678 case 'Z': /* boolean, strict */
682 JArray<jboolean> *array = va_arg(list, JArray<jboolean> *);
685 *array = JArray<jboolean>((jobject) NULL);
686 else if (PyObject_TypeCheck(arg, PY_TYPE(JArrayBool)))
687 *array = ((t_JArray<jboolean> *) arg)->array;
689 *array = JArray<jboolean>(arg);
691 if (PyErr_Occurred())
696 jboolean *b = va_arg(list, jboolean *);
706 JArray<jbyte> *array = va_arg(list, JArray<jbyte> *);
709 *array = JArray<jbyte>((jobject) NULL);
710 else if (PyObject_TypeCheck(arg, PY_TYPE(JArrayByte)))
711 *array = ((t_JArray<jbyte> *) arg)->array;
713 *array = JArray<jbyte>(arg);
715 if (PyErr_Occurred())
718 else if (PyString_Check(arg))
720 jbyte *a = va_arg(list, jbyte *);
721 *a = (jbyte) PyString_AS_STRING(arg)[0];
725 jbyte *a = va_arg(list, jbyte *);
726 *a = (jbyte) PyInt_AsLong(arg);
735 JArray<jchar> *array = va_arg(list, JArray<jchar> *);
738 *array = JArray<jchar>((jobject) NULL);
739 else if (PyObject_TypeCheck(arg, PY_TYPE(JArrayChar)))
740 *array = ((t_JArray<jchar> *) arg)->array;
742 *array = JArray<jchar>(arg);
744 if (PyErr_Occurred())
749 jchar *c = va_arg(list, jchar *);
750 *c = (jchar) PyUnicode_AS_UNICODE(arg)[0];
759 JArray<jint> *array = va_arg(list, JArray<jint> *);
762 *array = JArray<jint>((jobject) NULL);
763 else if (PyObject_TypeCheck(arg, PY_TYPE(JArrayInt)))
764 *array = ((t_JArray<jint> *) arg)->array;
766 *array = JArray<jint>(arg);
768 if (PyErr_Occurred())
773 jint *n = va_arg(list, jint *);
774 *n = (jint) PyInt_AsLong(arg);
779 case 'S': /* short */
783 JArray<jshort> *array = va_arg(list, JArray<jshort> *);
786 *array = JArray<jshort>((jobject) NULL);
787 else if (PyObject_TypeCheck(arg, PY_TYPE(JArrayShort)))
788 *array = ((t_JArray<jshort> *) arg)->array;
790 *array = JArray<jshort>(arg);
792 if (PyErr_Occurred())
797 jshort *n = va_arg(list, jshort *);
798 *n = (jshort) PyInt_AsLong(arg);
803 case 'D': /* double */
807 JArray<jdouble> *array = va_arg(list, JArray<jdouble> *);
810 *array = JArray<jdouble>((jobject) NULL);
811 else if (PyObject_TypeCheck(arg, PY_TYPE(JArrayDouble)))
812 *array = ((t_JArray<jdouble> *) arg)->array;
814 *array = JArray<jdouble>(arg);
816 if (PyErr_Occurred())
821 jdouble *d = va_arg(list, jdouble *);
822 *d = (jdouble) PyFloat_AsDouble(arg);
827 case 'F': /* float */
831 JArray<jfloat> *array = va_arg(list, JArray<jfloat> *);
834 *array = JArray<jfloat>((jobject) NULL);
835 else if (PyObject_TypeCheck(arg, PY_TYPE(JArrayFloat)))
836 *array = ((t_JArray<jfloat> *) arg)->array;
838 *array = JArray<jfloat>(arg);
840 if (PyErr_Occurred())
845 jfloat *d = va_arg(list, jfloat *);
846 *d = (jfloat) (float) PyFloat_AsDouble(arg);
851 case 'J': /* long long */
855 JArray<jlong> *array = va_arg(list, JArray<jlong> *);
858 *array = JArray<jlong>((jobject) NULL);
859 else if (PyObject_TypeCheck(arg, PY_TYPE(JArrayLong)))
860 *array = ((t_JArray<jlong> *) arg)->array;
862 *array = JArray<jlong>(arg);
864 if (PyErr_Occurred())
869 jlong *l = va_arg(list, jlong *);
870 *l = (jlong) PyLong_AsLongLong(arg);
875 case 's': /* string */
879 JArray<jstring> *array = va_arg(list, JArray<jstring> *);
882 *array = JArray<jstring>((jobject) NULL);
883 else if (PyObject_TypeCheck(arg, PY_TYPE(JArrayString)))
884 *array = ((t_JArray<jstring> *) arg)->array;
886 *array = JArray<jstring>(arg);
888 if (PyErr_Occurred())
893 String *str = va_arg(list, String *);
900 if (PyErr_Occurred())
907 case 'o': /* java.lang.Object */
908 case 'O': /* java.lang.Object with type param */
912 JArray<Object> *array = va_arg(list, JArray<Object> *);
915 *array = JArray<Object>((jobject) NULL);
917 *array = JArray<Object>(arg);
919 if (PyErr_Occurred())
924 Object *obj = va_arg(list, Object *);
926 if (types[pos] == 'O')
928 PyTypeObject *type = va_arg(check, PyTypeObject *);
932 boxfn fn = get_boxfn(type);
934 if (fn == NULL || fn(type, arg, obj) < 0)
941 if (boxObject(NULL, arg, obj) < 0)
947 case 'T': /* tuple of python types with wrapfn_ */
949 int len = va_arg(check, int);
950 PyTypeObject **types = va_arg(list, PyTypeObject **);
952 for (int i = 0; i < len; i++) {
953 PyObject *type = PyTuple_GET_ITEM(arg, i);
958 types[i] = (PyTypeObject *) type;
967 if (types[pos] != '[')
971 if (pos == typeCount)
978 String p2j(PyObject *object)
980 return String(env->fromPyString(object));
983 PyObject *j2p(const String& js)
985 return env->fromJString((jstring) js.this$, 0);
988 PyObject *PyErr_SetArgsError(char *name, PyObject *args)
990 if (!PyErr_Occurred())
992 PyObject *err = Py_BuildValue("(sO)", name, args);
994 PyErr_SetObject(PyExc_InvalidArgsError, err);
1001 PyObject *PyErr_SetArgsError(PyObject *self, char *name, PyObject *args)
1003 if (!PyErr_Occurred())
1005 PyObject *type = (PyObject *) self->ob_type;
1006 PyObject *err = Py_BuildValue("(OsO)", type, name, args);
1008 PyErr_SetObject(PyExc_InvalidArgsError, err);
1015 PyObject *PyErr_SetArgsError(PyTypeObject *type, char *name, PyObject *args)
1017 if (!PyErr_Occurred())
1019 PyObject *err = Py_BuildValue("(OsO)", type, name, args);
1021 PyErr_SetObject(PyExc_InvalidArgsError, err);
1028 PyObject *PyErr_SetJavaError()
1030 JNIEnv *vm_env = env->get_vm_env();
1031 jthrowable throwable = vm_env->ExceptionOccurred();
1034 vm_env->ExceptionClear();
1035 err = t_Throwable::wrap_Object(Throwable(throwable));
1037 PyErr_SetObject(PyExc_JavaError, err);
1043 void throwPythonError(void)
1045 PyObject *exc = PyErr_Occurred();
1047 if (exc && PyErr_GivenExceptionMatches(exc, PyExc_JavaError))
1049 PyObject *value, *traceback;
1051 PyErr_Fetch(&exc, &value, &traceback);
1054 PyObject *je = PyObject_CallMethod(value, "getJavaException", "");
1057 PyErr_Restore(exc, value, traceback);
1062 Py_XDECREF(traceback);
1065 if (exc && PyObject_TypeCheck(exc, &PY_TYPE(Throwable)))
1067 jobject jobj = ((t_Throwable *) exc)->object.this$;
1069 env->get_vm_env()->Throw((jthrowable) jobj);
1079 Py_XDECREF(traceback);
1082 else if (exc && PyErr_GivenExceptionMatches(exc, PyExc_StopIteration))
1090 PyObject *name = PyObject_GetAttrString(exc, "__name__");
1092 env->get_vm_env()->ThrowNew(env->getPythonExceptionClass(),
1093 PyString_AS_STRING(name));
1097 env->get_vm_env()->ThrowNew(env->getPythonExceptionClass(),
1101 void throwTypeError(const char *name, PyObject *object)
1103 PyObject *tuple = Py_BuildValue("(ssO)", "while calling", name, object);
1105 PyErr_SetObject(PyExc_TypeError, tuple);
1108 env->get_vm_env()->ThrowNew(env->getPythonExceptionClass(), "type error");
1111 int abstract_init(PyObject *self, PyObject *args, PyObject *kwds)
1114 Py_BuildValue("(sO)", "instantiating java class", self->ob_type);
1116 PyErr_SetObject(PyExc_NotImplementedError, err);
1122 PyObject *callSuper(PyTypeObject *type, const char *name, PyObject *args,
1125 PyObject *super = (PyObject *) type->tp_base;
1127 PyObject_GetAttrString(super, (char *) name); // python 2.4 cast
1133 if (cardinality > 1)
1134 value = PyObject_Call(method, args, NULL);
1137 #if PY_VERSION_HEX < 0x02040000
1138 PyObject *tuple = Py_BuildValue("(O)", args);
1140 PyObject *tuple = PyTuple_Pack(1, args);
1142 value = PyObject_Call(method, tuple, NULL);
1151 PyObject *callSuper(PyTypeObject *type, PyObject *self,
1152 const char *name, PyObject *args, int cardinality)
1154 #if PY_VERSION_HEX < 0x02040000
1155 PyObject *tuple = Py_BuildValue("(OO)", type, self);
1157 PyObject *tuple = PyTuple_Pack(2, type, self);
1159 PyObject *super = PyObject_Call((PyObject *) &PySuper_Type, tuple, NULL);
1160 PyObject *method, *value;
1166 method = PyObject_GetAttrString(super, (char *) name); // python 2.4 cast
1171 if (cardinality > 1)
1172 value = PyObject_Call(method, args, NULL);
1175 #if PY_VERSION_HEX < 0x02040000
1176 tuple = Py_BuildValue("(O)", args);
1178 tuple = PyTuple_Pack(1, args);
1180 value = PyObject_Call(method, tuple, NULL);
1189 PyObject *castCheck(PyObject *obj, getclassfn initializeClass,
1192 if (PyObject_TypeCheck(obj, &PY_TYPE(FinalizerProxy)))
1193 obj = ((t_fp *) obj)->object;
1195 if (!PyObject_TypeCheck(obj, &PY_TYPE(Object)))
1198 PyErr_SetObject(PyExc_TypeError, obj);
1202 jobject jobj = ((t_Object *) obj)->object.this$;
1204 if (jobj && !env->isInstanceOf(jobj, initializeClass))
1207 PyErr_SetObject(PyExc_TypeError, obj);
1215 PyObject *get_extension_iterator(PyObject *self)
1217 return PyObject_CallMethod(self, "iterator", "");
1220 PyObject *get_extension_next(PyObject *self)
1222 return PyObject_CallMethod(self, "next", "");
1225 PyObject *get_extension_nextElement(PyObject *self)
1227 return PyObject_CallMethod(self, "nextElement", "");
1230 jobjectArray fromPySequence(jclass cls, PyObject *sequence)
1232 if (sequence == Py_None)
1235 if (!PySequence_Check(sequence))
1237 PyErr_SetObject(PyExc_TypeError, sequence);
1241 int length = PySequence_Length(sequence);
1245 array = env->newObjectArray(cls, length);
1251 PyErr_SetJavaError();
1258 JNIEnv *vm_env = env->get_vm_env();
1260 for (int i = 0; i < length; i++) {
1261 PyObject *obj = PySequence_GetItem(sequence, i);
1267 else if (obj == Py_None)
1269 else if (PyString_Check(obj) || PyUnicode_Check(obj))
1271 jobj = env->fromPyString(obj);
1274 else if (PyObject_TypeCheck(obj, &PY_TYPE(JObject)))
1275 jobj = ((t_JObject *) obj)->object.this$;
1276 else if (PyObject_TypeCheck(obj, &PY_TYPE(FinalizerProxy)))
1277 jobj = ((t_JObject *) ((t_fp *) obj)->object)->object.this$;
1278 else /* todo: add auto-boxing of primitive types */
1280 PyErr_SetObject(PyExc_TypeError, obj);
1288 env->setObjectArrayElement(array, i, jobj);
1290 vm_env->DeleteLocalRef(jobj);
1294 PyErr_SetJavaError();
1305 void installType(PyTypeObject *type, PyObject *module, char *name,
1308 if (PyType_Ready(type) == 0)
1313 type->ob_type = &PY_TYPE(FinalizerClass);
1314 Py_INCREF(&PY_TYPE(FinalizerClass));
1316 PyModule_AddObject(module, name, (PyObject *) type);
1320 PyObject *wrapType(PyTypeObject *type, const jobject& obj)
1322 static PyObject *wrapfn_ = PyString_FromString("wrapfn_");
1323 PyObject *cobj = PyObject_GetAttr((PyObject *) type, wrapfn_);
1324 PyObject *(*wrapfn)(const jobject&);
1329 wrapfn = (PyObject *(*)(const jobject &)) PyCObject_AsVoidPtr(cobj);
1335 PyObject *unboxBoolean(const jobject& obj)
1339 if (!env->isInstanceOf(obj, java::lang::Boolean::initializeClass))
1341 PyErr_SetObject(PyExc_TypeError,
1342 (PyObject *) &java::lang::PY_TYPE(Boolean));
1346 if (env->booleanValue(obj))
1355 PyObject *unboxByte(const jobject &obj)
1359 if (!env->isInstanceOf(obj, java::lang::Byte::initializeClass))
1361 PyErr_SetObject(PyExc_TypeError,
1362 (PyObject *) &java::lang::PY_TYPE(Byte));
1366 return PyInt_FromLong((long) env->byteValue(obj));
1372 PyObject *unboxCharacter(const jobject &obj)
1376 if (!env->isInstanceOf(obj, java::lang::Character::initializeClass))
1378 PyErr_SetObject(PyExc_TypeError,
1379 (PyObject *) &java::lang::PY_TYPE(Character));
1383 jchar c = env->charValue(obj);
1384 return PyUnicode_FromUnicode((Py_UNICODE *) &c, 1);
1390 PyObject *unboxDouble(const jobject &obj)
1394 if (!env->isInstanceOf(obj, java::lang::Double::initializeClass))
1396 PyErr_SetObject(PyExc_TypeError,
1397 (PyObject *) &java::lang::PY_TYPE(Double));
1401 return PyFloat_FromDouble((double) env->doubleValue(obj));
1407 PyObject *unboxFloat(const jobject &obj)
1411 if (!env->isInstanceOf(obj, java::lang::Float::initializeClass))
1413 PyErr_SetObject(PyExc_TypeError,
1414 (PyObject *) &java::lang::PY_TYPE(Float));
1418 return PyFloat_FromDouble((double) env->floatValue(obj));
1424 PyObject *unboxInteger(const jobject &obj)
1428 if (!env->isInstanceOf(obj, java::lang::Integer::initializeClass))
1430 PyErr_SetObject(PyExc_TypeError,
1431 (PyObject *) &java::lang::PY_TYPE(Integer));
1435 return PyInt_FromLong((long) env->intValue(obj));
1441 PyObject *unboxLong(const jobject &obj)
1445 if (!env->isInstanceOf(obj, java::lang::Long::initializeClass))
1447 PyErr_SetObject(PyExc_TypeError,
1448 (PyObject *) &java::lang::PY_TYPE(Long));
1452 return PyLong_FromLongLong((PY_LONG_LONG) env->longValue(obj));
1458 PyObject *unboxShort(const jobject &obj)
1462 if (!env->isInstanceOf(obj, java::lang::Short::initializeClass))
1464 PyErr_SetObject(PyExc_TypeError,
1465 (PyObject *) &java::lang::PY_TYPE(Short));
1469 return PyInt_FromLong((long) env->shortValue(obj));
1475 PyObject *unboxString(const jobject &obj)
1479 if (!env->isInstanceOf(obj, java::lang::String::initializeClass))
1481 PyErr_SetObject(PyExc_TypeError,
1482 (PyObject *) &java::lang::PY_TYPE(String));
1486 return env->fromJString((jstring) obj, 0);
1492 static int boxJObject(PyTypeObject *type, PyObject *arg,
1493 java::lang::Object *obj)
1498 *obj = Object(NULL);
1500 else if (PyObject_TypeCheck(arg, &PY_TYPE(Object)))
1502 if (type != NULL && !is_instance_of(arg, type))
1506 *obj = ((t_Object *) arg)->object;
1508 else if (PyObject_TypeCheck(arg, &PY_TYPE(FinalizerProxy)))
1510 arg = ((t_fp *) arg)->object;
1511 if (PyObject_TypeCheck(arg, &PY_TYPE(Object)))
1513 if (type != NULL && !is_instance_of(arg, type))
1517 *obj = ((t_Object *) arg)->object;
1528 int boxBoolean(PyTypeObject *type, PyObject *arg, java::lang::Object *obj)
1530 int result = boxJObject(type, arg, obj);
1538 *obj = *Boolean::TRUE;
1540 else if (arg == Py_False)
1543 *obj = *Boolean::FALSE;
1551 int boxByte(PyTypeObject *type, PyObject *arg, java::lang::Object *obj)
1553 int result = boxJObject(type, arg, obj);
1558 if (PyInt_Check(arg))
1560 int n = PyInt_AS_LONG(arg);
1561 jbyte b = (jbyte) n;
1571 else if (PyLong_Check(arg))
1573 PY_LONG_LONG ln = PyLong_AsLongLong(arg);
1574 jbyte b = (jbyte) ln;
1584 else if (PyFloat_Check(arg))
1586 double d = PyFloat_AS_DOUBLE(arg);
1587 jbyte b = (jbyte) d;
1603 int boxCharacter(PyTypeObject *type, PyObject *arg, java::lang::Object *obj)
1605 int result = boxJObject(type, arg, obj);
1610 if (PyString_Check(arg))
1615 if (PyString_AsStringAndSize(arg, &c, &len) < 0 || len != 1)
1619 *obj = Character((jchar) c[0]);
1621 else if (PyUnicode_Check(arg))
1623 Py_ssize_t len = PyUnicode_GetSize(arg);
1629 *obj = Character((jchar) PyUnicode_AsUnicode(arg)[0]);
1637 int boxCharSequence(PyTypeObject *type, PyObject *arg, java::lang::Object *obj)
1639 int result = boxJObject(type, arg, obj);
1644 if (PyString_Check(arg) || PyUnicode_Check(arg))
1649 if (PyErr_Occurred())
1659 int boxDouble(PyTypeObject *type, PyObject *arg, java::lang::Object *obj)
1661 int result = boxJObject(type, arg, obj);
1666 if (PyInt_Check(arg))
1669 *obj = Double((jdouble) PyInt_AS_LONG(arg));
1671 else if (PyLong_Check(arg))
1674 *obj = Double((jdouble) PyLong_AsLongLong(arg));
1676 else if (PyFloat_Check(arg))
1679 *obj = Double(PyFloat_AS_DOUBLE(arg));
1687 int boxFloat(PyTypeObject *type, PyObject *arg, java::lang::Object *obj)
1689 int result = boxJObject(type, arg, obj);
1694 if (PyInt_Check(arg))
1697 *obj = Float((jfloat) PyInt_AS_LONG(arg));
1699 else if (PyLong_Check(arg))
1701 PY_LONG_LONG ln = PyLong_AsLongLong(arg);
1702 float f = (float) ln;
1704 if ((PY_LONG_LONG) f == ln)
1712 else if (PyFloat_Check(arg))
1714 double d = PyFloat_AS_DOUBLE(arg);
1715 float f = (float) d;
1717 if ((double) f == d)
1731 int boxInteger(PyTypeObject *type, PyObject *arg, java::lang::Object *obj)
1733 int result = boxJObject(type, arg, obj);
1738 if (PyInt_Check(arg))
1741 *obj = Integer((jint) PyInt_AS_LONG(arg));
1743 else if (PyLong_Check(arg))
1745 PY_LONG_LONG ln = PyLong_AsLongLong(arg);
1756 else if (PyFloat_Check(arg))
1758 double d = PyFloat_AS_DOUBLE(arg);
1761 if ((double) n == d)
1775 int boxLong(PyTypeObject *type, PyObject *arg, java::lang::Object *obj)
1777 int result = boxJObject(type, arg, obj);
1782 if (PyInt_Check(arg))
1785 *obj = Long((jlong) PyInt_AS_LONG(arg));
1787 else if (PyLong_Check(arg))
1790 *obj = Long((jlong) PyLong_AsLongLong(arg));
1792 else if (PyFloat_Check(arg))
1794 double d = PyFloat_AS_DOUBLE(arg);
1795 PY_LONG_LONG n = (PY_LONG_LONG) d;
1797 if ((double) n == d)
1800 *obj = Long((jlong) n);
1811 int boxNumber(PyTypeObject *type, PyObject *arg, java::lang::Object *obj)
1813 int result = boxJObject(type, arg, obj);
1818 if (PyInt_Check(arg))
1821 *obj = Integer((jint) PyInt_AS_LONG(arg));
1823 else if (PyLong_Check(arg))
1826 *obj = Long((jlong) PyLong_AsLongLong(arg));
1828 else if (PyFloat_Check(arg))
1831 *obj = Double((jdouble) PyFloat_AS_DOUBLE(arg));
1839 int boxShort(PyTypeObject *type, PyObject *arg, java::lang::Object *obj)
1841 int result = boxJObject(type, arg, obj);
1846 if (PyInt_Check(arg))
1848 int n = (int) PyInt_AS_LONG(arg);
1849 short sn = (short) n;
1854 *obj = Short((jshort) sn);
1859 else if (PyLong_Check(arg))
1861 PY_LONG_LONG ln = PyLong_AsLongLong(arg);
1862 short sn = (short) ln;
1867 *obj = Short((jshort) sn);
1872 else if (PyFloat_Check(arg))
1874 double d = PyFloat_AS_DOUBLE(arg);
1875 short sn = (short) (int) d;
1877 if ((double) sn == d)
1880 *obj = Short((jshort) sn);
1891 int boxString(PyTypeObject *type, PyObject *arg, java::lang::Object *obj)
1893 int result = boxJObject(type, arg, obj);
1898 if (PyString_Check(arg) || PyUnicode_Check(arg))
1903 if (PyErr_Occurred())
1913 int boxObject(PyTypeObject *type, PyObject *arg, java::lang::Object *obj)
1915 int result = boxJObject(type, arg, obj);
1922 if (PyString_Check(arg) || PyUnicode_Check(arg))
1925 if (PyErr_Occurred())
1928 else if (arg == Py_True)
1929 *obj = *Boolean::TRUE;
1930 else if (arg == Py_False)
1931 *obj = *Boolean::FALSE;
1932 else if (PyInt_Check(arg))
1934 long ln = PyInt_AS_LONG(arg);
1938 *obj = Long((jlong) ln);
1940 *obj = Integer((jint) n);
1942 else if (PyLong_Check(arg))
1943 *obj = Long((jlong) PyLong_AsLongLong(arg));
1944 else if (PyFloat_Check(arg))
1945 *obj = Double((jdouble) PyFloat_AS_DOUBLE(arg));
1949 else if (!(PyString_Check(arg) || PyUnicode_Check(arg) ||
1950 arg == Py_True || arg == Py_False ||
1951 PyInt_Check(arg) || PyLong_Check(arg) ||
1952 PyFloat_Check(arg)))
1959 #ifdef _java_generics
1960 PyObject *typeParameters(PyTypeObject *types[], size_t size)
1962 size_t count = size / sizeof(PyTypeObject *);
1963 PyObject *tuple = PyTuple_New(count);
1965 for (size_t i = 0; i < count; i++) {
1966 PyObject *type = (PyObject *) types[i];
1971 PyTuple_SET_ITEM(tuple, i, type);