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     arg_cache->from_py_cleanup = _pygi_marshal_cleanup_from_py_interface_callback;
 682 }
 683
 684 static void
 685 _arg_cache_to_py_interface_callback_setup (void)
 686 {
 687     PyErr_Format(PyExc_NotImplementedError,
 688                  "Callback returns are not supported");
 689 }
 690
 691 static void
 692 _arg_cache_from_py_interface_enum_setup (PyGIArgCache *arg_cache,
 693                                          GITransfer transfer)
 694 {
 695     arg_cache->from_py_marshaller = _pygi_marshal_from_py_interface_enum;
 696 }
 697
 698 static void
 699 _arg_cache_to_py_interface_enum_setup (PyGIArgCache *arg_cache,
 700                                        GITransfer transfer)
 701 {
 702     arg_cache->to_py_marshaller = _pygi_marshal_to_py_interface_enum;
 703 }
 704
 705 static void
 706 _arg_cache_from_py_interface_flags_setup (PyGIArgCache *arg_cache,
 707                                           GITransfer transfer)
 708 {
 709     arg_cache->from_py_marshaller = _pygi_marshal_from_py_interface_flags;
 710 }
 711
 712 static void
 713 _arg_cache_to_py_interface_flags_setup (PyGIArgCache *arg_cache,
 714                                         GITransfer transfer)
 715 {
 716     arg_cache->to_py_marshaller = _pygi_marshal_to_py_interface_flags;
 717 }
 718
 719 PyGIArgCache *
 720 _arg_cache_new_for_interface (GIInterfaceInfo *iface_info,
 721                               PyGICallableCache *callable_cache,
 722                               GIArgInfo *arg_info,
 723                               GITransfer transfer,
 724                               PyGIDirection direction,
 725                               gssize c_arg_index,
 726                               gssize py_arg_index)
 727 {
 728     PyGIInterfaceCache *iface_cache = NULL;
 729     PyGIArgCache *arg_cache = NULL;
 730     gssize child_offset = 0;
 731     GIInfoType info_type;
 732
 733     if (callable_cache != NULL)
 734         child_offset =
 735             (callable_cache->function_type == PYGI_FUNCTION_TYPE_METHOD ||
 736                  callable_cache->function_type == PYGI_FUNCTION_TYPE_VFUNC) ? 1: 0;
 737
 738     info_type = g_base_info_get_type ( (GIBaseInfo *)iface_info);
 739
 740     /* Callbacks are special cased */
 741     if (info_type != GI_INFO_TYPE_CALLBACK) {
 742         iface_cache = _interface_cache_new (iface_info);
 743
 744         arg_cache = (PyGIArgCache *)iface_cache;
 745         if (arg_cache == NULL)
 746             return NULL;
 747     }
 748
 749     switch (info_type) {
 750         case GI_INFO_TYPE_UNION:
 751             if (direction == PYGI_DIRECTION_FROM_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
 752                _arg_cache_from_py_interface_union_setup (arg_cache, transfer);
 753
 754             if (direction == PYGI_DIRECTION_TO_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
 755                _arg_cache_to_py_interface_union_setup (arg_cache, transfer);
 756
 757             break;
 758         case GI_INFO_TYPE_STRUCT:
 759             if (direction == PYGI_DIRECTION_FROM_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
 760                _arg_cache_from_py_interface_struct_setup (arg_cache,
 761                                                           iface_info,
 762                                                           transfer);
 763
 764             if (direction == PYGI_DIRECTION_TO_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
 765                _arg_cache_to_py_interface_struct_setup (arg_cache,
 766                                                         iface_info,
 767                                                         transfer);
 768             break;
 769         case GI_INFO_TYPE_OBJECT:
 770         case GI_INFO_TYPE_INTERFACE:
 771             if (direction == PYGI_DIRECTION_FROM_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
 772                _arg_cache_from_py_interface_object_setup (arg_cache, transfer);
 773
 774             if (direction == PYGI_DIRECTION_TO_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
 775                _arg_cache_to_py_interface_object_setup (arg_cache, transfer);
 776
 777             break;
 778         case GI_INFO_TYPE_BOXED:
 779             if (direction == PYGI_DIRECTION_FROM_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
 780                 _arg_cache_from_py_interface_struct_setup (arg_cache,
 781                                                        iface_info,
 782                                                        transfer);
 783
 784             if (direction == PYGI_DIRECTION_TO_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
 785                 _arg_cache_to_py_interface_struct_setup (arg_cache,
 786                                                       iface_info,
 787                                                       transfer);
 788             break;
 789         case GI_INFO_TYPE_CALLBACK:
 790             {
 791                 PyGICallbackCache *callback_cache;
 792
 793                 if (direction == PYGI_DIRECTION_TO_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL) {
 794                     _arg_cache_to_py_interface_callback_setup ();
 795                     return NULL;
 796                 }
 797
 798                 callback_cache =
 799                     _callback_cache_new (arg_info,
 800                                          iface_info,
 801                                          child_offset);
 802
 803                 arg_cache = (PyGIArgCache *)callback_cache;
 804                 if (arg_cache == NULL)
 805                     return NULL;
 806
 807                 if (direction == PYGI_DIRECTION_FROM_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
 808                     _arg_cache_from_py_interface_callback_setup (arg_cache, callable_cache);
 809
 810                 break;
 811             }
 812         case GI_INFO_TYPE_ENUM:
 813             if (direction == PYGI_DIRECTION_FROM_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
 814                _arg_cache_from_py_interface_enum_setup (arg_cache, transfer);
 815
 816             if (direction == PYGI_DIRECTION_TO_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
 817                _arg_cache_to_py_interface_enum_setup (arg_cache, transfer);
 818
 819             break;
 820         case GI_INFO_TYPE_FLAGS:
 821             if (direction == PYGI_DIRECTION_FROM_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
 822                _arg_cache_from_py_interface_flags_setup (arg_cache, transfer);
 823
 824             if (direction == PYGI_DIRECTION_TO_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
 825                _arg_cache_to_py_interface_flags_setup (arg_cache, transfer);
 826
 827             break;
 828         default:
 829             g_assert_not_reached ();
 830     }
 831
 832     if (arg_cache != NULL) {
 833         arg_cache->direction = direction;
 834         arg_cache->transfer = transfer;
 835         arg_cache->type_tag = GI_TYPE_TAG_INTERFACE;
 836         arg_cache->py_arg_index = py_arg_index;
 837         arg_cache->c_arg_index = c_arg_index;
 838
 839         if (iface_cache != NULL) {
 840             g_base_info_ref ( (GIBaseInfo *)iface_info);
 841             iface_cache->interface_info = iface_info;
 842         }
 843     }
 844
 845     return arg_cache;
 846 }
 847
 848 PyGIArgCache *
 849 _arg_cache_new (GITypeInfo *type_info,
 850                 PyGICallableCache *callable_cache,
 851                 GIArgInfo *arg_info,
 852                 GITransfer transfer,
 853                 PyGIDirection direction,
 854                 gssize c_arg_index,
 855                 gssize py_arg_index)
 856 {
 857     PyGIArgCache *arg_cache = NULL;
 858     gssize child_offset = 0;
 859     GITypeTag type_tag;
 860
 861     type_tag = g_type_info_get_tag (type_info);
 862
 863     if (callable_cache != NULL)
 864         child_offset =
 865             (callable_cache->function_type == PYGI_FUNCTION_TYPE_METHOD ||
 866                 callable_cache->function_type == PYGI_FUNCTION_TYPE_VFUNC) ? 1: 0;
 867
 868     switch (type_tag) {
 869        case GI_TYPE_TAG_VOID:
 870            arg_cache = _arg_cache_alloc ();
 871            if (arg_cache == NULL)
 872                break;
 873
 874            if (direction == PYGI_DIRECTION_FROM_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
 875                _arg_cache_from_py_void_setup (arg_cache);
 876
 877            if (direction == PYGI_DIRECTION_TO_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
 878                _arg_cache_to_py_void_setup (arg_cache);
 879
 880            break;
 881        case GI_TYPE_TAG_BOOLEAN:
 882            arg_cache = _arg_cache_alloc ();
 883            if (arg_cache == NULL)
 884                break;
 885
 886            if (direction == PYGI_DIRECTION_FROM_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
 887                _arg_cache_from_py_boolean_setup (arg_cache);
 888
 889            if (direction == PYGI_DIRECTION_TO_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
 890                _arg_cache_to_py_boolean_setup (arg_cache);
 891
 892            break;
 893        case GI_TYPE_TAG_INT8:
 894            arg_cache = _arg_cache_alloc ();
 895            if (arg_cache == NULL)
 896                break;
 897
 898            if (direction == PYGI_DIRECTION_FROM_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
 899                _arg_cache_from_py_int8_setup (arg_cache);
 900
 901            if (direction == PYGI_DIRECTION_TO_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
 902                _arg_cache_to_py_int8_setup (arg_cache);
 903
 904            break;
 905        case GI_TYPE_TAG_UINT8:
 906            arg_cache = _arg_cache_alloc ();
 907            if (arg_cache == NULL)
 908                break;
 909
 910            if (direction == PYGI_DIRECTION_FROM_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
 911                _arg_cache_from_py_uint8_setup (arg_cache);
 912
 913            if (direction == PYGI_DIRECTION_TO_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
 914                _arg_cache_to_py_uint8_setup (arg_cache);
 915
 916            break;
 917        case GI_TYPE_TAG_INT16:
 918            arg_cache = _arg_cache_alloc ();
 919            if (arg_cache == NULL)
 920                break;
 921
 922            if (direction == PYGI_DIRECTION_FROM_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
 923                _arg_cache_from_py_int16_setup (arg_cache);
 924
 925            if (direction == PYGI_DIRECTION_TO_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
 926                _arg_cache_to_py_int16_setup (arg_cache);
 927
 928            break;
 929        case GI_TYPE_TAG_UINT16:
 930            arg_cache = _arg_cache_alloc ();
 931            if (arg_cache == NULL)
 932                break;
 933
 934            if (direction == PYGI_DIRECTION_FROM_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
 935                _arg_cache_from_py_uint16_setup (arg_cache);
 936
 937            if (direction == PYGI_DIRECTION_TO_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
 938                _arg_cache_to_py_uint16_setup (arg_cache);
 939            break;
 940        case GI_TYPE_TAG_INT32:
 941            arg_cache = _arg_cache_alloc ();
 942            if (arg_cache == NULL)
 943                break;
 944
 945            if (direction == PYGI_DIRECTION_FROM_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
 946                _arg_cache_from_py_int32_setup (arg_cache);
 947
 948            if (direction == PYGI_DIRECTION_TO_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
 949                _arg_cache_to_py_int32_setup (arg_cache);
 950
 951            break;
 952        case GI_TYPE_TAG_UINT32:
 953            arg_cache = _arg_cache_alloc ();
 954            if (arg_cache == NULL)
 955                break;
 956
 957            if (direction == PYGI_DIRECTION_FROM_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
 958                _arg_cache_from_py_uint32_setup (arg_cache);
 959
 960            if (direction == PYGI_DIRECTION_TO_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
 961                _arg_cache_to_py_uint32_setup (arg_cache);
 962
 963            break;
 964        case GI_TYPE_TAG_INT64:
 965            arg_cache = _arg_cache_alloc ();
 966            if (arg_cache == NULL)
 967                break;
 968
 969            if (direction == PYGI_DIRECTION_FROM_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
 970                _arg_cache_from_py_int64_setup (arg_cache);
 971
 972            if (direction == PYGI_DIRECTION_TO_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
 973                _arg_cache_to_py_int64_setup (arg_cache);
 974
 975            break;
 976        case GI_TYPE_TAG_UINT64:
 977            arg_cache = _arg_cache_alloc ();
 978            if (arg_cache == NULL)
 979                break;
 980
 981            if (direction == PYGI_DIRECTION_FROM_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
 982                _arg_cache_from_py_uint64_setup (arg_cache);
 983
 984            if (direction == PYGI_DIRECTION_TO_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
 985                _arg_cache_to_py_uint64_setup (arg_cache);
 986
 987            break;
 988        case GI_TYPE_TAG_FLOAT:
 989            arg_cache = _arg_cache_alloc ();
 990            if (arg_cache == NULL)
 991                break;
 992
 993            if (direction == PYGI_DIRECTION_FROM_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
 994                _arg_cache_from_py_float_setup (arg_cache);
 995
 996            if (direction == PYGI_DIRECTION_TO_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
 997                _arg_cache_to_py_float_setup (arg_cache);
 998
 999            break;
1000        case GI_TYPE_TAG_DOUBLE:
1001            arg_cache = _arg_cache_alloc ();
1002            if (arg_cache == NULL)
1003                break;
1004
1005            if (direction == PYGI_DIRECTION_FROM_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
1006                _arg_cache_from_py_double_setup (arg_cache);
1007
1008            if (direction == PYGI_DIRECTION_TO_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
1009                _arg_cache_to_py_double_setup (arg_cache);
1010
1011            break;
1012        case GI_TYPE_TAG_UNICHAR:
1013            arg_cache = _arg_cache_alloc ();
1014            if (arg_cache == NULL)
1015                break;
1016
1017            if (direction == PYGI_DIRECTION_FROM_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
1018                _arg_cache_from_py_unichar_setup (arg_cache);
1019
1020            if (direction == PYGI_DIRECTION_TO_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
1021                _arg_cache_to_py_unichar_setup (arg_cache);
1022
1023            break;
1024        case GI_TYPE_TAG_GTYPE:
1025            arg_cache = _arg_cache_alloc ();
1026            if (arg_cache == NULL)
1027                break;
1028
1029            if (direction == PYGI_DIRECTION_FROM_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
1030                _arg_cache_from_py_gtype_setup (arg_cache);
1031
1032            if (direction == PYGI_DIRECTION_TO_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
1033                _arg_cache_to_py_gtype_setup (arg_cache);
1034
1035            break;
1036        case GI_TYPE_TAG_UTF8:
1037            arg_cache = _arg_cache_alloc ();
1038            if (arg_cache == NULL)
1039                break;
1040
1041            if (direction == PYGI_DIRECTION_FROM_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
1042                _arg_cache_from_py_utf8_setup (arg_cache, transfer);
1043
1044            if (direction == PYGI_DIRECTION_TO_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
1045                _arg_cache_to_py_utf8_setup (arg_cache, transfer);
1046
1047            break;
1048        case GI_TYPE_TAG_FILENAME:
1049            arg_cache = _arg_cache_alloc ();
1050            if (arg_cache == NULL)
1051                break;
1052
1053            if (direction == PYGI_DIRECTION_FROM_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
1054                _arg_cache_from_py_filename_setup (arg_cache, transfer);
1055
1056            if (direction == PYGI_DIRECTION_TO_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
1057                _arg_cache_to_py_filename_setup (arg_cache, transfer);
1058
1059            break;
1060        case GI_TYPE_TAG_ARRAY:
1061            {
1062                PyGISequenceCache *seq_cache =
1063                    _sequence_cache_new (type_info,
1064                                         direction,
1065                                         transfer,
1066                                         child_offset);
1067
1068                arg_cache = (PyGIArgCache *)seq_cache;
1069                if (arg_cache == NULL)
1070                    break;
1071
1072                if (direction == PYGI_DIRECTION_FROM_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
1073                    _arg_cache_from_py_array_setup (arg_cache,
1074                                                    callable_cache,
1075                                                    type_info,
1076                                                    transfer,
1077                                                    direction,
1078                                                    c_arg_index);
1079
1080                if (direction == PYGI_DIRECTION_TO_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
1081                    _arg_cache_to_py_array_setup (arg_cache,
1082                                                  callable_cache,
1083                                                  type_info,
1084                                                  transfer,
1085                                                  direction,
1086                                                  c_arg_index);
1087
1088                /* ugly edge case code:
1089                 *
1090                 * length can come before the array parameter which means we
1091                 * need to update indexes if this happens
1092                 */
1093                if (seq_cache->len_arg_index > -1 &&
1094                    callable_cache->args_cache[seq_cache->len_arg_index]->meta_type == PYGI_META_ARG_TYPE_CHILD_NEEDS_UPDATE) {
1095                    gssize i;
1096                    PyGIArgCache *child_cache =
1097                        callable_cache->args_cache[seq_cache->len_arg_index];
1098
1099                    child_cache->meta_type = PYGI_META_ARG_TYPE_CHILD;
1100                    py_arg_index -= 1;
1101                    callable_cache->n_py_args -= 1;
1102
1103                    for (i = seq_cache->len_arg_index + 1;
1104                           i < callable_cache->n_args;
1105                             i++) {
1106                        PyGIArgCache *update_cache = callable_cache->args_cache[i];
1107                        if (update_cache == NULL)
1108                            break;
1109
1110                        update_cache->py_arg_index -= 1;
1111                    }
1112                }
1113
1114                break;
1115            }
1116        case GI_TYPE_TAG_GLIST:
1117            {
1118                PyGISequenceCache *seq_cache =
1119                    _sequence_cache_new (type_info,
1120                                         direction,
1121                                         transfer,
1122                                         child_offset);
1123
1124                arg_cache = (PyGIArgCache *)seq_cache;
1125                if (arg_cache == NULL)
1126                    break;
1127
1128                if (direction == PYGI_DIRECTION_FROM_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
1129                    _arg_cache_from_py_glist_setup (arg_cache, transfer);
1130
1131                if (direction == PYGI_DIRECTION_TO_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
1132                    _arg_cache_to_py_glist_setup (arg_cache, transfer);
1133
1134
1135                break;
1136            }
1137        case GI_TYPE_TAG_GSLIST:
1138            {
1139                PyGISequenceCache *seq_cache =
1140                    _sequence_cache_new (type_info,
1141                                         direction,
1142                                         transfer,
1143                                         child_offset);
1144
1145                arg_cache = (PyGIArgCache *)seq_cache;
1146                if (arg_cache == NULL)
1147                    break;
1148
1149                if (direction == PYGI_DIRECTION_FROM_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
1150                    _arg_cache_from_py_gslist_setup (arg_cache, transfer);
1151
1152                if (direction == PYGI_DIRECTION_TO_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
1153                    _arg_cache_to_py_gslist_setup (arg_cache, transfer);
1154
1155                break;
1156             }
1157        case GI_TYPE_TAG_GHASH:
1158            arg_cache =
1159                (PyGIArgCache *)_hash_cache_new (type_info,
1160                                                 direction,
1161                                                 transfer);
1162
1163            if (arg_cache == NULL)
1164                    break;
1165
1166            if (direction == PYGI_DIRECTION_FROM_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
1167                _arg_cache_from_py_ghash_setup (arg_cache);
1168
1169            if (direction == PYGI_DIRECTION_TO_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL) {
1170                _arg_cache_to_py_ghash_setup (arg_cache);
1171            }
1172
1173            break;
1174        case GI_TYPE_TAG_INTERFACE:
1175            {
1176                GIInterfaceInfo *interface_info = g_type_info_get_interface (type_info);
1177                arg_cache = _arg_cache_new_for_interface (interface_info,
1178                                                          callable_cache,
1179                                                          arg_info,
1180                                                          transfer,
1181                                                          direction,
1182                                                          c_arg_index,
1183                                                          py_arg_index);
1184
1185                g_base_info_unref ( (GIBaseInfo *)interface_info);
1186                break;
1187            }
1188        case GI_TYPE_TAG_ERROR:
1189            arg_cache = _arg_cache_alloc ();
1190            if (arg_cache == NULL)
1191                break;
1192
1193            if (direction == PYGI_DIRECTION_FROM_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
1194                _arg_cache_from_py_gerror_setup (arg_cache);
1195
1196            if (direction == PYGI_DIRECTION_TO_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL)
1197                _arg_cache_to_py_gerror_setup (arg_cache);
1198
1199            break;
1200     }
1201
1202     if (arg_cache != NULL) {
1203         arg_cache->direction = direction;
1204         arg_cache->transfer = transfer;
1205         arg_cache->type_tag = type_tag;
1206         arg_cache->py_arg_index = py_arg_index;
1207         arg_cache->c_arg_index = c_arg_index;
1208         arg_cache->is_pointer = g_type_info_is_pointer (type_info);
1209         g_base_info_ref ( (GIBaseInfo *) type_info);
1210         arg_cache->type_info = type_info;
1211     }
1212
1213     return arg_cache;
1214 }
1215
1216 static void
1217 _arg_name_list_generate (PyGICallableCache *callable_cache)
1218 {
1219     GSList * arg_name_list = NULL;
1220     int i;
1221
1222     if (callable_cache->arg_name_hash == NULL) {
1223         callable_cache->arg_name_hash = g_hash_table_new (g_str_hash, g_str_equal);
1224     } else {
1225         g_hash_table_remove_all (callable_cache->arg_name_hash);
1226     }
1227
1228     for (i=0; i < callable_cache->n_args; i++) {
1229         PyGIArgCache *arg_cache = NULL;
1230
1231         arg_cache = callable_cache->args_cache[i];
1232
1233         if (arg_cache->meta_type != PYGI_META_ARG_TYPE_CHILD &&
1234             arg_cache->meta_type != PYGI_META_ARG_TYPE_CLOSURE &&
1235                 (arg_cache->direction == PYGI_DIRECTION_FROM_PYTHON ||
1236                  arg_cache->direction == PYGI_DIRECTION_BIDIRECTIONAL)) {
1237
1238             gpointer arg_name = (gpointer)arg_cache->arg_name;
1239
1240             arg_name_list = g_slist_prepend (arg_name_list, arg_name);
1241             if (arg_name != NULL) {
1242                 g_hash_table_insert (callable_cache->arg_name_hash, arg_name, arg_name);
1243             }
1244         }
1245     }
1246
1247     callable_cache->arg_name_list = g_slist_reverse (arg_name_list);
1248 }
1249
1250 /* Generate the cache for the callable's arguments */
1251 static gboolean
1252 _args_cache_generate (GICallableInfo *callable_info,
1253                       PyGICallableCache *callable_cache)
1254 {
1255     gssize arg_index = 0;
1256     gssize i;
1257     GITypeInfo *return_info;
1258     GITransfer return_transfer;
1259     PyGIArgCache *return_cache;
1260     PyGIDirection return_direction;
1261
1262     /* determine if we are marshalling the return to or from python */
1263     if (callable_cache->function_type == PYGI_FUNCTION_TYPE_CALLBACK)
1264         return_direction = PYGI_DIRECTION_FROM_PYTHON;
1265     else
1266         return_direction = PYGI_DIRECTION_TO_PYTHON;
1267
1268     /* cache the return arg */
1269     return_info =
1270         g_callable_info_get_return_type (callable_info);
1271     return_transfer =
1272         g_callable_info_get_caller_owns (callable_info);
1273     return_cache =
1274         _arg_cache_new (return_info,
1275                         callable_cache,
1276                         NULL,
1277                         return_transfer,
1278                         return_direction,
1279                         -1,
1280                         -1);
1281     if (return_cache == NULL)
1282         return FALSE;
1283
1284     return_cache->is_skipped = g_callable_info_skip_return (callable_info);
1285     callable_cache->return_cache = return_cache;
1286     g_base_info_unref (return_info);
1287
1288     /* first arg is the instance */
1289     if (callable_cache->function_type == PYGI_FUNCTION_TYPE_METHOD ||
1290             callable_cache->function_type == PYGI_FUNCTION_TYPE_VFUNC) {
1291         GIInterfaceInfo *interface_info;
1292         PyGIArgCache *instance_cache;
1293         PyGIDirection instance_direction;
1294
1295         instance_direction = PYGI_DIRECTION_FROM_PYTHON;
1296
1297
1298         interface_info = g_base_info_get_container ( (GIBaseInfo *)callable_info);
1299
1300         instance_cache =
1301             _arg_cache_new_for_interface (interface_info,
1302                                           callable_cache,
1303                                           NULL,
1304                                           GI_TRANSFER_NOTHING,
1305                                           instance_direction,
1306                                           arg_index,
1307                                           0);
1308
1309         /* FIXME: marshal interfaces from_py */
1310         instance_cache->from_py_marshaller = _pygi_marshal_from_py_interface_instance;
1311         g_base_info_unref ( (GIBaseInfo *)interface_info);
1312
1313         if (instance_cache == NULL)
1314             return FALSE;
1315
1316         callable_cache->args_cache[arg_index] = instance_cache;
1317
1318         arg_index++;
1319         callable_cache->n_from_py_args++;
1320         callable_cache->n_py_args++;
1321     }
1322
1323
1324     for (i=0; arg_index < callable_cache->n_args; arg_index++, i++) {
1325         PyGIArgCache *arg_cache = NULL;
1326         GIArgInfo *arg_info;
1327         GITypeInfo *type_info;
1328         GIDirection gi_direction;
1329         PyGIDirection direction;
1330         GITransfer transfer;
1331         GITypeTag type_tag;
1332         gboolean is_caller_allocates = FALSE;
1333         gssize py_arg_index = -1;
1334
1335         arg_info = g_callable_info_get_arg (callable_info, i);
1336
1337         if (g_arg_info_get_closure (arg_info) == i) {
1338
1339             arg_cache = _arg_cache_alloc ();
1340             callable_cache->args_cache[arg_index] = arg_cache;
1341
1342             arg_cache->arg_name = g_base_info_get_name ((GIBaseInfo *) arg_info);
1343             arg_cache->direction = PYGI_DIRECTION_FROM_PYTHON;
1344             arg_cache->meta_type = PYGI_META_ARG_TYPE_CLOSURE;
1345             arg_cache->c_arg_index = i;
1346
1347             callable_cache->n_from_py_args++;
1348
1349             g_base_info_unref ( (GIBaseInfo *)arg_info);
1350
1351             continue;
1352         }
1353
1354         /* For vfuncs and callbacks our marshalling directions
1355            are reversed */
1356         gi_direction = g_arg_info_get_direction (arg_info);
1357         if (gi_direction == GI_DIRECTION_INOUT) {
1358             direction = PYGI_DIRECTION_BIDIRECTIONAL;
1359         } else if (gi_direction == GI_DIRECTION_IN) {
1360             direction = PYGI_DIRECTION_FROM_PYTHON;
1361             if (callable_cache->function_type == PYGI_FUNCTION_TYPE_CALLBACK)
1362                 direction = PYGI_DIRECTION_TO_PYTHON;
1363         } else {
1364             direction = PYGI_DIRECTION_TO_PYTHON;
1365             if (callable_cache->function_type == PYGI_FUNCTION_TYPE_CALLBACK)
1366                 direction = PYGI_DIRECTION_FROM_PYTHON;
1367         }
1368
1369         transfer = g_arg_info_get_ownership_transfer (arg_info);
1370         type_info = g_arg_info_get_type (arg_info);
1371         type_tag = g_type_info_get_tag (type_info);
1372
1373         if (type_tag == GI_TYPE_TAG_INTERFACE || type_tag == GI_TYPE_TAG_ARRAY)
1374             is_caller_allocates = g_arg_info_is_caller_allocates (arg_info);
1375
1376         /* must be an child arg filled in by its owner
1377          * and continue
1378          * fill in it's c_arg_index, add to the in count
1379          */
1380         if (callable_cache->args_cache[arg_index] != NULL) {
1381             arg_cache = callable_cache->args_cache[arg_index];
1382             if (arg_cache->meta_type == PYGI_META_ARG_TYPE_CHILD_WITH_PYARG) {
1383                 arg_cache->py_arg_index = callable_cache->n_py_args;
1384                 callable_cache->n_py_args++;
1385             }
1386
1387             if (direction == PYGI_DIRECTION_FROM_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL) {
1388                 arg_cache->c_arg_index = callable_cache->n_from_py_args;
1389                 callable_cache->n_from_py_args++;
1390             }
1391
1392             if (direction == PYGI_DIRECTION_TO_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL) {
1393                 callable_cache->n_to_py_args++;
1394                 callable_cache->n_to_py_child_args++;
1395             }
1396
1397             arg_cache->type_tag = g_type_info_get_tag (type_info);
1398
1399             g_base_info_unref ( (GIBaseInfo *)arg_info);
1400             continue;
1401         }
1402
1403         if (direction == PYGI_DIRECTION_FROM_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL) {
1404             py_arg_index = callable_cache->n_py_args;
1405             callable_cache->n_from_py_args++;
1406             callable_cache->n_py_args++;
1407         }
1408
1409         arg_cache =
1410             _arg_cache_new (type_info,
1411                             callable_cache,
1412                             arg_info,
1413                             transfer,
1414                             direction,
1415                             arg_index,
1416                             py_arg_index);
1417
1418         if (arg_cache == NULL)
1419             goto arg_err;
1420
1421         arg_cache->arg_name = g_base_info_get_name ((GIBaseInfo *) arg_info);
1422         arg_cache->allow_none = g_arg_info_may_be_null(arg_info);
1423         arg_cache->is_caller_allocates = is_caller_allocates;
1424
1425         if (direction == PYGI_DIRECTION_TO_PYTHON || direction == PYGI_DIRECTION_BIDIRECTIONAL) {
1426             callable_cache->n_to_py_args++;
1427
1428             if (arg_cache == NULL)
1429                 goto arg_err;
1430
1431             callable_cache->to_py_args =
1432                 g_slist_append (callable_cache->to_py_args, arg_cache);
1433         }
1434
1435         callable_cache->args_cache[arg_index] = arg_cache;
1436         g_base_info_unref( (GIBaseInfo *)type_info);
1437         g_base_info_unref( (GIBaseInfo *)arg_info);
1438
1439         continue;
1440 arg_err:
1441         g_base_info_unref( (GIBaseInfo *)type_info);
1442         g_base_info_unref( (GIBaseInfo *)arg_info);
1443         return FALSE;
1444     }
1445
1446     _arg_name_list_generate (callable_cache);
1447
1448     return TRUE;
1449 }
1450
1451 PyGICallableCache *
1452 _pygi_callable_cache_new (GICallableInfo *callable_info, gboolean is_ccallback)
1453 {
1454     PyGICallableCache *cache;
1455     GIInfoType type = g_base_info_get_type ( (GIBaseInfo *)callable_info);
1456
1457     cache = g_slice_new0 (PyGICallableCache);
1458
1459     if (cache == NULL)
1460         return NULL;
1461
1462     cache->name = g_base_info_get_name ((GIBaseInfo *)callable_info);
1463
1464     if (type == GI_INFO_TYPE_FUNCTION) {
1465         GIFunctionInfoFlags flags;
1466
1467         flags = g_function_info_get_flags ( (GIFunctionInfo *)callable_info);
1468
1469         if (flags & GI_FUNCTION_IS_CONSTRUCTOR)
1470             cache->function_type = PYGI_FUNCTION_TYPE_CONSTRUCTOR;
1471         else if (flags & GI_FUNCTION_IS_METHOD)
1472             cache->function_type = PYGI_FUNCTION_TYPE_METHOD;
1473     } else if (type == GI_INFO_TYPE_VFUNC) {
1474         cache->function_type = PYGI_FUNCTION_TYPE_VFUNC;
1475     } else if (type == GI_INFO_TYPE_CALLBACK) {
1476         if (is_ccallback)
1477             cache->function_type = PYGI_FUNCTION_TYPE_CCALLBACK;
1478         else
1479             cache->function_type = PYGI_FUNCTION_TYPE_CALLBACK;
1480     } else {
1481         cache->function_type = PYGI_FUNCTION_TYPE_METHOD;
1482     }
1483
1484     cache->n_args = g_callable_info_get_n_args (callable_info);
1485
1486     /* if we are a method or vfunc make sure the instance parameter is counted */
1487     if (cache->function_type == PYGI_FUNCTION_TYPE_METHOD ||
1488             cache->function_type == PYGI_FUNCTION_TYPE_VFUNC)
1489         cache->n_args++;
1490
1491     if (cache->n_args > 0)
1492         cache->args_cache = g_slice_alloc0 (cache->n_args * sizeof (PyGIArgCache *));
1493
1494     if (!_args_cache_generate (callable_info, cache))
1495         goto err;
1496
1497     return cache;
1498 err:
1499     _pygi_callable_cache_free (cache);
1500     return NULL;
1501 }