gi/pygi-argument.c

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