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  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
  19  * USA
  20  */
  21
  22 #include "pygi-info.h"
  23 #include "pygi-cache.h"
  24 #include "pygi-marshal-to-py.h"
  25 #include "pygi-marshal-from-py.h"
  26 #include "pygi-marshal-cleanup.h"
  27 #include "pygi-type.h"
  28 #include <girepository.h>
  29
  30 PyGIArgCache * _arg_cache_new (GITypeInfo *type_info,
  31                                PyGICallableCache *callable_cache,
  32                                GIArgInfo *arg_info,
  33                                GITransfer transfer,
  34                                PyGIDirection direction,
  35                                gssize c_arg_index,
  36                                gssize py_arg_index);
  37
  38 PyGIArgCache * _arg_cache_new_for_interface (GIInterfaceInfo *iface_info,
  39                                              PyGICallableCache *callable_cache,
  40                                              GIArgInfo *arg_info,
  41                                              GITransfer transfer,
  42                                              PyGIDirection direction,
  43                                              gssize c_arg_index,
  44                                              gssize py_arg_index);
  45 /* cleanup */
  46 static void
  47 _pygi_arg_cache_free (PyGIArgCache *cache)
  48 {
  49     if (cache == NULL)
  50         return;
  51
  52     if (cache->type_info != NULL)
  53         g_base_info_unref ( (GIBaseInfo *)cache->type_info);
  54     if (cache->destroy_notify)
  55         cache->destroy_notify (cache);
  56     else
  57         g_slice_free (PyGIArgCache, cache);
  58 }
  59
  60 static void
  61 _interface_cache_free_func (PyGIInterfaceCache *cache)
  62 {
  63     if (cache != NULL) {
  64         Py_XDECREF (cache->py_type);
  65         if (cache->type_name != NULL)
  66             g_free (cache->type_name);
  67         if (cache->interface_info != NULL)
  68             g_base_info_unref ( (GIBaseInfo *)cache->interface_info);
  69         g_slice_free (PyGIInterfaceCache, cache);
  70     }
  71 }
  72
  73 static void
  74 _hash_cache_free_func (PyGIHashCache *cache)
  75 {
  76     if (cache != NULL) {
  77         _pygi_arg_cache_free (cache->key_cache);
  78         _pygi_arg_cache_free (cache->value_cache);
  79         g_slice_free (PyGIHashCache, cache);
  80     }
  81 }
  82
  83 static void
  84 _sequence_cache_free_func (PyGISequenceCache *cache)
  85 {
  86     if (cache != NULL) {
  87         _pygi_arg_cache_free (cache->item_cache);
  88         g_slice_free (PyGISequenceCache, cache);
  89     }
  90 }
  91
  92 static void
  93 _callback_cache_free_func (PyGICallbackCache *cache)
  94 {
  95     if (cache != NULL) {
  96         if (cache->interface_info != NULL)
  97             g_base_info_unref ( (GIBaseInfo *)cache->interface_info);
  98
  99         g_slice_free (PyGICallbackCache, cache);
 100     }
 101 }
 102
 103 void
 104 _pygi_callable_cache_free (PyGICallableCache *cache)
 105 {
 106     gssize i;
 107
 108     if (cache == NULL)
 109         return;
 110
 111     g_slist_free (cache->to_py_args);
 112     g_slist_free (cache->arg_name_list);
 113     g_hash_table_destroy (cache->arg_name_hash);
 114
 115     for (i = 0; i < cache->n_args; i++) {
 116         PyGIArgCache *tmp = cache->args_cache[i];
 117         _pygi_arg_cache_free (tmp);
 118     }
 119     if (cache->return_cache != NULL)
 120         _pygi_arg_cache_free (cache->return_cache);
 121
 122     g_slice_free1 (cache->n_args * sizeof (PyGIArgCache *), cache->args_cache);
 123     g_slice_free (PyGICallableCache, cache);
 124 }
 125
 126 /* cache generation */
 127
 128 static PyGIInterfaceCache *
 129 _interface_cache_new (GIInterfaceInfo *iface_info)
 130 {
 131     PyGIInterfaceCache *ic;
 132
 133     ic = g_slice_new0 (PyGIInterfaceCache);
 134     ( (PyGIArgCache *)ic)->destroy_notify = (GDestroyNotify)_interface_cache_free_func;
 135     ic->g_type = g_registered_type_info_get_g_type ( (GIRegisteredTypeInfo *)iface_info);
 136     ic->py_type = _pygi_type_import_by_gi_info ( (GIBaseInfo *) iface_info);
 137
 138     if (ic->py_type == NULL)
 139         return NULL;
 140
 141     ic->type_name = _pygi_g_base_info_get_fullname (iface_info);
 142     return ic;
 143 }
 144
 145 static PyGISequenceCache *
 146 _sequence_cache_new (GITypeInfo *type_info,
 147                      GIDirection direction,
 148                      GITransfer transfer,
 149                      gssize child_offset)
 150 {
 151     PyGISequenceCache *sc;
 152     GITypeInfo *item_type_info;
 153     GITransfer item_transfer;
 154
 155     sc = g_slice_new0 (PyGISequenceCache);
 156     ( (PyGIArgCache *)sc)->destroy_notify = (GDestroyNotify)_sequence_cache_free_func;
 157
 158     sc->is_zero_terminated = g_type_info_is_zero_terminated (type_info);
 159     sc->fixed_size = g_type_info_get_array_fixed_size (type_info);
 160     sc->len_arg_index = g_type_info_get_array_length (type_info);
 161     if (sc->len_arg_index >= 0)
 162         sc->len_arg_index += child_offset;
 163
 164     item_type_info = g_type_info_get_param_type (type_info, 0);
 165
 166     item_transfer =
 167         transfer == GI_TRANSFER_CONTAINER ? GI_TRANSFER_NOTHING : transfer;
 168
 169     sc->item_cache = _arg_cache_new (item_type_info,
 170                                      NULL,
 171                                      NULL,
 172                                      item_transfer,
 173                                      direction,
 174                                      0, 0);
 175
 176     if (sc->item_cache == NULL) {
 177         _pygi_arg_cache_free ( (PyGIArgCache *)sc);
 178         return NULL;
 179     }
 180
 181     sc->item_size = _pygi_g_type_info_size (item_type_info);
 182     g_base_info_unref ( (GIBaseInfo *)item_type_info);
 183
 184     return sc;
 185 }
 186 static PyGIHashCache *
 187 _hash_cache_new (GITypeInfo *type_info,
 188                  GIDirection direction,
 189                  GITransfer transfer)
 190 {
 191     PyGIHashCache *hc;
 192     GITypeInfo *key_type_info;
 193     GITypeInfo *value_type_info;
 194     GITransfer item_transfer;
 195
 196     hc = g_slice_new0 (PyGIHashCache);
 197     ( (PyGIArgCache *)hc)->destroy_notify = (GDestroyNotify)_hash_cache_free_func;
 198     key_type_info = g_type_info_get_param_type (type_info, 0);
 199     value_type_info = g_type_info_get_param_type (type_info, 1);
 200
 201     item_transfer =
 202         transfer == GI_TRANSFER_CONTAINER ? GI_TRANSFER_NOTHING : transfer;
 203
 204     hc->key_cache = _arg_cache_new (key_type_info,
 205                                     NULL,
 206                                     NULL,
 207                                     item_transfer,
 208                                     direction,
 209                                     0, 0);
 210
 211     if (hc->key_cache == NULL) {
 212         _pygi_arg_cache_free ( (PyGIArgCache *)hc);
 213         return NULL;
 214     }
 215
 216     hc->value_cache = _arg_cache_new (value_type_info,
 217                                       NULL,
 218                                       NULL,
 219                                       item_transfer,
 220                                       direction,
 221                                       0, 0);
 222
 223     if (hc->value_cache == NULL) {
 224         _pygi_arg_cache_free ( (PyGIArgCache *)hc);
 225         return NULL;
 226     }
 227
 228     g_base_info_unref( (GIBaseInfo *)key_type_info);
 229     g_base_info_unref( (GIBaseInfo *)value_type_info);
 230
 231     return hc;
 232 }
 233
 234 static PyGICallbackCache *
 235 _callback_cache_new (GIArgInfo *arg_info,
 236                      GIInterfaceInfo *iface_info,
 237                      gssize child_offset)
 238 {
 239    PyGICallbackCache *cc;
 240
 241    cc = g_slice_new0 (PyGICallbackCache);
 242    ( (PyGIArgCache *)cc)->destroy_notify = (GDestroyNotify)_callback_cache_free_func;
 243
 244    cc->user_data_index = g_arg_info_get_closure (arg_info);
 245    if (cc->user_data_index != -1)
 246        cc->user_data_index += child_offset;
 247    cc->destroy_notify_index = g_arg_info_get_destroy (arg_info);
 248    if (cc->destroy_notify_index != -1)
 249        cc->destroy_notify_index += child_offset;
 250    cc->scope = g_arg_info_get_scope (arg_info);
 251    g_base_info_ref( (GIBaseInfo *)iface_info);
 252    cc->interface_info = iface_info;
 253    return cc;
 254 }
 255
 256 static PyGIArgCache *
 257 _arg_cache_alloc (void)
 258 {
 259     return g_slice_new0 (PyGIArgCache);
 260 }
 261
 262 static void
 263 _arg_cache_from_py_void_setup (PyGIArgCache *arg_cache)
 264 {
 265     arg_cache->from_py_marshaller = _pygi_marshal_from_py_void;
 266 }
 267
 268 static void
 269 _arg_cache_to_py_void_setup (PyGIArgCache *arg_cache)
 270 {
 271     arg_cache->to_py_marshaller = _pygi_marshal_to_py_void;
 272 }
 273
 274 static void
 275 _arg_cache_from_py_boolean_setup (PyGIArgCache *arg_cache)
 276 {
 277     arg_cache->from_py_marshaller = _pygi_marshal_from_py_boolean;
 278 }
 279
 280 static void
 281 _arg_cache_to_py_boolean_setup (PyGIArgCache *arg_cache)
 282 {
 283     arg_cache->to_py_marshaller = _pygi_marshal_to_py_boolean;
 284 }
 285
 286 static void
 287 _arg_cache_from_py_int8_setup (PyGIArgCache *arg_cache)
 288 {
 289     arg_cache->from_py_marshaller = _pygi_marshal_from_py_int8;
 290 }
 291
 292 static void
 293 _arg_cache_to_py_int8_setup (PyGIArgCache *arg_cache)
 294 {
 295     arg_cache->to_py_marshaller = _pygi_marshal_to_py_int8;
 296 }
 297
 298 static void
 299 _arg_cache_from_py_uint8_setup (PyGIArgCache *arg_cache)
 300 {
 301     arg_cache->from_py_marshaller = _pygi_marshal_from_py_uint8;
 302 }
 303
 304 static void
 305 _arg_cache_to_py_uint8_setup (PyGIArgCache *arg_cache)
 306 {
 307     arg_cache->to_py_marshaller = _pygi_marshal_to_py_uint8;
 308 }
 309
 310 static void
 311 _arg_cache_from_py_int16_setup (PyGIArgCache *arg_cache)
 312 {
 313     arg_cache->from_py_marshaller = _pygi_marshal_from_py_int16;
 314 }
 315
 316 static void
 317 _arg_cache_to_py_int16_setup (PyGIArgCache *arg_cache)
 318 {
 319     arg_cache->to_py_marshaller = _pygi_marshal_to_py_int16;
 320 }
 321
 322 static void
 323 _arg_cache_from_py_uint16_setup (PyGIArgCache *arg_cache)
 324 {
 325     arg_cache->from_py_marshaller = _pygi_marshal_from_py_uint16;
 326 }
 327
 328 static void
 329 _arg_cache_to_py_uint16_setup (PyGIArgCache *arg_cache)
 330 {
 331     arg_cache->to_py_marshaller = _pygi_marshal_to_py_uint16;
 332 }
 333
 334 static void
 335 _arg_cache_from_py_int32_setup (PyGIArgCache *arg_cache)
 336 {
 337     arg_cache->from_py_marshaller = _pygi_marshal_from_py_int32;
 338 }
 339
 340 static void
 341 _arg_cache_to_py_int32_setup (PyGIArgCache *arg_cache)
 342 {
 343     arg_cache->to_py_marshaller = _pygi_marshal_to_py_int32;
 344 }
 345
 346 static void
 347 _arg_cache_from_py_uint32_setup (PyGIArgCache *arg_cache)
 348 {
 349     arg_cache->from_py_marshaller = _pygi_marshal_from_py_uint32;
 350 }
 351
 352 static void
 353 _arg_cache_to_py_uint32_setup (PyGIArgCache *arg_cache)
 354 {
 355     arg_cache->to_py_marshaller = _pygi_marshal_to_py_uint32;
 356 }
 357
 358 static void
 359 _arg_cache_from_py_int64_setup (PyGIArgCache *arg_cache)
 360 {
 361     arg_cache->from_py_marshaller = _pygi_marshal_from_py_int64;
 362 }
 363
 364 static void
 365 _arg_cache_to_py_int64_setup (PyGIArgCache *arg_cache)
 366 {
 367     arg_cache->to_py_marshaller = _pygi_marshal_to_py_int64;
 368 }
 369
 370 static void
 371 _arg_cache_from_py_uint64_setup (PyGIArgCache *arg_cache)
 372 {
 373     arg_cache->from_py_marshaller = _pygi_marshal_from_py_uint64;
 374 }
 375
 376 static void
 377 _arg_cache_to_py_uint64_setup (PyGIArgCache *arg_cache)
 378 {
 379     arg_cache->to_py_marshaller = _pygi_marshal_to_py_uint64;
 380 }
 381
 382 static void
 383 _arg_cache_from_py_float_setup (PyGIArgCache *arg_cache)
 384 {
 385     arg_cache->from_py_marshaller = _pygi_marshal_from_py_float;
 386 }
 387
 388 static void
 389 _arg_cache_to_py_float_setup (PyGIArgCache *arg_cache)
 390 {
 391     arg_cache->to_py_marshaller = _pygi_marshal_to_py_float;
 392 }
 393
 394 static void
 395 _arg_cache_from_py_double_setup (PyGIArgCache *arg_cache)
 396 {
 397     arg_cache->from_py_marshaller = _pygi_marshal_from_py_double;
 398 }
 399
 400 static void
 401 _arg_cache_to_py_double_setup (PyGIArgCache *arg_cache)
 402 {
 403     arg_cache->to_py_marshaller = _pygi_marshal_to_py_double;
 404 }
 405
 406 static void
 407 _arg_cache_from_py_unichar_setup (PyGIArgCache *arg_cache)
 408 {
 409     arg_cache->from_py_marshaller = _pygi_marshal_from_py_unichar;
 410 }
 411
 412 static void
 413 _arg_cache_to_py_unichar_setup (PyGIArgCache *arg_cache)
 414 {
 415     arg_cache->to_py_marshaller = _pygi_marshal_to_py_unichar;
 416 }
 417
 418 static void
 419 _arg_cache_from_py_gtype_setup (PyGIArgCache *arg_cache)
 420 {
 421     arg_cache->from_py_marshaller = _pygi_marshal_from_py_gtype;
 422 }
 423
 424 static void
 425 _arg_cache_to_py_gtype_setup (PyGIArgCache *arg_cache)
 426 {
 427     arg_cache->to_py_marshaller = _pygi_marshal_to_py_gtype;
 428 }
 429
 430 static void
 431 _arg_cache_from_py_utf8_setup (PyGIArgCache *arg_cache,
 432                                GITransfer transfer)
 433 {
 434     arg_cache->from_py_marshaller = _pygi_marshal_from_py_utf8;
 435     arg_cache->from_py_cleanup = _pygi_marshal_cleanup_from_py_utf8;
 436 }
 437
 438 static void
 439 _arg_cache_to_py_utf8_setup (PyGIArgCache *arg_cache,
 440                                GITransfer transfer)
 441 {
 442     arg_cache->to_py_marshaller = _pygi_marshal_to_py_utf8;
 443     arg_cache->to_py_cleanup = _pygi_marshal_cleanup_to_py_utf8;
 444 }
 445
 446 static void
 447 _arg_cache_from_py_filename_setup (PyGIArgCache *arg_cache,
 448                                  GITransfer transfer)
 449 {
 450     arg_cache->from_py_marshaller = _pygi_marshal_from_py_filename;
 451     arg_cache->from_py_cleanup = _pygi_marshal_cleanup_from_py_utf8;
 452 }
 453
 454 static void
 455 _arg_cache_to_py_filename_setup (PyGIArgCache *arg_cache,
 456                                  GITransfer transfer)
 457 {
 458     arg_cache->to_py_marshaller = _pygi_marshal_to_py_filename;
 459     arg_cache->to_py_cleanup = _pygi_marshal_cleanup_to_py_utf8;
 460 }
 461
 462 static gboolean
 463 _arg_cache_from_py_array_setup (PyGIArgCache *arg_cache,
 464                                 PyGICallableCache *callable_cache,
 465                                 GITypeInfo *type_info,
 466                                 GITransfer transfer,
 467                                 PyGIDirection direction,
 468                                 gssize arg_index)
 469 {
 470     PyGISequenceCache *seq_cache = (PyGISequenceCache *)arg_cache;
 471     seq_cache->array_type = g_type_info_get_array_type (type_info);
 472
 473     arg_cache->from_py_marshaller = _pygi_marshal_from_py_array;
 474
 475     if (seq_cache->len_arg_index >= 0) {
 476         PyGIArgCache *child_cache =
 477             callable_cache->args_cache[seq_cache->len_arg_index];
 478
 479         if (child_cache == NULL) {
 480             child_cache = _arg_cache_alloc ();
 481         } else if (child_cache->meta_type == PYGI_META_ARG_TYPE_CHILD ||
 482                    child_cache->meta_type == PYGI_META_ARG_TYPE_CHILD_NEEDS_UPDATE) {
 483             return TRUE;
 484         }
 485
 486         if (seq_cache->len_arg_index < arg_index)
 487             child_cache->meta_type = PYGI_META_ARG_TYPE_CHILD_NEEDS_UPDATE;
 488         else
 489             child_cache->meta_type = PYGI_META_ARG_TYPE_CHILD;
 490
 491         child_cache->direction = direction;
 492         child_cache->to_py_marshaller = NULL;
 493         child_cache->from_py_marshaller = NULL;
 494
 495         callable_cache->args_cache[seq_cache->len_arg_index] = child_cache;
 496     }
 497
 498     arg_cache->from_py_cleanup = _pygi_marshal_cleanup_from_py_array;
 499
 500     return TRUE;
 501 }
 502
 503 static gboolean
 504 _arg_cache_to_py_array_setup (PyGIArgCache *arg_cache,
 505                               PyGICallableCache *callable_cache,
 506                               GITypeInfo *type_info,
 507                               GITransfer transfer,
 508                               PyGIDirection direction,
 509                               gssize arg_index)
 510 {
 511     PyGISequenceCache *seq_cache = (PyGISequenceCache *)arg_cache;
 512     arg_cache->to_py_marshaller = _pygi_marshal_to_py_array;
 513     arg_cache->to_py_cleanup = _pygi_marshal_cleanup_to_py_array;
 514
 515     seq_cache->array_type = g_type_info_get_array_type (type_info);
 516
 517     if (seq_cache->len_arg_index >= 0) {
 518         PyGIArgCache *child_cache = callable_cache->args_cache[seq_cache->len_arg_index];
 519         if (seq_cache->len_arg_index < arg_index)
 520              callable_cache->n_to_py_child_args++;
 521
 522         if (child_cache != NULL) {
 523             callable_cache->to_py_args =
 524                 g_slist_remove (callable_cache->to_py_args, child_cache);
 525
 526             if (child_cache->meta_type == PYGI_META_ARG_TYPE_CHILD ||
 527                 child_cache->meta_type == PYGI_META_ARG_TYPE_CHILD_NEEDS_UPDATE)
 528                 return TRUE;
 529         } else {
 530             child_cache = _arg_cache_alloc ();
 531         }
 532
 533         child_cache->meta_type = PYGI_META_ARG_TYPE_CHILD;
 534         child_cache->direction = direction;
 535         child_cache->to_py_marshaller = NULL;
 536         child_cache->from_py_marshaller = NULL;
 537
 538         callable_cache->args_cache[seq_cache->len_arg_index] = child_cache;
 539     }
 540
 541     return TRUE;
 542 }
 543
 544 static void
 545 _arg_cache_from_py_glist_setup (PyGIArgCache *arg_cache,
 546                                 GITransfer transfer)
 547 {
 548     arg_cache->from_py_marshaller = _pygi_marshal_from_py_glist;
 549     arg_cache->from_py_cleanup = _pygi_marshal_cleanup_from_py_glist;
 550 }
 551
 552 static void
 553 _arg_cache_to_py_glist_setup (PyGIArgCache *arg_cache,
 554                               GITransfer transfer)
 555 {
 556     arg_cache->to_py_marshaller = _pygi_marshal_to_py_glist;
 557     arg_cache->to_py_cleanup = _pygi_marshal_cleanup_to_py_glist;
 558 }
 559
 560 static void
 561 _arg_cache_from_py_gslist_setup (PyGIArgCache *arg_cache,
 562                                  GITransfer transfer)
 563 {
 564     arg_cache->from_py_marshaller = _pygi_marshal_from_py_gslist;
 565     arg_cache->from_py_cleanup = _pygi_marshal_cleanup_from_py_glist;
 566 }
 567
 568 static void
 569 _arg_cache_to_py_gslist_setup (PyGIArgCache *arg_cache,
 570                                  GITransfer transfer)
 571 {
 572     arg_cache->to_py_marshaller = _pygi_marshal_to_py_gslist;
 573     arg_cache->to_py_cleanup = _pygi_marshal_cleanup_to_py_glist;
 574 }
 575
 576 static void
 577 _arg_cache_from_py_ghash_setup (PyGIArgCache *arg_cache)
 578 {
 579     arg_cache->from_py_marshaller = _pygi_marshal_from_py_ghash;
 580     arg_cache->from_py_cleanup = _pygi_marshal_cleanup_from_py_ghash;
 581 }
 582
 583 static void
 584 _arg_cache_to_py_ghash_setup (PyGIArgCache *arg_cache)
 585 {
 586     arg_cache->to_py_marshaller = _pygi_marshal_to_py_ghash;
 587     arg_cache->to_py_cleanup = _pygi_marshal_cleanup_to_py_ghash;
 588 }
 589
 590 static void
 591 _arg_cache_from_py_gerror_setup (PyGIArgCache *arg_cache)
 592 {
 593     arg_cache->from_py_marshaller = _pygi_marshal_from_py_gerror;
 594     arg_cache->meta_type = PYGI_META_ARG_TYPE_CHILD;
 595 }
 596
 597 static void
 598 _arg_cache_to_py_gerror_setup (PyGIArgCache *arg_cache)
 599 {
 600     arg_cache->to_py_marshaller = _pygi_marshal_to_py_gerror;
 601     arg_cache->meta_type = PYGI_META_ARG_TYPE_CHILD;
 602 }
 603
 604 static void
 605 _arg_cache_from_py_interface_union_setup (PyGIArgCache *arg_cache,
 606                                           GITransfer transfer)
 607 {
 608     arg_cache->from_py_marshaller = _pygi_marshal_from_py_interface_struct;
 609 }
 610
 611 static void
 612 _arg_cache_to_py_interface_union_setup (PyGIArgCache *arg_cache,
 613                                         GITransfer transfer)
 614 {
 615     arg_cache->to_py_marshaller = _pygi_marshal_to_py_interface_struct;
 616 }
 617
 618 static void
 619 _arg_cache_from_py_interface_struct_setup (PyGIArgCache *arg_cache,
 620                                            GIInterfaceInfo *iface_info,
 621                                            GITransfer transfer)
 622 {
 623     PyGIInterfaceCache *iface_cache = (PyGIInterfaceCache *)arg_cache;
 624     iface_cache->is_foreign = g_struct_info_is_foreign ( (GIStructInfo*)iface_info);
 625     arg_cache->from_py_marshaller = _pygi_marshal_from_py_interface_struct;
 626
 627     if (iface_cache->g_type == G_TYPE_VALUE)
 628         arg_cache->from_py_cleanup = _pygi_marshal_cleanup_from_py_interface_struct_gvalue;
 629     else if (iface_cache->is_foreign)
 630         arg_cache->from_py_cleanup = _pygi_marshal_cleanup_from_py_interface_struct_foreign;
 631 }
 632
 633 static void
 634 _arg_cache_to_py_interface_struct_setup (PyGIArgCache *arg_cache,
 635                                          GIInterfaceInfo *iface_info,
 636                                          GITransfer transfer)
 637 {
 638     PyGIInterfaceCache *iface_cache = (PyGIInterfaceCache *)arg_cache;
 639     iface_cache->is_foreign = g_struct_info_is_foreign ( (GIStructInfo*)iface_info);
 640     arg_cache->to_py_marshaller = _pygi_marshal_to_py_interface_struct;
 641
 642     if (iface_cache->is_foreign)
 643         arg_cache->to_py_cleanup = _pygi_marshal_cleanup_to_py_interface_struct_foreign;
 644 }
 645
 646 static void
 647 _arg_cache_from_py_interface_object_setup (PyGIArgCache *arg_cache,
 648                                            GITransfer transfer)
 649 {
 650     arg_cache->from_py_marshaller = _pygi_marshal_from_py_interface_object;
 651     arg_cache->from_py_cleanup = _pygi_marshal_cleanup_from_py_interface_object;
 652 }
 653
 654 static void
 655 _arg_cache_to_py_interface_object_setup (PyGIArgCache *arg_cache,
 656                                          GITransfer transfer)
 657 {
 658     arg_cache->to_py_marshaller = _pygi_marshal_to_py_interface_object;
 659     arg_cache->to_py_cleanup = _pygi_marshal_cleanup_to_py_interface_object;
 660 }
 661
 662 static void
 663 _arg_cache_from_py_interface_callback_setup (PyGIArgCache *arg_cache,
 664                                              PyGICallableCache *callable_cache)
 665 {
 666     PyGICallbackCache *callback_cache = (PyGICallbackCache *)arg_cache;
 667     if (callback_cache->user_data_index >= 0) {
 668         PyGIArgCache *user_data_arg_cache = _arg_cache_alloc ();
 669         user_data_arg_cache->meta_type = PYGI_META_ARG_TYPE_CHILD_WITH_PYARG;
 670         user_data_arg_cache->direction = PYGI_DIRECTION_FROM_PYTHON;
 671         callable_cache->args_cache[callback_cache->user_data_index] = user_data_arg_cache;
 672     }
 673
 674     if (callback_cache->destroy_notify_index >= 0) {
 675         PyGIArgCache *destroy_arg_cache = _arg_cache_alloc ();
 676         destroy_arg_cache->meta_type = PYGI_META_ARG_TYPE_CHILD;
 677         destroy_arg_cache->direction = PYGI_DIRECTION_FROM_PYTHON;
 678         callable_cache->args_cache[callback_cache->destroy_notify_index] = destroy_arg_cache;
 679     }
 680     arg_cache->from_py_marshaller = _pygi_marshal_from_py_interface_callback;
 681 }
 682
 683 static void
 684 _arg_cache_to_py_interface_callback_setup (void)
 685 {
 686     PyErr_Format(PyExc_NotImplementedError,
 687                  "Callback returns are not supported");
 688 }
 689
 690 static void
 691 _arg_cache_from_py_interface_enum_setup (PyGIArgCache *arg_cache,
 692                                          GITransfer transfer)
 693 {
 694     arg_cache->from_py_marshaller = _pygi_marshal_from_py_interface_enum;
 695 }
 696
 697 static void
 698 _arg_cache_to_py_interface_enum_setup (PyGIArgCache *arg_cache,
 699                                        GITransfer transfer)
 700 {
 701     arg_cache->to_py_marshaller = _pygi_marshal_to_py_interface_enum;
 702 }
 703
 704 static void
 705 _arg_cache_from_py_interface_flags_setup (PyGIArgCache *arg_cache,
 706                                           GITransfer transfer)
 707 {
 708     arg_cache->from_py_marshaller = _pygi_marshal_from_py_interface_flags;
 709 }
 710
 711 static void
 712 _arg_cache_to_py_interface_flags_setup (PyGIArgCache *arg_cache,
 713                                         GITransfer transfer)
 714 {
 715     arg_cache->to_py_marshaller = _pygi_marshal_to_py_interface_flags;
 716 }
 717
 718 PyGIArgCache *
 719 _arg_cache_new_for_interface (GIInterfaceInfo *iface_info,
 720                               PyGICallableCache *callable_cache,
 721                               GIArgInfo *arg_info,
 722                               GITransfer transfer,
 723                               PyGIDirection direction,
 724                               gssize c_arg_index,
 725                               gssize py_arg_index)
 726 {
 727     PyGIInterfaceCache *iface_cache = NULL;
 728     PyGIArgCache *arg_cache = NULL;
 729     gssize child_offset = 0;
 730     GIInfoType info_type;
 731
 732     if (callable_cache != NULL)
 733         child_offset =
 734             (callable_cache->function_type == PYGI_FUNCTION_TYPE_METHOD ||
 735                  callable_cache->function_type == PYGI_FUNCTION_TYPE_VFUNC) ? 1: 0;
 736
 737     info_type = g_base_info_get_type ( (GIBaseInfo *)iface_info);
 738
 739     /* Callbacks are special cased */
 740     if (info_type != GI_INFO_TYPE_CALLBACK) {
 741         iface_cache = _interface_cache_new (iface_info);
 742
 743         arg_cache = (PyGIArgCache *)iface_cache;
 744         if (arg_cache == NULL)
 745             return NULL;
 746     }
 747
 748     switch (info_type) {
 749         case GI_INFO_TYPE_UNION:
 750             if (direction == PYGI_DIRECTION_FROM_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
 751                _arg_cache_from_py_interface_union_setup (arg_cache, transfer);
 752
 753             if (direction == PYGI_DIRECTION_TO_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
 754                _arg_cache_to_py_interface_union_setup (arg_cache, transfer);
 755
 756             break;
 757         case GI_INFO_TYPE_STRUCT:
 758             if (direction == PYGI_DIRECTION_FROM_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
 759                _arg_cache_from_py_interface_struct_setup (arg_cache,
 760                                                           iface_info,
 761                                                           transfer);
 762
 763             if (direction == PYGI_DIRECTION_TO_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
 764                _arg_cache_to_py_interface_struct_setup (arg_cache,
 765                                                         iface_info,
 766                                                         transfer);
 767             break;
 768         case GI_INFO_TYPE_OBJECT:
 769         case GI_INFO_TYPE_INTERFACE:
 770             if (direction == PYGI_DIRECTION_FROM_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
 771                _arg_cache_from_py_interface_object_setup (arg_cache, transfer);
 772
 773             if (direction == PYGI_DIRECTION_TO_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
 774                _arg_cache_to_py_interface_object_setup (arg_cache, transfer);
 775
 776             break;
 777         case GI_INFO_TYPE_BOXED:
 778             if (direction == PYGI_DIRECTION_FROM_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
 779                 _arg_cache_from_py_interface_struct_setup (arg_cache,
 780                                                        iface_info,
 781                                                        transfer);
 782
 783             if (direction == PYGI_DIRECTION_TO_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
 784                 _arg_cache_to_py_interface_struct_setup (arg_cache,
 785                                                       iface_info,
 786                                                       transfer);
 787             break;
 788         case GI_INFO_TYPE_CALLBACK:
 789             {
 790                 PyGICallbackCache *callback_cache;
 791
 792                 if (direction == PYGI_DIRECTION_TO_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL) {
 793                     _arg_cache_to_py_interface_callback_setup ();
 794                     return NULL;
 795                 }
 796
 797                 callback_cache =
 798                     _callback_cache_new (arg_info,
 799                                          iface_info,
 800                                          child_offset);
 801
 802                 arg_cache = (PyGIArgCache *)callback_cache;
 803                 if (arg_cache == NULL)
 804                     return NULL;
 805
 806                 if (direction == PYGI_DIRECTION_FROM_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
 807                     _arg_cache_from_py_interface_callback_setup (arg_cache, callable_cache);
 808
 809                 break;
 810             }
 811         case GI_INFO_TYPE_ENUM:
 812             if (direction == PYGI_DIRECTION_FROM_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
 813                _arg_cache_from_py_interface_enum_setup (arg_cache, transfer);
 814
 815             if (direction == PYGI_DIRECTION_TO_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
 816                _arg_cache_to_py_interface_enum_setup (arg_cache, transfer);
 817
 818             break;
 819         case GI_INFO_TYPE_FLAGS:
 820             if (direction == PYGI_DIRECTION_FROM_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
 821                _arg_cache_from_py_interface_flags_setup (arg_cache, transfer);
 822
 823             if (direction == PYGI_DIRECTION_TO_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
 824                _arg_cache_to_py_interface_flags_setup (arg_cache, transfer);
 825
 826             break;
 827         default:
 828             g_assert_not_reached ();
 829     }
 830
 831     if (arg_cache != NULL) {
 832         arg_cache->direction = direction;
 833         arg_cache->transfer = transfer;
 834         arg_cache->type_tag = GI_TYPE_TAG_INTERFACE;
 835         arg_cache->py_arg_index = py_arg_index;
 836         arg_cache->c_arg_index = c_arg_index;
 837
 838         if (iface_cache != NULL) {
 839             g_base_info_ref ( (GIBaseInfo *)iface_info);
 840             iface_cache->interface_info = iface_info;
 841         }
 842     }
 843
 844     return arg_cache;
 845 }
 846
 847 PyGIArgCache *
 848 _arg_cache_new (GITypeInfo *type_info,
 849                 PyGICallableCache *callable_cache,
 850                 GIArgInfo *arg_info,
 851                 GITransfer transfer,
 852                 PyGIDirection direction,
 853                 gssize c_arg_index,
 854                 gssize py_arg_index)
 855 {
 856     PyGIArgCache *arg_cache = NULL;
 857     gssize child_offset = 0;
 858     GITypeTag type_tag;
 859
 860     type_tag = g_type_info_get_tag (type_info);
 861
 862     if (callable_cache != NULL)
 863         child_offset =
 864             (callable_cache->function_type == PYGI_FUNCTION_TYPE_METHOD ||
 865                 callable_cache->function_type == PYGI_FUNCTION_TYPE_VFUNC) ? 1: 0;
 866
 867     switch (type_tag) {
 868        case GI_TYPE_TAG_VOID:
 869            arg_cache = _arg_cache_alloc ();
 870            if (arg_cache == NULL)
 871                break;
 872
 873            if (direction == PYGI_DIRECTION_FROM_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
 874                _arg_cache_from_py_void_setup (arg_cache);
 875
 876            if (direction == PYGI_DIRECTION_TO_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
 877                _arg_cache_to_py_void_setup (arg_cache);
 878
 879            break;
 880        case GI_TYPE_TAG_BOOLEAN:
 881            arg_cache = _arg_cache_alloc ();
 882            if (arg_cache == NULL)
 883                break;
 884
 885            if (direction == PYGI_DIRECTION_FROM_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
 886                _arg_cache_from_py_boolean_setup (arg_cache);
 887
 888            if (direction == PYGI_DIRECTION_TO_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
 889                _arg_cache_to_py_boolean_setup (arg_cache);
 890
 891            break;
 892        case GI_TYPE_TAG_INT8:
 893            arg_cache = _arg_cache_alloc ();
 894            if (arg_cache == NULL)
 895                break;
 896
 897            if (direction == PYGI_DIRECTION_FROM_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
 898                _arg_cache_from_py_int8_setup (arg_cache);
 899
 900            if (direction == PYGI_DIRECTION_TO_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
 901                _arg_cache_to_py_int8_setup (arg_cache);
 902
 903            break;
 904        case GI_TYPE_TAG_UINT8:
 905            arg_cache = _arg_cache_alloc ();
 906            if (arg_cache == NULL)
 907                break;
 908
 909            if (direction == PYGI_DIRECTION_FROM_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
 910                _arg_cache_from_py_uint8_setup (arg_cache);
 911
 912            if (direction == PYGI_DIRECTION_TO_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
 913                _arg_cache_to_py_uint8_setup (arg_cache);
 914
 915            break;
 916        case GI_TYPE_TAG_INT16:
 917            arg_cache = _arg_cache_alloc ();
 918            if (arg_cache == NULL)
 919                break;
 920
 921            if (direction == PYGI_DIRECTION_FROM_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
 922                _arg_cache_from_py_int16_setup (arg_cache);
 923
 924            if (direction == PYGI_DIRECTION_TO_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
 925                _arg_cache_to_py_int16_setup (arg_cache);
 926
 927            break;
 928        case GI_TYPE_TAG_UINT16:
 929            arg_cache = _arg_cache_alloc ();
 930            if (arg_cache == NULL)
 931                break;
 932
 933            if (direction == PYGI_DIRECTION_FROM_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
 934                _arg_cache_from_py_uint16_setup (arg_cache);
 935
 936            if (direction == PYGI_DIRECTION_TO_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
 937                _arg_cache_to_py_uint16_setup (arg_cache);
 938            break;
 939        case GI_TYPE_TAG_INT32:
 940            arg_cache = _arg_cache_alloc ();
 941            if (arg_cache == NULL)
 942                break;
 943
 944            if (direction == PYGI_DIRECTION_FROM_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
 945                _arg_cache_from_py_int32_setup (arg_cache);
 946
 947            if (direction == PYGI_DIRECTION_TO_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
 948                _arg_cache_to_py_int32_setup (arg_cache);
 949
 950            break;
 951        case GI_TYPE_TAG_UINT32:
 952            arg_cache = _arg_cache_alloc ();
 953            if (arg_cache == NULL)
 954                break;
 955
 956            if (direction == PYGI_DIRECTION_FROM_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
 957                _arg_cache_from_py_uint32_setup (arg_cache);
 958
 959            if (direction == PYGI_DIRECTION_TO_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
 960                _arg_cache_to_py_uint32_setup (arg_cache);
 961
 962            break;
 963        case GI_TYPE_TAG_INT64:
 964            arg_cache = _arg_cache_alloc ();
 965            if (arg_cache == NULL)
 966                break;
 967
 968            if (direction == PYGI_DIRECTION_FROM_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
 969                _arg_cache_from_py_int64_setup (arg_cache);
 970
 971            if (direction == PYGI_DIRECTION_TO_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
 972                _arg_cache_to_py_int64_setup (arg_cache);
 973
 974            break;
 975        case GI_TYPE_TAG_UINT64:
 976            arg_cache = _arg_cache_alloc ();
 977            if (arg_cache == NULL)
 978                break;
 979
 980            if (direction == PYGI_DIRECTION_FROM_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
 981                _arg_cache_from_py_uint64_setup (arg_cache);
 982
 983            if (direction == PYGI_DIRECTION_TO_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
 984                _arg_cache_to_py_uint64_setup (arg_cache);
 985
 986            break;
 987        case GI_TYPE_TAG_FLOAT:
 988            arg_cache = _arg_cache_alloc ();
 989            if (arg_cache == NULL)
 990                break;
 991
 992            if (direction == PYGI_DIRECTION_FROM_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
 993                _arg_cache_from_py_float_setup (arg_cache);
 994
 995            if (direction == PYGI_DIRECTION_TO_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
 996                _arg_cache_to_py_float_setup (arg_cache);
 997
 998            break;
 999        case GI_TYPE_TAG_DOUBLE:
1000            arg_cache = _arg_cache_alloc ();
1001            if (arg_cache == NULL)
1002                break;
1003
1004            if (direction == PYGI_DIRECTION_FROM_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
1005                _arg_cache_from_py_double_setup (arg_cache);
1006
1007            if (direction == PYGI_DIRECTION_TO_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
1008                _arg_cache_to_py_double_setup (arg_cache);
1009
1010            break;
1011        case GI_TYPE_TAG_UNICHAR:
1012            arg_cache = _arg_cache_alloc ();
1013            if (arg_cache == NULL)
1014                break;
1015
1016            if (direction == PYGI_DIRECTION_FROM_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
1017                _arg_cache_from_py_unichar_setup (arg_cache);
1018
1019            if (direction == PYGI_DIRECTION_TO_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
1020                _arg_cache_to_py_unichar_setup (arg_cache);
1021
1022            break;
1023        case GI_TYPE_TAG_GTYPE:
1024            arg_cache = _arg_cache_alloc ();
1025            if (arg_cache == NULL)
1026                break;
1027
1028            if (direction == PYGI_DIRECTION_FROM_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
1029                _arg_cache_from_py_gtype_setup (arg_cache);
1030
1031            if (direction == PYGI_DIRECTION_TO_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
1032                _arg_cache_to_py_gtype_setup (arg_cache);
1033
1034            break;
1035        case GI_TYPE_TAG_UTF8:
1036            arg_cache = _arg_cache_alloc ();
1037            if (arg_cache == NULL)
1038                break;
1039
1040            if (direction == PYGI_DIRECTION_FROM_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
1041                _arg_cache_from_py_utf8_setup (arg_cache, transfer);
1042
1043            if (direction == PYGI_DIRECTION_TO_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
1044                _arg_cache_to_py_utf8_setup (arg_cache, transfer);
1045
1046            break;
1047        case GI_TYPE_TAG_FILENAME:
1048            arg_cache = _arg_cache_alloc ();
1049            if (arg_cache == NULL)
1050                break;
1051
1052            if (direction == PYGI_DIRECTION_FROM_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
1053                _arg_cache_from_py_filename_setup (arg_cache, transfer);
1054
1055            if (direction == PYGI_DIRECTION_TO_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
1056                _arg_cache_to_py_filename_setup (arg_cache, transfer);
1057
1058            break;
1059        case GI_TYPE_TAG_ARRAY:
1060            {
1061                PyGISequenceCache *seq_cache =
1062                    _sequence_cache_new (type_info,
1063                                         direction,
1064                                         transfer,
1065                                         child_offset);
1066
1067                arg_cache = (PyGIArgCache *)seq_cache;
1068                if (arg_cache == NULL)
1069                    break;
1070
1071                if (direction == PYGI_DIRECTION_FROM_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
1072                    _arg_cache_from_py_array_setup (arg_cache,
1073                                                    callable_cache,
1074                                                    type_info,
1075                                                    transfer,
1076                                                    direction,
1077                                                    c_arg_index);
1078
1079                if (direction == PYGI_DIRECTION_TO_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
1080                    _arg_cache_to_py_array_setup (arg_cache,
1081                                                  callable_cache,
1082                                                  type_info,
1083                                                  transfer,
1084                                                  direction,
1085                                                  c_arg_index);
1086
1087                /* ugly edge case code:
1088                 *
1089                 * length can come before the array parameter which means we
1090                 * need to update indexes if this happens
1091                 */
1092                if (seq_cache->len_arg_index > -1 &&
1093                    callable_cache->args_cache[seq_cache->len_arg_index]->meta_type == PYGI_META_ARG_TYPE_CHILD_NEEDS_UPDATE) {
1094                    gssize i;
1095                    PyGIArgCache *child_cache =
1096                        callable_cache->args_cache[seq_cache->len_arg_index];
1097
1098                    child_cache->meta_type = PYGI_META_ARG_TYPE_CHILD;
1099                    py_arg_index -= 1;
1100                    callable_cache->n_py_args -= 1;
1101
1102                    for (i = seq_cache->len_arg_index + 1;
1103                           i < callable_cache->n_args;
1104                             i++) {
1105                        PyGIArgCache *update_cache = callable_cache->args_cache[i];
1106                        if (update_cache == NULL)
1107                            break;
1108
1109                        update_cache->py_arg_index -= 1;
1110                    }
1111                }
1112
1113                break;
1114            }
1115        case GI_TYPE_TAG_GLIST:
1116            {
1117                PyGISequenceCache *seq_cache =
1118                    _sequence_cache_new (type_info,
1119                                         direction,
1120                                         transfer,
1121                                         child_offset);
1122
1123                arg_cache = (PyGIArgCache *)seq_cache;
1124                if (arg_cache == NULL)
1125                    break;
1126
1127                if (direction == PYGI_DIRECTION_FROM_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
1128                    _arg_cache_from_py_glist_setup (arg_cache, transfer);
1129
1130                if (direction == PYGI_DIRECTION_TO_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
1131                    _arg_cache_to_py_glist_setup (arg_cache, transfer);
1132
1133
1134                break;
1135            }
1136        case GI_TYPE_TAG_GSLIST:
1137            {
1138                PyGISequenceCache *seq_cache =
1139                    _sequence_cache_new (type_info,
1140                                         direction,
1141                                         transfer,
1142                                         child_offset);
1143
1144                arg_cache = (PyGIArgCache *)seq_cache;
1145                if (arg_cache == NULL)
1146                    break;
1147
1148                if (direction == PYGI_DIRECTION_FROM_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
1149                    _arg_cache_from_py_gslist_setup (arg_cache, transfer);
1150
1151                if (direction == PYGI_DIRECTION_TO_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
1152                    _arg_cache_to_py_gslist_setup (arg_cache, transfer);
1153
1154                break;
1155             }
1156        case GI_TYPE_TAG_GHASH:
1157            arg_cache =
1158                (PyGIArgCache *)_hash_cache_new (type_info,
1159                                                 direction,
1160                                                 transfer);
1161
1162            if (arg_cache == NULL)
1163                    break;
1164
1165            if (direction == PYGI_DIRECTION_FROM_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
1166                _arg_cache_from_py_ghash_setup (arg_cache);
1167
1168            if (direction == PYGI_DIRECTION_TO_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL) {
1169                _arg_cache_to_py_ghash_setup (arg_cache);
1170            }
1171
1172            break;
1173        case GI_TYPE_TAG_INTERFACE:
1174            {
1175                GIInterfaceInfo *interface_info = g_type_info_get_interface (type_info);
1176                arg_cache = _arg_cache_new_for_interface (interface_info,
1177                                                          callable_cache,
1178                                                          arg_info,
1179                                                          transfer,
1180                                                          direction,
1181                                                          c_arg_index,
1182                                                          py_arg_index);
1183
1184                g_base_info_unref ( (GIBaseInfo *)interface_info);
1185                break;
1186            }
1187        case GI_TYPE_TAG_ERROR:
1188            arg_cache = _arg_cache_alloc ();
1189            if (arg_cache == NULL)
1190                break;
1191
1192            if (direction == PYGI_DIRECTION_FROM_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
1193                _arg_cache_from_py_gerror_setup (arg_cache);
1194
1195            if (direction == PYGI_DIRECTION_TO_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
1196                _arg_cache_to_py_gerror_setup (arg_cache);
1197
1198            break;
1199     }
1200
1201     if (arg_cache != NULL) {
1202         arg_cache->direction = direction;
1203         arg_cache->transfer = transfer;
1204         arg_cache->type_tag = type_tag;
1205         arg_cache->py_arg_index = py_arg_index;
1206         arg_cache->c_arg_index = c_arg_index;
1207         arg_cache->is_pointer = g_type_info_is_pointer (type_info);
1208         g_base_info_ref ( (GIBaseInfo *) type_info);
1209         arg_cache->type_info = type_info;
1210     }
1211
1212     return arg_cache;
1213 }
1214
1215 static void
1216 _arg_name_list_generate (PyGICallableCache *callable_cache)
1217 {
1218     GSList * arg_name_list = NULL;
1219     int i;
1220
1221     if (callable_cache->arg_name_hash == NULL) {
1222         callable_cache->arg_name_hash = g_hash_table_new (g_str_hash, g_str_equal);
1223     } else {
1224         g_hash_table_remove_all (callable_cache->arg_name_hash);
1225     }
1226
1227     for (i=0; i < callable_cache->n_args; i++) {
1228         PyGIArgCache *arg_cache = NULL;
1229
1230         arg_cache = callable_cache->args_cache[i];
1231
1232         if (arg_cache->meta_type != PYGI_META_ARG_TYPE_CHILD &&
1233             arg_cache->meta_type != PYGI_META_ARG_TYPE_CLOSURE &&
1234                 (arg_cache->direction == PYGI_DIRECTION_FROM_PYTHON ||
1235                  arg_cache->direction == PYGI_DIRECTION_BIDIRECTIONAL)) {
1236
1237             gpointer arg_name = (gpointer)arg_cache->arg_name;
1238
1239             arg_name_list = g_slist_prepend (arg_name_list, arg_name);
1240             if (arg_name != NULL) {
1241                 g_hash_table_insert (callable_cache->arg_name_hash, arg_name, arg_name);
1242             }
1243         }
1244     }
1245
1246     callable_cache->arg_name_list = g_slist_reverse (arg_name_list);
1247 }
1248
1249 /* Generate the cache for the callable's arguments */
1250 static gboolean
1251 _args_cache_generate (GICallableInfo *callable_info,
1252                       PyGICallableCache *callable_cache)
1253 {
1254     gssize arg_index = 0;
1255     gssize i;
1256     GITypeInfo *return_info;
1257     GITransfer return_transfer;
1258     PyGIArgCache *return_cache;
1259     PyGIDirection return_direction;
1260
1261     /* determine if we are marshalling the return to or from python */
1262     if (callable_cache->function_type == PYGI_FUNCTION_TYPE_CALLBACK)
1263         return_direction = PYGI_DIRECTION_FROM_PYTHON;
1264     else
1265         return_direction = PYGI_DIRECTION_TO_PYTHON;
1266
1267     /* cache the return arg */
1268     return_info =
1269         g_callable_info_get_return_type (callable_info);
1270     return_transfer =
1271         g_callable_info_get_caller_owns (callable_info);
1272     return_cache =
1273         _arg_cache_new (return_info,
1274                         callable_cache,
1275                         NULL,
1276                         return_transfer,
1277                         return_direction,
1278                         -1,
1279                         -1);
1280     if (return_cache == NULL)
1281         return FALSE;
1282
1283     return_cache->is_skipped = g_callable_info_skip_return (callable_info);
1284     callable_cache->return_cache = return_cache;
1285     g_base_info_unref (return_info);
1286
1287     /* first arg is the instance */
1288     if (callable_cache->function_type == PYGI_FUNCTION_TYPE_METHOD ||
1289             callable_cache->function_type == PYGI_FUNCTION_TYPE_VFUNC) {
1290         GIInterfaceInfo *interface_info;
1291         PyGIArgCache *instance_cache;
1292         PyGIDirection instance_direction;
1293
1294         instance_direction = PYGI_DIRECTION_FROM_PYTHON;
1295
1296
1297         interface_info = g_base_info_get_container ( (GIBaseInfo *)callable_info);
1298
1299         instance_cache =
1300             _arg_cache_new_for_interface (interface_info,
1301                                           callable_cache,
1302                                           NULL,
1303                                           GI_TRANSFER_NOTHING,
1304                                           instance_direction,
1305                                           arg_index,
1306                                           0);
1307
1308         /* FIXME: marshal interfaces from_py */
1309         instance_cache->from_py_marshaller = _pygi_marshal_from_py_interface_instance;
1310         g_base_info_unref ( (GIBaseInfo *)interface_info);
1311
1312         if (instance_cache == NULL)
1313             return FALSE;
1314
1315         callable_cache->args_cache[arg_index] = instance_cache;
1316
1317         arg_index++;
1318         callable_cache->n_from_py_args++;
1319         callable_cache->n_py_args++;
1320     }
1321
1322
1323     for (i=0; arg_index < callable_cache->n_args; arg_index++, i++) {
1324         PyGIArgCache *arg_cache = NULL;
1325         GIArgInfo *arg_info;
1326         GITypeInfo *type_info;
1327         GIDirection gi_direction;
1328         PyGIDirection direction;
1329         GITransfer transfer;
1330         GITypeTag type_tag;
1331         gboolean is_caller_allocates = FALSE;
1332         gssize py_arg_index = -1;
1333
1334         arg_info = g_callable_info_get_arg (callable_info, i);
1335
1336         if (g_arg_info_get_closure (arg_info) == i) {
1337
1338             arg_cache = _arg_cache_alloc ();
1339             callable_cache->args_cache[arg_index] = arg_cache;
1340
1341             arg_cache->arg_name = g_base_info_get_name ((GIBaseInfo *) arg_info);
1342             arg_cache->direction = PYGI_DIRECTION_FROM_PYTHON;
1343             arg_cache->meta_type = PYGI_META_ARG_TYPE_CLOSURE;
1344             arg_cache->c_arg_index = i;
1345
1346             callable_cache->n_from_py_args++;
1347
1348             g_base_info_unref ( (GIBaseInfo *)arg_info);
1349
1350             continue;
1351         }
1352
1353         /* For vfuncs and callbacks our marshalling directions
1354            are reversed */
1355         gi_direction = g_arg_info_get_direction (arg_info);
1356         if (gi_direction == GI_DIRECTION_INOUT) {
1357             direction = PYGI_DIRECTION_BIDIRECTIONAL;
1358         } else if (gi_direction == GI_DIRECTION_IN) {
1359             direction = PYGI_DIRECTION_FROM_PYTHON;
1360             if (callable_cache->function_type == PYGI_FUNCTION_TYPE_CALLBACK)
1361                 direction = PYGI_DIRECTION_TO_PYTHON;
1362         } else {
1363             direction = PYGI_DIRECTION_TO_PYTHON;
1364             if (callable_cache->function_type == PYGI_FUNCTION_TYPE_CALLBACK)
1365                 direction = PYGI_DIRECTION_FROM_PYTHON;
1366         }
1367
1368         transfer = g_arg_info_get_ownership_transfer (arg_info);
1369         type_info = g_arg_info_get_type (arg_info);
1370         type_tag = g_type_info_get_tag (type_info);
1371
1372         if (type_tag == GI_TYPE_TAG_INTERFACE)
1373             is_caller_allocates = g_arg_info_is_caller_allocates (arg_info);
1374
1375         /* must be an child arg filled in by its owner
1376          * and continue
1377          * fill in it's c_arg_index, add to the in count
1378          */
1379         if (callable_cache->args_cache[arg_index] != NULL) {
1380             arg_cache = callable_cache->args_cache[arg_index];
1381             if (arg_cache->meta_type == PYGI_META_ARG_TYPE_CHILD_WITH_PYARG) {
1382                 arg_cache->py_arg_index = callable_cache->n_py_args;
1383                 callable_cache->n_py_args++;
1384             }
1385
1386             if (direction == PYGI_DIRECTION_FROM_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL) {
1387                 arg_cache->c_arg_index = callable_cache->n_from_py_args;
1388                 callable_cache->n_from_py_args++;
1389             }
1390
1391             if (direction == PYGI_DIRECTION_TO_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL) {
1392                 callable_cache->n_to_py_args++;
1393                 callable_cache->n_to_py_child_args++;
1394             }
1395
1396             arg_cache->type_tag = g_type_info_get_tag (type_info);
1397
1398             g_base_info_unref ( (GIBaseInfo *)arg_info);
1399             continue;
1400         }
1401
1402         if (direction == PYGI_DIRECTION_FROM_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL) {
1403             py_arg_index = callable_cache->n_py_args;
1404             callable_cache->n_from_py_args++;
1405             callable_cache->n_py_args++;
1406         }
1407
1408         arg_cache =
1409             _arg_cache_new (type_info,
1410                             callable_cache,
1411                             arg_info,
1412                             transfer,
1413                             direction,
1414                             arg_index,
1415                             py_arg_index);
1416
1417         if (arg_cache == NULL)
1418             goto arg_err;
1419
1420         arg_cache->arg_name = g_base_info_get_name ((GIBaseInfo *) arg_info);
1421         arg_cache->allow_none = g_arg_info_may_be_null(arg_info);
1422         arg_cache->is_caller_allocates = is_caller_allocates;
1423
1424         if (direction == PYGI_DIRECTION_TO_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL) {
1425             callable_cache->n_to_py_args++;
1426
1427             if (arg_cache == NULL)
1428                 goto arg_err;
1429
1430             callable_cache->to_py_args =
1431                 g_slist_append (callable_cache->to_py_args, arg_cache);
1432         }
1433
1434         callable_cache->args_cache[arg_index] = arg_cache;
1435         g_base_info_unref( (GIBaseInfo *)type_info);
1436         g_base_info_unref( (GIBaseInfo *)arg_info);
1437
1438         continue;
1439 arg_err:
1440         g_base_info_unref( (GIBaseInfo *)type_info);
1441         g_base_info_unref( (GIBaseInfo *)arg_info);
1442         return FALSE;
1443     }
1444
1445     _arg_name_list_generate (callable_cache);
1446
1447     return TRUE;
1448 }
1449
1450 PyGICallableCache *
1451 _pygi_callable_cache_new (GICallableInfo *callable_info, gboolean is_ccallback)
1452 {
1453     PyGICallableCache *cache;
1454     GIInfoType type = g_base_info_get_type ( (GIBaseInfo *)callable_info);
1455
1456     cache = g_slice_new0 (PyGICallableCache);
1457
1458     if (cache == NULL)
1459         return NULL;
1460
1461     cache->name = g_base_info_get_name ((GIBaseInfo *)callable_info);
1462
1463     if (type == GI_INFO_TYPE_FUNCTION) {
1464         GIFunctionInfoFlags flags;
1465
1466         flags = g_function_info_get_flags ( (GIFunctionInfo *)callable_info);
1467
1468         if (flags & GI_FUNCTION_IS_CONSTRUCTOR)
1469             cache->function_type = PYGI_FUNCTION_TYPE_CONSTRUCTOR;
1470         else if (flags & GI_FUNCTION_IS_METHOD)
1471             cache->function_type = PYGI_FUNCTION_TYPE_METHOD;
1472     } else if (type == GI_INFO_TYPE_VFUNC) {
1473         cache->function_type = PYGI_FUNCTION_TYPE_VFUNC;
1474     } else if (type == GI_INFO_TYPE_CALLBACK) {
1475         if (is_ccallback)
1476             cache->function_type = PYGI_FUNCTION_TYPE_CCALLBACK;
1477         else
1478             cache->function_type = PYGI_FUNCTION_TYPE_CALLBACK;
1479     } else {
1480         cache->function_type = PYGI_FUNCTION_TYPE_METHOD;
1481     }
1482
1483     cache->n_args = g_callable_info_get_n_args (callable_info);
1484
1485     /* if we are a method or vfunc make sure the instance parameter is counted */
1486     if (cache->function_type == PYGI_FUNCTION_TYPE_METHOD ||
1487             cache->function_type == PYGI_FUNCTION_TYPE_VFUNC)
1488         cache->n_args++;
1489
1490     if (cache->n_args > 0)
1491         cache->args_cache = g_slice_alloc0 (cache->n_args * sizeof (PyGIArgCache *));
1492
1493     if (!_args_cache_generate (callable_info, cache))
1494         goto err;
1495
1496     return cache;
1497 err:
1498     _pygi_callable_cache_free (cache);
1499     return NULL;
1500 }