[gtypelib.ch] Rename to gitypelib.ch

Rename gtypelib.h -> gitypelib-internal.h and rename
gtypelib.c to gitypelib.c

1 files changed, 1108 insertions, 0 deletions

diff --git a/girepository/gitypelib-internal.h b/girepository/gitypelib-internal.h
new file mode 100644
index 00000000..0524efa1
--- /dev/null
+++ b/girepository/gitypelib-internal.h
@@ -0,0 +1,1108 @@
+/* GObject introspection: struct definitions for the binary
+ * typelib format, validation
+ *
+ * Copyright (C) 2005 Matthias Clasen
+ * Copyright (C) 2008,2009 Red Hat, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#ifndef __G_TYPELIB_H__
+#define __G_TYPELIB_H__
+
+#include <gmodule.h>
+#include "girepository.h"
+
+G_BEGIN_DECLS
+
+/**
+ * SECTION:gtypelib
+ * @short_description: Layout and accessors for typelib
+ * @stability: Stable
+ *
+ * The "typelib" is a binary, readonly, memory-mappable database
+ * containing reflective information about a GObject library.
+ *
+ * The format of GObject typelib is strongly influenced by the Mozilla XPCOM
+ * format.
+ *
+ * Some of the differences to XPCOM include:
+ * - Type information is stored not quite as compactly (XPCOM stores it inline
+ * in function descriptions in variable-sized blobs of 1 to n bytes. We store
+ * 16 bits of type information for each parameter, which is enough to encode
+ * simple types inline. Complex (e.g. recursive) types are stored out of line
+ * in a separate list of types.
+ * - String and complex type data is stored outside of typelib entry blobs,
+ * references are stored as offsets relative to the start of the typelib.
+ * One possibility is to store the strings and types in a pools at the end
+ * of the typelib.
+ *
+ * The typelib has the following general format.
+ *
+ * typelib ::= header, directory, blobs, attributes, attributedata
+ *
+ * directory ::= list of entries
+ *
+ * entry ::= blob type, name, namespace, offset
+ * blob ::= function|callback|struct|boxed|enum|flags|object|interface|constant|errordomain|union
+ * attributes ::= list of attributes, sorted by offset
+ * attribute ::= offset, key, value
+ * attributedata ::= string data for attributes
+ *
+ * Details
+ *
+ * We describe the fragments that make up the typelib in the form of C structs
+ * (although some fall short of being valid C structs since they contain multiple
+ * flexible arrays).
+ */
+
+/*
+TYPELIB HISTORY
+-----
+Version 1.0
+- Rename class_struct to gtype_struct, add to interfaces
+
+Changes since 0.9:
+- Add padding to structures
+
+Changes since 0.8:
+- Add class struct concept to ObjectBlob
+- Add is_class_struct bit to StructBlob
+
+Changes since 0.7:
+- Add dependencies
+
+Changes since 0.6:
+- rename metadata to typelib, to follow xpcom terminology
+
+Changes since 0.5:
+- basic type cleanup:
+  + remove GString
+  + add [u]int, [u]long, [s]size_t
+  + rename string to utf8, add filename
+- allow blob_type to be zero for non-local entries
+
+Changes since 0.4:
+- add a UnionBlob
+
+Changes since 0.3:
+- drop short_name for ValueBlob
+
+Changes since 0.2:
+- make inline types 4 bytes after all, remove header->types and allow
+  types to appear anywhere
+- allow error domains in the directory
+
+Changes since 0.1:
+
+- drop comments about _GOBJ_METADATA
+- drop string pool, strings can appear anywhere
+- use 'blob' as collective name for the various blob types
+- rename 'type' field in blobs to 'blob_type'
+- rename 'type_name' and 'type_init' fields to 'gtype_name', 'gtype_init'
+- shrink directory entries to 12 bytes
+- merge struct and boxed blobs
+- split interface blobs into enum, object and interface blobs
+- add an 'unregistered' flag to struct and enum blobs
+- add a 'wraps_vfunc' flag to function blobs and link them to
+  the vfuncs they wrap
+- restrict value blobs to only occur inside enums and flags again
+- add constant blobs, allow them toplevel, in interfaces and in objects
+- rename 'receiver_owns_value' and 'receiver_owns_container' to
+  'transfer_ownership' and 'transfer_container_ownership'
+- add a 'struct_offset' field to virtual function and field blobs
+- add 'dipper' and 'optional' flags to arg blobs
+- add a 'true_stops_emit' flag to signal blobs
+- add variable blob sizes to header
+- store offsets to signature blobs instead of including them directly
+- change the type offset to be measured in words rather than bytes
+*/
+
+/**
+ * G_IR_MAGIC:
+ *
+ * Identifying prefix for the typelib.  This was inspired by XPCOM,
+ * which in turn borrowed from PNG.
+ */
+#define G_IR_MAGIC "GOBJ\nMETADATA\r\n\032"
+
+/**
+ * GTypelibBlobType:
+ * @BLOB_TYPE_INVALID: Should not appear in code
+ * @BLOB_TYPE_FUNCTION: A #FunctionBlob
+ * @BLOB_TYPE_CALLBACK: A #CallbackBlob
+ * @BLOB_TYPE_STRUCT: A #StructBlob
+ * @BLOB_TYPE_BOXED: Can be either a #StructBlob or #UnionBlob
+ * @BLOB_TYPE_ENUM: An #EnumBlob
+ * @BLOB_TYPE_FLAGS: An #EnumBlob
+ * @BLOB_TYPE_OBJECT: An #ObjectBlob
+ * @BLOB_TYPE_INTERFACE: An #InterfaceBlob
+ * @BLOB_TYPE_CONSTANT: A #ConstantBlob
+ * @BLOB_TYPE_ERROR_DOMAIN: A #ErrorDomainBlob
+ * @BLOB_TYPE_UNION: A #UnionBlob
+ *
+ * The integral value of this enumeration appears in each "Blob"
+ * component of a typelib to identify its type.
+ */
+typedef enum {
+  BLOB_TYPE_INVALID,
+  BLOB_TYPE_FUNCTION,
+  BLOB_TYPE_CALLBACK,
+  BLOB_TYPE_STRUCT,
+  BLOB_TYPE_BOXED,
+  BLOB_TYPE_ENUM,
+  BLOB_TYPE_FLAGS,
+  BLOB_TYPE_OBJECT,
+  BLOB_TYPE_INTERFACE,
+  BLOB_TYPE_CONSTANT,
+  BLOB_TYPE_ERROR_DOMAIN,
+  BLOB_TYPE_UNION
+} GTypelibBlobType;
+
+#define BLOB_IS_REGISTERED_TYPE(blob)               \
+        ((blob)->blob_type == BLOB_TYPE_STRUCT ||   \
+         (blob)->blob_type == BLOB_TYPE_UNION  ||   \
+         (blob)->blob_type == BLOB_TYPE_ENUM   ||   \
+         (blob)->blob_type == BLOB_TYPE_OBJECT ||   \
+         (blob)->blob_type == BLOB_TYPE_INTERFACE)
+
+/**
+ * Header:
+ * @magic: See #G_IR_MAGIC.
+ * @major_version: The version of the typelib format. Minor version changes indicate
+ * compatible changes and should still allow the typelib to be parsed
+ * by a parser designed for the same major_version.
+ * @minor_version: See major_version.
+ * @n_entries: The number of entries in the directory.
+ * @n_local_entries: The number of entries referring to blobs in this typelib. The
+ * local entries must occur before the unresolved entries.
+ * @directory: Offset of the directory in the typelib.
+ * @n_attributes: Number of attribute blocks
+ * @attributes: Offset of the list of attributes in the typelib.
+ * @dependencies: Offset of a single string, which is the list of
+ * dependencies, separated by the '|' character.  The
+ * dependencies are required in order to avoid having programs
+ * consuming a typelib check for an "Unresolved" type return
+ * from every API call.
+ * @size: The size in bytes of the typelib.
+ * @namespace: Offset of the namespace string in the typelib.
+ * @nsversion: Offset of the namespace version string in the typelib.
+ * @shared_library: This field is the set of shared libraries associated
+ * with the typelib.  The entries are separated by the '|' (pipe) character.
+ * @c_prefix: The prefix for the function names of the library
+ * @entry_blob_size: The sizes of fixed-size blobs. Recording this information here
+ * allows to write parser which continue to work if the format is
+ * extended by adding new fields to the end of the fixed-size blobs.
+ * @function_blob_size: See above.
+ * @callback_blob_size: See above.
+ * @signal_blob_size: See above.
+ * @vfunc_blob_size: See above.
+ * @arg_blob_size: See above.
+ * @property_blob_size: See above.
+ * @field_blob_size: See above.
+ * @value_blob_size: See above.
+ * @attribute_blob_size: See above.
+ * @constant_blob_size: See above.
+ * @object_blob_size: See above.
+ * @union_blob_size: See above.
+ * @signature_blob_size: See above.
+ * @enum_blob_size: See above.
+ * @struct_blob_size: See above.
+ * @error_domain_blob_size: See above.
+ * @interface_blob_size: For variable-size blobs, the size of the struct up to the first
+ * flexible array member. Recording this information here allows to
+ * write parser which continue to work if the format is extended by
+ * adding new fields before the first flexible array member in
+ * variable-size blobs.
+ *
+ * The header structure appears exactly once at the beginning of a typelib.  It is a
+ * collection of meta-information, such as the number of entries and dependencies.
+ */
+typedef struct {
+  gchar   magic[16];
+  guint8  major_version;
+  guint8  minor_version;
+  /* <private> */
+  guint16 reserved;
+  /* <public> */
+  guint16 n_entries;
+  guint16 n_local_entries;
+  guint32 directory;
+  guint32 n_attributes;
+  guint32 attributes;
+
+  guint32 dependencies;
+
+  guint32 size;
+  guint32 namespace;
+  guint32 nsversion;
+  guint32 shared_library;
+  guint32 c_prefix;
+
+  guint16 entry_blob_size;
+  guint16 function_blob_size;
+  guint16 callback_blob_size;
+  guint16 signal_blob_size;
+  guint16 vfunc_blob_size;
+  guint16 arg_blob_size;
+  guint16 property_blob_size;
+  guint16 field_blob_size;
+  guint16 value_blob_size;
+  guint16 attribute_blob_size;
+  guint16 constant_blob_size;
+  guint16 error_domain_blob_size;
+
+  guint16 signature_blob_size;
+  guint16 enum_blob_size;
+  guint16 struct_blob_size;
+  guint16 object_blob_size;
+  guint16 interface_blob_size;
+  guint16 union_blob_size;
+
+  /* <private> */
+  guint16 padding[7];
+} Header;
+
+/**
+ * DirEntry:
+ * @blob_type: A #GTypelibBlobType
+ * @local: Whether this entry refers to a blob in this typelib.
+ * @name: The name of the entry.
+ * @offset:   If is_local is set, this is the offset of the blob in the typelib.
+ * Otherwise, it is the offset of the namespace in which the blob has
+ * to be looked up by name.
+ *
+ * References to directory entries are stored as 1-based 16-bit indexes.
+ *
+ * All blobs pointed to by a directory entry start with the same layout for
+ * the first 8 bytes (the reserved flags may be used by some blob types)
+ */
+typedef struct {
+  guint16 blob_type;
+
+  guint16 local    : 1;
+  /* <private> */
+  guint16 reserved :15;
+  /* <public> */
+  guint32 name;
+  guint32 offset;
+} DirEntry;
+
+/**
+ * SimpleTypeBlob:
+ * @is_pointer: Indicates whether the type is passed by reference.
+ * @tag: A #GITypeTag
+ * @offset:  Offset relative to header->types that points to a TypeBlob.
+ * Unlike other offsets, this is in words (ie 32bit units) rather
+ * than bytes.
+ *
+ * The SimpleTypeBlob is the general purpose "reference to a type" construct, used
+ * in method parameters, returns, callback definitions, fields, constants, etc.
+ * It's actually just a 32 bit integer which you can see from the union definition.
+ * This is for efficiency reasons, since there are so many references to types.
+ *
+ * SimpleTypeBlob is divided into two cases; first, if "reserved" and "reserved2", the
+ * type tag for a basic type is embedded in the "tag" bits.  This allows e.g.
+ * GI_TYPE_TAG_UTF8, GI_TYPE_TAG_INT and the like to be embedded directly without
+ * taking up extra space.
+ *
+ * References to "interfaces" (objects, interfaces) are more complicated;  In this case,
+ * the integer is actually an offset into the directory (see above).  Because the header
+ * is larger than 2^8=256 bits, all offsets will have one of the upper 24 bits set.
+ */
+typedef union
+{
+  struct
+  {
+    /* <private> */
+    guint reserved   : 8;
+    guint reserved2  :16;
+    /* <public> */
+    guint pointer    : 1;
+    /* <private> */
+    guint reserved3  : 2;
+    /* <public> */
+    guint tag        : 5;
+  } flags;
+  guint32    offset;
+} SimpleTypeBlob;
+
+/**
+ * ArgBlob:
+ * @name: A suggested name for the parameter.
+ * @in: The parameter is an input to the function
+ * @out: The parameter is used to return an output of the function.
+ * Parameters can be both in and out. Out parameters implicitly
+ * add another level of indirection to the parameter type. Ie if
+ * the type is uint32 in an out parameter, the function actually
+ * takes an uint32*.
+ * @caller_allocates: The parameter is a pointer to a struct or object that will
+ * receive an output of the function.
+ * @allow_none: Only meaningful for types which are passed as pointers.
+ * For an in parameter, indicates if it is ok to pass NULL in, for
+ * an out parameter, whether it may return NULL. Note that NULL is a
+ * valid GList and GSList value, thus allow_none will normally be set
+ * for parameters of these types.
+ * @optional: For an out parameter, indicates that NULL may be passed in
+ * if the value is not needed.
+ * @transfer_ownership: For an in parameter, indicates that the function takes over
+ * ownership of the parameter value. For an out parameter, it
+ * indicates that the caller is responsible for freeing the return
+ * value.
+ * @transfer_container_ownership: For container types, indicates that the
+ * ownership of the container,  but not of its contents is transferred. This is typically the case
+ * for out parameters returning lists of statically allocated things.
+ * @return_value: The parameter should be considered the return value of the function.
+ * Only out parameters can be marked as return value, and there can be
+ * at most one per function call. If an out parameter is marked as
+ * return value, the actual return value of the function should be
+ * either void or a boolean indicating the success of the call.
+ * @scope: A #GIScopeType. If the parameter is of a callback type, this denotes the scope
+ * of the user_data and the callback function pointer itself
+ * (for languages that emit code at run-time).
+ * @closure: Index of the closure (user_data) parameter associated with the callback,
+ * or -1.
+ * @destroy: Index of the destroy notfication callback parameter associated with
+ * the callback, or -1.
+ * @arg_type: Describes the type of the parameter. See details below.
+ *
+ * Types are specified by four bytes. If the three high bytes are zero,
+ * the low byte describes a basic type, otherwise the 32bit number is an
+ * offset which points to a TypeBlob.
+ */
+typedef struct {
+  guint32        name;
+
+  guint          in                           : 1;
+  guint          out                          : 1;
+  guint          caller_allocates             : 1;
+  guint          allow_none                   : 1;
+  guint          optional                     : 1;
+  guint          transfer_ownership           : 1;
+  guint          transfer_container_ownership : 1;
+  guint          return_value                 : 1;
+  guint          scope                        : 3;
+  /* <private> */
+  guint          reserved                     :21;
+
+  gint8        closure;
+  gint8        destroy;
+
+  SimpleTypeBlob arg_type;
+} ArgBlob;
+
+/**
+ * SignatureBlob:
+ * @return_type: Describes the type of the return value. See details below.
+ * @may_return_null: Only relevant for pointer types. Indicates whether the caller
+ * must expect NULL as a return value.
+ * @caller_owns_return_value: If set, the caller is responsible for freeing the return value
+ * if it is no longer needed.
+ * @caller_owns_return_container: This flag is only relevant if the return type is a container type.
+ * If the flag is set, the caller is resonsible for freeing the
+ * container, but not its contents.
+ * @n_arguments: The number of arguments that this function expects, also the length
+ * of the array of ArgBlobs.
+ * @arguments: An array of ArgBlob for the arguments of the function.
+ */
+typedef struct {
+  SimpleTypeBlob return_type;
+
+  guint16        may_return_null              : 1;
+  guint16        caller_owns_return_value     : 1;
+  guint16        caller_owns_return_container : 1;
+  guint16        reserved                     :13;
+
+  guint16        n_arguments;
+
+  ArgBlob        arguments[];
+} SignatureBlob;
+
+/**
+ * CommonBlob:
+ * @blob_type: A #GTypelibBlobType
+ * @deprecated: Whether the blob is deprecated.
+ * @name: The name of the blob.
+ *
+ * The #CommonBlob is shared between #FunctionBlob,
+ * #CallbackBlob, #SignalBlob.
+ */
+typedef struct {
+  guint16 blob_type;  /* 1 */
+
+  guint16 deprecated : 1;
+  /* <private> */
+  guint16 reserved   :15;
+  /* <public> */
+  guint32 name;
+} CommonBlob;
+
+/**
+ * FunctionBlob:
+ * @blob_Type: #BLOB_TYPE_FUNCTION
+ * @symbol:   The symbol which can be used to obtain the function pointer with
+ * dlsym().
+ * @deprecated: The function is deprecated.
+ * @setter: The function is a setter for a property. Language bindings may
+ * prefer to not bind individual setters and rely on the generic
+ * g_object_set().
+ * @getter: The function is a getter for a property. Language bindings may
+ * prefer to not bind individual getters and rely on the generic
+ * g_object_get().
+ * @constructor:The function acts as a constructor for the object it is contained
+ * in.
+ * @wraps_vfunc: The function is a simple wrapper for a virtual function.
+ * @index: Index of the property that this function is a setter or getter of
+ * in the array of properties of the containing interface, or index
+ * of the virtual function that this function wraps.
+ * @signature: Offset of the SignatureBlob describing the parameter types and the
+ * return value type.
+ * @is_static: The function is a "static method"; in other words it's a pure
+ * function whose name is conceptually scoped to the object.
+ */
+typedef struct {
+  guint16 blob_type;  /* 1 */
+
+  guint16 deprecated  : 1;
+  guint16 setter      : 1;
+  guint16 getter      : 1;
+  guint16 constructor : 1;
+  guint16 wraps_vfunc : 1;
+  guint16 throws      : 1;
+  guint16 index       :10;
+  /* Note the bits above need to match CommonBlob
+   * and are thus exhausted, extend things using
+   * the reserved block below. */
+
+  guint32 name;
+  guint32 symbol;
+  guint32 signature;
+
+  guint16 is_static   : 1;
+  guint16 reserved    : 15;
+  guint16 reserved2   : 16;
+} FunctionBlob;
+
+/**
+ * CallbackBlob:
+ * @signature: Offset of the #SignatureBlob describing the parameter types and the
+ * return value type.
+ */
+typedef struct {
+  guint16 blob_type;  /* 2 */
+
+  guint16 deprecated : 1;
+  /* <private> */
+  guint16 reserved   :15;
+  /* <public> */
+  guint32 name;
+  guint32 signature;
+} CallbackBlob;
+
+/**
+ * InterfaceTypeBlob:
+ * @pointer: Whether this type represents an indirection
+ * @tag: A #GITypeTag
+ * @interface: Index of the directory entry for the interface.
+ *
+ * If the interface is an enum of flags type, is_pointer is 0, otherwise it is 1.
+ */
+typedef struct {
+  guint8  pointer  :1;
+  /* <private> */
+  guint8  reserved :2;
+  /* <public> */
+  guint8  tag      :5;
+  /* <private> */
+  guint8  reserved2;
+  /* <public> */
+  guint16 interface;
+} InterfaceTypeBlob;
+
+/**
+ * ArrayTypeBlob:
+ * @zero_terminated: Indicates that the array must be terminated by a suitable #NULL
+ * value.
+ * @has_length: Indicates that length points to a parameter specifying the length
+ * of the array. If both has_length and zero_terminated are set, the
+ * convention is to pass -1 for the length if the array is
+ * zero-terminated.
+ * @has_size: Indicates that size is the fixed size of the array.
+ * @array_type: Indicates whether this is a C array, GArray, GPtrArray, or
+ * GByteArray. If something other than a C array, the length and element size
+ * are implicit in the structure.
+ * @length: The index of the parameter which is used to pass the length of the
+ * array. The parameter must be an integer type and have the same
+ * direction as this one.
+ * @size: The fixed size of the array.
+ * @type: The type of the array elements.
+ * Arrays are passed by reference, thus is_pointer is always 1.
+ */
+typedef struct {
+  guint16 pointer         :1;
+  guint16 reserved        :2;
+  guint16 tag             :5;
+
+  guint16 zero_terminated :1;
+  guint16 has_length      :1;
+  guint16 has_size        :1;
+  guint16 array_type      :2;
+  guint16 reserved2       :3;
+
+  union {
+    guint16 length;
+    guint16 size;
+  } dimensions;
+
+  SimpleTypeBlob type;
+} ArrayTypeBlob;
+
+/**
+ * ParamTypeBlob:
+ * @n_types: The number of parameter types to follow.
+ * @type: Describes the type of the list elements.
+ *
+ */
+typedef struct {
+  guint8	 pointer  :1;
+  guint8	 reserved :2;
+  guint8	 tag      :5;
+
+  guint8	 reserved2;
+  guint16	 n_types;
+
+  SimpleTypeBlob type[];
+} ParamTypeBlob;
+
+/**
+ * ErrorTypeBlob:
+ * @n_domains: The number of domains to follow
+ * @domains:  Indices of the directory entries for the error domains
+ */
+typedef struct {
+  guint8  pointer  :1;
+  guint8  reserved :2;
+  guint8  tag      :5;
+
+  guint8  reserved2;
+  guint16 n_domains;
+
+  guint16 domains[];
+}  ErrorTypeBlob;
+
+/**
+ * ErrorDomainBlob:
+ * @get_quark: The symbol name of the function which must be called to obtain the
+ * GQuark for the error domain.
+ * @error_codes: Index of the InterfaceBlob describing the enumeration which lists
+ * the possible error codes.
+ */
+typedef struct {
+  guint16 blob_type;  /* 10 */
+
+  guint16 deprecated : 1;
+  guint16 reserved   :15;
+
+  guint32 name;
+
+  guint32 get_quark;
+  guint16 error_codes;
+  guint16 reserved2;
+} ErrorDomainBlob;
+
+/**
+ * ValueBlob:
+ * @deprecated: Whether this value is deprecated
+ * @value: The numerical value
+ * @name: Name of blob
+ *
+ * Values commonly occur in enums and flags.
+ */
+typedef struct {
+  guint32 deprecated : 1;
+  /* <private> */
+  guint32 reserved   :31;
+  /* <public> */
+  guint32 name;
+  gint32 value;
+} ValueBlob;
+
+/**
+ * FieldBlob:
+ * @name: The name of the field.
+ * @readable:
+ * @writable: How the field may be accessed.
+ * @has_embedded_type: An anonymous type follows the FieldBlob.
+ * @bits: If this field is part of a bitfield, the number of bits which it
+ * uses, otherwise 0.
+ * @struct_offset:
+ * The offset of the field in the struct. The value 0xFFFF indicates
+ * that the struct offset is unknown.
+ * @type: The type of the field.
+ */
+typedef struct {
+  guint32        name;
+
+  guint8         readable :1;
+  guint8         writable :1;
+  guint8         has_embedded_type :1;
+  guint8         reserved :5;
+  guint8         bits;
+
+  guint16        struct_offset;
+
+  guint32        reserved2;
+
+  SimpleTypeBlob type;
+} FieldBlob;
+
+/**
+ * RegisteredTypeBlob:
+ * @gtype_name: The name under which the type is registered with GType.
+ * @gtype_init: The symbol name of the get_type() function which registers the type.
+ */
+typedef struct {
+  guint16 blob_type;
+  guint16 deprecated   : 1;
+  guint16 unregistered : 1;
+  guint16 reserved :14;
+  guint32 name;
+
+  guint32 gtype_name;
+  guint32 gtype_init;
+} RegisteredTypeBlob;
+
+/**
+ * StructBlob:
+ * @blob_type: #BLOB_TYPE_STRUCT
+ * @deprecated: Whether this structure is deprecated
+ * @unregistered: If this is set, the type is not registered with GType.
+ * @alignment: The byte boundary that the struct is aligned to in memory
+ * @is_gtype_struct: Whether this structure is the class or interface layout for a GObject
+ * @foreign: If the type is foreign, eg if it's expected to be overridden by
+ * a native language binding instead of relying of introspected bindings.
+ * @size: The size of the struct in bytes.
+ * @gtype_name: String name of the associated #GType
+ * @gtype_init: String naming the symbol which gets the runtime #GType
+ * @n_fields:
+ * @fields: An array of n_fields FieldBlobs.
+ * should be considered as methods of the struct.
+ */
+typedef struct {
+  guint16   blob_type;
+
+  guint16   deprecated   : 1;
+  guint16   unregistered : 1;
+  guint16   is_gtype_struct : 1;
+  guint16   alignment    : 6;
+  guint16   foreign      : 1;
+  guint16   reserved     : 6;
+
+  guint32   name;
+
+  guint32   gtype_name;
+  guint32   gtype_init;
+
+  guint32   size;
+
+  guint16   n_fields;
+  guint16   n_methods;
+
+  guint32   reserved2;
+  guint32   reserved3;
+
+#if 0
+  /* variable-length parts of the blob */
+  FieldBlob    fields[];
+  FunctionBlob methods[];
+#endif
+} StructBlob;
+
+/**
+ * UnionBlob:
+ * @unregistered: If this is set, the type is not registered with GType.
+ * @discriminated: Is set if the union is discriminated
+ * @alignment: The byte boundary that the union is aligned to in memory
+ * @size: The size of the union in bytes.
+ * @gtype_name: String name of the associated #GType
+ * @gtype_init: String naming the symbol which gets the runtime #GType
+ * @n_fields: Length of the arrays
+ * @discriminator_offset: Offset from the beginning of the union where the
+ * discriminator of a discriminated union is located.
+ * The value 0xFFFF indicates that the discriminator offset
+ * is unknown.
+ * @discriminator_type: Type of the discriminator
+ * @fields: Array of FieldBlobs describing the alternative branches of the union
+ */
+typedef struct {
+  guint16      blob_type;
+  guint16      deprecated    : 1;
+  guint16      unregistered  : 1;
+  guint16      discriminated : 1;
+  guint16      alignment     : 6;
+  guint16      reserved      : 7;
+  guint32      name;
+
+  guint32      gtype_name;
+  guint32      gtype_init;
+
+  guint32      size;
+
+  guint16      n_fields;
+  guint16      n_functions;
+
+  guint32      reserved2;
+  guint32      reserved3;
+
+  gint32       discriminator_offset;
+  SimpleTypeBlob discriminator_type;
+
+#if 0
+  FieldBlob    fields[];
+  FunctionBlob functions[];
+  ConstantBlob discriminator_values[]
+#endif
+} UnionBlob;
+
+/**
+ * EnumBlob:
+ * @unregistered: If this is set, the type is not registered with GType.
+ * @storage_type: The tag of the type used for the enum in the C ABI
+ * (will be a signed or unsigned integral type)
+ * @gtype_name: String name of the associated #GType
+ * @gtype_init: String naming the symbol which gets the runtime #GType
+ * @n_values: The lengths of the values arrays.
+ * @values: Describes the enum values.
+ */
+typedef struct {
+  guint16   blob_type;
+
+  guint16   deprecated   : 1;
+  guint16   unregistered : 1;
+  guint16   storage_type : 5;
+  guint16   reserved     : 9;
+
+  guint32   name;
+
+  guint32   gtype_name;
+  guint32   gtype_init;
+
+  guint16   n_values;
+  guint16   reserved2;
+
+  guint32   reserved3;
+
+  ValueBlob values[];
+} EnumBlob;
+
+/**
+ * PropertyBlob:
+ * @name:     The name of the property.
+ * @readable:
+ * @writable:
+ * @construct:
+ * @construct_only: The ParamFlags used when registering the property.
+ * @type: Describes the type of the property.
+ */
+typedef struct {
+  guint32        name;
+
+  guint32        deprecated     : 1;
+  guint32        readable       : 1;
+  guint32        writable       : 1;
+  guint32        construct      : 1;
+  guint32        construct_only : 1;
+  guint32        reserved       :27;
+
+  guint32        reserved2;
+
+  SimpleTypeBlob type;
+} PropertyBlob;
+
+/**
+ * SignalBlob:
+ * @name: The name of the signal.
+ * @run_first:
+ * @run_last:
+ * @run_cleanup:
+ * @no_recurse:
+ * @detailed:
+ * @action:
+ * @no_hooks: The flags used when registering the signal.
+ * @has_class_closure: Set if the signal has a class closure.
+ * @true_stops_emit: Whether the signal has true-stops-emit semantics
+ * @class_closure: The index of the class closure in the list of virtual functions
+ * of the object or interface on which the signal is defined.
+ * @signature: Offset of the SignatureBlob describing the parameter types and the
+ * return value type.
+ */
+typedef struct {
+  guint16 deprecated        : 1;
+  guint16 run_first         : 1;
+  guint16 run_last          : 1;
+  guint16 run_cleanup       : 1;
+  guint16 no_recurse        : 1;
+  guint16 detailed          : 1;
+  guint16 action            : 1;
+  guint16 no_hooks          : 1;
+  guint16 has_class_closure : 1;
+  guint16 true_stops_emit   : 1;
+  guint16 reserved          : 6;
+
+  guint16 class_closure;
+
+  guint32 name;
+
+  guint32 reserved2;
+
+  guint32 signature;
+} SignalBlob;
+
+/**
+ * VFuncBlob:
+ * @name: The name of the virtual function.
+ * @must_chain_up: If set, every implementation of this virtual function must
+ * chain up to the implementation of the parent class.
+ * @must_be_implemented: If set, every derived class must override this virtual function.
+ * @must_not_be_implemented: If set, derived class must not override this virtual function.
+ * @class_closure: Set if this virtual function is the class closure of a signal.
+ * @signal: The index of the signal in the list of signals of the object or
+ * interface to which this virtual function belongs.
+ * @struct_offset: The offset of the function pointer in the class struct. The value
+ * 0xFFFF indicates that the struct offset is unknown.
+ * @invoker: If a method invoker for this virtual exists, this is the offset in the
+ * class structure of the method.  If no method is known, this value will be 0x3ff.
+ * @signature:
+ * Offset of the SignatureBlob describing the parameter types and the
+ * return value type.
+ */
+typedef struct {
+  guint32 name;
+
+  guint16 must_chain_up           : 1;
+  guint16 must_be_implemented     : 1;
+  guint16 must_not_be_implemented : 1;
+  guint16 class_closure           : 1;
+  guint16 reserved                :12;
+  guint16 signal;
+
+  guint16 struct_offset;
+  guint16 invoker : 10; /* Number of bits matches @index in FunctionBlob */
+  guint16 reserved2 : 6;
+
+  guint32 reserved3;
+  guint32 signature;
+} VFuncBlob;
+
+/**
+ * ObjectBlob:
+ * @blob_type: #BLOB_TYPE_OBJECT
+ * @gtype_name: String name of the associated #GType
+ * @gtype_init: String naming the symbol which gets the runtime #GType
+ * @parent: The directory index of the parent type. This is only set for
+ * objects. If an object does not have a parent, it is zero.
+ * @n_interfaces:
+ * @n_fields:
+ * @n_properties:
+ * @n_methods:
+ * @n_signals:
+ * @n_vfuncs:
+ * @n_constants: The lengths of the arrays.Up to 16bits of padding may be inserted
+ * between the arrays to ensure that they start on a 32bit boundary.
+ * @interfaces: An array of indices of directory entries for the implemented
+ * interfaces.
+ * @fields: Describes the fields.
+ * @methods: Describes the methods, constructors, setters and getters.
+ * @properties: Describes the properties.
+ * @signals: Describes the signals.
+ * @vfuncs: Describes the virtual functions.
+ * @constants: Describes the constants.
+ */
+typedef struct {
+  guint16   blob_type;  /* 7 */
+  guint16   deprecated   : 1;
+  guint16   abstract     : 1;
+  guint16   reserved     :14;
+  guint32   name;
+
+  guint32   gtype_name;
+  guint32   gtype_init;
+
+  guint16   parent;
+  guint16   gtype_struct;
+
+  guint16   n_interfaces;
+  guint16   n_fields;
+  guint16   n_properties;
+  guint16   n_methods;
+  guint16   n_signals;
+  guint16   n_vfuncs;
+  guint16   n_constants;
+  guint16   reserved2;
+
+  guint32   reserved3;
+  guint32   reserved4;
+
+  guint16   interfaces[];
+
+#if 0
+  /* variable-length parts of the blob */
+  FieldBlob           fields[];
+  PropertyBlob        properties[];
+  FunctionBlob        methods[];
+  SignalBlob          signals[];
+  VFuncBlob           vfuncs[];
+  ConstantBlob        constants[];
+#endif
+} ObjectBlob;
+
+/**
+ * InterfaceBlob:
+ * @gtype_struct: Name of the interface "class" C structure
+ * @n_prerequisites: Number of prerequisites
+ * @n_properties: Number of properties
+ * @n_methods: Number of methods
+ * @n_signals: Number of signals
+ * @n_vfuncs: Number of virtual functions
+ * @n_constants: The lengths of the arrays.
+ * Up to 16bits of padding may be inserted between the arrays to ensure that they
+ * start on a 32bit boundary.
+ * @prerequisites: An array of indices of directory entries for required interfaces.
+ * @methods: Describes the methods, constructors, setters and getters.
+ * @properties: Describes the properties.
+ * @signals:  Describes the signals.
+ * @vfuncs: Describes the virtual functions.
+ * @constants: Describes the constants.
+ */
+typedef struct {
+  guint16 blob_type;
+  guint16 deprecated   : 1;
+  guint16 reserved     :15;
+  guint32 name;
+
+  guint32 gtype_name;
+  guint32 gtype_init;
+  guint16 gtype_struct;
+
+  guint16 n_prerequisites;
+  guint16 n_properties;
+  guint16 n_methods;
+  guint16 n_signals;
+  guint16 n_vfuncs;
+  guint16 n_constants;
+
+  guint32 reserved2;
+  guint32 reserved3;
+
+  guint16 prerequisites[];
+
+#if 0
+  /* variable-length parts of the blob */
+  PropertyBlob        properties[];
+  FunctionBlob        methods[];
+  SignalBlob          signals[];
+  VFuncBlob           vfuncs[];
+  ConstantBlob        constants[];
+#endif
+} InterfaceBlob;
+
+/**
+ * ConstantBlob:
+ * @type: The type of the value. In most cases this should be a numeric
+ * type or string.
+ * @size: The size of the value in bytes.
+ * @offset: The offset of the value in the typelib.
+ */
+typedef struct {
+  guint16        blob_type;
+  guint16        deprecated   : 1;
+  guint16        reserved     :15;
+  guint32        name;
+
+  SimpleTypeBlob type;
+
+  guint32        size;
+  guint32        offset;
+
+  guint32        reserved2;
+} ConstantBlob;
+
+/**
+ * AttributeBlob:
+ * @offset: The offset of the typelib entry to which this attribute refers.
+ * Attributes are kept sorted by offset, so that the attributes
+ * of an entry can be found by a binary search.
+ * @name: The name of the attribute, a string.
+ * @value: The value of the attribute (also a string)
+ */
+typedef struct {
+  guint32 offset;
+  guint32 name;
+  guint32 value;
+} AttributeBlob;
+
+/**
+ * GTypelib:
+ */
+struct _GTypelib {
+  /* <private> */
+  guchar *data;
+  gsize len;
+  gboolean owns_memory;
+  GMappedFile *mfile;
+  GList *modules;
+  gboolean open_attempted;
+};
+
+DirEntry *g_typelib_get_dir_entry (GTypelib *typelib,
+				   guint16   index);
+
+void      g_typelib_check_sanity (void);
+
+#define   g_typelib_get_string(typelib,offset) ((const gchar*)&(typelib->data)[(offset)])
+
+
+/**
+ * GTypelibError:
+ * @G_TYPELIB_ERROR_INVALID: the typelib is invalid
+ * @G_TYPELIB_ERROR_INVALID_HEADER: the typelib header is invalid
+ * @G_TYPELIB_ERROR_INVALID_DIRECTORY: the typelib directory is invalid
+ * @G_TYPELIB_ERROR_INVALID_ENTRY: a typelib entry is invalid
+ * @G_TYPELIB_ERROR_INVALID_BLOB: a typelib blob is invalid
+ *
+ * A error set while validating the #GTypelib
+ */
+typedef enum
+{
+  G_TYPELIB_ERROR_INVALID,
+  G_TYPELIB_ERROR_INVALID_HEADER,
+  G_TYPELIB_ERROR_INVALID_DIRECTORY,
+  G_TYPELIB_ERROR_INVALID_ENTRY,
+  G_TYPELIB_ERROR_INVALID_BLOB
+} GTypelibError;
+
+#define G_TYPELIB_ERROR (g_typelib_error_quark ())
+
+GQuark g_typelib_error_quark (void);
+
+gboolean g_typelib_validate (GTypelib  *typelib,
+			     GError    **error);
+
+
+G_END_DECLS
+
+#endif  /* __G_TYPELIB_H__ */
+