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

   1 /* GObject introspection: Repository implementation
   2  *
   3  * Copyright (C) 2005 Matthias Clasen
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the
  17  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18  * Boston, MA 02111-1307, USA.
  19  */
  20
  21 #include <stdlib.h>
  22 #include <string.h>
  23
  24 #include <glib.h>
  25 #include <glib-object.h>
  26
  27 #include "girepository.h"
  28 #include "gtypelib.h"
  29
  30 struct _GIBaseInfo
  31 {
  32   gint type;
  33   gint ref_count;
  34   GIBaseInfo *container;
  35
  36   GTypelib *typelib;
  37   guint32 offset;
  38 };
  39
  40 struct _GIUnresolvedInfo
  41 {
  42   gint type;
  43   gint ref_count;
  44   GIBaseInfo *container;
  45
  46   const gchar *name;
  47   const gchar *namespace;
  48 };
  49
  50 struct _GICallableInfo
  51 {
  52   GIBaseInfo base;
  53 };
  54
  55 struct _GIFunctionInfo
  56 {
  57   GICallableInfo callable;
  58 };
  59
  60 struct _GICallbackInfo
  61 {
  62   GICallableInfo callable;
  63 };
  64
  65 struct _GIRegisteredTypeInfo
  66 {
  67   GIBaseInfo base;
  68 };
  69
  70 struct _GIStructInfo
  71 {
  72   GIRegisteredTypeInfo registered;
  73 };
  74
  75 struct _GIEnumInfo
  76 {
  77   GIRegisteredTypeInfo registered;
  78 };
  79
  80 struct _GIObjectInfo
  81 {
  82   GIRegisteredTypeInfo registered;
  83 };
  84
  85 struct _GIInterfaceInfo
  86 {
  87   GIRegisteredTypeInfo registered;
  88 };
  89
  90 struct _GIConstantInfo
  91 {
  92   GIBaseInfo base;
  93 };
  94
  95 struct _GIValueInfo
  96 {
  97   GIBaseInfo base;
  98 };
  99
 100 struct _GISignalInfo
 101 {
 102   GICallableInfo callable;
 103 };
 104
 105 struct _GIVFuncInfo
 106 {
 107   GICallableInfo callable;
 108 };
 109
 110 struct _GIPropertyInfo
 111 {
 112   GIBaseInfo base;
 113 };
 114
 115 struct _GIFieldInfo
 116 {
 117   GIBaseInfo base;
 118 };
 119
 120 struct _GIArgInfo
 121 {
 122   GIBaseInfo base;
 123 };
 124
 125 struct _GITypeInfo
 126 {
 127   GIBaseInfo base;
 128 };
 129
 130 struct _GIUnionInfo
 131 {
 132   GIRegisteredTypeInfo registered;
 133 };
 134
 135
 136 /* info creation */
 137 GIBaseInfo *
 138 g_info_new (GIInfoType     type,
 139             GIBaseInfo    *container,
 140             GTypelib     *typelib,
 141             guint32        offset)
 142 {
 143   GIBaseInfo *info;
 144
 145   info = g_new0 (GIBaseInfo, 1);
 146
 147   info->ref_count = 1;
 148   info->type = type;
 149
 150   info->typelib = typelib;
 151   info->offset = offset;
 152
 153   if (container)
 154     info->container = g_base_info_ref (container);
 155
 156   return info;
 157 }
 158
 159 static GIBaseInfo *
 160 g_info_from_entry (GTypelib *typelib,
 161                    guint16    index)
 162 {
 163   GIBaseInfo *result;
 164   DirEntry *entry = g_typelib_get_dir_entry (typelib, index);
 165
 166   if (entry->local)
 167     result = g_info_new (entry->blob_type, NULL, typelib, entry->offset);
 168   else
 169     {
 170       const gchar *namespace = g_typelib_get_string (typelib, entry->offset);
 171       const gchar *name = g_typelib_get_string (typelib, entry->name);
 172
 173       GIRepository *repository = g_irepository_get_default ();
 174
 175       result = g_irepository_find_by_name (repository, namespace, name);
 176       if (result == NULL)
 177         {
 178           GIUnresolvedInfo *unresolved;
 179
 180           unresolved = g_new0 (GIUnresolvedInfo, 1);
 181
 182           unresolved->type = GI_INFO_TYPE_UNRESOLVED;
 183           unresolved->ref_count = 1;
 184           unresolved->container = NULL;
 185           unresolved->name = name;
 186           unresolved->namespace = namespace;
 187
 188           return (GIBaseInfo*)unresolved;
 189         }
 190       return result;
 191     }
 192
 193   return result;
 194 }
 195
 196 /* GIBaseInfo functions */
 197 GIBaseInfo *
 198 g_base_info_ref (GIBaseInfo *info)
 199 {
 200   info->ref_count++;
 201
 202   return info;
 203 }
 204
 205 void
 206 g_base_info_unref (GIBaseInfo *info)
 207 {
 208   g_assert (info->ref_count > 0);
 209   info->ref_count--;
 210
 211   if (!info->ref_count)
 212     {
 213       if (info->container)
 214         g_base_info_unref (info->container);
 215
 216       g_free (info);
 217     }
 218 }
 219
 220 GIInfoType
 221 g_base_info_get_type (GIBaseInfo *info)
 222 {
 223
 224   return info->type;
 225 }
 226
 227 const gchar *
 228 g_base_info_get_name (GIBaseInfo *info)
 229 {
 230   g_assert (info->ref_count > 0);
 231   switch (info->type)
 232     {
 233     case GI_INFO_TYPE_FUNCTION:
 234     case GI_INFO_TYPE_CALLBACK:
 235     case GI_INFO_TYPE_STRUCT:
 236     case GI_INFO_TYPE_BOXED:
 237     case GI_INFO_TYPE_ENUM:
 238     case GI_INFO_TYPE_FLAGS:
 239     case GI_INFO_TYPE_OBJECT:
 240     case GI_INFO_TYPE_INTERFACE:
 241     case GI_INFO_TYPE_CONSTANT:
 242     case GI_INFO_TYPE_ERROR_DOMAIN:
 243     case GI_INFO_TYPE_UNION:
 244       {
 245         CommonBlob *blob = (CommonBlob *)&info->typelib->data[info->offset];
 246
 247         return g_typelib_get_string (info->typelib, blob->name);
 248       }
 249       break;
 250
 251     case GI_INFO_TYPE_VALUE:
 252       {
 253         ValueBlob *blob = (ValueBlob *)&info->typelib->data[info->offset];
 254
 255         return g_typelib_get_string (info->typelib, blob->name);
 256       }
 257       break;
 258
 259     case GI_INFO_TYPE_SIGNAL:
 260       {
 261         SignalBlob *blob = (SignalBlob *)&info->typelib->data[info->offset];
 262
 263         return g_typelib_get_string (info->typelib, blob->name);
 264       }
 265       break;
 266
 267     case GI_INFO_TYPE_PROPERTY:
 268       {
 269         PropertyBlob *blob = (PropertyBlob *)&info->typelib->data[info->offset];
 270
 271         return g_typelib_get_string (info->typelib, blob->name);
 272       }
 273       break;
 274
 275     case GI_INFO_TYPE_VFUNC:
 276       {
 277         VFuncBlob *blob = (VFuncBlob *)&info->typelib->data[info->offset];
 278
 279         return g_typelib_get_string (info->typelib, blob->name);
 280       }
 281       break;
 282
 283     case GI_INFO_TYPE_FIELD:
 284       {
 285         FieldBlob *blob = (FieldBlob *)&info->typelib->data[info->offset];
 286
 287         return g_typelib_get_string (info->typelib, blob->name);
 288       }
 289       break;
 290
 291     case GI_INFO_TYPE_ARG:
 292       {
 293         ArgBlob *blob = (ArgBlob *)&info->typelib->data[info->offset];
 294
 295         return g_typelib_get_string (info->typelib, blob->name);
 296       }
 297       break;
 298     case GI_INFO_TYPE_UNRESOLVED:
 299       {
 300         GIUnresolvedInfo *unresolved = (GIUnresolvedInfo *)info;
 301
 302         return unresolved->name;
 303       }
 304       break;
 305     case GI_INFO_TYPE_TYPE:
 306     default: ;
 307       g_assert_not_reached ();
 308       /* unnamed */
 309     }
 310
 311   return NULL;
 312 }
 313
 314 const gchar *
 315 g_base_info_get_namespace (GIBaseInfo *info)
 316 {
 317   Header *header = (Header *)info->typelib->data;
 318
 319   g_assert (info->ref_count > 0);
 320
 321   if (info->type == GI_INFO_TYPE_UNRESOLVED)
 322     {
 323       GIUnresolvedInfo *unresolved = (GIUnresolvedInfo *)info;
 324
 325       return unresolved->namespace;
 326     }
 327
 328   return g_typelib_get_string (info->typelib, header->namespace);
 329 }
 330
 331 gboolean
 332 g_base_info_is_deprecated (GIBaseInfo *info)
 333 {
 334   switch (info->type)
 335     {
 336     case GI_INFO_TYPE_FUNCTION:
 337     case GI_INFO_TYPE_CALLBACK:
 338     case GI_INFO_TYPE_STRUCT:
 339     case GI_INFO_TYPE_BOXED:
 340     case GI_INFO_TYPE_ENUM:
 341     case GI_INFO_TYPE_FLAGS:
 342     case GI_INFO_TYPE_OBJECT:
 343     case GI_INFO_TYPE_INTERFACE:
 344     case GI_INFO_TYPE_CONSTANT:
 345     case GI_INFO_TYPE_ERROR_DOMAIN:
 346       {
 347         CommonBlob *blob = (CommonBlob *)&info->typelib->data[info->offset];
 348
 349         return blob->deprecated;
 350       }
 351       break;
 352
 353     case GI_INFO_TYPE_VALUE:
 354       {
 355         ValueBlob *blob = (ValueBlob *)&info->typelib->data[info->offset];
 356
 357         return blob->deprecated;
 358       }
 359       break;
 360
 361     case GI_INFO_TYPE_SIGNAL:
 362       {
 363         SignalBlob *blob = (SignalBlob *)&info->typelib->data[info->offset];
 364
 365         return blob->deprecated;
 366       }
 367       break;
 368
 369     case GI_INFO_TYPE_PROPERTY:
 370       {
 371         PropertyBlob *blob = (PropertyBlob *)&info->typelib->data[info->offset];
 372
 373         return blob->deprecated;
 374       }
 375       break;
 376
 377     case GI_INFO_TYPE_VFUNC:
 378     case GI_INFO_TYPE_FIELD:
 379     case GI_INFO_TYPE_ARG:
 380     case GI_INFO_TYPE_TYPE:
 381     default: ;
 382       /* no deprecation flag for these */
 383     }
 384
 385   return FALSE;
 386 }
 387
 388 static int
 389 cmp_annotation (const void *av,
 390                 const void *bv)
 391 {
 392   const AnnotationBlob *a = av;
 393   const AnnotationBlob *b = bv;
 394
 395   if (b->offset < a->offset)
 396     return -1;
 397
 398   if (b->offset > a->offset)
 399     return 1;
 400
 401   return 0;
 402 }
 403
 404 const gchar *
 405 g_base_info_get_annotation (GIBaseInfo   *info,
 406                             const gchar *name)
 407 {
 408   GIBaseInfo *base = (GIBaseInfo *)info;
 409   Header *header = (Header *)base->typelib->data;
 410   AnnotationBlob blob, *first, *after, *res, *next;
 411   const gchar *rname;
 412
 413   blob.offset = base->offset;
 414
 415   first = (AnnotationBlob *) &base->typelib->data[header->annotations];
 416   after = (AnnotationBlob *) &base->typelib->data[header->annotations +
 417                                              header->n_annotations * header->annotation_blob_size];
 418
 419   res = bsearch (&blob, first, header->n_annotations,
 420                  header->annotation_blob_size, cmp_annotation);
 421
 422   if (res == NULL)
 423     return NULL;
 424
 425   next = res;
 426   do
 427     {
 428       res = next;
 429       next = res -= header->annotation_blob_size;
 430     }
 431   while (next >= first && next->offset == base->offset);
 432
 433   next = res;
 434   do
 435     {
 436       res = next;
 437
 438       rname = g_typelib_get_string (base->typelib, res->name);
 439       if (strcmp (name, rname) == 0)
 440         return g_typelib_get_string (base->typelib, res->value);
 441
 442       next = res += header->annotation_blob_size;
 443     }
 444   while (next < after && next->offset == base->offset);
 445
 446   return NULL;
 447 }
 448
 449 GIBaseInfo *
 450 g_base_info_get_container (GIBaseInfo *info)
 451 {
 452   return info->container;
 453 }
 454
 455 GTypelib *
 456 g_base_info_get_typelib (GIBaseInfo *info)
 457 {
 458   return info->typelib;
 459 }
 460
 461 /* GIFunctionInfo functions */
 462 const gchar *
 463 g_function_info_get_symbol (GIFunctionInfo *info)
 464 {
 465   GIBaseInfo *base = (GIBaseInfo *)info;
 466   FunctionBlob *blob = (FunctionBlob *)&base->typelib->data[base->offset];
 467
 468   return g_typelib_get_string (base->typelib, blob->symbol);
 469 }
 470
 471 GIFunctionInfoFlags
 472 g_function_info_get_flags (GIFunctionInfo *info)
 473 {
 474   GIFunctionInfoFlags flags;
 475   GIBaseInfo *base = (GIBaseInfo *)info;
 476   FunctionBlob *blob = (FunctionBlob *)&base->typelib->data[base->offset];
 477
 478   flags = 0;
 479
 480   /* Make sure we don't flag Constructors as methods */
 481   if (base->container != NULL && !blob->constructor)
 482     flags = flags | GI_FUNCTION_IS_METHOD;
 483
 484   if (blob->constructor)
 485     flags = flags | GI_FUNCTION_IS_CONSTRUCTOR;
 486
 487   if (blob->getter)
 488     flags = flags | GI_FUNCTION_IS_GETTER;
 489
 490   if (blob->setter)
 491     flags = flags | GI_FUNCTION_IS_SETTER;
 492
 493   if (blob->wraps_vfunc)
 494     flags = flags | GI_FUNCTION_WRAPS_VFUNC;
 495
 496   if (blob->throws)
 497     flags = flags | GI_FUNCTION_THROWS;
 498
 499   return flags;
 500 }
 501
 502 GIPropertyInfo *
 503 g_function_info_get_property (GIFunctionInfo *info)
 504 {
 505   GIBaseInfo *base = (GIBaseInfo *)info;
 506   FunctionBlob *blob = (FunctionBlob *)&base->typelib->data[base->offset];
 507   GIInterfaceInfo *container = (GIInterfaceInfo *)base->container;
 508
 509   return g_interface_info_get_property (container, blob->index);
 510 }
 511
 512 GIVFuncInfo *
 513 g_function_info_get_vfunc (GIFunctionInfo *info)
 514 {
 515   GIBaseInfo *base = (GIBaseInfo *)info;
 516   FunctionBlob *blob = (FunctionBlob *)&base->typelib->data[base->offset];
 517   GIInterfaceInfo *container = (GIInterfaceInfo *)base->container;
 518
 519   return g_interface_info_get_vfunc (container, blob->index);
 520 }
 521
 522
 523 /* GICallableInfo functions */
 524 static guint32
 525 signature_offset (GICallableInfo *info)
 526 {
 527   int sigoff = -1;
 528   switch (info->base.type)
 529     {
 530     case GI_INFO_TYPE_FUNCTION:
 531       sigoff = G_STRUCT_OFFSET (FunctionBlob, signature);
 532       break;
 533     case GI_INFO_TYPE_VFUNC:
 534       sigoff = G_STRUCT_OFFSET (VFuncBlob, signature);
 535       break;
 536     case GI_INFO_TYPE_CALLBACK:
 537       sigoff = G_STRUCT_OFFSET (CallbackBlob, signature);
 538       break;
 539     case GI_INFO_TYPE_SIGNAL:
 540       sigoff = G_STRUCT_OFFSET (SignalBlob, signature);
 541       break;
 542     }
 543   if (sigoff >= 0)
 544     return *(guint32 *)&info->base.typelib->data[info->base.offset + sigoff];
 545   return 0;
 546 }
 547
 548 GITypeInfo *
 549 g_type_info_new (GIBaseInfo    *container,
 550                  GTypelib     *typelib,
 551                  guint32        offset)
 552 {
 553   SimpleTypeBlob *type = (SimpleTypeBlob *)&typelib->data[offset];
 554
 555   return (GITypeInfo *) g_info_new (GI_INFO_TYPE_TYPE, container, typelib,
 556                                     (type->reserved == 0 && type->reserved2 == 0) ? offset : type->offset);
 557 }
 558
 559 /**
 560  * g_callable_info_get_return_type:
 561  * @info: a #GICallableInfo
 562  *
 563  * Get the return type of a callable item as
 564  * a #GITypeInfo
 565  *
 566  * Returns: a #GITypeInfo idexing the TypeBlob for the
 567  * return type of #info
 568  */
 569 GITypeInfo *
 570 g_callable_info_get_return_type (GICallableInfo *info)
 571 {
 572   GIBaseInfo *base = (GIBaseInfo *)info;
 573   guint32 offset;
 574
 575   offset = signature_offset (info);
 576
 577   return g_type_info_new (base, base->typelib, offset);
 578 }
 579
 580 /**
 581  * g_callable_info_may_return_null:
 582  * @info: a #GICallableInfo
 583  *
 584  * See if a callable could return NULL.
 585  *
 586  * Returns: TRUE if callable could return NULL
 587  */
 588 gboolean
 589 g_callable_info_may_return_null (GICallableInfo *info)
 590 {
 591   GIBaseInfo *base = (GIBaseInfo *)info;
 592   SignatureBlob *blob = (SignatureBlob *)&base->typelib->data[signature_offset (info)];
 593
 594   return blob->may_return_null;
 595 }
 596
 597 /**
 598  * g_callable_info_get_caller_owns:
 599  * @info: a #GICallableInfo
 600  *
 601  * See whether the caller owns the return value
 602  * of this callable.
 603  *
 604  * Returns: TRUE if the caller owns the return value, FALSE otherwise.
 605  */
 606 GITransfer
 607 g_callable_info_get_caller_owns (GICallableInfo *info)
 608 {
 609   GIBaseInfo *base = (GIBaseInfo *)info;
 610   SignatureBlob *blob = (SignatureBlob *)&base->typelib->data[signature_offset (info)];
 611
 612   if (blob->caller_owns_return_value)
 613     return GI_TRANSFER_EVERYTHING;
 614   else if (blob->caller_owns_return_container)
 615     return GI_TRANSFER_CONTAINER;
 616   else
 617     return GI_TRANSFER_NOTHING;
 618 }
 619
 620 /**
 621  * g_callable_info_get_n_args:
 622  * @info: a #GICallableInfo
 623  *
 624  * Get the number of arguments (both IN and OUT) for this callable.
 625  *
 626  * Returns: The number of arguments this callable expects.
 627  */
 628 gint
 629 g_callable_info_get_n_args (GICallableInfo *info)
 630 {
 631   GIBaseInfo *base = (GIBaseInfo *)info;
 632   gint offset;
 633   SignatureBlob *blob;
 634
 635   offset = signature_offset (info);
 636   blob = (SignatureBlob *)&base->typelib->data[offset];
 637
 638   return blob->n_arguments;
 639 }
 640
 641 /**
 642  * g_callable_info_get_arg:
 643  * @info: a #GICallableInfo
 644  *
 645  * Get information about a particular argument of this callable.
 646  *
 647  * Returns: A #GIArgInfo indexing the typelib on the given argument.
 648  */
 649 GIArgInfo *
 650 g_callable_info_get_arg (GICallableInfo *info,
 651                          gint           n)
 652 {
 653   GIBaseInfo *base = (GIBaseInfo *)info;
 654   Header *header = (Header *)base->typelib->data;
 655   gint offset;
 656
 657   offset = signature_offset (info);
 658
 659   return (GIArgInfo *) g_info_new (GI_INFO_TYPE_ARG, base, base->typelib,
 660                                    offset + header->signature_blob_size + n * header->arg_blob_size);
 661 }
 662
 663 /* GIArgInfo function */
 664 GIDirection
 665 g_arg_info_get_direction (GIArgInfo *info)
 666 {
 667   GIBaseInfo *base = (GIBaseInfo *)info;
 668   ArgBlob *blob = (ArgBlob *)&base->typelib->data[base->offset];
 669
 670   if (blob->in && blob->out)
 671     return GI_DIRECTION_INOUT;
 672   else if (blob->out)
 673     return GI_DIRECTION_OUT;
 674   else
 675     return GI_DIRECTION_IN;
 676 }
 677
 678 gboolean
 679 g_arg_info_is_return_value (GIArgInfo *info)
 680 {
 681   GIBaseInfo *base = (GIBaseInfo *)info;
 682   ArgBlob *blob = (ArgBlob *)&base->typelib->data[base->offset];
 683
 684   return blob->return_value;
 685 }
 686
 687 gboolean
 688 g_arg_info_is_dipper (GIArgInfo *info)
 689 {
 690   GIBaseInfo *base = (GIBaseInfo *)info;
 691   ArgBlob *blob = (ArgBlob *)&base->typelib->data[base->offset];
 692
 693   return blob->dipper;
 694 }
 695
 696 gboolean
 697 g_arg_info_is_optional (GIArgInfo *info)
 698 {
 699   GIBaseInfo *base = (GIBaseInfo *)info;
 700   ArgBlob *blob = (ArgBlob *)&base->typelib->data[base->offset];
 701
 702   return blob->optional;
 703 }
 704
 705 gboolean
 706 g_arg_info_may_be_null (GIArgInfo *info)
 707 {
 708   GIBaseInfo *base = (GIBaseInfo *)info;
 709   ArgBlob *blob = (ArgBlob *)&base->typelib->data[base->offset];
 710
 711   return blob->allow_none;
 712 }
 713
 714 GITransfer
 715 g_arg_info_get_ownership_transfer (GIArgInfo *info)
 716 {
 717   GIBaseInfo *base = (GIBaseInfo *)info;
 718   ArgBlob *blob = (ArgBlob *)&base->typelib->data[base->offset];
 719
 720   if (blob->transfer_ownership)
 721     return GI_TRANSFER_EVERYTHING;
 722   else if (blob->transfer_container_ownership)
 723     return GI_TRANSFER_CONTAINER;
 724   else
 725     return GI_TRANSFER_NOTHING;
 726 }
 727
 728 GITypeInfo *
 729 g_arg_info_get_type (GIArgInfo *info)
 730 {
 731   GIBaseInfo *base = (GIBaseInfo *)info;
 732
 733   return g_type_info_new (base, base->typelib, base->offset + 8);
 734 }
 735
 736 /* GITypeInfo functions */
 737 gboolean
 738 g_type_info_is_pointer (GITypeInfo *info)
 739 {
 740   GIBaseInfo *base = (GIBaseInfo *)info;
 741   SimpleTypeBlob *type = (SimpleTypeBlob *)&base->typelib->data[base->offset];
 742
 743   if (type->reserved == 0 && type->reserved2 == 0)
 744     return type->pointer;
 745   else
 746     {
 747       InterfaceTypeBlob *iface = (InterfaceTypeBlob *)&base->typelib->data[base->offset];
 748
 749       return iface->pointer;
 750     }
 751 }
 752
 753 GITypeTag
 754 g_type_info_get_tag (GITypeInfo *info)
 755 {
 756   GIBaseInfo *base = (GIBaseInfo *)info;
 757   SimpleTypeBlob *type = (SimpleTypeBlob *)&base->typelib->data[base->offset];
 758
 759   if (type->reserved == 0 && type->reserved2 == 0)
 760     return type->tag;
 761   else
 762     {
 763       InterfaceTypeBlob *iface = (InterfaceTypeBlob *)&base->typelib->data[base->offset];
 764
 765       return iface->tag;
 766     }
 767 }
 768
 769 GITypeInfo *
 770 g_type_info_get_param_type (GITypeInfo *info,
 771                             gint       n)
 772 {
 773   GIBaseInfo *base = (GIBaseInfo *)info;
 774   SimpleTypeBlob *type = (SimpleTypeBlob *)&base->typelib->data[base->offset];
 775
 776   if (!(type->reserved == 0 && type->reserved2 == 0))
 777     {
 778       ParamTypeBlob *param = (ParamTypeBlob *)&base->typelib->data[base->offset];
 779
 780       switch (param->tag)
 781         {
 782         case GI_TYPE_TAG_ARRAY:
 783         case GI_TYPE_TAG_GLIST:
 784         case GI_TYPE_TAG_GSLIST:
 785         case GI_TYPE_TAG_GHASH:
 786           return g_type_info_new (base, base->typelib, base->offset + 4 + 4 * n);
 787           break;
 788
 789         default: ;
 790         }
 791     }
 792
 793   return NULL;
 794 }
 795
 796 GIBaseInfo *
 797 g_type_info_get_interface (GITypeInfo *info)
 798 {
 799   GIBaseInfo *base = (GIBaseInfo *)info;
 800   SimpleTypeBlob *type = (SimpleTypeBlob *)&base->typelib->data[base->offset];
 801
 802   if (!(type->reserved == 0 && type->reserved2 == 0))
 803     {
 804       InterfaceTypeBlob *blob = (InterfaceTypeBlob *)&base->typelib->data[base->offset];
 805
 806       if (blob->tag == GI_TYPE_TAG_INTERFACE)
 807         return g_info_from_entry (base->typelib, blob->interface);
 808     }
 809
 810   return NULL;
 811 }
 812
 813 gint
 814 g_type_info_get_array_length (GITypeInfo *info)
 815 {
 816   GIBaseInfo *base = (GIBaseInfo *)info;
 817   SimpleTypeBlob *type = (SimpleTypeBlob *)&base->typelib->data[base->offset];
 818
 819   if (!(type->reserved == 0 && type->reserved2 == 0))
 820     {
 821       ArrayTypeBlob *blob = (ArrayTypeBlob *)&base->typelib->data[base->offset];
 822
 823       if (blob->tag == GI_TYPE_TAG_ARRAY)
 824         {
 825           if (blob->has_length)
 826             return blob->length;
 827         }
 828     }
 829
 830   return -1;
 831 }
 832
 833 gboolean
 834 g_type_info_is_zero_terminated (GITypeInfo *info)
 835 {
 836   GIBaseInfo *base = (GIBaseInfo *)info;
 837   SimpleTypeBlob *type = (SimpleTypeBlob *)&base->typelib->data[base->offset];
 838
 839   if (!(type->reserved == 0 && type->reserved2 == 0))
 840     {
 841       ArrayTypeBlob *blob = (ArrayTypeBlob *)&base->typelib->data[base->offset];
 842
 843       if (blob->tag == GI_TYPE_TAG_ARRAY)
 844         return blob->zero_terminated;
 845     }
 846
 847   return FALSE;
 848 }
 849
 850 gint
 851 g_type_info_get_n_error_domains (GITypeInfo *info)
 852 {
 853   GIBaseInfo *base = (GIBaseInfo *)info;
 854   SimpleTypeBlob *type = (SimpleTypeBlob *)&base->typelib->data[base->offset];
 855
 856   if (!(type->reserved == 0 && type->reserved2 == 0))
 857     {
 858       ErrorTypeBlob *blob = (ErrorTypeBlob *)&base->typelib->data[base->offset];
 859
 860       if (blob->tag == GI_TYPE_TAG_ERROR)
 861         return blob->n_domains;
 862     }
 863
 864   return 0;
 865 }
 866
 867 GIErrorDomainInfo *
 868 g_type_info_get_error_domain (GITypeInfo *info,
 869                               gint       n)
 870 {
 871   GIBaseInfo *base = (GIBaseInfo *)info;
 872   SimpleTypeBlob *type = (SimpleTypeBlob *)&base->typelib->data[base->offset];
 873
 874   if (!(type->reserved == 0 && type->reserved2 == 0))
 875     {
 876       ErrorTypeBlob *blob = (ErrorTypeBlob *)&base->typelib->data[base->offset];
 877
 878       if (blob->tag == GI_TYPE_TAG_ERROR)
 879         return (GIErrorDomainInfo *) g_info_from_entry (base->typelib,
 880                                                         blob->domains[n]);
 881     }
 882
 883   return NULL;
 884 }
 885
 886
 887 /* GIErrorDomainInfo functions */
 888 const gchar *
 889 g_error_domain_info_get_quark (GIErrorDomainInfo *info)
 890 {
 891   GIBaseInfo *base = (GIBaseInfo *)info;
 892   ErrorDomainBlob *blob = (ErrorDomainBlob *)&base->typelib->data[base->offset];
 893
 894   return g_typelib_get_string (base->typelib, blob->get_quark);
 895 }
 896
 897 GIInterfaceInfo *
 898 g_error_domain_info_get_codes (GIErrorDomainInfo *info)
 899 {
 900   GIBaseInfo *base = (GIBaseInfo *)info;
 901   ErrorDomainBlob *blob = (ErrorDomainBlob *)&base->typelib->data[base->offset];
 902
 903   return (GIInterfaceInfo *) g_info_from_entry (base->typelib, blob->error_codes);
 904 }
 905
 906
 907 /* GIValueInfo functions */
 908 glong
 909 g_value_info_get_value (GIValueInfo *info)
 910 {
 911   GIBaseInfo *base = (GIBaseInfo *)info;
 912   ValueBlob *blob = (ValueBlob *)&base->typelib->data[base->offset];
 913
 914   return (glong)blob->value;
 915 }
 916
 917 /* GIFieldInfo functions */
 918 GIFieldInfoFlags
 919 g_field_info_get_flags (GIFieldInfo *info)
 920 {
 921   GIFieldInfoFlags flags;
 922
 923   GIBaseInfo *base = (GIBaseInfo *)info;
 924   FieldBlob *blob = (FieldBlob *)&base->typelib->data[base->offset];
 925
 926   flags = 0;
 927
 928   if (blob->readable)
 929     flags = flags | GI_FIELD_IS_READABLE;
 930
 931   if (blob->writable)
 932     flags = flags | GI_FIELD_IS_WRITABLE;
 933
 934   return flags;
 935 }
 936
 937 gint
 938 g_field_info_get_size (GIFieldInfo *info)
 939 {
 940   GIBaseInfo *base = (GIBaseInfo *)info;
 941   FieldBlob *blob = (FieldBlob *)&base->typelib->data[base->offset];
 942
 943   return blob->bits;
 944 }
 945
 946 gint
 947 g_field_info_get_offset (GIFieldInfo *info)
 948 {
 949   GIBaseInfo *base = (GIBaseInfo *)info;
 950   FieldBlob *blob = (FieldBlob *)&base->typelib->data[base->offset];
 951
 952   return blob->struct_offset;
 953 }
 954
 955 GITypeInfo *
 956 g_field_info_get_type (GIFieldInfo *info)
 957 {
 958   GIBaseInfo *base = (GIBaseInfo *)info;
 959
 960   return g_type_info_new (base, base->typelib, base->offset + 8);
 961 }
 962
 963 /* GIRegisteredTypeInfo functions */
 964 const gchar *
 965 g_registered_type_info_get_type_name (GIRegisteredTypeInfo *info)
 966 {
 967   GIBaseInfo *base = (GIBaseInfo *)info;
 968   RegisteredTypeBlob *blob = (RegisteredTypeBlob *)&base->typelib->data[base->offset];
 969
 970   if (blob->gtype_name)
 971     return g_typelib_get_string (base->typelib, blob->gtype_name);
 972
 973   return NULL;
 974 }
 975
 976 const gchar *
 977 g_registered_type_info_get_type_init (GIRegisteredTypeInfo *info)
 978 {
 979   GIBaseInfo *base = (GIBaseInfo *)info;
 980   RegisteredTypeBlob *blob = (RegisteredTypeBlob *)&base->typelib->data[base->offset];
 981
 982   if (blob->gtype_init)
 983     return g_typelib_get_string (base->typelib, blob->gtype_init);
 984
 985   return NULL;
 986 }
 987
 988 GType
 989 g_registered_type_info_get_g_type (GIRegisteredTypeInfo *info)
 990 {
 991   const char *type_init;
 992   GType (* get_type_func) (void);
 993
 994   type_init = g_registered_type_info_get_type_init (info);
 995
 996   if (type_init == NULL)
 997     return G_TYPE_NONE;
 998
 999   get_type_func = NULL;
1000   if (!g_typelib_symbol (((GIBaseInfo*)info)->typelib,
1001                          type_init,
1002                          (void**) &get_type_func))
1003     return G_TYPE_NONE;
1004
1005   return (* get_type_func) ();
1006 }
1007
1008 /* GIStructInfo functions */
1009 gint
1010 g_struct_info_get_n_fields (GIStructInfo *info)
1011 {
1012   GIBaseInfo *base = (GIBaseInfo *)info;
1013   StructBlob *blob = (StructBlob *)&base->typelib->data[base->offset];
1014
1015   return blob->n_fields;
1016 }
1017
1018 GIFieldInfo *
1019 g_struct_info_get_field (GIStructInfo *info,
1020                          gint         n)
1021 {
1022   GIBaseInfo *base = (GIBaseInfo *)info;
1023   Header *header = (Header *)base->typelib->data;
1024
1025   return (GIFieldInfo *) g_info_new (GI_INFO_TYPE_FIELD, base, base->typelib,
1026                                      base->offset + header->struct_blob_size +
1027                                      n * header->field_blob_size);
1028 }
1029
1030 gint
1031 g_struct_info_get_n_methods (GIStructInfo *info)
1032 {
1033   GIBaseInfo *base = (GIBaseInfo *)info;
1034   StructBlob *blob = (StructBlob *)&base->typelib->data[base->offset];
1035
1036   return blob->n_methods;
1037 }
1038
1039 GIFunctionInfo *
1040 g_struct_info_get_method (GIStructInfo *info,
1041                           gint         n)
1042 {
1043   GIBaseInfo *base = (GIBaseInfo *)info;
1044   StructBlob *blob = (StructBlob *)&base->typelib->data[base->offset];
1045   Header *header = (Header *)base->typelib->data;
1046   gint offset;
1047
1048   offset = base->offset + header->struct_blob_size
1049     + blob->n_fields * header->field_blob_size
1050     + n * header->function_blob_size;
1051   return (GIFunctionInfo *) g_info_new (GI_INFO_TYPE_FUNCTION, base,
1052                                         base->typelib, offset);
1053 }
1054
1055 static GIFunctionInfo *
1056 find_method (GIBaseInfo   *base,
1057              guint32       offset,
1058              gint          n_methods,
1059              const gchar  *name)
1060 {
1061   /* FIXME hash */
1062   Header *header = (Header *)base->typelib->data;
1063   gint i;
1064
1065   for (i = 0; i < n_methods; i++)
1066     {
1067       FunctionBlob *fblob = (FunctionBlob *)&base->typelib->data[offset];
1068       const gchar *fname = (const gchar *)&base->typelib->data[fblob->name];
1069
1070       if (strcmp (name, fname) == 0)
1071         return (GIFunctionInfo *) g_info_new (GI_INFO_TYPE_FUNCTION, base,
1072                                               base->typelib, offset);
1073
1074       offset += header->function_blob_size;
1075     }
1076
1077   return NULL;
1078 }
1079
1080 GIFunctionInfo *
1081 g_struct_info_find_method (GIStructInfo *info,
1082                            const gchar  *name)
1083 {
1084   gint offset;
1085   GIBaseInfo *base = (GIBaseInfo *)info;
1086   Header *header = (Header *)base->typelib->data;
1087   StructBlob *blob = (StructBlob *)&base->typelib->data[base->offset];
1088
1089   offset = base->offset + header->struct_blob_size
1090     + blob->n_fields * header->field_blob_size;
1091
1092   return find_method (base, offset, blob->n_methods, name);
1093 }
1094
1095 gint
1096 g_enum_info_get_n_values (GIEnumInfo *info)
1097 {
1098   GIBaseInfo *base = (GIBaseInfo *)info;
1099   EnumBlob *blob = (EnumBlob *)&base->typelib->data[base->offset];
1100
1101   return blob->n_values;
1102 }
1103
1104 GIValueInfo *
1105 g_enum_info_get_value (GIEnumInfo *info,
1106                        gint            n)
1107 {
1108   GIBaseInfo *base = (GIBaseInfo *)info;
1109   Header *header = (Header *)base->typelib->data;
1110   gint offset;
1111
1112   offset = base->offset + header->enum_blob_size
1113     + n * header->value_blob_size;
1114   return (GIValueInfo *) g_info_new (GI_INFO_TYPE_VALUE, base, base->typelib, offset);
1115 }
1116
1117 /* GIObjectInfo functions */
1118 GIObjectInfo *
1119 g_object_info_get_parent (GIObjectInfo *info)
1120 {
1121   GIBaseInfo *base = (GIBaseInfo *)info;
1122   ObjectBlob *blob = (ObjectBlob *)&base->typelib->data[base->offset];
1123
1124   if (blob->parent)
1125     return (GIObjectInfo *) g_info_from_entry (base->typelib, blob->parent);
1126   else
1127     return NULL;
1128 }
1129
1130 gboolean
1131 g_object_info_get_abstract (GIObjectInfo    *info)
1132 {
1133   GIBaseInfo *base = (GIBaseInfo *)info;
1134   ObjectBlob *blob = (ObjectBlob *)&base->typelib->data[base->offset];
1135   return blob->abstract != 0;
1136 }
1137
1138 const gchar *
1139 g_object_info_get_type_name (GIObjectInfo *info)
1140 {
1141   GIBaseInfo *base = (GIBaseInfo *)info;
1142   ObjectBlob *blob = (ObjectBlob *)&base->typelib->data[base->offset];
1143
1144   return g_typelib_get_string (base->typelib, blob->gtype_name);
1145 }
1146
1147 const gchar *
1148 g_object_info_get_type_init (GIObjectInfo *info)
1149 {
1150   GIBaseInfo *base = (GIBaseInfo *)info;
1151   ObjectBlob *blob = (ObjectBlob *)&base->typelib->data[base->offset];
1152
1153   return g_typelib_get_string (base->typelib, blob->gtype_init);
1154 }
1155
1156 gint
1157 g_object_info_get_n_interfaces (GIObjectInfo *info)
1158 {
1159   GIBaseInfo *base = (GIBaseInfo *)info;
1160   ObjectBlob *blob = (ObjectBlob *)&base->typelib->data[base->offset];
1161
1162   return blob->n_interfaces;
1163 }
1164
1165 GIInterfaceInfo *
1166 g_object_info_get_interface (GIObjectInfo *info,
1167                              gint          n)
1168 {
1169   GIBaseInfo *base = (GIBaseInfo *)info;
1170   ObjectBlob *blob = (ObjectBlob *)&base->typelib->data[base->offset];
1171
1172   return (GIInterfaceInfo *) g_info_from_entry (base->typelib, blob->interfaces[n]);
1173 }
1174
1175 gint
1176 g_object_info_get_n_fields (GIObjectInfo *info)
1177 {
1178   GIBaseInfo *base = (GIBaseInfo *)info;
1179   ObjectBlob *blob = (ObjectBlob *)&base->typelib->data[base->offset];
1180
1181   return blob->n_fields;
1182 }
1183
1184 GIFieldInfo *
1185 g_object_info_get_field (GIObjectInfo *info,
1186                          gint          n)
1187 {
1188   gint offset;
1189   GIBaseInfo *base = (GIBaseInfo *)info;
1190   Header *header = (Header *)base->typelib->data;
1191   ObjectBlob *blob = (ObjectBlob *)&base->typelib->data[base->offset];
1192
1193   offset = base->offset + header->object_blob_size
1194     + (blob->n_interfaces + blob->n_interfaces % 2) * 2
1195     + n * header->field_blob_size;
1196
1197   return (GIFieldInfo *) g_info_new (GI_INFO_TYPE_FIELD, base, base->typelib, offset);
1198 }
1199
1200 gint
1201 g_object_info_get_n_properties (GIObjectInfo *info)
1202 {
1203   GIBaseInfo *base = (GIBaseInfo *)info;
1204   ObjectBlob *blob = (ObjectBlob *)&base->typelib->data[base->offset];
1205
1206   return blob->n_properties;
1207 }
1208
1209 GIPropertyInfo *
1210 g_object_info_get_property (GIObjectInfo *info,
1211                             gint          n)
1212 {
1213   gint offset;
1214   GIBaseInfo *base = (GIBaseInfo *)info;
1215   Header *header = (Header *)base->typelib->data;
1216   ObjectBlob *blob = (ObjectBlob *)&base->typelib->data[base->offset];
1217
1218   offset = base->offset + header->object_blob_size
1219     + (blob->n_interfaces + blob->n_interfaces % 2) * 2
1220     + blob->n_fields * header->field_blob_size
1221     + n * header->property_blob_size;
1222
1223   return (GIPropertyInfo *) g_info_new (GI_INFO_TYPE_PROPERTY, base,
1224                                         base->typelib, offset);
1225 }
1226
1227 gint
1228 g_object_info_get_n_methods (GIObjectInfo *info)
1229 {
1230   GIBaseInfo *base = (GIBaseInfo *)info;
1231   ObjectBlob *blob = (ObjectBlob *)&base->typelib->data[base->offset];
1232
1233   return blob->n_methods;
1234 }
1235
1236 GIFunctionInfo *
1237 g_object_info_get_method (GIObjectInfo *info,
1238                           gint          n)
1239 {
1240   gint offset;
1241   GIBaseInfo *base = (GIBaseInfo *)info;
1242   Header *header = (Header *)base->typelib->data;
1243   ObjectBlob *blob = (ObjectBlob *)&base->typelib->data[base->offset];
1244
1245   offset = base->offset + header->object_blob_size
1246     + (blob->n_interfaces + blob->n_interfaces % 2) * 2
1247     + blob->n_fields * header->field_blob_size
1248     + blob->n_properties * header->property_blob_size
1249     + n * header->function_blob_size;
1250
1251     return (GIFunctionInfo *) g_info_new (GI_INFO_TYPE_FUNCTION, base,
1252                                           base->typelib, offset);
1253 }
1254
1255 GIFunctionInfo *
1256 g_object_info_find_method (GIObjectInfo *info,
1257                            const gchar  *name)
1258 {
1259   gint offset;
1260   GIBaseInfo *base = (GIBaseInfo *)info;
1261   Header *header = (Header *)base->typelib->data;
1262   ObjectBlob *blob = (ObjectBlob *)&base->typelib->data[base->offset];
1263
1264   offset = base->offset + header->object_blob_size
1265     + (blob->n_interfaces + blob->n_interfaces % 2) * 2
1266     + blob->n_fields * header->field_blob_size +
1267     + blob->n_properties * header->property_blob_size;
1268
1269   return find_method (base, offset, blob->n_methods, name);
1270 }
1271
1272 gint
1273 g_object_info_get_n_signals (GIObjectInfo *info)
1274 {
1275   GIBaseInfo *base = (GIBaseInfo *)info;
1276   ObjectBlob *blob = (ObjectBlob *)&base->typelib->data[base->offset];
1277
1278   return blob->n_signals;
1279 }
1280
1281 GISignalInfo *
1282 g_object_info_get_signal (GIObjectInfo *info,
1283                           gint          n)
1284 {
1285   gint offset;
1286   GIBaseInfo *base = (GIBaseInfo *)info;
1287   Header *header = (Header *)base->typelib->data;
1288   ObjectBlob *blob = (ObjectBlob *)&base->typelib->data[base->offset];
1289
1290   offset = base->offset + header->object_blob_size
1291     + (blob->n_interfaces + blob->n_interfaces % 2) * 2
1292     + blob->n_fields * header->field_blob_size
1293     + blob->n_properties * header->property_blob_size
1294     + blob->n_methods * header->function_blob_size
1295     + n * header->signal_blob_size;
1296
1297   return (GISignalInfo *) g_info_new (GI_INFO_TYPE_SIGNAL, base,
1298                                       base->typelib, offset);
1299 }
1300
1301 gint
1302 g_object_info_get_n_vfuncs (GIObjectInfo *info)
1303 {
1304   GIBaseInfo *base = (GIBaseInfo *)info;
1305   ObjectBlob *blob = (ObjectBlob *)&base->typelib->data[base->offset];
1306
1307   return blob->n_vfuncs;
1308 }
1309
1310 GIVFuncInfo *
1311 g_object_info_get_vfunc (GIObjectInfo *info,
1312                          gint          n)
1313 {
1314   gint offset;
1315   GIBaseInfo *base = (GIBaseInfo *)info;
1316   Header *header = (Header *)base->typelib->data;
1317   ObjectBlob *blob = (ObjectBlob *)&base->typelib->data[base->offset];
1318
1319   offset = base->offset + header->object_blob_size
1320     + (blob->n_interfaces + blob->n_interfaces % 2) * 2
1321     + blob->n_fields * header->field_blob_size
1322     + blob->n_properties * header->property_blob_size
1323     + blob->n_methods * header->function_blob_size
1324     + blob->n_signals * header->signal_blob_size
1325     + n * header->vfunc_blob_size;
1326
1327   return (GIVFuncInfo *) g_info_new (GI_INFO_TYPE_VFUNC, base,
1328                                      base->typelib, offset);
1329 }
1330
1331 gint
1332 g_object_info_get_n_constants (GIObjectInfo *info)
1333 {
1334   GIBaseInfo *base = (GIBaseInfo *)info;
1335   ObjectBlob *blob = (ObjectBlob *)&base->typelib->data[base->offset];
1336
1337   return blob->n_constants;
1338 }
1339
1340 GIConstantInfo *
1341 g_object_info_get_constant (GIObjectInfo *info,
1342                             gint          n)
1343 {
1344   gint offset;
1345   GIBaseInfo *base = (GIBaseInfo *)info;
1346   Header *header = (Header *)base->typelib->data;
1347   ObjectBlob *blob = (ObjectBlob *)&base->typelib->data[base->offset];
1348
1349   offset = base->offset + header->object_blob_size
1350     + (blob->n_interfaces + blob->n_interfaces % 2) * 2
1351     + blob->n_fields * header->field_blob_size
1352     + blob->n_properties * header->property_blob_size
1353     + blob->n_methods * header->function_blob_size
1354     + blob->n_signals * header->signal_blob_size
1355     + blob->n_vfuncs * header->vfunc_blob_size
1356     + n * header->constant_blob_size;
1357
1358   return (GIConstantInfo *) g_info_new (GI_INFO_TYPE_CONSTANT, base,
1359                                         base->typelib, offset);
1360 }
1361
1362
1363 /* GIInterfaceInfo functions */
1364 gint
1365 g_interface_info_get_n_prerequisites (GIInterfaceInfo *info)
1366 {
1367   GIBaseInfo *base = (GIBaseInfo *)info;
1368   InterfaceBlob *blob = (InterfaceBlob *)&base->typelib->data[base->offset];
1369
1370   return blob->n_prerequisites;
1371 }
1372
1373 GIBaseInfo *
1374 g_interface_info_get_prerequisite (GIInterfaceInfo *info,
1375                                    gint            n)
1376 {
1377   GIBaseInfo *base = (GIBaseInfo *)info;
1378   InterfaceBlob *blob = (InterfaceBlob *)&base->typelib->data[base->offset];
1379
1380   return g_info_from_entry (base->typelib, blob->prerequisites[n]);
1381 }
1382
1383
1384 gint
1385 g_interface_info_get_n_properties (GIInterfaceInfo *info)
1386 {
1387   GIBaseInfo *base = (GIBaseInfo *)info;
1388   InterfaceBlob *blob = (InterfaceBlob *)&base->typelib->data[base->offset];
1389
1390   return blob->n_properties;
1391 }
1392
1393 GIPropertyInfo *
1394 g_interface_info_get_property (GIInterfaceInfo *info,
1395                                gint            n)
1396 {
1397   gint offset;
1398   GIBaseInfo *base = (GIBaseInfo *)info;
1399   Header *header = (Header *)base->typelib->data;
1400   InterfaceBlob *blob = (InterfaceBlob *)&base->typelib->data[base->offset];
1401
1402   offset = base->offset + header->interface_blob_size
1403     + (blob->n_prerequisites + (blob->n_prerequisites % 2)) * 2
1404     + n * header->property_blob_size;
1405
1406   return (GIPropertyInfo *) g_info_new (GI_INFO_TYPE_PROPERTY, base,
1407                                         base->typelib, offset);
1408 }
1409
1410 gint
1411 g_interface_info_get_n_methods (GIInterfaceInfo *info)
1412 {
1413   GIBaseInfo *base = (GIBaseInfo *)info;
1414   InterfaceBlob *blob = (InterfaceBlob *)&base->typelib->data[base->offset];
1415
1416   return blob->n_methods;
1417 }
1418
1419 GIFunctionInfo *
1420 g_interface_info_get_method (GIInterfaceInfo *info,
1421                              gint            n)
1422 {
1423   gint offset;
1424   GIBaseInfo *base = (GIBaseInfo *)info;
1425   Header *header = (Header *)base->typelib->data;
1426   InterfaceBlob *blob = (InterfaceBlob *)&base->typelib->data[base->offset];
1427
1428   offset = base->offset + header->interface_blob_size
1429     + (blob->n_prerequisites + (blob->n_prerequisites % 2)) * 2
1430     + blob->n_properties * header->property_blob_size
1431     + n * header->function_blob_size;
1432
1433   return (GIFunctionInfo *) g_info_new (GI_INFO_TYPE_FUNCTION, base,
1434                                         base->typelib, offset);
1435 }
1436
1437 GIFunctionInfo *
1438 g_interface_info_find_method (GIInterfaceInfo *info,
1439                               const gchar     *name)
1440 {
1441   gint offset;
1442   GIBaseInfo *base = (GIBaseInfo *)info;
1443   Header *header = (Header *)base->typelib->data;
1444   InterfaceBlob *blob = (InterfaceBlob *)&base->typelib->data[base->offset];
1445
1446   offset = base->offset + header->interface_blob_size
1447     + (blob->n_prerequisites + (blob->n_prerequisites % 2)) * 2
1448     + blob->n_properties * header->property_blob_size;
1449
1450   return find_method (base, offset, blob->n_methods, name);
1451 }
1452
1453 gint
1454 g_interface_info_get_n_signals (GIInterfaceInfo *info)
1455 {
1456   GIBaseInfo *base = (GIBaseInfo *)info;
1457   InterfaceBlob *blob = (InterfaceBlob *)&base->typelib->data[base->offset];
1458
1459   return blob->n_signals;
1460 }
1461
1462 GISignalInfo *
1463 g_interface_info_get_signal (GIInterfaceInfo *info,
1464                              gint            n)
1465 {
1466   gint offset;
1467   GIBaseInfo *base = (GIBaseInfo *)info;
1468   Header *header = (Header *)base->typelib->data;
1469   InterfaceBlob *blob = (InterfaceBlob *)&base->typelib->data[base->offset];
1470
1471   offset = base->offset + header->interface_blob_size
1472     + (blob->n_prerequisites + (blob->n_prerequisites % 2)) * 2
1473     + blob->n_properties * header->property_blob_size
1474     + blob->n_methods * header->function_blob_size
1475     + n * header->signal_blob_size;
1476
1477   return (GISignalInfo *) g_info_new (GI_INFO_TYPE_SIGNAL, base,
1478                                       base->typelib, offset);
1479 }
1480
1481 gint
1482 g_interface_info_get_n_vfuncs (GIInterfaceInfo *info)
1483 {
1484   GIBaseInfo *base = (GIBaseInfo *)info;
1485   InterfaceBlob *blob = (InterfaceBlob *)&base->typelib->data[base->offset];
1486
1487   return blob->n_vfuncs;
1488 }
1489
1490 GIVFuncInfo *
1491 g_interface_info_get_vfunc (GIInterfaceInfo *info,
1492                             gint            n)
1493 {
1494   gint offset;
1495   GIBaseInfo *base = (GIBaseInfo *)info;
1496   Header *header = (Header *)base->typelib->data;
1497   InterfaceBlob *blob = (InterfaceBlob *)&base->typelib->data[base->offset];
1498
1499   offset = base->offset + header->interface_blob_size
1500     + (blob->n_prerequisites + (blob->n_prerequisites % 2)) * 2
1501     + blob->n_properties * header->property_blob_size
1502     + blob->n_methods * header->function_blob_size
1503     + blob->n_signals * header->signal_blob_size
1504     + n * header->vfunc_blob_size;
1505
1506   return (GIVFuncInfo *) g_info_new (GI_INFO_TYPE_VFUNC, base,
1507                                      base->typelib, offset);
1508 }
1509
1510 gint
1511 g_interface_info_get_n_constants (GIInterfaceInfo *info)
1512 {
1513   GIBaseInfo *base = (GIBaseInfo *)info;
1514   InterfaceBlob *blob = (InterfaceBlob *)&base->typelib->data[base->offset];
1515
1516   return blob->n_constants;
1517 }
1518
1519 GIConstantInfo *
1520 g_interface_info_get_constant (GIInterfaceInfo *info,
1521                                gint             n)
1522 {
1523   gint offset;
1524   GIBaseInfo *base = (GIBaseInfo *)info;
1525   Header *header = (Header *)base->typelib->data;
1526   InterfaceBlob *blob = (InterfaceBlob *)&base->typelib->data[base->offset];
1527
1528   offset = base->offset + header->interface_blob_size
1529     + (blob->n_prerequisites + (blob->n_prerequisites % 2)) * 2
1530     + blob->n_properties * header->property_blob_size
1531     + blob->n_methods * header->function_blob_size
1532     + blob->n_signals * header->signal_blob_size
1533     + blob->n_vfuncs * header->vfunc_blob_size
1534     + n * header->constant_blob_size;
1535
1536   return (GIConstantInfo *) g_info_new (GI_INFO_TYPE_CONSTANT, base,
1537                                         base->typelib, offset);
1538 }
1539
1540
1541
1542
1543 /* GIPropertyInfo functions */
1544 GParamFlags
1545 g_property_info_get_flags (GIPropertyInfo *info)
1546 {
1547   GParamFlags flags;
1548   GIBaseInfo *base = (GIBaseInfo *)info;
1549   PropertyBlob *blob = (PropertyBlob *)&base->typelib->data[base->offset];
1550
1551   flags = 0;
1552
1553   if (blob->readable)
1554     flags = flags | G_PARAM_READABLE;
1555
1556   if (blob->writable)
1557     flags = flags | G_PARAM_WRITABLE;
1558
1559   if (blob->construct)
1560     flags = flags | G_PARAM_CONSTRUCT;
1561
1562   if (blob->construct_only)
1563     flags = flags | G_PARAM_CONSTRUCT_ONLY;
1564
1565   return flags;
1566 }
1567
1568 GITypeInfo *
1569 g_property_info_get_type (GIPropertyInfo *info)
1570 {
1571   GIBaseInfo *base = (GIBaseInfo *)info;
1572
1573   return g_type_info_new (base, base->typelib, base->offset + 8);
1574 }
1575
1576
1577 /* GISignalInfo functions */
1578 GSignalFlags
1579 g_signal_info_get_flags (GISignalInfo *info)
1580 {
1581   GSignalFlags flags;
1582
1583   GIBaseInfo *base = (GIBaseInfo *)info;
1584   SignalBlob *blob = (SignalBlob *)&base->typelib->data[base->offset];
1585
1586   flags = 0;
1587
1588   if (blob->run_first)
1589     flags = flags | G_SIGNAL_RUN_FIRST;
1590
1591   if (blob->run_last)
1592     flags = flags | G_SIGNAL_RUN_LAST;
1593
1594   if (blob->run_cleanup)
1595     flags = flags | G_SIGNAL_RUN_CLEANUP;
1596
1597   if (blob->no_recurse)
1598     flags = flags | G_SIGNAL_NO_RECURSE;
1599
1600   if (blob->detailed)
1601     flags = flags | G_SIGNAL_DETAILED;
1602
1603   if (blob->action)
1604     flags = flags | G_SIGNAL_ACTION;
1605
1606   if (blob->no_hooks)
1607     flags = flags | G_SIGNAL_NO_HOOKS;
1608
1609   return flags;
1610 }
1611
1612 GIVFuncInfo *
1613 g_signal_info_get_class_closure (GISignalInfo *info)
1614 {
1615   GIBaseInfo *base = (GIBaseInfo *)info;
1616   SignalBlob *blob = (SignalBlob *)&base->typelib->data[base->offset];
1617
1618   if (blob->has_class_closure)
1619     return g_interface_info_get_vfunc ((GIInterfaceInfo *)base->container, blob->class_closure);
1620
1621   return NULL;
1622 }
1623
1624 gboolean
1625 g_signal_info_true_stops_emit (GISignalInfo *info)
1626 {
1627   GIBaseInfo *base = (GIBaseInfo *)info;
1628   SignalBlob *blob = (SignalBlob *)&base->typelib->data[base->offset];
1629
1630   return blob->true_stops_emit;
1631 }
1632
1633 /* GIVFuncInfo functions */
1634 GIVFuncInfoFlags
1635 g_vfunc_info_get_flags (GIVFuncInfo *info)
1636 {
1637   GIVFuncInfoFlags flags;
1638
1639   GIBaseInfo *base = (GIBaseInfo *)info;
1640   VFuncBlob *blob = (VFuncBlob *)&base->typelib->data[base->offset];
1641
1642   flags = 0;
1643
1644   if (blob->must_chain_up)
1645     flags = flags | GI_VFUNC_MUST_CHAIN_UP;
1646
1647   if (blob->must_be_implemented)
1648     flags = flags | GI_VFUNC_MUST_OVERRIDE;
1649
1650   if (blob->must_not_be_implemented)
1651     flags = flags | GI_VFUNC_MUST_NOT_OVERRIDE;
1652
1653   return flags;
1654 }
1655
1656 gint
1657 g_vfunc_info_get_offset (GIVFuncInfo *info)
1658 {
1659   GIBaseInfo *base = (GIBaseInfo *)info;
1660   VFuncBlob *blob = (VFuncBlob *)&base->typelib->data[base->offset];
1661
1662   return blob->struct_offset;
1663 }
1664
1665 GISignalInfo *
1666 g_vfunc_info_get_signal (GIVFuncInfo *info)
1667 {
1668   GIBaseInfo *base = (GIBaseInfo *)info;
1669   VFuncBlob *blob = (VFuncBlob *)&base->typelib->data[base->offset];
1670
1671   if (blob->class_closure)
1672     return g_interface_info_get_signal ((GIInterfaceInfo *)base->container, blob->signal);
1673
1674   return NULL;
1675 }
1676
1677
1678 /* GIConstantInfo functions */
1679 GITypeInfo *
1680 g_constant_info_get_type (GIConstantInfo *info)
1681 {
1682   GIBaseInfo *base = (GIBaseInfo *)info;
1683
1684   return g_type_info_new (base, base->typelib, base->offset + 8);
1685 }
1686
1687 gint
1688 g_constant_info_get_value (GIConstantInfo *info,
1689                            GArgument      *value)
1690 {
1691   GIBaseInfo *base = (GIBaseInfo *)info;
1692   ConstantBlob *blob = (ConstantBlob *)&base->typelib->data[base->offset];
1693
1694   /* FIXME non-basic types ? */
1695   if (blob->type.reserved == 0 && blob->type.reserved2 == 0)
1696     {
1697       if (blob->type.pointer)
1698         value->v_pointer = g_memdup (&base->typelib->data[blob->offset], blob->size);
1699       else
1700         {
1701           switch (blob->type.tag)
1702             {
1703             case GI_TYPE_TAG_BOOLEAN:
1704               value->v_boolean = *(gboolean*)&base->typelib->data[blob->offset];
1705               break;
1706             case GI_TYPE_TAG_INT8:
1707               value->v_int8 = *(gint8*)&base->typelib->data[blob->offset];
1708               break;
1709             case GI_TYPE_TAG_UINT8:
1710               value->v_uint8 = *(guint8*)&base->typelib->data[blob->offset];
1711               break;
1712             case GI_TYPE_TAG_INT16:
1713               value->v_int16 = *(gint16*)&base->typelib->data[blob->offset];
1714               break;
1715             case GI_TYPE_TAG_UINT16:
1716               value->v_uint16 = *(guint16*)&base->typelib->data[blob->offset];
1717               break;
1718             case GI_TYPE_TAG_INT32:
1719               value->v_int32 = *(gint32*)&base->typelib->data[blob->offset];
1720               break;
1721             case GI_TYPE_TAG_UINT32:
1722               value->v_uint32 = *(guint32*)&base->typelib->data[blob->offset];
1723               break;
1724             case GI_TYPE_TAG_INT64:
1725               value->v_int64 = *(gint64*)&base->typelib->data[blob->offset];
1726               break;
1727             case GI_TYPE_TAG_UINT64:
1728               value->v_uint64 = *(guint64*)&base->typelib->data[blob->offset];
1729               break;
1730             case GI_TYPE_TAG_FLOAT:
1731               value->v_float = *(gfloat*)&base->typelib->data[blob->offset];
1732               break;
1733             case GI_TYPE_TAG_DOUBLE:
1734               value->v_double = *(gdouble*)&base->typelib->data[blob->offset];
1735               break;
1736             case GI_TYPE_TAG_TIME_T:
1737               value->v_long = *(long*)&base->typelib->data[blob->offset];
1738               break;
1739             case GI_TYPE_TAG_INT:
1740               value->v_int = *(gint*)&base->typelib->data[blob->offset];
1741               break;
1742             case GI_TYPE_TAG_UINT:
1743               value->v_uint = *(guint*)&base->typelib->data[blob->offset];
1744               break;
1745             case GI_TYPE_TAG_LONG:
1746               value->v_long = *(glong*)&base->typelib->data[blob->offset];
1747               break;
1748             case GI_TYPE_TAG_ULONG:
1749               value->v_ulong = *(gulong*)&base->typelib->data[blob->offset];
1750               break;
1751             }
1752         }
1753     }
1754
1755   return blob->size;
1756 }
1757
1758 /* GIUnionInfo functions */
1759 gint
1760 g_union_info_get_n_fields  (GIUnionInfo *info)
1761 {
1762   GIBaseInfo *base = (GIBaseInfo *)info;
1763   UnionBlob *blob = (UnionBlob *)&base->typelib->data[base->offset];
1764
1765   return blob->n_fields;
1766 }
1767
1768 GIFieldInfo *
1769 g_union_info_get_field (GIUnionInfo *info,
1770                         gint         n)
1771 {
1772   GIBaseInfo *base = (GIBaseInfo *)info;
1773   Header *header = (Header *)base->typelib->data;
1774
1775   return (GIFieldInfo *) g_info_new (GI_INFO_TYPE_FIELD, base, base->typelib,
1776                                      base->offset + header->union_blob_size +
1777                                      n * header->field_blob_size);
1778 }
1779
1780 gint
1781 g_union_info_get_n_methods (GIUnionInfo *info)
1782 {
1783   GIBaseInfo *base = (GIBaseInfo *)info;
1784   UnionBlob *blob = (UnionBlob *)&base->typelib->data[base->offset];
1785
1786   return blob->n_functions;
1787 }
1788
1789 GIFunctionInfo *
1790 g_union_info_get_method (GIUnionInfo *info,
1791                          gint         n)
1792 {
1793   GIBaseInfo *base = (GIBaseInfo *)info;
1794   UnionBlob *blob = (UnionBlob *)&base->typelib->data[base->offset];
1795   Header *header = (Header *)base->typelib->data;
1796   gint offset;
1797
1798   offset = base->offset + header->union_blob_size
1799     + blob->n_fields * header->field_blob_size
1800     + n * header->function_blob_size;
1801   return (GIFunctionInfo *) g_info_new (GI_INFO_TYPE_FUNCTION, base,
1802                                         base->typelib, offset);
1803 }
1804
1805 gboolean
1806 g_union_info_is_discriminated (GIUnionInfo *info)
1807 {
1808   GIBaseInfo *base = (GIBaseInfo *)info;
1809   UnionBlob *blob = (UnionBlob *)&base->typelib->data[base->offset];
1810
1811   return blob->discriminated;
1812 }
1813
1814 gint
1815 g_union_info_get_discriminator_offset (GIUnionInfo *info)
1816 {
1817   GIBaseInfo *base = (GIBaseInfo *)info;
1818   UnionBlob *blob = (UnionBlob *)&base->typelib->data[base->offset];
1819
1820   return blob->discriminator_offset;
1821 }
1822
1823 GITypeInfo *
1824 g_union_info_get_discriminator_type (GIUnionInfo *info)
1825 {
1826   GIBaseInfo *base = (GIBaseInfo *)info;
1827
1828   return g_type_info_new (base, base->typelib, base->offset + 24);
1829 }
1830
1831 GIConstantInfo *
1832 g_union_info_get_discriminator (GIUnionInfo *info,
1833                                 gint         n)
1834 {
1835   GIBaseInfo *base = (GIBaseInfo *)info;
1836   UnionBlob *blob = (UnionBlob *)&base->typelib->data[base->offset];
1837
1838   if (blob->discriminated)
1839     {
1840       Header *header = (Header *)base->typelib->data;
1841       gint offset;
1842
1843       offset = base->offset + header->union_blob_size
1844         + blob->n_fields * header->field_blob_size
1845         + blob->n_functions * header->function_blob_size
1846         + n * header->constant_blob_size;
1847
1848       return (GIConstantInfo *) g_info_new (GI_INFO_TYPE_CONSTANT, base,
1849                                             base->typelib, offset);
1850     }
1851
1852   return NULL;
1853 }
1854
1855 GIFunctionInfo *
1856 g_union_info_find_method (GIUnionInfo *info,
1857                           const gchar *name)
1858 {
1859   gint offset;
1860   GIBaseInfo *base = (GIBaseInfo *)info;
1861   Header *header = (Header *)base->typelib->data;
1862   UnionBlob *blob = (UnionBlob *)&base->typelib->data[base->offset];
1863
1864   offset = base->offset + header->union_blob_size
1865     + blob->n_fields * header->field_blob_size;
1866
1867   return find_method (base, offset, blob->n_functions, name);
1868 }
1869