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