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