gi/pygi-marshal-cleanup.c

   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>, Red Hat, Inc.
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include "pygi-marshal-cleanup.h"
  21 #include "pygi-foreign.h"
  22 #include <glib.h>
  23
  24 static inline void
  25 _cleanup_caller_allocates (PyGIInvokeState    *state,
  26                            PyGIArgCache       *cache,
  27                            PyObject           *py_obj,
  28                            gpointer            data,
  29                            gboolean            was_processed)
  30 {
  31     PyGIInterfaceCache *iface_cache = (PyGIInterfaceCache *)cache;
  32
  33     /* check GValue first because GValue is also a boxed sub-type */
  34     if (g_type_is_a (iface_cache->g_type, G_TYPE_VALUE)) {
  35         if (was_processed)
  36             g_value_unset (data);
  37         g_slice_free (GValue, data);
  38     } else if (g_type_is_a (iface_cache->g_type, G_TYPE_BOXED)) {
  39         gsize size;
  40         if (was_processed)
  41             return; /* will be cleaned up at deallocation */
  42         size = g_struct_info_get_size (iface_cache->interface_info);
  43         g_slice_free1 (size, data);
  44     } else if (iface_cache->is_foreign) {
  45         if (was_processed)
  46             return; /* will be cleaned up at deallocation */
  47         pygi_struct_foreign_release ((GIBaseInfo *)iface_cache->interface_info,
  48                                      data);
  49     } else {
  50         if (was_processed)
  51             return; /* will be cleaned up at deallocation */
  52         g_free (data);
  53     }
  54 }
  55
  56 /**
  57  * Cleanup during invoke can happen in multiple
  58  * stages, each of which can be the result of a
  59  * successful compleation of that stage or an error
  60  * occured which requires partial cleanup.
  61  *
  62  * For the most part, either the C interface being
  63  * invoked or the python object which wraps the
  64  * parameters, handle their lifecycles but in some
  65  * cases, where we have intermediate objects,
  66  * or when we fail processing a parameter, we need
  67  * to handle the clean up manually.
  68  *
  69  * There are two argument processing stages.
  70  * They are the in stage, where we process python
  71  * parameters into their C counterparts, and the out
  72  * stage, where we process out C parameters back
  73  * into python objects. The in stage also sets up
  74  * temporary out structures for caller allocated
  75  * parameters which need to be cleaned up either on
  76  * in stage failure or at the completion of the out
  77  * stage (either success or failure)
  78  *
  79  * The in stage must call one of these cleanup functions:
  80  *    - pygi_marshal_cleanup_args_from_py_marshal_success
  81  *       (continue to out stage)
  82  *    - pygi_marshal_cleanup_args_from_py_parameter_fail
  83  *       (final, exit from invoke)
  84  *
  85  * The out stage must call one of these cleanup functions which are all final:
  86  *    - pygi_marshal_cleanup_args_to_py_marshal_success
  87  *    - pygi_marshal_cleanup_args_return_fail
  88  *    - pygi_marshal_cleanup_args_to_py_parameter_fail
  89  *
  90  **/
  91 void
  92 pygi_marshal_cleanup_args_from_py_marshal_success (PyGIInvokeState   *state,
  93                                                    PyGICallableCache *cache)
  94 {
  95     guint i;
  96     PyObject *error_type, *error_value, *error_traceback;
  97     gboolean have_error = !!PyErr_Occurred ();
  98
  99     if (have_error)
 100         PyErr_Fetch (&error_type, &error_value, &error_traceback);
 101
 102     for (i = 0; i < _pygi_callable_cache_args_len (cache); i++) {
 103         PyGIArgCache *arg_cache = _pygi_callable_cache_get_arg (cache, i);
 104         PyGIMarshalCleanupFunc cleanup_func = arg_cache->from_py_cleanup;
 105         gpointer cleanup_data = state->args[i].arg_cleanup_data;
 106
 107         /* Only cleanup using args_cleanup_data when available.
 108          * It is the responsibility of the various "from_py" marshalers to return
 109          * cleanup_data which is then passed into their respective cleanup function.
 110          * PyGIInvokeState.args_cleanup_data stores this data (via _invoke_marshal_in_args)
 111          * for the duration of the invoke up until this point.
 112          */
 113         if (cleanup_func && cleanup_data != NULL && arg_cache->py_arg_index >= 0 &&
 114                 arg_cache->direction & PYGI_DIRECTION_FROM_PYTHON) {
 115             PyObject *py_arg = PyTuple_GET_ITEM (state->py_in_args, arg_cache->py_arg_index);
 116             cleanup_func (state, arg_cache, py_arg, cleanup_data, TRUE);
 117             state->args[i].arg_cleanup_data = NULL;
 118         }
 119     }
 120
 121     if (have_error)
 122         PyErr_Restore (error_type, error_value, error_traceback);
 123 }
 124
 125 void
 126 pygi_marshal_cleanup_args_to_py_marshal_success (PyGIInvokeState   *state,
 127                                                  PyGICallableCache *cache)
 128 {
 129     GSList *cache_item;
 130     guint i = 0;
 131     PyObject *error_type, *error_value, *error_traceback;
 132     gboolean have_error = !!PyErr_Occurred ();
 133
 134     if (have_error)
 135         PyErr_Fetch (&error_type, &error_value, &error_traceback);
 136
 137     /* clean up the return if available */
 138     if (cache->return_cache != NULL) {
 139         PyGIMarshalToPyCleanupFunc cleanup_func = cache->return_cache->to_py_cleanup;
 140         if (cleanup_func && state->return_arg.v_pointer != NULL)
 141             cleanup_func (state,
 142                           cache->return_cache,
 143                           state->to_py_return_arg_cleanup_data,
 144                           state->return_arg.v_pointer,
 145                           TRUE);
 146     }
 147
 148     /* Now clean up args */
 149     cache_item = cache->to_py_args;
 150     while (cache_item) {
 151         PyGIArgCache *arg_cache = (PyGIArgCache *) cache_item->data;
 152         PyGIMarshalToPyCleanupFunc cleanup_func = arg_cache->to_py_cleanup;
 153         gpointer data = state->args[arg_cache->c_arg_index].arg_value.v_pointer;
 154
 155         if (cleanup_func != NULL && data != NULL)
 156             cleanup_func (state,
 157                           arg_cache,
 158                           state->args[arg_cache->c_arg_index].to_py_arg_cleanup_data,
 159                           data,
 160                           TRUE);
 161         else if (arg_cache->is_caller_allocates && data != NULL) {
 162             _cleanup_caller_allocates (state,
 163                                        arg_cache,
 164                                        state->args[arg_cache->c_arg_index].to_py_arg_cleanup_data,
 165                                        data,
 166                                        TRUE);
 167         }
 168
 169         i++;
 170         cache_item = cache_item->next;
 171     }
 172
 173     if (have_error)
 174         PyErr_Restore (error_type, error_value, error_traceback);
 175 }
 176
 177 void
 178 pygi_marshal_cleanup_args_from_py_parameter_fail (PyGIInvokeState   *state,
 179                                                   PyGICallableCache *cache,
 180                                                   gssize failed_arg_index)
 181 {
 182     guint i;
 183     PyObject *error_type, *error_value, *error_traceback;
 184     gboolean have_error = !!PyErr_Occurred ();
 185
 186     if (have_error)
 187         PyErr_Fetch (&error_type, &error_value, &error_traceback);
 188
 189     state->failed = TRUE;
 190
 191     for (i = 0; i < _pygi_callable_cache_args_len (cache)  && i <= (guint)failed_arg_index; i++) {
 192         PyGIArgCache *arg_cache = _pygi_callable_cache_get_arg (cache, i);
 193         PyGIMarshalCleanupFunc cleanup_func = arg_cache->from_py_cleanup;
 194         gpointer cleanup_data = state->args[i].arg_cleanup_data;
 195         PyObject *py_arg = NULL;
 196
 197         if (arg_cache->py_arg_index < 0) {
 198             continue;
 199         }
 200         py_arg = PyTuple_GET_ITEM (state->py_in_args, arg_cache->py_arg_index);
 201
 202         if (cleanup_func && cleanup_data != NULL &&
 203                 arg_cache->direction == PYGI_DIRECTION_FROM_PYTHON) {
 204             cleanup_func (state,
 205                           arg_cache,
 206                           py_arg,
 207                           cleanup_data,
 208                           i < (guint)failed_arg_index);
 209
 210         } else if (arg_cache->is_caller_allocates && cleanup_data != NULL) {
 211             _cleanup_caller_allocates (state,
 212                                        arg_cache,
 213                                        py_arg,
 214                                        cleanup_data,
 215                                        FALSE);
 216         }
 217         state->args[i].arg_cleanup_data = NULL;
 218     }
 219
 220     if (have_error)
 221         PyErr_Restore (error_type, error_value, error_traceback);
 222 }
 223
 224 void
 225 pygi_marshal_cleanup_args_return_fail (PyGIInvokeState   *state,
 226                                        PyGICallableCache *cache)
 227 {
 228     state->failed = TRUE;
 229 }
 230
 231 void
 232 pygi_marshal_cleanup_args_to_py_parameter_fail (PyGIInvokeState   *state,
 233                                               PyGICallableCache *cache,
 234                                               gssize failed_to_py_arg_index)
 235 {
 236     state->failed = TRUE;
 237 }