diff options
author | Johan Dahlin <johan@gnome.org> | 2010-05-31 17:44:46 -0300 |
---|---|---|
committer | Johan Dahlin <johan@gnome.org> | 2010-05-31 17:47:50 -0300 |
commit | 5ed7381046c873d142452fbce03c310874cd8d4b (patch) | |
tree | 0dd0c070a14b70f4b796cba5a80e1104ba574adf /girepository/gitypelib-internal.h | |
parent | 39d0023ebcdbc72a6e7b48de657b594e9de97358 (diff) | |
download | gobject-introspection-5ed7381046c873d142452fbce03c310874cd8d4b.tar.gz |
[gtypelib.ch] Rename to gitypelib.ch
Rename gtypelib.h -> gitypelib-internal.h and rename
gtypelib.c to gitypelib.c
Diffstat (limited to 'girepository/gitypelib-internal.h')
-rw-r--r-- | girepository/gitypelib-internal.h | 1108 |
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__ */ + |