jcc/jcc/sources/functions.cpp

   1 /*
   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
   5  *
   6  *       http://www.apache.org/licenses/LICENSE-2.0
   7  *
   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.
  13  */
  14
  15 #include <jni.h>
  16 #include <stdarg.h>
  17
  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"
  31 #include "JArray.h"
  32 #include "functions.h"
  33 #include "macros.h"
  34
  35 using namespace java::lang;
  36 using namespace java::util;
  37
  38 PyObject *PyExc_JavaError = PyExc_ValueError;
  39 PyObject *PyExc_InvalidArgsError = PyExc_ValueError;
  40
  41 PyObject *_set_exception_types(PyObject *self, PyObject *args)
  42 {
  43     if (!PyArg_ParseTuple(args, "OO",
  44                           &PyExc_JavaError, &PyExc_InvalidArgsError))
  45         return NULL;
  46
  47     Py_RETURN_NONE;
  48 }
  49
  50 PyObject *_set_function_self(PyObject *self, PyObject *args)
  51 {
  52     PyObject *object, *module;
  53
  54     if (!PyArg_ParseTuple(args, "OO", &object, &module))
  55         return NULL;
  56
  57     if (!PyCFunction_Check(object))
  58     {
  59         PyErr_SetObject(PyExc_TypeError, object);
  60         return NULL;
  61     }
  62
  63     PyCFunctionObject *cfn = (PyCFunctionObject *) object;
  64
  65     Py_INCREF(module);
  66     Py_XDECREF(cfn->m_self);
  67     cfn->m_self = module;
  68
  69     Py_RETURN_NONE;
  70 }
  71
  72 PyObject *findClass(PyObject *self, PyObject *args)
  73 {
  74     char *className;
  75
  76     if (!PyArg_ParseTuple(args, "s", &className))
  77         return NULL;
  78
  79     try {
  80         jclass cls = env->findClass(className);
  81
  82         if (cls)
  83             return t_Class::wrap_Object(Class(cls));
  84     } catch (int e) {
  85         switch (e) {
  86           case _EXC_PYTHON:
  87             return NULL;
  88           case _EXC_JAVA:
  89             return PyErr_SetJavaError();
  90           default:
  91             throw;
  92         }
  93     }
  94
  95     Py_RETURN_NONE;
  96 }
  97
  98 static boxfn get_boxfn(PyTypeObject *type)
  99 {
 100     static PyObject *boxfn_ = PyString_FromString("boxfn_");
 101     PyObject *cobj = PyObject_GetAttr((PyObject *) type, boxfn_);
 102     boxfn fn;
 103
 104     if (cobj == NULL)
 105         return NULL;
 106
 107     fn = (boxfn) PyCObject_AsVoidPtr(cobj);
 108     Py_DECREF(cobj);
 109
 110     return fn;
 111 }
 112
 113 static int is_instance_of(PyObject *arg, PyTypeObject *type)
 114 {
 115     static PyObject *class_ = PyString_FromString("class_");
 116     PyObject *clsObj = PyObject_GetAttr((PyObject *) type, class_);
 117     int result;
 118
 119     if (clsObj == NULL)
 120         return -1;
 121
 122     result = env->get_vm_env()->
 123         IsInstanceOf(((t_Object *) arg)->object.this$,
 124                      (jclass) ((t_Object *) clsObj)->object.this$);
 125     Py_DECREF(clsObj);
 126
 127     return result;
 128 }
 129
 130
 131 #if defined(_MSC_VER) || defined(__SUNPRO_CC)
 132 int __parseArgs(PyObject *args, char *types, ...)
 133 {
 134     int count = ((PyTupleObject *)(args))->ob_size;
 135     va_list list, check;
 136
 137     va_start(list, types);
 138     va_start(check, types);
 139
 140     return _parseArgs(((PyTupleObject *)(args))->ob_item, count, types,
 141                       list, check);
 142 }
 143
 144 int __parseArg(PyObject *arg, char *types, ...)
 145 {
 146     va_list list, check;
 147
 148     va_start(list, types);
 149     va_start(check, types);
 150
 151     return _parseArgs(&arg, 1, types, list, check);
 152 }
 153
 154 int _parseArgs(PyObject **args, unsigned int count, char *types,
 155                va_list list, va_list check)
 156 {
 157     unsigned int typeCount = strlen(types);
 158
 159     if (count > typeCount)
 160         return -1;
 161 #else
 162
 163 int _parseArgs(PyObject **args, unsigned int count, char *types, ...)
 164 {
 165     unsigned int typeCount = strlen(types);
 166     va_list list, check;
 167
 168     if (count > typeCount)
 169         return -1;
 170
 171     va_start(list, types);
 172     va_start(check, types);
 173 #endif
 174
 175     if (!env->vm)
 176     {
 177         PyErr_SetString(PyExc_RuntimeError, "initVM() must be called first");
 178         return -1;
 179     }
 180
 181     JNIEnv *vm_env = env->get_vm_env();
 182
 183     if (!vm_env)
 184     {
 185         PyErr_SetString(PyExc_RuntimeError, "attachCurrentThread() must be called first");
 186         return -1;
 187     }
 188
 189     unsigned int pos = 0;
 190     int array = 0;
 191
 192     for (unsigned int a = 0; a < count; a++, pos++) {
 193         PyObject *arg = args[a];
 194
 195         switch (types[pos]) {
 196           case '[':
 197           {
 198               if (++array > 1)
 199                   return -1;
 200
 201               a -= 1;
 202               break;
 203           }
 204
 205           case 'j':           /* Java object, with class$    */
 206           case 'k':           /* Java object, with initializeClass */
 207           case 'K':           /* Java object, with initializeClass and params */
 208           {
 209               jclass cls = NULL;
 210
 211               switch (types[pos]) {
 212                 case 'j':
 213                   cls = (jclass) va_arg(list, Class *)->this$;
 214                   break;
 215                 case 'k':
 216                 case 'K':
 217                   try {
 218                       getclassfn initializeClass = va_arg(list, getclassfn);
 219                       cls = (*initializeClass)();
 220                   } catch (int e) {
 221                       switch (e) {
 222                         case _EXC_PYTHON:
 223                           return -1;
 224                         case _EXC_JAVA:
 225                           PyErr_SetJavaError();
 226                           return -1;
 227                         default:
 228                           throw;
 229                       }
 230                   }
 231                   break;
 232               }
 233
 234               if (arg == Py_None)
 235                   break;
 236
 237               /* ensure that class Class is initialized (which may not be the
 238                * case because of earlier recursion avoidance (JObject(cls)).
 239                */
 240               if (!Class::class$)
 241                   Class::initializeClass();
 242
 243               if (array)
 244               {
 245                   if (PyObject_TypeCheck(arg, PY_TYPE(JArrayObject)))
 246                       break;
 247
 248                   if (PySequence_Check(arg) &&
 249                       !PyString_Check(arg) && !PyUnicode_Check(arg))
 250                   {
 251                       if (PySequence_Length(arg) > 0)
 252                       {
 253                           PyObject *obj = PySequence_GetItem(arg, 0);
 254                           int ok = 0;
 255
 256                           if (obj == Py_None)
 257                               ok = 1;
 258                           else if (PyObject_TypeCheck(obj, &PY_TYPE(Object)) &&
 259                                    vm_env->IsInstanceOf(((t_Object *) obj)->object.this$, cls))
 260                               ok = 1;
 261                           else if (PyObject_TypeCheck(obj, &PY_TYPE(FinalizerProxy)))
 262                           {
 263                               PyObject *o = ((t_fp *) obj)->object;
 264
 265                               if (PyObject_TypeCheck(o, &PY_TYPE(Object)) &&
 266                                   vm_env->IsInstanceOf(((t_Object *) o)->object.this$, cls))
 267                                   ok = 1;
 268                           }
 269
 270                           Py_DECREF(obj);
 271                           if (ok)
 272                               break;
 273                       }
 274                       else
 275                           break;
 276                   }
 277               }
 278               else if (PyObject_TypeCheck(arg, &PY_TYPE(Object)) &&
 279                        vm_env->IsInstanceOf(((t_Object *) arg)->object.this$, cls))
 280                   break;
 281               else if (PyObject_TypeCheck(arg, &PY_TYPE(FinalizerProxy)))
 282               {
 283                   arg = ((t_fp *) arg)->object;
 284                   if (PyObject_TypeCheck(arg, &PY_TYPE(Object)) &&
 285                       vm_env->IsInstanceOf(((t_Object *) arg)->object.this$, cls))
 286                       break;
 287               }
 288
 289               return -1;
 290           }
 291
 292           case 'Z':           /* boolean, strict */
 293           {
 294               if (array)
 295               {
 296                   if (arg == Py_None)
 297                       break;
 298
 299                   if (PyObject_TypeCheck(arg, PY_TYPE(JArrayBool)))
 300                       break;
 301
 302                   if (PySequence_Check(arg))
 303                   {
 304                       if (PySequence_Length(arg) > 0)
 305                       {
 306                           PyObject *obj = PySequence_GetItem(arg, 0);
 307                           int ok = obj == Py_True || obj == Py_False;
 308
 309                           Py_DECREF(obj);
 310                           if (ok)
 311                               break;
 312                       }
 313                       else
 314                           break;
 315                   }
 316               }
 317               else if (arg == Py_True || arg == Py_False)
 318                   break;
 319
 320               return -1;
 321           }
 322
 323           case 'B':           /* byte */
 324           {
 325               if (array)
 326               {
 327                   if (arg == Py_None)
 328                       break;
 329                   if (PyObject_TypeCheck(arg, PY_TYPE(JArrayByte)))
 330                       break;
 331               }
 332               else if (PyString_Check(arg) && (PyString_Size(arg) == 1))
 333                   break;
 334               else if (PyInt_CheckExact(arg))
 335                   break;
 336
 337               return -1;
 338           }
 339
 340           case 'C':           /* char */
 341           {
 342               if (array)
 343               {
 344                   if (arg == Py_None)
 345                       break;
 346                   if (PyObject_TypeCheck(arg, PY_TYPE(JArrayChar)))
 347                       break;
 348               }
 349               else if (PyUnicode_Check(arg) && PyUnicode_GET_SIZE(arg) == 1)
 350                   break;
 351               return -1;
 352           }
 353
 354           case 'I':           /* int */
 355           {
 356               if (array)
 357               {
 358                   if (arg == Py_None)
 359                       break;
 360
 361                   if (PyObject_TypeCheck(arg, PY_TYPE(JArrayInt)))
 362                       break;
 363
 364                   if (PySequence_Check(arg))
 365                   {
 366                       if (PySequence_Length(arg) > 0)
 367                       {
 368                           PyObject *obj = PySequence_GetItem(arg, 0);
 369                           int ok = PyInt_CheckExact(obj);
 370
 371                           Py_DECREF(obj);
 372                           if (ok)
 373                               break;
 374                       }
 375                       else
 376                           break;
 377                   }
 378               }
 379               else if (PyInt_CheckExact(arg))
 380                   break;
 381
 382               return -1;
 383           }
 384
 385           case 'S':           /* short */
 386           {
 387               if (array)
 388               {
 389                   if (arg == Py_None)
 390                       break;
 391
 392                   if (PyObject_TypeCheck(arg, PY_TYPE(JArrayShort)))
 393                       break;
 394
 395                   if (PySequence_Check(arg))
 396                   {
 397                       if (PySequence_Length(arg) > 0)
 398                       {
 399                           PyObject *obj = PySequence_GetItem(arg, 0);
 400                           int ok = PyInt_CheckExact(obj);
 401
 402                           Py_DECREF(obj);
 403                           if (ok)
 404                               break;
 405                       }
 406                       else
 407                           break;
 408                   }
 409               }
 410               else if (PyInt_CheckExact(arg))
 411                   break;
 412
 413               return -1;
 414           }
 415
 416           case 'D':           /* double */
 417           {
 418               if (array)
 419               {
 420                   if (arg == Py_None)
 421                       break;
 422
 423                   if (PyObject_TypeCheck(arg, PY_TYPE(JArrayDouble)))
 424                       break;
 425
 426                   if (PySequence_Check(arg))
 427                   {
 428                       if (PySequence_Length(arg) > 0)
 429                       {
 430                           PyObject *obj = PySequence_GetItem(arg, 0);
 431                           int ok = PyFloat_CheckExact(obj);
 432
 433                           Py_DECREF(obj);
 434                           if (ok)
 435                               break;
 436                       }
 437                       else
 438                           break;
 439                   }
 440               }
 441               else if (PyFloat_CheckExact(arg))
 442                   break;
 443
 444               return -1;
 445           }
 446
 447           case 'F':           /* float */
 448           {
 449               if (array)
 450               {
 451                   if (arg == Py_None)
 452                       break;
 453
 454                   if (PyObject_TypeCheck(arg, PY_TYPE(JArrayFloat)))
 455                       break;
 456
 457                   if (PySequence_Check(arg))
 458                   {
 459                       if (PySequence_Length(arg) > 0)
 460                       {
 461                           PyObject *obj = PySequence_GetItem(arg, 0);
 462                           int ok = PyFloat_CheckExact(obj);
 463
 464                           Py_DECREF(obj);
 465                           if (ok)
 466                               break;
 467                       }
 468                       else
 469                           break;
 470                   }
 471               }
 472               else if (PyFloat_CheckExact(arg))
 473                   break;
 474
 475               return -1;
 476           }
 477
 478           case 'J':           /* long long */
 479           {
 480               if (array)
 481               {
 482                   if (arg == Py_None)
 483                       break;
 484
 485                   if (PyObject_TypeCheck(arg, PY_TYPE(JArrayLong)))
 486                       break;
 487
 488                   if (PySequence_Check(arg))
 489                   {
 490                       if (PySequence_Length(arg) > 0)
 491                       {
 492                           PyObject *obj = PySequence_GetItem(arg, 0);
 493                           int ok = PyLong_CheckExact(obj);
 494
 495                           Py_DECREF(obj);
 496                           if (ok)
 497                               break;
 498                       }
 499                       else
 500                           break;
 501                   }
 502               }
 503               else if (PyLong_CheckExact(arg))
 504                   break;
 505
 506               return -1;
 507           }
 508
 509           case 's':           /* string  */
 510           {
 511               if (array)
 512               {
 513                   if (arg == Py_None)
 514                       break;
 515
 516                   if (PyObject_TypeCheck(arg, PY_TYPE(JArrayString)))
 517                       break;
 518
 519                   if (PySequence_Check(arg) &&
 520                       !PyString_Check(arg) && !PyUnicode_Check(arg))
 521                   {
 522                       if (PySequence_Length(arg) > 0)
 523                       {
 524                           PyObject *obj = PySequence_GetItem(arg, 0);
 525                           int ok =
 526                               (obj == Py_None ||
 527                                PyString_Check(obj) || PyUnicode_Check(obj));
 528
 529                           Py_DECREF(obj);
 530                           if (ok)
 531                               break;
 532                       }
 533                       else
 534                           break;
 535                   }
 536               }
 537               else if (arg == Py_None ||
 538                        PyString_Check(arg) || PyUnicode_Check(arg))
 539                   break;
 540
 541               return -1;
 542           }
 543
 544           case 'o':         /* java.lang.Object */
 545             break;
 546
 547           case 'O':         /* java.lang.Object with type param */
 548           {
 549               PyTypeObject *type = va_arg(list, PyTypeObject *);
 550
 551               if (type != NULL)
 552               {
 553                   boxfn fn = get_boxfn(type);
 554
 555                   if (fn == NULL || fn(type, arg, NULL) < 0)
 556                       return -1;
 557               }
 558               break;
 559           }
 560
 561           case 'T':         /* tuple of python types with wrapfn_ */
 562           {
 563               static PyObject *wrapfn_ = PyString_FromString("wrapfn_");
 564               int len = va_arg(list, int);
 565
 566               if (PyTuple_Check(arg))
 567               {
 568                   if (PyTuple_GET_SIZE(arg) != len)
 569                       return -1;
 570
 571                   for (int i = 0; i < len; i++) {
 572                       PyObject *type = PyTuple_GET_ITEM(arg, i);
 573
 574                       if (!(type == Py_None ||
 575                             (PyType_Check(type) &&
 576                              PyObject_HasAttr(type, wrapfn_))))
 577                           return -1;
 578                   }
 579                   break;
 580               }
 581               return -1;
 582           }
 583
 584           default:
 585             return -1;
 586         }
 587
 588         if (types[pos] != '[')
 589             array = 0;
 590     }
 591
 592     if (array)
 593         return -1;
 594
 595     pos = 0;
 596
 597     for (unsigned int a = 0; a < count; a++, pos++) {
 598         PyObject *arg = args[a];
 599
 600         switch (types[pos]) {
 601           case '[':
 602           {
 603               if (++array > 1)
 604                   return -1;
 605
 606               a -= 1;
 607               break;
 608           }
 609
 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 */
 613           {
 614               jclass cls = NULL;
 615
 616               switch (types[pos]) {
 617                 case 'j':
 618                   cls = (jclass) va_arg(check, Class *)->this$;
 619                   break;
 620                 case 'k':
 621                 case 'K':
 622                   getclassfn initializeClass = va_arg(check, getclassfn);
 623                   cls = (*initializeClass)();
 624                   break;
 625               }
 626
 627               if (array)
 628               {
 629                   JArray<jobject> *array = va_arg(list, JArray<jobject> *);
 630
 631 #ifdef _java_generics
 632                   if (types[pos] == 'K')
 633                   {
 634                       PyTypeObject ***tp = va_arg(list, PyTypeObject ***);
 635
 636                       va_arg(list, getparametersfn);
 637                       *tp = NULL;
 638                   }
 639 #endif
 640                   if (arg == Py_None)
 641                       *array = JArray<jobject>((jobject) NULL);
 642                   else if (PyObject_TypeCheck(arg, PY_TYPE(JArrayObject)))
 643                       *array = ((t_JArray<jobject> *) arg)->array;
 644                   else
 645                       *array = JArray<jobject>(cls, arg);
 646
 647                   if (PyErr_Occurred())
 648                       return -1;
 649               }
 650               else
 651               {
 652                   Object *obj = va_arg(list, Object *);
 653
 654                   if (PyObject_TypeCheck(arg, &PY_TYPE(FinalizerProxy)))
 655                       arg = ((t_fp *) arg)->object;
 656
 657 #ifdef _java_generics
 658                   if (types[pos] == 'K')
 659                   {
 660                       PyTypeObject ***tp = va_arg(list, PyTypeObject ***);
 661                       PyTypeObject **(*parameters_)(void *) =
 662                           va_arg(list, getparametersfn);
 663
 664                       if (arg == Py_None)
 665                           *tp = NULL;
 666                       else
 667                           *tp = (*parameters_)(arg);
 668                   }
 669 #endif
 670
 671                   *obj = arg == Py_None
 672                       ? Object(NULL)
 673                       : ((t_Object *) arg)->object;
 674               }
 675               break;
 676           }
 677
 678           case 'Z':           /* boolean, strict */
 679           {
 680               if (array)
 681               {
 682                   JArray<jboolean> *array = va_arg(list, JArray<jboolean> *);
 683
 684                   if (arg == Py_None)
 685                       *array = JArray<jboolean>((jobject) NULL);
 686                   else if (PyObject_TypeCheck(arg, PY_TYPE(JArrayBool)))
 687                       *array = ((t_JArray<jboolean> *) arg)->array;
 688                   else
 689                       *array = JArray<jboolean>(arg);
 690
 691                   if (PyErr_Occurred())
 692                       return -1;
 693               }
 694               else
 695               {
 696                   jboolean *b = va_arg(list, jboolean *);
 697                   *b = arg == Py_True;
 698               }
 699               break;
 700           }
 701
 702           case 'B':           /* byte */
 703           {
 704               if (array)
 705               {
 706                   JArray<jbyte> *array = va_arg(list, JArray<jbyte> *);
 707
 708                   if (arg == Py_None)
 709                       *array = JArray<jbyte>((jobject) NULL);
 710                   else if (PyObject_TypeCheck(arg, PY_TYPE(JArrayByte)))
 711                       *array = ((t_JArray<jbyte> *) arg)->array;
 712                   else
 713                       *array = JArray<jbyte>(arg);
 714
 715                   if (PyErr_Occurred())
 716                       return -1;
 717               }
 718               else if (PyString_Check(arg))
 719               {
 720                   jbyte *a = va_arg(list, jbyte *);
 721                   *a = (jbyte) PyString_AS_STRING(arg)[0];
 722               }
 723               else
 724               {
 725                   jbyte *a = va_arg(list, jbyte *);
 726                   *a = (jbyte) PyInt_AsLong(arg);
 727               }
 728               break;
 729           }
 730
 731           case 'C':           /* char */
 732           {
 733               if (array)
 734               {
 735                   JArray<jchar> *array = va_arg(list, JArray<jchar> *);
 736
 737                   if (arg == Py_None)
 738                       *array = JArray<jchar>((jobject) NULL);
 739                   else if (PyObject_TypeCheck(arg, PY_TYPE(JArrayChar)))
 740                       *array = ((t_JArray<jchar> *) arg)->array;
 741                   else
 742                       *array = JArray<jchar>(arg);
 743
 744                   if (PyErr_Occurred())
 745                       return -1;
 746               }
 747               else
 748               {
 749                   jchar *c = va_arg(list, jchar *);
 750                   *c = (jchar) PyUnicode_AS_UNICODE(arg)[0];
 751               }
 752               break;
 753           }
 754
 755           case 'I':           /* int */
 756           {
 757               if (array)
 758               {
 759                   JArray<jint> *array = va_arg(list, JArray<jint> *);
 760
 761                   if (arg == Py_None)
 762                       *array = JArray<jint>((jobject) NULL);
 763                   else if (PyObject_TypeCheck(arg, PY_TYPE(JArrayInt)))
 764                       *array = ((t_JArray<jint> *) arg)->array;
 765                   else
 766                       *array = JArray<jint>(arg);
 767
 768                   if (PyErr_Occurred())
 769                       return -1;
 770               }
 771               else
 772               {
 773                   jint *n = va_arg(list, jint *);
 774                   *n = (jint) PyInt_AsLong(arg);
 775               }
 776               break;
 777           }
 778
 779           case 'S':           /* short */
 780           {
 781               if (array)
 782               {
 783                   JArray<jshort> *array = va_arg(list, JArray<jshort> *);
 784
 785                   if (arg == Py_None)
 786                       *array = JArray<jshort>((jobject) NULL);
 787                   else if (PyObject_TypeCheck(arg, PY_TYPE(JArrayShort)))
 788                       *array = ((t_JArray<jshort> *) arg)->array;
 789                   else
 790                       *array = JArray<jshort>(arg);
 791
 792                   if (PyErr_Occurred())
 793                       return -1;
 794               }
 795               else
 796               {
 797                   jshort *n = va_arg(list, jshort *);
 798                   *n = (jshort) PyInt_AsLong(arg);
 799               }
 800               break;
 801           }
 802
 803           case 'D':           /* double */
 804           {
 805               if (array)
 806               {
 807                   JArray<jdouble> *array = va_arg(list, JArray<jdouble> *);
 808
 809                   if (arg == Py_None)
 810                       *array = JArray<jdouble>((jobject) NULL);
 811                   else if (PyObject_TypeCheck(arg, PY_TYPE(JArrayDouble)))
 812                       *array = ((t_JArray<jdouble> *) arg)->array;
 813                   else
 814                       *array = JArray<jdouble>(arg);
 815
 816                   if (PyErr_Occurred())
 817                       return -1;
 818               }
 819               else
 820               {
 821                   jdouble *d = va_arg(list, jdouble *);
 822                   *d = (jdouble) PyFloat_AsDouble(arg);
 823               }
 824               break;
 825           }
 826
 827           case 'F':           /* float */
 828           {
 829               if (array)
 830               {
 831                   JArray<jfloat> *array = va_arg(list, JArray<jfloat> *);
 832
 833                   if (arg == Py_None)
 834                       *array = JArray<jfloat>((jobject) NULL);
 835                   else if (PyObject_TypeCheck(arg, PY_TYPE(JArrayFloat)))
 836                       *array = ((t_JArray<jfloat> *) arg)->array;
 837                   else
 838                       *array = JArray<jfloat>(arg);
 839
 840                   if (PyErr_Occurred())
 841                       return -1;
 842               }
 843               else
 844               {
 845                   jfloat *d = va_arg(list, jfloat *);
 846                   *d = (jfloat) (float) PyFloat_AsDouble(arg);
 847               }
 848               break;
 849           }
 850
 851           case 'J':           /* long long */
 852           {
 853               if (array)
 854               {
 855                   JArray<jlong> *array = va_arg(list, JArray<jlong> *);
 856
 857                   if (arg == Py_None)
 858                       *array = JArray<jlong>((jobject) NULL);
 859                   else if (PyObject_TypeCheck(arg, PY_TYPE(JArrayLong)))
 860                       *array = ((t_JArray<jlong> *) arg)->array;
 861                   else
 862                       *array = JArray<jlong>(arg);
 863
 864                   if (PyErr_Occurred())
 865                       return -1;
 866               }
 867               else
 868               {
 869                   jlong *l = va_arg(list, jlong *);
 870                   *l = (jlong) PyLong_AsLongLong(arg);
 871               }
 872               break;
 873           }
 874
 875           case 's':           /* string  */
 876           {
 877               if (array)
 878               {
 879                   JArray<jstring> *array = va_arg(list, JArray<jstring> *);
 880
 881                   if (arg == Py_None)
 882                       *array = JArray<jstring>((jobject) NULL);
 883                   else if (PyObject_TypeCheck(arg, PY_TYPE(JArrayString)))
 884                       *array = ((t_JArray<jstring> *) arg)->array;
 885                   else
 886                       *array = JArray<jstring>(arg);
 887
 888                   if (PyErr_Occurred())
 889                       return -1;
 890               }
 891               else
 892               {
 893                   String *str = va_arg(list, String *);
 894
 895                   if (arg == Py_None)
 896                       *str = String(NULL);
 897                   else
 898                   {
 899                       *str = p2j(arg);
 900                       if (PyErr_Occurred())
 901                           return -1;
 902                   }
 903               }
 904               break;
 905           }
 906
 907           case 'o':           /* java.lang.Object  */
 908           case 'O':           /* java.lang.Object with type param */
 909           {
 910               if (array)
 911               {
 912                   JArray<Object> *array = va_arg(list, JArray<Object> *);
 913
 914                   if (arg == Py_None)
 915                       *array = JArray<Object>((jobject) NULL);
 916                   else
 917                       *array = JArray<Object>(arg);
 918
 919                   if (PyErr_Occurred())
 920                       return -1;
 921               }
 922               else
 923               {
 924                   Object *obj = va_arg(list, Object *);
 925
 926                   if (types[pos] == 'O')
 927                   {
 928                       PyTypeObject *type = va_arg(check, PyTypeObject *);
 929
 930                       if (type != NULL)
 931                       {
 932                           boxfn fn = get_boxfn(type);
 933
 934                           if (fn == NULL || fn(type, arg, obj) < 0)
 935                               return -1;
 936
 937                           break;
 938                       }
 939                   }
 940
 941                   if (boxObject(NULL, arg, obj) < 0)
 942                       return -1;
 943               }
 944               break;
 945           }
 946
 947           case 'T':         /* tuple of python types with wrapfn_ */
 948           {
 949               int len = va_arg(check, int);
 950               PyTypeObject **types = va_arg(list, PyTypeObject **);
 951
 952               for (int i = 0; i < len; i++) {
 953                   PyObject *type = PyTuple_GET_ITEM(arg, i);
 954
 955                   if (type == Py_None)
 956                       types[i] = NULL;
 957                   else
 958                       types[i] = (PyTypeObject *) type;
 959               }
 960               break;
 961           }
 962
 963           default:
 964             return -1;
 965         }
 966
 967         if (types[pos] != '[')
 968             array = 0;
 969     }
 970
 971     if (pos == typeCount)
 972         return 0;
 973
 974     return -1;
 975 }
 976
 977
 978 String p2j(PyObject *object)
 979 {
 980     return String(env->fromPyString(object));
 981 }
 982
 983 PyObject *j2p(const String& js)
 984 {
 985     return env->fromJString((jstring) js.this$, 0);
 986 }
 987
 988 PyObject *PyErr_SetArgsError(char *name, PyObject *args)
 989 {
 990     if (!PyErr_Occurred())
 991     {
 992         PyObject *err = Py_BuildValue("(sO)", name, args);
 993
 994         PyErr_SetObject(PyExc_InvalidArgsError, err);
 995         Py_DECREF(err);
 996     }
 997
 998     return NULL;
 999 }
1000
1001 PyObject *PyErr_SetArgsError(PyObject *self, char *name, PyObject *args)
1002 {
1003     if (!PyErr_Occurred())
1004     {
1005         PyObject *type = (PyObject *) self->ob_type;
1006         PyObject *err = Py_BuildValue("(OsO)", type, name, args);
1007
1008         PyErr_SetObject(PyExc_InvalidArgsError, err);
1009         Py_DECREF(err);
1010     }
1011
1012     return NULL;
1013 }
1014
1015 PyObject *PyErr_SetArgsError(PyTypeObject *type, char *name, PyObject *args)
1016 {
1017     if (!PyErr_Occurred())
1018     {
1019         PyObject *err = Py_BuildValue("(OsO)", type, name, args);
1020
1021         PyErr_SetObject(PyExc_InvalidArgsError, err);
1022         Py_DECREF(err);
1023     }
1024
1025     return NULL;
1026 }
1027
1028 PyObject *PyErr_SetJavaError()
1029 {
1030     JNIEnv *vm_env = env->get_vm_env();
1031     jthrowable throwable = vm_env->ExceptionOccurred();
1032     PyObject *err;
1033
1034     vm_env->ExceptionClear();
1035     err = t_Throwable::wrap_Object(Throwable(throwable));
1036
1037     PyErr_SetObject(PyExc_JavaError, err);
1038     Py_DECREF(err);
1039
1040     return NULL;
1041 }
1042
1043 void throwPythonError(void)
1044 {
1045     PyObject *exc = PyErr_Occurred();
1046
1047     if (exc && PyErr_GivenExceptionMatches(exc, PyExc_JavaError))
1048     {
1049         PyObject *value, *traceback;
1050
1051         PyErr_Fetch(&exc, &value, &traceback);
1052         if (value)
1053         {
1054             PyObject *je = PyObject_CallMethod(value, "getJavaException", "");
1055
1056             if (!je)
1057                 PyErr_Restore(exc, value, traceback);
1058             else
1059             {
1060                 Py_DECREF(exc);
1061                 Py_DECREF(value);
1062                 Py_XDECREF(traceback);
1063                 exc = je;
1064
1065                 if (exc && PyObject_TypeCheck(exc, &PY_TYPE(Throwable)))
1066                 {
1067                     jobject jobj = ((t_Throwable *) exc)->object.this$;
1068
1069                     env->get_vm_env()->Throw((jthrowable) jobj);
1070                     Py_DECREF(exc);
1071
1072                     return;
1073                 }
1074             }
1075         }
1076         else
1077         {
1078             Py_DECREF(exc);
1079             Py_XDECREF(traceback);
1080         }
1081     }
1082     else if (exc && PyErr_GivenExceptionMatches(exc, PyExc_StopIteration))
1083     {
1084         PyErr_Clear();
1085         return;
1086     }
1087
1088     if (exc)
1089     {
1090         PyObject *name = PyObject_GetAttrString(exc, "__name__");
1091
1092         env->get_vm_env()->ThrowNew(env->getPythonExceptionClass(),
1093                                     PyString_AS_STRING(name));
1094         Py_DECREF(name);
1095     }
1096     else
1097         env->get_vm_env()->ThrowNew(env->getPythonExceptionClass(),
1098                                     "python error");
1099 }
1100
1101 void throwTypeError(const char *name, PyObject *object)
1102 {
1103     PyObject *tuple = Py_BuildValue("(ssO)", "while calling", name, object);
1104
1105     PyErr_SetObject(PyExc_TypeError, tuple);
1106     Py_DECREF(tuple);
1107
1108     env->get_vm_env()->ThrowNew(env->getPythonExceptionClass(), "type error");
1109 }
1110
1111 int abstract_init(PyObject *self, PyObject *args, PyObject *kwds)
1112 {
1113     PyObject *err =
1114         Py_BuildValue("(sO)", "instantiating java class", self->ob_type);
1115
1116     PyErr_SetObject(PyExc_NotImplementedError, err);
1117     Py_DECREF(err);
1118
1119     return -1;
1120 }
1121
1122 PyObject *callSuper(PyTypeObject *type, const char *name, PyObject *args,
1123                     int cardinality)
1124 {
1125     PyObject *super = (PyObject *) type->tp_base;
1126     PyObject *method =
1127         PyObject_GetAttrString(super, (char *) name); // python 2.4 cast
1128     PyObject *value;
1129
1130     if (!method)
1131         return NULL;
1132
1133     if (cardinality > 1)
1134         value = PyObject_Call(method, args, NULL);
1135     else
1136     {
1137 #if PY_VERSION_HEX < 0x02040000
1138         PyObject *tuple = Py_BuildValue("(O)", args);
1139 #else
1140         PyObject *tuple = PyTuple_Pack(1, args);
1141 #endif
1142         value = PyObject_Call(method, tuple, NULL);
1143         Py_DECREF(tuple);
1144     }
1145
1146     Py_DECREF(method);
1147
1148     return value;
1149 }
1150
1151 PyObject *callSuper(PyTypeObject *type, PyObject *self,
1152                     const char *name, PyObject *args, int cardinality)
1153 {
1154 #if PY_VERSION_HEX < 0x02040000
1155     PyObject *tuple = Py_BuildValue("(OO)", type, self);
1156 #else
1157     PyObject *tuple = PyTuple_Pack(2, type, self);
1158 #endif
1159     PyObject *super = PyObject_Call((PyObject *) &PySuper_Type, tuple, NULL);
1160     PyObject *method, *value;
1161
1162     Py_DECREF(tuple);
1163     if (!super)
1164         return NULL;
1165
1166     method = PyObject_GetAttrString(super, (char *) name); // python 2.4 cast
1167     Py_DECREF(super);
1168     if (!method)
1169         return NULL;
1170
1171     if (cardinality > 1)
1172         value = PyObject_Call(method, args, NULL);
1173     else
1174     {
1175 #if PY_VERSION_HEX < 0x02040000
1176         tuple = Py_BuildValue("(O)", args);
1177 #else
1178         tuple = PyTuple_Pack(1, args);
1179 #endif
1180         value = PyObject_Call(method, tuple, NULL);
1181         Py_DECREF(tuple);
1182     }
1183
1184     Py_DECREF(method);
1185
1186     return value;
1187 }
1188
1189 PyObject *castCheck(PyObject *obj, getclassfn initializeClass,
1190                     int reportError)
1191 {
1192     if (PyObject_TypeCheck(obj, &PY_TYPE(FinalizerProxy)))
1193         obj = ((t_fp *) obj)->object;
1194
1195     if (!PyObject_TypeCheck(obj, &PY_TYPE(Object)))
1196     {
1197         if (reportError)
1198             PyErr_SetObject(PyExc_TypeError, obj);
1199         return NULL;
1200     }
1201
1202     jobject jobj = ((t_Object *) obj)->object.this$;
1203
1204     if (jobj && !env->isInstanceOf(jobj, initializeClass))
1205     {
1206         if (reportError)
1207             PyErr_SetObject(PyExc_TypeError, obj);
1208
1209         return NULL;
1210     }
1211
1212     return obj;
1213 }
1214
1215 PyObject *get_extension_iterator(PyObject *self)
1216 {
1217     return PyObject_CallMethod(self, "iterator", "");
1218 }
1219
1220 PyObject *get_extension_next(PyObject *self)
1221 {
1222     return PyObject_CallMethod(self, "next", "");
1223 }
1224
1225 PyObject *get_extension_nextElement(PyObject *self)
1226 {
1227     return PyObject_CallMethod(self, "nextElement", "");
1228 }
1229
1230 jobjectArray fromPySequence(jclass cls, PyObject *sequence)
1231 {
1232     if (sequence == Py_None)
1233         return NULL;
1234
1235     if (!PySequence_Check(sequence))
1236     {
1237         PyErr_SetObject(PyExc_TypeError, sequence);
1238         return NULL;
1239     }
1240
1241     int length = PySequence_Length(sequence);
1242     jobjectArray array;
1243
1244     try {
1245         array = env->newObjectArray(cls, length);
1246     } catch (int e) {
1247         switch (e) {
1248           case _EXC_PYTHON:
1249             return NULL;
1250           case _EXC_JAVA:
1251             PyErr_SetJavaError();
1252             return NULL;
1253           default:
1254             throw;
1255         }
1256     }
1257
1258     JNIEnv *vm_env = env->get_vm_env();
1259
1260     for (int i = 0; i < length; i++) {
1261         PyObject *obj = PySequence_GetItem(sequence, i);
1262         int fromString = 0;
1263         jobject jobj;
1264
1265         if (!obj)
1266             break;
1267         else if (obj == Py_None)
1268             jobj = NULL;
1269         else if (PyString_Check(obj) || PyUnicode_Check(obj))
1270         {
1271             jobj = env->fromPyString(obj);
1272             fromString = 1;
1273         }
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 */
1279         {
1280             PyErr_SetObject(PyExc_TypeError, obj);
1281             Py_DECREF(obj);
1282             return NULL;
1283         }
1284
1285         Py_DECREF(obj);
1286
1287         try {
1288             env->setObjectArrayElement(array, i, jobj);
1289             if (fromString)
1290                 vm_env->DeleteLocalRef(jobj);
1291         } catch (int e) {
1292             switch (e) {
1293               case _EXC_JAVA:
1294                 PyErr_SetJavaError();
1295                 return NULL;
1296               default:
1297                 throw;
1298             }
1299         }
1300     }
1301
1302     return array;
1303 }
1304
1305 void installType(PyTypeObject *type, PyObject *module, char *name,
1306                  int isExtension)
1307 {
1308     if (PyType_Ready(type) == 0)
1309     {
1310         Py_INCREF(type);
1311         if (isExtension)
1312         {
1313             type->ob_type = &PY_TYPE(FinalizerClass);
1314             Py_INCREF(&PY_TYPE(FinalizerClass));
1315         }
1316         PyModule_AddObject(module, name, (PyObject *) type);
1317     }
1318 }
1319
1320 PyObject *wrapType(PyTypeObject *type, const jobject& obj)
1321 {
1322     static PyObject *wrapfn_ = PyString_FromString("wrapfn_");
1323     PyObject *cobj = PyObject_GetAttr((PyObject *) type, wrapfn_);
1324     PyObject *(*wrapfn)(const jobject&);
1325
1326     if (cobj == NULL)
1327         return NULL;
1328
1329     wrapfn = (PyObject *(*)(const jobject &)) PyCObject_AsVoidPtr(cobj);
1330     Py_DECREF(cobj);
1331
1332     return wrapfn(obj);
1333 }
1334
1335 PyObject *unboxBoolean(const jobject& obj)
1336 {
1337     if (obj != NULL)
1338     {
1339         if (!env->isInstanceOf(obj, java::lang::Boolean::initializeClass))
1340         {
1341             PyErr_SetObject(PyExc_TypeError,
1342                             (PyObject *) &java::lang::PY_TYPE(Boolean));
1343             return NULL;
1344         }
1345
1346         if (env->booleanValue(obj))
1347             Py_RETURN_TRUE;
1348
1349         Py_RETURN_FALSE;
1350     }
1351
1352     Py_RETURN_NONE;
1353 }
1354
1355 PyObject *unboxByte(const jobject &obj)
1356 {
1357     if (obj != NULL)
1358     {
1359         if (!env->isInstanceOf(obj, java::lang::Byte::initializeClass))
1360         {
1361             PyErr_SetObject(PyExc_TypeError,
1362                             (PyObject *) &java::lang::PY_TYPE(Byte));
1363             return NULL;
1364         }
1365
1366         return PyInt_FromLong((long) env->byteValue(obj));
1367     }
1368
1369     Py_RETURN_NONE;
1370 }
1371
1372 PyObject *unboxCharacter(const jobject &obj)
1373 {
1374     if (obj != NULL)
1375     {
1376         if (!env->isInstanceOf(obj, java::lang::Character::initializeClass))
1377         {
1378             PyErr_SetObject(PyExc_TypeError,
1379                             (PyObject *) &java::lang::PY_TYPE(Character));
1380             return NULL;
1381         }
1382
1383         jchar c = env->charValue(obj);
1384         return PyUnicode_FromUnicode((Py_UNICODE *) &c, 1);
1385     }
1386
1387     Py_RETURN_NONE;
1388 }
1389
1390 PyObject *unboxDouble(const jobject &obj)
1391 {
1392     if (obj != NULL)
1393     {
1394         if (!env->isInstanceOf(obj, java::lang::Double::initializeClass))
1395         {
1396             PyErr_SetObject(PyExc_TypeError,
1397                             (PyObject *) &java::lang::PY_TYPE(Double));
1398             return NULL;
1399         }
1400
1401         return PyFloat_FromDouble((double) env->doubleValue(obj));
1402     }
1403
1404     Py_RETURN_NONE;
1405 }
1406
1407 PyObject *unboxFloat(const jobject &obj)
1408 {
1409     if (obj != NULL)
1410     {
1411         if (!env->isInstanceOf(obj, java::lang::Float::initializeClass))
1412         {
1413             PyErr_SetObject(PyExc_TypeError,
1414                             (PyObject *) &java::lang::PY_TYPE(Float));
1415             return NULL;
1416         }
1417
1418         return PyFloat_FromDouble((double) env->floatValue(obj));
1419     }
1420
1421     Py_RETURN_NONE;
1422 }
1423
1424 PyObject *unboxInteger(const jobject &obj)
1425 {
1426     if (obj != NULL)
1427     {
1428         if (!env->isInstanceOf(obj, java::lang::Integer::initializeClass))
1429         {
1430             PyErr_SetObject(PyExc_TypeError,
1431                             (PyObject *) &java::lang::PY_TYPE(Integer));
1432             return NULL;
1433         }
1434
1435         return PyInt_FromLong((long) env->intValue(obj));
1436     }
1437
1438     Py_RETURN_NONE;
1439 }
1440
1441 PyObject *unboxLong(const jobject &obj)
1442 {
1443     if (obj != NULL)
1444     {
1445         if (!env->isInstanceOf(obj, java::lang::Long::initializeClass))
1446         {
1447             PyErr_SetObject(PyExc_TypeError,
1448                             (PyObject *) &java::lang::PY_TYPE(Long));
1449             return NULL;
1450         }
1451
1452         return PyLong_FromLongLong((PY_LONG_LONG) env->longValue(obj));
1453     }
1454
1455     Py_RETURN_NONE;
1456 }
1457
1458 PyObject *unboxShort(const jobject &obj)
1459 {
1460     if (obj != NULL)
1461     {
1462         if (!env->isInstanceOf(obj, java::lang::Short::initializeClass))
1463         {
1464             PyErr_SetObject(PyExc_TypeError,
1465                             (PyObject *) &java::lang::PY_TYPE(Short));
1466             return NULL;
1467         }
1468
1469         return PyInt_FromLong((long) env->shortValue(obj));
1470     }
1471
1472     Py_RETURN_NONE;
1473 }
1474
1475 PyObject *unboxString(const jobject &obj)
1476 {
1477     if (obj != NULL)
1478     {
1479         if (!env->isInstanceOf(obj, java::lang::String::initializeClass))
1480         {
1481             PyErr_SetObject(PyExc_TypeError,
1482                             (PyObject *) &java::lang::PY_TYPE(String));
1483             return NULL;
1484         }
1485
1486         return env->fromJString((jstring) obj, 0);
1487     }
1488
1489     Py_RETURN_NONE;
1490 }
1491
1492 static int boxJObject(PyTypeObject *type, PyObject *arg,
1493                       java::lang::Object *obj)
1494 {
1495     if (arg == Py_None)
1496     {
1497         if (obj != NULL)
1498             *obj = Object(NULL);
1499     }
1500     else if (PyObject_TypeCheck(arg, &PY_TYPE(Object)))
1501     {
1502         if (type != NULL && !is_instance_of(arg, type))
1503             return -1;
1504
1505         if (obj != NULL)
1506             *obj = ((t_Object *) arg)->object;
1507     }
1508     else if (PyObject_TypeCheck(arg, &PY_TYPE(FinalizerProxy)))
1509     {
1510         arg = ((t_fp *) arg)->object;
1511         if (PyObject_TypeCheck(arg, &PY_TYPE(Object)))
1512         {
1513             if (type != NULL && !is_instance_of(arg, type))
1514                 return -1;
1515
1516             if (obj != NULL)
1517                 *obj = ((t_Object *) arg)->object;
1518         }
1519         else
1520             return -1;
1521     }
1522     else
1523         return 1;
1524
1525     return 0;
1526 }
1527
1528 int boxBoolean(PyTypeObject *type, PyObject *arg, java::lang::Object *obj)
1529 {
1530     int result = boxJObject(type, arg, obj);
1531
1532     if (result <= 0)
1533         return result;
1534
1535     if (arg == Py_True)
1536     {
1537         if (obj != NULL)
1538             *obj = *Boolean::TRUE;
1539     }
1540     else if (arg == Py_False)
1541     {
1542         if (obj != NULL)
1543             *obj = *Boolean::FALSE;
1544     }
1545     else
1546         return -1;
1547
1548     return 0;
1549 }
1550
1551 int boxByte(PyTypeObject *type, PyObject *arg, java::lang::Object *obj)
1552 {
1553     int result = boxJObject(type, arg, obj);
1554
1555     if (result <= 0)
1556         return result;
1557
1558     if (PyInt_Check(arg))
1559     {
1560         int n = PyInt_AS_LONG(arg);
1561         jbyte b = (jbyte) n;
1562
1563         if (b == n)
1564         {
1565             if (obj != NULL)
1566                 *obj = Byte(b);
1567         }
1568         else
1569             return -1;
1570     }
1571     else if (PyLong_Check(arg))
1572     {
1573         PY_LONG_LONG ln = PyLong_AsLongLong(arg);
1574         jbyte b = (jbyte) ln;
1575
1576         if (b == ln)
1577         {
1578             if (obj != NULL)
1579                 *obj = Byte(b);
1580         }
1581         else
1582             return -1;
1583     }
1584     else if (PyFloat_Check(arg))
1585     {
1586         double d = PyFloat_AS_DOUBLE(arg);
1587         jbyte b = (jbyte) d;
1588
1589         if (b == d)
1590         {
1591             if (obj != NULL)
1592                 *obj = Byte(b);
1593         }
1594         else
1595             return -1;
1596     }
1597     else
1598         return -1;
1599
1600     return 0;
1601 }
1602
1603 int boxCharacter(PyTypeObject *type, PyObject *arg, java::lang::Object *obj)
1604 {
1605     int result = boxJObject(type, arg, obj);
1606
1607     if (result <= 0)
1608         return result;
1609
1610     if (PyString_Check(arg))
1611     {
1612         char *c;
1613         Py_ssize_t len;
1614
1615         if (PyString_AsStringAndSize(arg, &c, &len) < 0 || len != 1)
1616             return -1;
1617
1618         if (obj != NULL)
1619             *obj = Character((jchar) c[0]);
1620     }
1621     else if (PyUnicode_Check(arg))
1622     {
1623         Py_ssize_t len = PyUnicode_GetSize(arg);
1624
1625         if (len != 1)
1626             return -1;
1627
1628         if (obj != NULL)
1629             *obj = Character((jchar) PyUnicode_AsUnicode(arg)[0]);
1630     }
1631     else
1632         return -1;
1633
1634     return 0;
1635 }
1636
1637 int boxCharSequence(PyTypeObject *type, PyObject *arg, java::lang::Object *obj)
1638 {
1639     int result = boxJObject(type, arg, obj);
1640
1641     if (result <= 0)
1642         return result;
1643
1644     if (PyString_Check(arg) || PyUnicode_Check(arg))
1645     {
1646         if (obj != NULL)
1647         {
1648             *obj = p2j(arg);
1649             if (PyErr_Occurred())
1650                 return -1;
1651         }
1652     }
1653     else
1654         return -1;
1655
1656     return 0;
1657 }
1658
1659 int boxDouble(PyTypeObject *type, PyObject *arg, java::lang::Object *obj)
1660 {
1661     int result = boxJObject(type, arg, obj);
1662
1663     if (result <= 0)
1664         return result;
1665
1666     if (PyInt_Check(arg))
1667     {
1668         if (obj != NULL)
1669             *obj = Double((jdouble) PyInt_AS_LONG(arg));
1670     }
1671     else if (PyLong_Check(arg))
1672     {
1673         if (obj != NULL)
1674             *obj = Double((jdouble) PyLong_AsLongLong(arg));
1675     }
1676     else if (PyFloat_Check(arg))
1677     {
1678         if (obj != NULL)
1679             *obj = Double(PyFloat_AS_DOUBLE(arg));
1680     }
1681     else
1682         return -1;
1683
1684     return 0;
1685 }
1686
1687 int boxFloat(PyTypeObject *type, PyObject *arg, java::lang::Object *obj)
1688 {
1689     int result = boxJObject(type, arg, obj);
1690
1691     if (result <= 0)
1692         return result;
1693
1694     if (PyInt_Check(arg))
1695     {
1696         if (obj != NULL)
1697             *obj = Float((jfloat) PyInt_AS_LONG(arg));
1698     }
1699     else if (PyLong_Check(arg))
1700     {
1701         PY_LONG_LONG ln = PyLong_AsLongLong(arg);
1702         float f = (float) ln;
1703
1704         if ((PY_LONG_LONG) f == ln)
1705         {
1706             if (obj != NULL)
1707                 *obj = Float(f);
1708         }
1709         else
1710             return -1;
1711     }
1712     else if (PyFloat_Check(arg))
1713     {
1714         double d = PyFloat_AS_DOUBLE(arg);
1715         float f = (float) d;
1716
1717         if ((double) f == d)
1718         {
1719             if (obj != NULL)
1720                 *obj = Float(f);
1721         }
1722         else
1723             return -1;
1724     }
1725     else
1726         return -1;
1727
1728     return 0;
1729 }
1730
1731 int boxInteger(PyTypeObject *type, PyObject *arg, java::lang::Object *obj)
1732 {
1733     int result = boxJObject(type, arg, obj);
1734
1735     if (result <= 0)
1736         return result;
1737
1738     if (PyInt_Check(arg))
1739     {
1740         if (obj != NULL)
1741             *obj = Integer((jint) PyInt_AS_LONG(arg));
1742     }
1743     else if (PyLong_Check(arg))
1744     {
1745         PY_LONG_LONG ln = PyLong_AsLongLong(arg);
1746         int n = (int) ln;
1747
1748         if (n == ln)
1749         {
1750             if (obj != NULL)
1751                 *obj = Integer(n);
1752         }
1753         else
1754             return -1;
1755     }
1756     else if (PyFloat_Check(arg))
1757     {
1758         double d = PyFloat_AS_DOUBLE(arg);
1759         int n = (int) d;
1760
1761         if ((double) n == d)
1762         {
1763             if (obj != NULL)
1764                 *obj = Integer(n);
1765         }
1766         else
1767             return -1;
1768     }
1769     else
1770         return -1;
1771
1772     return 0;
1773 }
1774
1775 int boxLong(PyTypeObject *type, PyObject *arg, java::lang::Object *obj)
1776 {
1777     int result = boxJObject(type, arg, obj);
1778
1779     if (result <= 0)
1780         return result;
1781
1782     if (PyInt_Check(arg))
1783     {
1784         if (obj != NULL)
1785             *obj = Long((jlong) PyInt_AS_LONG(arg));
1786     }
1787     else if (PyLong_Check(arg))
1788     {
1789         if (obj != NULL)
1790             *obj = Long((jlong) PyLong_AsLongLong(arg));
1791     }
1792     else if (PyFloat_Check(arg))
1793     {
1794         double d = PyFloat_AS_DOUBLE(arg);
1795         PY_LONG_LONG n = (PY_LONG_LONG) d;
1796
1797         if ((double) n == d)
1798         {
1799             if (obj != NULL)
1800                 *obj = Long((jlong) n);
1801         }
1802         else
1803             return -1;
1804     }
1805     else
1806         return -1;
1807
1808     return 0;
1809 }
1810
1811 int boxNumber(PyTypeObject *type, PyObject *arg, java::lang::Object *obj)
1812 {
1813     int result = boxJObject(type, arg, obj);
1814
1815     if (result <= 0)
1816         return result;
1817
1818     if (PyInt_Check(arg))
1819     {
1820         if (obj != NULL)
1821             *obj = Integer((jint) PyInt_AS_LONG(arg));
1822     }
1823     else if (PyLong_Check(arg))
1824     {
1825         if (obj != NULL)
1826             *obj = Long((jlong) PyLong_AsLongLong(arg));
1827     }
1828     else if (PyFloat_Check(arg))
1829     {
1830         if (obj != NULL)
1831             *obj = Double((jdouble) PyFloat_AS_DOUBLE(arg));
1832     }
1833     else
1834         return -1;
1835
1836     return 0;
1837 }
1838
1839 int boxShort(PyTypeObject *type, PyObject *arg, java::lang::Object *obj)
1840 {
1841     int result = boxJObject(type, arg, obj);
1842
1843     if (result <= 0)
1844         return result;
1845
1846     if (PyInt_Check(arg))
1847     {
1848         int n = (int) PyInt_AS_LONG(arg);
1849         short sn = (short) n;
1850
1851         if (sn == n)
1852         {
1853             if (obj != NULL)
1854                 *obj = Short((jshort) sn);
1855         }
1856         else
1857             return -1;
1858     }
1859     else if (PyLong_Check(arg))
1860     {
1861         PY_LONG_LONG ln = PyLong_AsLongLong(arg);
1862         short sn = (short) ln;
1863
1864         if (sn == ln)
1865         {
1866             if (obj != NULL)
1867                 *obj = Short((jshort) sn);
1868         }
1869         else
1870             return -1;
1871     }
1872     else if (PyFloat_Check(arg))
1873     {
1874         double d = PyFloat_AS_DOUBLE(arg);
1875         short sn = (short) (int) d;
1876
1877         if ((double) sn == d)
1878         {
1879             if (obj != NULL)
1880                 *obj = Short((jshort) sn);
1881         }
1882         else
1883             return -1;
1884     }
1885     else
1886         return -1;
1887
1888     return 0;
1889 }
1890
1891 int boxString(PyTypeObject *type, PyObject *arg, java::lang::Object *obj)
1892 {
1893     int result = boxJObject(type, arg, obj);
1894
1895     if (result <= 0)
1896         return result;
1897
1898     if (PyString_Check(arg) || PyUnicode_Check(arg))
1899     {
1900         if (obj != NULL)
1901         {
1902             *obj = p2j(arg);
1903             if (PyErr_Occurred())
1904                 return -1;
1905         }
1906     }
1907     else
1908         return -1;
1909
1910     return 0;
1911 }
1912
1913 int boxObject(PyTypeObject *type, PyObject *arg, java::lang::Object *obj)
1914 {
1915     int result = boxJObject(type, arg, obj);
1916
1917     if (result <= 0)
1918         return result;
1919
1920     if (obj != NULL)
1921     {
1922         if (PyString_Check(arg) || PyUnicode_Check(arg))
1923         {
1924             *obj = p2j(arg);
1925             if (PyErr_Occurred())
1926                 return -1;
1927         }
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))
1933         {
1934             long ln = PyInt_AS_LONG(arg);
1935             int n = (int) ln;
1936
1937             if (ln != (long) n)
1938                 *obj = Long((jlong) ln);
1939             else
1940                 *obj = Integer((jint) n);
1941         }
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));
1946         else
1947             return -1;
1948     }
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)))
1953         return -1;
1954
1955     return 0;
1956 }
1957
1958
1959 #ifdef _java_generics
1960 PyObject *typeParameters(PyTypeObject *types[], size_t size)
1961 {
1962     size_t count = size / sizeof(PyTypeObject *);
1963     PyObject *tuple = PyTuple_New(count);
1964
1965     for (size_t i = 0; i < count; i++) {
1966         PyObject *type = (PyObject *) types[i];
1967
1968         if (type == NULL)
1969             type = Py_None;
1970
1971         PyTuple_SET_ITEM(tuple, i, type);
1972         Py_INCREF(type);
1973     }
1974
1975     return tuple;
1976 }
1977 #endif