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