gi/pygi-argument.c

   1 /* -*- Mode: C; c-basic-offset: 4 -*-
   2  * vim: tabstop=4 shiftwidth=4 expandtab
   3  *
   4  * Copyright (C) 2005-2009 Johan Dahlin <johan@gnome.org>
   5  *
   6  *   pygi-argument.c: GIArgument - PyObject conversion functions.
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, see <http://www.gnu.org/licenses/>.
  20  */
  21
  22 #include <Python.h>
  23
  24 #include <string.h>
  25 #include <time.h>
  26
  27 #include "pygobject-internal.h"
  28
  29 #include <pygenum.h>
  30 #include <pygflags.h>
  31
  32 #include "pygi-python-compat.h"
  33 #include "pygi-argument.h"
  34 #include "pygi-info.h"
  35 #include "pygi-value.h"
  36 #include "pygi-basictype.h"
  37 #include "pygi-object.h"
  38 #include "pygi-struct-marshal.h"
  39 #include "pygi-error.h"
  40 #include "pygi-foreign.h"
  41 #include "pygi-type.h"
  42 #include "pygi-util.h"
  43
  44
  45 gboolean
  46 pygi_argument_to_gssize (GIArgument *arg_in,
  47                          GITypeTag  type_tag,
  48                          gssize *gssize_out)
  49 {
  50     switch (type_tag) {
  51       case GI_TYPE_TAG_INT8:
  52           *gssize_out = arg_in->v_int8;
  53           return TRUE;
  54       case GI_TYPE_TAG_UINT8:
  55           *gssize_out = arg_in->v_uint8;
  56           return TRUE;
  57       case GI_TYPE_TAG_INT16:
  58           *gssize_out = arg_in->v_int16;
  59           return TRUE;
  60       case GI_TYPE_TAG_UINT16:
  61           *gssize_out = arg_in->v_uint16;
  62           return TRUE;
  63       case GI_TYPE_TAG_INT32:
  64           *gssize_out = arg_in->v_int32;
  65           return TRUE;
  66       case GI_TYPE_TAG_UINT32:
  67           *gssize_out = arg_in->v_uint32;
  68           return TRUE;
  69       case GI_TYPE_TAG_INT64:
  70           if (arg_in->v_int64 > G_MAXSSIZE || arg_in->v_int64 < G_MINSSIZE) {
  71               PyErr_Format (PyExc_TypeError,
  72                             "Unable to marshal %s to gssize",
  73                             g_type_tag_to_string(type_tag));
  74               return FALSE;
  75           }
  76           *gssize_out = (gssize)arg_in->v_int64;
  77           return TRUE;
  78       case GI_TYPE_TAG_UINT64:
  79           if (arg_in->v_uint64 > G_MAXSSIZE) {
  80               PyErr_Format (PyExc_TypeError,
  81                             "Unable to marshal %s to gssize",
  82                             g_type_tag_to_string(type_tag));
  83               return FALSE;
  84           }
  85           *gssize_out = (gssize)arg_in->v_uint64;
  86           return TRUE;
  87       default:
  88           PyErr_Format (PyExc_TypeError,
  89                         "Unable to marshal %s to gssize",
  90                         g_type_tag_to_string(type_tag));
  91           return FALSE;
  92     }
  93 }
  94
  95 static GITypeTag
  96 _pygi_get_storage_type (GITypeInfo *type_info)
  97 {
  98     GITypeTag type_tag = g_type_info_get_tag (type_info);
  99
 100     if (type_tag == GI_TYPE_TAG_INTERFACE) {
 101         GIBaseInfo *interface = g_type_info_get_interface (type_info);
 102         switch (g_base_info_get_type (interface)) {
 103             case GI_INFO_TYPE_ENUM:
 104             case GI_INFO_TYPE_FLAGS:
 105                 type_tag = g_enum_info_get_storage_type ((GIEnumInfo *)interface);
 106                 break;
 107             default:
 108                 /* FIXME: we might have something to do for other types */
 109                 break;
 110         }
 111         g_base_info_unref (interface);
 112     }
 113     return type_tag;
 114 }
 115
 116 void
 117 _pygi_hash_pointer_to_arg (GIArgument *arg,
 118                            GITypeInfo *type_info)
 119 {
 120     GITypeTag type_tag = _pygi_get_storage_type (type_info);
 121
 122     switch (type_tag) {
 123         case GI_TYPE_TAG_INT8:
 124             arg->v_int8 = (gint8)GPOINTER_TO_INT (arg->v_pointer);
 125             break;
 126         case GI_TYPE_TAG_INT16:
 127             arg->v_int16 = (gint16)GPOINTER_TO_INT (arg->v_pointer);
 128             break;
 129         case GI_TYPE_TAG_INT32:
 130             arg->v_int32 = (gint32)GPOINTER_TO_INT (arg->v_pointer);
 131             break;
 132         case GI_TYPE_TAG_UINT8:
 133             arg->v_uint8 = (guint8)GPOINTER_TO_UINT (arg->v_pointer);
 134             break;
 135         case GI_TYPE_TAG_UINT16:
 136             arg->v_uint16 = (guint16)GPOINTER_TO_UINT (arg->v_pointer);
 137             break;
 138         case GI_TYPE_TAG_UINT32:
 139             arg->v_uint32 = (guint32)GPOINTER_TO_UINT (arg->v_pointer);
 140             break;
 141         case GI_TYPE_TAG_GTYPE:
 142             arg->v_size = GPOINTER_TO_SIZE (arg->v_pointer);
 143             break;
 144         case GI_TYPE_TAG_UTF8:
 145         case GI_TYPE_TAG_FILENAME:
 146         case GI_TYPE_TAG_INTERFACE:
 147         case GI_TYPE_TAG_ARRAY:
 148             break;
 149         default:
 150             g_critical ("Unsupported type %s", g_type_tag_to_string(type_tag));
 151     }
 152 }
 153
 154 gpointer
 155 _pygi_arg_to_hash_pointer (const GIArgument *arg,
 156                            GITypeInfo       *type_info)
 157 {
 158     GITypeTag type_tag = _pygi_get_storage_type (type_info);
 159
 160     switch (type_tag) {
 161         case GI_TYPE_TAG_INT8:
 162             return GINT_TO_POINTER (arg->v_int8);
 163         case GI_TYPE_TAG_UINT8:
 164             return GINT_TO_POINTER (arg->v_uint8);
 165         case GI_TYPE_TAG_INT16:
 166             return GINT_TO_POINTER (arg->v_int16);
 167         case GI_TYPE_TAG_UINT16:
 168             return GINT_TO_POINTER (arg->v_uint16);
 169         case GI_TYPE_TAG_INT32:
 170             return GINT_TO_POINTER (arg->v_int32);
 171         case GI_TYPE_TAG_UINT32:
 172             return GINT_TO_POINTER (arg->v_uint32);
 173         case GI_TYPE_TAG_GTYPE:
 174             return GSIZE_TO_POINTER (arg->v_size);
 175         case GI_TYPE_TAG_UTF8:
 176         case GI_TYPE_TAG_FILENAME:
 177         case GI_TYPE_TAG_INTERFACE:
 178         case GI_TYPE_TAG_ARRAY:
 179             return arg->v_pointer;
 180         default:
 181             g_critical ("Unsupported type %s", g_type_tag_to_string(type_tag));
 182             return arg->v_pointer;
 183     }
 184 }
 185
 186
 187 /**
 188  * _pygi_argument_array_length_marshal:
 189  * @length_arg_index: Index of length argument in the callables args list.
 190  * @user_data1: (type Array(GValue)): Array of GValue arguments to retrieve length
 191  * @user_data2: (type GICallableInfo): Callable info to get the argument from.
 192  *
 193  * Generic marshalling policy for array length arguments in callables.
 194  *
 195  * Returns: The length of the array or -1 on failure.
 196  */
 197 gssize
 198 _pygi_argument_array_length_marshal (gsize length_arg_index,
 199                                      void *user_data1,
 200                                      void *user_data2)
 201 {
 202     GIArgInfo length_arg_info;
 203     GITypeInfo length_type_info;
 204     GIArgument length_arg;
 205     gssize array_len = -1;
 206     GValue *values = (GValue *)user_data1;
 207     GICallableInfo *callable_info = (GICallableInfo *)user_data2;
 208
 209     g_callable_info_load_arg (callable_info, (gint)length_arg_index, &length_arg_info);
 210     g_arg_info_load_type (&length_arg_info, &length_type_info);
 211
 212     length_arg = _pygi_argument_from_g_value (&(values[length_arg_index]),
 213                                               &length_type_info);
 214     if (!pygi_argument_to_gssize (&length_arg,
 215                                   g_type_info_get_tag (&length_type_info),
 216                                   &array_len)) {
 217         return -1;
 218     }
 219
 220     return array_len;
 221 }
 222
 223 /**
 224  * _pygi_argument_to_array
 225  * @arg: The argument to convert
 226  * @array_length_policy: Closure for marshalling the array length argument when needed.
 227  * @user_data1: Generic user data passed to the array_length_policy.
 228  * @user_data2: Generic user data passed to the array_length_policy.
 229  * @type_info: The type info for @arg
 230  * @out_free_array: A return location for a gboolean that indicates whether
 231  *                  or not the wrapped GArray should be freed
 232  *
 233  * Make sure an array type argument is wrapped in a GArray.
 234  *
 235  * Note: This method can *not* be folded into _pygi_argument_to_object() because
 236  * arrays are special in the sense that they might require access to @args in
 237  * order to get the length.
 238  *
 239  * Returns: A GArray wrapping @arg. If @out_free_array has been set to TRUE then
 240  *          free the array with g_array_free() without freeing the data members.
 241  *          Otherwise don't free the array.
 242  */
 243 GArray *
 244 _pygi_argument_to_array (GIArgument  *arg,
 245                          PyGIArgArrayLengthPolicy array_length_policy,
 246                          void        *user_data1,
 247                          void        *user_data2,
 248                          GITypeInfo  *type_info,
 249                          gboolean    *out_free_array)
 250 {
 251     GITypeInfo *item_type_info;
 252     gboolean is_zero_terminated;
 253     gsize item_size;
 254     gssize length;
 255     GArray *g_array;
 256
 257     g_return_val_if_fail (g_type_info_get_tag (type_info) == GI_TYPE_TAG_ARRAY, NULL);
 258
 259     if (arg->v_pointer == NULL) {
 260         return NULL;
 261     }
 262
 263     switch (g_type_info_get_array_type (type_info)) {
 264         case GI_ARRAY_TYPE_C:
 265             is_zero_terminated = g_type_info_is_zero_terminated (type_info);
 266             item_type_info = g_type_info_get_param_type (type_info, 0);
 267
 268             item_size = _pygi_g_type_info_size (item_type_info);
 269
 270             g_base_info_unref ( (GIBaseInfo *) item_type_info);
 271
 272             if (is_zero_terminated) {
 273                 length = g_strv_length (arg->v_pointer);
 274             } else {
 275                 length = g_type_info_get_array_fixed_size (type_info);
 276                 if (length < 0) {
 277                     gint length_arg_pos;
 278
 279                     if (G_UNLIKELY (array_length_policy == NULL)) {
 280                         g_critical ("Unable to determine array length for %p",
 281                                     arg->v_pointer);
 282                         g_array = g_array_new (is_zero_terminated, FALSE, (guint)item_size);
 283                         *out_free_array = TRUE;
 284                         return g_array;
 285                     }
 286
 287                     length_arg_pos = g_type_info_get_array_length (type_info);
 288                     g_assert (length_arg_pos >= 0);
 289
 290                     length = array_length_policy (length_arg_pos, user_data1, user_data2);
 291                     if (length < 0) {
 292                         return NULL;
 293                     }
 294                 }
 295             }
 296
 297             g_assert (length >= 0);
 298
 299             g_array = g_array_new (is_zero_terminated, FALSE, (guint)item_size);
 300
 301             g_free (g_array->data);
 302             g_array->data = arg->v_pointer;
 303             g_array->len = (guint)length;
 304             *out_free_array = TRUE;
 305             break;
 306         case GI_ARRAY_TYPE_ARRAY:
 307         case GI_ARRAY_TYPE_BYTE_ARRAY:
 308             /* Note: GByteArray is really just a GArray */
 309             g_array = arg->v_pointer;
 310             *out_free_array = FALSE;
 311             break;
 312         case GI_ARRAY_TYPE_PTR_ARRAY:
 313         {
 314             GPtrArray *ptr_array = (GPtrArray*) arg->v_pointer;
 315             g_array = g_array_sized_new (FALSE, FALSE,
 316                                          sizeof(gpointer),
 317                                          ptr_array->len);
 318              g_array->data = (char*) ptr_array->pdata;
 319              g_array->len = ptr_array->len;
 320              *out_free_array = TRUE;
 321              break;
 322         }
 323         default:
 324             g_critical ("Unexpected array type %u",
 325                         g_type_info_get_array_type (type_info));
 326             g_array = NULL;
 327             break;
 328     }
 329
 330     return g_array;
 331 }
 332
 333 GIArgument
 334 _pygi_argument_from_object (PyObject   *object,
 335                             GITypeInfo *type_info,
 336                             GITransfer  transfer)
 337 {
 338     GIArgument arg;
 339     GITypeTag type_tag;
 340     gpointer cleanup_data = NULL;
 341
 342     memset(&arg, 0, sizeof(GIArgument));
 343     type_tag = g_type_info_get_tag (type_info);
 344
 345     switch (type_tag) {
 346         case GI_TYPE_TAG_ARRAY:
 347         {
 348             Py_ssize_t py_length;
 349             guint length, i;
 350             gboolean is_zero_terminated;
 351             GITypeInfo *item_type_info;
 352             gsize item_size;
 353             GArray *array;
 354             GITransfer item_transfer;
 355
 356             if (object == Py_None) {
 357                 arg.v_pointer = NULL;
 358                 break;
 359             }
 360
 361             /* Note, strings are sequences, but we cannot accept them here */
 362             if (!PySequence_Check (object) ||
 363 #if PY_VERSION_HEX < 0x03000000
 364                 PyString_Check (object) ||
 365 #endif
 366                 PyUnicode_Check (object)) {
 367                 PyErr_SetString (PyExc_TypeError, "expected sequence");
 368                 break;
 369             }
 370
 371             py_length = PySequence_Length (object);
 372             if (py_length < 0)
 373                 break;
 374
 375             if (!pygi_guint_from_pyssize (py_length, &length))
 376                 break;
 377
 378             is_zero_terminated = g_type_info_is_zero_terminated (type_info);
 379             item_type_info = g_type_info_get_param_type (type_info, 0);
 380
 381             /* we handle arrays that are really strings specially, see below */
 382             if (g_type_info_get_tag (item_type_info) == GI_TYPE_TAG_UINT8)
 383                item_size = 1;
 384             else
 385                item_size = sizeof (GIArgument);
 386
 387             array = g_array_sized_new (is_zero_terminated, FALSE, (guint)item_size, length);
 388             if (array == NULL) {
 389                 g_base_info_unref ( (GIBaseInfo *) item_type_info);
 390                 PyErr_NoMemory();
 391                 break;
 392             }
 393
 394             if (g_type_info_get_tag (item_type_info) == GI_TYPE_TAG_UINT8 &&
 395                 PYGLIB_PyBytes_Check(object)) {
 396
 397                 memcpy(array->data, PYGLIB_PyBytes_AsString(object), length);
 398                 array->len = length;
 399                 goto array_success;
 400             }
 401
 402
 403             item_transfer = transfer == GI_TRANSFER_CONTAINER ? GI_TRANSFER_NOTHING : transfer;
 404
 405             for (i = 0; i < length; i++) {
 406                 PyObject *py_item;
 407                 GIArgument item;
 408
 409                 py_item = PySequence_GetItem (object, i);
 410                 if (py_item == NULL) {
 411                     goto array_item_error;
 412                 }
 413
 414                 item = _pygi_argument_from_object (py_item, item_type_info, item_transfer);
 415
 416                 Py_DECREF (py_item);
 417
 418                 if (PyErr_Occurred()) {
 419                     goto array_item_error;
 420                 }
 421
 422                 g_array_insert_val (array, i, item);
 423                 continue;
 424
 425 array_item_error:
 426                 /* Free everything we have converted so far. */
 427                 _pygi_argument_release ( (GIArgument *) &array, type_info,
 428                                          GI_TRANSFER_NOTHING, GI_DIRECTION_IN);
 429                 array = NULL;
 430
 431                 _PyGI_ERROR_PREFIX ("Item %u: ", i);
 432                 break;
 433             }
 434
 435 array_success:
 436             arg.v_pointer = array;
 437
 438             g_base_info_unref ( (GIBaseInfo *) item_type_info);
 439             break;
 440         }
 441         case GI_TYPE_TAG_INTERFACE:
 442         {
 443             GIBaseInfo *info;
 444             GIInfoType info_type;
 445
 446             info = g_type_info_get_interface (type_info);
 447             info_type = g_base_info_get_type (info);
 448
 449             switch (info_type) {
 450                 case GI_INFO_TYPE_CALLBACK:
 451                     /* This should be handled in invoke() */
 452                     g_assert_not_reached();
 453                     break;
 454                 case GI_INFO_TYPE_BOXED:
 455                 case GI_INFO_TYPE_STRUCT:
 456                 case GI_INFO_TYPE_UNION:
 457                 {
 458                     GType g_type;
 459                     PyObject *py_type;
 460                     gboolean is_foreign = (info_type == GI_INFO_TYPE_STRUCT) &&
 461                                           (g_struct_info_is_foreign ((GIStructInfo *) info));
 462
 463                     g_type = g_registered_type_info_get_g_type ( (GIRegisteredTypeInfo *) info);
 464                     py_type = pygi_type_import_by_gi_info ( (GIBaseInfo *) info);
 465
 466                     /* Note for G_TYPE_VALUE g_type:
 467                      * This will currently leak the GValue that is allocated and
 468                      * stashed in arg.v_pointer. Out argument marshaling for caller
 469                      * allocated GValues already pass in memory for the GValue.
 470                      * Further re-factoring is needed to fix this leak.
 471                      * See: https://bugzilla.gnome.org/show_bug.cgi?id=693405
 472                      */
 473                     pygi_arg_struct_from_py_marshal (object,
 474                                                      &arg,
 475                                                      NULL, /*arg_name*/
 476                                                      info, /*interface_info*/
 477                                                      g_type,
 478                                                      py_type,
 479                                                      transfer,
 480                                                      FALSE, /*copy_reference*/
 481                                                      is_foreign,
 482                                                      g_type_info_is_pointer (type_info));
 483
 484                     Py_DECREF (py_type);
 485                     break;
 486                 }
 487                 case GI_INFO_TYPE_ENUM:
 488                 case GI_INFO_TYPE_FLAGS:
 489                 {
 490                     if (!pygi_gint_from_py (object, &arg.v_int))
 491                         break;
 492
 493                     break;
 494                 }
 495                 case GI_INFO_TYPE_INTERFACE:
 496                 case GI_INFO_TYPE_OBJECT:
 497                     /* An error within this call will result in a NULL arg */
 498                     pygi_arg_gobject_out_arg_from_py (object, &arg, transfer);
 499                     break;
 500
 501                 default:
 502                     g_assert_not_reached();
 503             }
 504             g_base_info_unref (info);
 505             break;
 506         }
 507         case GI_TYPE_TAG_GLIST:
 508         case GI_TYPE_TAG_GSLIST:
 509         {
 510             Py_ssize_t length;
 511             GITypeInfo *item_type_info;
 512             GSList *list = NULL;
 513             GITransfer item_transfer;
 514             Py_ssize_t i;
 515
 516             if (object == Py_None) {
 517                 arg.v_pointer = NULL;
 518                 break;
 519             }
 520
 521             length = PySequence_Length (object);
 522             if (length < 0) {
 523                 break;
 524             }
 525
 526             item_type_info = g_type_info_get_param_type (type_info, 0);
 527             g_assert (item_type_info != NULL);
 528
 529             item_transfer = transfer == GI_TRANSFER_CONTAINER ? GI_TRANSFER_NOTHING : transfer;
 530
 531             for (i = length - 1; i >= 0; i--) {
 532                 PyObject *py_item;
 533                 GIArgument item;
 534
 535                 py_item = PySequence_GetItem (object, i);
 536                 if (py_item == NULL) {
 537                     goto list_item_error;
 538                 }
 539
 540                 item = _pygi_argument_from_object (py_item, item_type_info, item_transfer);
 541
 542                 Py_DECREF (py_item);
 543
 544                 if (PyErr_Occurred()) {
 545                     goto list_item_error;
 546                 }
 547
 548                 if (type_tag == GI_TYPE_TAG_GLIST) {
 549                     list = (GSList *) g_list_prepend ( (GList *) list, item.v_pointer);
 550                 } else {
 551                     list = g_slist_prepend (list, item.v_pointer);
 552                 }
 553
 554                 continue;
 555
 556 list_item_error:
 557                 /* Free everything we have converted so far. */
 558                 _pygi_argument_release ( (GIArgument *) &list, type_info,
 559                                          GI_TRANSFER_NOTHING, GI_DIRECTION_IN);
 560                 list = NULL;
 561
 562                 _PyGI_ERROR_PREFIX ("Item %zd: ", i);
 563                 break;
 564             }
 565
 566             arg.v_pointer = list;
 567
 568             g_base_info_unref ( (GIBaseInfo *) item_type_info);
 569
 570             break;
 571         }
 572         case GI_TYPE_TAG_GHASH:
 573         {
 574             Py_ssize_t length;
 575             PyObject *keys;
 576             PyObject *values;
 577             GITypeInfo *key_type_info;
 578             GITypeInfo *value_type_info;
 579             GITypeTag key_type_tag;
 580             GHashFunc hash_func;
 581             GEqualFunc equal_func;
 582             GHashTable *hash_table;
 583             GITransfer item_transfer;
 584             Py_ssize_t i;
 585
 586
 587             if (object == Py_None) {
 588                 arg.v_pointer = NULL;
 589                 break;
 590             }
 591
 592             length = PyMapping_Length (object);
 593             if (length < 0) {
 594                 break;
 595             }
 596
 597             keys = PyMapping_Keys (object);
 598             if (keys == NULL) {
 599                 break;
 600             }
 601
 602             values = PyMapping_Values (object);
 603             if (values == NULL) {
 604                 Py_DECREF (keys);
 605                 break;
 606             }
 607
 608             key_type_info = g_type_info_get_param_type (type_info, 0);
 609             g_assert (key_type_info != NULL);
 610
 611             value_type_info = g_type_info_get_param_type (type_info, 1);
 612             g_assert (value_type_info != NULL);
 613
 614             key_type_tag = g_type_info_get_tag (key_type_info);
 615
 616             switch (key_type_tag) {
 617                 case GI_TYPE_TAG_UTF8:
 618                 case GI_TYPE_TAG_FILENAME:
 619                     hash_func = g_str_hash;
 620                     equal_func = g_str_equal;
 621                     break;
 622                 default:
 623                     hash_func = NULL;
 624                     equal_func = NULL;
 625             }
 626
 627             hash_table = g_hash_table_new (hash_func, equal_func);
 628             if (hash_table == NULL) {
 629                 PyErr_NoMemory();
 630                 goto hash_table_release;
 631             }
 632
 633             item_transfer = transfer == GI_TRANSFER_CONTAINER ? GI_TRANSFER_NOTHING : transfer;
 634
 635             for (i = 0; i < length; i++) {
 636                 PyObject *py_key;
 637                 PyObject *py_value;
 638                 GIArgument key;
 639                 GIArgument value;
 640
 641                 py_key = PyList_GET_ITEM (keys, i);
 642                 py_value = PyList_GET_ITEM (values, i);
 643
 644                 key = _pygi_argument_from_object (py_key, key_type_info, item_transfer);
 645                 if (PyErr_Occurred()) {
 646                     goto hash_table_item_error;
 647                 }
 648
 649                 value = _pygi_argument_from_object (py_value, value_type_info, item_transfer);
 650                 if (PyErr_Occurred()) {
 651                     _pygi_argument_release (&key, type_info, GI_TRANSFER_NOTHING, GI_DIRECTION_IN);
 652                     goto hash_table_item_error;
 653                 }
 654
 655                 g_hash_table_insert (hash_table, key.v_pointer,
 656                                      _pygi_arg_to_hash_pointer (&value, value_type_info));
 657                 continue;
 658
 659 hash_table_item_error:
 660                 /* Free everything we have converted so far. */
 661                 _pygi_argument_release ( (GIArgument *) &hash_table, type_info,
 662                                          GI_TRANSFER_NOTHING, GI_DIRECTION_IN);
 663                 hash_table = NULL;
 664
 665                 _PyGI_ERROR_PREFIX ("Item %zd: ", i);
 666                 break;
 667             }
 668
 669             arg.v_pointer = hash_table;
 670
 671 hash_table_release:
 672             g_base_info_unref ( (GIBaseInfo *) key_type_info);
 673             g_base_info_unref ( (GIBaseInfo *) value_type_info);
 674             Py_DECREF (keys);
 675             Py_DECREF (values);
 676             break;
 677         }
 678         case GI_TYPE_TAG_ERROR:
 679             PyErr_SetString (PyExc_NotImplementedError, "error marshalling is not supported yet");
 680             /* TODO */
 681             break;
 682         default:
 683             /* Ignores cleanup data for now. */
 684             pygi_marshal_from_py_basic_type (object, &arg, type_tag, transfer, &cleanup_data);
 685             break;
 686     }
 687
 688     return arg;
 689 }
 690
 691 /**
 692  * _pygi_argument_to_object:
 693  * @arg: The argument to convert to an object.
 694  * @type_info: Type info for @arg
 695  * @transfer:
 696  *
 697  * If the argument is of type array, it must be encoded in a GArray, by calling
 698  * _pygi_argument_to_array(). This logic can not be folded into this method
 699  * as determining array lengths may require access to method call arguments.
 700  *
 701  * Returns: A PyObject representing @arg
 702  */
 703 PyObject *
 704 _pygi_argument_to_object (GIArgument  *arg,
 705                           GITypeInfo *type_info,
 706                           GITransfer transfer)
 707 {
 708     GITypeTag type_tag;
 709     PyObject *object = NULL;
 710
 711     type_tag = g_type_info_get_tag (type_info);
 712
 713     switch (type_tag) {
 714         case GI_TYPE_TAG_VOID:
 715         {
 716             if (g_type_info_is_pointer (type_info)) {
 717                 g_warn_if_fail (transfer == GI_TRANSFER_NOTHING);
 718                 object = PyLong_FromVoidPtr (arg->v_pointer);
 719             }
 720             break;
 721         }
 722         case GI_TYPE_TAG_ARRAY:
 723         {
 724             /* Arrays are assumed to be packed in a GArray */
 725             GArray *array;
 726             GITypeInfo *item_type_info;
 727             GITypeTag item_type_tag;
 728             GITransfer item_transfer;
 729             gsize i, item_size;
 730
 731             if (arg->v_pointer == NULL)
 732                 return PyList_New (0);
 733
 734             item_type_info = g_type_info_get_param_type (type_info, 0);
 735             g_assert (item_type_info != NULL);
 736
 737             item_type_tag = g_type_info_get_tag (item_type_info);
 738             item_transfer = transfer == GI_TRANSFER_CONTAINER ? GI_TRANSFER_NOTHING : transfer;
 739
 740             array = arg->v_pointer;
 741             item_size = g_array_get_element_size (array);
 742
 743             if (G_UNLIKELY (item_size > sizeof(GIArgument))) {
 744                 g_critical ("Stack overflow protection. "
 745                             "Can't copy array element into GIArgument.");
 746                 return PyList_New (0);
 747             }
 748
 749             if (item_type_tag == GI_TYPE_TAG_UINT8) {
 750                 /* Return as a byte array */
 751                 object = PYGLIB_PyBytes_FromStringAndSize (array->data, array->len);
 752             } else {
 753                 object = PyList_New (array->len);
 754                 if (object == NULL) {
 755                     g_critical ("Failure to allocate array for %u items", array->len);
 756                     g_base_info_unref ( (GIBaseInfo *) item_type_info);
 757                     break;
 758                 }
 759
 760                 for (i = 0; i < array->len; i++) {
 761                     GIArgument item = { 0 };
 762                     PyObject *py_item;
 763
 764                     memcpy (&item, array->data + i * item_size, item_size);
 765
 766                     py_item = _pygi_argument_to_object (&item, item_type_info, item_transfer);
 767                     if (py_item == NULL) {
 768                         Py_CLEAR (object);
 769                         _PyGI_ERROR_PREFIX ("Item %zu: ", i);
 770                         break;
 771                     }
 772
 773                     PyList_SET_ITEM (object, i, py_item);
 774                 }
 775             }
 776
 777             g_base_info_unref ( (GIBaseInfo *) item_type_info);
 778             break;
 779         }
 780         case GI_TYPE_TAG_INTERFACE:
 781         {
 782             GIBaseInfo *info;
 783             GIInfoType info_type;
 784
 785             info = g_type_info_get_interface (type_info);
 786             info_type = g_base_info_get_type (info);
 787
 788             switch (info_type) {
 789                 case GI_INFO_TYPE_CALLBACK:
 790                 {
 791                     g_assert_not_reached();
 792                 }
 793                 case GI_INFO_TYPE_BOXED:
 794                 case GI_INFO_TYPE_STRUCT:
 795                 case GI_INFO_TYPE_UNION:
 796                 {
 797                     PyObject *py_type;
 798                     GType g_type = g_registered_type_info_get_g_type ( (GIRegisteredTypeInfo *) info);
 799                     gboolean is_foreign = (info_type == GI_INFO_TYPE_STRUCT) &&
 800                                           (g_struct_info_is_foreign ((GIStructInfo *) info));
 801
 802                     /* Special case variant and none to force loading from py module. */
 803                     if (g_type == G_TYPE_VARIANT || g_type == G_TYPE_NONE) {
 804                         py_type = pygi_type_import_by_gi_info (info);
 805                     } else {
 806                         py_type = pygi_type_get_from_g_type (g_type);
 807                     }
 808
 809                     object = pygi_arg_struct_to_py_marshal (arg,
 810                                                             info, /*interface_info*/
 811                                                             g_type,
 812                                                             py_type,
 813                                                             transfer,
 814                                                             FALSE, /*is_allocated*/
 815                                                             is_foreign);
 816
 817                     Py_XDECREF (py_type);
 818                     break;
 819                 }
 820                 case GI_INFO_TYPE_ENUM:
 821                 case GI_INFO_TYPE_FLAGS:
 822                 {
 823                     GType type;
 824
 825                     type = g_registered_type_info_get_g_type ( (GIRegisteredTypeInfo *) info);
 826
 827                     if (type == G_TYPE_NONE) {
 828                         /* An enum with a GType of None is an enum without GType */
 829                         PyObject *py_type = pygi_type_import_by_gi_info (info);
 830                         PyObject *py_args = NULL;
 831
 832                         if (!py_type)
 833                             return NULL;
 834
 835                         py_args = PyTuple_New (1);
 836                         if (PyTuple_SetItem (py_args, 0, pygi_gint_to_py (arg->v_int)) != 0) {
 837                             Py_DECREF (py_args);
 838                             Py_DECREF (py_type);
 839                             return NULL;
 840                         }
 841
 842                         object = PyObject_CallFunction (py_type, "i", arg->v_int);
 843
 844                         Py_DECREF (py_args);
 845                         Py_DECREF (py_type);
 846
 847                     } else if (info_type == GI_INFO_TYPE_ENUM) {
 848                         object = pyg_enum_from_gtype (type, arg->v_int);
 849                     } else {
 850                         object = pyg_flags_from_gtype (type, arg->v_uint);
 851                     }
 852
 853                     break;
 854                 }
 855                 case GI_INFO_TYPE_INTERFACE:
 856                 case GI_INFO_TYPE_OBJECT:
 857                     object = pygi_arg_gobject_to_py_called_from_c (arg, transfer);
 858
 859                     break;
 860                 default:
 861                     g_assert_not_reached();
 862             }
 863
 864             g_base_info_unref (info);
 865             break;
 866         }
 867         case GI_TYPE_TAG_GLIST:
 868         case GI_TYPE_TAG_GSLIST:
 869         {
 870             GSList *list;
 871             gsize length;
 872             GITypeInfo *item_type_info;
 873             GITransfer item_transfer;
 874             gsize i;
 875
 876             list = arg->v_pointer;
 877             length = g_slist_length (list);
 878
 879             object = PyList_New (length);
 880             if (object == NULL) {
 881                 break;
 882             }
 883
 884             item_type_info = g_type_info_get_param_type (type_info, 0);
 885             g_assert (item_type_info != NULL);
 886
 887             item_transfer = transfer == GI_TRANSFER_CONTAINER ? GI_TRANSFER_NOTHING : transfer;
 888
 889             for (i = 0; list != NULL; list = g_slist_next (list), i++) {
 890                 GIArgument item;
 891                 PyObject *py_item;
 892
 893                 item.v_pointer = list->data;
 894
 895                 py_item = _pygi_argument_to_object (&item, item_type_info, item_transfer);
 896                 if (py_item == NULL) {
 897                     Py_CLEAR (object);
 898                     _PyGI_ERROR_PREFIX ("Item %zu: ", i);
 899                     break;
 900                 }
 901
 902                 PyList_SET_ITEM (object, i, py_item);
 903             }
 904
 905             g_base_info_unref ( (GIBaseInfo *) item_type_info);
 906             break;
 907         }
 908         case GI_TYPE_TAG_GHASH:
 909         {
 910             GITypeInfo *key_type_info;
 911             GITypeInfo *value_type_info;
 912             GITransfer item_transfer;
 913             GHashTableIter hash_table_iter;
 914             GIArgument key;
 915             GIArgument value;
 916
 917             if (arg->v_pointer == NULL) {
 918                 object = Py_None;
 919                 Py_INCREF (object);
 920                 break;
 921             }
 922
 923             object = PyDict_New();
 924             if (object == NULL) {
 925                 break;
 926             }
 927
 928             key_type_info = g_type_info_get_param_type (type_info, 0);
 929             g_assert (key_type_info != NULL);
 930             g_assert (g_type_info_get_tag (key_type_info) != GI_TYPE_TAG_VOID);
 931
 932             value_type_info = g_type_info_get_param_type (type_info, 1);
 933             g_assert (value_type_info != NULL);
 934             g_assert (g_type_info_get_tag (value_type_info) != GI_TYPE_TAG_VOID);
 935
 936             item_transfer = transfer == GI_TRANSFER_CONTAINER ? GI_TRANSFER_NOTHING : transfer;
 937
 938             g_hash_table_iter_init (&hash_table_iter, (GHashTable *) arg->v_pointer);
 939             while (g_hash_table_iter_next (&hash_table_iter, &key.v_pointer, &value.v_pointer)) {
 940                 PyObject *py_key;
 941                 PyObject *py_value;
 942                 int retval;
 943
 944                 py_key = _pygi_argument_to_object (&key, key_type_info, item_transfer);
 945                 if (py_key == NULL) {
 946                     break;
 947                 }
 948
 949                 _pygi_hash_pointer_to_arg (&value, value_type_info);
 950                 py_value = _pygi_argument_to_object (&value, value_type_info, item_transfer);
 951                 if (py_value == NULL) {
 952                     Py_DECREF (py_key);
 953                     break;
 954                 }
 955
 956                 retval = PyDict_SetItem (object, py_key, py_value);
 957
 958                 Py_DECREF (py_key);
 959                 Py_DECREF (py_value);
 960
 961                 if (retval < 0) {
 962                     Py_CLEAR (object);
 963                     break;
 964                 }
 965             }
 966
 967             g_base_info_unref ( (GIBaseInfo *) key_type_info);
 968             g_base_info_unref ( (GIBaseInfo *) value_type_info);
 969             break;
 970         }
 971         case GI_TYPE_TAG_ERROR:
 972         {
 973             GError *error = (GError *) arg->v_pointer;
 974             if (error != NULL && transfer == GI_TRANSFER_NOTHING) {
 975                 /* If we have not been transferred the ownership we must copy
 976                  * the error, because pygi_error_check() is going to free it.
 977                  */
 978                 error = g_error_copy (error);
 979             }
 980
 981             if (pygi_error_check (&error)) {
 982                 PyObject *err_type;
 983                 PyObject *err_value;
 984                 PyObject *err_trace;
 985                 PyErr_Fetch (&err_type, &err_value, &err_trace);
 986                 Py_XDECREF (err_type);
 987                 Py_XDECREF (err_trace);
 988                 object = err_value;
 989             } else {
 990                 object = Py_None;
 991                 Py_INCREF (object);
 992                 break;
 993             }
 994             break;
 995         }
 996         default:
 997         {
 998             object = pygi_marshal_to_py_basic_type (arg, type_tag, transfer);
 999         }
1000     }
1001
1002     return object;
1003 }
1004
1005 void
1006 _pygi_argument_release (GIArgument   *arg,
1007                         GITypeInfo  *type_info,
1008                         GITransfer   transfer,
1009                         GIDirection  direction)
1010 {
1011     GITypeTag type_tag;
1012     gboolean is_out = (direction == GI_DIRECTION_OUT || direction == GI_DIRECTION_INOUT);
1013
1014     type_tag = g_type_info_get_tag (type_info);
1015
1016     switch (type_tag) {
1017         case GI_TYPE_TAG_VOID:
1018             /* Don't do anything, it's transparent to the C side */
1019             break;
1020         case GI_TYPE_TAG_BOOLEAN:
1021         case GI_TYPE_TAG_INT8:
1022         case GI_TYPE_TAG_UINT8:
1023         case GI_TYPE_TAG_INT16:
1024         case GI_TYPE_TAG_UINT16:
1025         case GI_TYPE_TAG_INT32:
1026         case GI_TYPE_TAG_UINT32:
1027         case GI_TYPE_TAG_INT64:
1028         case GI_TYPE_TAG_UINT64:
1029         case GI_TYPE_TAG_FLOAT:
1030         case GI_TYPE_TAG_DOUBLE:
1031         case GI_TYPE_TAG_GTYPE:
1032         case GI_TYPE_TAG_UNICHAR:
1033             break;
1034         case GI_TYPE_TAG_FILENAME:
1035         case GI_TYPE_TAG_UTF8:
1036             /* With allow-none support the string could be NULL */
1037             if ((arg->v_string != NULL &&
1038                     (direction == GI_DIRECTION_IN && transfer == GI_TRANSFER_NOTHING))
1039                     || (direction == GI_DIRECTION_OUT && transfer == GI_TRANSFER_EVERYTHING)) {
1040                 g_free (arg->v_string);
1041             }
1042             break;
1043         case GI_TYPE_TAG_ARRAY:
1044         {
1045             GArray *array;
1046             gsize i;
1047
1048             if (arg->v_pointer == NULL) {
1049                 return;
1050             }
1051
1052             array = arg->v_pointer;
1053
1054             if ( (direction == GI_DIRECTION_IN && transfer != GI_TRANSFER_EVERYTHING)
1055                     || (direction == GI_DIRECTION_OUT && transfer == GI_TRANSFER_EVERYTHING)) {
1056                 GITypeInfo *item_type_info;
1057                 GITransfer item_transfer;
1058
1059                 item_type_info = g_type_info_get_param_type (type_info, 0);
1060
1061                 item_transfer = direction == GI_DIRECTION_IN ? GI_TRANSFER_NOTHING : GI_TRANSFER_EVERYTHING;
1062
1063                 /* Free the items */
1064                 for (i = 0; i < array->len; i++) {
1065                     GIArgument item;
1066                     memcpy (&item, array->data + (g_array_get_element_size (array) * i), sizeof (GIArgument));
1067                     _pygi_argument_release (&item, item_type_info, item_transfer, direction);
1068                 }
1069
1070                 g_base_info_unref ( (GIBaseInfo *) item_type_info);
1071             }
1072
1073             if ( (direction == GI_DIRECTION_IN && transfer == GI_TRANSFER_NOTHING)
1074                     || (direction == GI_DIRECTION_OUT && transfer != GI_TRANSFER_NOTHING)) {
1075                 g_array_free (array, TRUE);
1076             }
1077
1078             break;
1079         }
1080         case GI_TYPE_TAG_INTERFACE:
1081         {
1082             GIBaseInfo *info;
1083             GIInfoType info_type;
1084
1085             info = g_type_info_get_interface (type_info);
1086             info_type = g_base_info_get_type (info);
1087
1088             switch (info_type) {
1089                 case GI_INFO_TYPE_CALLBACK:
1090                     /* TODO */
1091                     break;
1092                 case GI_INFO_TYPE_BOXED:
1093                 case GI_INFO_TYPE_STRUCT:
1094                 case GI_INFO_TYPE_UNION:
1095                 {
1096                     GType type;
1097
1098                     if (arg->v_pointer == NULL) {
1099                         return;
1100                     }
1101
1102                     type = g_registered_type_info_get_g_type ( (GIRegisteredTypeInfo *) info);
1103
1104                     if (g_type_is_a (type, G_TYPE_VALUE)) {
1105                         GValue *value;
1106
1107                         value = arg->v_pointer;
1108
1109                         if ( (direction == GI_DIRECTION_IN && transfer != GI_TRANSFER_EVERYTHING)
1110                                 || (direction == GI_DIRECTION_OUT && transfer == GI_TRANSFER_EVERYTHING)) {
1111                             g_value_unset (value);
1112                         }
1113
1114                         if ( (direction == GI_DIRECTION_IN && transfer == GI_TRANSFER_NOTHING)
1115                                 || (direction == GI_DIRECTION_OUT && transfer != GI_TRANSFER_NOTHING)) {
1116                             g_slice_free (GValue, value);
1117                         }
1118                     } else if (g_type_is_a (type, G_TYPE_CLOSURE)) {
1119                         if (direction == GI_DIRECTION_IN && transfer == GI_TRANSFER_NOTHING) {
1120                             g_closure_unref (arg->v_pointer);
1121                         }
1122                     } else if (info_type == GI_INFO_TYPE_STRUCT &&
1123                                g_struct_info_is_foreign ((GIStructInfo*) info)) {
1124                         if (direction == GI_DIRECTION_OUT && transfer == GI_TRANSFER_EVERYTHING) {
1125                             pygi_struct_foreign_release (info, arg->v_pointer);
1126                         }
1127                     } else if (g_type_is_a (type, G_TYPE_BOXED)) {
1128                     } else if (g_type_is_a (type, G_TYPE_POINTER) || type == G_TYPE_NONE) {
1129                         g_warn_if_fail (!g_type_info_is_pointer (type_info) || transfer == GI_TRANSFER_NOTHING);
1130                     }
1131
1132                     break;
1133                 }
1134                 case GI_INFO_TYPE_ENUM:
1135                 case GI_INFO_TYPE_FLAGS:
1136                     break;
1137                 case GI_INFO_TYPE_INTERFACE:
1138                 case GI_INFO_TYPE_OBJECT:
1139                     if (arg->v_pointer == NULL) {
1140                         return;
1141                     }
1142                     if (is_out && transfer == GI_TRANSFER_EVERYTHING) {
1143                         g_object_unref (arg->v_pointer);
1144                     }
1145                     break;
1146                 default:
1147                     g_assert_not_reached();
1148             }
1149
1150             g_base_info_unref (info);
1151             break;
1152         }
1153         case GI_TYPE_TAG_GLIST:
1154         case GI_TYPE_TAG_GSLIST:
1155         {
1156             GSList *list;
1157
1158             if (arg->v_pointer == NULL) {
1159                 return;
1160             }
1161
1162             list = arg->v_pointer;
1163
1164             if ( (direction == GI_DIRECTION_IN && transfer != GI_TRANSFER_EVERYTHING)
1165                     || (direction == GI_DIRECTION_OUT && transfer == GI_TRANSFER_EVERYTHING)) {
1166                 GITypeInfo *item_type_info;
1167                 GITransfer item_transfer;
1168                 GSList *item;
1169
1170                 item_type_info = g_type_info_get_param_type (type_info, 0);
1171                 g_assert (item_type_info != NULL);
1172
1173                 item_transfer = direction == GI_DIRECTION_IN ? GI_TRANSFER_NOTHING : GI_TRANSFER_EVERYTHING;
1174
1175                 /* Free the items */
1176                 for (item = list; item != NULL; item = g_slist_next (item)) {
1177                     _pygi_argument_release ( (GIArgument *) &item->data, item_type_info,
1178                                              item_transfer, direction);
1179                 }
1180
1181                 g_base_info_unref ( (GIBaseInfo *) item_type_info);
1182             }
1183
1184             if ( (direction == GI_DIRECTION_IN && transfer == GI_TRANSFER_NOTHING)
1185                     || (direction == GI_DIRECTION_OUT && transfer != GI_TRANSFER_NOTHING)) {
1186                 if (type_tag == GI_TYPE_TAG_GLIST) {
1187                     g_list_free ( (GList *) list);
1188                 } else {
1189                     /* type_tag == GI_TYPE_TAG_GSLIST */
1190                     g_slist_free (list);
1191                 }
1192             }
1193
1194             break;
1195         }
1196         case GI_TYPE_TAG_GHASH:
1197         {
1198             GHashTable *hash_table;
1199
1200             if (arg->v_pointer == NULL) {
1201                 return;
1202             }
1203
1204             hash_table = arg->v_pointer;
1205
1206             if (direction == GI_DIRECTION_IN && transfer != GI_TRANSFER_EVERYTHING) {
1207                 /* We created the table without a destroy function, so keys and
1208                  * values need to be released. */
1209                 GITypeInfo *key_type_info;
1210                 GITypeInfo *value_type_info;
1211                 GITransfer item_transfer;
1212                 GHashTableIter hash_table_iter;
1213                 gpointer key;
1214                 gpointer value;
1215
1216                 key_type_info = g_type_info_get_param_type (type_info, 0);
1217                 g_assert (key_type_info != NULL);
1218
1219                 value_type_info = g_type_info_get_param_type (type_info, 1);
1220                 g_assert (value_type_info != NULL);
1221
1222                 if (direction == GI_DIRECTION_IN) {
1223                     item_transfer = GI_TRANSFER_NOTHING;
1224                 } else {
1225                     item_transfer = GI_TRANSFER_EVERYTHING;
1226                 }
1227
1228                 g_hash_table_iter_init (&hash_table_iter, hash_table);
1229                 while (g_hash_table_iter_next (&hash_table_iter, &key, &value)) {
1230                     _pygi_argument_release ( (GIArgument *) &key, key_type_info,
1231                                              item_transfer, direction);
1232                     _pygi_argument_release ( (GIArgument *) &value, value_type_info,
1233                                              item_transfer, direction);
1234                 }
1235
1236                 g_base_info_unref ( (GIBaseInfo *) key_type_info);
1237                 g_base_info_unref ( (GIBaseInfo *) value_type_info);
1238             } else if (direction == GI_DIRECTION_OUT && transfer == GI_TRANSFER_CONTAINER) {
1239                 /* Be careful to avoid keys and values being freed if the
1240                  * callee gave a destroy function. */
1241                 g_hash_table_steal_all (hash_table);
1242             }
1243
1244             if ( (direction == GI_DIRECTION_IN && transfer == GI_TRANSFER_NOTHING)
1245                     || (direction == GI_DIRECTION_OUT && transfer != GI_TRANSFER_NOTHING)) {
1246                 g_hash_table_unref (hash_table);
1247             }
1248
1249             break;
1250         }
1251         case GI_TYPE_TAG_ERROR:
1252         {
1253             GError *error;
1254
1255             if (arg->v_pointer == NULL) {
1256                 return;
1257             }
1258
1259             error = * (GError **) arg->v_pointer;
1260
1261             if (error != NULL) {
1262                 g_error_free (error);
1263             }
1264
1265             g_slice_free (GError *, arg->v_pointer);
1266             break;
1267         }
1268         default:
1269             break;
1270     }
1271 }
1272