jcc/jcc/sources/functions.h

   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 #ifndef _functions_h
  16 #define _functions_h
  17
  18 #include "java/util/Iterator.h"
  19 #include "java/util/Enumeration.h"
  20 #include "java/lang/String.h"
  21 #include "java/lang/Object.h"
  22 #include "macros.h"
  23
  24 #if PY_VERSION_HEX < 0x02050000
  25 typedef int Py_ssize_t;
  26 typedef inquiry lenfunc;
  27 typedef intargfunc ssizeargfunc;
  28 typedef intintargfunc ssizessizeargfunc;
  29 typedef intobjargproc ssizeobjargproc;
  30 typedef intintobjargproc ssizessizeobjargproc;
  31 #endif
  32
  33 typedef PyTypeObject **(*getparametersfn)(void *);
  34 typedef int (*boxfn)(PyTypeObject *, PyObject *, java::lang::Object *);
  35
  36 PyObject *PyErr_SetArgsError(char *name, PyObject *args);
  37 PyObject *PyErr_SetArgsError(PyObject *self, char *name, PyObject *args);
  38 PyObject *PyErr_SetArgsError(PyTypeObject *type, char *name, PyObject *args);
  39 PyObject *PyErr_SetJavaError();
  40
  41 extern PyObject *PyExc_JavaError;
  42 extern PyObject *PyExc_InvalidArgsError;
  43
  44
  45 void throwPythonError(void);
  46 void throwTypeError(const char *name, PyObject *object);
  47
  48 #if defined(_MSC_VER) || defined(__SUNPRO_CC)
  49
  50 #define parseArgs __parseArgs
  51 #define parseArg __parseArg
  52
  53 int __parseArgs(PyObject *args, char *types, ...);
  54 int __parseArg(PyObject *arg, char *types, ...);
  55
  56 int _parseArgs(PyObject **args, unsigned int count, char *types,
  57                va_list list, va_list check);
  58
  59 #else
  60
  61 #define parseArgs(args, types, rest...) \
  62     _parseArgs(((PyTupleObject *)(args))->ob_item, \
  63                ((PyTupleObject *)(args))->ob_size, types, ##rest)
  64
  65 #define parseArg(arg, types, rest...) \
  66     _parseArgs(&(arg), 1, types, ##rest)
  67
  68 int _parseArgs(PyObject **args, unsigned int count, char *types, ...);
  69
  70 #endif
  71
  72 int abstract_init(PyObject *self, PyObject *args, PyObject *kwds);
  73 PyObject *wrapType(PyTypeObject *type, const jobject& obj);
  74
  75 PyObject *unboxBoolean(const jobject& obj);
  76 PyObject *unboxByte(const jobject& obj);
  77 PyObject *unboxCharacter(const jobject& obj);
  78 PyObject *unboxDouble(const jobject& obj);
  79 PyObject *unboxFloat(const jobject& obj);
  80 PyObject *unboxInteger(const jobject& obj);
  81 PyObject *unboxLong(const jobject& obj);
  82 PyObject *unboxShort(const jobject& obj);
  83 PyObject *unboxString(const jobject& obj);
  84
  85 int boxBoolean(PyTypeObject *type, PyObject *arg, java::lang::Object *obj);
  86 int boxByte(PyTypeObject *type, PyObject *arg, java::lang::Object *obj);
  87 int boxCharacter(PyTypeObject *type, PyObject *arg, java::lang::Object *obj);
  88 int boxCharSequence(PyTypeObject *type, PyObject *arg, java::lang::Object *obj);
  89 int boxDouble(PyTypeObject *type, PyObject *arg, java::lang::Object *obj);
  90 int boxFloat(PyTypeObject *type, PyObject *arg, java::lang::Object *obj);
  91 int boxInteger(PyTypeObject *type, PyObject *arg, java::lang::Object *obj);
  92 int boxLong(PyTypeObject *type, PyObject *arg, java::lang::Object *obj);
  93 int boxNumber(PyTypeObject *type, PyObject *arg, java::lang::Object *obj);
  94 int boxShort(PyTypeObject *type, PyObject *arg, java::lang::Object *obj);
  95 int boxString(PyTypeObject *type, PyObject *arg, java::lang::Object *obj);
  96 int boxObject(PyTypeObject *type, PyObject *arg, java::lang::Object *obj);
  97
  98 PyObject *j2p(const java::lang::String& js);
  99 java::lang::String p2j(PyObject *object);
 100
 101 PyObject *make_descriptor(PyTypeObject *value);
 102 PyObject *make_descriptor(getclassfn initializeClass);
 103 PyObject *make_descriptor(getclassfn initializeClass, int generics);
 104 PyObject *make_descriptor(PyObject *value);
 105 PyObject *make_descriptor(PyObject *(*wrapfn)(const jobject &));
 106 PyObject *make_descriptor(boxfn fn);
 107 PyObject *make_descriptor(jboolean value);
 108 PyObject *make_descriptor(jbyte value);
 109 PyObject *make_descriptor(jchar value);
 110 PyObject *make_descriptor(jdouble value);
 111 PyObject *make_descriptor(jfloat value);
 112 PyObject *make_descriptor(jint value);
 113 PyObject *make_descriptor(jlong value);
 114 PyObject *make_descriptor(jshort value);
 115
 116 jobjectArray make_array(jclass cls, PyObject *sequence);
 117
 118 PyObject *callSuper(PyTypeObject *type,
 119                     const char *name, PyObject *args, int cardinality);
 120 PyObject *callSuper(PyTypeObject *type, PyObject *self,
 121                     const char *name, PyObject *args, int cardinality);
 122
 123 template<class T> PyObject *get_iterator(T *self)
 124 {
 125     jobject iterator;
 126
 127     OBJ_CALL(iterator = env->iterator(self->object.this$));
 128     return java::util::t_Iterator::wrap_jobject(iterator);
 129 }
 130
 131 #ifdef _java_generics
 132 template<class T> PyObject *get_generic_iterator(T *self)
 133 {
 134     PyTypeObject *param = self->parameters ? self->parameters[0] : NULL;
 135     jobject iterator;
 136
 137     OBJ_CALL(iterator = env->iterator(self->object.this$));
 138     return java::util::t_Iterator::wrap_jobject(iterator, param);
 139 }
 140 #endif
 141
 142 template<class T, class U> PyObject *get_iterator_next(T *self)
 143 {
 144     jboolean hasNext;
 145     OBJ_CALL(hasNext = self->object.hasNext());
 146     if (!hasNext)
 147     {
 148         PyErr_SetNone(PyExc_StopIteration);
 149         return NULL;
 150     }
 151
 152     jobject next;
 153     OBJ_CALL(next = env->iteratorNext(self->object.this$));
 154
 155     jclass cls = java::lang::String::initializeClass();
 156     if (env->get_vm_env()->IsInstanceOf(next, cls))
 157         return env->fromJString((jstring) next, 1);
 158
 159     return U::wrap_jobject(next);
 160 }
 161
 162 #ifdef _java_generics
 163 template<class T, class U> PyObject *get_generic_iterator_next(T *self)
 164 {
 165     jboolean hasNext;
 166     OBJ_CALL(hasNext = self->object.hasNext());
 167     if (!hasNext)
 168     {
 169         PyErr_SetNone(PyExc_StopIteration);
 170         return NULL;
 171     }
 172
 173     jobject next;
 174     OBJ_CALL(next = env->iteratorNext(self->object.this$));
 175
 176     jclass cls = java::lang::String::initializeClass();
 177     if (env->get_vm_env()->IsInstanceOf(next, cls))
 178         return env->fromJString((jstring) next, 1);
 179
 180     PyTypeObject *param = self->parameters ? self->parameters[0] : NULL;
 181     if (param != NULL)
 182         return wrapType(param, next);
 183
 184     return U::wrap_jobject(next);
 185 }
 186 #endif
 187
 188 template<class T, class U> PyObject *get_enumeration_next(T *self)
 189 {
 190     jboolean hasMoreElements;
 191     OBJ_CALL(hasMoreElements = self->object.hasMoreElements());
 192     if (!hasMoreElements)
 193     {
 194         PyErr_SetNone(PyExc_StopIteration);
 195         return NULL;
 196     }
 197
 198     jobject next;
 199     OBJ_CALL(next = env->enumerationNext(self->object.this$));
 200
 201     jclass cls = java::lang::String::initializeClass();
 202     if (env->get_vm_env()->IsInstanceOf(next, cls))
 203         return env->fromJString((jstring) next, 1);
 204
 205     return U::wrap_jobject(next);
 206 }
 207
 208 #ifdef _java_generics
 209 template<class T, class U> PyObject *get_generic_enumeration_next(T *self)
 210 {
 211     jboolean hasMoreElements;
 212     OBJ_CALL(hasMoreElements = self->object.hasMoreElements());
 213     if (!hasMoreElements)
 214     {
 215         PyErr_SetNone(PyExc_StopIteration);
 216         return NULL;
 217     }
 218
 219     jobject next;
 220     OBJ_CALL(next = env->enumerationNext(self->object.this$));
 221
 222     jclass cls = java::lang::String::initializeClass();
 223     if (env->get_vm_env()->IsInstanceOf(next, cls))
 224         return env->fromJString((jstring) next, 1);
 225
 226     PyTypeObject *param = self->parameters ? self->parameters[0] : NULL;
 227     if (param != NULL)
 228         return wrapType(param, next);
 229
 230     return U::wrap_jobject(next);
 231 }
 232 #endif
 233
 234 template<class T, class U, class V> PyObject *get_next(T *self)
 235 {
 236     V next((jobject) NULL);
 237     OBJ_CALL(next = self->object.next());
 238     if (!next)
 239     {
 240         PyErr_SetNone(PyExc_StopIteration);
 241         return NULL;
 242     }
 243
 244     jclass cls = java::lang::String::initializeClass();
 245     if (env->get_vm_env()->IsInstanceOf(next.this$, cls))
 246         return env->fromJString((jstring) next.this$, 0);
 247
 248     return U::wrap_Object(next);
 249 }
 250
 251 #ifdef _java_generics
 252 template<class T, class U, class V> PyObject *get_generic_next(T *self)
 253 {
 254     V next((jobject) NULL);
 255     OBJ_CALL(next = self->object.next());
 256     if (!next)
 257     {
 258         PyErr_SetNone(PyExc_StopIteration);
 259         return NULL;
 260     }
 261
 262     jclass cls = java::lang::String::initializeClass();
 263     if (env->get_vm_env()->IsInstanceOf(next.this$, cls))
 264         return env->fromJString((jstring) next.this$, 0);
 265
 266     PyTypeObject *param = self->parameters ? self->parameters[0] : NULL;
 267     if (param != NULL)
 268         return wrapType(param, next.this$);
 269
 270     return U::wrap_Object(next);
 271 }
 272 #endif
 273
 274 PyObject *get_extension_iterator(PyObject *self);
 275 PyObject *get_extension_next(PyObject *self);
 276 PyObject *get_extension_nextElement(PyObject *self);
 277
 278 jobjectArray fromPySequence(jclass cls, PyObject *sequence);
 279 PyObject *castCheck(PyObject *obj, getclassfn initializeClass,
 280                     int reportError);
 281 void installType(PyTypeObject *type, PyObject *module, char *name,
 282                  int isExtension);
 283
 284 #ifdef _java_generics
 285 PyObject *typeParameters(PyTypeObject *types[], size_t size);
 286 #endif
 287
 288 extern PyTypeObject PY_TYPE(FinalizerClass);
 289 extern PyTypeObject PY_TYPE(FinalizerProxy);
 290
 291 typedef struct {
 292     PyObject_HEAD
 293     PyObject *object;
 294 } t_fp;
 295
 296 #endif /* _functions_h */