--- /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 */