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