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, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
  21  * USA
  22  */
  23
  24 #include "pygi-private.h"
  25
  26 #include <string.h>
  27 #include <time.h>
  28
  29 #include <datetime.h>
  30 #include <pygobject.h>
  31 #include <pyglib-python-compat.h>
  32 #include <pyglib.h>
  33
  34 static void
  35 _pygi_g_type_tag_py_bounds (GITypeTag   type_tag,
  36                             PyObject  **lower,
  37                             PyObject  **upper)
  38 {
  39     switch (type_tag) {
  40         case GI_TYPE_TAG_INT8:
  41             *lower = PYGLIB_PyLong_FromLong (-128);
  42             *upper = PYGLIB_PyLong_FromLong (127);
  43             break;
  44         case GI_TYPE_TAG_UINT8:
  45             *upper = PYGLIB_PyLong_FromLong (255);
  46             *lower = PYGLIB_PyLong_FromLong (0);
  47             break;
  48         case GI_TYPE_TAG_INT16:
  49             *lower = PYGLIB_PyLong_FromLong (-32768);
  50             *upper = PYGLIB_PyLong_FromLong (32767);
  51             break;
  52         case GI_TYPE_TAG_UINT16:
  53             *upper = PYGLIB_PyLong_FromLong (65535);
  54             *lower = PYGLIB_PyLong_FromLong (0);
  55             break;
  56         case GI_TYPE_TAG_INT32:
  57             *lower = PYGLIB_PyLong_FromLong (G_MININT32);
  58             *upper = PYGLIB_PyLong_FromLong (G_MAXINT32);
  59             break;
  60         case GI_TYPE_TAG_UINT32:
  61             /* Note: On 32-bit archs, this number doesn't fit in a long. */
  62             *upper = PyLong_FromLongLong (G_MAXUINT32);
  63             *lower = PYGLIB_PyLong_FromLong (0);
  64             break;
  65         case GI_TYPE_TAG_INT64:
  66             /* Note: On 32-bit archs, these numbers don't fit in a long. */
  67             *lower = PyLong_FromLongLong (G_MININT64);
  68             *upper = PyLong_FromLongLong (G_MAXINT64);
  69             break;
  70         case GI_TYPE_TAG_UINT64:
  71             *upper = PyLong_FromUnsignedLongLong (G_MAXUINT64);
  72             *lower = PYGLIB_PyLong_FromLong (0);
  73             break;
  74         case GI_TYPE_TAG_FLOAT:
  75             *upper = PyFloat_FromDouble (G_MAXFLOAT);
  76             *lower = PyFloat_FromDouble (-G_MAXFLOAT);
  77             break;
  78         case GI_TYPE_TAG_DOUBLE:
  79             *upper = PyFloat_FromDouble (G_MAXDOUBLE);
  80             *lower = PyFloat_FromDouble (-G_MAXDOUBLE);
  81             break;
  82         default:
  83             PyErr_SetString (PyExc_TypeError, "Non-numeric type tag");
  84             *lower = *upper = NULL;
  85             return;
  86     }
  87 }
  88
  89 gint
  90 _pygi_g_registered_type_info_check_object (GIRegisteredTypeInfo *info,
  91                                            gboolean              is_instance,
  92                                            PyObject             *object)
  93 {
  94     gint retval;
  95
  96     GType g_type;
  97     PyObject *py_type;
  98     gchar *type_name_expected = NULL;
  99     GIInfoType interface_type;
 100
 101     interface_type = g_base_info_get_type (info);
 102     if ( (interface_type == GI_INFO_TYPE_STRUCT) &&
 103             (g_struct_info_is_foreign ( (GIStructInfo*) info))) {
 104         /* TODO: Could we check is the correct foreign type? */
 105         return 1;
 106     }
 107
 108     g_type = g_registered_type_info_get_g_type (info);
 109     if (g_type != G_TYPE_NONE) {
 110         py_type = _pygi_type_get_from_g_type (g_type);
 111     } else {
 112         py_type = _pygi_type_import_by_gi_info ( (GIBaseInfo *) info);
 113     }
 114
 115     if (py_type == NULL) {
 116         return 0;
 117     }
 118
 119     g_assert (PyType_Check (py_type));
 120
 121     if (is_instance) {
 122         retval = PyObject_IsInstance (object, py_type);
 123         if (!retval) {
 124             type_name_expected = _pygi_g_base_info_get_fullname (
 125                                      (GIBaseInfo *) info);
 126         }
 127     } else {
 128         if (!PyObject_Type (py_type)) {
 129             type_name_expected = "type";
 130             retval = 0;
 131         } else if (!PyType_IsSubtype ( (PyTypeObject *) object,
 132                                        (PyTypeObject *) py_type)) {
 133             type_name_expected = _pygi_g_base_info_get_fullname (
 134                                      (GIBaseInfo *) info);
 135             retval = 0;
 136         } else {
 137             retval = 1;
 138         }
 139     }
 140
 141     Py_DECREF (py_type);
 142
 143     if (!retval) {
 144         PyTypeObject *object_type;
 145
 146         if (type_name_expected == NULL) {
 147             return -1;
 148         }
 149
 150         object_type = (PyTypeObject *) PyObject_Type (object);
 151         if (object_type == NULL) {
 152             return -1;
 153         }
 154
 155         PyErr_Format (PyExc_TypeError, "Must be %s, not %s",
 156                       type_name_expected, object_type->tp_name);
 157
 158         g_free (type_name_expected);
 159     }
 160
 161     return retval;
 162 }
 163
 164 gint
 165 _pygi_g_type_interface_check_object (GIBaseInfo *info,
 166                                      PyObject   *object)
 167 {
 168     gint retval = 1;
 169     GIInfoType info_type;
 170
 171     info_type = g_base_info_get_type (info);
 172     switch (info_type) {
 173         case GI_INFO_TYPE_CALLBACK:
 174             if (!PyCallable_Check (object)) {
 175                 PyErr_Format (PyExc_TypeError, "Must be callable, not %s",
 176                               object->ob_type->tp_name);
 177                 retval = 0;
 178             }
 179             break;
 180         case GI_INFO_TYPE_ENUM:
 181             retval = 0;
 182             if (PyNumber_Check (object)) {
 183                 PyObject *number = PYGLIB_PyNumber_Long (object);
 184                 if (number == NULL)
 185                     PyErr_Clear();
 186                 else {
 187                     glong value = PYGLIB_PyLong_AsLong (number);
 188                     int i;
 189                     for (i = 0; i < g_enum_info_get_n_values (info); i++) {
 190                         GIValueInfo *value_info = g_enum_info_get_value (info, i);
 191                         glong enum_value = g_value_info_get_value (value_info);
 192                         g_base_info_unref (value_info);
 193                         if (value == enum_value) {
 194                             retval = 1;
 195                             break;
 196                         }
 197                     }
 198                 }
 199             }
 200             if (retval < 1)
 201                 retval = _pygi_g_registered_type_info_check_object (
 202                              (GIRegisteredTypeInfo *) info, TRUE, object);
 203             break;
 204         case GI_INFO_TYPE_FLAGS:
 205             if (PyNumber_Check (object)) {
 206                 /* Accept 0 as a valid flag value */
 207                 PyObject *number = PYGLIB_PyNumber_Long (object);
 208                 if (number == NULL)
 209                     PyErr_Clear();
 210                 else {
 211                     long value = PYGLIB_PyLong_AsLong (number);
 212                     if (value == 0)
 213                         break;
 214                     else if (value == -1)
 215                         PyErr_Clear();
 216                 }
 217             }
 218             retval = _pygi_g_registered_type_info_check_object (
 219                          (GIRegisteredTypeInfo *) info, TRUE, object);
 220             break;
 221         case GI_INFO_TYPE_STRUCT:
 222         {
 223             GType type;
 224
 225             /* Handle special cases. */
 226             type = g_registered_type_info_get_g_type ( (GIRegisteredTypeInfo *) info);
 227             if (g_type_is_a (type, G_TYPE_CLOSURE)) {
 228                 if (!(PyCallable_Check (object) ||
 229                       pyg_type_from_object_strict (object, FALSE) == G_TYPE_CLOSURE)) {
 230                     PyErr_Format (PyExc_TypeError, "Must be callable, not %s",
 231                                   object->ob_type->tp_name);
 232                     retval = 0;
 233                 }
 234                 break;
 235             } else if (g_type_is_a (type, G_TYPE_VALUE)) {
 236                 /* we can't check g_values because we don't have
 237                  * enough context so just pass them through */
 238                 break;
 239             }
 240
 241             /* Fallback. */
 242         }
 243         case GI_INFO_TYPE_BOXED:
 244         case GI_INFO_TYPE_INTERFACE:
 245         case GI_INFO_TYPE_OBJECT:
 246             retval = _pygi_g_registered_type_info_check_object ( (GIRegisteredTypeInfo *) info, TRUE, object);
 247             break;
 248         case GI_INFO_TYPE_UNION:
 249
 250
 251             retval = _pygi_g_registered_type_info_check_object ( (GIRegisteredTypeInfo *) info, TRUE, object);
 252
 253             /* If not the same type then check to see if the object's type
 254              * is the same as one of the union's members
 255              */
 256             if (retval == 0) {
 257                 gint i;
 258                 gint n_fields;
 259
 260                 n_fields = g_union_info_get_n_fields ( (GIUnionInfo *) info);
 261
 262                 for (i = 0; i < n_fields; i++) {
 263                     gint member_retval;
 264                     GIFieldInfo *field_info;
 265                     GITypeInfo *field_type_info;
 266
 267                     field_info =
 268                         g_union_info_get_field ( (GIUnionInfo *) info, i);
 269                     field_type_info = g_field_info_get_type (field_info);
 270
 271                     member_retval = _pygi_g_type_info_check_object(
 272                         field_type_info,
 273                         object,
 274                         TRUE);
 275
 276                     g_base_info_unref ( ( GIBaseInfo *) field_type_info);
 277                     g_base_info_unref ( ( GIBaseInfo *) field_info);
 278
 279                     if (member_retval == 1) {
 280                         retval = member_retval;
 281                         break;
 282                     }
 283                 }
 284             }
 285
 286             break;
 287         default:
 288             g_assert_not_reached();
 289     }
 290
 291     return retval;
 292 }
 293
 294 gint
 295 _pygi_g_type_info_check_object (GITypeInfo *type_info,
 296                                 PyObject   *object,
 297                                 gboolean   allow_none)
 298 {
 299     GITypeTag type_tag;
 300     gint retval = 1;
 301
 302     if (allow_none && object == Py_None) {
 303         return retval;
 304     }
 305
 306     type_tag = g_type_info_get_tag (type_info);
 307
 308     switch (type_tag) {
 309         case GI_TYPE_TAG_VOID:
 310             /* No check; VOID means undefined type */
 311             break;
 312         case GI_TYPE_TAG_BOOLEAN:
 313             /* No check; every Python object has a truth value. */
 314             break;
 315         case GI_TYPE_TAG_UINT8:
 316             /* UINT8 types can be characters */
 317             if (PYGLIB_PyBytes_Check(object)) {
 318                 if (PYGLIB_PyBytes_Size(object) != 1) {
 319                     PyErr_Format (PyExc_TypeError, "Must be a single character");
 320                     retval = 0;
 321                     break;
 322                 }
 323
 324                 break;
 325             }
 326         case GI_TYPE_TAG_INT8:
 327         case GI_TYPE_TAG_INT16:
 328         case GI_TYPE_TAG_UINT16:
 329         case GI_TYPE_TAG_INT32:
 330         case GI_TYPE_TAG_UINT32:
 331         case GI_TYPE_TAG_INT64:
 332         case GI_TYPE_TAG_UINT64:
 333         case GI_TYPE_TAG_FLOAT:
 334         case GI_TYPE_TAG_DOUBLE:
 335         {
 336             PyObject *number, *lower, *upper;
 337
 338             if (!PyNumber_Check (object)) {
 339                 PyErr_Format (PyExc_TypeError, "Must be number, not %s",
 340                               object->ob_type->tp_name);
 341                 retval = 0;
 342                 break;
 343             }
 344
 345             if (type_tag == GI_TYPE_TAG_FLOAT || type_tag == GI_TYPE_TAG_DOUBLE) {
 346                 number = PyNumber_Float (object);
 347             } else {
 348                 number = PYGLIB_PyNumber_Long (object);
 349             }
 350
 351             _pygi_g_type_tag_py_bounds (type_tag, &lower, &upper);
 352
 353             if (lower == NULL || upper == NULL || number == NULL) {
 354                 retval = -1;
 355                 goto check_number_release;
 356             }
 357
 358             /* Check bounds */
 359             if (PyObject_RichCompareBool (lower, number, Py_GT)
 360                     || PyObject_RichCompareBool (upper, number, Py_LT)) {
 361                 PyObject *lower_str;
 362                 PyObject *upper_str;
 363
 364                 if (PyErr_Occurred()) {
 365                     retval = -1;
 366                     goto check_number_release;
 367                 }
 368
 369                 lower_str = PyObject_Str (lower);
 370                 upper_str = PyObject_Str (upper);
 371                 if (lower_str == NULL || upper_str == NULL) {
 372                     retval = -1;
 373                     goto check_number_error_release;
 374                 }
 375
 376 #if PY_VERSION_HEX < 0x03000000
 377                 PyErr_Format (PyExc_ValueError, "Must range from %s to %s",
 378                               PyString_AS_STRING (lower_str),
 379                               PyString_AS_STRING (upper_str));
 380 #else
 381                 {
 382                     PyObject *lower_pybytes_obj = PyUnicode_AsUTF8String (lower_str);
 383                     if (!lower_pybytes_obj)
 384                         goto utf8_fail;
 385
 386                     PyObject *upper_pybytes_obj = PyUnicode_AsUTF8String (upper_str);
 387                     if (!upper_pybytes_obj) {
 388                         Py_DECREF(lower_pybytes_obj);
 389                         goto utf8_fail;
 390                     }
 391
 392                     PyErr_Format (PyExc_ValueError, "Must range from %s to %s",
 393                                   PyBytes_AsString (lower_pybytes_obj),
 394                                   PyBytes_AsString (upper_pybytes_obj));
 395                     Py_DECREF (lower_pybytes_obj);
 396                     Py_DECREF (upper_pybytes_obj);
 397                 }
 398 utf8_fail:
 399 #endif
 400                 retval = 0;
 401
 402 check_number_error_release:
 403                 Py_XDECREF (lower_str);
 404                 Py_XDECREF (upper_str);
 405             }
 406
 407 check_number_release:
 408             Py_XDECREF (number);
 409             Py_XDECREF (lower);
 410             Py_XDECREF (upper);
 411             break;
 412         }
 413         case GI_TYPE_TAG_GTYPE:
 414         {
 415             if (pyg_type_from_object (object) == 0) {
 416                 PyErr_Format (PyExc_TypeError, "Must be gobject.GType, not %s",
 417                               object->ob_type->tp_name);
 418                 retval = 0;
 419             }
 420             break;
 421         }
 422         case GI_TYPE_TAG_UNICHAR:
 423         {
 424             Py_ssize_t size;
 425             if (PyUnicode_Check (object)) {
 426                 size = PyUnicode_GET_SIZE (object);
 427 #if PY_VERSION_HEX < 0x03000000
 428             } else if (PyString_Check (object)) {
 429                 PyObject *pyuni = PyUnicode_FromEncodedObject (object, "UTF-8", "strict");
 430                 size = PyUnicode_GET_SIZE (pyuni);
 431                 Py_DECREF(pyuni);
 432 #endif
 433             } else {
 434                 PyErr_Format (PyExc_TypeError, "Must be string, not %s",
 435                               object->ob_type->tp_name);
 436                 retval = 0;
 437                 break;
 438             }
 439
 440             if (size != 1) {
 441                 PyErr_Format (PyExc_TypeError, "Must be a one character string, not %ld characters",
 442                               size);
 443                 retval = 0;
 444                 break;
 445             }
 446
 447             break;
 448         }
 449         case GI_TYPE_TAG_UTF8:
 450         case GI_TYPE_TAG_FILENAME:
 451             if (!PYGLIB_PyBaseString_Check (object) ) {
 452                 PyErr_Format (PyExc_TypeError, "Must be string, not %s",
 453                               object->ob_type->tp_name);
 454                 retval = 0;
 455             }
 456             break;
 457         case GI_TYPE_TAG_ARRAY:
 458         {
 459             gssize fixed_size;
 460             Py_ssize_t length;
 461             GITypeInfo *item_type_info;
 462             Py_ssize_t i;
 463
 464             if (!PySequence_Check (object)) {
 465                 PyErr_Format (PyExc_TypeError, "Must be sequence, not %s",
 466                               object->ob_type->tp_name);
 467                 retval = 0;
 468                 break;
 469             }
 470
 471             length = PySequence_Length (object);
 472             if (length < 0) {
 473                 retval = -1;
 474                 break;
 475             }
 476
 477             fixed_size = g_type_info_get_array_fixed_size (type_info);
 478             if (fixed_size >= 0 && length != fixed_size) {
 479                 PyErr_Format (PyExc_ValueError, "Must contain %zd items, not %zd",
 480                               fixed_size, length);
 481                 retval = 0;
 482                 break;
 483             }
 484
 485             item_type_info = g_type_info_get_param_type (type_info, 0);
 486             g_assert (item_type_info != NULL);
 487
 488             /* FIXME: This is insain.  We really should only check the first
 489              *        object and perhaps have a debugging mode.  Large arrays
 490              *        will cause apps to slow to a crawl.
 491              */
 492             for (i = 0; i < length; i++) {
 493                 PyObject *item;
 494
 495                 item = PySequence_GetItem (object, i);
 496                 if (item == NULL) {
 497                     retval = -1;
 498                     break;
 499                 }
 500
 501                 retval = _pygi_g_type_info_check_object (item_type_info, item, TRUE);
 502
 503                 Py_DECREF (item);
 504
 505                 if (retval < 0) {
 506                     break;
 507                 }
 508                 if (!retval) {
 509                     _PyGI_ERROR_PREFIX ("Item %zd: ", i);
 510                     break;
 511                 }
 512             }
 513
 514             g_base_info_unref ( (GIBaseInfo *) item_type_info);
 515
 516             break;
 517         }
 518         case GI_TYPE_TAG_INTERFACE:
 519         {
 520             GIBaseInfo *info;
 521
 522             info = g_type_info_get_interface (type_info);
 523             g_assert (info != NULL);
 524
 525             retval = _pygi_g_type_interface_check_object(info, object);
 526
 527             g_base_info_unref (info);
 528             break;
 529         }
 530         case GI_TYPE_TAG_GLIST:
 531         case GI_TYPE_TAG_GSLIST:
 532         {
 533             Py_ssize_t length;
 534             GITypeInfo *item_type_info;
 535             Py_ssize_t i;
 536
 537             if (!PySequence_Check (object)) {
 538                 PyErr_Format (PyExc_TypeError, "Must be sequence, not %s",
 539                               object->ob_type->tp_name);
 540                 retval = 0;
 541                 break;
 542             }
 543
 544             length = PySequence_Length (object);
 545             if (length < 0) {
 546                 retval = -1;
 547                 break;
 548             }
 549
 550             item_type_info = g_type_info_get_param_type (type_info, 0);
 551             g_assert (item_type_info != NULL);
 552
 553             for (i = 0; i < length; i++) {
 554                 PyObject *item;
 555
 556                 item = PySequence_GetItem (object, i);
 557                 if (item == NULL) {
 558                     retval = -1;
 559                     break;
 560                 }
 561
 562                 retval = _pygi_g_type_info_check_object (item_type_info, item, TRUE);
 563
 564                 Py_DECREF (item);
 565
 566                 if (retval < 0) {
 567                     break;
 568                 }
 569                 if (!retval) {
 570                     _PyGI_ERROR_PREFIX ("Item %zd: ", i);
 571                     break;
 572                 }
 573             }
 574
 575             g_base_info_unref ( (GIBaseInfo *) item_type_info);
 576             break;
 577         }
 578         case GI_TYPE_TAG_GHASH:
 579         {
 580             Py_ssize_t length;
 581             PyObject *keys;
 582             PyObject *values;
 583             GITypeInfo *key_type_info;
 584             GITypeInfo *value_type_info;
 585             Py_ssize_t i;
 586
 587             keys = PyMapping_Keys (object);
 588             if (keys == NULL) {
 589                 PyErr_Format (PyExc_TypeError, "Must be mapping, not %s",
 590                               object->ob_type->tp_name);
 591                 retval = 0;
 592                 break;
 593             }
 594
 595             length = PyMapping_Length (object);
 596             if (length < 0) {
 597                 Py_DECREF (keys);
 598                 retval = -1;
 599                 break;
 600             }
 601
 602             values = PyMapping_Values (object);
 603             if (values == NULL) {
 604                 retval = -1;
 605                 Py_DECREF (keys);
 606                 break;
 607             }
 608
 609             key_type_info = g_type_info_get_param_type (type_info, 0);
 610             g_assert (key_type_info != NULL);
 611
 612             value_type_info = g_type_info_get_param_type (type_info, 1);
 613             g_assert (value_type_info != NULL);
 614
 615             for (i = 0; i < length; i++) {
 616                 PyObject *key;
 617                 PyObject *value;
 618
 619                 key = PyList_GET_ITEM (keys, i);
 620                 value = PyList_GET_ITEM (values, i);
 621
 622                 retval = _pygi_g_type_info_check_object (key_type_info, key, TRUE);
 623                 if (retval < 0) {
 624                     break;
 625                 }
 626                 if (!retval) {
 627                     _PyGI_ERROR_PREFIX ("Key %zd :", i);
 628                     break;
 629                 }
 630
 631                 retval = _pygi_g_type_info_check_object (value_type_info, value, TRUE);
 632                 if (retval < 0) {
 633                     break;
 634                 }
 635                 if (!retval) {
 636                     _PyGI_ERROR_PREFIX ("Value %zd :", i);
 637                     break;
 638                 }
 639             }
 640
 641             g_base_info_unref ( (GIBaseInfo *) key_type_info);
 642             g_base_info_unref ( (GIBaseInfo *) value_type_info);
 643             Py_DECREF (values);
 644             Py_DECREF (keys);
 645             break;
 646         }
 647         case GI_TYPE_TAG_ERROR:
 648             PyErr_SetString (PyExc_NotImplementedError, "Error marshalling is not supported yet");
 649             /* TODO */
 650             break;
 651     }
 652
 653     return retval;
 654 }
 655
 656 GArray *
 657 _pygi_argument_to_array (GIArgument  *arg,
 658                          GIArgument  *args[],
 659                          GITypeInfo *type_info,
 660                          gboolean is_method)
 661 {
 662     GITypeInfo *item_type_info;
 663     gboolean is_zero_terminated;
 664     gsize item_size;
 665     gssize length;
 666     GArray *g_array;
 667
 668     if (arg->v_pointer == NULL) {
 669         return NULL;
 670     }
 671
 672     is_zero_terminated = g_type_info_is_zero_terminated (type_info);
 673     item_type_info = g_type_info_get_param_type (type_info, 0);
 674
 675     item_size = _pygi_g_type_info_size (item_type_info);
 676
 677     g_base_info_unref ( (GIBaseInfo *) item_type_info);
 678
 679     if (is_zero_terminated) {
 680         length = g_strv_length (arg->v_pointer);
 681     } else {
 682         length = g_type_info_get_array_fixed_size (type_info);
 683         if (length < 0) {
 684             gint length_arg_pos;
 685
 686             length_arg_pos = g_type_info_get_array_length (type_info);
 687             g_assert (length_arg_pos >= 0);
 688
 689             /* FIXME: Take into account the type of the argument. */
 690             length = args[length_arg_pos]->v_int;
 691         }
 692     }
 693
 694     g_assert (length >= 0);
 695
 696     g_array = g_array_new (is_zero_terminated, FALSE, item_size);
 697
 698     g_array->data = arg->v_pointer;
 699     g_array->len = length;
 700
 701     return g_array;
 702 }
 703
 704 GIArgument
 705 _pygi_argument_from_object (PyObject   *object,
 706                             GITypeInfo *type_info,
 707                             GITransfer  transfer)
 708 {
 709     GIArgument arg;
 710     GITypeTag type_tag;
 711
 712     memset(&arg, 0, sizeof(GIArgument));
 713     type_tag = g_type_info_get_tag (type_info);
 714
 715     switch (type_tag) {
 716         case GI_TYPE_TAG_VOID:
 717             g_warn_if_fail (transfer == GI_TRANSFER_NOTHING);
 718             arg.v_pointer = object;
 719             break;
 720         case GI_TYPE_TAG_BOOLEAN:
 721         {
 722             arg.v_boolean = PyObject_IsTrue (object);
 723             break;
 724         }
 725         case GI_TYPE_TAG_UINT8:
 726             if (PYGLIB_PyBytes_Check(object)) {
 727                 arg.v_long = (long)(PYGLIB_PyBytes_AsString(object)[0]);
 728                 break;
 729             }
 730
 731         case GI_TYPE_TAG_INT8:
 732         case GI_TYPE_TAG_INT16:
 733         case GI_TYPE_TAG_UINT16:
 734         case GI_TYPE_TAG_INT32:
 735         {
 736             PyObject *int_;
 737
 738             int_ = PYGLIB_PyNumber_Long (object);
 739             if (int_ == NULL) {
 740                 break;
 741             }
 742
 743             arg.v_long = PYGLIB_PyLong_AsLong (int_);
 744
 745             Py_DECREF (int_);
 746
 747             break;
 748         }
 749         case GI_TYPE_TAG_UINT32:
 750         case GI_TYPE_TAG_UINT64:
 751         {
 752             PyObject *number;
 753             guint64 value;
 754
 755             number = PYGLIB_PyNumber_Long (object);
 756             if (number == NULL) {
 757                 break;
 758             }
 759
 760 #if PY_VERSION_HEX < 0x03000000
 761             if (PyInt_Check (number)) {
 762                 value = PyInt_AS_LONG (number);
 763             } else
 764 #endif
 765             value = PyLong_AsUnsignedLongLong (number);
 766
 767             arg.v_uint64 = value;
 768
 769             Py_DECREF (number);
 770
 771             break;
 772         }
 773         case GI_TYPE_TAG_INT64:
 774         {
 775             PyObject *number;
 776             gint64 value;
 777
 778             number = PYGLIB_PyNumber_Long (object);
 779             if (number == NULL) {
 780                 break;
 781             }
 782
 783 #if PY_VERSION_HEX < 0x03000000
 784             if (PyInt_Check (number)) {
 785                 value = PyInt_AS_LONG (number);
 786             } else
 787 #endif
 788             value = PyLong_AsLongLong (number);
 789
 790             arg.v_int64 = value;
 791
 792             Py_DECREF (number);
 793
 794             break;
 795         }
 796         case GI_TYPE_TAG_FLOAT:
 797         {
 798             PyObject *float_;
 799
 800             float_ = PyNumber_Float (object);
 801             if (float_ == NULL) {
 802                 break;
 803             }
 804
 805             arg.v_float = (float) PyFloat_AsDouble (float_);
 806             Py_DECREF (float_);
 807
 808             break;
 809         }
 810         case GI_TYPE_TAG_DOUBLE:
 811         {
 812             PyObject *float_;
 813
 814             float_ = PyNumber_Float (object);
 815             if (float_ == NULL) {
 816                 break;
 817             }
 818
 819             arg.v_double = PyFloat_AsDouble (float_);
 820             Py_DECREF (float_);
 821
 822             break;
 823         }
 824         case GI_TYPE_TAG_GTYPE:
 825         {
 826             arg.v_long = pyg_type_from_object (object);
 827
 828             break;
 829         }
 830         case GI_TYPE_TAG_UNICHAR:
 831         {
 832             gchar *string;
 833
 834             if (object == Py_None) {
 835                 arg.v_uint32 = 0;
 836                 break;
 837             }
 838
 839 #if PY_VERSION_HEX < 0x03000000
 840             if (PyUnicode_Check(object)) {
 841                  PyObject *pystr_obj = PyUnicode_AsUTF8String (object);
 842
 843                  if (!pystr_obj)
 844                      break;
 845
 846                  string = g_strdup(PyString_AsString (pystr_obj));
 847                  Py_DECREF(pystr_obj);
 848             } else {
 849                  string = g_strdup(PyString_AsString (object));
 850             }
 851 #else
 852             {
 853                 PyObject *pybytes_obj = PyUnicode_AsUTF8String (object);
 854                 if (!pybytes_obj)
 855                     break;
 856
 857                 string = g_strdup(PyBytes_AsString (pybytes_obj));
 858                 Py_DECREF (pybytes_obj);
 859             }
 860 #endif
 861
 862             arg.v_uint32 = g_utf8_get_char (string);
 863
 864             break;
 865         }
 866         case GI_TYPE_TAG_UTF8:
 867         {
 868             gchar *string;
 869
 870             if (object == Py_None) {
 871                 arg.v_string = NULL;
 872                 break;
 873             }
 874 #if PY_VERSION_HEX < 0x03000000
 875             if (PyUnicode_Check(object)) {
 876                  PyObject *pystr_obj = PyUnicode_AsUTF8String (object);
 877
 878                  if (!pystr_obj)
 879                      break;
 880
 881                  string = g_strdup(PyString_AsString (pystr_obj));
 882                  Py_DECREF(pystr_obj);
 883             } else {
 884                  string = g_strdup(PyString_AsString (object));
 885             }
 886 #else
 887             {
 888                 PyObject *pybytes_obj = PyUnicode_AsUTF8String (object);
 889                 if (!pybytes_obj)
 890                     break;
 891
 892                 string = g_strdup(PyBytes_AsString (pybytes_obj));
 893                 Py_DECREF (pybytes_obj);
 894             }
 895 #endif
 896             arg.v_string = string;
 897
 898             break;
 899         }
 900         case GI_TYPE_TAG_FILENAME:
 901         {
 902             GError *error = NULL;
 903             gchar *string;
 904
 905 #if PY_VERSION_HEX < 0x03000000
 906             string = g_strdup(PyString_AsString (object));
 907 #else
 908             {
 909                 PyObject *pybytes_obj = PyUnicode_AsUTF8String (object);
 910                 if (!pybytes_obj)
 911                     break;
 912
 913                 string = g_strdup(PyBytes_AsString (pybytes_obj));
 914                 Py_DECREF (pybytes_obj);
 915             }
 916 #endif
 917
 918             if (string == NULL) {
 919                 break;
 920             }
 921
 922             arg.v_string = g_filename_from_utf8 (string, -1, NULL, NULL, &error);
 923             g_free(string);
 924
 925             if (arg.v_string == NULL) {
 926                 PyErr_SetString (PyExc_Exception, error->message);
 927                 /* TODO: Convert the error to an exception. */
 928             }
 929
 930             break;
 931         }
 932         case GI_TYPE_TAG_ARRAY:
 933         {
 934             Py_ssize_t length;
 935             gboolean is_zero_terminated;
 936             GITypeInfo *item_type_info;
 937             gsize item_size;
 938             GArray *array;
 939             GITransfer item_transfer;
 940             Py_ssize_t i;
 941
 942             if (object == Py_None) {
 943                 arg.v_pointer = NULL;
 944                 break;
 945             }
 946
 947             length = PySequence_Length (object);
 948             if (length < 0) {
 949                 break;
 950             }
 951
 952             is_zero_terminated = g_type_info_is_zero_terminated (type_info);
 953             item_type_info = g_type_info_get_param_type (type_info, 0);
 954
 955             item_size = _pygi_g_type_info_size (item_type_info);
 956
 957             array = g_array_sized_new (is_zero_terminated, FALSE, item_size, length);
 958             if (array == NULL) {
 959                 g_base_info_unref ( (GIBaseInfo *) item_type_info);
 960                 PyErr_NoMemory();
 961                 break;
 962             }
 963
 964             if (g_type_info_get_tag (item_type_info) == GI_TYPE_TAG_UINT8 &&
 965                 PYGLIB_PyBytes_Check(object)) {
 966
 967                 memcpy(array->data, PYGLIB_PyBytes_AsString(object), length);
 968                 array->len = length;
 969                 goto array_success;
 970             }
 971
 972
 973             item_transfer = transfer == GI_TRANSFER_CONTAINER ? GI_TRANSFER_NOTHING : transfer;
 974
 975             for (i = 0; i < length; i++) {
 976                 PyObject *py_item;
 977                 GIArgument item;
 978
 979                 py_item = PySequence_GetItem (object, i);
 980                 if (py_item == NULL) {
 981                     goto array_item_error;
 982                 }
 983
 984                 item = _pygi_argument_from_object (py_item, item_type_info, item_transfer);
 985
 986                 Py_DECREF (py_item);
 987
 988                 if (PyErr_Occurred()) {
 989                     goto array_item_error;
 990                 }
 991
 992                 g_array_insert_val (array, i, item);
 993                 continue;
 994
 995 array_item_error:
 996                 /* Free everything we have converted so far. */
 997                 _pygi_argument_release ( (GIArgument *) &array, type_info,
 998                                          GI_TRANSFER_NOTHING, GI_DIRECTION_IN);
 999                 array = NULL;
1000
1001                 _PyGI_ERROR_PREFIX ("Item %zd: ", i);
1002                 break;
1003             }
1004
1005 array_success:
1006             arg.v_pointer = array;
1007
1008             g_base_info_unref ( (GIBaseInfo *) item_type_info);
1009             break;
1010         }
1011         case GI_TYPE_TAG_INTERFACE:
1012         {
1013             GIBaseInfo *info;
1014             GIInfoType info_type;
1015
1016             info = g_type_info_get_interface (type_info);
1017             info_type = g_base_info_get_type (info);
1018
1019             switch (info_type) {
1020                 case GI_INFO_TYPE_CALLBACK:
1021                     /* This should be handled in invoke() */
1022                     g_assert_not_reached();
1023                     break;
1024                 case GI_INFO_TYPE_BOXED:
1025                 case GI_INFO_TYPE_STRUCT:
1026                 case GI_INFO_TYPE_UNION:
1027                 {
1028                     GType type;
1029
1030                     if (object == Py_None) {
1031                         arg.v_pointer = NULL;
1032                         break;
1033                     }
1034
1035                     type = g_registered_type_info_get_g_type ( (GIRegisteredTypeInfo *) info);
1036
1037                     /* Handle special cases first. */
1038                     if (g_type_is_a (type, G_TYPE_VALUE)) {
1039                         GValue *value;
1040                         GType object_type;
1041                         gint retval;
1042
1043                         object_type = pyg_type_from_object_strict ( (PyObject *) object->ob_type, FALSE);
1044                         if (object_type == G_TYPE_INVALID) {
1045                             PyErr_SetString (PyExc_RuntimeError, "unable to retrieve object's GType");
1046                             break;
1047                         }
1048
1049                         g_warn_if_fail (transfer == GI_TRANSFER_NOTHING);
1050
1051                         value = g_slice_new0 (GValue);
1052
1053                         /* if already a gvalue, copy, else marshal into gvalue */
1054                         if (object_type == G_TYPE_VALUE) {
1055                             /* src GValue's lifecycle is handled by Python
1056                              * so we have to copy it into the destination's
1057                              * GValue which is freed during the cleanup of
1058                              * invoke.
1059                              */
1060                             GValue *src = (GValue *)((PyGObject *) object)->obj;
1061                             g_value_init (value, G_VALUE_TYPE (src));
1062                             g_value_copy(src, value);
1063                         } else {
1064                             g_value_init (value, object_type);
1065                             retval = pyg_value_from_pyobject (value, object);
1066                             if (retval < 0) {
1067                                 g_slice_free (GValue, value);
1068                                 PyErr_SetString (PyExc_RuntimeError, "PyObject conversion to GValue failed");
1069                                 break;
1070                             }
1071                         }
1072
1073                         arg.v_pointer = value;
1074                     } else if (g_type_is_a (type, G_TYPE_CLOSURE)) {
1075                         GClosure *closure;
1076
1077                         if (pyg_type_from_object_strict (object, FALSE) == G_TYPE_CLOSURE) {
1078                             closure = (GClosure *)pyg_boxed_get (object, void);
1079                         } else {
1080                             closure = pyg_closure_new (object, NULL, NULL);
1081                             if (closure == NULL) {
1082                                 PyErr_SetString (PyExc_RuntimeError, "PyObject conversion to GClosure failed");
1083                                 break;
1084                             }
1085                         }
1086
1087                         arg.v_pointer = closure;
1088                     } else if (g_struct_info_is_foreign (info)) {
1089                         PyObject *result;
1090                         result = pygi_struct_foreign_convert_to_g_argument (
1091                                      object, info, transfer, &arg);
1092                     } else if (g_type_is_a (type, G_TYPE_BOXED)) {
1093                         arg.v_pointer = pyg_boxed_get (object, void);
1094                         if (transfer == GI_TRANSFER_EVERYTHING) {
1095                             arg.v_pointer = g_boxed_copy (type, arg.v_pointer);
1096                         }
1097                     } else if (g_type_is_a (type, G_TYPE_POINTER) ||
1098                                g_type_is_a (type, G_TYPE_VARIANT) ||
1099                                type == G_TYPE_NONE) {
1100                         g_warn_if_fail (g_type_is_a (type, G_TYPE_VARIANT) || !g_type_info_is_pointer (type_info) || transfer == GI_TRANSFER_NOTHING);
1101                         arg.v_pointer = pyg_pointer_get (object, void);
1102                     } else {
1103                         PyErr_Format (PyExc_NotImplementedError, "structure type '%s' is not supported yet", g_type_name (type));
1104                     }
1105
1106                     break;
1107                 }
1108                 case GI_INFO_TYPE_ENUM:
1109                 case GI_INFO_TYPE_FLAGS:
1110                 {
1111                     PyObject *int_;
1112
1113                     int_ = PYGLIB_PyNumber_Long (object);
1114                     if (int_ == NULL) {
1115                         break;
1116                     }
1117
1118                     arg.v_long = PYGLIB_PyLong_AsLong (int_);
1119
1120                     Py_DECREF (int_);
1121
1122                     break;
1123                 }
1124                 case GI_INFO_TYPE_INTERFACE:
1125                 case GI_INFO_TYPE_OBJECT:
1126                     if (object == Py_None) {
1127                         arg.v_pointer = NULL;
1128                         break;
1129                     }
1130
1131                     arg.v_pointer = pygobject_get (object);
1132                     if (transfer == GI_TRANSFER_EVERYTHING) {
1133                         g_object_ref (arg.v_pointer);
1134                     }
1135
1136                     break;
1137                 default:
1138                     g_assert_not_reached();
1139             }
1140             g_base_info_unref (info);
1141             break;
1142         }
1143         case GI_TYPE_TAG_GLIST:
1144         case GI_TYPE_TAG_GSLIST:
1145         {
1146             Py_ssize_t length;
1147             GITypeInfo *item_type_info;
1148             GSList *list = NULL;
1149             GITransfer item_transfer;
1150             Py_ssize_t i;
1151
1152             if (object == Py_None) {
1153                 arg.v_pointer = NULL;
1154                 break;
1155             }
1156
1157             length = PySequence_Length (object);
1158             if (length < 0) {
1159                 break;
1160             }
1161
1162             item_type_info = g_type_info_get_param_type (type_info, 0);
1163             g_assert (item_type_info != NULL);
1164
1165             item_transfer = transfer == GI_TRANSFER_CONTAINER ? GI_TRANSFER_NOTHING : transfer;
1166
1167             for (i = length - 1; i >= 0; i--) {
1168                 PyObject *py_item;
1169                 GIArgument item;
1170
1171                 py_item = PySequence_GetItem (object, i);
1172                 if (py_item == NULL) {
1173                     goto list_item_error;
1174                 }
1175
1176                 item = _pygi_argument_from_object (py_item, item_type_info, item_transfer);
1177
1178                 Py_DECREF (py_item);
1179
1180                 if (PyErr_Occurred()) {
1181                     goto list_item_error;
1182                 }
1183
1184                 if (type_tag == GI_TYPE_TAG_GLIST) {
1185                     list = (GSList *) g_list_prepend ( (GList *) list, item.v_pointer);
1186                 } else {
1187                     list = g_slist_prepend (list, item.v_pointer);
1188                 }
1189
1190                 continue;
1191
1192 list_item_error:
1193                 /* Free everything we have converted so far. */
1194                 _pygi_argument_release ( (GIArgument *) &list, type_info,
1195                                          GI_TRANSFER_NOTHING, GI_DIRECTION_IN);
1196                 list = NULL;
1197
1198                 _PyGI_ERROR_PREFIX ("Item %zd: ", i);
1199                 break;
1200             }
1201
1202             arg.v_pointer = list;
1203
1204             g_base_info_unref ( (GIBaseInfo *) item_type_info);
1205
1206             break;
1207         }
1208         case GI_TYPE_TAG_GHASH:
1209         {
1210             Py_ssize_t length;
1211             PyObject *keys;
1212             PyObject *values;
1213             GITypeInfo *key_type_info;
1214             GITypeInfo *value_type_info;
1215             GITypeTag key_type_tag;
1216             GHashFunc hash_func;
1217             GEqualFunc equal_func;
1218             GHashTable *hash_table;
1219             GITransfer item_transfer;
1220             Py_ssize_t i;
1221
1222
1223             if (object == Py_None) {
1224                 arg.v_pointer = NULL;
1225                 break;
1226             }
1227
1228             length = PyMapping_Length (object);
1229             if (length < 0) {
1230                 break;
1231             }
1232
1233             keys = PyMapping_Keys (object);
1234             if (keys == NULL) {
1235                 break;
1236             }
1237
1238             values = PyMapping_Values (object);
1239             if (values == NULL) {
1240                 Py_DECREF (keys);
1241                 break;
1242             }
1243
1244             key_type_info = g_type_info_get_param_type (type_info, 0);
1245             g_assert (key_type_info != NULL);
1246
1247             value_type_info = g_type_info_get_param_type (type_info, 1);
1248             g_assert (value_type_info != NULL);
1249
1250             key_type_tag = g_type_info_get_tag (key_type_info);
1251
1252             switch (key_type_tag) {
1253                 case GI_TYPE_TAG_UTF8:
1254                 case GI_TYPE_TAG_FILENAME:
1255                     hash_func = g_str_hash;
1256                     equal_func = g_str_equal;
1257                     break;
1258                 default:
1259                     hash_func = NULL;
1260                     equal_func = NULL;
1261             }
1262
1263             hash_table = g_hash_table_new (hash_func, equal_func);
1264             if (hash_table == NULL) {
1265                 PyErr_NoMemory();
1266                 goto hash_table_release;
1267             }
1268
1269             item_transfer = transfer == GI_TRANSFER_CONTAINER ? GI_TRANSFER_NOTHING : transfer;
1270
1271             for (i = 0; i < length; i++) {
1272                 PyObject *py_key;
1273                 PyObject *py_value;
1274                 GIArgument key;
1275                 GIArgument value;
1276
1277                 py_key = PyList_GET_ITEM (keys, i);
1278                 py_value = PyList_GET_ITEM (values, i);
1279
1280                 key = _pygi_argument_from_object (py_key, key_type_info, item_transfer);
1281                 if (PyErr_Occurred()) {
1282                     goto hash_table_item_error;
1283                 }
1284
1285                 value = _pygi_argument_from_object (py_value, value_type_info, item_transfer);
1286                 if (PyErr_Occurred()) {
1287                     _pygi_argument_release (&key, type_info, GI_TRANSFER_NOTHING, GI_DIRECTION_IN);
1288                     goto hash_table_item_error;
1289                 }
1290
1291                 g_hash_table_insert (hash_table, key.v_pointer, value.v_pointer);
1292                 continue;
1293
1294 hash_table_item_error:
1295                 /* Free everything we have converted so far. */
1296                 _pygi_argument_release ( (GIArgument *) &hash_table, type_info,
1297                                          GI_TRANSFER_NOTHING, GI_DIRECTION_IN);
1298                 hash_table = NULL;
1299
1300                 _PyGI_ERROR_PREFIX ("Item %zd: ", i);
1301                 break;
1302             }
1303
1304             arg.v_pointer = hash_table;
1305
1306 hash_table_release:
1307             g_base_info_unref ( (GIBaseInfo *) key_type_info);
1308             g_base_info_unref ( (GIBaseInfo *) value_type_info);
1309             Py_DECREF (keys);
1310             Py_DECREF (values);
1311             break;
1312         }
1313         case GI_TYPE_TAG_ERROR:
1314             PyErr_SetString (PyExc_NotImplementedError, "error marshalling is not supported yet");
1315             /* TODO */
1316             break;
1317     }
1318
1319     return arg;
1320 }
1321
1322 PyObject *
1323 _pygi_argument_to_object (GIArgument  *arg,
1324                           GITypeInfo *type_info,
1325                           GITransfer transfer)
1326 {
1327     GITypeTag type_tag;
1328     PyObject *object = NULL;
1329
1330     type_tag = g_type_info_get_tag (type_info);
1331     switch (type_tag) {
1332         case GI_TYPE_TAG_VOID:
1333             if (g_type_info_is_pointer (type_info)) {
1334                 /* Raw Python objects are passed to void* args */
1335                 g_warn_if_fail (transfer == GI_TRANSFER_NOTHING);
1336                 object = arg->v_pointer;
1337             } else
1338                 object = Py_None;
1339             Py_XINCREF (object);
1340             break;
1341         case GI_TYPE_TAG_BOOLEAN:
1342         {
1343             object = PyBool_FromLong (arg->v_boolean);
1344             break;
1345         }
1346         case GI_TYPE_TAG_INT8:
1347         {
1348             object = PYGLIB_PyLong_FromLong (arg->v_int8);
1349             break;
1350         }
1351         case GI_TYPE_TAG_UINT8:
1352         {
1353             object = PYGLIB_PyLong_FromLong (arg->v_uint8);
1354             break;
1355         }
1356         case GI_TYPE_TAG_INT16:
1357         {
1358             object = PYGLIB_PyLong_FromLong (arg->v_int16);
1359             break;
1360         }
1361         case GI_TYPE_TAG_UINT16:
1362         {
1363             object = PYGLIB_PyLong_FromLong (arg->v_uint16);
1364             break;
1365         }
1366         case GI_TYPE_TAG_INT32:
1367         {
1368             object = PYGLIB_PyLong_FromLong (arg->v_int32);
1369             break;
1370         }
1371         case GI_TYPE_TAG_UINT32:
1372         {
1373             object = PyLong_FromLongLong (arg->v_uint32);
1374             break;
1375         }
1376         case GI_TYPE_TAG_INT64:
1377         {
1378             object = PyLong_FromLongLong (arg->v_int64);
1379             break;
1380         }
1381         case GI_TYPE_TAG_UINT64:
1382         {
1383             object = PyLong_FromUnsignedLongLong (arg->v_uint64);
1384             break;
1385         }
1386         case GI_TYPE_TAG_FLOAT:
1387         {
1388             object = PyFloat_FromDouble (arg->v_float);
1389             break;
1390         }
1391         case GI_TYPE_TAG_DOUBLE:
1392         {
1393             object = PyFloat_FromDouble (arg->v_double);
1394             break;
1395         }
1396         case GI_TYPE_TAG_GTYPE:
1397         {
1398             object = pyg_type_wrapper_new ( (GType) arg->v_long);
1399             break;
1400         }
1401         case GI_TYPE_TAG_UNICHAR:
1402         {
1403             /* Preserve the bidirectional mapping between 0 and "" */
1404             if (arg->v_uint32 == 0) {
1405                 object = PYGLIB_PyUnicode_FromString ("");
1406             } else if (g_unichar_validate (arg->v_uint32)) {
1407                 gchar utf8[6];
1408                 gint bytes;
1409
1410                 bytes = g_unichar_to_utf8 (arg->v_uint32, utf8);
1411                 object = PYGLIB_PyUnicode_FromStringAndSize ((char*)utf8, bytes);
1412             } else {
1413                 /* TODO: Convert the error to an exception. */
1414                 PyErr_Format (PyExc_TypeError,
1415                               "Invalid unicode codepoint %" G_GUINT32_FORMAT,
1416                               arg->v_uint32);
1417                 object = Py_None;
1418                 Py_INCREF (object);
1419             }
1420             break;
1421         }
1422         case GI_TYPE_TAG_UTF8:
1423             if (arg->v_string == NULL) {
1424                 object = Py_None;
1425                 Py_INCREF (object);
1426                 break;
1427             }
1428
1429             object = PYGLIB_PyUnicode_FromString (arg->v_string);
1430             break;
1431         case GI_TYPE_TAG_FILENAME:
1432         {
1433             GError *error = NULL;
1434             gchar *string;
1435
1436             if (arg->v_string == NULL) {
1437                 object = Py_None;
1438                 Py_INCREF (object);
1439                 break;
1440             }
1441
1442             string = g_filename_to_utf8 (arg->v_string, -1, NULL, NULL, &error);
1443             if (string == NULL) {
1444                 PyErr_SetString (PyExc_Exception, error->message);
1445                 /* TODO: Convert the error to an exception. */
1446                 break;
1447             }
1448
1449             object = PYGLIB_PyUnicode_FromString (string);
1450
1451             g_free (string);
1452
1453             break;
1454         }
1455         case GI_TYPE_TAG_ARRAY:
1456         {
1457             GArray *array;
1458             GITypeInfo *item_type_info;
1459             GITypeTag item_type_tag;
1460             GITransfer item_transfer;
1461             gsize i, item_size;
1462
1463             array = arg->v_pointer;
1464
1465             item_type_info = g_type_info_get_param_type (type_info, 0);
1466             g_assert (item_type_info != NULL);
1467
1468             item_type_tag = g_type_info_get_tag (item_type_info);
1469             item_transfer = transfer == GI_TRANSFER_CONTAINER ? GI_TRANSFER_NOTHING : transfer;
1470
1471             if (item_type_tag == GI_TYPE_TAG_UINT8) {
1472                 /* Return as a byte array */
1473                 if (arg->v_pointer == NULL) {
1474                     object = PYGLIB_PyBytes_FromString ("");
1475                     break;
1476                 }
1477
1478                 object = PYGLIB_PyBytes_FromStringAndSize(array->data, array->len);
1479                 break;
1480
1481             } else {
1482                 if (arg->v_pointer == NULL) {
1483                     object = PyList_New (0);
1484                     break;
1485                 }
1486
1487                 object = PyList_New (array->len);
1488                 if (object == NULL) {
1489                     break;
1490                 }
1491
1492             }
1493             item_size = g_array_get_element_size (array);
1494
1495             for (i = 0; i < array->len; i++) {
1496                 GIArgument item;
1497                 PyObject *py_item;
1498                 gboolean is_struct = FALSE;
1499
1500                 if (item_type_tag == GI_TYPE_TAG_INTERFACE) {
1501                     GIBaseInfo *iface_info = g_type_info_get_interface (item_type_info);
1502                     switch (g_base_info_get_type (iface_info)) {
1503                         case GI_INFO_TYPE_STRUCT:
1504                         case GI_INFO_TYPE_BOXED:
1505                             is_struct = TRUE;
1506                         default:
1507                             break;
1508                     }
1509                     g_base_info_unref ( (GIBaseInfo *) iface_info);
1510                 }
1511
1512                 if (is_struct) {
1513                     item.v_pointer = &_g_array_index (array, GIArgument, i);
1514                 } else {
1515                     memcpy (&item, &_g_array_index (array, GIArgument, i), item_size);
1516                 }
1517
1518                 py_item = _pygi_argument_to_object (&item, item_type_info, item_transfer);
1519                 if (py_item == NULL) {
1520                     Py_CLEAR (object);
1521                     _PyGI_ERROR_PREFIX ("Item %zu: ", i);
1522                     break;
1523                 }
1524
1525                 PyList_SET_ITEM (object, i, py_item);
1526             }
1527
1528             g_base_info_unref ( (GIBaseInfo *) item_type_info);
1529             break;
1530         }
1531         case GI_TYPE_TAG_INTERFACE:
1532         {
1533             GIBaseInfo *info;
1534             GIInfoType info_type;
1535
1536             info = g_type_info_get_interface (type_info);
1537             info_type = g_base_info_get_type (info);
1538
1539             switch (info_type) {
1540                 case GI_INFO_TYPE_CALLBACK:
1541                 {
1542                     /* There is no way we can support a callback return
1543                      * as we are never sure if the callback was set from C
1544                      * or Python.  API that return callbacks are broken
1545                      * so we print a warning and send back a None
1546                      */
1547
1548                     g_warning ("You are trying to use an API which returns a callback."
1549                                "Callback returns can not be supported. Returning None instead.");
1550                     object = Py_None;
1551                     Py_INCREF (object);
1552                     break;
1553                 }
1554                 case GI_INFO_TYPE_BOXED:
1555                 case GI_INFO_TYPE_STRUCT:
1556                 case GI_INFO_TYPE_UNION:
1557                 {
1558                     GType type;
1559
1560                     if (arg->v_pointer == NULL) {
1561                         object = Py_None;
1562                         Py_INCREF (object);
1563                         break;
1564                     }
1565
1566                     type = g_registered_type_info_get_g_type ( (GIRegisteredTypeInfo *) info);
1567                     if (g_type_is_a (type, G_TYPE_VALUE)) {
1568                         object = pyg_value_as_pyobject (arg->v_pointer, FALSE);
1569                     } else if (g_struct_info_is_foreign (info)) {
1570                         object = pygi_struct_foreign_convert_from_g_argument (info, arg->v_pointer);
1571                     } else if (g_type_is_a (type, G_TYPE_BOXED)) {
1572                         PyObject *py_type;
1573
1574                         py_type = _pygi_type_get_from_g_type (type);
1575                         if (py_type == NULL)
1576                             break;
1577
1578                         object = _pygi_boxed_new ( (PyTypeObject *) py_type, arg->v_pointer, transfer == GI_TRANSFER_EVERYTHING);
1579
1580                         Py_DECREF (py_type);
1581                     } else if (g_type_is_a (type, G_TYPE_POINTER)) {
1582                         PyObject *py_type;
1583
1584                         py_type = _pygi_type_get_from_g_type (type);
1585
1586                         if (py_type == NULL || !PyType_IsSubtype ( (PyTypeObject *) type, &PyGIStruct_Type)) {
1587                             g_warn_if_fail (transfer == GI_TRANSFER_NOTHING);
1588                             object = pyg_pointer_new (type, arg->v_pointer);
1589                         } else {
1590                             object = _pygi_struct_new ( (PyTypeObject *) py_type, arg->v_pointer, transfer == GI_TRANSFER_EVERYTHING);
1591                         }
1592
1593                         Py_XDECREF (py_type);
1594                     } else if (type == G_TYPE_VARIANT) {
1595                         PyObject *py_type;
1596
1597                         g_variant_ref_sink (arg->v_pointer);
1598                         py_type = _pygi_type_import_by_gi_info (info);
1599                         object = _pygi_struct_new ( (PyTypeObject *) py_type, arg->v_pointer,
1600                                                     transfer == GI_TRANSFER_EVERYTHING);
1601                     } else if (type == G_TYPE_NONE) {
1602                         PyObject *py_type;
1603
1604                         py_type = _pygi_type_import_by_gi_info (info);
1605                         if (py_type == NULL) {
1606                             break;
1607                         }
1608
1609                         /* Only structs created in invoke can be safely marked
1610                          * GI_TRANSFER_EVERYTHING. Trust that invoke has
1611                          * filtered correctly
1612                          */
1613                         object = _pygi_struct_new ( (PyTypeObject *) py_type, arg->v_pointer,
1614                                                     transfer == GI_TRANSFER_EVERYTHING);
1615
1616                         Py_DECREF (py_type);
1617                     } else {
1618                         PyErr_Format (PyExc_NotImplementedError, "structure type '%s' is not supported yet", g_type_name (type));
1619                     }
1620
1621                     break;
1622                 }
1623                 case GI_INFO_TYPE_ENUM:
1624                 case GI_INFO_TYPE_FLAGS:
1625                 {
1626                     GType type;
1627
1628                     type = g_registered_type_info_get_g_type ( (GIRegisteredTypeInfo *) info);
1629
1630                     if (type == G_TYPE_NONE) {
1631                         /* An enum with a GType of None is an enum without GType */
1632                         PyObject *py_type = _pygi_type_import_by_gi_info (info);
1633                         PyObject *py_args = NULL;
1634
1635                         if (!py_type)
1636                             return NULL;
1637
1638                         py_args = PyTuple_New (1);
1639                         if (PyTuple_SetItem (py_args, 0, PyLong_FromLong (arg->v_long)) != 0) {
1640                             Py_DECREF (py_args);
1641                             Py_DECREF (py_type);
1642                             return NULL;
1643                         }
1644
1645                         object = PyObject_CallFunction (py_type, "l", arg->v_long);
1646
1647                         Py_DECREF (py_args);
1648                         Py_DECREF (py_type);
1649
1650                     } else if (info_type == GI_INFO_TYPE_ENUM) {
1651                         object = pyg_enum_from_gtype (type, arg->v_long);
1652                     } else {
1653                         object = pyg_flags_from_gtype (type, arg->v_long);
1654                     }
1655
1656                     break;
1657                 }
1658                 case GI_INFO_TYPE_INTERFACE:
1659                 case GI_INFO_TYPE_OBJECT:
1660                     if (arg->v_pointer == NULL) {
1661                         object = Py_None;
1662                         Py_INCREF (object);
1663                         break;
1664                     }
1665                     object = pygobject_new (arg->v_pointer);
1666                     break;
1667                 default:
1668                     g_assert_not_reached();
1669             }
1670
1671             g_base_info_unref (info);
1672             break;
1673         }
1674         case GI_TYPE_TAG_GLIST:
1675         case GI_TYPE_TAG_GSLIST:
1676         {
1677             GSList *list;
1678             gsize length;
1679             GITypeInfo *item_type_info;
1680             GITransfer item_transfer;
1681             gsize i;
1682
1683             list = arg->v_pointer;
1684             length = g_slist_length (list);
1685
1686             object = PyList_New (length);
1687             if (object == NULL) {
1688                 break;
1689             }
1690
1691             item_type_info = g_type_info_get_param_type (type_info, 0);
1692             g_assert (item_type_info != NULL);
1693
1694             item_transfer = transfer == GI_TRANSFER_CONTAINER ? GI_TRANSFER_NOTHING : transfer;
1695
1696             for (i = 0; list != NULL; list = g_slist_next (list), i++) {
1697                 GIArgument item;
1698                 PyObject *py_item;
1699
1700                 item.v_pointer = list->data;
1701
1702                 py_item = _pygi_argument_to_object (&item, item_type_info, item_transfer);
1703                 if (py_item == NULL) {
1704                     Py_CLEAR (object);
1705                     _PyGI_ERROR_PREFIX ("Item %zu: ", i);
1706                     break;
1707                 }
1708
1709                 PyList_SET_ITEM (object, i, py_item);
1710             }
1711
1712             g_base_info_unref ( (GIBaseInfo *) item_type_info);
1713             break;
1714         }
1715         case GI_TYPE_TAG_GHASH:
1716         {
1717             GITypeInfo *key_type_info;
1718             GITypeInfo *value_type_info;
1719             GITransfer item_transfer;
1720             GHashTableIter hash_table_iter;
1721             GIArgument key;
1722             GIArgument value;
1723
1724             if (arg->v_pointer == NULL) {
1725                 object = Py_None;
1726                 Py_INCREF (object);
1727                 break;
1728             }
1729
1730             object = PyDict_New();
1731             if (object == NULL) {
1732                 break;
1733             }
1734
1735             key_type_info = g_type_info_get_param_type (type_info, 0);
1736             g_assert (key_type_info != NULL);
1737             g_assert (g_type_info_get_tag (key_type_info) != GI_TYPE_TAG_VOID);
1738
1739             value_type_info = g_type_info_get_param_type (type_info, 1);
1740             g_assert (value_type_info != NULL);
1741             g_assert (g_type_info_get_tag (value_type_info) != GI_TYPE_TAG_VOID);
1742
1743             item_transfer = transfer == GI_TRANSFER_CONTAINER ? GI_TRANSFER_NOTHING : transfer;
1744
1745             g_hash_table_iter_init (&hash_table_iter, (GHashTable *) arg->v_pointer);
1746             while (g_hash_table_iter_next (&hash_table_iter, &key.v_pointer, &value.v_pointer)) {
1747                 PyObject *py_key;
1748                 PyObject *py_value;
1749                 int retval;
1750
1751                 py_key = _pygi_argument_to_object (&key, key_type_info, item_transfer);
1752                 if (py_key == NULL) {
1753                     break;
1754                 }
1755
1756                 py_value = _pygi_argument_to_object (&value, value_type_info, item_transfer);
1757                 if (py_value == NULL) {
1758                     Py_DECREF (py_key);
1759                     break;
1760                 }
1761
1762                 retval = PyDict_SetItem (object, py_key, py_value);
1763
1764                 Py_DECREF (py_key);
1765                 Py_DECREF (py_value);
1766
1767                 if (retval < 0) {
1768                     Py_CLEAR (object);
1769                     break;
1770                 }
1771             }
1772
1773             g_base_info_unref ( (GIBaseInfo *) key_type_info);
1774             g_base_info_unref ( (GIBaseInfo *) value_type_info);
1775             break;
1776         }
1777         case GI_TYPE_TAG_ERROR:
1778              if (pyglib_error_check (&arg->v_pointer)) {
1779                  PyObject *err_type;
1780                  PyObject *err_value;
1781                  PyObject *err_trace;
1782                  PyErr_Fetch (&err_type, &err_value, &err_trace);
1783                  Py_XDECREF (err_type);
1784                  Py_XDECREF (err_trace);
1785                  object = err_value;
1786              } else {
1787                  object = Py_None;
1788                  Py_INCREF (object);
1789                  break;
1790              }
1791     }
1792
1793     return object;
1794 }
1795
1796
1797 GIArgument
1798 _pygi_argument_from_g_value(const GValue *value,
1799                             GITypeInfo *type_info)
1800 {
1801     GIArgument arg = { 0, };
1802
1803     GITypeTag type_tag = g_type_info_get_tag (type_info);
1804     switch (type_tag) {
1805         case GI_TYPE_TAG_BOOLEAN:
1806             arg.v_boolean = g_value_get_boolean (value);
1807             break;
1808         case GI_TYPE_TAG_INT8:
1809         case GI_TYPE_TAG_INT16:
1810         case GI_TYPE_TAG_INT32:
1811         case GI_TYPE_TAG_INT64:
1812             arg.v_int = g_value_get_int (value);
1813             break;
1814         case GI_TYPE_TAG_UINT8:
1815         case GI_TYPE_TAG_UINT16:
1816         case GI_TYPE_TAG_UINT32:
1817         case GI_TYPE_TAG_UINT64:
1818             arg.v_uint = g_value_get_uint (value);
1819             break;
1820         case GI_TYPE_TAG_UNICHAR:
1821             arg.v_uint32 = g_value_get_char (value);
1822             break;
1823         case GI_TYPE_TAG_FLOAT:
1824             arg.v_float = g_value_get_float (value);
1825             break;
1826         case GI_TYPE_TAG_DOUBLE:
1827             arg.v_double = g_value_get_double (value);
1828             break;
1829         case GI_TYPE_TAG_GTYPE:
1830             arg.v_long = g_value_get_gtype (value);
1831             break;
1832         case GI_TYPE_TAG_UTF8:
1833         case GI_TYPE_TAG_FILENAME:
1834             arg.v_string = g_value_dup_string (value);
1835             break;
1836         case GI_TYPE_TAG_GLIST:
1837         case GI_TYPE_TAG_GSLIST:
1838             arg.v_pointer = g_value_get_pointer (value);
1839             break;
1840         case GI_TYPE_TAG_ARRAY:
1841         case GI_TYPE_TAG_GHASH:
1842             arg.v_pointer = g_value_get_boxed (value);
1843             break;
1844         case GI_TYPE_TAG_INTERFACE:
1845         {
1846             GIBaseInfo *info;
1847             GIInfoType info_type;
1848
1849             info = g_type_info_get_interface (type_info);
1850             info_type = g_base_info_get_type (info);
1851
1852             g_base_info_unref (info);
1853
1854             switch (info_type) {
1855                 case GI_INFO_TYPE_FLAGS:
1856                     arg.v_long = g_value_get_flags (value);
1857                     break;
1858                 case GI_INFO_TYPE_ENUM:
1859                     arg.v_long = g_value_get_enum (value);
1860                     break;
1861                 case GI_INFO_TYPE_INTERFACE:
1862                 case GI_INFO_TYPE_OBJECT:
1863                     arg.v_pointer = g_value_get_object (value);
1864                     break;
1865                 case GI_INFO_TYPE_BOXED:
1866                 case GI_INFO_TYPE_STRUCT:
1867                 case GI_INFO_TYPE_UNION:
1868                     if (G_VALUE_HOLDS(value, G_TYPE_BOXED)) {
1869                         arg.v_pointer = g_value_get_boxed (value);
1870                     } else if (G_VALUE_HOLDS(value, G_TYPE_VARIANT)) {
1871                         arg.v_pointer = g_value_get_variant (value);
1872                     } else {
1873                         arg.v_pointer = g_value_get_pointer (value);
1874                     }
1875                     break;
1876                 default:
1877                     g_warning("Converting of type '%s' is not implemented", g_info_type_to_string(info_type));
1878                     g_assert_not_reached();
1879             }
1880             break;
1881         }
1882         case GI_TYPE_TAG_ERROR:
1883             arg.v_pointer = g_value_get_boxed (value);
1884             break;
1885         case GI_TYPE_TAG_VOID:
1886             g_critical("Converting of type '%s' is not implemented", g_type_tag_to_string(type_tag));
1887             g_assert_not_reached();
1888     }
1889
1890     return arg;
1891 }
1892
1893 void
1894 _pygi_argument_release (GIArgument   *arg,
1895                         GITypeInfo  *type_info,
1896                         GITransfer   transfer,
1897                         GIDirection  direction)
1898 {
1899     GITypeTag type_tag;
1900     gboolean is_out = (direction == GI_DIRECTION_OUT || direction == GI_DIRECTION_INOUT);
1901
1902     type_tag = g_type_info_get_tag (type_info);
1903
1904     switch (type_tag) {
1905         case GI_TYPE_TAG_VOID:
1906             /* Don't do anything, it's transparent to the C side */
1907             break;
1908         case GI_TYPE_TAG_BOOLEAN:
1909         case GI_TYPE_TAG_INT8:
1910         case GI_TYPE_TAG_UINT8:
1911         case GI_TYPE_TAG_INT16:
1912         case GI_TYPE_TAG_UINT16:
1913         case GI_TYPE_TAG_INT32:
1914         case GI_TYPE_TAG_UINT32:
1915         case GI_TYPE_TAG_INT64:
1916         case GI_TYPE_TAG_UINT64:
1917         case GI_TYPE_TAG_FLOAT:
1918         case GI_TYPE_TAG_DOUBLE:
1919         case GI_TYPE_TAG_GTYPE:
1920         case GI_TYPE_TAG_UNICHAR:
1921             break;
1922         case GI_TYPE_TAG_FILENAME:
1923         case GI_TYPE_TAG_UTF8:
1924             /* With allow-none support the string could be NULL */
1925             if ((arg->v_string != NULL &&
1926                     (direction == GI_DIRECTION_IN && transfer == GI_TRANSFER_NOTHING))
1927                     || (direction == GI_DIRECTION_OUT && transfer == GI_TRANSFER_EVERYTHING)) {
1928                 g_free (arg->v_string);
1929             }
1930             break;
1931         case GI_TYPE_TAG_ARRAY:
1932         {
1933             GArray *array;
1934             gsize i;
1935
1936             if (arg->v_pointer == NULL) {
1937                 return;
1938             }
1939
1940             array = arg->v_pointer;
1941
1942             if ( (direction == GI_DIRECTION_IN && transfer != GI_TRANSFER_EVERYTHING)
1943                     || (direction == GI_DIRECTION_OUT && transfer == GI_TRANSFER_EVERYTHING)) {
1944                 GITypeInfo *item_type_info;
1945                 GITransfer item_transfer;
1946
1947                 item_type_info = g_type_info_get_param_type (type_info, 0);
1948
1949                 item_transfer = direction == GI_DIRECTION_IN ? GI_TRANSFER_NOTHING : GI_TRANSFER_EVERYTHING;
1950
1951                 /* Free the items */
1952                 for (i = 0; i < array->len; i++) {
1953                     GIArgument *item;
1954                     item = &_g_array_index (array, GIArgument, i);
1955                     _pygi_argument_release (item, item_type_info, item_transfer, direction);
1956                 }
1957
1958                 g_base_info_unref ( (GIBaseInfo *) item_type_info);
1959             }
1960
1961             if ( (direction == GI_DIRECTION_IN && transfer == GI_TRANSFER_NOTHING)
1962                     || (direction == GI_DIRECTION_OUT && transfer != GI_TRANSFER_NOTHING)) {
1963                 g_array_free (array, TRUE);
1964             }
1965
1966             break;
1967         }
1968         case GI_TYPE_TAG_INTERFACE:
1969         {
1970             GIBaseInfo *info;
1971             GIInfoType info_type;
1972
1973             info = g_type_info_get_interface (type_info);
1974             info_type = g_base_info_get_type (info);
1975
1976             switch (info_type) {
1977                 case GI_INFO_TYPE_CALLBACK:
1978                     /* TODO */
1979                     break;
1980                 case GI_INFO_TYPE_BOXED:
1981                 case GI_INFO_TYPE_STRUCT:
1982                 case GI_INFO_TYPE_UNION:
1983                 {
1984                     GType type;
1985
1986                     if (arg->v_pointer == NULL) {
1987                         return;
1988                     }
1989
1990                     type = g_registered_type_info_get_g_type ( (GIRegisteredTypeInfo *) info);
1991
1992                     if (g_type_is_a (type, G_TYPE_VALUE)) {
1993                         GValue *value;
1994
1995                         value = arg->v_pointer;
1996
1997                         if ( (direction == GI_DIRECTION_IN && transfer != GI_TRANSFER_EVERYTHING)
1998                                 || (direction == GI_DIRECTION_OUT && transfer == GI_TRANSFER_EVERYTHING)) {
1999                             g_value_unset (value);
2000                         }
2001
2002                         if ( (direction == GI_DIRECTION_IN && transfer == GI_TRANSFER_NOTHING)
2003                                 || (direction == GI_DIRECTION_OUT && transfer != GI_TRANSFER_NOTHING)) {
2004                             g_slice_free (GValue, value);
2005                         }
2006                     } else if (g_type_is_a (type, G_TYPE_CLOSURE)) {
2007                         if (direction == GI_DIRECTION_IN && transfer == GI_TRANSFER_NOTHING) {
2008                             g_closure_unref (arg->v_pointer);
2009                         }
2010                     } else if (g_struct_info_is_foreign ( (GIStructInfo*) info)) {
2011                         if (direction == GI_DIRECTION_OUT && transfer == GI_TRANSFER_EVERYTHING) {
2012                             pygi_struct_foreign_release (info, arg->v_pointer);
2013                         }
2014                     } else if (g_type_is_a (type, G_TYPE_BOXED)) {
2015                     } else if (g_type_is_a (type, G_TYPE_POINTER) || type == G_TYPE_NONE) {
2016                         g_warn_if_fail (!g_type_info_is_pointer (type_info) || transfer == GI_TRANSFER_NOTHING);
2017                     }
2018
2019                     break;
2020                 }
2021                 case GI_INFO_TYPE_ENUM:
2022                 case GI_INFO_TYPE_FLAGS:
2023                     break;
2024                 case GI_INFO_TYPE_INTERFACE:
2025                 case GI_INFO_TYPE_OBJECT:
2026                     if (arg->v_pointer == NULL) {
2027                         return;
2028                     }
2029                     if (is_out && transfer == GI_TRANSFER_EVERYTHING) {
2030                         g_object_unref (arg->v_pointer);
2031                     }
2032                     break;
2033                 default:
2034                     g_assert_not_reached();
2035             }
2036
2037             g_base_info_unref (info);
2038             break;
2039         }
2040         case GI_TYPE_TAG_GLIST:
2041         case GI_TYPE_TAG_GSLIST:
2042         {
2043             GSList *list;
2044
2045             if (arg->v_pointer == NULL) {
2046                 return;
2047             }
2048
2049             list = arg->v_pointer;
2050
2051             if ( (direction == GI_DIRECTION_IN && transfer != GI_TRANSFER_EVERYTHING)
2052                     || (direction == GI_DIRECTION_OUT && transfer == GI_TRANSFER_EVERYTHING)) {
2053                 GITypeInfo *item_type_info;
2054                 GITransfer item_transfer;
2055                 GSList *item;
2056
2057                 item_type_info = g_type_info_get_param_type (type_info, 0);
2058                 g_assert (item_type_info != NULL);
2059
2060                 item_transfer = direction == GI_DIRECTION_IN ? GI_TRANSFER_NOTHING : GI_TRANSFER_EVERYTHING;
2061
2062                 /* Free the items */
2063                 for (item = list; item != NULL; item = g_slist_next (item)) {
2064                     _pygi_argument_release ( (GIArgument *) &item->data, item_type_info,
2065                                              item_transfer, direction);
2066                 }
2067
2068                 g_base_info_unref ( (GIBaseInfo *) item_type_info);
2069             }
2070
2071             if ( (direction == GI_DIRECTION_IN && transfer == GI_TRANSFER_NOTHING)
2072                     || (direction == GI_DIRECTION_OUT && transfer != GI_TRANSFER_NOTHING)) {
2073                 if (type_tag == GI_TYPE_TAG_GLIST) {
2074                     g_list_free ( (GList *) list);
2075                 } else {
2076                     /* type_tag == GI_TYPE_TAG_GSLIST */
2077                     g_slist_free (list);
2078                 }
2079             }
2080
2081             break;
2082         }
2083         case GI_TYPE_TAG_GHASH:
2084         {
2085             GHashTable *hash_table;
2086
2087             if (arg->v_pointer == NULL) {
2088                 return;
2089             }
2090
2091             hash_table = arg->v_pointer;
2092
2093             if (direction == GI_DIRECTION_IN && transfer != GI_TRANSFER_EVERYTHING) {
2094                 /* We created the table without a destroy function, so keys and
2095                  * values need to be released. */
2096                 GITypeInfo *key_type_info;
2097                 GITypeInfo *value_type_info;
2098                 GITransfer item_transfer;
2099                 GHashTableIter hash_table_iter;
2100                 gpointer key;
2101                 gpointer value;
2102
2103                 key_type_info = g_type_info_get_param_type (type_info, 0);
2104                 g_assert (key_type_info != NULL);
2105
2106                 value_type_info = g_type_info_get_param_type (type_info, 1);
2107                 g_assert (value_type_info != NULL);
2108
2109                 if (direction == GI_DIRECTION_IN) {
2110                     item_transfer = GI_TRANSFER_NOTHING;
2111                 } else {
2112                     item_transfer = GI_TRANSFER_EVERYTHING;
2113                 }
2114
2115                 g_hash_table_iter_init (&hash_table_iter, hash_table);
2116                 while (g_hash_table_iter_next (&hash_table_iter, &key, &value)) {
2117                     _pygi_argument_release ( (GIArgument *) &key, key_type_info,
2118                                              item_transfer, direction);
2119                     _pygi_argument_release ( (GIArgument *) &value, value_type_info,
2120                                              item_transfer, direction);
2121                 }
2122
2123                 g_base_info_unref ( (GIBaseInfo *) key_type_info);
2124                 g_base_info_unref ( (GIBaseInfo *) value_type_info);
2125             } else if (direction == GI_DIRECTION_OUT && transfer == GI_TRANSFER_CONTAINER) {
2126                 /* Be careful to avoid keys and values being freed if the
2127                  * callee gave a destroy function. */
2128                 g_hash_table_steal_all (hash_table);
2129             }
2130
2131             if ( (direction == GI_DIRECTION_IN && transfer == GI_TRANSFER_NOTHING)
2132                     || (direction == GI_DIRECTION_OUT && transfer != GI_TRANSFER_NOTHING)) {
2133                 g_hash_table_unref (hash_table);
2134             }
2135
2136             break;
2137         }
2138         case GI_TYPE_TAG_ERROR:
2139         {
2140             GError *error;
2141
2142             if (arg->v_pointer == NULL) {
2143                 return;
2144             }
2145
2146             error = * (GError **) arg->v_pointer;
2147
2148             if (error != NULL) {
2149                 g_error_free (error);
2150             }
2151
2152             g_slice_free (GError *, arg->v_pointer);
2153             break;
2154         }
2155     }
2156 }
2157
2158 void
2159 _pygi_argument_init (void)
2160 {
2161     PyDateTime_IMPORT;
2162     _pygobject_import();
2163 }
2164