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