gi/pygi-cache.h

   1 /* -*- Mode: C; c-basic-offset: 4 -*-
   2  * vim: tabstop=4 shiftwidth=4 expandtab
   3  *
   4  * Copyright (C) 2011 John (J5) Palmieri <johnp@redhat.com>
   5  * Copyright (C) 2013 Simon Feltman <sfeltman@gnome.org>
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, see <http://www.gnu.org/licenses/>.
  19  */
  20
  21 #ifndef __PYGI_CACHE_H__
  22 #define __PYGI_CACHE_H__
  23
  24 #include <Python.h>
  25 #include <girepository.h>
  26 #include <girffi.h>
  27
  28 #include "pygi-invoke-state-struct.h"
  29
  30 G_BEGIN_DECLS
  31
  32 typedef struct _PyGIArgCache PyGIArgCache;
  33 typedef struct _PyGICallableCache PyGICallableCache;
  34 typedef struct _PyGIFunctionCache PyGIFunctionCache;
  35 typedef struct _PyGIVFuncCache PyGIVFuncCache;
  36
  37 typedef PyGIFunctionCache PyGICCallbackCache;
  38 typedef PyGIFunctionCache PyGIConstructorCache;
  39 typedef PyGIFunctionCache PyGIFunctionWithInstanceCache;
  40 typedef PyGIFunctionCache PyGIMethodCache;
  41 typedef PyGICallableCache PyGIClosureCache;
  42
  43 typedef gboolean (*PyGIMarshalFromPyFunc) (PyGIInvokeState   *state,
  44                                            PyGICallableCache *callable_cache,
  45                                            PyGIArgCache      *arg_cache,
  46                                            PyObject          *py_arg,
  47                                            GIArgument        *arg,
  48                                            gpointer          *cleanup_data);
  49
  50 typedef PyObject *(*PyGIMarshalToPyFunc) (PyGIInvokeState   *state,
  51                                           PyGICallableCache *callable_cache,
  52                                           PyGIArgCache      *arg_cache,
  53                                           GIArgument        *arg,
  54                                           gpointer          *cleanup_data);
  55
  56 typedef void (*PyGIMarshalCleanupFunc) (PyGIInvokeState *state,
  57                                         PyGIArgCache    *arg_cache,
  58                                         PyObject        *py_arg,
  59                                         gpointer         data,
  60                                         gboolean         was_processed);
  61
  62 typedef void (*PyGIMarshalToPyCleanupFunc) (PyGIInvokeState *state,
  63                                             PyGIArgCache    *arg_cache,
  64                                             gpointer         cleanup_data,
  65                                             gpointer         data,
  66                                             gboolean         was_processed);
  67
  68 /* Argument meta types denote how we process the argument:
  69  *  - PYGI_META_ARG_TYPE_PARENT - parents may or may not have children
  70  *    but are always processed via the normal marshaller for their
  71  *    actual GI type.  If they have children the marshaller will
  72  *    also handle marshalling the children.
  73  *  - PYGI_META_ARG_TYPE_CHILD - Children without python argument are
  74  *    ignored by the marshallers and handled directly by their parents
  75  *    marshaller.
  76  *  - Children with pyargs (PYGI_META_ARG_TYPE_CHILD_WITH_PYARG) are processed
  77  *    the same as other child args but also have an index into the
  78  *    python parameters passed to the invoker
  79  */
  80 typedef enum {
  81     PYGI_META_ARG_TYPE_PARENT,
  82     PYGI_META_ARG_TYPE_CHILD,
  83     PYGI_META_ARG_TYPE_CHILD_WITH_PYARG,
  84     PYGI_META_ARG_TYPE_CLOSURE,
  85 } PyGIMetaArgType;
  86
  87 /*
  88  * Argument direction types denotes how we marshal,
  89  * e.g. to Python or from Python or both.
  90  */
  91 typedef enum {
  92     PYGI_DIRECTION_TO_PYTHON     = 1 << 0,
  93     PYGI_DIRECTION_FROM_PYTHON   = 1 << 1,
  94     PYGI_DIRECTION_BIDIRECTIONAL = PYGI_DIRECTION_TO_PYTHON | PYGI_DIRECTION_FROM_PYTHON
  95  } PyGIDirection;
  96
  97 /*
  98  * In PyGI IN and OUT arguments mean different things depending on the context
  99  * of the callable, e.g. is it a callback that is being called from C or a
 100  * function that is being called from Python.
 101  */
 102 typedef enum {
 103     PYGI_CALLING_CONTEXT_IS_FROM_C,
 104     PYGI_CALLING_CONTEXT_IS_FROM_PY
 105 } PyGICallingContext;
 106
 107
 108 struct _PyGIArgCache
 109 {
 110     const gchar *arg_name;
 111
 112     PyGIMetaArgType meta_type;
 113     gboolean is_pointer;
 114     gboolean is_caller_allocates;
 115     gboolean is_skipped;
 116     gboolean allow_none;
 117     gboolean has_default;
 118
 119     PyGIDirection direction;
 120     GITransfer transfer;
 121     GITypeTag type_tag;
 122     GITypeInfo *type_info;
 123
 124     PyGIMarshalFromPyFunc from_py_marshaller;
 125     PyGIMarshalToPyFunc to_py_marshaller;
 126
 127     PyGIMarshalCleanupFunc from_py_cleanup;
 128     PyGIMarshalToPyCleanupFunc to_py_cleanup;
 129
 130     GDestroyNotify destroy_notify;
 131
 132     gssize c_arg_index;
 133     gssize py_arg_index;
 134
 135     /* Set when has_default is true. */
 136     GIArgument default_value;
 137 };
 138
 139 typedef struct _PyGISequenceCache
 140 {
 141     PyGIArgCache arg_cache;
 142     PyGIArgCache *item_cache;
 143 } PyGISequenceCache;
 144
 145 typedef struct _PyGIArgGArray
 146 {
 147     PyGISequenceCache seq_cache;
 148     gssize fixed_size;
 149     gssize len_arg_index;
 150     gboolean is_zero_terminated;
 151     gsize item_size;
 152     GIArrayType array_type;
 153 } PyGIArgGArray;
 154
 155 typedef struct _PyGIInterfaceCache
 156 {
 157     PyGIArgCache arg_cache;
 158     gboolean is_foreign;
 159     GType g_type;
 160     PyObject *py_type;
 161     GIInterfaceInfo *interface_info;
 162     gchar *type_name;
 163 } PyGIInterfaceCache;
 164
 165 struct _PyGICallableCache
 166 {
 167     const gchar *name;
 168     const gchar *container_name;
 169     const gchar *namespace;
 170
 171     PyGICallingContext calling_context;
 172
 173     PyGIArgCache *return_cache;
 174     GPtrArray *args_cache;
 175     GSList *to_py_args;
 176     GSList *arg_name_list; /* for keyword arg matching */
 177     GHashTable *arg_name_hash;
 178     gboolean throws;
 179
 180     /* Index of user_data arg passed to a callable. */
 181     gssize user_data_index;
 182
 183     /* Index of user_data arg that can eat variable args passed to a callable. */
 184     gssize user_data_varargs_index;
 185
 186     /* Number of args already added */
 187     gssize args_offset;
 188
 189     /* Number of out args passed to g_function_info_invoke.
 190      * This is used for the length of PyGIInvokeState.out_values */
 191     gssize n_to_py_args;
 192
 193     /* If the callable return value gets used */
 194     gboolean has_return;
 195
 196     /* The type used for returning multiple values or NULL */
 197     PyTypeObject* resulttuple_type;
 198
 199     /* Number of out args for g_function_info_invoke that will be skipped
 200      * when marshaling to Python due to them being implicitly available
 201      * (list/array length).
 202      */
 203     gssize n_to_py_child_args;
 204
 205     /* Number of Python arguments expected for invoking the gi function. */
 206     gssize n_py_args;
 207
 208     /* Minimum number of args required to call the callable from Python.
 209      * This count does not include args with defaults. */
 210     gssize n_py_required_args;
 211
 212     void     (*deinit)              (PyGICallableCache *callable_cache);
 213
 214     gboolean (*generate_args_cache) (PyGICallableCache *callable_cache,
 215                                      GICallableInfo *callable_info);
 216 };
 217
 218 struct _PyGIFunctionCache {
 219     PyGICallableCache callable_cache;
 220
 221     /* An invoker with ffi_cif already setup */
 222     GIFunctionInvoker invoker;
 223
 224     PyObject *(*invoke) (PyGIFunctionCache *function_cache,
 225                          PyGIInvokeState *state,
 226                          PyObject *py_args,
 227                          PyObject *py_kwargs);
 228 } ;
 229
 230 struct _PyGIVFuncCache {
 231     PyGIFunctionWithInstanceCache fwi_cache;
 232
 233     GIBaseInfo *info;
 234 };
 235
 236
 237 gboolean
 238 pygi_arg_base_setup      (PyGIArgCache *arg_cache,
 239                           GITypeInfo   *type_info,
 240                           GIArgInfo    *arg_info,  /* may be NULL for return arguments */
 241                           GITransfer    transfer,
 242                           PyGIDirection direction);
 243
 244 gboolean
 245 pygi_arg_interface_setup (PyGIInterfaceCache *iface_cache,
 246                           GITypeInfo         *type_info,
 247                           GIArgInfo          *arg_info,  /* may be NULL for return arguments */
 248                           GITransfer          transfer,
 249                           PyGIDirection       direction,
 250                           GIInterfaceInfo    *iface_info);
 251
 252 gboolean
 253 pygi_arg_sequence_setup  (PyGISequenceCache  *sc,
 254                           GITypeInfo         *type_info,
 255                           GIArgInfo          *arg_info,    /* may be NULL for return arguments */
 256                           GITransfer          transfer,
 257                           PyGIDirection       direction,
 258                           PyGICallableCache  *callable_cache);
 259
 260 PyGIArgCache *
 261 pygi_arg_interface_new_from_info (GITypeInfo         *type_info,
 262                                   GIArgInfo          *arg_info,     /* may be NULL for return arguments */
 263                                   GITransfer          transfer,
 264                                   PyGIDirection       direction,
 265                                   GIInterfaceInfo    *iface_info);
 266
 267 PyGIArgCache *
 268 pygi_arg_cache_alloc     (void);
 269
 270 PyGIArgCache *
 271 pygi_arg_cache_new       (GITypeInfo *type_info,
 272                           GIArgInfo *arg_info,
 273                           GITransfer transfer,
 274                           PyGIDirection direction,
 275                           PyGICallableCache *callable_cache,
 276                           /* will be removed */
 277                           gssize c_arg_index,
 278                           gssize py_arg_index);
 279
 280 void
 281 pygi_arg_cache_free      (PyGIArgCache *cache);
 282
 283 void
 284 pygi_callable_cache_free    (PyGICallableCache *cache);
 285
 286 gchar *
 287 pygi_callable_cache_get_full_name (PyGICallableCache *cache);
 288
 289 PyGIFunctionCache *
 290 pygi_function_cache_new     (GICallableInfo *info);
 291
 292 PyObject *
 293 pygi_function_cache_invoke  (PyGIFunctionCache *function_cache,
 294                              PyObject *py_args,
 295                              PyObject *py_kwargs);
 296
 297 PyGIFunctionCache *
 298 pygi_ccallback_cache_new    (GICallableInfo *info,
 299                              GCallback function_ptr);
 300
 301 PyObject *
 302 pygi_ccallback_cache_invoke (PyGIFunctionCache *function_cache,
 303                              PyObject *py_args,
 304                              PyObject *py_kwargs,
 305                              gpointer user_data);
 306
 307 PyGIFunctionCache *
 308 pygi_constructor_cache_new  (GICallableInfo *info);
 309
 310 PyGIFunctionCache *
 311 pygi_method_cache_new       (GICallableInfo *info);
 312
 313 PyGIFunctionCache *
 314 pygi_vfunc_cache_new        (GICallableInfo *info);
 315
 316 PyGIClosureCache *
 317 pygi_closure_cache_new      (GICallableInfo *info);
 318
 319 inline static guint
 320 _pygi_callable_cache_args_len (PyGICallableCache *cache) {
 321     return ((cache)->args_cache)->len;
 322 }
 323
 324 inline static PyGIArgCache *
 325 _pygi_callable_cache_get_arg (PyGICallableCache *cache, guint index) {
 326     return (PyGIArgCache *) g_ptr_array_index (cache->args_cache, index);
 327 }
 328
 329 inline static void
 330 _pygi_callable_cache_set_arg (PyGICallableCache *cache, guint index, PyGIArgCache *arg_cache) {
 331     cache->args_cache->pdata[index] = arg_cache;
 332 }
 333
 334 G_END_DECLS
 335
 336 #endif /* __PYGI_CACHE_H__ */