gi/pygi-cache.c

   1 /* -*- Mode: C; c-basic-offset: 4 -*-
   2  * vim: tabstop=4 shiftwidth=4 expandtab
   3  *
   4  * Copyright (C) 2011 John (J5) Palmieri <johnp@redhat.com>
   5  * Copyright (C) 2013 Simon Feltman <sfeltman@gnome.org>
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, see <http://www.gnu.org/licenses/>.
  19  */
  20
  21 #include <Python.h>
  22 #include <girepository.h>
  23
  24 #include "pyglib.h"
  25 #include "pygtype.h"
  26 #include "pygi-info.h"
  27 #include "pygi-cache.h"
  28 #include "pygi-marshal-cleanup.h"
  29 #include "pygi-type.h"
  30 #include "pygi-hashtable.h"
  31 #include "pygi-basictype.h"
  32 #include "pygi-list.h"
  33 #include "pygi-array.h"
  34 #include "pygi-closure.h"
  35 #include "pygi-error.h"
  36 #include "pygi-object.h"
  37 #include "pygi-struct-marshal.h"
  38 #include "pygi-enum-marshal.h"
  39 #include "pygi-resulttuple.h"
  40 #include "pygi-invoke.h"
  41
  42
  43 /* _arg_info_default_value
  44  * info:
  45  * arg: (out): GIArgument to fill in with default value.
  46  *
  47  * This is currently a place holder API which only supports "allow-none" pointer args.
  48  * Once defaults are part of the GI API, we can replace this with: g_arg_info_default_value
  49  * https://bugzilla.gnome.org/show_bug.cgi?id=558620
  50  *
  51  * Returns: TRUE if the given argument supports a default value and was filled in.
  52  */
  53 static gboolean
  54 _arg_info_default_value (GIArgInfo *info, GIArgument *arg)
  55 {
  56     if (g_arg_info_may_be_null (info)) {
  57         arg->v_pointer = NULL;
  58         return TRUE;
  59     }
  60     return FALSE;
  61 }
  62
  63 /* pygi_arg_base_setup:
  64  * arg_cache: argument cache to initialize
  65  * type_info: source for type related attributes to cache
  66  * arg_info: (allow-none): source for argument related attributes to cache
  67  * transfer: transfer mode to store in the argument cache
  68  * direction: marshaling direction to store in the cache
  69  *
  70  * Initializer for PyGIArgCache
  71  *
  72  * Returns: TRUE on success and FALSE on failure
  73  */
  74 gboolean
  75 pygi_arg_base_setup (PyGIArgCache *arg_cache,
  76                      GITypeInfo   *type_info,
  77                      GIArgInfo    *arg_info,  /* may be NULL for return arguments */
  78                      GITransfer    transfer,
  79                      PyGIDirection direction)
  80 {
  81     arg_cache->direction = direction;
  82     arg_cache->transfer = transfer;
  83     arg_cache->py_arg_index = -1;
  84     arg_cache->c_arg_index = -1;
  85
  86     if (type_info != NULL) {
  87         arg_cache->is_pointer = g_type_info_is_pointer (type_info);
  88         arg_cache->type_tag = g_type_info_get_tag (type_info);
  89         g_base_info_ref ( (GIBaseInfo *) type_info);
  90         arg_cache->type_info = type_info;
  91     }
  92
  93     if (arg_info != NULL) {
  94         if (!arg_cache->has_default) {
  95             /* It is possible has_default was set somewhere else */
  96             arg_cache->has_default = _arg_info_default_value (arg_info,
  97                                                               &arg_cache->default_value);
  98         }
  99         arg_cache->arg_name = g_base_info_get_name ((GIBaseInfo *) arg_info);
 100         arg_cache->allow_none = g_arg_info_may_be_null (arg_info);
 101
 102         if (arg_cache->type_tag == GI_TYPE_TAG_INTERFACE || arg_cache->type_tag == GI_TYPE_TAG_ARRAY)
 103             arg_cache->is_caller_allocates = g_arg_info_is_caller_allocates (arg_info);
 104         else
 105             arg_cache->is_caller_allocates = FALSE;
 106     }
 107     return TRUE;
 108 }
 109
 110 void
 111 pygi_arg_cache_free (PyGIArgCache *cache)
 112 {
 113     if (cache == NULL)
 114         return;
 115
 116     if (cache->type_info != NULL)
 117         g_base_info_unref ( (GIBaseInfo *)cache->type_info);
 118     if (cache->destroy_notify)
 119         cache->destroy_notify (cache);
 120     else
 121         g_slice_free (PyGIArgCache, cache);
 122 }
 123
 124 /* PyGIInterfaceCache */
 125
 126 static void
 127 _interface_cache_free_func (PyGIInterfaceCache *cache)
 128 {
 129     if (cache != NULL) {
 130         Py_XDECREF (cache->py_type);
 131         if (cache->type_name != NULL)
 132             g_free (cache->type_name);
 133         if (cache->interface_info != NULL)
 134             g_base_info_unref ( (GIBaseInfo *)cache->interface_info);
 135         g_slice_free (PyGIInterfaceCache, cache);
 136     }
 137 }
 138
 139 /* pygi_arg_interface_setup:
 140  * arg_cache: argument cache to initialize
 141  * type_info: source for type related attributes to cache
 142  * arg_info: (allow-none): source for argument related attributes to cache
 143  * transfer: transfer mode to store in the argument cache
 144  * direction: marshaling direction to store in the cache
 145  * iface_info: interface info to cache
 146  *
 147  * Initializer for PyGIInterfaceCache
 148  *
 149  * Returns: TRUE on success and FALSE on failure
 150  */
 151 gboolean
 152 pygi_arg_interface_setup (PyGIInterfaceCache *iface_cache,
 153                           GITypeInfo         *type_info,
 154                           GIArgInfo          *arg_info,    /* may be NULL for return arguments */
 155                           GITransfer          transfer,
 156                           PyGIDirection       direction,
 157                           GIInterfaceInfo    *iface_info)
 158 {
 159     if (!pygi_arg_base_setup ((PyGIArgCache *)iface_cache,
 160                               type_info,
 161                               arg_info,
 162                               transfer,
 163                               direction)) {
 164         return FALSE;
 165     }
 166
 167     ( (PyGIArgCache *)iface_cache)->destroy_notify = (GDestroyNotify)_interface_cache_free_func;
 168
 169     g_base_info_ref ( (GIBaseInfo *)iface_info);
 170     iface_cache->interface_info = iface_info;
 171     iface_cache->arg_cache.type_tag = GI_TYPE_TAG_INTERFACE;
 172     iface_cache->type_name = _pygi_g_base_info_get_fullname (iface_info);
 173     iface_cache->g_type = g_registered_type_info_get_g_type ( (GIRegisteredTypeInfo *)iface_info);
 174     iface_cache->py_type = _pygi_type_import_by_gi_info ( (GIBaseInfo *) iface_info);
 175
 176     if (iface_cache->py_type == NULL) {
 177         return FALSE;
 178     }
 179
 180     return TRUE;
 181 }
 182
 183 PyGIArgCache *
 184 pygi_arg_interface_new_from_info (GITypeInfo         *type_info,
 185                                   GIArgInfo          *arg_info,    /* may be NULL for return arguments */
 186                                   GITransfer          transfer,
 187                                   PyGIDirection       direction,
 188                                   GIInterfaceInfo    *iface_info)
 189 {
 190     PyGIInterfaceCache *ic;
 191
 192     ic = g_slice_new0 (PyGIInterfaceCache);
 193     if (!pygi_arg_interface_setup (ic,
 194                                    type_info,
 195                                    arg_info,
 196                                    transfer,
 197                                    direction,
 198                                    iface_info)) {
 199         pygi_arg_cache_free ((PyGIArgCache *)ic);
 200         return NULL;
 201     }
 202
 203     return (PyGIArgCache *)ic;
 204 }
 205
 206 /* PyGISequenceCache */
 207
 208 static void
 209 _sequence_cache_free_func (PyGISequenceCache *cache)
 210 {
 211     if (cache != NULL) {
 212         pygi_arg_cache_free (cache->item_cache);
 213         g_slice_free (PyGISequenceCache, cache);
 214     }
 215 }
 216
 217 /* pygi_arg_sequence_setup:
 218  * sc: sequence cache to initialize
 219  * type_info: source for type related attributes to cache
 220  * arg_info: (allow-none): source for argument related attributes to cache
 221  * transfer: transfer mode to store in the argument cache
 222  * direction: marshaling direction to store in the cache
 223  * iface_info: interface info to cache
 224  *
 225  * Initializer for PyGISequenceCache used for holding list and array argument
 226  * caches.
 227  *
 228  * Returns: TRUE on success and FALSE on failure
 229  */
 230 gboolean
 231 pygi_arg_sequence_setup (PyGISequenceCache  *sc,
 232                          GITypeInfo         *type_info,
 233                          GIArgInfo          *arg_info,    /* may be NULL for return arguments */
 234                          GITransfer          transfer,
 235                          PyGIDirection       direction,
 236                          PyGICallableCache  *callable_cache)
 237 {
 238     GITypeInfo *item_type_info;
 239     GITransfer item_transfer;
 240
 241     if (!pygi_arg_base_setup ((PyGIArgCache *)sc,
 242                               type_info,
 243                               arg_info,
 244                               transfer,
 245                               direction)) {
 246         return FALSE;
 247     }
 248
 249     sc->arg_cache.destroy_notify = (GDestroyNotify)_sequence_cache_free_func;
 250     item_type_info = g_type_info_get_param_type (type_info, 0);
 251     item_transfer =
 252         transfer == GI_TRANSFER_CONTAINER ? GI_TRANSFER_NOTHING : transfer;
 253
 254     sc->item_cache = pygi_arg_cache_new (item_type_info,
 255                                          NULL,
 256                                          item_transfer,
 257                                          direction,
 258                                          callable_cache,
 259                                          0, 0);
 260
 261     g_base_info_unref ( (GIBaseInfo *)item_type_info);
 262
 263     if (sc->item_cache == NULL) {
 264         return FALSE;
 265     }
 266
 267     return TRUE;
 268 }
 269
 270 PyGIArgCache *
 271 pygi_arg_cache_alloc (void)
 272 {
 273     return g_slice_new0 (PyGIArgCache);
 274 }
 275
 276 static PyGIArgCache *
 277 _arg_cache_new_for_interface (GIInterfaceInfo   *iface_info,
 278                               GITypeInfo        *type_info,
 279                               GIArgInfo         *arg_info,
 280                               GITransfer         transfer,
 281                               PyGIDirection      direction,
 282                               PyGICallableCache *callable_cache)
 283 {
 284     GIInfoType info_type;
 285
 286     info_type = g_base_info_get_type ( (GIBaseInfo *)iface_info);
 287
 288     switch (info_type) {
 289         case GI_INFO_TYPE_CALLBACK:
 290             return pygi_arg_callback_new_from_info (type_info,
 291                                                     arg_info,
 292                                                     transfer,
 293                                                     direction,
 294                                                     iface_info,
 295                                                     callable_cache);
 296         case GI_INFO_TYPE_OBJECT:
 297         case GI_INFO_TYPE_INTERFACE:
 298             return pygi_arg_gobject_new_from_info (type_info,
 299                                                    arg_info,
 300                                                    transfer,
 301                                                    direction,
 302                                                    iface_info,
 303                                                    callable_cache);
 304         case GI_INFO_TYPE_BOXED:
 305         case GI_INFO_TYPE_STRUCT:
 306         case GI_INFO_TYPE_UNION:
 307             return pygi_arg_struct_new_from_info (type_info,
 308                                                   arg_info,
 309                                                   transfer,
 310                                                   direction,
 311                                                   iface_info);
 312         case GI_INFO_TYPE_ENUM:
 313             return pygi_arg_enum_new_from_info (type_info,
 314                                                 arg_info,
 315                                                 transfer,
 316                                                 direction,
 317                                                 iface_info);
 318         case GI_INFO_TYPE_FLAGS:
 319             return pygi_arg_flags_new_from_info (type_info,
 320                                                  arg_info,
 321                                                  transfer,
 322                                                  direction,
 323                                                  iface_info);
 324         default:
 325             g_assert_not_reached ();
 326     }
 327
 328     return NULL;
 329 }
 330
 331 PyGIArgCache *
 332 pygi_arg_cache_new (GITypeInfo *type_info,
 333                     GIArgInfo *arg_info,     /* may be null */
 334                     GITransfer transfer,
 335                     PyGIDirection direction,
 336                     PyGICallableCache *callable_cache,
 337                     gssize c_arg_index,
 338                     gssize py_arg_index)
 339 {
 340     PyGIArgCache *arg_cache = NULL;
 341     GITypeTag type_tag;
 342
 343     type_tag = g_type_info_get_tag (type_info);
 344
 345     switch (type_tag) {
 346        case GI_TYPE_TAG_VOID:
 347        case GI_TYPE_TAG_BOOLEAN:
 348        case GI_TYPE_TAG_INT8:
 349        case GI_TYPE_TAG_UINT8:
 350        case GI_TYPE_TAG_INT16:
 351        case GI_TYPE_TAG_UINT16:
 352        case GI_TYPE_TAG_INT32:
 353        case GI_TYPE_TAG_UINT32:
 354        case GI_TYPE_TAG_INT64:
 355        case GI_TYPE_TAG_UINT64:
 356        case GI_TYPE_TAG_FLOAT:
 357        case GI_TYPE_TAG_DOUBLE:
 358        case GI_TYPE_TAG_UNICHAR:
 359        case GI_TYPE_TAG_GTYPE:
 360        case GI_TYPE_TAG_UTF8:
 361        case GI_TYPE_TAG_FILENAME:
 362            arg_cache = pygi_arg_basic_type_new_from_info (type_info,
 363                                                           arg_info,
 364                                                           transfer,
 365                                                           direction);
 366            break;
 367
 368        case GI_TYPE_TAG_ARRAY:
 369            {
 370                arg_cache = pygi_arg_garray_new_from_info (type_info,
 371                                                           arg_info,
 372                                                           transfer,
 373                                                           direction,
 374                                                           callable_cache);
 375                if (arg_cache == NULL)
 376                    return NULL;
 377
 378                pygi_arg_garray_len_arg_setup (arg_cache,
 379                                               type_info,
 380                                               callable_cache,
 381                                               direction,
 382                                               c_arg_index,
 383                                               &py_arg_index);
 384            }
 385            break;
 386
 387        case GI_TYPE_TAG_GLIST:
 388            arg_cache = pygi_arg_glist_new_from_info (type_info,
 389                                                      arg_info,
 390                                                      transfer,
 391                                                      direction,
 392                                                      callable_cache);
 393            break;
 394
 395        case GI_TYPE_TAG_GSLIST:
 396            arg_cache = pygi_arg_gslist_new_from_info (type_info,
 397                                                       arg_info,
 398                                                       transfer,
 399                                                       direction,
 400                                                       callable_cache);
 401            break;
 402
 403        case GI_TYPE_TAG_GHASH:
 404            arg_cache = pygi_arg_hash_table_new_from_info (type_info,
 405                                                           arg_info,
 406                                                           transfer,
 407                                                           direction,
 408                                                           callable_cache);
 409            break;
 410
 411        case GI_TYPE_TAG_INTERFACE:
 412            {
 413                GIInterfaceInfo *interface_info = g_type_info_get_interface (type_info);
 414                arg_cache = _arg_cache_new_for_interface (interface_info,
 415                                                          type_info,
 416                                                          arg_info,
 417                                                          transfer,
 418                                                          direction,
 419                                                          callable_cache);
 420
 421                g_base_info_unref ( (GIBaseInfo *)interface_info);
 422            }
 423            break;
 424
 425        case GI_TYPE_TAG_ERROR:
 426            arg_cache = pygi_arg_gerror_new_from_info (type_info,
 427                                                       arg_info,
 428                                                       transfer,
 429                                                       direction);
 430            break;
 431        default:
 432            break;
 433     }
 434
 435     if (arg_cache != NULL) {
 436         arg_cache->py_arg_index = py_arg_index;
 437         arg_cache->c_arg_index = c_arg_index;
 438     }
 439
 440     return arg_cache;
 441 }
 442
 443 /* PyGICallableCache */
 444
 445 static PyGIDirection
 446 _pygi_get_direction (PyGICallableCache *callable_cache, GIDirection gi_direction)
 447 {
 448     /* For vfuncs and callbacks our marshalling directions are reversed */
 449     if (gi_direction == GI_DIRECTION_INOUT) {
 450         return PYGI_DIRECTION_BIDIRECTIONAL;
 451     } else if (gi_direction == GI_DIRECTION_IN) {
 452         if (callable_cache->calling_context != PYGI_CALLING_CONTEXT_IS_FROM_PY)
 453             return PYGI_DIRECTION_TO_PYTHON;
 454         return PYGI_DIRECTION_FROM_PYTHON;
 455     } else {
 456         if (callable_cache->calling_context != PYGI_CALLING_CONTEXT_IS_FROM_PY)
 457             return PYGI_DIRECTION_FROM_PYTHON;
 458         return PYGI_DIRECTION_TO_PYTHON;
 459     }
 460 }
 461
 462 /* Generate the cache for the callable's arguments */
 463 static gboolean
 464 _callable_cache_generate_args_cache_real (PyGICallableCache *callable_cache,
 465                                           GICallableInfo *callable_info)
 466 {
 467     gssize i;
 468     gssize arg_index;
 469     GITypeInfo *return_info;
 470     GITransfer return_transfer;
 471     PyGIArgCache *return_cache;
 472     PyGIDirection return_direction;
 473         gssize last_explicit_arg_index;
 474     PyObject *tuple_names;
 475     GSList *arg_cache_item;
 476     PyTypeObject* resulttuple_type;
 477
 478     /* Return arguments are always considered out */
 479     return_direction = _pygi_get_direction (callable_cache, GI_DIRECTION_OUT);
 480
 481     /* cache the return arg */
 482     return_info =
 483         g_callable_info_get_return_type (callable_info);
 484     return_transfer =
 485         g_callable_info_get_caller_owns (callable_info);
 486     return_cache =
 487         pygi_arg_cache_new (return_info,
 488                             NULL,
 489                             return_transfer,
 490                             return_direction,
 491                             callable_cache,
 492                             -1,
 493                             -1);
 494     if (return_cache == NULL)
 495         return FALSE;
 496
 497     return_cache->is_skipped = g_callable_info_skip_return (callable_info);
 498     callable_cache->return_cache = return_cache;
 499     g_base_info_unref (return_info);
 500
 501     callable_cache->user_data_index = -1;
 502
 503     for (i = 0, arg_index = callable_cache->args_offset;
 504          (gsize)arg_index < _pygi_callable_cache_args_len (callable_cache);
 505          i++, arg_index++) {
 506         PyGIArgCache *arg_cache = NULL;
 507         GIArgInfo *arg_info;
 508         PyGIDirection direction;
 509
 510         arg_info = g_callable_info_get_arg (callable_info, i);
 511
 512         /* This only happens when dealing with callbacks */
 513         if (g_arg_info_get_closure (arg_info) == i) {
 514             callable_cache->user_data_index = i;
 515
 516             arg_cache = pygi_arg_cache_alloc ();
 517             _pygi_callable_cache_set_arg (callable_cache, arg_index, arg_cache);
 518
 519             direction = _pygi_get_direction (callable_cache, GI_DIRECTION_IN);
 520             arg_cache->direction = direction;
 521             arg_cache->meta_type = PYGI_META_ARG_TYPE_CLOSURE;
 522             arg_cache->c_arg_index = i;
 523             arg_cache->is_pointer = TRUE;
 524
 525         } else {
 526             GITypeInfo *type_info;
 527
 528             direction = _pygi_get_direction (callable_cache,
 529                                              g_arg_info_get_direction (arg_info));
 530             type_info = g_arg_info_get_type (arg_info);
 531
 532             /* must be an child arg filled in by its owner
 533              * and continue
 534              * fill in it's c_arg_index, add to the in count
 535              */
 536             arg_cache = _pygi_callable_cache_get_arg (callable_cache, arg_index);
 537             if (arg_cache != NULL) {
 538                 /* ensure c_arg_index always aligns with callable_cache->args_cache
 539                  * and all of the various PyGIInvokeState arrays. */
 540                 arg_cache->c_arg_index = arg_index;
 541
 542                 if (arg_cache->meta_type == PYGI_META_ARG_TYPE_CHILD_WITH_PYARG) {
 543                     arg_cache->py_arg_index = callable_cache->n_py_args;
 544                     callable_cache->n_py_args++;
 545                 }
 546
 547                 if (direction & PYGI_DIRECTION_TO_PYTHON) {
 548                     callable_cache->n_to_py_args++;
 549                 }
 550
 551                 arg_cache->type_tag = g_type_info_get_tag (type_info);
 552
 553             } else {
 554                 GITransfer transfer;
 555                 gssize py_arg_index = -1;
 556
 557                 transfer = g_arg_info_get_ownership_transfer (arg_info);
 558
 559                 if (direction & PYGI_DIRECTION_FROM_PYTHON) {
 560                     py_arg_index = callable_cache->n_py_args;
 561                     callable_cache->n_py_args++;
 562                 }
 563
 564                 arg_cache =
 565                     pygi_arg_cache_new (type_info,
 566                                         arg_info,
 567                                         transfer,
 568                                         direction,
 569                                         callable_cache,
 570                                         arg_index,
 571                                         py_arg_index);
 572
 573                 if (arg_cache == NULL) {
 574                     g_base_info_unref( (GIBaseInfo *)type_info);
 575                     g_base_info_unref( (GIBaseInfo *)arg_info);
 576                     return FALSE;
 577                 }
 578
 579
 580                 if (direction & PYGI_DIRECTION_TO_PYTHON) {
 581                     callable_cache->n_to_py_args++;
 582
 583                     callable_cache->to_py_args =
 584                         g_slist_append (callable_cache->to_py_args, arg_cache);
 585                 }
 586
 587                 _pygi_callable_cache_set_arg (callable_cache, arg_index, arg_cache);
 588             }
 589
 590             g_base_info_unref (type_info);
 591         }
 592
 593         /* Ensure arguments always have a name when available */
 594         arg_cache->arg_name = g_base_info_get_name ((GIBaseInfo *) arg_info);
 595
 596         g_base_info_unref ( (GIBaseInfo *)arg_info);
 597
 598     }
 599
 600     if (callable_cache->arg_name_hash == NULL) {
 601         callable_cache->arg_name_hash = g_hash_table_new (g_str_hash, g_str_equal);
 602     } else {
 603         g_hash_table_remove_all (callable_cache->arg_name_hash);
 604     }
 605     callable_cache->n_py_required_args = 0;
 606     callable_cache->user_data_varargs_index = -1;
 607
 608     last_explicit_arg_index = -1;
 609
 610     /* Reverse loop through all the arguments to setup arg_name_list/hash
 611      * and find the number of required arguments */
 612     for (i=((gssize)_pygi_callable_cache_args_len (callable_cache))-1; i >= 0; i--) {
 613         PyGIArgCache *arg_cache = _pygi_callable_cache_get_arg (callable_cache, i);
 614
 615         if (arg_cache->meta_type != PYGI_META_ARG_TYPE_CHILD &&
 616                 arg_cache->meta_type != PYGI_META_ARG_TYPE_CLOSURE &&
 617                 arg_cache->direction & PYGI_DIRECTION_FROM_PYTHON) {
 618
 619             /* Setup arg_name_list and arg_name_hash */
 620             gpointer arg_name = (gpointer)arg_cache->arg_name;
 621             callable_cache->arg_name_list = g_slist_prepend (callable_cache->arg_name_list,
 622                                                              arg_name);
 623             if (arg_name != NULL) {
 624                 g_hash_table_insert (callable_cache->arg_name_hash,
 625                                      arg_name,
 626                                      GINT_TO_POINTER(i));
 627             }
 628
 629             /* The first tail argument without a default will force all the preceding
 630              * argument defaults off. This limits support of default args to the
 631              * tail of an args list.
 632              */
 633             if (callable_cache->n_py_required_args > 0) {
 634                 arg_cache->has_default = FALSE;
 635                 callable_cache->n_py_required_args += 1;
 636             } else if (!arg_cache->has_default) {
 637                 callable_cache->n_py_required_args += 1;
 638             }
 639
 640             if (last_explicit_arg_index == -1) {
 641                 last_explicit_arg_index = i;
 642
 643                 /* If the last "from python" argument in the args list is a child
 644                  * with pyarg (currently only callback user_data). Set it to eat
 645                  * variable args in the callable cache.
 646                  */
 647                 if (arg_cache->meta_type == PYGI_META_ARG_TYPE_CHILD_WITH_PYARG)
 648                     callable_cache->user_data_varargs_index = i;
 649             }
 650         }
 651     }
 652
 653     if (!return_cache->is_skipped && return_cache->type_tag != GI_TYPE_TAG_VOID) {
 654         callable_cache->has_return = TRUE;
 655     }
 656
 657     tuple_names = PyList_New (0);
 658     if (callable_cache->has_return) {
 659         PyList_Append (tuple_names, Py_None);
 660     }
 661
 662     arg_cache_item = callable_cache->to_py_args;
 663     while (arg_cache_item) {
 664         const gchar *arg_name = ((PyGIArgCache *)arg_cache_item->data)->arg_name;
 665         PyObject *arg_string = PYGLIB_PyUnicode_FromString (arg_name);
 666         PyList_Append (tuple_names, arg_string);
 667         Py_DECREF (arg_string);
 668         arg_cache_item = arg_cache_item->next;
 669     }
 670
 671     /* No need to create a tuple type if there aren't multiple values */
 672     if (PyList_Size (tuple_names) > 1) {
 673         resulttuple_type = pygi_resulttuple_new_type (tuple_names);
 674         if (resulttuple_type == NULL) {
 675             Py_DECREF (tuple_names);
 676             return FALSE;
 677         } else {
 678             callable_cache->resulttuple_type = resulttuple_type;
 679         }
 680     }
 681     Py_DECREF (tuple_names);
 682
 683     return TRUE;
 684 }
 685
 686 static void
 687 _callable_cache_deinit_real (PyGICallableCache *cache)
 688 {
 689     g_clear_pointer (&cache->to_py_args, g_slist_free);
 690     g_clear_pointer (&cache->arg_name_list, g_slist_free);
 691     g_clear_pointer (&cache->arg_name_hash, g_hash_table_unref);
 692     g_clear_pointer (&cache->args_cache, g_ptr_array_unref);
 693     Py_CLEAR (cache->resulttuple_type);
 694
 695     g_clear_pointer (&cache->return_cache, pygi_arg_cache_free);
 696 }
 697
 698 static gboolean
 699 _callable_cache_init (PyGICallableCache *cache,
 700                       GICallableInfo *callable_info)
 701 {
 702     gint n_args;
 703     GIBaseInfo *container;
 704
 705     if (cache->deinit == NULL)
 706         cache->deinit = _callable_cache_deinit_real;
 707
 708     if (cache->generate_args_cache == NULL)
 709         cache->generate_args_cache = _callable_cache_generate_args_cache_real;
 710
 711     cache->name = g_base_info_get_name ((GIBaseInfo *) callable_info);
 712     cache->namespace = g_base_info_get_namespace ((GIBaseInfo *) callable_info);
 713     container = g_base_info_get_container ((GIBaseInfo *) callable_info);
 714     cache->container_name = NULL;
 715     /* https://bugzilla.gnome.org/show_bug.cgi?id=709456 */
 716     if (container != NULL && g_base_info_get_type (container) != GI_INFO_TYPE_TYPE) {
 717         cache->container_name = g_base_info_get_name (container);
 718     }
 719     cache->throws = g_callable_info_can_throw_gerror ((GIBaseInfo *) callable_info);
 720
 721     if (g_base_info_is_deprecated (callable_info)) {
 722         const gchar *deprecated = g_base_info_get_attribute (callable_info, "deprecated");
 723         gchar *warning;
 724         gchar *full_name = pygi_callable_cache_get_full_name (cache);
 725         if (deprecated != NULL)
 726             warning = g_strdup_printf ("%s is deprecated: %s",
 727                                        full_name,
 728                                        deprecated);
 729         else
 730             warning = g_strdup_printf ("%s is deprecated",
 731                                        full_name);
 732         g_free (full_name);
 733         PyErr_WarnEx (PyExc_DeprecationWarning, warning, 0);
 734         g_free (warning);
 735     }
 736
 737     n_args = cache->args_offset + g_callable_info_get_n_args (callable_info);
 738
 739     if (n_args >= 0) {
 740         cache->args_cache = g_ptr_array_new_full (n_args, (GDestroyNotify) pygi_arg_cache_free);
 741         g_ptr_array_set_size (cache->args_cache, n_args);
 742     }
 743
 744     if (!cache->generate_args_cache (cache, callable_info)) {
 745         _callable_cache_deinit_real (cache);
 746         return FALSE;
 747     }
 748
 749     return TRUE;
 750 }
 751
 752 gchar *
 753 pygi_callable_cache_get_full_name (PyGICallableCache *cache)
 754 {
 755     if (cache->container_name != NULL) {
 756         return g_strjoin (".",
 757                           cache->namespace,
 758                           cache->container_name,
 759                           cache->name,
 760                           NULL);
 761     } else {
 762         return g_strjoin (".",
 763                           cache->namespace,
 764                           cache->name,
 765                           NULL);
 766     }
 767 }
 768
 769 void
 770 pygi_callable_cache_free (PyGICallableCache *cache)
 771 {
 772     cache->deinit (cache);
 773     g_free (cache);
 774 }
 775
 776 /* PyGIFunctionCache */
 777
 778 static PyObject *
 779 _function_cache_invoke_real (PyGIFunctionCache *function_cache,
 780                              PyGIInvokeState *state,
 781                              PyObject *py_args,
 782                              PyObject *py_kwargs)
 783 {
 784     return pygi_invoke_c_callable (function_cache, state,
 785                                    py_args, py_kwargs);
 786 }
 787
 788 static void
 789 _function_cache_deinit_real (PyGICallableCache *callable_cache)
 790 {
 791     g_function_invoker_destroy (&((PyGIFunctionCache *) callable_cache)->invoker);
 792
 793     _callable_cache_deinit_real (callable_cache);
 794 }
 795
 796 static gboolean
 797 _function_cache_init (PyGIFunctionCache *function_cache,
 798                       GICallableInfo *callable_info)
 799 {
 800     PyGICallableCache *callable_cache = (PyGICallableCache *) function_cache;
 801     GIFunctionInvoker *invoker = &function_cache->invoker;
 802     GError *error = NULL;
 803
 804     callable_cache->calling_context = PYGI_CALLING_CONTEXT_IS_FROM_PY;
 805
 806     if (callable_cache->deinit == NULL)
 807         callable_cache->deinit = _function_cache_deinit_real;
 808
 809     if (function_cache->invoke == NULL)
 810         function_cache->invoke = _function_cache_invoke_real;
 811
 812     if (!_callable_cache_init (callable_cache, callable_info))
 813         return FALSE;
 814
 815     /* Set by PyGICCallbackCache and PyGIVFuncCache */
 816     if (invoker->native_address == NULL) {
 817         if (g_function_info_prep_invoker ((GIFunctionInfo *) callable_info,
 818                                           invoker,
 819                                           &error)) {
 820             return TRUE;
 821         }
 822     } else {
 823         if (g_function_invoker_new_for_address (invoker->native_address,
 824                                                 (GIFunctionInfo *) callable_info,
 825                                                 invoker,
 826                                                 &error)) {
 827             return TRUE;
 828         }
 829     }
 830
 831     if (!pygi_error_check (&error)) {
 832         PyErr_Format (PyExc_RuntimeError,
 833                       "unknown error creating invoker for %s",
 834                       g_base_info_get_name ((GIBaseInfo *) callable_info));
 835     }
 836
 837     _callable_cache_deinit_real (callable_cache);
 838     return FALSE;
 839 }
 840
 841 PyGIFunctionCache *
 842 pygi_function_cache_new (GICallableInfo *info)
 843 {
 844     PyGIFunctionCache *function_cache;
 845
 846     function_cache = g_new0 (PyGIFunctionCache, 1);
 847
 848     if (!_function_cache_init (function_cache, info)) {
 849         g_free (function_cache);
 850         return NULL;
 851     }
 852
 853     return function_cache;
 854 }
 855
 856 PyObject *
 857 pygi_function_cache_invoke (PyGIFunctionCache *function_cache,
 858                             PyObject *py_args,
 859                             PyObject *py_kwargs)
 860 {
 861     PyGIInvokeState state = { 0, };
 862
 863     return function_cache->invoke (function_cache, &state,
 864                                    py_args, py_kwargs);
 865 }
 866
 867 /* PyGICCallbackCache */
 868
 869 PyGIFunctionCache *
 870 pygi_ccallback_cache_new (GICallableInfo *info,
 871                           GCallback function_ptr)
 872 {
 873     PyGICCallbackCache *ccallback_cache;
 874     PyGIFunctionCache *function_cache;
 875
 876     ccallback_cache = g_new0 (PyGICCallbackCache, 1);
 877     function_cache = (PyGIFunctionCache *) ccallback_cache;
 878
 879     function_cache->invoker.native_address = function_ptr;
 880
 881     if (!_function_cache_init (function_cache, info)) {
 882         g_free (ccallback_cache);
 883         return NULL;
 884      }
 885
 886     return function_cache;
 887 }
 888
 889 PyObject *
 890 pygi_ccallback_cache_invoke (PyGICCallbackCache *ccallback_cache,
 891                              PyObject *py_args,
 892                              PyObject *py_kwargs,
 893                              gpointer user_data)
 894 {
 895     PyGIFunctionCache *function_cache = (PyGIFunctionCache *) ccallback_cache;
 896     PyGIInvokeState state = { 0, };
 897
 898     state.user_data = user_data;
 899
 900     return function_cache->invoke (function_cache, &state,
 901                                    py_args, py_kwargs);
 902 }
 903
 904 /* PyGIConstructorCache */
 905
 906 static PyObject *
 907 _constructor_cache_invoke_real (PyGIFunctionCache *function_cache,
 908                                 PyGIInvokeState *state,
 909                                 PyObject *py_args,
 910                                 PyObject *py_kwargs)
 911 {
 912     PyGICallableCache *cache = (PyGICallableCache *) function_cache;
 913     PyObject *constructor_class;
 914     PyObject *ret;
 915
 916     constructor_class = PyTuple_GetItem (py_args, 0);
 917     if (constructor_class == NULL) {
 918         gchar *full_name = pygi_callable_cache_get_full_name (cache);
 919         PyErr_Clear ();
 920         PyErr_Format (PyExc_TypeError,
 921                       "Constructors require the class to be passed in as an argument, "
 922                       "No arguments passed to the %s constructor.",
 923                       full_name);
 924         g_free (full_name);
 925
 926         return FALSE;
 927     }
 928
 929     py_args = PyTuple_GetSlice (py_args, 1, PyTuple_Size (py_args));
 930     ret = _function_cache_invoke_real (function_cache, state,
 931                                        py_args, py_kwargs);
 932     Py_DECREF (py_args);
 933
 934     if (ret == NULL || cache->return_cache->is_skipped)
 935         return ret;
 936
 937     if (ret != Py_None) {
 938         if (!PyTuple_Check (ret))
 939             return ret;
 940
 941         if (PyTuple_GET_ITEM (ret, 0) != Py_None)
 942             return ret;
 943     }
 944
 945     PyErr_SetString (PyExc_TypeError, "constructor returned NULL");
 946
 947     Py_DECREF (ret);
 948     return NULL;
 949 }
 950
 951 PyGIFunctionCache *
 952 pygi_constructor_cache_new (GICallableInfo *info)
 953 {
 954     PyGIConstructorCache *constructor_cache;
 955     PyGIFunctionCache *function_cache;
 956
 957     constructor_cache = g_new0 (PyGIConstructorCache, 1);
 958     function_cache = (PyGIFunctionCache *) constructor_cache;
 959
 960     function_cache->invoke = _constructor_cache_invoke_real;
 961
 962     if (!_function_cache_init (function_cache, info)) {
 963         g_free (constructor_cache);
 964         return NULL;
 965     }
 966
 967     return function_cache;
 968 }
 969
 970 /* PyGIFunctionWithInstanceCache */
 971
 972 static gboolean
 973 _function_with_instance_cache_generate_args_cache_real (PyGICallableCache *callable_cache,
 974                                                         GICallableInfo *callable_info)
 975 {
 976     GIInterfaceInfo *interface_info;
 977     PyGIArgCache *instance_cache;
 978     GITransfer transfer;
 979
 980     interface_info = g_base_info_get_container ((GIBaseInfo *) callable_info);
 981     transfer = g_callable_info_get_instance_ownership_transfer (callable_info);
 982
 983     instance_cache =
 984         _arg_cache_new_for_interface (interface_info,
 985                                       NULL,
 986                                       NULL,
 987                                       transfer,
 988                                       PYGI_DIRECTION_FROM_PYTHON,
 989                                       callable_cache);
 990
 991     if (instance_cache == NULL)
 992         return FALSE;
 993
 994     /* Because we are not supplied a GITypeInfo for instance arguments,
 995      * assume some defaults. */
 996     instance_cache->is_pointer = TRUE;
 997     instance_cache->py_arg_index = 0;
 998     instance_cache->c_arg_index = 0;
 999
1000     _pygi_callable_cache_set_arg (callable_cache, 0, instance_cache);
1001
1002     callable_cache->n_py_args++;
1003
1004     return _callable_cache_generate_args_cache_real (callable_cache,
1005                                                      callable_info);
1006 }
1007
1008 static gboolean
1009 _function_with_instance_cache_init (PyGIFunctionWithInstanceCache *fwi_cache,
1010                                     GICallableInfo *info)
1011 {
1012     PyGICallableCache *callable_cache = (PyGICallableCache *) fwi_cache;
1013
1014     callable_cache->args_offset += 1;
1015     callable_cache->generate_args_cache = _function_with_instance_cache_generate_args_cache_real;
1016
1017     return _function_cache_init ((PyGIFunctionCache *) fwi_cache, info);
1018 }
1019
1020 /* PyGIMethodCache */
1021
1022 PyGIFunctionCache *
1023 pygi_method_cache_new (GICallableInfo *info)
1024 {
1025     PyGIMethodCache *method_cache;
1026     PyGIFunctionWithInstanceCache *fwi_cache;
1027
1028     method_cache = g_new0 (PyGIMethodCache, 1);
1029     fwi_cache = (PyGIFunctionWithInstanceCache *) method_cache;
1030
1031     if (!_function_with_instance_cache_init (fwi_cache, info)) {
1032         g_free (method_cache);
1033         return NULL;
1034     }
1035
1036     return (PyGIFunctionCache *) method_cache;
1037 }
1038
1039 /* PyGIVFuncCache */
1040
1041 static PyObject *
1042 _vfunc_cache_invoke_real (PyGIFunctionCache *function_cache,
1043                           PyGIInvokeState *state,
1044                           PyObject *py_args,
1045                           PyObject *py_kwargs)
1046 {
1047     PyGIVFuncCache *vfunc_cache = (PyGIVFuncCache *) function_cache;
1048     PyObject *py_gtype;
1049     GType implementor_gtype;
1050     GError *error = NULL;
1051     PyObject *ret;
1052
1053     py_gtype = PyTuple_GetItem (py_args, 0);
1054     if (py_gtype == NULL) {
1055         PyErr_SetString (PyExc_TypeError,
1056                          "need the GType of the implementor class");
1057         return FALSE;
1058     }
1059
1060     implementor_gtype = pyg_type_from_object (py_gtype);
1061     if (implementor_gtype == G_TYPE_INVALID)
1062         return FALSE;
1063
1064     /* vfunc addresses are pulled into the state at call time and cannot be
1065      * cached because the call site can specify a different portion of the
1066      * class hierarchy. e.g. Object.do_func vs. SubObject.do_func might
1067      * retrieve a different vfunc address but GI gives us the same vfunc info.
1068      */
1069     state->function_ptr = g_vfunc_info_get_address ((GIVFuncInfo *) vfunc_cache->info,
1070                                                     implementor_gtype,
1071                                                     &error);
1072     if (pygi_error_check (&error)) {
1073         return FALSE;
1074     }
1075
1076     py_args = PyTuple_GetSlice (py_args, 1, PyTuple_Size (py_args));
1077     ret = _function_cache_invoke_real (function_cache, state,
1078                                        py_args, py_kwargs);
1079     Py_DECREF (py_args);
1080
1081     return ret;
1082 }
1083
1084 static void
1085 _vfunc_cache_deinit_real (PyGICallableCache *callable_cache)
1086 {
1087     g_base_info_unref (((PyGIVFuncCache *) callable_cache)->info);
1088
1089     _function_cache_deinit_real (callable_cache);
1090 }
1091
1092 PyGIFunctionCache *
1093 pygi_vfunc_cache_new (GICallableInfo *info)
1094 {
1095     PyGIVFuncCache *vfunc_cache;
1096     PyGIFunctionCache *function_cache;
1097     PyGIFunctionWithInstanceCache *fwi_cache;
1098
1099     vfunc_cache = g_new0 (PyGIVFuncCache, 1);
1100     function_cache = (PyGIFunctionCache *) vfunc_cache;
1101     fwi_cache = (PyGIFunctionWithInstanceCache *) vfunc_cache;
1102
1103     ((PyGICallableCache *) vfunc_cache)->deinit = _vfunc_cache_deinit_real;
1104
1105     /* This must be non-NULL for _function_cache_init() to create the
1106      * invoker, the real address will be set in _vfunc_cache_invoke_real().
1107      */
1108     function_cache->invoker.native_address = (gpointer) 0xdeadbeef;
1109
1110     function_cache->invoke = _vfunc_cache_invoke_real;
1111
1112     if (!_function_with_instance_cache_init (fwi_cache, info)) {
1113         g_free (vfunc_cache);
1114         return NULL;
1115     }
1116
1117     /* Required by _vfunc_cache_invoke_real() */
1118     vfunc_cache->info = g_base_info_ref ((GIBaseInfo *) info);
1119
1120     return function_cache;
1121 }
1122
1123 /* PyGIClosureCache */
1124
1125 PyGIClosureCache *
1126 pygi_closure_cache_new (GICallableInfo *info)
1127 {
1128     gssize i;
1129     PyGIClosureCache *closure_cache;
1130     PyGICallableCache *callable_cache;
1131
1132     closure_cache = g_new0 (PyGIClosureCache, 1);
1133     callable_cache = (PyGICallableCache *) closure_cache;
1134
1135     callable_cache->calling_context = PYGI_CALLING_CONTEXT_IS_FROM_C;
1136
1137     if (!_callable_cache_init (callable_cache, info)) {
1138         g_free (closure_cache);
1139         return NULL;
1140     }
1141
1142     /* For backwards compatibility closures include the array's length.
1143      *
1144      * See: https://bugzilla.gnome.org/show_bug.cgi?id=652115
1145      */
1146     for (i = 0; (gsize)i < _pygi_callable_cache_args_len (callable_cache); i++) {
1147         PyGIArgCache *arg_cache;
1148         PyGIArgGArray *garray_cache;
1149         PyGIArgCache *len_arg_cache;
1150
1151         arg_cache = g_ptr_array_index (callable_cache->args_cache, i);
1152         if (arg_cache->type_tag != GI_TYPE_TAG_ARRAY)
1153             continue;
1154
1155         garray_cache = (PyGIArgGArray *) arg_cache;
1156         if (garray_cache->len_arg_index == -1)
1157             continue;
1158
1159         len_arg_cache = g_ptr_array_index (callable_cache->args_cache,
1160                                            garray_cache->len_arg_index);
1161         len_arg_cache->meta_type = PYGI_META_ARG_TYPE_PARENT;
1162     }
1163
1164     /* Prevent guessing multiple user data arguments.
1165      * This is required because some versions of GI
1166      * do not recognize user_data/data arguments correctly.
1167      */
1168     if (callable_cache->user_data_index == -1) {
1169         for (i = 0; (gsize)i < _pygi_callable_cache_args_len (callable_cache); i++) {
1170             PyGIArgCache *arg_cache;
1171
1172             arg_cache = g_ptr_array_index (callable_cache->args_cache, i);
1173
1174             if (arg_cache->direction == PYGI_DIRECTION_TO_PYTHON &&
1175                 arg_cache->type_tag == GI_TYPE_TAG_VOID &&
1176                 arg_cache->is_pointer) {
1177
1178                 callable_cache->user_data_index = i;
1179                 break;
1180             }
1181         }
1182     }
1183
1184     return closure_cache;
1185 }