diff -r b758351d191f -r cc9b7e14412b web/lib/arch/osx/jcc/sources/functions.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/web/lib/arch/osx/jcc/sources/functions.h	Tue May 25 02:43:45 2010 +0200
@@ -0,0 +1,272 @@
+/*
+ *   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.
+ */
+
+#ifndef _functions_h
+#define _functions_h
+
+#include "java/util/Iterator.h"
+#include "java/util/Enumeration.h"
+#include "java/lang/String.h"
+#include "java/lang/Object.h"
+#include "macros.h"
+
+#if PY_VERSION_HEX < 0x02050000
+typedef int Py_ssize_t;
+typedef inquiry lenfunc;
+typedef intargfunc ssizeargfunc;
+typedef intintargfunc ssizessizeargfunc;
+typedef intobjargproc ssizeobjargproc;
+typedef intintobjargproc ssizessizeobjargproc;
+#endif
+
+typedef jclass (*getclassfn)(void);
+typedef PyTypeObject **(*getparametersfn)(void *);
+
+PyObject *PyErr_SetArgsError(char *name, PyObject *args);
+PyObject *PyErr_SetArgsError(PyObject *self, char *name, PyObject *args);
+PyObject *PyErr_SetArgsError(PyTypeObject *type, char *name, PyObject *args);
+PyObject *PyErr_SetJavaError(jthrowable throwable);
+
+extern PyObject *PyExc_JavaError;
+extern PyObject *PyExc_InvalidArgsError;
+
+
+void throwPythonError(void);
+void throwTypeError(const char *name, PyObject *object);
+
+#if defined(_MSC_VER) || defined(__SUNPRO_CC)
+
+#define parseArgs __parseArgs
+#define parseArg __parseArg
+
+int __parseArgs(PyObject *args, char *types, ...);
+int __parseArg(PyObject *arg, char *types, ...);
+
+int _parseArgs(PyObject **args, unsigned int count, char *types,
+	       va_list list, va_list check);
+
+#else
+
+#define parseArgs(args, types, rest...) \
+    _parseArgs(((PyTupleObject *)(args))->ob_item, \
+               ((PyTupleObject *)(args))->ob_size, types, ##rest)
+
+#define parseArg(arg, types, rest...) \
+    _parseArgs(&(arg), 1, types, ##rest)
+
+int _parseArgs(PyObject **args, unsigned int count, char *types, ...);
+
+#endif
+
+int abstract_init(PyObject *self, PyObject *args, PyObject *kwds);
+PyObject *wrapType(PyTypeObject *type, const jobject& obj);
+
+PyObject *j2p(const java::lang::String& js);
+java::lang::String p2j(PyObject *object);
+
+PyObject *make_descriptor(PyTypeObject *value);
+PyObject *make_descriptor(getclassfn initializeClass);
+PyObject *make_descriptor(getclassfn initializeClass, int generics);
+PyObject *make_descriptor(PyObject *value);
+PyObject *make_descriptor(PyObject *(*wrapfn)(const jobject &));
+PyObject *make_descriptor(jboolean value);
+PyObject *make_descriptor(jbyte value);
+PyObject *make_descriptor(jchar value);
+PyObject *make_descriptor(jdouble value);
+PyObject *make_descriptor(jfloat value);
+PyObject *make_descriptor(jint value);
+PyObject *make_descriptor(jlong value);
+PyObject *make_descriptor(jshort value);
+
+jobjectArray make_array(jclass cls, PyObject *sequence);
+
+PyObject *callSuper(PyTypeObject *type,
+                    const char *name, PyObject *args, int cardinality);
+PyObject *callSuper(PyTypeObject *type, PyObject *self,
+                    const char *name, PyObject *args, int cardinality);
+
+template<class T> PyObject *get_iterator(T *self)
+{
+    java::util::Iterator iterator((jobject) NULL);
+
+    OBJ_CALL(iterator = self->object.iterator());
+    return java::util::t_Iterator::wrap_Object(iterator);
+}
+
+#ifdef _java_generics
+template<class T> PyObject *get_generic_iterator(T *self)
+{
+    java::util::Iterator iterator((jobject) NULL);
+    PyTypeObject *param = self->parameters ? self->parameters[0] : NULL;
+
+    OBJ_CALL(iterator = self->object.iterator());
+    return java::util::t_Iterator::wrap_Object(iterator, param);
+}
+#endif
+
+template<class T, class U> PyObject *get_iterator_next(T *self)
+{
+    jboolean hasNext;
+    OBJ_CALL(hasNext = self->object.hasNext());
+    if (!hasNext)
+    {
+        PyErr_SetNone(PyExc_StopIteration);
+        return NULL;
+    }
+
+    jobject next;
+    OBJ_CALL(next = env->iteratorNext(self->object.this$));
+
+    jclass cls = java::lang::String::initializeClass();
+    if (env->get_vm_env()->IsInstanceOf(next, cls))
+        return env->fromJString((jstring) next, 1);
+
+    return U::wrap_jobject(next);
+}
+
+#ifdef _java_generics
+template<class T, class U> PyObject *get_generic_iterator_next(T *self)
+{
+    jboolean hasNext;
+    OBJ_CALL(hasNext = self->object.hasNext());
+    if (!hasNext)
+    {
+        PyErr_SetNone(PyExc_StopIteration);
+        return NULL;
+    }
+
+    jobject next;
+    OBJ_CALL(next = env->iteratorNext(self->object.this$));
+
+    jclass cls = java::lang::String::initializeClass();
+    if (env->get_vm_env()->IsInstanceOf(next, cls))
+        return env->fromJString((jstring) next, 1);
+
+    PyTypeObject *param = self->parameters ? self->parameters[0] : NULL;
+    if (param != NULL)
+        return wrapType(param, next);
+
+    return U::wrap_jobject(next);
+}
+#endif
+
+template<class T, class U> PyObject *get_enumeration_next(T *self)
+{
+    jboolean hasMoreElements;
+    OBJ_CALL(hasMoreElements = self->object.hasMoreElements());
+    if (!hasMoreElements)
+    {
+        PyErr_SetNone(PyExc_StopIteration);
+        return NULL;
+    }
+
+    jobject next;
+    OBJ_CALL(next = env->enumerationNext(self->object.this$));
+
+    jclass cls = java::lang::String::initializeClass();
+    if (env->get_vm_env()->IsInstanceOf(next, cls))
+        return env->fromJString((jstring) next, 1);
+
+    return U::wrap_jobject(next);
+}
+
+#ifdef _java_generics
+template<class T, class U> PyObject *get_generic_enumeration_next(T *self)
+{
+    jboolean hasMoreElements;
+    OBJ_CALL(hasMoreElements = self->object.hasMoreElements());
+    if (!hasMoreElements)
+    {
+        PyErr_SetNone(PyExc_StopIteration);
+        return NULL;
+    }
+
+    jobject next;
+    OBJ_CALL(next = env->enumerationNext(self->object.this$));
+
+    jclass cls = java::lang::String::initializeClass();
+    if (env->get_vm_env()->IsInstanceOf(next, cls))
+        return env->fromJString((jstring) next, 1);
+
+    PyTypeObject *param = self->parameters ? self->parameters[0] : NULL;
+    if (param != NULL)
+        return wrapType(param, next);
+
+    return U::wrap_jobject(next);
+}
+#endif
+
+template<class T, class U, class V> PyObject *get_next(T *self)
+{
+    V next((jobject) NULL);
+    OBJ_CALL(next = self->object.next());
+    if (!next)
+    {
+        PyErr_SetNone(PyExc_StopIteration);
+        return NULL;
+    }
+        
+    jclass cls = java::lang::String::initializeClass();
+    if (env->get_vm_env()->IsInstanceOf(next.this$, cls))
+        return env->fromJString((jstring) next.this$, 0);
+
+    return U::wrap_Object(next);
+}
+
+#ifdef _java_generics
+template<class T, class U, class V> PyObject *get_generic_next(T *self)
+{
+    V next((jobject) NULL);
+    OBJ_CALL(next = self->object.next());
+    if (!next)
+    {
+        PyErr_SetNone(PyExc_StopIteration);
+        return NULL;
+    }
+        
+    jclass cls = java::lang::String::initializeClass();
+    if (env->get_vm_env()->IsInstanceOf(next.this$, cls))
+        return env->fromJString((jstring) next.this$, 0);
+
+    PyTypeObject *param = self->parameters ? self->parameters[0] : NULL;
+    if (param != NULL)
+        return wrapType(param, next.this$);
+
+    return U::wrap_Object(next);
+}
+#endif
+
+PyObject *get_extension_iterator(PyObject *self);
+PyObject *get_extension_next(PyObject *self);
+PyObject *get_extension_nextElement(PyObject *self);
+
+jobjectArray fromPySequence(jclass cls, PyObject *sequence);
+PyObject *castCheck(PyObject *obj, getclassfn initializeClass,
+                    int reportError);
+void installType(PyTypeObject *type, PyObject *module, char *name,
+                 int isExtension);
+
+#ifdef _java_generics
+PyObject *typeParameters(PyTypeObject *types[], size_t size);
+#endif
+
+extern PyTypeObject FinalizerClass$$Type;
+extern PyTypeObject FinalizerProxy$$Type;
+
+typedef struct {
+    PyObject_HEAD
+    PyObject *object;
+} t_fp;
+
+#endif /* _functions_h */