luc14n0/glib
1
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/glib.git synced 2024-12-25 23:16:14 +01:00
Code Issues Packages Projects Releases Wiki Activity
a6df2ec312
glib/girepository/gitypelib-internal.h
Philip Withnall 844544f72c girepository: Add SPDX license header to all obvious files 
Add the SPDX license runes to all the files which have an obvious
copyright header already. This is a mechanical edit.

Signed-off-by: Philip Withnall <philip@tecnocode.co.uk>

Helps: #3155
2023-10-25 17:10:10 +01:00

1355 lines
41 KiB
C
Raw Blame History

/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*-
* GObject introspection: struct definitions for the binary
* typelib format, validation
*
* Copyright (C) 2005 Matthias Clasen
* Copyright (C) 2008,2009 Red Hat, Inc.
*
* SPDX-License-Identifier: LGPL-2.1-or-later
*
* 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:gitypelib-internal
* @title: GITypelib Internals
* @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.
*
* What the typelib describes and the types used are the same for every
* platform so, apart the endianness of its scalar values, the typelib
* database must be considered architecture-independent.
*
* 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:
*
* |[<!-- language="C" -->
* typelib ::= header, section-index, directory, blobs, attributes, attributedata
*
* directory ::= list of entries
*
* entry ::= blob type, name, namespace, offset
* blob ::= function|callback|struct|boxed|enum|flags|object|interface|constant|union
* 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.1
- Add ref/unref/set-value/get-value functions to Object, to be able
to support instantiatable fundamental types which are not GObject based.
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_INVALID_0: Deleted, used to be ErrorDomain.
* @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_INVALID_0,
BLOB_TYPE_UNION
} GTypelibBlobType;
#if defined (G_CAN_INLINE) && defined (G_ALWAYS_INLINE)
G_ALWAYS_INLINE
inline gboolean
_blob_is_registered_type (GTypelibBlobType blob_type)
{
switch (blob_type)
{
case BLOB_TYPE_STRUCT:
case BLOB_TYPE_UNION:
case BLOB_TYPE_ENUM:
case BLOB_TYPE_FLAGS:
case BLOB_TYPE_OBJECT:
case BLOB_TYPE_INTERFACE:
return TRUE;
default:
return FALSE;
}
}
#define BLOB_IS_REGISTERED_TYPE(blob) \
_blob_is_registered_type ((GTypelibBlobType) (blob)->blob_type)
#else
#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_FLAGS || \
(blob)->blob_type == BLOB_TYPE_OBJECT || \
(blob)->blob_type == BLOB_TYPE_INTERFACE)
#endif /* defined (G_CAN_INLINE) && defined (G_ALWAYS_INLINE) */
/**
* Header:
* @magic: See #G_IR_MAGIC.
* @major_version: The major version number of the typelib format. Major version
* number changes indicate incompatible changes to the tyeplib format.
* @minor_version: The minor version number of the typelib format. Minor version
* number changes indicate compatible changes and should still allow the
* typelib to be parsed by a parser designed for the same @major_version.
* @reserved: Reserved for future use.
* @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 immediate
* 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 @entry_blob_size.
* @callback_blob_size: See @entry_blob_size.
* @signal_blob_size: See @entry_blob_size.
* @vfunc_blob_size: See @entry_blob_size.
* @arg_blob_size: See @entry_blob_size.
* @property_blob_size: See @entry_blob_size.
* @field_blob_size: See @entry_blob_size.
* @value_blob_size: See @entry_blob_size.
* @attribute_blob_size: See @entry_blob_size.
* @constant_blob_size: See @entry_blob_size.
* @error_domain_blob_size: See @entry_blob_size.
* @signature_blob_size: See @entry_blob_size.
* @enum_blob_size: See @entry_blob_size.
* @struct_blob_size: See @entry_blob_size.
* @object_blob_size: See @entry_blob_size.
* @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.
* @union_blob_size: See @entry_blob_size.
* @sections: Offset of section blob array
* @padding: TODO
*
* 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;
guint16 reserved;
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;
guint32 sections;
guint16 padding[6];
} Header;
/**
* SectionType:
* @GI_SECTION_END: TODO
* @GI_SECTION_DIRECTORY_INDEX: TODO
*
* TODO
*/
typedef enum {
GI_SECTION_END = 0,
GI_SECTION_DIRECTORY_INDEX = 1
} SectionType;
/**
* Section:
* @id: A #SectionType
* @offset: Integer offset for this section
*
* A section is a blob of data that's (at least theoretically) optional,
* and may or may not be present in the typelib. Presently, just used
* for the directory index. This allows a form of dynamic extensibility
* with different tradeoffs from the format minor version.
*/
typedef struct {
guint32 id;
guint32 offset;
} Section;
/**
* DirEntry:
* @blob_type: A #GTypelibBlobType
* @local: Whether this entry refers to a blob in this typelib.
* @reserved: Reserved for future use.
* @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;
guint16 reserved :15;
guint32 name;
guint32 offset;
} DirEntry;
/**
* SimpleTypeBlobFlags:
* @reserved: Reserved for future use.
* @reserved2: Reserved for future use.
* @pointer: TODO
* @reserved3: Reserved for future use.
* @tag: A #GITypeTag
*
* TODO
*/
typedef struct {
guint reserved : 8;
guint reserved2 :16;
guint pointer : 1;
guint reserved3 : 2;
guint tag : 5;
} SimpleTypeBlobFlags;
union _SimpleTypeBlob
{
SimpleTypeBlobFlags flags;
guint32 offset;
};
/**
* SimpleTypeBlob:
* @flags: TODO
* @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" are both zero, 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 _SimpleTypeBlob 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.
* @nullable: Only meaningful for types which are passed as pointers. For an
* in parameter, indicates if it is ok to pass NULL in. Gor an out
* parameter, indicates 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).
* @skip: Indicates that the parameter is only useful in C and should be skipped.
* @reserved: Reserved for future use.
* @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.
* @padding: TODO
* @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 nullable : 1;
guint optional : 1;
guint transfer_ownership : 1;
guint transfer_container_ownership : 1;
guint return_value : 1;
guint scope : 3;
guint skip : 1;
guint reserved :20;
gint8 closure;
gint8 destroy;
guint16 padding;
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.
* @skip_return: Indicates that the return value is only useful in C and should
* be skipped.
* @instance_transfer_ownership: When calling, the function assumes ownership of
* the instance parameter.
* @throws: Denotes the signature takes an additional #GError argument beyond
* the annotated arguments.
* @reserved: Reserved for future use.
* @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.
*
* TODO
*/
typedef struct {
SimpleTypeBlob return_type;
guint16 may_return_null : 1;
guint16 caller_owns_return_value : 1;
guint16 caller_owns_return_container : 1;
guint16 skip_return : 1;
guint16 instance_transfer_ownership : 1;
guint16 throws : 1;
guint16 reserved :10;
guint16 n_arguments;
ArgBlob arguments[];
} SignatureBlob;
/**
* CommonBlob:
* @blob_type: A #GTypelibBlobType
* @deprecated: Whether the blob is deprecated.
* @reserved: Reserved for future use.
* @name: The name of the blob.
*
* The #CommonBlob is shared between #FunctionBlob,
* #CallbackBlob, #SignalBlob.
*
* TODO
*/
typedef struct {
guint16 blob_type; /* 1 */
guint16 deprecated : 1;
guint16 reserved :15;
guint32 name;
} CommonBlob;
/**
* FunctionBlob:
* @blob_type: #BLOB_TYPE_FUNCTION
* @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.
* @throws: This is now additionally stored in the #SignatureBlob. (deprecated)
* @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.
* @name: TODO
* @symbol: The symbol which can be used to obtain the function pointer with
* dlsym().
* @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.
* @reserved: Reserved for future use.
* @reserved2: Reserved for future use.
*
* TODO
*/
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:
* @blob_type: TODO
* @deprecated: TODO
* @reserved: Reserved for future use.
* @name: TODO
* @signature: Offset of the #SignatureBlob describing the parameter types and
* the return value type.
*
* TODO
*/
typedef struct {
guint16 blob_type; /* 2 */
guint16 deprecated : 1;
guint16 reserved :15;
guint32 name;
guint32 signature;
} CallbackBlob;
/**
* InterfaceTypeBlob:
* @pointer: Whether this type represents an indirection
* @reserved: Reserved for future use.
* @tag: A #GITypeTag
* @reserved2: Reserved for future use.
* @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;
guint8 reserved :2;
guint8 tag :5;
guint8 reserved2;
guint16 interface;
} InterfaceTypeBlob;
/**
* ArrayTypeDimension:
* @length: TODO
* @size: TODO
*
* TODO
*/
typedef union {
guint16 length;
guint16 size;
} ArrayTypeDimension;
/**
* ArrayTypeBlob:
* @pointer: TODO
* @reserved: Reserved for future use.
* @tag: TODO
* @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.
* @reserved2: Reserved for future use.
* @dimensions: TODO
* @type: TODO
*
* TODO
*/
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;
ArrayTypeDimension dimensions;
SimpleTypeBlob type;
} ArrayTypeBlob;
/**
* ParamTypeBlob:
* @pointer: TODO
* @reserved: Reserved for future use.
* @tag: TODO
* @reserved2: Reserved for future use.
* @n_types: The number of parameter types to follow.
* @type: Describes the type of the list elements.
*
* TODO
*/
typedef struct {
guint8 pointer :1;
guint8 reserved :2;
guint8 tag :5;
guint8 reserved2;
guint16 n_types;
SimpleTypeBlob type[];
} ParamTypeBlob;
/**
* ErrorTypeBlob:
* @pointer: TODO
* @reserved: TODO
* @tag: TODO
* @reserved2: TODO
* @n_domains: TODO: must be 0
* @domains: TODO
*
* TODO
*/
typedef struct {
guint8 pointer :1;
guint8 reserved :2;
guint8 tag :5;
guint8 reserved2;
guint16 n_domains; /* Must be 0 */
guint16 domains[];
} ErrorTypeBlob;
/**
* ValueBlob:
* @deprecated: Whether this value is deprecated
* @unsigned_value: if set, value is a 32-bit unsigned integer cast to gint32
* @reserved: Reserved for future use.
* @name: Name of blob
* @value: The numerical value
*
* Values commonly occur in enums and flags.
*/
typedef struct {
guint32 deprecated : 1;
guint32 unsigned_value : 1;
guint32 reserved :30;
guint32 name;
gint32 value;
} ValueBlob;
/**
* FieldBlob:
* @name: The name of the field.
* @readable: TODO
* @writable: How the field may be accessed.
* @has_embedded_type: An anonymous type follows the FieldBlob.
* @reserved: Reserved for future use.
* @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.
* @reserved2: Reserved for future use.
* @type: The type of the field.
*
* TODO
*/
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:
* @blob_type: TODO
* @deprecated: TODO
* @unregistered: TODO
* @reserved: Reserved for future use.
* @name: TODO
* @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.
*
* TODO
*/
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.
* @is_gtype_struct: Whether this structure is the class or interface layout
* for a GObject
* @alignment: The byte boundary that the struct is aligned to in memory
* @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.
* @reserved: Reserved for future use.
* @name: TODO
* @gtype_name: String name of the associated #GType
* @gtype_init: String naming the symbol which gets the runtime #GType
* @size: The size of the struct in bytes.
* @n_fields: TODO
* @n_methods: TODO
* @copy_func: String pointing to a function which can be called to copy
* the contents of this struct type
* @free_func: String pointing to a function which can be called to free
* the contents of this struct type
*
* TODO
*/
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 copy_func;
guint32 free_func;
} StructBlob;
/**
* UnionBlob:
* @blob_type: TODO
* @deprecated: TODO
* @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
* @reserved: Reserved for future use.
* @name: TODO
* @gtype_name: String name of the associated #GType
* @gtype_init: String naming the symbol which gets the runtime #GType
* @size: TODO
* @n_fields: Length of the arrays
* @n_functions: TODO
* @copy_func: String pointing to a function which can be called to copy
* the contents of this union type
* @free_func: String pointing to a function which can be called to free
* the contents of this union type
* @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
*
* TODO
*/
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 copy_func;
guint32 free_func;
gint32 discriminator_offset;
SimpleTypeBlob discriminator_type;
} UnionBlob;
/**
* EnumBlob:
* @blob_type: TODO
* @deprecated: TODO
* @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)
* @reserved: Reserved for future use.
* @name: TODO
* @gtype_name: String name of the associated #GType
* @gtype_init: String naming the symbol which gets the runtime #GType
* @n_values: The length of the values array.
* @n_methods: The length of the methods array.
* @error_domain: String naming the #GError domain this enum is associated with
* @values: TODO
*
* TODO
*/
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 n_methods;
guint32 error_domain;
ValueBlob values[];
} EnumBlob;
#define ACCESSOR_SENTINEL 0x3ff
/**
* PropertyBlob:
* @name: The name of the property.
* @deprecated: TODO
* @readable: TODO
* @writable: TODO
* @construct: TODO
* @construct_only: The ParamFlags used when registering the property.
* @transfer_ownership: When writing, the type containing the property takes
* ownership of the value. When reading, the returned value needs to be
* released by the caller.
* @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 when reading lists of statically allocated
* things.
* @setter: the index of the setter function for this property, if @writable
* is set; if the method is not known, the value will be set to %ACCESSOR_SENTINEL
* @getter: ths index of the getter function for this property, if @readable
* is set; if the method is not known, the value will be set to %ACCESSOR_SENTINEL
* @reserved: Reserved for future use.
* @reserved2: Reserved for future use.
* @type: Describes the type of the property.
*
* TODO
*/
typedef struct {
guint32 name;
guint32 deprecated : 1;
guint32 readable : 1;
guint32 writable : 1;
guint32 construct : 1;
guint32 construct_only : 1;
guint32 transfer_ownership : 1;
guint32 transfer_container_ownership : 1;
guint32 setter :10;
guint32 getter :10;
guint32 reserved : 5;
guint32 reserved2;
SimpleTypeBlob type;
} PropertyBlob;
/**
* SignalBlob:
* @deprecated: TODO
* @run_first: TODO
* @run_last: TODO
* @run_cleanup: TODO
* @no_recurse: TODO
* @detailed: TODO
* @action: TODO
* @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
* @reserved: Reserved for future use.
* @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.
* @name: The name of the signal.
* @reserved2: Reserved for future use.
* @signature: Offset of the SignatureBlob describing the parameter types
* and the return value type.
*
* TODO
*/
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.
* @throws: This is now additionally stored in the #SignatureBlob. (deprecated)
* @reserved: Reserved for future use.
* @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.
* @reserved2: Reserved for future use.
* @reserved3: Reserved for future use.
* @signature: Offset of the SignatureBlob describing the parameter types and
* the return value type.
*
* TODO
*/
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 throws : 1;
guint16 reserved :11;
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
* @deprecated: whether the type is deprecated
* @abstract: whether the type can be instantiated
* @fundamental: this object is not a GObject derived type, instead it's
* an additional fundamental type.
* @final_: whether the type can be derived
* @reserved: Reserved for future use.
* @name: TODO
* @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.
* @gtype_struct: TODO
* @n_interfaces: TODO
* @n_fields: TODO
* @n_properties: TODO
* @n_methods: TODO
* @n_signals: TODO
* @n_vfuncs: TODO
* @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.
* @n_field_callbacks: The number of n_fields which are also callbacks.
* This is used to calculate the fields section size in constant time.
* @ref_func: String pointing to a function which can be called to increase
* the reference count for an instance of this object type.
* @unref_func: String pointing to a function which can be called to decrease
* the reference count for an instance of this object type.
* @set_value_func: String pointing to a function which can be called to
* convert a pointer of this object to a GValue
* @get_value_func: String pointing to a function which can be called to
* convert extract a pointer to this object from a GValue
* @reserved3: Reserved for future use.
* @reserved4: Reserved for future use.
* @interfaces: An array of indices of directory entries for the implemented
* interfaces.
*
* TODO
*/
typedef struct {
guint16 blob_type; /* 7 */
guint16 deprecated : 1;
guint16 abstract : 1;
guint16 fundamental : 1;
guint16 final_ : 1;
guint16 reserved :12;
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 n_field_callbacks;
guint32 ref_func;
guint32 unref_func;
guint32 set_value_func;
guint32 get_value_func;
guint32 reserved3;
guint32 reserved4;
guint16 interfaces[];
} ObjectBlob;
/**
* InterfaceBlob:
* @blob_type: TODO
* @deprecated: TODO
* @reserved: Reserved for future use.
* @name: TODO
* @gtype_name: TODO
* @gtype_init: TODO
* @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.
* @padding: TODO
* @reserved2: Reserved for future use.
* @reserved3: Reserved for future use.
* @prerequisites: An array of indices of directory entries for required
* interfaces.
*
* TODO
*/
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;
guint16 padding;
guint32 reserved2;
guint32 reserved3;
guint16 prerequisites[];
} InterfaceBlob;
/**
* ConstantBlob:
* @blob_type: TODO
* @deprecated: TODO
* @reserved: Reserved for future use.
* @name: TODO
* @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.
* @reserved2: Reserved for future use.
*
* TODO
*/
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)
*
* TODO
*/
typedef struct {
guint32 offset;
guint32 name;
guint32 value;
} AttributeBlob;
struct _GITypelib {
/*< private >*/
guchar *data;
gsize len;
gboolean owns_memory;
GMappedFile *mfile;
GList *modules;
gboolean open_attempted;
};
DirEntry *g_typelib_get_dir_entry (GITypelib *typelib,
guint16 index);
DirEntry *g_typelib_get_dir_entry_by_name (GITypelib *typelib,
const char *name);
DirEntry *g_typelib_get_dir_entry_by_gtype_name (GITypelib *typelib,
const gchar *gtype_name);
DirEntry *g_typelib_get_dir_entry_by_error_domain (GITypelib *typelib,
GQuark error_domain);
gboolean g_typelib_matches_gtype_name_prefix (GITypelib *typelib,
const gchar *gtype_name);
GI_AVAILABLE_IN_ALL
void g_typelib_check_sanity (void);
/**
* g_typelib_get_string:
* @typelib: TODO
* @offset: TODO
*
* TODO
*
* Returns: TODO
*/
#define g_typelib_get_string(typelib,offset) ((const gchar*)&(typelib->data)[(offset)])
/**
* GITypelibError:
* @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 #GITypelib
*/
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
} GITypelibError;
/**
* G_TYPELIB_ERROR:
*
* TODO
*/
#define G_TYPELIB_ERROR (g_typelib_error_quark ())
GQuark g_typelib_error_quark (void);
GI_AVAILABLE_IN_ALL
gboolean g_typelib_validate (GITypelib *typelib,
GError **error);
/* defined in gibaseinfo.c */
AttributeBlob *_attribute_blob_find_first (GIBaseInfo *info,
guint32 blob_offset);
/**
* GITypelibHashBuilder:
*
* TODO
*/
typedef struct _GITypelibHashBuilder GITypelibHashBuilder;
GITypelibHashBuilder * _gi_typelib_hash_builder_new (void);
void _gi_typelib_hash_builder_add_string (GITypelibHashBuilder *builder, const char *str, guint16 value);
gboolean _gi_typelib_hash_builder_prepare (GITypelibHashBuilder *builder);
guint32 _gi_typelib_hash_builder_get_buffer_size (GITypelibHashBuilder *builder);
void _gi_typelib_hash_builder_pack (GITypelibHashBuilder *builder, guint8* mem, guint32 size);
void _gi_typelib_hash_builder_destroy (GITypelibHashBuilder *builder);
guint16 _gi_typelib_hash_search (guint8* memory, const char *str, guint n_entries);
G_END_DECLS
#endif /* __G_TYPELIB_H__ */
Reference in New Issue View Git Blame Copy Permalink