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