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         case GI_TYPE_TAG_INT8:
 414             /* (U)INT8 types can be characters */
 415             if (PYGLIB_PyBytes_Check(object)) {
 416                 if (PYGLIB_PyBytes_Size(object) != 1) {
 417                     PyErr_Format (PyExc_TypeError, "Must be a single character");
 418                     retval = 0;
 419                     break;
 420                 }
 421
 422                 break;
 423             }
 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                     g_callable_info_load_arg (callable_info, length_arg_pos, &length_arg_info);
 821                     g_arg_info_load_type (&length_arg_info, &length_type_info);
 822                     if (!gi_argument_to_gssize (args[length_arg_pos],
 823                                                 g_type_info_get_tag (&length_type_info),
 824                                                 &length))
 825                         return NULL;
 826                 }
 827             }
 828
 829             g_assert (length >= 0);
 830
 831             g_array = g_array_new (is_zero_terminated, FALSE, item_size);
 832
 833             g_array->data = arg->v_pointer;
 834             g_array->len = length;
 835             *out_free_array = TRUE;
 836             break;
 837         case GI_ARRAY_TYPE_ARRAY:
 838         case GI_ARRAY_TYPE_BYTE_ARRAY:
 839             /* Note: GByteArray is really just a GArray */
 840             g_array = arg->v_pointer;
 841             *out_free_array = FALSE;
 842             break;
 843         case GI_ARRAY_TYPE_PTR_ARRAY:
 844         {
 845             GPtrArray *ptr_array = (GPtrArray*) arg->v_pointer;
 846             g_array = g_array_sized_new (FALSE, FALSE,
 847                                          sizeof(gpointer),
 848                                          ptr_array->len);
 849              g_array->data = (char*) ptr_array->pdata;
 850              g_array->len = ptr_array->len;
 851              *out_free_array = TRUE;
 852              break;
 853         }
 854         default:
 855             g_critical ("Unexpected array type %u",
 856                         g_type_info_get_array_type (type_info));
 857             g_array = NULL;
 858             break;
 859     }
 860
 861     return g_array;
 862 }
 863
 864 GIArgument
 865 _pygi_argument_from_object (PyObject   *object,
 866                             GITypeInfo *type_info,
 867                             GITransfer  transfer)
 868 {
 869     GIArgument arg;
 870     GITypeTag type_tag;
 871
 872     memset(&arg, 0, sizeof(GIArgument));
 873     type_tag = g_type_info_get_tag (type_info);
 874
 875     switch (type_tag) {
 876         case GI_TYPE_TAG_VOID:
 877             g_warn_if_fail (transfer == GI_TRANSFER_NOTHING);
 878             if (object == Py_None) {
 879                 arg.v_pointer = NULL;
 880             } else if (!PYGLIB_PyLong_Check(object)  && !PyLong_Check(object)) {
 881                 PyErr_SetString(PyExc_TypeError,
 882                     "Pointer assignment is restricted to integer values. "
 883                     "See: https://bugzilla.gnome.org/show_bug.cgi?id=683599");
 884             } else {
 885                 arg.v_pointer = PyLong_AsVoidPtr (object);
 886             }
 887             break;
 888         case GI_TYPE_TAG_BOOLEAN:
 889         {
 890             arg.v_boolean = PyObject_IsTrue (object);
 891             break;
 892         }
 893         case GI_TYPE_TAG_INT8:
 894         case GI_TYPE_TAG_INT16:
 895         case GI_TYPE_TAG_INT32:
 896         {
 897             PyObject *int_;
 898
 899             int_ = PYGLIB_PyNumber_Long (object);
 900             if (int_ == NULL) {
 901                 PyErr_SetString (PyExc_TypeError, "expected int argument");
 902                 break;
 903             }
 904
 905             if (type_tag == GI_TYPE_TAG_INT32)
 906                 arg.v_int32 = PYGLIB_PyLong_AsLong (int_);
 907             else if (type_tag == GI_TYPE_TAG_INT8)
 908                 arg.v_int8 = PYGLIB_PyLong_AsLong (int_);
 909             else if (type_tag == GI_TYPE_TAG_INT16)
 910                 arg.v_int16 = PYGLIB_PyLong_AsLong (int_);
 911
 912             Py_DECREF (int_);
 913
 914             break;
 915         }
 916         case GI_TYPE_TAG_UINT8:
 917         case GI_TYPE_TAG_UINT16:
 918         case GI_TYPE_TAG_UINT32:
 919         case GI_TYPE_TAG_UINT64:
 920         {
 921             PyObject *number;
 922             guint64 value;
 923
 924             number = PYGLIB_PyNumber_Long (object);
 925             if (number == NULL) {
 926                 PyErr_SetString (PyExc_TypeError, "expected int argument");
 927                 break;
 928             }
 929
 930 #if PY_VERSION_HEX < 0x03000000
 931             if (PyInt_Check (number)) {
 932                 value = PyInt_AS_LONG (number);
 933             } else
 934 #endif
 935             value = PyLong_AsUnsignedLongLong (number);
 936
 937             if (type_tag == GI_TYPE_TAG_UINT32)
 938                 arg.v_uint32 = value;
 939             else if (type_tag == GI_TYPE_TAG_UINT64)
 940                 arg.v_uint64 = value;
 941             else if (type_tag == GI_TYPE_TAG_UINT8)
 942                 arg.v_uint8 = value;
 943             else if (type_tag == GI_TYPE_TAG_UINT16)
 944                 arg.v_uint16 = value;
 945
 946             Py_DECREF (number);
 947
 948             break;
 949         }
 950         case GI_TYPE_TAG_INT64:
 951         {
 952             PyObject *number;
 953             gint64 value;
 954
 955             number = PYGLIB_PyNumber_Long (object);
 956             if (number == NULL) {
 957                 PyErr_SetString (PyExc_TypeError, "expected int argument");
 958                 break;
 959             }
 960
 961 #if PY_VERSION_HEX < 0x03000000
 962             if (PyInt_Check (number)) {
 963                 value = PyInt_AS_LONG (number);
 964             } else
 965 #endif
 966             value = PyLong_AsLongLong (number);
 967
 968             arg.v_int64 = value;
 969
 970             Py_DECREF (number);
 971
 972             break;
 973         }
 974         case GI_TYPE_TAG_FLOAT:
 975         {
 976             PyObject *float_;
 977
 978             float_ = PyNumber_Float (object);
 979             if (float_ == NULL) {
 980                 PyErr_SetString (PyExc_TypeError, "expected float or int argument");
 981                 break;
 982             }
 983
 984             arg.v_float = (float) PyFloat_AsDouble (float_);
 985             Py_DECREF (float_);
 986
 987             break;
 988         }
 989         case GI_TYPE_TAG_DOUBLE:
 990         {
 991             PyObject *float_;
 992
 993             float_ = PyNumber_Float (object);
 994             if (float_ == NULL) {
 995                 PyErr_SetString (PyExc_TypeError, "expected float or int argument");
 996                 break;
 997             }
 998
 999             arg.v_double = PyFloat_AsDouble (float_);
1000             Py_DECREF (float_);
1001
1002             break;
1003         }
1004         case GI_TYPE_TAG_GTYPE:
1005         {
1006             arg.v_long = pyg_type_from_object (object);
1007
1008             break;
1009         }
1010         case GI_TYPE_TAG_UNICHAR:
1011         {
1012             gchar *string;
1013
1014             if (object == Py_None) {
1015                 arg.v_uint32 = 0;
1016                 break;
1017             }
1018
1019 #if PY_VERSION_HEX < 0x03000000
1020             if (PyUnicode_Check(object)) {
1021                  PyObject *pystr_obj = PyUnicode_AsUTF8String (object);
1022
1023                  if (!pystr_obj)
1024                      break;
1025
1026                  string = g_strdup(PyString_AsString (pystr_obj));
1027                  Py_DECREF(pystr_obj);
1028             } else {
1029                  string = g_strdup(PyString_AsString (object));
1030             }
1031 #else
1032             {
1033                 PyObject *pybytes_obj = PyUnicode_AsUTF8String (object);
1034                 if (!pybytes_obj)
1035                     break;
1036
1037                 string = g_strdup(PyBytes_AsString (pybytes_obj));
1038                 Py_DECREF (pybytes_obj);
1039             }
1040 #endif
1041
1042             arg.v_uint32 = g_utf8_get_char (string);
1043
1044             break;
1045         }
1046         case GI_TYPE_TAG_UTF8:
1047         {
1048             gchar *string;
1049
1050             if (object == Py_None) {
1051                 arg.v_string = NULL;
1052                 break;
1053             }
1054 #if PY_VERSION_HEX < 0x03000000
1055             if (PyUnicode_Check(object)) {
1056                  PyObject *pystr_obj = PyUnicode_AsUTF8String (object);
1057
1058                  if (!pystr_obj)
1059                      break;
1060
1061                  string = g_strdup(PyString_AsString (pystr_obj));
1062                  Py_DECREF(pystr_obj);
1063             } else {
1064                  string = g_strdup(PyString_AsString (object));
1065             }
1066 #else
1067             {
1068                 PyObject *pybytes_obj = PyUnicode_AsUTF8String (object);
1069                 if (!pybytes_obj)
1070                     break;
1071
1072                 string = g_strdup(PyBytes_AsString (pybytes_obj));
1073                 Py_DECREF (pybytes_obj);
1074             }
1075 #endif
1076             arg.v_string = string;
1077
1078             break;
1079         }
1080         case GI_TYPE_TAG_FILENAME:
1081         {
1082             GError *error = NULL;
1083             gchar *string;
1084
1085 #if PY_VERSION_HEX < 0x03000000
1086             string = g_strdup(PyString_AsString (object));
1087 #else
1088             {
1089                 PyObject *pybytes_obj = PyUnicode_AsUTF8String (object);
1090                 if (!pybytes_obj)
1091                     break;
1092
1093                 string = g_strdup(PyBytes_AsString (pybytes_obj));
1094                 Py_DECREF (pybytes_obj);
1095             }
1096 #endif
1097
1098             if (string == NULL) {
1099                 break;
1100             }
1101
1102             arg.v_string = g_filename_from_utf8 (string, -1, NULL, NULL, &error);
1103             g_free(string);
1104
1105             if (arg.v_string == NULL) {
1106                 PyErr_SetString (PyExc_Exception, error->message);
1107                 /* TODO: Convert the error to an exception. */
1108             }
1109
1110             break;
1111         }
1112         case GI_TYPE_TAG_ARRAY:
1113         {
1114             Py_ssize_t length;
1115             gboolean is_zero_terminated;
1116             GITypeInfo *item_type_info;
1117             gsize item_size;
1118             GArray *array;
1119             GITransfer item_transfer;
1120             Py_ssize_t i;
1121
1122             if (object == Py_None) {
1123                 arg.v_pointer = NULL;
1124                 break;
1125             }
1126
1127             /* Note, strings are sequences, but we cannot accept them here */
1128             if (!PySequence_Check (object) ||
1129 #if PY_VERSION_HEX < 0x03000000
1130                 PyString_Check (object) ||
1131 #endif
1132                 PyUnicode_Check (object)) {
1133                 PyErr_SetString (PyExc_TypeError, "expected sequence");
1134                 break;
1135             }
1136
1137             length = PySequence_Length (object);
1138             if (length < 0) {
1139                 break;
1140             }
1141
1142             is_zero_terminated = g_type_info_is_zero_terminated (type_info);
1143             item_type_info = g_type_info_get_param_type (type_info, 0);
1144
1145             /* we handle arrays that are really strings specially, see below */
1146             if (g_type_info_get_tag (item_type_info) == GI_TYPE_TAG_UINT8)
1147                item_size = 1;
1148             else
1149                item_size = sizeof (GIArgument);
1150
1151             array = g_array_sized_new (is_zero_terminated, FALSE, item_size, length);
1152             if (array == NULL) {
1153                 g_base_info_unref ( (GIBaseInfo *) item_type_info);
1154                 PyErr_NoMemory();
1155                 break;
1156             }
1157
1158             if (g_type_info_get_tag (item_type_info) == GI_TYPE_TAG_UINT8 &&
1159                 PYGLIB_PyBytes_Check(object)) {
1160
1161                 memcpy(array->data, PYGLIB_PyBytes_AsString(object), length);
1162                 array->len = length;
1163                 goto array_success;
1164             }
1165
1166
1167             item_transfer = transfer == GI_TRANSFER_CONTAINER ? GI_TRANSFER_NOTHING : transfer;
1168
1169             for (i = 0; i < length; i++) {
1170                 PyObject *py_item;
1171                 GIArgument item;
1172
1173                 py_item = PySequence_GetItem (object, i);
1174                 if (py_item == NULL) {
1175                     goto array_item_error;
1176                 }
1177
1178                 item = _pygi_argument_from_object (py_item, item_type_info, item_transfer);
1179
1180                 Py_DECREF (py_item);
1181
1182                 if (PyErr_Occurred()) {
1183                     goto array_item_error;
1184                 }
1185
1186                 g_array_insert_val (array, i, item);
1187                 continue;
1188
1189 array_item_error:
1190                 /* Free everything we have converted so far. */
1191                 _pygi_argument_release ( (GIArgument *) &array, type_info,
1192                                          GI_TRANSFER_NOTHING, GI_DIRECTION_IN);
1193                 array = NULL;
1194
1195                 _PyGI_ERROR_PREFIX ("Item %zd: ", i);
1196                 break;
1197             }
1198
1199 array_success:
1200             arg.v_pointer = array;
1201
1202             g_base_info_unref ( (GIBaseInfo *) item_type_info);
1203             break;
1204         }
1205         case GI_TYPE_TAG_INTERFACE:
1206         {
1207             GIBaseInfo *info;
1208             GIInfoType info_type;
1209
1210             info = g_type_info_get_interface (type_info);
1211             info_type = g_base_info_get_type (info);
1212
1213             switch (info_type) {
1214                 case GI_INFO_TYPE_CALLBACK:
1215                     /* This should be handled in invoke() */
1216                     g_assert_not_reached();
1217                     break;
1218                 case GI_INFO_TYPE_BOXED:
1219                 case GI_INFO_TYPE_STRUCT:
1220                 case GI_INFO_TYPE_UNION:
1221                 {
1222                     GType type;
1223
1224                     if (object == Py_None) {
1225                         arg.v_pointer = NULL;
1226                         break;
1227                     }
1228
1229                     type = g_registered_type_info_get_g_type ( (GIRegisteredTypeInfo *) info);
1230
1231                     /* Handle special cases first. */
1232                     if (g_type_is_a (type, G_TYPE_VALUE)) {
1233                         GValue *value;
1234                         GType object_type;
1235                         gint retval;
1236
1237                         object_type = pyg_type_from_object_strict ( (PyObject *) object->ob_type, FALSE);
1238                         if (object_type == G_TYPE_INVALID) {
1239                             PyErr_SetString (PyExc_RuntimeError, "unable to retrieve object's GType");
1240                             break;
1241                         }
1242
1243                         g_warn_if_fail (transfer == GI_TRANSFER_NOTHING);
1244
1245                         value = g_slice_new0 (GValue);
1246
1247                         /* if already a gvalue, copy, else marshal into gvalue */
1248                         if (object_type == G_TYPE_VALUE) {
1249                             /* src GValue's lifecycle is handled by Python
1250                              * so we have to copy it into the destination's
1251                              * GValue which is freed during the cleanup of
1252                              * invoke.
1253                              */
1254                             GValue *src = (GValue *)((PyGObject *) object)->obj;
1255                             g_value_init (value, G_VALUE_TYPE (src));
1256                             g_value_copy(src, value);
1257                         } else {
1258                             g_value_init (value, object_type);
1259                             retval = pyg_value_from_pyobject (value, object);
1260                             if (retval < 0) {
1261                                 g_slice_free (GValue, value);
1262                                 PyErr_SetString (PyExc_RuntimeError, "PyObject conversion to GValue failed");
1263                                 break;
1264                             }
1265                         }
1266
1267                         arg.v_pointer = value;
1268                     } else if (g_type_is_a (type, G_TYPE_CLOSURE)) {
1269                         GClosure *closure;
1270
1271                         if (pyg_type_from_object_strict (object, FALSE) == G_TYPE_CLOSURE) {
1272                             closure = (GClosure *)pyg_boxed_get (object, void);
1273                         } else {
1274                             closure = pyg_closure_new (object, NULL, NULL);
1275                             if (closure == NULL) {
1276                                 PyErr_SetString (PyExc_RuntimeError, "PyObject conversion to GClosure failed");
1277                                 break;
1278                             }
1279                         }
1280
1281                         arg.v_pointer = closure;
1282                     } else if (g_struct_info_is_foreign (info)) {
1283                         pygi_struct_foreign_convert_to_g_argument (object, info, transfer, &arg);
1284                     } else if (g_type_is_a (type, G_TYPE_BOXED)) {
1285                         if (pyg_boxed_check (object, type)) {
1286                             arg.v_pointer = pyg_boxed_get (object, void);
1287                             if (transfer == GI_TRANSFER_EVERYTHING) {
1288                                 arg.v_pointer = g_boxed_copy (type, arg.v_pointer);
1289                             }
1290                         } else {
1291                             PyErr_Format (PyExc_TypeError, "wrong boxed type");
1292                         }
1293                     } else if (g_type_is_a (type, G_TYPE_POINTER) ||
1294                                g_type_is_a (type, G_TYPE_VARIANT) ||
1295                                type == G_TYPE_NONE) {
1296                         g_warn_if_fail (g_type_is_a (type, G_TYPE_VARIANT) || !g_type_info_is_pointer (type_info) || transfer == GI_TRANSFER_NOTHING);
1297
1298                         if (g_type_is_a (type, G_TYPE_VARIANT) && pyg_type_from_object (object) != G_TYPE_VARIANT) {
1299                             PyErr_SetString (PyExc_TypeError, "expected GLib.Variant");
1300                             break;
1301                         }
1302                         arg.v_pointer = pyg_pointer_get (object, void);
1303                     } else {
1304                         PyErr_Format (PyExc_NotImplementedError, "structure type '%s' is not supported yet", g_type_name (type));
1305                     }
1306
1307                     break;
1308                 }
1309                 case GI_INFO_TYPE_ENUM:
1310                 case GI_INFO_TYPE_FLAGS:
1311                 {
1312                     PyObject *int_;
1313
1314                     int_ = PYGLIB_PyNumber_Long (object);
1315                     if (int_ == NULL) {
1316                         break;
1317                     }
1318
1319                     arg.v_int = PYGLIB_PyLong_AsLong (int_);
1320
1321                     Py_DECREF (int_);
1322
1323                     break;
1324                 }
1325                 case GI_INFO_TYPE_INTERFACE:
1326                 case GI_INFO_TYPE_OBJECT:
1327                     if (object == Py_None) {
1328                         arg.v_pointer = NULL;
1329                         break;
1330                     }
1331
1332                     arg.v_pointer = pygobject_get (object);
1333                     if (transfer == GI_TRANSFER_EVERYTHING) {
1334                         g_object_ref (arg.v_pointer);
1335                     }
1336
1337                     break;
1338                 default:
1339                     g_assert_not_reached();
1340             }
1341             g_base_info_unref (info);
1342             break;
1343         }
1344         case GI_TYPE_TAG_GLIST:
1345         case GI_TYPE_TAG_GSLIST:
1346         {
1347             Py_ssize_t length;
1348             GITypeInfo *item_type_info;
1349             GSList *list = NULL;
1350             GITransfer item_transfer;
1351             Py_ssize_t i;
1352
1353             if (object == Py_None) {
1354                 arg.v_pointer = NULL;
1355                 break;
1356             }
1357
1358             length = PySequence_Length (object);
1359             if (length < 0) {
1360                 break;
1361             }
1362
1363             item_type_info = g_type_info_get_param_type (type_info, 0);
1364             g_assert (item_type_info != NULL);
1365
1366             item_transfer = transfer == GI_TRANSFER_CONTAINER ? GI_TRANSFER_NOTHING : transfer;
1367
1368             for (i = length - 1; i >= 0; i--) {
1369                 PyObject *py_item;
1370                 GIArgument item;
1371
1372                 py_item = PySequence_GetItem (object, i);
1373                 if (py_item == NULL) {
1374                     goto list_item_error;
1375                 }
1376
1377                 item = _pygi_argument_from_object (py_item, item_type_info, item_transfer);
1378
1379                 Py_DECREF (py_item);
1380
1381                 if (PyErr_Occurred()) {
1382                     goto list_item_error;
1383                 }
1384
1385                 if (type_tag == GI_TYPE_TAG_GLIST) {
1386                     list = (GSList *) g_list_prepend ( (GList *) list, item.v_pointer);
1387                 } else {
1388                     list = g_slist_prepend (list, item.v_pointer);
1389                 }
1390
1391                 continue;
1392
1393 list_item_error:
1394                 /* Free everything we have converted so far. */
1395                 _pygi_argument_release ( (GIArgument *) &list, type_info,
1396                                          GI_TRANSFER_NOTHING, GI_DIRECTION_IN);
1397                 list = NULL;
1398
1399                 _PyGI_ERROR_PREFIX ("Item %zd: ", i);
1400                 break;
1401             }
1402
1403             arg.v_pointer = list;
1404
1405             g_base_info_unref ( (GIBaseInfo *) item_type_info);
1406
1407             break;
1408         }
1409         case GI_TYPE_TAG_GHASH:
1410         {
1411             Py_ssize_t length;
1412             PyObject *keys;
1413             PyObject *values;
1414             GITypeInfo *key_type_info;
1415             GITypeInfo *value_type_info;
1416             GITypeTag key_type_tag;
1417             GHashFunc hash_func;
1418             GEqualFunc equal_func;
1419             GHashTable *hash_table;
1420             GITransfer item_transfer;
1421             Py_ssize_t i;
1422
1423
1424             if (object == Py_None) {
1425                 arg.v_pointer = NULL;
1426                 break;
1427             }
1428
1429             length = PyMapping_Length (object);
1430             if (length < 0) {
1431                 break;
1432             }
1433
1434             keys = PyMapping_Keys (object);
1435             if (keys == NULL) {
1436                 break;
1437             }
1438
1439             values = PyMapping_Values (object);
1440             if (values == NULL) {
1441                 Py_DECREF (keys);
1442                 break;
1443             }
1444
1445             key_type_info = g_type_info_get_param_type (type_info, 0);
1446             g_assert (key_type_info != NULL);
1447
1448             value_type_info = g_type_info_get_param_type (type_info, 1);
1449             g_assert (value_type_info != NULL);
1450
1451             key_type_tag = g_type_info_get_tag (key_type_info);
1452
1453             switch (key_type_tag) {
1454                 case GI_TYPE_TAG_UTF8:
1455                 case GI_TYPE_TAG_FILENAME:
1456                     hash_func = g_str_hash;
1457                     equal_func = g_str_equal;
1458                     break;
1459                 default:
1460                     hash_func = NULL;
1461                     equal_func = NULL;
1462             }
1463
1464             hash_table = g_hash_table_new (hash_func, equal_func);
1465             if (hash_table == NULL) {
1466                 PyErr_NoMemory();
1467                 goto hash_table_release;
1468             }
1469
1470             item_transfer = transfer == GI_TRANSFER_CONTAINER ? GI_TRANSFER_NOTHING : transfer;
1471
1472             for (i = 0; i < length; i++) {
1473                 PyObject *py_key;
1474                 PyObject *py_value;
1475                 GIArgument key;
1476                 GIArgument value;
1477
1478                 py_key = PyList_GET_ITEM (keys, i);
1479                 py_value = PyList_GET_ITEM (values, i);
1480
1481                 key = _pygi_argument_from_object (py_key, key_type_info, item_transfer);
1482                 if (PyErr_Occurred()) {
1483                     goto hash_table_item_error;
1484                 }
1485
1486                 value = _pygi_argument_from_object (py_value, value_type_info, item_transfer);
1487                 if (PyErr_Occurred()) {
1488                     _pygi_argument_release (&key, type_info, GI_TRANSFER_NOTHING, GI_DIRECTION_IN);
1489                     goto hash_table_item_error;
1490                 }
1491
1492                 g_hash_table_insert (hash_table, key.v_pointer,
1493                                      _pygi_arg_to_hash_pointer (&value, g_type_info_get_tag (value_type_info)));
1494                 continue;
1495
1496 hash_table_item_error:
1497                 /* Free everything we have converted so far. */
1498                 _pygi_argument_release ( (GIArgument *) &hash_table, type_info,
1499                                          GI_TRANSFER_NOTHING, GI_DIRECTION_IN);
1500                 hash_table = NULL;
1501
1502                 _PyGI_ERROR_PREFIX ("Item %zd: ", i);
1503                 break;
1504             }
1505
1506             arg.v_pointer = hash_table;
1507
1508 hash_table_release:
1509             g_base_info_unref ( (GIBaseInfo *) key_type_info);
1510             g_base_info_unref ( (GIBaseInfo *) value_type_info);
1511             Py_DECREF (keys);
1512             Py_DECREF (values);
1513             break;
1514         }
1515         case GI_TYPE_TAG_ERROR:
1516             PyErr_SetString (PyExc_NotImplementedError, "error marshalling is not supported yet");
1517             /* TODO */
1518             break;
1519     }
1520
1521     return arg;
1522 }
1523
1524 /**
1525  * _pygi_argument_to_object:
1526  * @arg: The argument to convert to an object.
1527  * @type_info: Type info for @arg
1528  * @transfer:
1529  *
1530  * If the argument is of type array, it must be encoded in a GArray, by calling
1531  * _pygi_argument_to_array(). This logic can not be folded into this method
1532  * as determining array lengths may require access to method call arguments.
1533  *
1534  * Returns: A PyObject representing @arg
1535  */
1536 PyObject *
1537 _pygi_argument_to_object (GIArgument  *arg,
1538                           GITypeInfo *type_info,
1539                           GITransfer transfer)
1540 {
1541     GITypeTag type_tag;
1542     PyObject *object = NULL;
1543
1544     type_tag = g_type_info_get_tag (type_info);
1545     switch (type_tag) {
1546         case GI_TYPE_TAG_VOID:
1547         {
1548             if (g_type_info_is_pointer (type_info) &&
1549                     (arg->v_pointer != NULL)) {
1550                 g_warn_if_fail (transfer == GI_TRANSFER_NOTHING);
1551                 object = PyLong_FromVoidPtr (arg->v_pointer);
1552             } else {
1553                 /* None is used instead of zero for parity with ctypes.
1554                  * This is helpful in case the values are being used for
1555                  * actual memory addressing, in which case None will
1556                  * raise as opposed to 0 which will crash.
1557                  */
1558                 object = Py_None;
1559                 Py_INCREF (object);
1560             }
1561             break;
1562         }
1563         case GI_TYPE_TAG_BOOLEAN:
1564         {
1565             object = PyBool_FromLong (arg->v_boolean);
1566             break;
1567         }
1568         case GI_TYPE_TAG_INT8:
1569         {
1570             object = PYGLIB_PyLong_FromLong (arg->v_int8);
1571             break;
1572         }
1573         case GI_TYPE_TAG_UINT8:
1574         {
1575             object = PYGLIB_PyLong_FromLong (arg->v_uint8);
1576             break;
1577         }
1578         case GI_TYPE_TAG_INT16:
1579         {
1580             object = PYGLIB_PyLong_FromLong (arg->v_int16);
1581             break;
1582         }
1583         case GI_TYPE_TAG_UINT16:
1584         {
1585             object = PYGLIB_PyLong_FromLong (arg->v_uint16);
1586             break;
1587         }
1588         case GI_TYPE_TAG_INT32:
1589         {
1590             object = PYGLIB_PyLong_FromLong (arg->v_int32);
1591             break;
1592         }
1593         case GI_TYPE_TAG_UINT32:
1594         {
1595             object = PyLong_FromLongLong (arg->v_uint32);
1596             break;
1597         }
1598         case GI_TYPE_TAG_INT64:
1599         {
1600             object = PyLong_FromLongLong (arg->v_int64);
1601             break;
1602         }
1603         case GI_TYPE_TAG_UINT64:
1604         {
1605             object = PyLong_FromUnsignedLongLong (arg->v_uint64);
1606             break;
1607         }
1608         case GI_TYPE_TAG_FLOAT:
1609         {
1610             object = PyFloat_FromDouble (arg->v_float);
1611             break;
1612         }
1613         case GI_TYPE_TAG_DOUBLE:
1614         {
1615             object = PyFloat_FromDouble (arg->v_double);
1616             break;
1617         }
1618         case GI_TYPE_TAG_GTYPE:
1619         {
1620             object = pyg_type_wrapper_new ( (GType) arg->v_long);
1621             break;
1622         }
1623         case GI_TYPE_TAG_UNICHAR:
1624         {
1625             /* Preserve the bidirectional mapping between 0 and "" */
1626             if (arg->v_uint32 == 0) {
1627                 object = PYGLIB_PyUnicode_FromString ("");
1628             } else if (g_unichar_validate (arg->v_uint32)) {
1629                 gchar utf8[6];
1630                 gint bytes;
1631
1632                 bytes = g_unichar_to_utf8 (arg->v_uint32, utf8);
1633                 object = PYGLIB_PyUnicode_FromStringAndSize ((char*)utf8, bytes);
1634             } else {
1635                 /* TODO: Convert the error to an exception. */
1636                 PyErr_Format (PyExc_TypeError,
1637                               "Invalid unicode codepoint %" G_GUINT32_FORMAT,
1638                               arg->v_uint32);
1639                 object = Py_None;
1640                 Py_INCREF (object);
1641             }
1642             break;
1643         }
1644         case GI_TYPE_TAG_UTF8:
1645             if (arg->v_string == NULL) {
1646                 object = Py_None;
1647                 Py_INCREF (object);
1648                 break;
1649             }
1650
1651             object = PYGLIB_PyUnicode_FromString (arg->v_string);
1652             break;
1653         case GI_TYPE_TAG_FILENAME:
1654         {
1655             GError *error = NULL;
1656             gchar *string;
1657
1658             if (arg->v_string == NULL) {
1659                 object = Py_None;
1660                 Py_INCREF (object);
1661                 break;
1662             }
1663
1664             string = g_filename_to_utf8 (arg->v_string, -1, NULL, NULL, &error);
1665             if (string == NULL) {
1666                 PyErr_SetString (PyExc_Exception, error->message);
1667                 /* TODO: Convert the error to an exception. */
1668                 break;
1669             }
1670
1671             object = PYGLIB_PyUnicode_FromString (string);
1672
1673             g_free (string);
1674
1675             break;
1676         }
1677         case GI_TYPE_TAG_ARRAY:
1678         {
1679             /* Arrays are assumed to be packed in a GArray */
1680             GArray *array;
1681             GITypeInfo *item_type_info;
1682             GITypeTag item_type_tag;
1683             GITransfer item_transfer;
1684             gsize i, item_size;
1685
1686             if (arg->v_pointer == NULL)
1687                 return PyList_New (0);
1688
1689             item_type_info = g_type_info_get_param_type (type_info, 0);
1690             g_assert (item_type_info != NULL);
1691
1692             item_type_tag = g_type_info_get_tag (item_type_info);
1693             item_transfer = transfer == GI_TRANSFER_CONTAINER ? GI_TRANSFER_NOTHING : transfer;
1694
1695             array = arg->v_pointer;
1696             item_size = g_array_get_element_size (array);
1697
1698             if (G_UNLIKELY (item_size > sizeof(GIArgument))) {
1699                 g_critical ("Stack overflow protection. "
1700                             "Can't copy array element into GIArgument.");
1701                 return PyList_New (0);
1702             }
1703
1704             if (item_type_tag == GI_TYPE_TAG_UINT8) {
1705                 /* Return as a byte array */
1706                 object = PYGLIB_PyBytes_FromStringAndSize (array->data, array->len);
1707             } else {
1708                 object = PyList_New (array->len);
1709                 if (object == NULL) {
1710                     g_critical ("Failure to allocate array for %u items", array->len);
1711                     g_base_info_unref ( (GIBaseInfo *) item_type_info);
1712                     break;
1713                 }
1714
1715                 for (i = 0; i < array->len; i++) {
1716                     GIArgument item = { 0 };
1717                     PyObject *py_item;
1718
1719                     memcpy (&item, array->data + i * item_size, item_size);
1720
1721                     py_item = _pygi_argument_to_object (&item, item_type_info, item_transfer);
1722                     if (py_item == NULL) {
1723                         Py_CLEAR (object);
1724                         _PyGI_ERROR_PREFIX ("Item %zu: ", i);
1725                         break;
1726                     }
1727
1728                     PyList_SET_ITEM (object, i, py_item);
1729                 }
1730             }
1731
1732             g_base_info_unref ( (GIBaseInfo *) item_type_info);
1733             break;
1734         }
1735         case GI_TYPE_TAG_INTERFACE:
1736         {
1737             GIBaseInfo *info;
1738             GIInfoType info_type;
1739
1740             info = g_type_info_get_interface (type_info);
1741             info_type = g_base_info_get_type (info);
1742
1743             switch (info_type) {
1744                 case GI_INFO_TYPE_CALLBACK:
1745                 {
1746                     g_assert_not_reached();
1747                 }
1748                 case GI_INFO_TYPE_BOXED:
1749                 case GI_INFO_TYPE_STRUCT:
1750                 case GI_INFO_TYPE_UNION:
1751                 {
1752                     GType type;
1753
1754                     if (arg->v_pointer == NULL) {
1755                         object = Py_None;
1756                         Py_INCREF (object);
1757                         break;
1758                     }
1759
1760                     type = g_registered_type_info_get_g_type ( (GIRegisteredTypeInfo *) info);
1761                     if (g_type_is_a (type, G_TYPE_VALUE)) {
1762                         object = pyg_value_as_pyobject (arg->v_pointer, FALSE);
1763                     } else if (g_struct_info_is_foreign (info)) {
1764                         object = pygi_struct_foreign_convert_from_g_argument (info, arg->v_pointer);
1765                     } else if (g_type_is_a (type, G_TYPE_BOXED)) {
1766                         PyObject *py_type;
1767
1768                         py_type = _pygi_type_get_from_g_type (type);
1769                         if (py_type == NULL)
1770                             break;
1771
1772                         object = _pygi_boxed_new ( (PyTypeObject *) py_type, arg->v_pointer, transfer == GI_TRANSFER_EVERYTHING);
1773
1774                         Py_DECREF (py_type);
1775                     } else if (g_type_is_a (type, G_TYPE_POINTER)) {
1776                         PyObject *py_type;
1777
1778                         py_type = _pygi_type_get_from_g_type (type);
1779
1780                         if (py_type == NULL || !PyType_IsSubtype ( (PyTypeObject *) type, &PyGIStruct_Type)) {
1781                             g_warn_if_fail (transfer == GI_TRANSFER_NOTHING);
1782                             object = pyg_pointer_new (type, arg->v_pointer);
1783                         } else {
1784                             object = _pygi_struct_new ( (PyTypeObject *) py_type, arg->v_pointer, transfer == GI_TRANSFER_EVERYTHING);
1785                         }
1786
1787                         Py_XDECREF (py_type);
1788                     } else if (type == G_TYPE_VARIANT) {
1789                         PyObject *py_type;
1790
1791                         g_variant_ref_sink (arg->v_pointer);
1792                         py_type = _pygi_type_import_by_gi_info (info);
1793                         object = _pygi_struct_new ( (PyTypeObject *) py_type, arg->v_pointer,
1794                                                     transfer == GI_TRANSFER_EVERYTHING);
1795                     } else if (type == G_TYPE_NONE) {
1796                         PyObject *py_type;
1797
1798                         py_type = _pygi_type_import_by_gi_info (info);
1799                         if (py_type == NULL) {
1800                             break;
1801                         }
1802
1803                         /* Only structs created in invoke can be safely marked
1804                          * GI_TRANSFER_EVERYTHING. Trust that invoke has
1805                          * filtered correctly
1806                          */
1807                         object = _pygi_struct_new ( (PyTypeObject *) py_type, arg->v_pointer,
1808                                                     transfer == GI_TRANSFER_EVERYTHING);
1809
1810                         Py_DECREF (py_type);
1811                     } else {
1812                         PyErr_Format (PyExc_NotImplementedError, "structure type '%s' is not supported yet", g_type_name (type));
1813                     }
1814
1815                     break;
1816                 }
1817                 case GI_INFO_TYPE_ENUM:
1818                 case GI_INFO_TYPE_FLAGS:
1819                 {
1820                     GType type;
1821
1822                     type = g_registered_type_info_get_g_type ( (GIRegisteredTypeInfo *) info);
1823
1824                     if (type == G_TYPE_NONE) {
1825                         /* An enum with a GType of None is an enum without GType */
1826                         PyObject *py_type = _pygi_type_import_by_gi_info (info);
1827                         PyObject *py_args = NULL;
1828
1829                         if (!py_type)
1830                             return NULL;
1831
1832                         py_args = PyTuple_New (1);
1833                         if (PyTuple_SetItem (py_args, 0, PyLong_FromLong (arg->v_int)) != 0) {
1834                             Py_DECREF (py_args);
1835                             Py_DECREF (py_type);
1836                             return NULL;
1837                         }
1838
1839                         object = PyObject_CallFunction (py_type, "i", arg->v_int);
1840
1841                         Py_DECREF (py_args);
1842                         Py_DECREF (py_type);
1843
1844                     } else if (info_type == GI_INFO_TYPE_ENUM) {
1845                         object = pyg_enum_from_gtype (type, arg->v_int);
1846                     } else {
1847                         object = pyg_flags_from_gtype (type, arg->v_int);
1848                     }
1849
1850                     break;
1851                 }
1852                 case GI_INFO_TYPE_INTERFACE:
1853                 case GI_INFO_TYPE_OBJECT:
1854                     if (arg->v_pointer == NULL) {
1855                         object = Py_None;
1856                         Py_INCREF (object);
1857                         break;
1858                     }
1859
1860                     if (G_IS_PARAM_SPEC (arg->v_pointer)) {
1861                       object = pyg_param_spec_new (arg->v_pointer);
1862                       break;
1863                     }
1864
1865                     /* since we will unref the object when the
1866                      * wrapper is destroyed and we don't want
1867                      * GTK removing the object while the
1868                      * wrapper is live, we take a gobject reference
1869                      * when one is not transfered to us
1870                      */
1871                     if (transfer == GI_TRANSFER_NOTHING)
1872                         g_object_ref (G_OBJECT(arg->v_pointer));
1873
1874                     object = pygobject_new (arg->v_pointer);
1875                     break;
1876                 default:
1877                     g_assert_not_reached();
1878             }
1879
1880             g_base_info_unref (info);
1881             break;
1882         }
1883         case GI_TYPE_TAG_GLIST:
1884         case GI_TYPE_TAG_GSLIST:
1885         {
1886             GSList *list;
1887             gsize length;
1888             GITypeInfo *item_type_info;
1889             GITransfer item_transfer;
1890             gsize i;
1891
1892             list = arg->v_pointer;
1893             length = g_slist_length (list);
1894
1895             object = PyList_New (length);
1896             if (object == NULL) {
1897                 break;
1898             }
1899
1900             item_type_info = g_type_info_get_param_type (type_info, 0);
1901             g_assert (item_type_info != NULL);
1902
1903             item_transfer = transfer == GI_TRANSFER_CONTAINER ? GI_TRANSFER_NOTHING : transfer;
1904
1905             for (i = 0; list != NULL; list = g_slist_next (list), i++) {
1906                 GIArgument item;
1907                 PyObject *py_item;
1908
1909                 item.v_pointer = list->data;
1910
1911                 py_item = _pygi_argument_to_object (&item, item_type_info, item_transfer);
1912                 if (py_item == NULL) {
1913                     Py_CLEAR (object);
1914                     _PyGI_ERROR_PREFIX ("Item %zu: ", i);
1915                     break;
1916                 }
1917
1918                 PyList_SET_ITEM (object, i, py_item);
1919             }
1920
1921             g_base_info_unref ( (GIBaseInfo *) item_type_info);
1922             break;
1923         }
1924         case GI_TYPE_TAG_GHASH:
1925         {
1926             GITypeInfo *key_type_info;
1927             GITypeInfo *value_type_info;
1928             GITransfer item_transfer;
1929             GHashTableIter hash_table_iter;
1930             GIArgument key;
1931             GIArgument value;
1932
1933             if (arg->v_pointer == NULL) {
1934                 object = Py_None;
1935                 Py_INCREF (object);
1936                 break;
1937             }
1938
1939             object = PyDict_New();
1940             if (object == NULL) {
1941                 break;
1942             }
1943
1944             key_type_info = g_type_info_get_param_type (type_info, 0);
1945             g_assert (key_type_info != NULL);
1946             g_assert (g_type_info_get_tag (key_type_info) != GI_TYPE_TAG_VOID);
1947
1948             value_type_info = g_type_info_get_param_type (type_info, 1);
1949             g_assert (value_type_info != NULL);
1950             g_assert (g_type_info_get_tag (value_type_info) != GI_TYPE_TAG_VOID);
1951
1952             item_transfer = transfer == GI_TRANSFER_CONTAINER ? GI_TRANSFER_NOTHING : transfer;
1953
1954             g_hash_table_iter_init (&hash_table_iter, (GHashTable *) arg->v_pointer);
1955             while (g_hash_table_iter_next (&hash_table_iter, &key.v_pointer, &value.v_pointer)) {
1956                 PyObject *py_key;
1957                 PyObject *py_value;
1958                 int retval;
1959
1960                 py_key = _pygi_argument_to_object (&key, key_type_info, item_transfer);
1961                 if (py_key == NULL) {
1962                     break;
1963                 }
1964
1965                 _pygi_hash_pointer_to_arg (&value, g_type_info_get_tag (value_type_info));
1966                 py_value = _pygi_argument_to_object (&value, value_type_info, item_transfer);
1967                 if (py_value == NULL) {
1968                     Py_DECREF (py_key);
1969                     break;
1970                 }
1971
1972                 retval = PyDict_SetItem (object, py_key, py_value);
1973
1974                 Py_DECREF (py_key);
1975                 Py_DECREF (py_value);
1976
1977                 if (retval < 0) {
1978                     Py_CLEAR (object);
1979                     break;
1980                 }
1981             }
1982
1983             g_base_info_unref ( (GIBaseInfo *) key_type_info);
1984             g_base_info_unref ( (GIBaseInfo *) value_type_info);
1985             break;
1986         }
1987         case GI_TYPE_TAG_ERROR:
1988         {
1989             GError *error = (GError *) arg->v_pointer;
1990             if (error != NULL && transfer == GI_TRANSFER_NOTHING) {
1991                 /* If we have not been transferred the ownership we must copy
1992                  * the error, because pyglib_error_check() is going to free it.
1993                  */
1994                 error = g_error_copy (error);
1995             }
1996
1997             if (pyglib_error_check (&error)) {
1998                 PyObject *err_type;
1999                 PyObject *err_value;
2000                 PyObject *err_trace;
2001                 PyErr_Fetch (&err_type, &err_value, &err_trace);
2002                 Py_XDECREF (err_type);
2003                 Py_XDECREF (err_trace);
2004                 object = err_value;
2005             } else {
2006                 object = Py_None;
2007                 Py_INCREF (object);
2008                 break;
2009             }
2010         }
2011     }
2012
2013     return object;
2014 }
2015
2016
2017 GIArgument
2018 _pygi_argument_from_g_value(const GValue *value,
2019                             GITypeInfo *type_info)
2020 {
2021     GIArgument arg = { 0, };
2022
2023     GITypeTag type_tag = g_type_info_get_tag (type_info);
2024
2025     /* For the long handling: long can be equivalent to
2026        int32 or int64, depending on the architecture, but
2027        gi doesn't tell us (and same for ulong)
2028     */
2029     switch (type_tag) {
2030         case GI_TYPE_TAG_BOOLEAN:
2031             arg.v_boolean = g_value_get_boolean (value);
2032             break;
2033         case GI_TYPE_TAG_INT8:
2034         case GI_TYPE_TAG_INT16:
2035         case GI_TYPE_TAG_INT32:
2036             if (g_type_is_a (G_VALUE_TYPE (value), G_TYPE_LONG))
2037                 arg.v_int = g_value_get_long (value);
2038             else
2039                 arg.v_int = g_value_get_int (value);
2040             break;
2041         case GI_TYPE_TAG_INT64:
2042             if (g_type_is_a (G_VALUE_TYPE (value), G_TYPE_LONG))
2043                 arg.v_int64 = g_value_get_long (value);
2044             else
2045                 arg.v_int64 = g_value_get_int64 (value);
2046             break;
2047         case GI_TYPE_TAG_UINT8:
2048         case GI_TYPE_TAG_UINT16:
2049         case GI_TYPE_TAG_UINT32:
2050             if (g_type_is_a (G_VALUE_TYPE (value), G_TYPE_ULONG))
2051                 arg.v_uint = g_value_get_ulong (value);
2052             else
2053                 arg.v_uint = g_value_get_uint (value);
2054             break;
2055         case GI_TYPE_TAG_UINT64:
2056             if (g_type_is_a (G_VALUE_TYPE (value), G_TYPE_ULONG))
2057                 arg.v_uint64 = g_value_get_ulong (value);
2058             else
2059                 arg.v_uint64 = g_value_get_uint64 (value);
2060             break;
2061         case GI_TYPE_TAG_UNICHAR:
2062             arg.v_uint32 = g_value_get_schar (value);
2063             break;
2064         case GI_TYPE_TAG_FLOAT:
2065             arg.v_float = g_value_get_float (value);
2066             break;
2067         case GI_TYPE_TAG_DOUBLE:
2068             arg.v_double = g_value_get_double (value);
2069             break;
2070         case GI_TYPE_TAG_GTYPE:
2071             arg.v_long = g_value_get_gtype (value);
2072             break;
2073         case GI_TYPE_TAG_UTF8:
2074         case GI_TYPE_TAG_FILENAME:
2075             arg.v_string = g_value_dup_string (value);
2076             break;
2077         case GI_TYPE_TAG_GLIST:
2078         case GI_TYPE_TAG_GSLIST:
2079             arg.v_pointer = g_value_get_pointer (value);
2080             break;
2081         case GI_TYPE_TAG_ARRAY:
2082         case GI_TYPE_TAG_GHASH:
2083             arg.v_pointer = g_value_get_boxed (value);
2084             break;
2085         case GI_TYPE_TAG_INTERFACE:
2086         {
2087             GIBaseInfo *info;
2088             GIInfoType info_type;
2089
2090             info = g_type_info_get_interface (type_info);
2091             info_type = g_base_info_get_type (info);
2092
2093             g_base_info_unref (info);
2094
2095             switch (info_type) {
2096                 case GI_INFO_TYPE_FLAGS:
2097                     arg.v_long = g_value_get_flags (value);
2098                     break;
2099                 case GI_INFO_TYPE_ENUM:
2100                     arg.v_long = g_value_get_enum (value);
2101                     break;
2102                 case GI_INFO_TYPE_INTERFACE:
2103                 case GI_INFO_TYPE_OBJECT:
2104                     if (G_VALUE_HOLDS_PARAM (value))
2105                       arg.v_pointer = g_value_get_param (value);
2106                     else
2107                       arg.v_pointer = g_value_get_object (value);
2108                     break;
2109                 case GI_INFO_TYPE_BOXED:
2110                 case GI_INFO_TYPE_STRUCT:
2111                 case GI_INFO_TYPE_UNION:
2112                     if (G_VALUE_HOLDS(value, G_TYPE_BOXED)) {
2113                         arg.v_pointer = g_value_get_boxed (value);
2114                     } else if (G_VALUE_HOLDS(value, G_TYPE_VARIANT)) {
2115                         arg.v_pointer = g_value_get_variant (value);
2116                     } else {
2117                         arg.v_pointer = g_value_get_pointer (value);
2118                     }
2119                     break;
2120                 default:
2121                     g_warning("Converting of type '%s' is not implemented", g_info_type_to_string(info_type));
2122                     g_assert_not_reached();
2123             }
2124             break;
2125         }
2126         case GI_TYPE_TAG_ERROR:
2127             arg.v_pointer = g_value_get_boxed (value);
2128             break;
2129         case GI_TYPE_TAG_VOID:
2130             g_critical("Converting of type '%s' is not implemented", g_type_tag_to_string(type_tag));
2131             g_assert_not_reached();
2132     }
2133
2134     return arg;
2135 }
2136
2137 void
2138 _pygi_argument_release (GIArgument   *arg,
2139                         GITypeInfo  *type_info,
2140                         GITransfer   transfer,
2141                         GIDirection  direction)
2142 {
2143     GITypeTag type_tag;
2144     gboolean is_out = (direction == GI_DIRECTION_OUT || direction == GI_DIRECTION_INOUT);
2145
2146     type_tag = g_type_info_get_tag (type_info);
2147
2148     switch (type_tag) {
2149         case GI_TYPE_TAG_VOID:
2150             /* Don't do anything, it's transparent to the C side */
2151             break;
2152         case GI_TYPE_TAG_BOOLEAN:
2153         case GI_TYPE_TAG_INT8:
2154         case GI_TYPE_TAG_UINT8:
2155         case GI_TYPE_TAG_INT16:
2156         case GI_TYPE_TAG_UINT16:
2157         case GI_TYPE_TAG_INT32:
2158         case GI_TYPE_TAG_UINT32:
2159         case GI_TYPE_TAG_INT64:
2160         case GI_TYPE_TAG_UINT64:
2161         case GI_TYPE_TAG_FLOAT:
2162         case GI_TYPE_TAG_DOUBLE:
2163         case GI_TYPE_TAG_GTYPE:
2164         case GI_TYPE_TAG_UNICHAR:
2165             break;
2166         case GI_TYPE_TAG_FILENAME:
2167         case GI_TYPE_TAG_UTF8:
2168             /* With allow-none support the string could be NULL */
2169             if ((arg->v_string != NULL &&
2170                     (direction == GI_DIRECTION_IN && transfer == GI_TRANSFER_NOTHING))
2171                     || (direction == GI_DIRECTION_OUT && transfer == GI_TRANSFER_EVERYTHING)) {
2172                 g_free (arg->v_string);
2173             }
2174             break;
2175         case GI_TYPE_TAG_ARRAY:
2176         {
2177             GArray *array;
2178             gsize i;
2179
2180             if (arg->v_pointer == NULL) {
2181                 return;
2182             }
2183
2184             array = arg->v_pointer;
2185
2186             if ( (direction == GI_DIRECTION_IN && transfer != GI_TRANSFER_EVERYTHING)
2187                     || (direction == GI_DIRECTION_OUT && transfer == GI_TRANSFER_EVERYTHING)) {
2188                 GITypeInfo *item_type_info;
2189                 GITransfer item_transfer;
2190
2191                 item_type_info = g_type_info_get_param_type (type_info, 0);
2192
2193                 item_transfer = direction == GI_DIRECTION_IN ? GI_TRANSFER_NOTHING : GI_TRANSFER_EVERYTHING;
2194
2195                 /* Free the items */
2196                 for (i = 0; i < array->len; i++) {
2197                     GIArgument *item;
2198                     item = &_g_array_index (array, GIArgument, i);
2199                     _pygi_argument_release (item, item_type_info, item_transfer, direction);
2200                 }
2201
2202                 g_base_info_unref ( (GIBaseInfo *) item_type_info);
2203             }
2204
2205             if ( (direction == GI_DIRECTION_IN && transfer == GI_TRANSFER_NOTHING)
2206                     || (direction == GI_DIRECTION_OUT && transfer != GI_TRANSFER_NOTHING)) {
2207                 g_array_free (array, TRUE);
2208             }
2209
2210             break;
2211         }
2212         case GI_TYPE_TAG_INTERFACE:
2213         {
2214             GIBaseInfo *info;
2215             GIInfoType info_type;
2216
2217             info = g_type_info_get_interface (type_info);
2218             info_type = g_base_info_get_type (info);
2219
2220             switch (info_type) {
2221                 case GI_INFO_TYPE_CALLBACK:
2222                     /* TODO */
2223                     break;
2224                 case GI_INFO_TYPE_BOXED:
2225                 case GI_INFO_TYPE_STRUCT:
2226                 case GI_INFO_TYPE_UNION:
2227                 {
2228                     GType type;
2229
2230                     if (arg->v_pointer == NULL) {
2231                         return;
2232                     }
2233
2234                     type = g_registered_type_info_get_g_type ( (GIRegisteredTypeInfo *) info);
2235
2236                     if (g_type_is_a (type, G_TYPE_VALUE)) {
2237                         GValue *value;
2238
2239                         value = arg->v_pointer;
2240
2241                         if ( (direction == GI_DIRECTION_IN && transfer != GI_TRANSFER_EVERYTHING)
2242                                 || (direction == GI_DIRECTION_OUT && transfer == GI_TRANSFER_EVERYTHING)) {
2243                             g_value_unset (value);
2244                         }
2245
2246                         if ( (direction == GI_DIRECTION_IN && transfer == GI_TRANSFER_NOTHING)
2247                                 || (direction == GI_DIRECTION_OUT && transfer != GI_TRANSFER_NOTHING)) {
2248                             g_slice_free (GValue, value);
2249                         }
2250                     } else if (g_type_is_a (type, G_TYPE_CLOSURE)) {
2251                         if (direction == GI_DIRECTION_IN && transfer == GI_TRANSFER_NOTHING) {
2252                             g_closure_unref (arg->v_pointer);
2253                         }
2254                     } else if (g_struct_info_is_foreign ( (GIStructInfo*) info)) {
2255                         if (direction == GI_DIRECTION_OUT && transfer == GI_TRANSFER_EVERYTHING) {
2256                             pygi_struct_foreign_release (info, arg->v_pointer);
2257                         }
2258                     } else if (g_type_is_a (type, G_TYPE_BOXED)) {
2259                     } else if (g_type_is_a (type, G_TYPE_POINTER) || type == G_TYPE_NONE) {
2260                         g_warn_if_fail (!g_type_info_is_pointer (type_info) || transfer == GI_TRANSFER_NOTHING);
2261                     }
2262
2263                     break;
2264                 }
2265                 case GI_INFO_TYPE_ENUM:
2266                 case GI_INFO_TYPE_FLAGS:
2267                     break;
2268                 case GI_INFO_TYPE_INTERFACE:
2269                 case GI_INFO_TYPE_OBJECT:
2270                     if (arg->v_pointer == NULL) {
2271                         return;
2272                     }
2273                     if (is_out && transfer == GI_TRANSFER_EVERYTHING) {
2274                         g_object_unref (arg->v_pointer);
2275                     }
2276                     break;
2277                 default:
2278                     g_assert_not_reached();
2279             }
2280
2281             g_base_info_unref (info);
2282             break;
2283         }
2284         case GI_TYPE_TAG_GLIST:
2285         case GI_TYPE_TAG_GSLIST:
2286         {
2287             GSList *list;
2288
2289             if (arg->v_pointer == NULL) {
2290                 return;
2291             }
2292
2293             list = arg->v_pointer;
2294
2295             if ( (direction == GI_DIRECTION_IN && transfer != GI_TRANSFER_EVERYTHING)
2296                     || (direction == GI_DIRECTION_OUT && transfer == GI_TRANSFER_EVERYTHING)) {
2297                 GITypeInfo *item_type_info;
2298                 GITransfer item_transfer;
2299                 GSList *item;
2300
2301                 item_type_info = g_type_info_get_param_type (type_info, 0);
2302                 g_assert (item_type_info != NULL);
2303
2304                 item_transfer = direction == GI_DIRECTION_IN ? GI_TRANSFER_NOTHING : GI_TRANSFER_EVERYTHING;
2305
2306                 /* Free the items */
2307                 for (item = list; item != NULL; item = g_slist_next (item)) {
2308                     _pygi_argument_release ( (GIArgument *) &item->data, item_type_info,
2309                                              item_transfer, direction);
2310                 }
2311
2312                 g_base_info_unref ( (GIBaseInfo *) item_type_info);
2313             }
2314
2315             if ( (direction == GI_DIRECTION_IN && transfer == GI_TRANSFER_NOTHING)
2316                     || (direction == GI_DIRECTION_OUT && transfer != GI_TRANSFER_NOTHING)) {
2317                 if (type_tag == GI_TYPE_TAG_GLIST) {
2318                     g_list_free ( (GList *) list);
2319                 } else {
2320                     /* type_tag == GI_TYPE_TAG_GSLIST */
2321                     g_slist_free (list);
2322                 }
2323             }
2324
2325             break;
2326         }
2327         case GI_TYPE_TAG_GHASH:
2328         {
2329             GHashTable *hash_table;
2330
2331             if (arg->v_pointer == NULL) {
2332                 return;
2333             }
2334
2335             hash_table = arg->v_pointer;
2336
2337             if (direction == GI_DIRECTION_IN && transfer != GI_TRANSFER_EVERYTHING) {
2338                 /* We created the table without a destroy function, so keys and
2339                  * values need to be released. */
2340                 GITypeInfo *key_type_info;
2341                 GITypeInfo *value_type_info;
2342                 GITransfer item_transfer;
2343                 GHashTableIter hash_table_iter;
2344                 gpointer key;
2345                 gpointer value;
2346
2347                 key_type_info = g_type_info_get_param_type (type_info, 0);
2348                 g_assert (key_type_info != NULL);
2349
2350                 value_type_info = g_type_info_get_param_type (type_info, 1);
2351                 g_assert (value_type_info != NULL);
2352
2353                 if (direction == GI_DIRECTION_IN) {
2354                     item_transfer = GI_TRANSFER_NOTHING;
2355                 } else {
2356                     item_transfer = GI_TRANSFER_EVERYTHING;
2357                 }
2358
2359                 g_hash_table_iter_init (&hash_table_iter, hash_table);
2360                 while (g_hash_table_iter_next (&hash_table_iter, &key, &value)) {
2361                     _pygi_argument_release ( (GIArgument *) &key, key_type_info,
2362                                              item_transfer, direction);
2363                     _pygi_argument_release ( (GIArgument *) &value, value_type_info,
2364                                              item_transfer, direction);
2365                 }
2366
2367                 g_base_info_unref ( (GIBaseInfo *) key_type_info);
2368                 g_base_info_unref ( (GIBaseInfo *) value_type_info);
2369             } else if (direction == GI_DIRECTION_OUT && transfer == GI_TRANSFER_CONTAINER) {
2370                 /* Be careful to avoid keys and values being freed if the
2371                  * callee gave a destroy function. */
2372                 g_hash_table_steal_all (hash_table);
2373             }
2374
2375             if ( (direction == GI_DIRECTION_IN && transfer == GI_TRANSFER_NOTHING)
2376                     || (direction == GI_DIRECTION_OUT && transfer != GI_TRANSFER_NOTHING)) {
2377                 g_hash_table_unref (hash_table);
2378             }
2379
2380             break;
2381         }
2382         case GI_TYPE_TAG_ERROR:
2383         {
2384             GError *error;
2385
2386             if (arg->v_pointer == NULL) {
2387                 return;
2388             }
2389
2390             error = * (GError **) arg->v_pointer;
2391
2392             if (error != NULL) {
2393                 g_error_free (error);
2394             }
2395
2396             g_slice_free (GError *, arg->v_pointer);
2397             break;
2398         }
2399     }
2400 }
2401
2402 void
2403 _pygi_argument_init (void)
2404 {
2405     PyDateTime_IMPORT;
2406     _pygobject_import();
2407 }
2408