git.roojs.org Git - gnome.gobject-introspection/blob - girepository/ginfo.c

   1 /* GObject introspection: Repository implementation
   2  *
   3  * Copyright (C) 2005 Matthias Clasen
   4  * Copyright (C) 2008,2009 Red Hat, Inc.
   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 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
  18  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19  * Boston, MA 02111-1307, USA.
  20  */
  21
  22 #include <stdlib.h>
  23 #include <string.h>
  24
  25 #include <glib.h>
  26 #include <glib-object.h>
  27
  28 #include "gtypelib.h"
  29 #include "ginfo.h"
  30
  31 struct _GIBaseInfo
  32 {
  33   gint type;
  34   gint ref_count;
  35   GIRepository *repository;
  36   GIBaseInfo *container;
  37
  38   GTypelib *typelib;
  39   guint32 offset;
  40 };
  41
  42 struct _GIUnresolvedInfo
  43 {
  44   gint type;
  45   gint ref_count;
  46   GIBaseInfo *container;
  47
  48   const gchar *name;
  49   const gchar *namespace;
  50 };
  51
  52 struct _GICallableInfo
  53 {
  54   GIBaseInfo base;
  55 };
  56
  57 struct _GIFunctionInfo
  58 {
  59   GICallableInfo callable;
  60 };
  61
  62 struct _GICallbackInfo
  63 {
  64   GICallableInfo callable;
  65 };
  66
  67 struct _GIRegisteredTypeInfo
  68 {
  69   GIBaseInfo base;
  70 };
  71
  72 struct _GIStructInfo
  73 {
  74   GIRegisteredTypeInfo registered;
  75 };
  76
  77 struct _GIEnumInfo
  78 {
  79   GIRegisteredTypeInfo registered;
  80 };
  81
  82 struct _GIObjectInfo
  83 {
  84   GIRegisteredTypeInfo registered;
  85 };
  86
  87 struct _GIInterfaceInfo
  88 {
  89   GIRegisteredTypeInfo registered;
  90 };
  91
  92 struct _GIConstantInfo
  93 {
  94   GIBaseInfo base;
  95 };
  96
  97 struct _GIValueInfo
  98 {
  99   GIBaseInfo base;
 100 };
 101
 102 struct _GISignalInfo
 103 {
 104   GICallableInfo callable;
 105 };
 106
 107 struct _GIVFuncInfo
 108 {
 109   GICallableInfo callable;
 110 };
 111
 112 struct _GIPropertyInfo
 113 {
 114   GIBaseInfo base;
 115 };
 116
 117 struct _GIFieldInfo
 118 {
 119   GIBaseInfo base;
 120 };
 121
 122 struct _GIArgInfo
 123 {
 124   GIBaseInfo base;
 125 };
 126
 127 struct _GITypeInfo
 128 {
 129   GIBaseInfo base;
 130 };
 131
 132 struct _GIUnionInfo
 133 {
 134   GIRegisteredTypeInfo registered;
 135 };
 136
 137
 138 /* info creation */
 139 GIBaseInfo *
 140 g_info_new_full (GIInfoType     type,
 141                  GIRepository  *repository,
 142                  GIBaseInfo    *container,
 143                  GTypelib     *typelib,
 144                  guint32        offset)
 145 {
 146   GIBaseInfo *info;
 147
 148   g_return_val_if_fail (container != NULL || repository != NULL, NULL);
 149
 150   info = g_new0 (GIBaseInfo, 1);
 151
 152   info->ref_count = 1;
 153   info->type = type;
 154
 155   info->typelib = typelib;
 156   info->offset = offset;
 157
 158   if (container)
 159     info->container = g_base_info_ref (container);
 160
 161   info->repository = g_object_ref (repository);
 162
 163   return info;
 164 }
 165
 166 GIBaseInfo *
 167 g_info_new (GIInfoType     type,
 168             GIBaseInfo    *container,
 169             GTypelib     *typelib,
 170             guint32        offset)
 171 {
 172   return g_info_new_full (type, container->repository, container, typelib, offset);
 173 }
 174
 175 static GIBaseInfo *
 176 g_info_from_entry (GIRepository *repository,
 177                    GTypelib *typelib,
 178                    guint16    index)
 179 {
 180   GIBaseInfo *result;
 181   DirEntry *entry = g_typelib_get_dir_entry (typelib, index);
 182
 183   if (entry->local)
 184     result = g_info_new_full (entry->blob_type, repository, NULL, typelib, entry->offset);
 185   else
 186     {
 187       const gchar *namespace = g_typelib_get_string (typelib, entry->offset);
 188       const gchar *name = g_typelib_get_string (typelib, entry->name);
 189
 190       result = g_irepository_find_by_name (repository, namespace, name);
 191       if (result == NULL)
 192         {
 193           GIUnresolvedInfo *unresolved;
 194
 195           unresolved = g_new0 (GIUnresolvedInfo, 1);
 196
 197           unresolved->type = GI_INFO_TYPE_UNRESOLVED;
 198           unresolved->ref_count = 1;
 199           unresolved->container = NULL;
 200           unresolved->name = name;
 201           unresolved->namespace = namespace;
 202
 203           return (GIBaseInfo*)unresolved;
 204         }
 205       return result;
 206     }
 207
 208   return result;
 209 }
 210
 211 /* GIBaseInfo functions */
 212 GIBaseInfo *
 213 g_base_info_ref (GIBaseInfo *info)
 214 {
 215   info->ref_count++;
 216
 217   return info;
 218 }
 219
 220 void
 221 g_base_info_unref (GIBaseInfo *info)
 222 {
 223   g_assert (info->ref_count > 0);
 224   info->ref_count--;
 225
 226   if (!info->ref_count)
 227     {
 228       if (info->container)
 229         g_base_info_unref (info->container);
 230
 231       if (info->repository)
 232         g_object_unref (info->repository);
 233
 234       g_free (info);
 235     }
 236 }
 237
 238 GIInfoType
 239 g_base_info_get_type (GIBaseInfo *info)
 240 {
 241
 242   return info->type;
 243 }
 244
 245 const gchar *
 246 g_base_info_get_name (GIBaseInfo *info)
 247 {
 248   g_assert (info->ref_count > 0);
 249   switch (info->type)
 250     {
 251     case GI_INFO_TYPE_FUNCTION:
 252     case GI_INFO_TYPE_CALLBACK:
 253     case GI_INFO_TYPE_STRUCT:
 254     case GI_INFO_TYPE_BOXED:
 255     case GI_INFO_TYPE_ENUM:
 256     case GI_INFO_TYPE_FLAGS:
 257     case GI_INFO_TYPE_OBJECT:
 258     case GI_INFO_TYPE_INTERFACE:
 259     case GI_INFO_TYPE_CONSTANT:
 260     case GI_INFO_TYPE_ERROR_DOMAIN:
 261     case GI_INFO_TYPE_UNION:
 262       {
 263         CommonBlob *blob = (CommonBlob *)&info->typelib->data[info->offset];
 264
 265         return g_typelib_get_string (info->typelib, blob->name);
 266       }
 267       break;
 268
 269     case GI_INFO_TYPE_VALUE:
 270       {
 271         ValueBlob *blob = (ValueBlob *)&info->typelib->data[info->offset];
 272
 273         return g_typelib_get_string (info->typelib, blob->name);
 274       }
 275       break;
 276
 277     case GI_INFO_TYPE_SIGNAL:
 278       {
 279         SignalBlob *blob = (SignalBlob *)&info->typelib->data[info->offset];
 280
 281         return g_typelib_get_string (info->typelib, blob->name);
 282       }
 283       break;
 284
 285     case GI_INFO_TYPE_PROPERTY:
 286       {
 287         PropertyBlob *blob = (PropertyBlob *)&info->typelib->data[info->offset];
 288
 289         return g_typelib_get_string (info->typelib, blob->name);
 290       }
 291       break;
 292
 293     case GI_INFO_TYPE_VFUNC:
 294       {
 295         VFuncBlob *blob = (VFuncBlob *)&info->typelib->data[info->offset];
 296
 297         return g_typelib_get_string (info->typelib, blob->name);
 298       }
 299       break;
 300
 301     case GI_INFO_TYPE_FIELD:
 302       {
 303         FieldBlob *blob = (FieldBlob *)&info->typelib->data[info->offset];
 304
 305         return g_typelib_get_string (info->typelib, blob->name);
 306       }
 307       break;
 308
 309     case GI_INFO_TYPE_ARG:
 310       {
 311         ArgBlob *blob = (ArgBlob *)&info->typelib->data[info->offset];
 312
 313         return g_typelib_get_string (info->typelib, blob->name);
 314       }
 315       break;
 316     case GI_INFO_TYPE_UNRESOLVED:
 317       {
 318         GIUnresolvedInfo *unresolved = (GIUnresolvedInfo *)info;
 319
 320         return unresolved->name;
 321       }
 322       break;
 323     case GI_INFO_TYPE_TYPE:
 324     default: ;
 325       g_assert_not_reached ();
 326       /* unnamed */
 327     }
 328
 329   return NULL;
 330 }
 331
 332 const gchar *
 333 g_base_info_get_namespace (GIBaseInfo *info)
 334 {
 335   Header *header = (Header *)info->typelib->data;
 336
 337   g_assert (info->ref_count > 0);
 338
 339   if (info->type == GI_INFO_TYPE_UNRESOLVED)
 340     {
 341       GIUnresolvedInfo *unresolved = (GIUnresolvedInfo *)info;
 342
 343       return unresolved->namespace;
 344     }
 345
 346   return g_typelib_get_string (info->typelib, header->namespace);
 347 }
 348
 349 gboolean
 350 g_base_info_is_deprecated (GIBaseInfo *info)
 351 {
 352   switch (info->type)
 353     {
 354     case GI_INFO_TYPE_FUNCTION:
 355     case GI_INFO_TYPE_CALLBACK:
 356     case GI_INFO_TYPE_STRUCT:
 357     case GI_INFO_TYPE_BOXED:
 358     case GI_INFO_TYPE_ENUM:
 359     case GI_INFO_TYPE_FLAGS:
 360     case GI_INFO_TYPE_OBJECT:
 361     case GI_INFO_TYPE_INTERFACE:
 362     case GI_INFO_TYPE_CONSTANT:
 363     case GI_INFO_TYPE_ERROR_DOMAIN:
 364       {
 365         CommonBlob *blob = (CommonBlob *)&info->typelib->data[info->offset];
 366
 367         return blob->deprecated;
 368       }
 369       break;
 370
 371     case GI_INFO_TYPE_VALUE:
 372       {
 373         ValueBlob *blob = (ValueBlob *)&info->typelib->data[info->offset];
 374
 375         return blob->deprecated;
 376       }
 377       break;
 378
 379     case GI_INFO_TYPE_SIGNAL:
 380       {
 381         SignalBlob *blob = (SignalBlob *)&info->typelib->data[info->offset];
 382
 383         return blob->deprecated;
 384       }
 385       break;
 386
 387     case GI_INFO_TYPE_PROPERTY:
 388       {
 389         PropertyBlob *blob = (PropertyBlob *)&info->typelib->data[info->offset];
 390
 391         return blob->deprecated;
 392       }
 393       break;
 394
 395     case GI_INFO_TYPE_VFUNC:
 396     case GI_INFO_TYPE_FIELD:
 397     case GI_INFO_TYPE_ARG:
 398     case GI_INFO_TYPE_TYPE:
 399     default: ;
 400       /* no deprecation flag for these */
 401     }
 402
 403   return FALSE;
 404 }
 405
 406 /**
 407  * g_base_info_get_attribute:
 408  * @info: A #GIBaseInfo
 409  * @name: A freeform string naming an attribute
 410  *
 411  * Retrieve an arbitrary attribute associated with this node.
 412  *
 413  * Return value: The value of the attribute, or %NULL if no such attribute exists
 414  */
 415 const gchar *
 416 g_base_info_get_attribute (GIBaseInfo   *info,
 417                            const gchar *name)
 418 {
 419   GIAttributeIter iter = { 0, };
 420   gchar *curname, *curvalue;
 421   while (g_base_info_iterate_attributes (info, &iter, &curname, &curvalue))
 422     {
 423       if (strcmp (name, curname) == 0)
 424         return (const gchar*) curvalue;
 425     }
 426
 427   return NULL;
 428 }
 429
 430 static int
 431 cmp_attribute (const void *av,
 432                 const void *bv)
 433 {
 434   const AttributeBlob *a = av;
 435   const AttributeBlob *b = bv;
 436
 437   if (a->offset < b->offset)
 438     return -1;
 439   else if (a->offset == b->offset)
 440     return 0;
 441   else
 442     return 1;
 443 }
 444
 445 static AttributeBlob *
 446 find_first_attribute (GIBaseInfo *info)
 447 {
 448   GIBaseInfo *base = (GIBaseInfo *)info;
 449   Header *header = (Header *)base->typelib->data;
 450   AttributeBlob blob, *first, *res, *previous;
 451
 452   blob.offset = base->offset;
 453
 454   first = (AttributeBlob *) &base->typelib->data[header->attributes];
 455
 456   res = bsearch (&blob, first, header->n_attributes,
 457                  header->attribute_blob_size, cmp_attribute);
 458
 459   if (res == NULL)
 460     return NULL;
 461
 462   previous = res - 1;
 463   while (previous >= first && previous->offset == base->offset)
 464     {
 465       res = previous;
 466       previous = res - 1;
 467     }
 468
 469   return res;
 470 }
 471
 472 /**
 473  * g_base_info_iterate_attributes:
 474  * @info: A #GIBaseInfo
 475  * @iter: A #GIAttributeIter structure, must be initialized; see below
 476  * @name: (out) (transfer none): Returned name, must not be freed
 477  * @value: (out) (transfer none): Returned name, must not be freed
 478  *
 479  * Iterate over all attributes associated with this node.  The iterator
 480  * structure is typically stack allocated, and must have its first
 481  * member initialized to %NULL.
 482  *
 483  * Both the @name and @value should be treated as constants
 484  * and must not be freed.
 485  *
 486  * <example>
 487  * <title>Iterating over attributes</title>
 488  * <programlisting>
 489  * void
 490  * print_attributes (GIBaseInfo *info)
 491  * {
 492  *   GIAttributeIter iter = { 0, };
 493  *   char *name;
 494  *   char *value;
 495  *   while (g_base_info_iterate_attributes (info, &iter, &name, &value))
 496  *     {
 497  *       g_print ("attribute name: %s value: %s", name, value);
 498  *     }
 499  * }
 500  * </programlisting>
 501  * </example>
 502  *
 503  * Return value: %TRUE if there are more attributes, %FALSE otherwise
 504  */
 505 gboolean
 506 g_base_info_iterate_attributes (GIBaseInfo       *info,
 507                                  GIAttributeIter *iter,
 508                                  gchar           **name,
 509                                  gchar           **value)
 510 {
 511   GIBaseInfo *base = (GIBaseInfo *)info;
 512   Header *header = (Header *)base->typelib->data;
 513   AttributeBlob *next, *after;
 514
 515   after = (AttributeBlob *) &base->typelib->data[header->attributes +
 516                                                   header->n_attributes * header->attribute_blob_size];
 517
 518   if (iter->data != NULL)
 519     next = (AttributeBlob *) iter->data;
 520   else
 521     next = find_first_attribute (info);
 522
 523   if (next == NULL || next->offset != base->offset || next >= after)
 524     return FALSE;
 525
 526   *name = (gchar*) g_typelib_get_string (base->typelib, next->name);
 527   *value = (gchar*) g_typelib_get_string (base->typelib, next->value);
 528   iter->data = next + 1;
 529
 530   return TRUE;
 531 }
 532
 533 GIBaseInfo *
 534 g_base_info_get_container (GIBaseInfo *info)
 535 {
 536   return info->container;
 537 }
 538
 539 GTypelib *
 540 g_base_info_get_typelib (GIBaseInfo *info)
 541 {
 542   return info->typelib;
 543 }
 544
 545 /* GIFunctionInfo functions */
 546 const gchar *
 547 g_function_info_get_symbol (GIFunctionInfo *info)
 548 {
 549   GIBaseInfo *base = (GIBaseInfo *)info;
 550   FunctionBlob *blob = (FunctionBlob *)&base->typelib->data[base->offset];
 551
 552   return g_typelib_get_string (base->typelib, blob->symbol);
 553 }
 554
 555 GIFunctionInfoFlags
 556 g_function_info_get_flags (GIFunctionInfo *info)
 557 {
 558   GIFunctionInfoFlags flags;
 559   GIBaseInfo *base = (GIBaseInfo *)info;
 560   FunctionBlob *blob = (FunctionBlob *)&base->typelib->data[base->offset];
 561
 562   flags = 0;
 563
 564   /* Make sure we don't flag Constructors as methods */
 565   if (!blob->constructor && !blob->is_static)
 566     flags = flags | GI_FUNCTION_IS_METHOD;
 567
 568   if (blob->constructor)
 569     flags = flags | GI_FUNCTION_IS_CONSTRUCTOR;
 570
 571   if (blob->getter)
 572     flags = flags | GI_FUNCTION_IS_GETTER;
 573
 574   if (blob->setter)
 575     flags = flags | GI_FUNCTION_IS_SETTER;
 576
 577   if (blob->wraps_vfunc)
 578     flags = flags | GI_FUNCTION_WRAPS_VFUNC;
 579
 580   if (blob->throws)
 581     flags = flags | GI_FUNCTION_THROWS;
 582
 583   return flags;
 584 }
 585
 586 GIPropertyInfo *
 587 g_function_info_get_property (GIFunctionInfo *info)
 588 {
 589   GIBaseInfo *base = (GIBaseInfo *)info;
 590   FunctionBlob *blob = (FunctionBlob *)&base->typelib->data[base->offset];
 591   GIInterfaceInfo *container = (GIInterfaceInfo *)base->container;
 592
 593   return g_interface_info_get_property (container, blob->index);
 594 }
 595
 596 GIVFuncInfo *
 597 g_function_info_get_vfunc (GIFunctionInfo *info)
 598 {
 599   GIBaseInfo *base = (GIBaseInfo *)info;
 600   FunctionBlob *blob = (FunctionBlob *)&base->typelib->data[base->offset];
 601   GIInterfaceInfo *container = (GIInterfaceInfo *)base->container;
 602
 603   return g_interface_info_get_vfunc (container, blob->index);
 604 }
 605
 606
 607 /* GICallableInfo functions */
 608 static guint32
 609 signature_offset (GICallableInfo *info)
 610 {
 611   int sigoff = -1;
 612   switch (info->base.type)
 613     {
 614     case GI_INFO_TYPE_FUNCTION:
 615       sigoff = G_STRUCT_OFFSET (FunctionBlob, signature);
 616       break;
 617     case GI_INFO_TYPE_VFUNC:
 618       sigoff = G_STRUCT_OFFSET (VFuncBlob, signature);
 619       break;
 620     case GI_INFO_TYPE_CALLBACK:
 621       sigoff = G_STRUCT_OFFSET (CallbackBlob, signature);
 622       break;
 623     case GI_INFO_TYPE_SIGNAL:
 624       sigoff = G_STRUCT_OFFSET (SignalBlob, signature);
 625       break;
 626     }
 627   if (sigoff >= 0)
 628     return *(guint32 *)&info->base.typelib->data[info->base.offset + sigoff];
 629   return 0;
 630 }
 631
 632 GITypeInfo *
 633 g_type_info_new (GIBaseInfo    *container,
 634                  GTypelib     *typelib,
 635                  guint32        offset)
 636 {
 637   SimpleTypeBlob *type = (SimpleTypeBlob *)&typelib->data[offset];
 638
 639   return (GITypeInfo *) g_info_new (GI_INFO_TYPE_TYPE, container, typelib,
 640                                     (type->reserved == 0 && type->reserved2 == 0) ? offset : type->offset);
 641 }
 642
 643 /**
 644  * g_callable_info_get_return_type:
 645  * @info: a #GICallableInfo
 646  *
 647  * Get the return type of a callable item as
 648  * a #GITypeInfo
 649  *
 650  * Returns: a #GITypeInfo idexing the TypeBlob for the
 651  * return type of #info
 652  */
 653 GITypeInfo *
 654 g_callable_info_get_return_type (GICallableInfo *info)
 655 {
 656   GIBaseInfo *base = (GIBaseInfo *)info;
 657   guint32 offset;
 658
 659   offset = signature_offset (info);
 660
 661   return g_type_info_new (base, base->typelib, offset);
 662 }
 663
 664 /**
 665  * g_callable_info_may_return_null:
 666  * @info: a #GICallableInfo
 667  *
 668  * See if a callable could return NULL.
 669  *
 670  * Returns: TRUE if callable could return NULL
 671  */
 672 gboolean
 673 g_callable_info_may_return_null (GICallableInfo *info)
 674 {
 675   GIBaseInfo *base = (GIBaseInfo *)info;
 676   SignatureBlob *blob = (SignatureBlob *)&base->typelib->data[signature_offset (info)];
 677
 678   return blob->may_return_null;
 679 }
 680
 681 /**
 682  * g_callable_info_get_caller_owns:
 683  * @info: a #GICallableInfo
 684  *
 685  * See whether the caller owns the return value
 686  * of this callable.
 687  *
 688  * Returns: TRUE if the caller owns the return value, FALSE otherwise.
 689  */
 690 GITransfer
 691 g_callable_info_get_caller_owns (GICallableInfo *info)
 692 {
 693   GIBaseInfo *base = (GIBaseInfo *)info;
 694   SignatureBlob *blob = (SignatureBlob *)&base->typelib->data[signature_offset (info)];
 695
 696   if (blob->caller_owns_return_value)
 697     return GI_TRANSFER_EVERYTHING;
 698   else if (blob->caller_owns_return_container)
 699     return GI_TRANSFER_CONTAINER;
 700   else
 701     return GI_TRANSFER_NOTHING;
 702 }
 703
 704 /**
 705  * g_callable_info_get_n_args:
 706  * @info: a #GICallableInfo
 707  *
 708  * Get the number of arguments (both IN and OUT) for this callable.
 709  *
 710  * Returns: The number of arguments this callable expects.
 711  */
 712 gint
 713 g_callable_info_get_n_args (GICallableInfo *info)
 714 {
 715   GIBaseInfo *base = (GIBaseInfo *)info;
 716   gint offset;
 717   SignatureBlob *blob;
 718
 719   offset = signature_offset (info);
 720   blob = (SignatureBlob *)&base->typelib->data[offset];
 721
 722   return blob->n_arguments;
 723 }
 724
 725 /**
 726  * g_callable_info_get_arg:
 727  * @info: a #GICallableInfo
 728  * @n: the argument index to fetch
 729  *
 730  * Get information about a particular argument of this callable.
 731  *
 732  * Returns: A #GIArgInfo indexing the typelib on the given argument.
 733  */
 734 GIArgInfo *
 735 g_callable_info_get_arg (GICallableInfo *info,
 736                          gint           n)
 737 {
 738   GIBaseInfo *base = (GIBaseInfo *)info;
 739   Header *header = (Header *)base->typelib->data;
 740   gint offset;
 741
 742   offset = signature_offset (info);
 743
 744   return (GIArgInfo *) g_info_new (GI_INFO_TYPE_ARG, base, base->typelib,
 745                                    offset + header->signature_blob_size + n * header->arg_blob_size);
 746 }
 747
 748 /* GIArgInfo function */
 749 GIDirection
 750 g_arg_info_get_direction (GIArgInfo *info)
 751 {
 752   GIBaseInfo *base = (GIBaseInfo *)info;
 753   ArgBlob *blob = (ArgBlob *)&base->typelib->data[base->offset];
 754
 755   if (blob->in && blob->out)
 756     return GI_DIRECTION_INOUT;
 757   else if (blob->out)
 758     return GI_DIRECTION_OUT;
 759   else
 760     return GI_DIRECTION_IN;
 761 }
 762
 763 gboolean
 764 g_arg_info_is_return_value (GIArgInfo *info)
 765 {
 766   GIBaseInfo *base = (GIBaseInfo *)info;
 767   ArgBlob *blob = (ArgBlob *)&base->typelib->data[base->offset];
 768
 769   return blob->return_value;
 770 }
 771
 772 gboolean
 773 g_arg_info_is_dipper (GIArgInfo *info)
 774 {
 775   GIBaseInfo *base = (GIBaseInfo *)info;
 776   ArgBlob *blob = (ArgBlob *)&base->typelib->data[base->offset];
 777
 778   return blob->dipper;
 779 }
 780
 781 gboolean
 782 g_arg_info_is_optional (GIArgInfo *info)
 783 {
 784   GIBaseInfo *base = (GIBaseInfo *)info;
 785   ArgBlob *blob = (ArgBlob *)&base->typelib->data[base->offset];
 786
 787   return blob->optional;
 788 }
 789
 790 gboolean
 791 g_arg_info_may_be_null (GIArgInfo *info)
 792 {
 793   GIBaseInfo *base = (GIBaseInfo *)info;
 794   ArgBlob *blob = (ArgBlob *)&base->typelib->data[base->offset];
 795
 796   return blob->allow_none;
 797 }
 798
 799 GITransfer
 800 g_arg_info_get_ownership_transfer (GIArgInfo *info)
 801 {
 802   GIBaseInfo *base = (GIBaseInfo *)info;
 803   ArgBlob *blob = (ArgBlob *)&base->typelib->data[base->offset];
 804
 805   if (blob->transfer_ownership)
 806     return GI_TRANSFER_EVERYTHING;
 807   else if (blob->transfer_container_ownership)
 808     return GI_TRANSFER_CONTAINER;
 809   else
 810     return GI_TRANSFER_NOTHING;
 811 }
 812
 813 GIScopeType
 814 g_arg_info_get_scope (GIArgInfo *info)
 815 {
 816   GIBaseInfo *base = (GIBaseInfo *)info;
 817   ArgBlob *blob = (ArgBlob *)&base->typelib->data[base->offset];
 818
 819   return blob->scope;
 820 }
 821
 822 gint
 823 g_arg_info_get_closure (GIArgInfo *info)
 824 {
 825   GIBaseInfo *base = (GIBaseInfo *)info;
 826   ArgBlob *blob = (ArgBlob *)&base->typelib->data[base->offset];
 827
 828   return blob->closure;
 829 }
 830
 831 gint
 832 g_arg_info_get_destroy (GIArgInfo *info)
 833 {
 834   GIBaseInfo *base = (GIBaseInfo *)info;
 835   ArgBlob *blob = (ArgBlob *)&base->typelib->data[base->offset];
 836
 837   return blob->destroy;
 838 }
 839
 840 GITypeInfo *
 841 g_arg_info_get_type (GIArgInfo *info)
 842 {
 843   GIBaseInfo *base = (GIBaseInfo *)info;
 844
 845   return g_type_info_new (base, base->typelib, base->offset + G_STRUCT_OFFSET (ArgBlob, arg_type));
 846 }
 847
 848 /* GITypeInfo functions */
 849 gboolean
 850 g_type_info_is_pointer (GITypeInfo *info)
 851 {
 852   GIBaseInfo *base = (GIBaseInfo *)info;
 853   SimpleTypeBlob *type = (SimpleTypeBlob *)&base->typelib->data[base->offset];
 854
 855   if (type->reserved == 0 && type->reserved2 == 0)
 856     return type->pointer;
 857   else
 858     {
 859       InterfaceTypeBlob *iface = (InterfaceTypeBlob *)&base->typelib->data[base->offset];
 860
 861       return iface->pointer;
 862     }
 863 }
 864
 865 GITypeTag
 866 g_type_info_get_tag (GITypeInfo *info)
 867 {
 868   GIBaseInfo *base = (GIBaseInfo *)info;
 869   SimpleTypeBlob *type = (SimpleTypeBlob *)&base->typelib->data[base->offset];
 870
 871   if (type->reserved == 0 && type->reserved2 == 0)
 872     return type->tag;
 873   else
 874     {
 875       InterfaceTypeBlob *iface = (InterfaceTypeBlob *)&base->typelib->data[base->offset];
 876
 877       return iface->tag;
 878     }
 879 }
 880
 881 GITypeInfo *
 882 g_type_info_get_param_type (GITypeInfo *info,
 883                             gint       n)
 884 {
 885   GIBaseInfo *base = (GIBaseInfo *)info;
 886   SimpleTypeBlob *type = (SimpleTypeBlob *)&base->typelib->data[base->offset];
 887
 888   if (!(type->reserved == 0 && type->reserved2 == 0))
 889     {
 890       ParamTypeBlob *param = (ParamTypeBlob *)&base->typelib->data[base->offset];
 891
 892       switch (param->tag)
 893         {
 894         case GI_TYPE_TAG_ARRAY:
 895         case GI_TYPE_TAG_GLIST:
 896         case GI_TYPE_TAG_GSLIST:
 897         case GI_TYPE_TAG_GHASH:
 898           return g_type_info_new (base, base->typelib,
 899                                   base->offset + sizeof (ParamTypeBlob)
 900                                   + sizeof (SimpleTypeBlob) * n);
 901           break;
 902
 903         default: ;
 904         }
 905     }
 906
 907   return NULL;
 908 }
 909
 910 GIBaseInfo *
 911 g_type_info_get_interface (GITypeInfo *info)
 912 {
 913   GIBaseInfo *base = (GIBaseInfo *)info;
 914   SimpleTypeBlob *type = (SimpleTypeBlob *)&base->typelib->data[base->offset];
 915
 916   if (!(type->reserved == 0 && type->reserved2 == 0))
 917     {
 918       InterfaceTypeBlob *blob = (InterfaceTypeBlob *)&base->typelib->data[base->offset];
 919
 920       if (blob->tag == GI_TYPE_TAG_INTERFACE)
 921         return g_info_from_entry (base->repository, base->typelib, blob->interface);
 922     }
 923
 924   return NULL;
 925 }
 926
 927 gint
 928 g_type_info_get_array_length (GITypeInfo *info)
 929 {
 930   GIBaseInfo *base = (GIBaseInfo *)info;
 931   SimpleTypeBlob *type = (SimpleTypeBlob *)&base->typelib->data[base->offset];
 932
 933   if (!(type->reserved == 0 && type->reserved2 == 0))
 934     {
 935       ArrayTypeBlob *blob = (ArrayTypeBlob *)&base->typelib->data[base->offset];
 936
 937       if (blob->tag == GI_TYPE_TAG_ARRAY)
 938         {
 939           if (blob->has_length)
 940             return blob->length;
 941         }
 942     }
 943
 944   return -1;
 945 }
 946
 947 gint
 948 g_type_info_get_array_fixed_size (GITypeInfo *info)
 949 {
 950   GIBaseInfo *base = (GIBaseInfo *)info;
 951   SimpleTypeBlob *type = (SimpleTypeBlob *)&base->typelib->data[base->offset];
 952
 953   if (!(type->reserved == 0 && type->reserved2 == 0))
 954     {
 955       ArrayTypeBlob *blob = (ArrayTypeBlob *)&base->typelib->data[base->offset];
 956
 957       if (blob->tag == GI_TYPE_TAG_ARRAY)
 958         {
 959           if (blob->has_size)
 960             return blob->size;
 961         }
 962     }
 963
 964   return -1;
 965 }
 966
 967 gboolean
 968 g_type_info_is_zero_terminated (GITypeInfo *info)
 969 {
 970   GIBaseInfo *base = (GIBaseInfo *)info;
 971   SimpleTypeBlob *type = (SimpleTypeBlob *)&base->typelib->data[base->offset];
 972
 973   if (!(type->reserved == 0 && type->reserved2 == 0))
 974     {
 975       ArrayTypeBlob *blob = (ArrayTypeBlob *)&base->typelib->data[base->offset];
 976
 977       if (blob->tag == GI_TYPE_TAG_ARRAY)
 978         return blob->zero_terminated;
 979     }
 980
 981   return FALSE;
 982 }
 983
 984 gint
 985 g_type_info_get_n_error_domains (GITypeInfo *info)
 986 {
 987   GIBaseInfo *base = (GIBaseInfo *)info;
 988   SimpleTypeBlob *type = (SimpleTypeBlob *)&base->typelib->data[base->offset];
 989
 990   if (!(type->reserved == 0 && type->reserved2 == 0))
 991     {
 992       ErrorTypeBlob *blob = (ErrorTypeBlob *)&base->typelib->data[base->offset];
 993
 994       if (blob->tag == GI_TYPE_TAG_ERROR)
 995         return blob->n_domains;
 996     }
 997
 998   return 0;
 999 }
1000
1001 GIErrorDomainInfo *
1002 g_type_info_get_error_domain (GITypeInfo *info,
1003                               gint       n)
1004 {
1005   GIBaseInfo *base = (GIBaseInfo *)info;
1006   SimpleTypeBlob *type = (SimpleTypeBlob *)&base->typelib->data[base->offset];
1007
1008   if (!(type->reserved == 0 && type->reserved2 == 0))
1009     {
1010       ErrorTypeBlob *blob = (ErrorTypeBlob *)&base->typelib->data[base->offset];
1011
1012       if (blob->tag == GI_TYPE_TAG_ERROR)
1013         return (GIErrorDomainInfo *) g_info_from_entry (base->repository,
1014                                                         base->typelib,
1015                                                         blob->domains[n]);
1016     }
1017
1018   return NULL;
1019 }
1020
1021
1022 /* GIErrorDomainInfo functions */
1023 const gchar *
1024 g_error_domain_info_get_quark (GIErrorDomainInfo *info)
1025 {
1026   GIBaseInfo *base = (GIBaseInfo *)info;
1027   ErrorDomainBlob *blob = (ErrorDomainBlob *)&base->typelib->data[base->offset];
1028
1029   return g_typelib_get_string (base->typelib, blob->get_quark);
1030 }
1031
1032 GIInterfaceInfo *
1033 g_error_domain_info_get_codes (GIErrorDomainInfo *info)
1034 {
1035   GIBaseInfo *base = (GIBaseInfo *)info;
1036   ErrorDomainBlob *blob = (ErrorDomainBlob *)&base->typelib->data[base->offset];
1037
1038   return (GIInterfaceInfo *) g_info_from_entry (base->repository,
1039                                                 base->typelib, blob->error_codes);
1040 }
1041
1042
1043 /* GIValueInfo functions */
1044 glong
1045 g_value_info_get_value (GIValueInfo *info)
1046 {
1047   GIBaseInfo *base = (GIBaseInfo *)info;
1048   ValueBlob *blob = (ValueBlob *)&base->typelib->data[base->offset];
1049
1050   return (glong)blob->value;
1051 }
1052
1053 /* GIFieldInfo functions */
1054 GIFieldInfoFlags
1055 g_field_info_get_flags (GIFieldInfo *info)
1056 {
1057   GIFieldInfoFlags flags;
1058
1059   GIBaseInfo *base = (GIBaseInfo *)info;
1060   FieldBlob *blob = (FieldBlob *)&base->typelib->data[base->offset];
1061
1062   flags = 0;
1063
1064   if (blob->readable)
1065     flags = flags | GI_FIELD_IS_READABLE;
1066
1067   if (blob->writable)
1068     flags = flags | GI_FIELD_IS_WRITABLE;
1069
1070   return flags;
1071 }
1072
1073 gint
1074 g_field_info_get_size (GIFieldInfo *info)
1075 {
1076   GIBaseInfo *base = (GIBaseInfo *)info;
1077   FieldBlob *blob = (FieldBlob *)&base->typelib->data[base->offset];
1078
1079   return blob->bits;
1080 }
1081
1082 gint
1083 g_field_info_get_offset (GIFieldInfo *info)
1084 {
1085   GIBaseInfo *base = (GIBaseInfo *)info;
1086   FieldBlob *blob = (FieldBlob *)&base->typelib->data[base->offset];
1087
1088   return blob->struct_offset;
1089 }
1090
1091 GITypeInfo *
1092 g_field_info_get_type (GIFieldInfo *info)
1093 {
1094   GIBaseInfo *base = (GIBaseInfo *)info;
1095
1096   return g_type_info_new (base, base->typelib, base->offset + G_STRUCT_OFFSET (FieldBlob, type));
1097 }
1098
1099 /* GIRegisteredTypeInfo functions */
1100 const gchar *
1101 g_registered_type_info_get_type_name (GIRegisteredTypeInfo *info)
1102 {
1103   GIBaseInfo *base = (GIBaseInfo *)info;
1104   RegisteredTypeBlob *blob = (RegisteredTypeBlob *)&base->typelib->data[base->offset];
1105
1106   if (blob->gtype_name)
1107     return g_typelib_get_string (base->typelib, blob->gtype_name);
1108
1109   return NULL;
1110 }
1111
1112 const gchar *
1113 g_registered_type_info_get_type_init (GIRegisteredTypeInfo *info)
1114 {
1115   GIBaseInfo *base = (GIBaseInfo *)info;
1116   RegisteredTypeBlob *blob = (RegisteredTypeBlob *)&base->typelib->data[base->offset];
1117
1118   if (blob->gtype_init)
1119     return g_typelib_get_string (base->typelib, blob->gtype_init);
1120
1121   return NULL;
1122 }
1123
1124 GType
1125 g_registered_type_info_get_g_type (GIRegisteredTypeInfo *info)
1126 {
1127   const char *type_init;
1128   GType (* get_type_func) (void);
1129
1130   type_init = g_registered_type_info_get_type_init (info);
1131
1132   if (type_init == NULL)
1133     return G_TYPE_NONE;
1134   else if (!strcmp (type_init, "intern"))
1135     return G_TYPE_OBJECT;
1136
1137   get_type_func = NULL;
1138   if (!g_typelib_symbol (((GIBaseInfo*)info)->typelib,
1139                          type_init,
1140                          (void**) &get_type_func))
1141     return G_TYPE_NONE;
1142
1143   return (* get_type_func) ();
1144 }
1145
1146 /* GIStructInfo functions */
1147 gint
1148 g_struct_info_get_n_fields (GIStructInfo *info)
1149 {
1150   GIBaseInfo *base = (GIBaseInfo *)info;
1151   StructBlob *blob = (StructBlob *)&base->typelib->data[base->offset];
1152
1153   return blob->n_fields;
1154 }
1155
1156 GIFieldInfo *
1157 g_struct_info_get_field (GIStructInfo *info,
1158                          gint         n)
1159 {
1160   GIBaseInfo *base = (GIBaseInfo *)info;
1161   Header *header = (Header *)base->typelib->data;
1162
1163   return (GIFieldInfo *) g_info_new (GI_INFO_TYPE_FIELD, base, base->typelib,
1164                                      base->offset + header->struct_blob_size +
1165                                      n * header->field_blob_size);
1166 }
1167
1168 gint
1169 g_struct_info_get_n_methods (GIStructInfo *info)
1170 {
1171   GIBaseInfo *base = (GIBaseInfo *)info;
1172   StructBlob *blob = (StructBlob *)&base->typelib->data[base->offset];
1173
1174   return blob->n_methods;
1175 }
1176
1177 GIFunctionInfo *
1178 g_struct_info_get_method (GIStructInfo *info,
1179                           gint         n)
1180 {
1181   GIBaseInfo *base = (GIBaseInfo *)info;
1182   StructBlob *blob = (StructBlob *)&base->typelib->data[base->offset];
1183   Header *header = (Header *)base->typelib->data;
1184   gint offset;
1185
1186   offset = base->offset + header->struct_blob_size
1187     + blob->n_fields * header->field_blob_size
1188     + n * header->function_blob_size;
1189   return (GIFunctionInfo *) g_info_new (GI_INFO_TYPE_FUNCTION, base,
1190                                         base->typelib, offset);
1191 }
1192
1193 static GIFunctionInfo *
1194 find_method (GIBaseInfo   *base,
1195              guint32       offset,
1196              gint          n_methods,
1197              const gchar  *name)
1198 {
1199   /* FIXME hash */
1200   Header *header = (Header *)base->typelib->data;
1201   gint i;
1202
1203   for (i = 0; i < n_methods; i++)
1204     {
1205       FunctionBlob *fblob = (FunctionBlob *)&base->typelib->data[offset];
1206       const gchar *fname = (const gchar *)&base->typelib->data[fblob->name];
1207
1208       if (strcmp (name, fname) == 0)
1209         return (GIFunctionInfo *) g_info_new (GI_INFO_TYPE_FUNCTION, base,
1210                                               base->typelib, offset);
1211
1212       offset += header->function_blob_size;
1213     }
1214
1215   return NULL;
1216 }
1217
1218 GIFunctionInfo *
1219 g_struct_info_find_method (GIStructInfo *info,
1220                            const gchar  *name)
1221 {
1222   gint offset;
1223   GIBaseInfo *base = (GIBaseInfo *)info;
1224   Header *header = (Header *)base->typelib->data;
1225   StructBlob *blob = (StructBlob *)&base->typelib->data[base->offset];
1226
1227   offset = base->offset + header->struct_blob_size
1228     + blob->n_fields * header->field_blob_size;
1229
1230   return find_method (base, offset, blob->n_methods, name);
1231 }
1232
1233 gsize
1234 g_struct_info_get_size (GIStructInfo *info)
1235 {
1236   GIBaseInfo *base = (GIBaseInfo *)info;
1237   StructBlob *blob = (StructBlob *)&base->typelib->data[base->offset];
1238
1239   return blob->size;
1240 }
1241
1242 gsize
1243 g_struct_info_get_alignment (GIStructInfo *info)
1244 {
1245   GIBaseInfo *base = (GIBaseInfo *)info;
1246   StructBlob *blob = (StructBlob *)&base->typelib->data[base->offset];
1247
1248   return blob->alignment;
1249 }
1250
1251 /**
1252  * g_struct_info_is_gtype_struct:
1253  * @info: GIStructInfo
1254  *
1255  * Return true if this structure represents the "class structure" for some
1256  * #GObject or #GInterface.  This function is mainly useful to hide this kind of structure
1257  * from generated public APIs.
1258  *
1259  * Returns: %TRUE if this is a class struct, %FALSE otherwise
1260  */
1261 gboolean
1262 g_struct_info_is_gtype_struct (GIStructInfo *info)
1263 {
1264   GIBaseInfo *base = (GIBaseInfo *)info;
1265   StructBlob *blob = (StructBlob *)&base->typelib->data[base->offset];
1266
1267   return blob->is_gtype_struct;
1268 }
1269
1270 gint
1271 g_enum_info_get_n_values (GIEnumInfo *info)
1272 {
1273   GIBaseInfo *base = (GIBaseInfo *)info;
1274   EnumBlob *blob = (EnumBlob *)&base->typelib->data[base->offset];
1275
1276   return blob->n_values;
1277 }
1278
1279 GIValueInfo *
1280 g_enum_info_get_value (GIEnumInfo *info,
1281                        gint            n)
1282 {
1283   GIBaseInfo *base = (GIBaseInfo *)info;
1284   Header *header = (Header *)base->typelib->data;
1285   gint offset;
1286
1287   offset = base->offset + header->enum_blob_size
1288     + n * header->value_blob_size;
1289   return (GIValueInfo *) g_info_new (GI_INFO_TYPE_VALUE, base, base->typelib, offset);
1290 }
1291
1292 /**
1293  * g_enum_info_get_storage_type:
1294  * @info: GIEnumInfo
1295  *
1296  * Gets the tag of the type used for the enum in the C ABI. This will
1297  * will be a signed or unsigned integral type.
1298
1299  * Note that in the current implementation the width of the type is
1300  * computed correctly, but the signed or unsigned nature of the type
1301  * may not match the sign of the type used by the C compiler.
1302  *
1303  * Return Value: the storage type for the enumeration
1304  */
1305 GITypeTag
1306 g_enum_info_get_storage_type (GIEnumInfo *info)
1307 {
1308   GIBaseInfo *base = (GIBaseInfo *)info;
1309   EnumBlob *blob = (EnumBlob *)&base->typelib->data[base->offset];
1310
1311   return blob->storage_type;
1312 }
1313
1314 /* GIObjectInfo functions */
1315 GIObjectInfo *
1316 g_object_info_get_parent (GIObjectInfo *info)
1317 {
1318   GIBaseInfo *base = (GIBaseInfo *)info;
1319   ObjectBlob *blob = (ObjectBlob *)&base->typelib->data[base->offset];
1320
1321   if (blob->parent)
1322     return (GIObjectInfo *) g_info_from_entry (base->repository,
1323                                                base->typelib, blob->parent);
1324   else
1325     return NULL;
1326 }
1327
1328 gboolean
1329 g_object_info_get_abstract (GIObjectInfo    *info)
1330 {
1331   GIBaseInfo *base = (GIBaseInfo *)info;
1332   ObjectBlob *blob = (ObjectBlob *)&base->typelib->data[base->offset];
1333   return blob->abstract != 0;
1334 }
1335
1336 const gchar *
1337 g_object_info_get_type_name (GIObjectInfo *info)
1338 {
1339   GIBaseInfo *base = (GIBaseInfo *)info;
1340   ObjectBlob *blob = (ObjectBlob *)&base->typelib->data[base->offset];
1341
1342   return g_typelib_get_string (base->typelib, blob->gtype_name);
1343 }
1344
1345 const gchar *
1346 g_object_info_get_type_init (GIObjectInfo *info)
1347 {
1348   GIBaseInfo *base = (GIBaseInfo *)info;
1349   ObjectBlob *blob = (ObjectBlob *)&base->typelib->data[base->offset];
1350
1351   return g_typelib_get_string (base->typelib, blob->gtype_init);
1352 }
1353
1354 gint
1355 g_object_info_get_n_interfaces (GIObjectInfo *info)
1356 {
1357   GIBaseInfo *base = (GIBaseInfo *)info;
1358   ObjectBlob *blob = (ObjectBlob *)&base->typelib->data[base->offset];
1359
1360   return blob->n_interfaces;
1361 }
1362
1363 GIInterfaceInfo *
1364 g_object_info_get_interface (GIObjectInfo *info,
1365                              gint          n)
1366 {
1367   GIBaseInfo *base = (GIBaseInfo *)info;
1368   ObjectBlob *blob = (ObjectBlob *)&base->typelib->data[base->offset];
1369
1370   return (GIInterfaceInfo *) g_info_from_entry (base->repository,
1371                                                 base->typelib, blob->interfaces[n]);
1372 }
1373
1374 gint
1375 g_object_info_get_n_fields (GIObjectInfo *info)
1376 {
1377   GIBaseInfo *base = (GIBaseInfo *)info;
1378   ObjectBlob *blob = (ObjectBlob *)&base->typelib->data[base->offset];
1379
1380   return blob->n_fields;
1381 }
1382
1383 GIFieldInfo *
1384 g_object_info_get_field (GIObjectInfo *info,
1385                          gint          n)
1386 {
1387   gint offset;
1388   GIBaseInfo *base = (GIBaseInfo *)info;
1389   Header *header = (Header *)base->typelib->data;
1390   ObjectBlob *blob = (ObjectBlob *)&base->typelib->data[base->offset];
1391
1392   offset = base->offset + header->object_blob_size
1393     + (blob->n_interfaces + blob->n_interfaces % 2) * 2
1394     + n * header->field_blob_size;
1395
1396   return (GIFieldInfo *) g_info_new (GI_INFO_TYPE_FIELD, base, base->typelib, offset);
1397 }
1398
1399 gint
1400 g_object_info_get_n_properties (GIObjectInfo *info)
1401 {
1402   GIBaseInfo *base = (GIBaseInfo *)info;
1403   ObjectBlob *blob = (ObjectBlob *)&base->typelib->data[base->offset];
1404
1405   return blob->n_properties;
1406 }
1407
1408 GIPropertyInfo *
1409 g_object_info_get_property (GIObjectInfo *info,
1410                             gint          n)
1411 {
1412   gint offset;
1413   GIBaseInfo *base = (GIBaseInfo *)info;
1414   Header *header = (Header *)base->typelib->data;
1415   ObjectBlob *blob = (ObjectBlob *)&base->typelib->data[base->offset];
1416
1417   offset = base->offset + header->object_blob_size
1418     + (blob->n_interfaces + blob->n_interfaces % 2) * 2
1419     + blob->n_fields * header->field_blob_size
1420     + n * header->property_blob_size;
1421
1422   return (GIPropertyInfo *) g_info_new (GI_INFO_TYPE_PROPERTY, base,
1423                                         base->typelib, offset);
1424 }
1425
1426 gint
1427 g_object_info_get_n_methods (GIObjectInfo *info)
1428 {
1429   GIBaseInfo *base = (GIBaseInfo *)info;
1430   ObjectBlob *blob = (ObjectBlob *)&base->typelib->data[base->offset];
1431
1432   return blob->n_methods;
1433 }
1434
1435 GIFunctionInfo *
1436 g_object_info_get_method (GIObjectInfo *info,
1437                           gint          n)
1438 {
1439   gint offset;
1440   GIBaseInfo *base = (GIBaseInfo *)info;
1441   Header *header = (Header *)base->typelib->data;
1442   ObjectBlob *blob = (ObjectBlob *)&base->typelib->data[base->offset];
1443
1444   offset = base->offset + header->object_blob_size
1445     + (blob->n_interfaces + blob->n_interfaces % 2) * 2
1446     + blob->n_fields * header->field_blob_size
1447     + blob->n_properties * header->property_blob_size
1448     + n * header->function_blob_size;
1449
1450     return (GIFunctionInfo *) g_info_new (GI_INFO_TYPE_FUNCTION, base,
1451                                           base->typelib, offset);
1452 }
1453
1454 GIFunctionInfo *
1455 g_object_info_find_method (GIObjectInfo *info,
1456                            const gchar  *name)
1457 {
1458   gint offset;
1459   GIBaseInfo *base = (GIBaseInfo *)info;
1460   Header *header = (Header *)base->typelib->data;
1461   ObjectBlob *blob = (ObjectBlob *)&base->typelib->data[base->offset];
1462
1463   offset = base->offset + header->object_blob_size
1464     + (blob->n_interfaces + blob->n_interfaces % 2) * 2
1465     + blob->n_fields * header->field_blob_size +
1466     + blob->n_properties * header->property_blob_size;
1467
1468   return find_method (base, offset, blob->n_methods, name);
1469 }
1470
1471 gint
1472 g_object_info_get_n_signals (GIObjectInfo *info)
1473 {
1474   GIBaseInfo *base = (GIBaseInfo *)info;
1475   ObjectBlob *blob = (ObjectBlob *)&base->typelib->data[base->offset];
1476
1477   return blob->n_signals;
1478 }
1479
1480 GISignalInfo *
1481 g_object_info_get_signal (GIObjectInfo *info,
1482                           gint          n)
1483 {
1484   gint offset;
1485   GIBaseInfo *base = (GIBaseInfo *)info;
1486   Header *header = (Header *)base->typelib->data;
1487   ObjectBlob *blob = (ObjectBlob *)&base->typelib->data[base->offset];
1488
1489   offset = base->offset + header->object_blob_size
1490     + (blob->n_interfaces + blob->n_interfaces % 2) * 2
1491     + blob->n_fields * header->field_blob_size
1492     + blob->n_properties * header->property_blob_size
1493     + blob->n_methods * header->function_blob_size
1494     + n * header->signal_blob_size;
1495
1496   return (GISignalInfo *) g_info_new (GI_INFO_TYPE_SIGNAL, base,
1497                                       base->typelib, offset);
1498 }
1499
1500 gint
1501 g_object_info_get_n_vfuncs (GIObjectInfo *info)
1502 {
1503   GIBaseInfo *base = (GIBaseInfo *)info;
1504   ObjectBlob *blob = (ObjectBlob *)&base->typelib->data[base->offset];
1505
1506   return blob->n_vfuncs;
1507 }
1508
1509 GIVFuncInfo *
1510 g_object_info_get_vfunc (GIObjectInfo *info,
1511                          gint          n)
1512 {
1513   gint offset;
1514   GIBaseInfo *base = (GIBaseInfo *)info;
1515   Header *header = (Header *)base->typelib->data;
1516   ObjectBlob *blob = (ObjectBlob *)&base->typelib->data[base->offset];
1517
1518   offset = base->offset + header->object_blob_size
1519     + (blob->n_interfaces + blob->n_interfaces % 2) * 2
1520     + blob->n_fields * header->field_blob_size
1521     + blob->n_properties * header->property_blob_size
1522     + blob->n_methods * header->function_blob_size
1523     + blob->n_signals * header->signal_blob_size
1524     + n * header->vfunc_blob_size;
1525
1526   return (GIVFuncInfo *) g_info_new (GI_INFO_TYPE_VFUNC, base,
1527                                      base->typelib, offset);
1528 }
1529
1530 static GIVFuncInfo *
1531 find_vfunc (GIBaseInfo   *base,
1532             guint32       offset,
1533             gint          n_vfuncs,
1534             const gchar  *name)
1535 {
1536   /* FIXME hash */
1537   Header *header = (Header *)base->typelib->data;
1538   gint i;
1539
1540   for (i = 0; i < n_vfuncs; i++)
1541     {
1542       VFuncBlob *fblob = (VFuncBlob *)&base->typelib->data[offset];
1543       const gchar *fname = (const gchar *)&base->typelib->data[fblob->name];
1544
1545       if (strcmp (name, fname) == 0)
1546         return (GIVFuncInfo *) g_info_new (GI_INFO_TYPE_VFUNC, base,
1547                                            base->typelib, offset);
1548
1549       offset += header->vfunc_blob_size;
1550     }
1551
1552   return NULL;
1553 }
1554
1555 /**
1556  * g_object_info_find_vfunc:
1557  * @info: An #GIObjectInfo
1558  * @name: The name of a virtual function to find.
1559  *
1560  * Locate a virtual function slot with name @name.  Note that the namespace
1561  * for virtuals is distinct from that of methods; there may or may not be
1562  * a concrete method associated for a virtual.  If there is one, it may
1563  * be retrieved using #g_vfunc_info_get_invoker.  See the documentation for
1564  * that function for more information on invoking virtuals.
1565  *
1566  * Return value: (transfer full): A #GIVFuncInfo, or %NULL if none with name @name.
1567  */
1568 GIVFuncInfo *
1569 g_object_info_find_vfunc (GIObjectInfo *info,
1570                           const gchar  *name)
1571 {
1572   gint offset;
1573   GIBaseInfo *base = (GIBaseInfo *)info;
1574   Header *header = (Header *)base->typelib->data;
1575   ObjectBlob *blob = (ObjectBlob *)&base->typelib->data[base->offset];
1576
1577   offset = base->offset + header->object_blob_size
1578     + (blob->n_interfaces + blob->n_interfaces % 2) * 2
1579     + blob->n_fields * header->field_blob_size
1580     + blob->n_properties * header->property_blob_size
1581     + blob->n_methods * header->function_blob_size
1582     + blob->n_signals * header->signal_blob_size;
1583
1584   return find_vfunc (base, offset, blob->n_vfuncs, name);
1585 }
1586
1587 gint
1588 g_object_info_get_n_constants (GIObjectInfo *info)
1589 {
1590   GIBaseInfo *base = (GIBaseInfo *)info;
1591   ObjectBlob *blob = (ObjectBlob *)&base->typelib->data[base->offset];
1592
1593   return blob->n_constants;
1594 }
1595
1596 GIConstantInfo *
1597 g_object_info_get_constant (GIObjectInfo *info,
1598                             gint          n)
1599 {
1600   gint offset;
1601   GIBaseInfo *base = (GIBaseInfo *)info;
1602   Header *header = (Header *)base->typelib->data;
1603   ObjectBlob *blob = (ObjectBlob *)&base->typelib->data[base->offset];
1604
1605   offset = base->offset + header->object_blob_size
1606     + (blob->n_interfaces + blob->n_interfaces % 2) * 2
1607     + blob->n_fields * header->field_blob_size
1608     + blob->n_properties * header->property_blob_size
1609     + blob->n_methods * header->function_blob_size
1610     + blob->n_signals * header->signal_blob_size
1611     + blob->n_vfuncs * header->vfunc_blob_size
1612     + n * header->constant_blob_size;
1613
1614   return (GIConstantInfo *) g_info_new (GI_INFO_TYPE_CONSTANT, base,
1615                                         base->typelib, offset);
1616 }
1617
1618 /**
1619  * g_object_info_get_class_struct:
1620  * @info: A #GIObjectInfo to query
1621  *
1622  * Every #GObject has two structures; an instance structure and a class
1623  * structure.  This function returns the metadata for the class structure.
1624  *
1625  * Returns: a #GIStructInfo for the class struct or %NULL if none found.
1626  */
1627 GIStructInfo *
1628 g_object_info_get_class_struct (GIObjectInfo *info)
1629 {
1630   GIBaseInfo *base = (GIBaseInfo *)info;
1631   ObjectBlob *blob = (ObjectBlob *)&base->typelib->data[base->offset];
1632
1633   if (blob->gtype_struct)
1634     return (GIStructInfo *) g_info_from_entry (base->repository,
1635                                                base->typelib, blob->gtype_struct);
1636   else
1637     return NULL;
1638 }
1639
1640 /* GIInterfaceInfo functions */
1641 gint
1642 g_interface_info_get_n_prerequisites (GIInterfaceInfo *info)
1643 {
1644   GIBaseInfo *base = (GIBaseInfo *)info;
1645   InterfaceBlob *blob = (InterfaceBlob *)&base->typelib->data[base->offset];
1646
1647   return blob->n_prerequisites;
1648 }
1649
1650 GIBaseInfo *
1651 g_interface_info_get_prerequisite (GIInterfaceInfo *info,
1652                                    gint            n)
1653 {
1654   GIBaseInfo *base = (GIBaseInfo *)info;
1655   InterfaceBlob *blob = (InterfaceBlob *)&base->typelib->data[base->offset];
1656
1657   return g_info_from_entry (base->repository,
1658                             base->typelib, blob->prerequisites[n]);
1659 }
1660
1661
1662 gint
1663 g_interface_info_get_n_properties (GIInterfaceInfo *info)
1664 {
1665   GIBaseInfo *base = (GIBaseInfo *)info;
1666   InterfaceBlob *blob = (InterfaceBlob *)&base->typelib->data[base->offset];
1667
1668   return blob->n_properties;
1669 }
1670
1671 GIPropertyInfo *
1672 g_interface_info_get_property (GIInterfaceInfo *info,
1673                                gint            n)
1674 {
1675   gint offset;
1676   GIBaseInfo *base = (GIBaseInfo *)info;
1677   Header *header = (Header *)base->typelib->data;
1678   InterfaceBlob *blob = (InterfaceBlob *)&base->typelib->data[base->offset];
1679
1680   offset = base->offset + header->interface_blob_size
1681     + (blob->n_prerequisites + (blob->n_prerequisites % 2)) * 2
1682     + n * header->property_blob_size;
1683
1684   return (GIPropertyInfo *) g_info_new (GI_INFO_TYPE_PROPERTY, base,
1685                                         base->typelib, offset);
1686 }
1687
1688 gint
1689 g_interface_info_get_n_methods (GIInterfaceInfo *info)
1690 {
1691   GIBaseInfo *base = (GIBaseInfo *)info;
1692   InterfaceBlob *blob = (InterfaceBlob *)&base->typelib->data[base->offset];
1693
1694   return blob->n_methods;
1695 }
1696
1697 GIFunctionInfo *
1698 g_interface_info_get_method (GIInterfaceInfo *info,
1699                              gint            n)
1700 {
1701   gint offset;
1702   GIBaseInfo *base = (GIBaseInfo *)info;
1703   Header *header = (Header *)base->typelib->data;
1704   InterfaceBlob *blob = (InterfaceBlob *)&base->typelib->data[base->offset];
1705
1706   offset = base->offset + header->interface_blob_size
1707     + (blob->n_prerequisites + (blob->n_prerequisites % 2)) * 2
1708     + blob->n_properties * header->property_blob_size
1709     + n * header->function_blob_size;
1710
1711   return (GIFunctionInfo *) g_info_new (GI_INFO_TYPE_FUNCTION, base,
1712                                         base->typelib, offset);
1713 }
1714
1715 GIFunctionInfo *
1716 g_interface_info_find_method (GIInterfaceInfo *info,
1717                               const gchar     *name)
1718 {
1719   gint offset;
1720   GIBaseInfo *base = (GIBaseInfo *)info;
1721   Header *header = (Header *)base->typelib->data;
1722   InterfaceBlob *blob = (InterfaceBlob *)&base->typelib->data[base->offset];
1723
1724   offset = base->offset + header->interface_blob_size
1725     + (blob->n_prerequisites + (blob->n_prerequisites % 2)) * 2
1726     + blob->n_properties * header->property_blob_size;
1727
1728   return find_method (base, offset, blob->n_methods, name);
1729 }
1730
1731 gint
1732 g_interface_info_get_n_signals (GIInterfaceInfo *info)
1733 {
1734   GIBaseInfo *base = (GIBaseInfo *)info;
1735   InterfaceBlob *blob = (InterfaceBlob *)&base->typelib->data[base->offset];
1736
1737   return blob->n_signals;
1738 }
1739
1740 GISignalInfo *
1741 g_interface_info_get_signal (GIInterfaceInfo *info,
1742                              gint            n)
1743 {
1744   gint offset;
1745   GIBaseInfo *base = (GIBaseInfo *)info;
1746   Header *header = (Header *)base->typelib->data;
1747   InterfaceBlob *blob = (InterfaceBlob *)&base->typelib->data[base->offset];
1748
1749   offset = base->offset + header->interface_blob_size
1750     + (blob->n_prerequisites + (blob->n_prerequisites % 2)) * 2
1751     + blob->n_properties * header->property_blob_size
1752     + blob->n_methods * header->function_blob_size
1753     + n * header->signal_blob_size;
1754
1755   return (GISignalInfo *) g_info_new (GI_INFO_TYPE_SIGNAL, base,
1756                                       base->typelib, offset);
1757 }
1758
1759 gint
1760 g_interface_info_get_n_vfuncs (GIInterfaceInfo *info)
1761 {
1762   GIBaseInfo *base = (GIBaseInfo *)info;
1763   InterfaceBlob *blob = (InterfaceBlob *)&base->typelib->data[base->offset];
1764
1765   return blob->n_vfuncs;
1766 }
1767
1768 GIVFuncInfo *
1769 g_interface_info_get_vfunc (GIInterfaceInfo *info,
1770                             gint            n)
1771 {
1772   gint offset;
1773   GIBaseInfo *base = (GIBaseInfo *)info;
1774   Header *header = (Header *)base->typelib->data;
1775   InterfaceBlob *blob = (InterfaceBlob *)&base->typelib->data[base->offset];
1776
1777   offset = base->offset + header->interface_blob_size
1778     + (blob->n_prerequisites + (blob->n_prerequisites % 2)) * 2
1779     + blob->n_properties * header->property_blob_size
1780     + blob->n_methods * header->function_blob_size
1781     + blob->n_signals * header->signal_blob_size
1782     + n * header->vfunc_blob_size;
1783
1784   return (GIVFuncInfo *) g_info_new (GI_INFO_TYPE_VFUNC, base,
1785                                      base->typelib, offset);
1786 }
1787
1788 /**
1789  * g_interface_info_find_vfunc:
1790  * @info: An #GIObjectInfo
1791  * @name: The name of a virtual function to find.
1792  *
1793  * Locate a virtual function slot with name @name.  See the documentation
1794  * for #g_object_info_find_vfunc for more information on virtuals.
1795  *
1796  * Return value: (transfer full): A #GIVFuncInfo, or %NULL if none with name @name.
1797  */
1798 GIVFuncInfo *
1799 g_interface_info_find_vfunc (GIInterfaceInfo *info,
1800                              const gchar  *name)
1801 {
1802   gint offset;
1803   GIBaseInfo *base = (GIBaseInfo *)info;
1804   Header *header = (Header *)base->typelib->data;
1805   InterfaceBlob *blob = (InterfaceBlob *)&base->typelib->data[base->offset];
1806
1807   offset = base->offset + header->interface_blob_size
1808     + (blob->n_prerequisites + blob->n_prerequisites % 2) * 2
1809     + blob->n_properties * header->property_blob_size
1810     + blob->n_methods * header->function_blob_size
1811     + blob->n_signals * header->signal_blob_size;
1812
1813   return find_vfunc (base, offset, blob->n_vfuncs, name);
1814 }
1815
1816 gint
1817 g_interface_info_get_n_constants (GIInterfaceInfo *info)
1818 {
1819   GIBaseInfo *base = (GIBaseInfo *)info;
1820   InterfaceBlob *blob = (InterfaceBlob *)&base->typelib->data[base->offset];
1821
1822   return blob->n_constants;
1823 }
1824
1825 GIConstantInfo *
1826 g_interface_info_get_constant (GIInterfaceInfo *info,
1827                                gint             n)
1828 {
1829   gint offset;
1830   GIBaseInfo *base = (GIBaseInfo *)info;
1831   Header *header = (Header *)base->typelib->data;
1832   InterfaceBlob *blob = (InterfaceBlob *)&base->typelib->data[base->offset];
1833
1834   offset = base->offset + header->interface_blob_size
1835     + (blob->n_prerequisites + (blob->n_prerequisites % 2)) * 2
1836     + blob->n_properties * header->property_blob_size
1837     + blob->n_methods * header->function_blob_size
1838     + blob->n_signals * header->signal_blob_size
1839     + blob->n_vfuncs * header->vfunc_blob_size
1840     + n * header->constant_blob_size;
1841
1842   return (GIConstantInfo *) g_info_new (GI_INFO_TYPE_CONSTANT, base,
1843                                         base->typelib, offset);
1844 }
1845
1846 /**
1847  * g_interface_info_get_iface_struct:
1848  * @info: A #GIInterfaceInfo to query
1849  *
1850  * Returns the layout C structure associated with this #GInterface.
1851  *
1852  * Returns: A #GIStructInfo for the class struct or %NULL if none found.
1853  */
1854 GIStructInfo *
1855 g_interface_info_get_iface_struct (GIInterfaceInfo *info)
1856 {
1857   GIBaseInfo *base = (GIBaseInfo *)info;
1858   InterfaceBlob *blob = (InterfaceBlob *)&base->typelib->data[base->offset];
1859
1860   if (blob->gtype_struct)
1861     return (GIStructInfo *) g_info_from_entry (base->repository,
1862                                                base->typelib, blob->gtype_struct);
1863   else
1864     return NULL;
1865 }
1866
1867 /* GIPropertyInfo functions */
1868 GParamFlags
1869 g_property_info_get_flags (GIPropertyInfo *info)
1870 {
1871   GParamFlags flags;
1872   GIBaseInfo *base = (GIBaseInfo *)info;
1873   PropertyBlob *blob = (PropertyBlob *)&base->typelib->data[base->offset];
1874
1875   flags = 0;
1876
1877   if (blob->readable)
1878     flags = flags | G_PARAM_READABLE;
1879
1880   if (blob->writable)
1881     flags = flags | G_PARAM_WRITABLE;
1882
1883   if (blob->construct)
1884     flags = flags | G_PARAM_CONSTRUCT;
1885
1886   if (blob->construct_only)
1887     flags = flags | G_PARAM_CONSTRUCT_ONLY;
1888
1889   return flags;
1890 }
1891
1892 GITypeInfo *
1893 g_property_info_get_type (GIPropertyInfo *info)
1894 {
1895   GIBaseInfo *base = (GIBaseInfo *)info;
1896
1897   return g_type_info_new (base, base->typelib, base->offset + G_STRUCT_OFFSET (PropertyBlob, type));
1898 }
1899
1900
1901 /* GISignalInfo functions */
1902 GSignalFlags
1903 g_signal_info_get_flags (GISignalInfo *info)
1904 {
1905   GSignalFlags flags;
1906
1907   GIBaseInfo *base = (GIBaseInfo *)info;
1908   SignalBlob *blob = (SignalBlob *)&base->typelib->data[base->offset];
1909
1910   flags = 0;
1911
1912   if (blob->run_first)
1913     flags = flags | G_SIGNAL_RUN_FIRST;
1914
1915   if (blob->run_last)
1916     flags = flags | G_SIGNAL_RUN_LAST;
1917
1918   if (blob->run_cleanup)
1919     flags = flags | G_SIGNAL_RUN_CLEANUP;
1920
1921   if (blob->no_recurse)
1922     flags = flags | G_SIGNAL_NO_RECURSE;
1923
1924   if (blob->detailed)
1925     flags = flags | G_SIGNAL_DETAILED;
1926
1927   if (blob->action)
1928     flags = flags | G_SIGNAL_ACTION;
1929
1930   if (blob->no_hooks)
1931     flags = flags | G_SIGNAL_NO_HOOKS;
1932
1933   return flags;
1934 }
1935
1936 GIVFuncInfo *
1937 g_signal_info_get_class_closure (GISignalInfo *info)
1938 {
1939   GIBaseInfo *base = (GIBaseInfo *)info;
1940   SignalBlob *blob = (SignalBlob *)&base->typelib->data[base->offset];
1941
1942   if (blob->has_class_closure)
1943     return g_interface_info_get_vfunc ((GIInterfaceInfo *)base->container, blob->class_closure);
1944
1945   return NULL;
1946 }
1947
1948 gboolean
1949 g_signal_info_true_stops_emit (GISignalInfo *info)
1950 {
1951   GIBaseInfo *base = (GIBaseInfo *)info;
1952   SignalBlob *blob = (SignalBlob *)&base->typelib->data[base->offset];
1953
1954   return blob->true_stops_emit;
1955 }
1956
1957 /* GIVFuncInfo functions */
1958 GIVFuncInfoFlags
1959 g_vfunc_info_get_flags (GIVFuncInfo *info)
1960 {
1961   GIVFuncInfoFlags flags;
1962
1963   GIBaseInfo *base = (GIBaseInfo *)info;
1964   VFuncBlob *blob = (VFuncBlob *)&base->typelib->data[base->offset];
1965
1966   flags = 0;
1967
1968   if (blob->must_chain_up)
1969     flags = flags | GI_VFUNC_MUST_CHAIN_UP;
1970
1971   if (blob->must_be_implemented)
1972     flags = flags | GI_VFUNC_MUST_OVERRIDE;
1973
1974   if (blob->must_not_be_implemented)
1975     flags = flags | GI_VFUNC_MUST_NOT_OVERRIDE;
1976
1977   return flags;
1978 }
1979
1980 gint
1981 g_vfunc_info_get_offset (GIVFuncInfo *info)
1982 {
1983   GIBaseInfo *base = (GIBaseInfo *)info;
1984   VFuncBlob *blob = (VFuncBlob *)&base->typelib->data[base->offset];
1985
1986   return blob->struct_offset;
1987 }
1988
1989 GISignalInfo *
1990 g_vfunc_info_get_signal (GIVFuncInfo *info)
1991 {
1992   GIBaseInfo *base = (GIBaseInfo *)info;
1993   VFuncBlob *blob = (VFuncBlob *)&base->typelib->data[base->offset];
1994
1995   if (blob->class_closure)
1996     return g_interface_info_get_signal ((GIInterfaceInfo *)base->container, blob->signal);
1997
1998   return NULL;
1999 }
2000
2001 /**
2002  * g_vfunc_info_get_invoker:
2003  * @info: A #GIVFuncInfo
2004  *
2005  * If this virtual function has an associated invoker method, this
2006  * method will return it.  An invoker method is a C entry point.
2007  *
2008  * Not all virtuals will have invokers.
2009  *
2010  * Return value: (transfer full): An invoker function, or %NULL if none known
2011  */
2012 GIFunctionInfo *
2013 g_vfunc_info_get_invoker (GIVFuncInfo *info)
2014 {
2015   GIBaseInfo *base = (GIBaseInfo *)info;
2016   VFuncBlob *blob = (VFuncBlob *)&base->typelib->data[base->offset];
2017   GIBaseInfo *container = base->container;
2018   GIInfoType parent_type;
2019
2020   /* 1023 = 0x3ff is the maximum of the 10 bits for invoker index */
2021   if (blob->invoker == 1023)
2022     return NULL;
2023
2024   parent_type = g_base_info_get_type (container);
2025   if (parent_type == GI_INFO_TYPE_OBJECT)
2026     return g_object_info_get_method ((GIObjectInfo*)container, blob->invoker);
2027   else if (parent_type == GI_INFO_TYPE_INTERFACE)
2028     return g_interface_info_get_method ((GIInterfaceInfo*)container, blob->invoker);
2029   else
2030     g_assert_not_reached ();
2031 }
2032
2033 /* GIConstantInfo functions */
2034 GITypeInfo *
2035 g_constant_info_get_type (GIConstantInfo *info)
2036 {
2037   GIBaseInfo *base = (GIBaseInfo *)info;
2038
2039   return g_type_info_new (base, base->typelib, base->offset + 8);
2040 }
2041
2042 gint
2043 g_constant_info_get_value (GIConstantInfo *info,
2044                            GArgument      *value)
2045 {
2046   GIBaseInfo *base = (GIBaseInfo *)info;
2047   ConstantBlob *blob = (ConstantBlob *)&base->typelib->data[base->offset];
2048
2049   /* FIXME non-basic types ? */
2050   if (blob->type.reserved == 0 && blob->type.reserved2 == 0)
2051     {
2052       if (blob->type.pointer)
2053         value->v_pointer = g_memdup (&base->typelib->data[blob->offset], blob->size);
2054       else
2055         {
2056           switch (blob->type.tag)
2057             {
2058             case GI_TYPE_TAG_BOOLEAN:
2059               value->v_boolean = *(gboolean*)&base->typelib->data[blob->offset];
2060               break;
2061             case GI_TYPE_TAG_INT8:
2062               value->v_int8 = *(gint8*)&base->typelib->data[blob->offset];
2063               break;
2064             case GI_TYPE_TAG_UINT8:
2065               value->v_uint8 = *(guint8*)&base->typelib->data[blob->offset];
2066               break;
2067             case GI_TYPE_TAG_INT16:
2068               value->v_int16 = *(gint16*)&base->typelib->data[blob->offset];
2069               break;
2070             case GI_TYPE_TAG_UINT16:
2071               value->v_uint16 = *(guint16*)&base->typelib->data[blob->offset];
2072               break;
2073             case GI_TYPE_TAG_INT32:
2074               value->v_int32 = *(gint32*)&base->typelib->data[blob->offset];
2075               break;
2076             case GI_TYPE_TAG_UINT32:
2077               value->v_uint32 = *(guint32*)&base->typelib->data[blob->offset];
2078               break;
2079             case GI_TYPE_TAG_INT64:
2080               value->v_int64 = *(gint64*)&base->typelib->data[blob->offset];
2081               break;
2082             case GI_TYPE_TAG_UINT64:
2083               value->v_uint64 = *(guint64*)&base->typelib->data[blob->offset];
2084               break;
2085             case GI_TYPE_TAG_FLOAT:
2086               value->v_float = *(gfloat*)&base->typelib->data[blob->offset];
2087               break;
2088             case GI_TYPE_TAG_DOUBLE:
2089               value->v_double = *(gdouble*)&base->typelib->data[blob->offset];
2090               break;
2091             case GI_TYPE_TAG_TIME_T:
2092               value->v_long = *(long*)&base->typelib->data[blob->offset];
2093               break;
2094             case GI_TYPE_TAG_SHORT:
2095               value->v_short = *(gshort*)&base->typelib->data[blob->offset];
2096               break;
2097             case GI_TYPE_TAG_USHORT:
2098               value->v_ushort = *(gushort*)&base->typelib->data[blob->offset];
2099               break;
2100             case GI_TYPE_TAG_INT:
2101               value->v_int = *(gint*)&base->typelib->data[blob->offset];
2102               break;
2103             case GI_TYPE_TAG_UINT:
2104               value->v_uint = *(guint*)&base->typelib->data[blob->offset];
2105               break;
2106             case GI_TYPE_TAG_LONG:
2107               value->v_long = *(glong*)&base->typelib->data[blob->offset];
2108               break;
2109             case GI_TYPE_TAG_ULONG:
2110               value->v_ulong = *(gulong*)&base->typelib->data[blob->offset];
2111               break;
2112             }
2113         }
2114     }
2115
2116   return blob->size;
2117 }
2118
2119 /* GIUnionInfo functions */
2120 gint
2121 g_union_info_get_n_fields  (GIUnionInfo *info)
2122 {
2123   GIBaseInfo *base = (GIBaseInfo *)info;
2124   UnionBlob *blob = (UnionBlob *)&base->typelib->data[base->offset];
2125
2126   return blob->n_fields;
2127 }
2128
2129 GIFieldInfo *
2130 g_union_info_get_field (GIUnionInfo *info,
2131                         gint         n)
2132 {
2133   GIBaseInfo *base = (GIBaseInfo *)info;
2134   Header *header = (Header *)base->typelib->data;
2135
2136   return (GIFieldInfo *) g_info_new (GI_INFO_TYPE_FIELD, base, base->typelib,
2137                                      base->offset + header->union_blob_size +
2138                                      n * header->field_blob_size);
2139 }
2140
2141 gint
2142 g_union_info_get_n_methods (GIUnionInfo *info)
2143 {
2144   GIBaseInfo *base = (GIBaseInfo *)info;
2145   UnionBlob *blob = (UnionBlob *)&base->typelib->data[base->offset];
2146
2147   return blob->n_functions;
2148 }
2149
2150 GIFunctionInfo *
2151 g_union_info_get_method (GIUnionInfo *info,
2152                          gint         n)
2153 {
2154   GIBaseInfo *base = (GIBaseInfo *)info;
2155   UnionBlob *blob = (UnionBlob *)&base->typelib->data[base->offset];
2156   Header *header = (Header *)base->typelib->data;
2157   gint offset;
2158
2159   offset = base->offset + header->union_blob_size
2160     + blob->n_fields * header->field_blob_size
2161     + n * header->function_blob_size;
2162   return (GIFunctionInfo *) g_info_new (GI_INFO_TYPE_FUNCTION, base,
2163                                         base->typelib, offset);
2164 }
2165
2166 gboolean
2167 g_union_info_is_discriminated (GIUnionInfo *info)
2168 {
2169   GIBaseInfo *base = (GIBaseInfo *)info;
2170   UnionBlob *blob = (UnionBlob *)&base->typelib->data[base->offset];
2171
2172   return blob->discriminated;
2173 }
2174
2175 gint
2176 g_union_info_get_discriminator_offset (GIUnionInfo *info)
2177 {
2178   GIBaseInfo *base = (GIBaseInfo *)info;
2179   UnionBlob *blob = (UnionBlob *)&base->typelib->data[base->offset];
2180
2181   return blob->discriminator_offset;
2182 }
2183
2184 GITypeInfo *
2185 g_union_info_get_discriminator_type (GIUnionInfo *info)
2186 {
2187   GIBaseInfo *base = (GIBaseInfo *)info;
2188
2189   return g_type_info_new (base, base->typelib, base->offset + 24);
2190 }
2191
2192 GIConstantInfo *
2193 g_union_info_get_discriminator (GIUnionInfo *info,
2194                                 gint         n)
2195 {
2196   GIBaseInfo *base = (GIBaseInfo *)info;
2197   UnionBlob *blob = (UnionBlob *)&base->typelib->data[base->offset];
2198
2199   if (blob->discriminated)
2200     {
2201       Header *header = (Header *)base->typelib->data;
2202       gint offset;
2203
2204       offset = base->offset + header->union_blob_size
2205         + blob->n_fields * header->field_blob_size
2206         + blob->n_functions * header->function_blob_size
2207         + n * header->constant_blob_size;
2208
2209       return (GIConstantInfo *) g_info_new (GI_INFO_TYPE_CONSTANT, base,
2210                                             base->typelib, offset);
2211     }
2212
2213   return NULL;
2214 }
2215
2216 GIFunctionInfo *
2217 g_union_info_find_method (GIUnionInfo *info,
2218                           const gchar *name)
2219 {
2220   gint offset;
2221   GIBaseInfo *base = (GIBaseInfo *)info;
2222   Header *header = (Header *)base->typelib->data;
2223   UnionBlob *blob = (UnionBlob *)&base->typelib->data[base->offset];
2224
2225   offset = base->offset + header->union_blob_size
2226     + blob->n_fields * header->field_blob_size;
2227
2228   return find_method (base, offset, blob->n_functions, name);
2229 }
2230
2231 gsize
2232 g_union_info_get_size (GIUnionInfo *info)
2233 {
2234   GIBaseInfo *base = (GIBaseInfo *)info;
2235   UnionBlob *blob = (UnionBlob *)&base->typelib->data[base->offset];
2236
2237   return blob->size;
2238 }
2239
2240 gsize
2241 g_union_info_get_alignment (GIUnionInfo *info)
2242 {
2243   GIBaseInfo *base = (GIBaseInfo *)info;
2244   UnionBlob *blob = (UnionBlob *)&base->typelib->data[base->offset];
2245
2246   return blob->alignment;
2247 }