diff -r b758351d191f -r cc9b7e14412b web/lib/arch/osx/jcc/sources/JArray.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/web/lib/arch/osx/jcc/sources/JArray.cpp	Tue May 25 02:43:45 2010 +0200
@@ -0,0 +1,1209 @@
+/*
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#ifdef PYTHON
+
+#include <jni.h>
+#include <Python.h>
+#include "structmember.h"
+
+#include "JArray.h"
+#include "functions.h"
+#include "java/lang/Class.h"
+
+using namespace java::lang;
+
+
+template<typename T> class _t_jarray : public t_jarray<T> {
+public:
+    static PyObject *format;
+};
+
+template<typename U>
+static PyObject *get(U *self, int n)
+{
+    return self->array.get(n);
+}
+
+template<typename U>
+static PyObject *toSequence(U *self)
+{
+    return self->array.toSequence();
+}
+
+template<typename U>
+static PyObject *toSequence(U *self, int lo, int hi)
+{
+    return self->array.toSequence(lo, hi);
+}
+
+template<typename U> class _t_iterator {
+public:
+    PyObject_HEAD
+    U *obj;
+    Py_ssize_t position;
+
+    static void dealloc(_t_iterator *self)
+    {
+        Py_XDECREF(self->obj);
+        self->ob_type->tp_free((PyObject *) self);
+    }
+
+    static PyObject *iternext(_t_iterator *self)
+    {
+        if (self->position < (Py_ssize_t) self->obj->array.length)
+            return get<U>(self->obj, self->position++);
+
+        PyErr_SetNone(PyExc_StopIteration);
+        return NULL;
+    }
+
+    static PyTypeObject *JArrayIterator;
+};
+
+template<typename T, typename U>
+static int init(U *self, PyObject *args, PyObject *kwds)
+{
+    PyObject *obj;
+
+    if (!PyArg_ParseTuple(args, "O", &obj))
+        return -1;
+
+    if (PySequence_Check(obj))
+    {
+        self->array = JArray<T>(obj);
+        if (PyErr_Occurred())
+            return -1;
+    }
+    else if (PyGen_Check(obj))
+    {
+        PyObject *tuple =
+            PyObject_CallFunctionObjArgs((PyObject *) &PyTuple_Type, obj, NULL);
+
+        if (!tuple)
+            return -1;
+
+        self->array = JArray<T>(tuple);
+        Py_DECREF(tuple);
+        if (PyErr_Occurred())
+            return -1;
+    }
+    else if (PyInt_Check(obj))
+    {
+        int n = PyInt_AsLong(obj);
+
+        if (n < 0)
+        {
+            PyErr_SetObject(PyExc_ValueError, obj);
+            return -1;
+        }
+
+        self->array = JArray<T>(n);
+    }
+    else
+    {
+        PyErr_SetObject(PyExc_TypeError, obj);
+        return -1;
+    }
+
+    return 0;
+}
+
+template<typename T, typename U>
+static void dealloc(U *self)
+{
+    self->array = JArray<T>((jobject) NULL);
+    self->ob_type->tp_free((PyObject *) self);
+}
+
+template<typename U>
+static PyObject *_format(U *self, PyObject *(*fn)(PyObject *))
+{
+    if (self->array.this$)
+    {
+        PyObject *list = toSequence<U>(self);
+            
+        if (list)
+        {
+            PyObject *result = (*fn)(list);
+
+            Py_DECREF(list);
+            if (result)
+            {
+                PyObject *args = PyTuple_New(1);
+
+                PyTuple_SET_ITEM(args, 0, result);
+                result = PyString_Format(U::format, args);
+                Py_DECREF(args);
+
+                return result;
+            }
+        }
+
+        return NULL;
+    }
+
+    return PyString_FromString("<null>");
+}
+
+template<typename U>
+static PyObject *repr(U *self)
+{
+    return _format(self, (PyObject *(*)(PyObject *)) PyObject_Repr);
+}
+
+template<typename U>
+static PyObject *str(U *self)
+{
+    return _format(self, (PyObject *(*)(PyObject *)) PyObject_Str);
+}
+
+template<typename U>
+static int _compare(U *self, PyObject *value, int i0, int i1, int op, int *cmp)
+{
+    PyObject *v0 = get<U>(self, i0);
+    PyObject *v1 = PySequence_Fast_GET_ITEM(value, i1);  /* borrowed */
+
+    if (!v0)
+        return -1;
+
+    if (!v1)
+    {
+        Py_DECREF(v0);
+        return -1;
+    }
+
+    *cmp = PyObject_RichCompareBool(v0, v1, op);
+    Py_DECREF(v0);
+
+    if (*cmp < 0)
+        return -1;
+
+    return 0;
+}
+
+template<typename U>
+static PyObject *richcompare(U *self, PyObject *value, int op)
+{
+    PyObject *result = NULL;
+    int s0, s1;
+
+    if (!PySequence_Check(value))
+    {
+        Py_INCREF(Py_NotImplemented);
+        return Py_NotImplemented;
+    }
+
+    value = PySequence_Fast(value, "not a sequence");
+    if (!value)
+        return NULL;
+
+    s0 = PySequence_Fast_GET_SIZE(value);
+    s1 = self->array.length;
+
+    if (s1 < 0)
+    {
+        Py_DECREF(value);
+        return NULL;
+    }
+
+    if (s0 != s1)
+    {
+        switch (op) {
+          case Py_EQ: result = Py_False; break;
+          case Py_NE: result = Py_True; break;
+        }
+    }
+
+    if (!result)
+    {
+        int i0, i1, cmp = 1;
+
+        for (i0 = 0, i1 = 0; i0 < s0 && i1 < s1 && cmp; i0++, i1++) {
+            if (_compare(self, value, i0, i1, Py_EQ, &cmp) < 0)
+            {
+                Py_DECREF(value);
+                return NULL;
+            }                
+        }
+
+        if (cmp)
+        {
+            switch (op) {
+              case Py_LT: cmp = s0 < s1; break;
+              case Py_LE: cmp = s0 <= s1; break;
+              case Py_EQ: cmp = s0 == s1; break;
+              case Py_NE: cmp = s0 != s1; break;
+              case Py_GT: cmp = s0 > s1; break;
+              case Py_GE: cmp = s0 >= s1; break;
+              default: cmp = 0;
+            }
+
+            result = cmp ? Py_True : Py_False;
+        }
+        else if (op == Py_EQ)
+            result = Py_False;
+        else if (op == Py_NE)
+            result = Py_True;
+        else if (_compare(self, value, i0, i1, op, &cmp) < 0)
+        {
+            Py_DECREF(value);
+            return NULL;
+        }
+        else
+            result = cmp ? Py_True : Py_False;
+    }
+    Py_DECREF(value);
+
+    Py_INCREF(result);
+    return result;
+}
+
+template<typename U>
+static PyObject *iter(U *self)
+{
+    _t_iterator<U> *it =
+        PyObject_New(_t_iterator<U>, _t_iterator<U>::JArrayIterator);
+
+    if (it)
+    {
+        it->position = 0;
+        it->obj = self; Py_INCREF((PyObject *) self);
+    }
+
+    return (PyObject *) it;
+}
+
+template<typename U>
+static Py_ssize_t seq_length(U *self)
+{
+    if (self->array.this$)
+        return self->array.length;
+
+    return 0;
+}
+
+template<typename U>
+static PyObject *seq_get(U *self, Py_ssize_t n)
+{
+    return get<U>(self, n);
+}
+
+template<typename U>
+static int seq_contains(U *self, PyObject *value)
+{
+    return 0;
+}
+
+template<typename U>
+static PyObject *seq_concat(U *self, PyObject *arg)
+{
+    PyObject *list = toSequence<U>(self);
+
+    if (list != NULL &&
+        PyList_Type.tp_as_sequence->sq_inplace_concat(list, arg) < 0)
+    {
+        Py_DECREF(list);
+        return NULL;
+    }
+
+    return list;
+}
+
+template<typename U>
+static PyObject *seq_repeat(U *self, Py_ssize_t n)
+{
+    PyObject *list = toSequence<U>(self);
+
+    if (list != NULL &&
+        PyList_Type.tp_as_sequence->sq_inplace_repeat(list, n) < 0)
+    {
+        Py_DECREF(list);
+        return NULL;
+    }
+
+    return list;
+}
+
+template<typename U>
+static PyObject *seq_getslice(U *self, Py_ssize_t lo, Py_ssize_t hi)
+{
+    return toSequence<U>(self, lo, hi);
+}
+
+template<typename U>
+static int seq_set(U *self, Py_ssize_t n, PyObject *value)
+{
+    return self->array.set(n, value);
+}
+
+template<typename U>
+static int seq_setslice(U *self, Py_ssize_t lo, Py_ssize_t hi, PyObject *values)
+{
+    int length = self->array.length;
+
+    if (values == NULL)
+    {
+        PyErr_SetString(PyExc_ValueError, "array size cannot change");
+        return -1;
+    }
+            
+    if (lo < 0) lo = length + lo;
+    if (lo < 0) lo = 0;
+    else if (lo > length) lo = length;
+    if (hi < 0) hi = length + hi;
+    if (hi < 0) hi = 0;
+    else if (hi > length) hi = length;
+    if (lo > hi) lo = hi;
+
+    PyObject *sequence = PySequence_Fast(values, "not a sequence");
+    if (!sequence)
+        return -1;
+
+    int size = PySequence_Fast_GET_SIZE(sequence);
+    if (size < 0)
+        goto error;
+
+    if (size != hi - lo)
+    {
+        PyErr_SetString(PyExc_ValueError, "array size cannot change");
+        goto error;
+    }
+
+    for (int i = lo; i < hi; i++) {
+        PyObject *value = PySequence_Fast_GET_ITEM(sequence, i - lo);
+
+        if (value == NULL)
+            goto error;
+
+        if (self->array.set(i, value) < 0)
+            goto error;
+    }
+
+    Py_DECREF(sequence);
+    return 0;
+
+  error:
+    Py_DECREF(sequence);
+    return -1;
+}
+
+template<typename T> 
+static jclass initializeClass(void)
+{
+    return env->get_vm_env()->GetObjectClass(JArray<T>(0).this$);
+}
+
+template<typename T> 
+static PyObject *cast_(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    PyObject *arg, *clsObj;
+
+    if (!PyArg_ParseTuple(args, "O", &arg))
+        return NULL;
+
+    if (!PyObject_TypeCheck(arg, &Object$$Type))
+    {
+        PyErr_SetObject(PyExc_TypeError, arg);
+        return NULL;
+    }
+
+    Class argCls = ((t_Object *) arg)->object.getClass();
+
+    if (!argCls.isArray())
+    {
+        PyErr_SetObject(PyExc_TypeError, arg);
+        return NULL;
+    }
+
+    clsObj = PyObject_GetAttrString((PyObject *) type, "class_");
+    if (!clsObj)
+        return NULL;
+
+    Class arrayCls = ((t_Class *) clsObj)->object;
+
+    if (!arrayCls.isAssignableFrom(argCls))
+    {
+        PyErr_SetObject(PyExc_TypeError, arg);
+        return NULL;
+    }
+
+    return JArray<T>(((t_JObject *) arg)->object.this$).wrap();
+}
+
+template<typename T> 
+static PyObject *instance_(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    PyObject *arg, *clsObj;
+
+    if (!PyArg_ParseTuple(args, "O", &arg))
+        return NULL;
+
+    if (!PyObject_TypeCheck(arg, &Object$$Type))
+        Py_RETURN_FALSE;
+
+    Class argCls = ((t_Object *) arg)->object.getClass();
+
+    if (!argCls.isArray())
+        Py_RETURN_FALSE;
+
+    clsObj = PyObject_GetAttrString((PyObject *) type, "class_");
+    if (!clsObj)
+        return NULL;
+
+    Class arrayCls = ((t_Class *) clsObj)->object;
+
+    if (!arrayCls.isAssignableFrom(argCls))
+        Py_RETURN_FALSE;
+
+    Py_RETURN_TRUE;
+}
+
+template<typename T> 
+static PyObject *assignable_(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    return instance_<T>(type, args, kwds);
+}
+
+template< typename T, typename U = _t_jarray<T> > class jarray_type {
+public:
+    PySequenceMethods seq_methods;
+    PyTypeObject type_object;
+
+    class iterator_type {
+    public:
+        PyTypeObject type_object;
+
+        void install(char *name, PyObject *module)
+        {
+            type_object.tp_name = name;
+
+            if (PyType_Ready(&type_object) == 0)
+            {
+                Py_INCREF((PyObject *) &type_object);
+                PyModule_AddObject(module, name, (PyObject *) &type_object);
+            }
+
+            _t_iterator<U>::JArrayIterator = &type_object;
+        }
+
+        iterator_type()
+        {
+            memset(&type_object, 0, sizeof(type_object));
+
+            type_object.ob_refcnt = 1;
+            type_object.ob_type = NULL;
+            type_object.tp_basicsize = sizeof(_t_iterator<U>);
+            type_object.tp_dealloc = (destructor) _t_iterator<U>::dealloc;
+            type_object.tp_flags = Py_TPFLAGS_DEFAULT;
+            type_object.tp_doc = "JArrayIterator<T> wrapper type";
+            type_object.tp_iter = (getiterfunc) PyObject_SelfIter;
+            type_object.tp_iternext = (iternextfunc) _t_iterator<U>::iternext;
+        }
+    };
+
+    iterator_type iterator_type_object;
+
+    void install(char *name, char *type_name, char *iterator_name,
+                 PyObject *module)
+    {
+        type_object.tp_name = name;
+
+        if (PyType_Ready(&type_object) == 0)
+        {
+            Py_INCREF((PyObject *) &type_object);
+            PyDict_SetItemString(type_object.tp_dict, "class_",
+                                 make_descriptor(initializeClass<T>));
+            
+            PyModule_AddObject(module, name, (PyObject *) &type_object);
+        }
+
+        U::format = PyString_FromFormat("JArray<%s>%%s", type_name);
+        iterator_type_object.install(iterator_name, module);
+    }
+
+    static PyObject *_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+    {
+        U *self = (U *) type->tp_alloc(type, 0);
+
+        if (self)
+            self->array = JArray<T>((jobject) NULL);
+
+        return (PyObject *) self;
+    }
+
+    jarray_type()
+    {
+        memset(&seq_methods, 0, sizeof(seq_methods));
+        memset(&type_object, 0, sizeof(type_object));
+
+        static PyMethodDef methods[] = {
+            { "cast_",
+              (PyCFunction) (PyObject *(*)(PyTypeObject *,
+                                           PyObject *, PyObject *))
+              cast_<T>,
+              METH_VARARGS | METH_CLASS, NULL },
+            { "instance_",
+              (PyCFunction) (PyObject *(*)(PyTypeObject *,
+                                           PyObject *, PyObject *))
+              instance_<T>,
+              METH_VARARGS | METH_CLASS, NULL },
+            { "assignable_",
+              (PyCFunction) (PyObject *(*)(PyTypeObject *,
+                                           PyObject *, PyObject *))
+              assignable_<T>,
+              METH_VARARGS | METH_CLASS, NULL },
+            { NULL, NULL, 0, NULL }
+        };
+
+        seq_methods.sq_length =
+            (lenfunc) (Py_ssize_t (*)(U *)) seq_length<U>;
+        seq_methods.sq_concat =
+            (binaryfunc) (PyObject *(*)(U *, PyObject *)) seq_concat<U>;
+        seq_methods.sq_repeat =
+            (ssizeargfunc) (PyObject *(*)(U *, Py_ssize_t)) seq_repeat<U>;
+        seq_methods.sq_item =
+            (ssizeargfunc) (PyObject *(*)(U *, Py_ssize_t)) seq_get<U>;
+        seq_methods.sq_slice =
+            (ssizessizeargfunc) (PyObject *(*)(U *, Py_ssize_t, Py_ssize_t))
+            seq_getslice<U>;
+        seq_methods.sq_ass_item =
+            (ssizeobjargproc) (int (*)(U *, Py_ssize_t, PyObject *)) seq_set<U>;
+        seq_methods.sq_ass_slice =
+            (ssizessizeobjargproc) (int (*)(U *, Py_ssize_t, Py_ssize_t,
+                                            PyObject *)) seq_setslice<U>;
+        seq_methods.sq_contains =
+            (objobjproc) (int (*)(U *, PyObject *)) seq_contains<U>;
+        seq_methods.sq_inplace_concat = NULL;
+        seq_methods.sq_inplace_repeat = NULL;
+
+        type_object.ob_refcnt = 1;
+        type_object.tp_basicsize = sizeof(U);
+        type_object.tp_dealloc = (destructor) (void (*)(U *)) dealloc<T,U>;
+        type_object.tp_repr = (reprfunc) (PyObject *(*)(U *)) repr<U>;
+        type_object.tp_as_sequence = &seq_methods;
+        type_object.tp_str = (reprfunc) (PyObject *(*)(U *)) str<U>;
+        type_object.tp_flags = Py_TPFLAGS_DEFAULT;
+        type_object.tp_doc = "JArray<T> wrapper type";
+        type_object.tp_richcompare =
+            (richcmpfunc) (PyObject *(*)(U *, PyObject *, int)) richcompare<U>;
+        type_object.tp_iter = (getiterfunc) (PyObject *(*)(U *)) iter<U>;
+        type_object.tp_methods = methods;
+        type_object.tp_base = &Object$$Type;
+        type_object.tp_init =
+            (initproc) (int (*)(U *, PyObject *, PyObject *)) init<T,U>;
+        type_object.tp_new = (newfunc) _new;
+    }
+};
+
+template<typename T> class _t_jobjectarray : public _t_jarray<T> {
+public:
+    PyObject *(*wrapfn)(const T&);
+};
+
+template<> PyObject *get(_t_jobjectarray<jobject> *self, int n)
+{
+    return self->array.get(n, self->wrapfn);
+}
+
+template<> PyObject *toSequence(_t_jobjectarray<jobject> *self)
+{
+    return self->array.toSequence(self->wrapfn);
+}
+
+template<> PyObject *toSequence(_t_jobjectarray<jobject> *self, int lo, int hi)
+{
+    return self->array.toSequence(lo, hi, self->wrapfn);
+}
+
+template<> int init< jobject,_t_jobjectarray<jobject> >(_t_jobjectarray<jobject> *self, PyObject *args, PyObject *kwds)
+{
+    PyObject *obj, *clsObj = NULL;
+    PyObject *(*wrapfn)(const jobject &) = NULL;
+    jclass cls;
+
+    if (!PyArg_ParseTuple(args, "O|O", &obj, &clsObj))
+        return -1;
+
+    if (clsObj == NULL)
+        cls = env->findClass("java/lang/Object");
+    else if (PyObject_TypeCheck(clsObj, &Class$$Type))
+        cls = (jclass) ((t_Class *) clsObj)->object.this$;
+    else if (PyType_Check(clsObj))
+    {
+        if (PyType_IsSubtype((PyTypeObject *) clsObj, &JObject$$Type))
+        {
+            PyObject *cobj = PyObject_GetAttrString(clsObj, "wrapfn_");
+
+            if (cobj == NULL)
+                PyErr_Clear();
+            else
+            {
+                wrapfn = (PyObject *(*)(const jobject &))
+                    PyCObject_AsVoidPtr(cobj);
+                Py_DECREF(cobj);
+            }
+
+            clsObj = PyObject_GetAttrString(clsObj, "class_");
+            if (clsObj == NULL)
+                return -1;
+
+            cls = (jclass) ((t_Class *) clsObj)->object.this$;
+            Py_DECREF(clsObj);
+        }
+        else
+        {
+            PyErr_SetObject(PyExc_ValueError, clsObj);
+            return -1;
+        }
+    }
+    else
+    {
+        PyErr_SetObject(PyExc_TypeError, clsObj);
+        return -1;
+    }
+
+    if (PySequence_Check(obj))
+    {
+        self->array = JArray<jobject>(cls, obj);
+        if (PyErr_Occurred())
+            return -1;
+    }
+    else if (PyGen_Check(obj))
+    {
+        PyObject *tuple =
+            PyObject_CallFunctionObjArgs((PyObject *) &PyTuple_Type, obj, NULL);
+
+        if (!tuple)
+            return -1;
+
+        self->array = JArray<jobject>(cls, tuple);
+        Py_DECREF(tuple);
+        if (PyErr_Occurred())
+            return -1;
+    }
+    else if (PyInt_Check(obj))
+    {
+        int n = PyInt_AsLong(obj);
+
+        if (n < 0)
+        {
+            PyErr_SetObject(PyExc_ValueError, obj);
+            return -1;
+        }
+
+        self->array = JArray<jobject>(cls, n);
+    }
+    else
+    {
+        PyErr_SetObject(PyExc_TypeError, obj);
+        return -1;
+    }
+
+    self->wrapfn = wrapfn;
+
+    return 0;
+}
+
+template<> jclass initializeClass<jobject>(void)
+{
+    jclass cls = env->findClass("java/lang/Object");
+    return env->get_vm_env()->GetObjectClass(JArray<jobject>(cls, 0).this$);
+}
+
+template<> PyObject *cast_<jobject>(PyTypeObject *type,
+				    PyObject *args, PyObject *kwds)
+{
+    PyObject *arg, *clsArg = NULL;
+    PyObject *(*wrapfn)(const jobject&) = NULL;
+    jclass elementCls;
+
+    if (!PyArg_ParseTuple(args, "O|O", &arg, &clsArg))
+        return NULL;
+
+    if (!PyObject_TypeCheck(arg, &Object$$Type))
+    {
+        PyErr_SetObject(PyExc_TypeError, arg);
+        return NULL;
+    }
+
+    Class argCls = ((t_Object *) arg)->object.getClass();
+
+    if (!argCls.isArray())
+    {
+        PyErr_SetObject(PyExc_TypeError, arg);
+        return NULL;
+    }
+
+    if (clsArg != NULL)
+    {
+        if (!PyType_Check(clsArg))
+        {
+            PyErr_SetObject(PyExc_TypeError, clsArg);
+            return NULL;
+        }
+        else if (!PyType_IsSubtype((PyTypeObject *) clsArg, &JObject$$Type))
+        {
+            PyErr_SetObject(PyExc_ValueError, clsArg);
+            return NULL;
+        }
+
+        PyObject *cobj = PyObject_GetAttrString(clsArg, "wrapfn_");
+
+        if (cobj == NULL)
+            PyErr_Clear();
+        else
+        {
+            wrapfn = (PyObject *(*)(const jobject &)) PyCObject_AsVoidPtr(cobj);
+            Py_DECREF(cobj);
+        }
+
+        clsArg = PyObject_GetAttrString(clsArg, "class_");
+        if (clsArg == NULL)
+            return NULL;
+
+        elementCls = (jclass) ((t_Class *) clsArg)->object.this$;
+        Py_DECREF(clsArg);
+    }
+    else
+        elementCls = env->findClass("java/lang/Object");
+
+    JNIEnv *vm_env = env->get_vm_env();
+    jobjectArray array = vm_env->NewObjectArray(0, elementCls, NULL);
+    Class arrayCls(vm_env->GetObjectClass((jobject) array));
+
+    if (!arrayCls.isAssignableFrom(argCls))
+    {
+        PyErr_SetObject(PyExc_TypeError, arg);
+        return NULL;
+    }
+
+    return JArray<jobject>(((t_JObject *) arg)->object.this$).wrap(wrapfn);
+}
+
+template<> PyObject *instance_<jobject>(PyTypeObject *type,
+					PyObject *args, PyObject *kwds)
+{
+    PyObject *arg, *clsArg = NULL;
+    jclass elementCls;
+
+    if (!PyArg_ParseTuple(args, "O|O", &arg, &clsArg))
+        return NULL;
+
+    if (!PyObject_TypeCheck(arg, &Object$$Type))
+        Py_RETURN_FALSE;
+
+    Class argCls = ((t_Object *) arg)->object.getClass();
+
+    if (!argCls.isArray())
+        Py_RETURN_FALSE;
+
+    if (clsArg != NULL)
+    {
+        if (!PyType_Check(clsArg))
+        {
+            PyErr_SetObject(PyExc_TypeError, clsArg);
+            return NULL;
+        }
+        else if (!PyType_IsSubtype((PyTypeObject *) clsArg, &JObject$$Type))
+        {
+            PyErr_SetObject(PyExc_ValueError, clsArg);
+            return NULL;
+        }
+
+        clsArg = PyObject_GetAttrString(clsArg, "class_");
+        if (clsArg == NULL)
+            return NULL;
+
+        elementCls = (jclass) ((t_Class *) clsArg)->object.this$;
+        Py_DECREF(clsArg);
+    }
+    else
+        elementCls = env->findClass("java/lang/Object");
+
+    JNIEnv *vm_env = env->get_vm_env();
+    jobjectArray array = vm_env->NewObjectArray(0, elementCls, NULL);
+    Class arrayCls(vm_env->GetObjectClass((jobject) array));
+
+    if (!arrayCls.isAssignableFrom(argCls))
+        Py_RETURN_FALSE;
+
+    Py_RETURN_TRUE;
+}
+
+template<> PyObject *assignable_<jobject>(PyTypeObject *type,
+					  PyObject *args, PyObject *kwds)
+{
+    PyObject *arg, *clsArg = NULL;
+    jclass elementCls;
+
+    if (!PyArg_ParseTuple(args, "O|O", &arg, &clsArg))
+        return NULL;
+
+    if (!PyObject_TypeCheck(arg, &Object$$Type))
+        Py_RETURN_FALSE;
+
+    Class argCls = ((t_Object *) arg)->object.getClass();
+
+    if (!argCls.isArray())
+        Py_RETURN_FALSE;
+
+    if (clsArg != NULL)
+    {
+        if (!PyType_Check(clsArg))
+        {
+            PyErr_SetObject(PyExc_TypeError, clsArg);
+            return NULL;
+        }
+        else if (!PyType_IsSubtype((PyTypeObject *) clsArg, &JObject$$Type))
+        {
+            PyErr_SetObject(PyExc_ValueError, clsArg);
+            return NULL;
+        }
+
+        clsArg = PyObject_GetAttrString(clsArg, "class_");
+        if (clsArg == NULL)
+            return NULL;
+
+        elementCls = (jclass) ((t_Class *) clsArg)->object.this$;
+        Py_DECREF(clsArg);
+    }
+    else
+        elementCls = env->findClass("java/lang/Object");
+
+    JNIEnv *vm_env = env->get_vm_env();
+    jobjectArray array = vm_env->NewObjectArray(0, elementCls, NULL);
+    Class arrayCls(vm_env->GetObjectClass((jobject) array));
+
+    if (!argCls.isAssignableFrom(arrayCls))
+        Py_RETURN_FALSE;
+
+    Py_RETURN_TRUE;
+}
+
+
+template<typename T> PyTypeObject *_t_iterator<T>::JArrayIterator;
+template<typename T> PyObject *_t_jarray<T>::format;
+
+static jarray_type< jobject, _t_jobjectarray<jobject> > jarray_jobject;
+
+static jarray_type<jstring> jarray_jstring;
+static jarray_type<jboolean> jarray_jboolean;
+static jarray_type<jbyte> jarray_jbyte;
+static jarray_type<jchar> jarray_jchar;
+static jarray_type<jdouble> jarray_jdouble;
+static jarray_type<jfloat> jarray_jfloat;
+static jarray_type<jint> jarray_jint;
+static jarray_type<jlong> jarray_jlong;
+static jarray_type<jshort> jarray_jshort;
+
+
+PyObject *JArray<jobject>::wrap(PyObject *(*wrapfn)(const jobject&))
+{
+    if (this$ != NULL)
+    {
+        _t_jobjectarray<jobject> *obj =
+            PyObject_New(_t_jobjectarray<jobject>, &jarray_jobject.type_object);
+
+        memset(&(obj->array), 0, sizeof(JArray<jobject>));
+        obj->array = *this;
+        obj->wrapfn = wrapfn;
+
+        return (PyObject *) obj;
+    }
+
+    Py_RETURN_NONE;
+}
+
+PyObject *JArray<jstring>::wrap()
+{
+    if (this$ != NULL)
+    {
+        _t_jarray<jstring> *obj =
+            PyObject_New(_t_jarray<jstring>, &jarray_jstring.type_object);
+
+        memset(&(obj->array), 0, sizeof(JArray<jstring>));
+        obj->array = *this;
+
+        return (PyObject *) obj;
+    }
+
+    Py_RETURN_NONE;
+}
+
+PyObject *JArray<jboolean>::wrap()
+{
+    if (this$ != NULL)
+    {
+        _t_jarray<jboolean> *obj =
+            PyObject_New(_t_jarray<jboolean>, &jarray_jboolean.type_object);
+
+        memset(&(obj->array), 0, sizeof(JArray<jboolean>));
+        obj->array = *this;
+
+        return (PyObject *) obj;
+    }
+
+    Py_RETURN_NONE;
+}
+
+PyObject *JArray<jbyte>::wrap()
+{
+    if (this$ != NULL)
+    {
+        _t_jarray<jbyte> *obj =
+            PyObject_New(_t_jarray<jbyte>, &jarray_jbyte.type_object);
+
+        memset(&(obj->array), 0, sizeof(JArray<jbyte>));
+        obj->array = *this;
+
+        return (PyObject *) obj;
+    }
+
+    Py_RETURN_NONE;
+}
+
+PyObject *JArray<jchar>::wrap()
+{
+    if (this$ != NULL)
+    {
+        _t_jarray<jchar> *obj =
+            PyObject_New(_t_jarray<jchar>, &jarray_jchar.type_object);
+
+        memset(&(obj->array), 0, sizeof(JArray<jchar>));
+        obj->array = *this;
+
+        return (PyObject *) obj;
+    }
+
+    Py_RETURN_NONE;
+}
+
+PyObject *JArray<jdouble>::wrap()
+{
+    if (this$ != NULL)
+    {
+        _t_jarray<jdouble> *obj =
+            PyObject_New(_t_jarray<jdouble>, &jarray_jdouble.type_object);
+
+        memset(&(obj->array), 0, sizeof(JArray<jdouble>));
+        obj->array = *this;
+
+        return (PyObject *) obj;
+    }
+
+    Py_RETURN_NONE;
+}
+
+PyObject *JArray<jfloat>::wrap()
+{
+    if (this$ != NULL)
+    {
+        _t_jarray<jfloat> *obj =
+            PyObject_New(_t_jarray<jfloat>, &jarray_jfloat.type_object);
+
+        memset(&(obj->array), 0, sizeof(JArray<jfloat>));
+        obj->array = *this;
+
+        return (PyObject *) obj;
+    }
+
+    Py_RETURN_NONE;
+}
+
+PyObject *JArray<jint>::wrap()
+{
+    if (this$ != NULL)
+    {
+        _t_jarray<jint> *obj =
+            PyObject_New(_t_jarray<jint>, &jarray_jint.type_object);
+
+        memset(&(obj->array), 0, sizeof(JArray<jint>));
+        obj->array = *this;
+
+        return (PyObject *) obj;
+    }
+
+    Py_RETURN_NONE;
+}
+
+PyObject *JArray<jlong>::wrap()
+{
+    if (this$ != NULL)
+    {
+        _t_jarray<jlong> *obj =
+            PyObject_New(_t_jarray<jlong>, &jarray_jlong.type_object);
+
+        memset(&(obj->array), 0, sizeof(JArray<jlong>));
+        obj->array = *this;
+
+        return (PyObject *) obj;
+    }
+
+    Py_RETURN_NONE;
+}
+
+PyObject *JArray<jshort>::wrap()
+{
+    if (this$ != NULL)
+    {
+        _t_jarray<jshort> *obj =
+            PyObject_New(_t_jarray<jshort>, &jarray_jshort.type_object);
+
+        memset(&(obj->array), 0, sizeof(JArray<jshort>));
+        obj->array = *this;
+
+        return (PyObject *) obj;
+    }
+
+    Py_RETURN_NONE;
+}
+
+PyObject *JArray_Type(PyObject *self, PyObject *arg)
+{
+    PyObject *type_name = NULL, *type;
+    char const *name = NULL;
+
+    if (PyType_Check(arg))
+    {
+        type_name = PyObject_GetAttrString(arg, "__name__");
+        if (!type_name)
+            return NULL;
+    }
+    else if (PyString_Check(arg))
+    {
+        type_name = arg;
+        Py_INCREF(type_name);
+    }
+    else if (PyFloat_Check(arg))
+    {
+        type_name = NULL;
+        name = "double";
+    }
+    else
+    {
+        PyObject *arg_type = (PyObject *) arg->ob_type;
+
+        type_name = PyObject_GetAttrString(arg_type, "__name__");
+        if (!type_name)
+            return NULL;
+    }
+
+    if (type_name != NULL)
+    {
+        name = PyString_AsString(type_name);
+        Py_DECREF(type_name);
+
+        if (!name)
+            return NULL;
+    }
+
+    if (!strcmp(name, "object"))
+        type = (PyObject *) &jarray_jobject.type_object;
+    else if (!strcmp(name, "string"))
+        type = (PyObject *) &jarray_jstring.type_object;
+    else if (!strcmp(name, "bool"))
+        type = (PyObject *) &jarray_jboolean.type_object;
+    else if (!strcmp(name, "byte"))
+        type = (PyObject *) &jarray_jbyte.type_object;
+    else if (!strcmp(name, "char"))
+        type = (PyObject *) &jarray_jchar.type_object;
+    else if (!strcmp(name, "double"))
+        type = (PyObject *) &jarray_jdouble.type_object;
+    else if (!strcmp(name, "float"))
+        type = (PyObject *) &jarray_jfloat.type_object;
+    else if (!strcmp(name, "int"))
+        type = (PyObject *) &jarray_jint.type_object;
+    else if (!strcmp(name, "long"))
+        type = (PyObject *) &jarray_jlong.type_object;
+    else if (!strcmp(name, "short"))
+        type = (PyObject *) &jarray_jshort.type_object;
+    else
+    {
+        PyErr_SetObject(PyExc_ValueError, arg);
+        return NULL;
+    }
+
+    Py_INCREF(type);
+    return type;
+}
+
+static PyObject *t_jarray_jbyte__get_string_(t_jarray<jbyte> *self, void *data)
+{
+    return self->array.to_string_();
+}
+
+static PyGetSetDef t_jarray_jbyte__fields[] = {
+    { "string_", (getter) t_jarray_jbyte__get_string_, NULL, "", NULL },
+    { NULL, NULL, NULL, NULL, NULL }
+};
+
+
+PyTypeObject *JArrayObject$$Type;
+PyTypeObject *JArrayString$$Type;
+PyTypeObject *JArrayBool$$Type;
+PyTypeObject *JArrayByte$$Type;
+PyTypeObject *JArrayChar$$Type;
+PyTypeObject *JArrayDouble$$Type;
+PyTypeObject *JArrayFloat$$Type;
+PyTypeObject *JArrayInt$$Type;
+PyTypeObject *JArrayLong$$Type;
+PyTypeObject *JArrayShort$$Type;
+
+
+void _install_jarray(PyObject *module)
+{
+    jarray_jobject.install("JArray_object", "object",
+                            "__JArray_object_iterator", module);
+    JArrayObject$$Type = &jarray_jobject.type_object;
+
+    jarray_jstring.install("JArray_string", "string",
+                            "__JArray_string_iterator", module);
+    JArrayString$$Type = &jarray_jstring.type_object;
+
+    jarray_jboolean.install("JArray_bool", "bool",
+                            "__JArray_bool_iterator", module);
+    JArrayBool$$Type = &jarray_jboolean.type_object;
+
+    jarray_jbyte.type_object.tp_getset = t_jarray_jbyte__fields;
+    jarray_jbyte.install("JArray_byte", "byte",
+                         "__JArray_byte_iterator", module);
+    JArrayByte$$Type = &jarray_jbyte.type_object;
+
+    jarray_jchar.install("JArray_char", "char",
+                         "__JArray_char_iterator", module);
+    JArrayChar$$Type = &jarray_jchar.type_object;
+
+    jarray_jdouble.install("JArray_double", "double",
+                           "__JArray_double_iterator", module);
+    JArrayDouble$$Type = &jarray_jdouble.type_object;
+
+    jarray_jfloat.install("JArray_float", "float",
+                          "__JArray_float_iterator", module);
+    JArrayFloat$$Type = &jarray_jfloat.type_object;
+
+    jarray_jint.install("JArray_int", "int",
+                        "__JArray_int_iterator", module);
+    JArrayInt$$Type = &jarray_jint.type_object;
+
+    jarray_jlong.install("JArray_long", "long",
+                         "__JArray_long_iterator", module);
+    JArrayLong$$Type = &jarray_jlong.type_object;
+
+    jarray_jshort.install("JArray_short", "short",
+                          "__JArray_short_iterator", module);
+    JArrayShort$$Type = &jarray_jshort.type_object;
+}
+
+#endif /* PYTHON */