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