luc14n0/glib
1
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/glib.git synced 2025-04-13 11:13:07 +02:00
Code Issues Packages Projects Releases Wiki Activity
glib/docs/reference/glib/glib-decl.txt
Owen Taylor 9231462089 Initial revision
1999-08-16 17:58:30 +00:00

4545 lines
102 KiB
Plaintext
Raw Blame History

<MACRO>
<NAME>G_DIR_SEPARATOR</NAME>
#define G_DIR_SEPARATOR '\\'
</MACRO>
<MACRO>
<NAME>G_DIR_SEPARATOR_S</NAME>
#define G_DIR_SEPARATOR_S "\\"
</MACRO>
<MACRO>
<NAME>G_SEARCHPATH_SEPARATOR</NAME>
#define G_SEARCHPATH_SEPARATOR ';'
</MACRO>
<MACRO>
<NAME>G_SEARCHPATH_SEPARATOR_S</NAME>
#define G_SEARCHPATH_SEPARATOR_S ";"
</MACRO>
<MACRO>
<NAME>G_DIR_SEPARATOR</NAME>
#define G_DIR_SEPARATOR '/'
</MACRO>
<MACRO>
<NAME>G_DIR_SEPARATOR_S</NAME>
#define G_DIR_SEPARATOR_S "/"
</MACRO>
<MACRO>
<NAME>G_SEARCHPATH_SEPARATOR</NAME>
#define G_SEARCHPATH_SEPARATOR ':'
</MACRO>
<MACRO>
<NAME>G_SEARCHPATH_SEPARATOR_S</NAME>
#define G_SEARCHPATH_SEPARATOR_S ":"
</MACRO>
<MACRO>
<NAME>NULL</NAME>
#define NULL ((void*) 0)
</MACRO>
<MACRO>
<NAME>FALSE</NAME>
#define FALSE (0)
</MACRO>
<MACRO>
<NAME>TRUE</NAME>
#define TRUE (!FALSE)
</MACRO>
<MACRO>
<NAME>MAX</NAME>
#define MAX(a, b) (((a) > (b)) ? (a) : (b))
</MACRO>
<MACRO>
<NAME>MIN</NAME>
#define MIN(a, b) (((a) < (b)) ? (a) : (b))
</MACRO>
<MACRO>
<NAME>ABS</NAME>
#define ABS(a) (((a) < 0) ? -(a) : (a))
</MACRO>
<MACRO>
<NAME>CLAMP</NAME>
#define CLAMP(x, low, high) (((x) > (high)) ? (high) : (((x) < (low)) ? (low) : (x)))
</MACRO>
<MACRO>
<NAME>G_VA_COPY</NAME>
# define G_VA_COPY(ap1, ap2) (*(ap1) = *(ap2))
</MACRO>
<MACRO>
<NAME>G_VA_COPY</NAME>
# define G_VA_COPY(ap1, ap2) g_memmove ((ap1), (ap2), sizeof (va_list))
</MACRO>
<MACRO>
<NAME>G_VA_COPY</NAME>
# define G_VA_COPY(ap1, ap2) ((ap1) = (ap2))
</MACRO>
<MACRO>
<NAME>G_STRUCT_OFFSET</NAME>
#define G_STRUCT_OFFSET(struct_type, member) \
((gulong) ((gchar*) &((struct_type*) 0)->member))
</MACRO>
<MACRO>
<NAME>G_STRUCT_MEMBER_P</NAME>
#define G_STRUCT_MEMBER_P(struct_p, struct_offset) \
((gpointer) ((gchar*) (struct_p) + (gulong) (struct_offset)))
</MACRO>
<MACRO>
<NAME>G_STRUCT_MEMBER</NAME>
#define G_STRUCT_MEMBER(member_type, struct_p, struct_offset) \
(*(member_type*) G_STRUCT_MEMBER_P ((struct_p), (struct_offset)))
</MACRO>
<MACRO>
<NAME>G_CAN_INLINE</NAME>
# define G_CAN_INLINE 1
</MACRO>
<MACRO>
<NAME>inline</NAME>
# define inline __inline__
</MACRO>
<MACRO>
<NAME>inline</NAME>
# define inline __inline__
</MACRO>
<MACRO>
<NAME>inline</NAME>
# define inline __inline
</MACRO>
<MACRO>
<NAME>inline</NAME>
# define inline /* don't inline, then */
</MACRO>
<MACRO>
<NAME>G_INLINE_FUNC</NAME>
# define G_INLINE_FUNC extern inline
</MACRO>
<MACRO>
<NAME>G_INLINE_FUNC</NAME>
# define G_INLINE_FUNC extern
</MACRO>
<MACRO>
<NAME>G_INLINE_FUNC</NAME>
# define G_INLINE_FUNC static inline
</MACRO>
<MACRO>
<NAME>G_INLINE_FUNC</NAME>
# define G_INLINE_FUNC extern
</MACRO>
<MACRO>
<NAME>G_STMT_START</NAME>
# define G_STMT_START (void)(
</MACRO>
<MACRO>
<NAME>G_STMT_END</NAME>
# define G_STMT_END )
</MACRO>
<MACRO>
<NAME>G_STMT_START</NAME>
# define G_STMT_START if (1)
</MACRO>
<MACRO>
<NAME>G_STMT_END</NAME>
# define G_STMT_END else (void)0
</MACRO>
<MACRO>
<NAME>G_STMT_START</NAME>
# define G_STMT_START do
</MACRO>
<MACRO>
<NAME>G_STMT_END</NAME>
# define G_STMT_END while (0)
</MACRO>
<MACRO>
<NAME>G_GNUC_PRINTF</NAME>
#define G_GNUC_PRINTF( format_idx, arg_idx ) \
__attribute__((format (printf, format_idx, arg_idx)))
</MACRO>
<MACRO>
<NAME>G_GNUC_SCANF</NAME>
#define G_GNUC_SCANF( format_idx, arg_idx ) \
__attribute__((format (scanf, format_idx, arg_idx)))
</MACRO>
<MACRO>
<NAME>G_GNUC_FORMAT</NAME>
#define G_GNUC_FORMAT( arg_idx ) \
__attribute__((format_arg (arg_idx)))
</MACRO>
<MACRO>
<NAME>G_GNUC_NORETURN</NAME>
#define G_GNUC_NORETURN \
__attribute__((noreturn))
</MACRO>
<MACRO>
<NAME>G_GNUC_CONST</NAME>
#define G_GNUC_CONST \
__attribute__((const))
</MACRO>
<MACRO>
<NAME>G_GNUC_UNUSED</NAME>
#define G_GNUC_UNUSED \
__attribute__((unused))
</MACRO>
<MACRO>
<NAME>G_GNUC_PRINTF</NAME>
#define G_GNUC_PRINTF( format_idx, arg_idx )
</MACRO>
<MACRO>
<NAME>G_GNUC_SCANF</NAME>
#define G_GNUC_SCANF( format_idx, arg_idx )
</MACRO>
<MACRO>
<NAME>G_GNUC_FORMAT</NAME>
#define G_GNUC_FORMAT( arg_idx )
</MACRO>
<MACRO>
<NAME>G_GNUC_NORETURN</NAME>
#define G_GNUC_NORETURN
</MACRO>
<MACRO>
<NAME>G_GNUC_CONST</NAME>
#define G_GNUC_CONST
</MACRO>
<MACRO>
<NAME>G_GNUC_UNUSED</NAME>
#define G_GNUC_UNUSED
</MACRO>
<MACRO>
<NAME>G_GNUC_FUNCTION</NAME>
#define G_GNUC_FUNCTION __FUNCTION__
</MACRO>
<MACRO>
<NAME>G_GNUC_PRETTY_FUNCTION</NAME>
#define G_GNUC_PRETTY_FUNCTION __PRETTY_FUNCTION__
</MACRO>
<MACRO>
<NAME>G_GNUC_FUNCTION</NAME>
#define G_GNUC_FUNCTION ""
</MACRO>
<MACRO>
<NAME>G_GNUC_PRETTY_FUNCTION</NAME>
#define G_GNUC_PRETTY_FUNCTION ""
</MACRO>
<MACRO>
<NAME>ATEXIT</NAME>
# define ATEXIT(proc) g_ATEXIT(proc)
</MACRO>
<MACRO>
<NAME>G_NATIVE_ATEXIT</NAME>
# define G_NATIVE_ATEXIT
</MACRO>
<MACRO>
<NAME>G_BREAKPOINT</NAME>
#define G_BREAKPOINT() G_STMT_START{ __asm__ __volatile__ ("int $03"); }G_STMT_END
</MACRO>
<MACRO>
<NAME>G_BREAKPOINT</NAME>
#define G_BREAKPOINT() G_STMT_START{ __asm__ __volatile__ ("bpt"); }G_STMT_END
</MACRO>
<MACRO>
<NAME>G_BREAKPOINT</NAME>
#define G_BREAKPOINT()
</MACRO>
<MACRO>
<NAME>g_new</NAME>
# define g_new(type, count) (ALLOC (type, count))
</MACRO>
<MACRO>
<NAME>g_new0</NAME>
# define g_new0(type, count) (CALLOC (type, count))
</MACRO>
<MACRO>
<NAME>g_renew</NAME>
# define g_renew(type, mem, count) (REALLOC (mem, type, count))
</MACRO>
<MACRO>
<NAME>g_new</NAME>
# define g_new(type, count) \
((type *) g_malloc ((unsigned) sizeof (type) * (count)))
</MACRO>
<MACRO>
<NAME>g_new0</NAME>
# define g_new0(type, count) \
((type *) g_malloc0 ((unsigned) sizeof (type) * (count)))
</MACRO>
<MACRO>
<NAME>g_renew</NAME>
# define g_renew(type, mem, count) \
((type *) g_realloc (mem, (unsigned) sizeof (type) * (count)))
</MACRO>
<MACRO>
<NAME>g_mem_chunk_create</NAME>
#define g_mem_chunk_create(type, pre_alloc, alloc_type) ( \
g_mem_chunk_new (#type " mem chunks (" #pre_alloc ")", \
sizeof (type), \
sizeof (type) * (pre_alloc), \
(alloc_type)) \
)
</MACRO>
<MACRO>
<NAME>g_chunk_new</NAME>
#define g_chunk_new(type, chunk) ( \
(type *) g_mem_chunk_alloc (chunk) \
)
</MACRO>
<MACRO>
<NAME>g_chunk_new0</NAME>
#define g_chunk_new0(type, chunk) ( \
(type *) g_mem_chunk_alloc0 (chunk) \
)
</MACRO>
<MACRO>
<NAME>g_chunk_free</NAME>
#define g_chunk_free(mem, mem_chunk) G_STMT_START { \
g_mem_chunk_free ((mem_chunk), (mem)); \
} G_STMT_END
</MACRO>
<MACRO>
<NAME>g_string</NAME>
#define g_string(x) #x
</MACRO>
<MACRO>
<NAME>g_assert</NAME>
#define g_assert(expr)
</MACRO>
<MACRO>
<NAME>g_assert_not_reached</NAME>
#define g_assert_not_reached()
</MACRO>
<MACRO>
<NAME>g_assert</NAME>
#define g_assert(expr) G_STMT_START{ \
if (!(expr)) \
g_log (G_LOG_DOMAIN, \
G_LOG_LEVEL_ERROR, \
"file %s: line %d (%s): assertion failed: (%s)", \
__FILE__, \
__LINE__, \
__PRETTY_FUNCTION__, \
#expr); }G_STMT_END
</MACRO>
<MACRO>
<NAME>g_assert_not_reached</NAME>
#define g_assert_not_reached() G_STMT_START{ \
g_log (G_LOG_DOMAIN, \
G_LOG_LEVEL_ERROR, \
"file %s: line %d (%s): should not be reached", \
__FILE__, \
__LINE__, \
__PRETTY_FUNCTION__); }G_STMT_END
</MACRO>
<MACRO>
<NAME>g_assert</NAME>
#define g_assert(expr) G_STMT_START{ \
if (!(expr)) \
g_log (G_LOG_DOMAIN, \
G_LOG_LEVEL_ERROR, \
"file %s: line %d: assertion failed: (%s)", \
__FILE__, \
__LINE__, \
#expr); }G_STMT_END
</MACRO>
<MACRO>
<NAME>g_assert_not_reached</NAME>
#define g_assert_not_reached() G_STMT_START{ \
g_log (G_LOG_DOMAIN, \
G_LOG_LEVEL_ERROR, \
"file %s: line %d: should not be reached", \
__FILE__, \
__LINE__); }G_STMT_END
</MACRO>
<MACRO>
<NAME>g_return_if_fail</NAME>
#define g_return_if_fail(expr)
</MACRO>
<MACRO>
<NAME>g_return_val_if_fail</NAME>
#define g_return_val_if_fail(expr,val)
</MACRO>
<MACRO>
<NAME>g_return_if_fail</NAME>
#define g_return_if_fail(expr) G_STMT_START{ \
if (!(expr)) \
{ \
g_log (G_LOG_DOMAIN, \
G_LOG_LEVEL_CRITICAL, \
"file %s: line %d (%s): assertion `%s' failed.", \
__FILE__, \
__LINE__, \
__PRETTY_FUNCTION__, \
#expr); \
return; \
}; }G_STMT_END
</MACRO>
<MACRO>
<NAME>g_return_val_if_fail</NAME>
#define g_return_val_if_fail(expr,val) G_STMT_START{ \
if (!(expr)) \
{ \
g_log (G_LOG_DOMAIN, \
G_LOG_LEVEL_CRITICAL, \
"file %s: line %d (%s): assertion `%s' failed.", \
__FILE__, \
__LINE__, \
__PRETTY_FUNCTION__, \
#expr); \
return val; \
}; }G_STMT_END
</MACRO>
<MACRO>
<NAME>g_return_if_fail</NAME>
#define g_return_if_fail(expr) G_STMT_START{ \
if (!(expr)) \
{ \
g_log (G_LOG_DOMAIN, \
G_LOG_LEVEL_CRITICAL, \
"file %s: line %d: assertion `%s' failed.", \
__FILE__, \
__LINE__, \
#expr); \
return; \
}; }G_STMT_END
</MACRO>
<MACRO>
<NAME>g_return_val_if_fail</NAME>
#define g_return_val_if_fail(expr, val) G_STMT_START{ \
if (!(expr)) \
{ \
g_log (G_LOG_DOMAIN, \
G_LOG_LEVEL_CRITICAL, \
"file %s: line %d: assertion `%s' failed.", \
__FILE__, \
__LINE__, \
#expr); \
return val; \
}; }G_STMT_END
</MACRO>
<TYPEDEF>
<NAME>gchar</NAME>
typedef char gchar;
</TYPEDEF>
<TYPEDEF>
<NAME>gshort</NAME>
typedef short gshort;
</TYPEDEF>
<TYPEDEF>
<NAME>glong</NAME>
typedef long glong;
</TYPEDEF>
<TYPEDEF>
<NAME>gint</NAME>
typedef int gint;
</TYPEDEF>
<TYPEDEF>
<NAME>gboolean</NAME>
typedef gint gboolean;
</TYPEDEF>
<TYPEDEF>
<NAME>guchar</NAME>
typedef unsigned char guchar;
</TYPEDEF>
<TYPEDEF>
<NAME>gushort</NAME>
typedef unsigned short gushort;
</TYPEDEF>
<TYPEDEF>
<NAME>gulong</NAME>
typedef unsigned long gulong;
</TYPEDEF>
<TYPEDEF>
<NAME>guint</NAME>
typedef unsigned int guint;
</TYPEDEF>
<TYPEDEF>
<NAME>gfloat</NAME>
typedef float gfloat;
</TYPEDEF>
<TYPEDEF>
<NAME>gdouble</NAME>
typedef double gdouble;
</TYPEDEF>
<TYPEDEF>
<NAME>gldouble</NAME>
typedef long double gldouble;
</TYPEDEF>
<TYPEDEF>
<NAME>gldouble</NAME>
typedef double gldouble;
</TYPEDEF>
<TYPEDEF>
<NAME>gpointer</NAME>
typedef void* gpointer;
</TYPEDEF>
<TYPEDEF>
<NAME>gconstpointer</NAME>
typedef const void *gconstpointer;
</TYPEDEF>
<TYPEDEF>
<NAME>gssize</NAME>
typedef gint32 gssize;
</TYPEDEF>
<TYPEDEF>
<NAME>gsize</NAME>
typedef guint32 gsize;
</TYPEDEF>
<TYPEDEF>
<NAME>GQuark</NAME>
typedef guint32 GQuark;
</TYPEDEF>
<TYPEDEF>
<NAME>GTime</NAME>
typedef gint32 GTime;
</TYPEDEF>
<MACRO>
<NAME>G_LITTLE_ENDIAN</NAME>
#define G_LITTLE_ENDIAN 1234
</MACRO>
<MACRO>
<NAME>G_BIG_ENDIAN</NAME>
#define G_BIG_ENDIAN 4321
</MACRO>
<MACRO>
<NAME>G_PDP_ENDIAN</NAME>
#define G_PDP_ENDIAN 3412 /* unused, need specific PDP check */
</MACRO>
<MACRO>
<NAME>GUINT16_SWAP_LE_BE_CONSTANT</NAME>
#define GUINT16_SWAP_LE_BE_CONSTANT(val) ((guint16) ( \
(((guint16) (val) & (guint16) 0x00ffU) << 8) | \
(((guint16) (val) & (guint16) 0xff00U) >> 8)))
</MACRO>
<MACRO>
<NAME>GUINT32_SWAP_LE_BE_CONSTANT</NAME>
#define GUINT32_SWAP_LE_BE_CONSTANT(val) ((guint32) ( \
(((guint32) (val) & (guint32) 0x000000ffU) << 24) | \
(((guint32) (val) & (guint32) 0x0000ff00U) << 8) | \
(((guint32) (val) & (guint32) 0x00ff0000U) >> 8) | \
(((guint32) (val) & (guint32) 0xff000000U) >> 24)))
</MACRO>
<MACRO>
<NAME>GUINT16_SWAP_LE_BE_X86</NAME>
# define GUINT16_SWAP_LE_BE_X86(val) \
(__extension__ \
({ register guint16 __v; \
if (__builtin_constant_p (val)) \
__v = GUINT16_SWAP_LE_BE_CONSTANT (val); \
else \
__asm__ __const__ ("rorw $8, %w0" \
: "=r" (__v) \
: "0" ((guint16) (val))); \
__v; }))
</MACRO>
<MACRO>
<NAME>GUINT16_SWAP_LE_BE</NAME>
# define GUINT16_SWAP_LE_BE(val) (GUINT16_SWAP_LE_BE_X86 (val))
</MACRO>
<MACRO>
<NAME>GUINT32_SWAP_LE_BE_X86</NAME>
# define GUINT32_SWAP_LE_BE_X86(val) \
(__extension__ \
({ register guint32 __v; \
if (__builtin_constant_p (val)) \
__v = GUINT32_SWAP_LE_BE_CONSTANT (val); \
else \
__asm__ __const__ ("rorw $8, %w0\n\t" \
"rorl $16, %0\n\t" \
"rorw $8, %w0" \
: "=r" (__v) \
: "0" ((guint32) (val))); \
__v; }))
</MACRO>
<MACRO>
<NAME>GUINT32_SWAP_LE_BE_X86</NAME>
# define GUINT32_SWAP_LE_BE_X86(val) \
(__extension__ \
({ register guint32 __v; \
if (__builtin_constant_p (val)) \
__v = GUINT32_SWAP_LE_BE_CONSTANT (val); \
else \
__asm__ __const__ ("bswap %0" \
: "=r" (__v) \
: "0" ((guint32) (val))); \
__v; }))
</MACRO>
<MACRO>
<NAME>GUINT32_SWAP_LE_BE</NAME>
# define GUINT32_SWAP_LE_BE(val) (GUINT32_SWAP_LE_BE_X86 (val))
</MACRO>
<MACRO>
<NAME>GUINT16_SWAP_LE_BE</NAME>
# define GUINT16_SWAP_LE_BE(val) (GUINT16_SWAP_LE_BE_CONSTANT (val))
</MACRO>
<MACRO>
<NAME>GUINT32_SWAP_LE_BE</NAME>
# define GUINT32_SWAP_LE_BE(val) (GUINT32_SWAP_LE_BE_CONSTANT (val))
</MACRO>
<MACRO>
<NAME>GUINT64_SWAP_LE_BE_CONSTANT</NAME>
# define GUINT64_SWAP_LE_BE_CONSTANT(val) ((guint64) ( \
(((guint64) (val) & \
(guint64) G_GINT64_CONSTANT(0x00000000000000ffU)) << 56) | \
(((guint64) (val) & \
(guint64) G_GINT64_CONSTANT(0x000000000000ff00U)) << 40) | \
(((guint64) (val) & \
(guint64) G_GINT64_CONSTANT(0x0000000000ff0000U)) << 24) | \
(((guint64) (val) & \
(guint64) G_GINT64_CONSTANT(0x00000000ff000000U)) << 8) | \
(((guint64) (val) & \
(guint64) G_GINT64_CONSTANT(0x000000ff00000000U)) >> 8) | \
(((guint64) (val) & \
(guint64) G_GINT64_CONSTANT(0x0000ff0000000000U)) >> 24) | \
(((guint64) (val) & \
(guint64) G_GINT64_CONSTANT(0x00ff000000000000U)) >> 40) | \
(((guint64) (val) & \
(guint64) G_GINT64_CONSTANT(0xff00000000000000U)) >> 56)))
</MACRO>
<MACRO>
<NAME>GUINT64_SWAP_LE_BE_X86</NAME>
# define GUINT64_SWAP_LE_BE_X86(val) \
(__extension__ \
({ union { guint64 __ll; \
guint32 __l[2]; } __r; \
if (__builtin_constant_p (val)) \
__r.__ll = GUINT64_SWAP_LE_BE_CONSTANT (val); \
else \
{ \
union { guint64 __ll; \
guint32 __l[2]; } __w; \
__w.__ll = ((guint64) val); \
__r.__l[0] = GUINT32_SWAP_LE_BE (__w.__l[1]); \
__r.__l[1] = GUINT32_SWAP_LE_BE (__w.__l[0]); \
} \
__r.__ll; }))
</MACRO>
<MACRO>
<NAME>GUINT64_SWAP_LE_BE</NAME>
# define GUINT64_SWAP_LE_BE(val) (GUINT64_SWAP_LE_BE_X86 (val))
</MACRO>
<MACRO>
<NAME>GUINT64_SWAP_LE_BE</NAME>
# define GUINT64_SWAP_LE_BE(val) (GUINT64_SWAP_LE_BE_CONSTANT(val))
</MACRO>
<MACRO>
<NAME>GUINT16_SWAP_LE_PDP</NAME>
#define GUINT16_SWAP_LE_PDP(val) ((guint16) (val))
</MACRO>
<MACRO>
<NAME>GUINT16_SWAP_BE_PDP</NAME>
#define GUINT16_SWAP_BE_PDP(val) (GUINT16_SWAP_LE_BE (val))
</MACRO>
<MACRO>
<NAME>GUINT32_SWAP_LE_PDP</NAME>
#define GUINT32_SWAP_LE_PDP(val) ((guint32) ( \
(((guint32) (val) & (guint32) 0x0000ffffU) << 16) | \
(((guint32) (val) & (guint32) 0xffff0000U) >> 16)))
</MACRO>
<MACRO>
<NAME>GUINT32_SWAP_BE_PDP</NAME>
#define GUINT32_SWAP_BE_PDP(val) ((guint32) ( \
(((guint32) (val) & (guint32) 0x00ff00ffU) << 8) | \
(((guint32) (val) & (guint32) 0xff00ff00U) >> 8)))
</MACRO>
<MACRO>
<NAME>GINT16_FROM_LE</NAME>
#define GINT16_FROM_LE(val) (GINT16_TO_LE (val))
</MACRO>
<MACRO>
<NAME>GUINT16_FROM_LE</NAME>
#define GUINT16_FROM_LE(val) (GUINT16_TO_LE (val))
</MACRO>
<MACRO>
<NAME>GINT16_FROM_BE</NAME>
#define GINT16_FROM_BE(val) (GINT16_TO_BE (val))
</MACRO>
<MACRO>
<NAME>GUINT16_FROM_BE</NAME>
#define GUINT16_FROM_BE(val) (GUINT16_TO_BE (val))
</MACRO>
<MACRO>
<NAME>GINT32_FROM_LE</NAME>
#define GINT32_FROM_LE(val) (GINT32_TO_LE (val))
</MACRO>
<MACRO>
<NAME>GUINT32_FROM_LE</NAME>
#define GUINT32_FROM_LE(val) (GUINT32_TO_LE (val))
</MACRO>
<MACRO>
<NAME>GINT32_FROM_BE</NAME>
#define GINT32_FROM_BE(val) (GINT32_TO_BE (val))
</MACRO>
<MACRO>
<NAME>GUINT32_FROM_BE</NAME>
#define GUINT32_FROM_BE(val) (GUINT32_TO_BE (val))
</MACRO>
<MACRO>
<NAME>GINT64_FROM_LE</NAME>
#define GINT64_FROM_LE(val) (GINT64_TO_LE (val))
</MACRO>
<MACRO>
<NAME>GUINT64_FROM_LE</NAME>
#define GUINT64_FROM_LE(val) (GUINT64_TO_LE (val))
</MACRO>
<MACRO>
<NAME>GINT64_FROM_BE</NAME>
#define GINT64_FROM_BE(val) (GINT64_TO_BE (val))
</MACRO>
<MACRO>
<NAME>GUINT64_FROM_BE</NAME>
#define GUINT64_FROM_BE(val) (GUINT64_TO_BE (val))
</MACRO>
<MACRO>
<NAME>GLONG_FROM_LE</NAME>
#define GLONG_FROM_LE(val) (GLONG_TO_LE (val))
</MACRO>
<MACRO>
<NAME>GULONG_FROM_LE</NAME>
#define GULONG_FROM_LE(val) (GULONG_TO_LE (val))
</MACRO>
<MACRO>
<NAME>GLONG_FROM_BE</NAME>
#define GLONG_FROM_BE(val) (GLONG_TO_BE (val))
</MACRO>
<MACRO>
<NAME>GULONG_FROM_BE</NAME>
#define GULONG_FROM_BE(val) (GULONG_TO_BE (val))
</MACRO>
<MACRO>
<NAME>GINT_FROM_LE</NAME>
#define GINT_FROM_LE(val) (GINT_TO_LE (val))
</MACRO>
<MACRO>
<NAME>GUINT_FROM_LE</NAME>
#define GUINT_FROM_LE(val) (GUINT_TO_LE (val))
</MACRO>
<MACRO>
<NAME>GINT_FROM_BE</NAME>
#define GINT_FROM_BE(val) (GINT_TO_BE (val))
</MACRO>
<MACRO>
<NAME>GUINT_FROM_BE</NAME>
#define GUINT_FROM_BE(val) (GUINT_TO_BE (val))
</MACRO>
<MACRO>
<NAME>g_ntohl</NAME>
#define g_ntohl(val) (GUINT32_FROM_BE (val))
</MACRO>
<MACRO>
<NAME>g_ntohs</NAME>
#define g_ntohs(val) (GUINT16_FROM_BE (val))
</MACRO>
<MACRO>
<NAME>g_htonl</NAME>
#define g_htonl(val) (GUINT32_TO_BE (val))
</MACRO>
<MACRO>
<NAME>g_htons</NAME>
#define g_htons(val) (GUINT16_TO_BE (val))
</MACRO>
<MACRO>
<NAME>GUTILS_C_VAR</NAME>
# define GUTILS_C_VAR __declspec(dllexport)
</MACRO>
<MACRO>
<NAME>GUTILS_C_VAR</NAME>
# define GUTILS_C_VAR extern __declspec(dllimport)
</MACRO>
<MACRO>
<NAME>GUTILS_C_VAR</NAME>
# define GUTILS_C_VAR extern
</MACRO>
<MACRO>
<NAME>GLIB_CHECK_VERSION</NAME>
#define GLIB_CHECK_VERSION(major,minor,micro) \
(GLIB_MAJOR_VERSION > (major) || \
(GLIB_MAJOR_VERSION == (major) && GLIB_MINOR_VERSION > (minor)) || \
(GLIB_MAJOR_VERSION == (major) && GLIB_MINOR_VERSION == (minor) && \
GLIB_MICRO_VERSION >= (micro)))
</MACRO>
<STRUCT>
<NAME>GAllocator</NAME>
</STRUCT>
<STRUCT>
<NAME>GArray</NAME>
</STRUCT>
<STRUCT>
<NAME>GByteArray</NAME>
</STRUCT>
<STRUCT>
<NAME>GCache</NAME>
</STRUCT>
<STRUCT>
<NAME>GCompletion</NAME>
</STRUCT>
<STRUCT>
<NAME>GData</NAME>
</STRUCT>
<STRUCT>
<NAME>GDebugKey</NAME>
</STRUCT>
<STRUCT>
<NAME>GHashTable</NAME>
</STRUCT>
<STRUCT>
<NAME>GHook</NAME>
</STRUCT>
<STRUCT>
<NAME>GHookList</NAME>
</STRUCT>
<STRUCT>
<NAME>GList</NAME>
</STRUCT>
<STRUCT>
<NAME>GMemChunk</NAME>
</STRUCT>
<STRUCT>
<NAME>GNode</NAME>
</STRUCT>
<STRUCT>
<NAME>GPtrArray</NAME>
</STRUCT>
<STRUCT>
<NAME>GRelation</NAME>
</STRUCT>
<STRUCT>
<NAME>GScanner</NAME>
</STRUCT>
<STRUCT>
<NAME>GScannerConfig</NAME>
</STRUCT>
<STRUCT>
<NAME>GSList</NAME>
</STRUCT>
<STRUCT>
<NAME>GString</NAME>
</STRUCT>
<STRUCT>
<NAME>GStringChunk</NAME>
</STRUCT>
<STRUCT>
<NAME>GTimer</NAME>
</STRUCT>
<STRUCT>
<NAME>GTree</NAME>
</STRUCT>
<STRUCT>
<NAME>GTuples</NAME>
</STRUCT>
<STRUCT>
<NAME>GIOChannel</NAME>
</STRUCT>
<ENUM>
<NAME>GTraverseFlags</NAME>
typedef enum
{
G_TRAVERSE_LEAFS = 1 << 0,
G_TRAVERSE_NON_LEAFS = 1 << 1,
G_TRAVERSE_ALL = G_TRAVERSE_LEAFS | G_TRAVERSE_NON_LEAFS,
G_TRAVERSE_MASK = 0x03
} GTraverseFlags;
</ENUM>
<ENUM>
<NAME>GTraverseType</NAME>
typedef enum
{
G_IN_ORDER,
G_PRE_ORDER,
G_POST_ORDER,
G_LEVEL_ORDER
} GTraverseType;
</ENUM>
<MACRO>
<NAME>G_LOG_LEVEL_USER_SHIFT</NAME>
#define G_LOG_LEVEL_USER_SHIFT (8)
</MACRO>
<ENUM>
<NAME>GLogLevelFlags</NAME>
typedef enum
{
/* log flags */
G_LOG_FLAG_RECURSION = 1 << 0,
G_LOG_FLAG_FATAL = 1 << 1,
/* GLib log levels */
G_LOG_LEVEL_ERROR = 1 << 2, /* always fatal */
G_LOG_LEVEL_CRITICAL = 1 << 3,
G_LOG_LEVEL_WARNING = 1 << 4,
G_LOG_LEVEL_MESSAGE = 1 << 5,
G_LOG_LEVEL_INFO = 1 << 6,
G_LOG_LEVEL_DEBUG = 1 << 7,
G_LOG_LEVEL_MASK = ~(G_LOG_FLAG_RECURSION | G_LOG_FLAG_FATAL)
} GLogLevelFlags;
</ENUM>
<MACRO>
<NAME>G_LOG_FATAL_MASK</NAME>
#define G_LOG_FATAL_MASK (G_LOG_FLAG_RECURSION | G_LOG_LEVEL_ERROR)
</MACRO>
<USER_FUNCTION>
<NAME>GCacheNewFunc</NAME>
<RETURNS>gpointer </RETURNS>
gpointer key
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GCacheDupFunc</NAME>
<RETURNS>gpointer </RETURNS>
gpointer value
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GCacheDestroyFunc</NAME>
<RETURNS>void </RETURNS>
gpointer value
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GCompareFunc</NAME>
<RETURNS>gint </RETURNS>
gconstpointer a,
gconstpointer b
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GCompletionFunc</NAME>
<RETURNS>gchar *</RETURNS>
gpointer
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GDestroyNotify</NAME>
<RETURNS>void </RETURNS>
gpointer data
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GDataForeachFunc</NAME>
<RETURNS>void </RETURNS>
GQuark key_id,
gpointer data,
gpointer user_data
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GFunc</NAME>
<RETURNS>void </RETURNS>
gpointer data,
gpointer user_data
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GHashFunc</NAME>
<RETURNS>guint </RETURNS>
gconstpointer key
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GFreeFunc</NAME>
<RETURNS>void </RETURNS>
gpointer data
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GHFunc</NAME>
<RETURNS>void </RETURNS>
gpointer key,
gpointer value,
gpointer user_data
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GHRFunc</NAME>
<RETURNS>gboolean </RETURNS>
gpointer key,
gpointer value,
gpointer user_data
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GHookCompareFunc</NAME>
<RETURNS>gint </RETURNS>
GHook *new_hook,
GHook *sibling
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GHookFindFunc</NAME>
<RETURNS>gboolean </RETURNS>
GHook *hook,
gpointer data
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GHookMarshaller</NAME>
<RETURNS>void </RETURNS>
GHook *hook,
gpointer data
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GHookCheckMarshaller</NAME>
<RETURNS>gboolean </RETURNS>
GHook *hook,
gpointer data
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GHookFunc</NAME>
<RETURNS>void </RETURNS>
gpointer data
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GHookCheckFunc</NAME>
<RETURNS>gboolean </RETURNS>
gpointer data
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GHookFreeFunc</NAME>
<RETURNS>void </RETURNS>
GHookList *hook_list,
GHook *hook
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GLogFunc</NAME>
<RETURNS>void </RETURNS>
const gchar *log_domain,
GLogLevelFlags log_level,
const gchar *message,
gpointer user_data
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GNodeTraverseFunc</NAME>
<RETURNS>gboolean </RETURNS>
GNode *node,
gpointer data
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GNodeForeachFunc</NAME>
<RETURNS>void </RETURNS>
GNode *node,
gpointer data
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GSearchFunc</NAME>
<RETURNS>gint </RETURNS>
gpointer key,
gpointer data
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GScannerMsgFunc</NAME>
<RETURNS>void </RETURNS>
GScanner *scanner,
gchar *message,
gint error
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GTraverseFunc</NAME>
<RETURNS>gint </RETURNS>
gpointer key,
gpointer value,
gpointer data
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GVoidFunc</NAME>
<RETURNS>void </RETURNS>
void
</USER_FUNCTION>
<STRUCT>
<NAME>GList</NAME>
struct GList
{
gpointer data;
GList *next;
GList *prev;
};
</STRUCT>
<STRUCT>
<NAME>GSList</NAME>
struct GSList
{
gpointer data;
GSList *next;
};
</STRUCT>
<STRUCT>
<NAME>GString</NAME>
struct GString
{
gchar *str;
gint len;
};
</STRUCT>
<STRUCT>
<NAME>GArray</NAME>
struct GArray
{
gchar *data;
guint len;
};
</STRUCT>
<STRUCT>
<NAME>GByteArray</NAME>
struct GByteArray
{
guint8 *data;
guint len;
};
</STRUCT>
<STRUCT>
<NAME>GPtrArray</NAME>
struct GPtrArray
{
gpointer *pdata;
guint len;
};
</STRUCT>
<STRUCT>
<NAME>GTuples</NAME>
struct GTuples
{
guint len;
};
</STRUCT>
<STRUCT>
<NAME>GDebugKey</NAME>
struct GDebugKey
{
gchar *key;
guint value;
};
</STRUCT>
<FUNCTION>
<NAME>g_list_push_allocator</NAME>
<RETURNS>void </RETURNS>
GAllocator *allocator
</FUNCTION>
<FUNCTION>
<NAME>g_list_pop_allocator</NAME>
<RETURNS>void </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>g_list_alloc</NAME>
<RETURNS>GList *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>g_list_free</NAME>
<RETURNS>void </RETURNS>
GList *list
</FUNCTION>
<FUNCTION>
<NAME>g_list_free_1</NAME>
<RETURNS>void </RETURNS>
GList *list
</FUNCTION>
<FUNCTION>
<NAME>g_list_append</NAME>
<RETURNS>GList *</RETURNS>
GList *list,gpointer data
</FUNCTION>
<FUNCTION>
<NAME>g_list_prepend</NAME>
<RETURNS>GList *</RETURNS>
GList *list,gpointer data
</FUNCTION>
<FUNCTION>
<NAME>g_list_insert</NAME>
<RETURNS>GList *</RETURNS>
GList *list,gpointer data,gint position
</FUNCTION>
<FUNCTION>
<NAME>g_list_insert_sorted</NAME>
<RETURNS>GList *</RETURNS>
GList *list,gpointer data,GCompareFunc func
</FUNCTION>
<FUNCTION>
<NAME>g_list_concat</NAME>
<RETURNS>GList *</RETURNS>
GList *list1,GList *list2
</FUNCTION>
<FUNCTION>
<NAME>g_list_remove</NAME>
<RETURNS>GList *</RETURNS>
GList *list,gpointer data
</FUNCTION>
<FUNCTION>
<NAME>g_list_remove_link</NAME>
<RETURNS>GList *</RETURNS>
GList *list,GList *llink
</FUNCTION>
<FUNCTION>
<NAME>g_list_reverse</NAME>
<RETURNS>GList *</RETURNS>
GList *list
</FUNCTION>
<FUNCTION>
<NAME>g_list_copy</NAME>
<RETURNS>GList *</RETURNS>
GList *list
</FUNCTION>
<FUNCTION>
<NAME>g_list_nth</NAME>
<RETURNS>GList *</RETURNS>
GList *list,guint n
</FUNCTION>
<FUNCTION>
<NAME>g_list_find</NAME>
<RETURNS>GList *</RETURNS>
GList *list,gpointer data
</FUNCTION>
<FUNCTION>
<NAME>g_list_find_custom</NAME>
<RETURNS>GList *</RETURNS>
GList *list,gpointer data,GCompareFunc func
</FUNCTION>
<FUNCTION>
<NAME>g_list_position</NAME>
<RETURNS>gint </RETURNS>
GList *list,GList *llink
</FUNCTION>
<FUNCTION>
<NAME>g_list_index</NAME>
<RETURNS>gint </RETURNS>
GList *list,gpointer data
</FUNCTION>
<FUNCTION>
<NAME>g_list_last</NAME>
<RETURNS>GList *</RETURNS>
GList *list
</FUNCTION>
<FUNCTION>
<NAME>g_list_first</NAME>
<RETURNS>GList *</RETURNS>
GList *list
</FUNCTION>
<FUNCTION>
<NAME>g_list_length</NAME>
<RETURNS>guint </RETURNS>
GList *list
</FUNCTION>
<FUNCTION>
<NAME>g_list_foreach</NAME>
<RETURNS>void </RETURNS>
GList *list,GFunc func,gpointer user_data
</FUNCTION>
<FUNCTION>
<NAME>g_list_sort</NAME>
<RETURNS>GList *</RETURNS>
GList *list,GCompareFunc compare_func
</FUNCTION>
<FUNCTION>
<NAME>g_list_nth_data</NAME>
<RETURNS>gpointer </RETURNS>
GList *list,guint n
</FUNCTION>
<MACRO>
<NAME>g_list_previous</NAME>
#define g_list_previous(list) ((list) ? (((GList *)(list))->prev) : NULL)
</MACRO>
<MACRO>
<NAME>g_list_next</NAME>
#define g_list_next(list) ((list) ? (((GList *)(list))->next) : NULL)
</MACRO>
<FUNCTION>
<NAME>g_slist_push_allocator</NAME>
<RETURNS>void </RETURNS>
GAllocator *allocator
</FUNCTION>
<FUNCTION>
<NAME>g_slist_pop_allocator</NAME>
<RETURNS>void </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>g_slist_alloc</NAME>
<RETURNS>GSList *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>g_slist_free</NAME>
<RETURNS>void </RETURNS>
GSList *list
</FUNCTION>
<FUNCTION>
<NAME>g_slist_free_1</NAME>
<RETURNS>void </RETURNS>
GSList *list
</FUNCTION>
<FUNCTION>
<NAME>g_slist_append</NAME>
<RETURNS>GSList *</RETURNS>
GSList *list,gpointer data
</FUNCTION>
<FUNCTION>
<NAME>g_slist_prepend</NAME>
<RETURNS>GSList *</RETURNS>
GSList *list,gpointer data
</FUNCTION>
<FUNCTION>
<NAME>g_slist_insert</NAME>
<RETURNS>GSList *</RETURNS>
GSList *list,gpointer data,gint position
</FUNCTION>
<FUNCTION>
<NAME>g_slist_insert_sorted</NAME>
<RETURNS>GSList *</RETURNS>
GSList *list,gpointer data,GCompareFunc func
</FUNCTION>
<FUNCTION>
<NAME>g_slist_concat</NAME>
<RETURNS>GSList *</RETURNS>
GSList *list1,GSList *list2
</FUNCTION>
<FUNCTION>
<NAME>g_slist_remove</NAME>
<RETURNS>GSList *</RETURNS>
GSList *list,gpointer data
</FUNCTION>
<FUNCTION>
<NAME>g_slist_remove_link</NAME>
<RETURNS>GSList *</RETURNS>
GSList *list,GSList *llink
</FUNCTION>
<FUNCTION>
<NAME>g_slist_reverse</NAME>
<RETURNS>GSList *</RETURNS>
GSList *list
</FUNCTION>
<FUNCTION>
<NAME>g_slist_copy</NAME>
<RETURNS>GSList *</RETURNS>
GSList *list
</FUNCTION>
<FUNCTION>
<NAME>g_slist_nth</NAME>
<RETURNS>GSList *</RETURNS>
GSList *list,guint n
</FUNCTION>
<FUNCTION>
<NAME>g_slist_find</NAME>
<RETURNS>GSList *</RETURNS>
GSList *list,gpointer data
</FUNCTION>
<FUNCTION>
<NAME>g_slist_find_custom</NAME>
<RETURNS>GSList *</RETURNS>
GSList *list,gpointer data,GCompareFunc func
</FUNCTION>
<FUNCTION>
<NAME>g_slist_position</NAME>
<RETURNS>gint </RETURNS>
GSList *list,GSList *llink
</FUNCTION>
<FUNCTION>
<NAME>g_slist_index</NAME>
<RETURNS>gint </RETURNS>
GSList *list,gpointer data
</FUNCTION>
<FUNCTION>
<NAME>g_slist_last</NAME>
<RETURNS>GSList *</RETURNS>
GSList *list
</FUNCTION>
<FUNCTION>
<NAME>g_slist_length</NAME>
<RETURNS>guint </RETURNS>
GSList *list
</FUNCTION>
<FUNCTION>
<NAME>g_slist_foreach</NAME>
<RETURNS>void </RETURNS>
GSList *list,GFunc func,gpointer user_data
</FUNCTION>
<FUNCTION>
<NAME>g_slist_sort</NAME>
<RETURNS>GSList *</RETURNS>
GSList *list,GCompareFunc compare_func
</FUNCTION>
<FUNCTION>
<NAME>g_slist_nth_data</NAME>
<RETURNS>gpointer </RETURNS>
GSList *list,guint n
</FUNCTION>
<MACRO>
<NAME>g_slist_next</NAME>
#define g_slist_next(slist) ((slist) ? (((GSList *)(slist))->next) : NULL)
</MACRO>
<FUNCTION>
<NAME>g_hash_table_new</NAME>
<RETURNS>GHashTable *</RETURNS>
GHashFunc hash_func,GCompareFunc key_compare_func
</FUNCTION>
<FUNCTION>
<NAME>g_hash_table_destroy</NAME>
<RETURNS>void </RETURNS>
GHashTable *hash_table
</FUNCTION>
<FUNCTION>
<NAME>g_hash_table_insert</NAME>
<RETURNS>void </RETURNS>
GHashTable *hash_table,gpointer key,gpointer value
</FUNCTION>
<FUNCTION>
<NAME>g_hash_table_remove</NAME>
<RETURNS>void </RETURNS>
GHashTable *hash_table,gconstpointer key
</FUNCTION>
<FUNCTION>
<NAME>g_hash_table_lookup</NAME>
<RETURNS>gpointer </RETURNS>
GHashTable *hash_table,gconstpointer key
</FUNCTION>
<FUNCTION>
<NAME>g_hash_table_lookup_extended</NAME>
<RETURNS>gboolean </RETURNS>
GHashTable *hash_table,gconstpointer lookup_key,gpointer *orig_key,gpointer *value
</FUNCTION>
<FUNCTION>
<NAME>g_hash_table_freeze</NAME>
<RETURNS>void </RETURNS>
GHashTable *hash_table
</FUNCTION>
<FUNCTION>
<NAME>g_hash_table_thaw</NAME>
<RETURNS>void </RETURNS>
GHashTable *hash_table
</FUNCTION>
<FUNCTION>
<NAME>g_hash_table_foreach</NAME>
<RETURNS>void </RETURNS>
GHashTable *hash_table,GHFunc func,gpointer user_data
</FUNCTION>
<FUNCTION>
<NAME>g_hash_table_foreach_remove</NAME>
<RETURNS>guint </RETURNS>
GHashTable *hash_table,GHRFunc func,gpointer user_data
</FUNCTION>
<FUNCTION>
<NAME>g_hash_table_size</NAME>
<RETURNS>guint </RETURNS>
GHashTable *hash_table
</FUNCTION>
<FUNCTION>
<NAME>g_cache_new</NAME>
<RETURNS>GCache *</RETURNS>
GCacheNewFunc value_new_func,GCacheDestroyFunc value_destroy_func,GCacheDupFunc key_dup_func,GCacheDestroyFunc key_destroy_func,GHashFunc hash_key_func,GHashFunc hash_value_func,GCompareFunc key_compare_func
</FUNCTION>
<FUNCTION>
<NAME>g_cache_destroy</NAME>
<RETURNS>void </RETURNS>
GCache *cache
</FUNCTION>
<FUNCTION>
<NAME>g_cache_insert</NAME>
<RETURNS>gpointer </RETURNS>
GCache *cache,gpointer key
</FUNCTION>
<FUNCTION>
<NAME>g_cache_remove</NAME>
<RETURNS>void </RETURNS>
GCache *cache,gpointer value
</FUNCTION>
<FUNCTION>
<NAME>g_cache_key_foreach</NAME>
<RETURNS>void </RETURNS>
GCache *cache,GHFunc func,gpointer user_data
</FUNCTION>
<FUNCTION>
<NAME>g_cache_value_foreach</NAME>
<RETURNS>void </RETURNS>
GCache *cache,GHFunc func,gpointer user_data
</FUNCTION>
<FUNCTION>
<NAME>g_tree_new</NAME>
<RETURNS>GTree *</RETURNS>
GCompareFunc key_compare_func
</FUNCTION>
<FUNCTION>
<NAME>g_tree_destroy</NAME>
<RETURNS>void </RETURNS>
GTree *tree
</FUNCTION>
<FUNCTION>
<NAME>g_tree_insert</NAME>
<RETURNS>void </RETURNS>
GTree *tree,gpointer key,gpointer value
</FUNCTION>
<FUNCTION>
<NAME>g_tree_remove</NAME>
<RETURNS>void </RETURNS>
GTree *tree,gpointer key
</FUNCTION>
<FUNCTION>
<NAME>g_tree_lookup</NAME>
<RETURNS>gpointer </RETURNS>
GTree *tree,gpointer key
</FUNCTION>
<FUNCTION>
<NAME>g_tree_traverse</NAME>
<RETURNS>void </RETURNS>
GTree *tree,GTraverseFunc traverse_func,GTraverseType traverse_type,gpointer data
</FUNCTION>
<FUNCTION>
<NAME>g_tree_search</NAME>
<RETURNS>gpointer </RETURNS>
GTree *tree,GSearchFunc search_func,gpointer data
</FUNCTION>
<FUNCTION>
<NAME>g_tree_height</NAME>
<RETURNS>gint </RETURNS>
GTree *tree
</FUNCTION>
<FUNCTION>
<NAME>g_tree_nnodes</NAME>
<RETURNS>gint </RETURNS>
GTree *tree
</FUNCTION>
<STRUCT>
<NAME>GNode</NAME>
struct GNode
{
gpointer data;
GNode *next;
GNode *prev;
GNode *parent;
GNode *children;
};
</STRUCT>
<MACRO>
<NAME>G_NODE_IS_ROOT</NAME>
#define G_NODE_IS_ROOT(node) (((GNode*) (node))->parent == NULL && \
((GNode*) (node))->prev == NULL && \
((GNode*) (node))->next == NULL)
</MACRO>
<MACRO>
<NAME>G_NODE_IS_LEAF</NAME>
#define G_NODE_IS_LEAF(node) (((GNode*) (node))->children == NULL)
</MACRO>
<FUNCTION>
<NAME>g_node_push_allocator</NAME>
<RETURNS>void </RETURNS>
GAllocator *allocator
</FUNCTION>
<FUNCTION>
<NAME>g_node_pop_allocator</NAME>
<RETURNS>void </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>g_node_new</NAME>
<RETURNS>GNode *</RETURNS>
gpointer data
</FUNCTION>
<FUNCTION>
<NAME>g_node_destroy</NAME>
<RETURNS>void </RETURNS>
GNode *root
</FUNCTION>
<FUNCTION>
<NAME>g_node_unlink</NAME>
<RETURNS>void </RETURNS>
GNode *node
</FUNCTION>
<FUNCTION>
<NAME>g_node_insert</NAME>
<RETURNS>GNode *</RETURNS>
GNode *parent,gint position,GNode *node
</FUNCTION>
<FUNCTION>
<NAME>g_node_insert_before</NAME>
<RETURNS>GNode *</RETURNS>
GNode *parent,GNode *sibling,GNode *node
</FUNCTION>
<FUNCTION>
<NAME>g_node_prepend</NAME>
<RETURNS>GNode *</RETURNS>
GNode *parent,GNode *node
</FUNCTION>
<FUNCTION>
<NAME>g_node_n_nodes</NAME>
<RETURNS>guint </RETURNS>
GNode *root,GTraverseFlags flags
</FUNCTION>
<FUNCTION>
<NAME>g_node_get_root</NAME>
<RETURNS>GNode *</RETURNS>
GNode *node
</FUNCTION>
<FUNCTION>
<NAME>g_node_is_ancestor</NAME>
<RETURNS>gboolean </RETURNS>
GNode *node,GNode *descendant
</FUNCTION>
<FUNCTION>
<NAME>g_node_depth</NAME>
<RETURNS>guint </RETURNS>
GNode *node
</FUNCTION>
<FUNCTION>
<NAME>g_node_find</NAME>
<RETURNS>GNode *</RETURNS>
GNode *root,GTraverseType order,GTraverseFlags flags,gpointer data
</FUNCTION>
<MACRO>
<NAME>g_node_append</NAME>
#define g_node_append(parent, node) \
g_node_insert_before ((parent), NULL, (node))
</MACRO>
<MACRO>
<NAME>g_node_insert_data</NAME>
#define g_node_insert_data(parent, position, data) \
g_node_insert ((parent), (position), g_node_new (data))
</MACRO>
<MACRO>
<NAME>g_node_insert_data_before</NAME>
#define g_node_insert_data_before(parent, sibling, data) \
g_node_insert_before ((parent), (sibling), g_node_new (data))
</MACRO>
<MACRO>
<NAME>g_node_prepend_data</NAME>
#define g_node_prepend_data(parent, data) \
g_node_prepend ((parent), g_node_new (data))
</MACRO>
<MACRO>
<NAME>g_node_append_data</NAME>
#define g_node_append_data(parent, data) \
g_node_insert_before ((parent), NULL, g_node_new (data))
</MACRO>
<FUNCTION>
<NAME>g_node_traverse</NAME>
<RETURNS>void </RETURNS>
GNode *root,GTraverseType order,GTraverseFlags flags,gint max_depth,GNodeTraverseFunc func,gpointer data
</FUNCTION>
<FUNCTION>
<NAME>g_node_max_height</NAME>
<RETURNS>guint </RETURNS>
GNode *root
</FUNCTION>
<FUNCTION>
<NAME>g_node_children_foreach</NAME>
<RETURNS>void </RETURNS>
GNode *node,GTraverseFlags flags,GNodeForeachFunc func,gpointer data
</FUNCTION>
<FUNCTION>
<NAME>g_node_reverse_children</NAME>
<RETURNS>void </RETURNS>
GNode *node
</FUNCTION>
<FUNCTION>
<NAME>g_node_n_children</NAME>
<RETURNS>guint </RETURNS>
GNode *node
</FUNCTION>
<FUNCTION>
<NAME>g_node_nth_child</NAME>
<RETURNS>GNode *</RETURNS>
GNode *node,guint n
</FUNCTION>
<FUNCTION>
<NAME>g_node_last_child</NAME>
<RETURNS>GNode *</RETURNS>
GNode *node
</FUNCTION>
<FUNCTION>
<NAME>g_node_find_child</NAME>
<RETURNS>GNode *</RETURNS>
GNode *node,GTraverseFlags flags,gpointer data
</FUNCTION>
<FUNCTION>
<NAME>g_node_child_position</NAME>
<RETURNS>gint </RETURNS>
GNode *node,GNode *child
</FUNCTION>
<FUNCTION>
<NAME>g_node_child_index</NAME>
<RETURNS>gint </RETURNS>
GNode *node,gpointer data
</FUNCTION>
<FUNCTION>
<NAME>g_node_first_sibling</NAME>
<RETURNS>GNode *</RETURNS>
GNode *node
</FUNCTION>
<FUNCTION>
<NAME>g_node_last_sibling</NAME>
<RETURNS>GNode *</RETURNS>
GNode *node
</FUNCTION>
<MACRO>
<NAME>g_node_prev_sibling</NAME>
#define g_node_prev_sibling(node) ((node) ? \
((GNode*) (node))->prev : NULL)
</MACRO>
<MACRO>
<NAME>g_node_next_sibling</NAME>
#define g_node_next_sibling(node) ((node) ? \
((GNode*) (node))->next : NULL)
</MACRO>
<MACRO>
<NAME>g_node_first_child</NAME>
#define g_node_first_child(node) ((node) ? \
((GNode*) (node))->children : NULL)
</MACRO>
<MACRO>
<NAME>G_HOOK_FLAG_USER_SHIFT</NAME>
#define G_HOOK_FLAG_USER_SHIFT (4)
</MACRO>
<ENUM>
<NAME>GHookFlagMask</NAME>
typedef enum
{
G_HOOK_FLAG_ACTIVE = 1 << 0,
G_HOOK_FLAG_IN_CALL = 1 << 1,
G_HOOK_FLAG_MASK = 0x0f
} GHookFlagMask;
</ENUM>
<MACRO>
<NAME>G_HOOK_DEFERRED_DESTROY</NAME>
#define G_HOOK_DEFERRED_DESTROY ((GHookFreeFunc) 0x01)
</MACRO>
<STRUCT>
<NAME>GHookList</NAME>
struct GHookList
{
guint seq_id;
guint hook_size;
guint is_setup : 1;
GHook *hooks;
GMemChunk *hook_memchunk;
GHookFreeFunc hook_free; /* virtual function */
GHookFreeFunc hook_destroy; /* virtual function */
};
</STRUCT>
<STRUCT>
<NAME>GHook</NAME>
struct GHook
{
gpointer data;
GHook *next;
GHook *prev;
guint ref_count;
guint hook_id;
guint flags;
gpointer func;
GDestroyNotify destroy;
};
</STRUCT>
<MACRO>
<NAME>G_HOOK_ACTIVE</NAME>
#define G_HOOK_ACTIVE(hook) ((((GHook*) hook)->flags & \
G_HOOK_FLAG_ACTIVE) != 0)
</MACRO>
<MACRO>
<NAME>G_HOOK_IN_CALL</NAME>
#define G_HOOK_IN_CALL(hook) ((((GHook*) hook)->flags & \
G_HOOK_FLAG_IN_CALL) != 0)
</MACRO>
<MACRO>
<NAME>G_HOOK_IS_VALID</NAME>
#define G_HOOK_IS_VALID(hook) (((GHook*) hook)->hook_id != 0 && \
G_HOOK_ACTIVE (hook))
</MACRO>
<MACRO>
<NAME>G_HOOK_IS_UNLINKED</NAME>
#define G_HOOK_IS_UNLINKED(hook) (((GHook*) hook)->next == NULL && \
((GHook*) hook)->prev == NULL && \
((GHook*) hook)->hook_id == 0 && \
((GHook*) hook)->ref_count == 0)
</MACRO>
<FUNCTION>
<NAME>g_hook_list_init</NAME>
<RETURNS>void </RETURNS>
GHookList *hook_list,guint hook_size
</FUNCTION>
<FUNCTION>
<NAME>g_hook_list_clear</NAME>
<RETURNS>void </RETURNS>
GHookList *hook_list
</FUNCTION>
<FUNCTION>
<NAME>g_hook_alloc</NAME>
<RETURNS>GHook *</RETURNS>
GHookList *hook_list
</FUNCTION>
<FUNCTION>
<NAME>g_hook_free</NAME>
<RETURNS>void </RETURNS>
GHookList *hook_list,GHook *hook
</FUNCTION>
<FUNCTION>
<NAME>g_hook_ref</NAME>
<RETURNS>void </RETURNS>
GHookList *hook_list,GHook *hook
</FUNCTION>
<FUNCTION>
<NAME>g_hook_unref</NAME>
<RETURNS>void </RETURNS>
GHookList *hook_list,GHook *hook
</FUNCTION>
<FUNCTION>
<NAME>g_hook_destroy</NAME>
<RETURNS>gboolean </RETURNS>
GHookList *hook_list,guint hook_id
</FUNCTION>
<FUNCTION>
<NAME>g_hook_destroy_link</NAME>
<RETURNS>void </RETURNS>
GHookList *hook_list,GHook *hook
</FUNCTION>
<FUNCTION>
<NAME>g_hook_prepend</NAME>
<RETURNS>void </RETURNS>
GHookList *hook_list,GHook *hook
</FUNCTION>
<FUNCTION>
<NAME>g_hook_insert_before</NAME>
<RETURNS>void </RETURNS>
GHookList *hook_list,GHook *sibling,GHook *hook
</FUNCTION>
<FUNCTION>
<NAME>g_hook_insert_sorted</NAME>
<RETURNS>void </RETURNS>
GHookList *hook_list,GHook *hook,GHookCompareFunc func
</FUNCTION>
<FUNCTION>
<NAME>g_hook_get</NAME>
<RETURNS>GHook *</RETURNS>
GHookList *hook_list,guint hook_id
</FUNCTION>
<FUNCTION>
<NAME>g_hook_find</NAME>
<RETURNS>GHook *</RETURNS>
GHookList *hook_list,gboolean need_valids,GHookFindFunc func,gpointer data
</FUNCTION>
<FUNCTION>
<NAME>g_hook_find_data</NAME>
<RETURNS>GHook *</RETURNS>
GHookList *hook_list,gboolean need_valids,gpointer data
</FUNCTION>
<FUNCTION>
<NAME>g_hook_find_func</NAME>
<RETURNS>GHook *</RETURNS>
GHookList *hook_list,gboolean need_valids,gpointer func
</FUNCTION>
<FUNCTION>
<NAME>g_hook_find_func_data</NAME>
<RETURNS>GHook *</RETURNS>
GHookList *hook_list,gboolean need_valids,gpointer func,gpointer data
</FUNCTION>
<FUNCTION>
<NAME>g_hook_first_valid</NAME>
<RETURNS>GHook *</RETURNS>
GHookList *hook_list,gboolean may_be_in_call
</FUNCTION>
<FUNCTION>
<NAME>g_hook_next_valid</NAME>
<RETURNS>GHook *</RETURNS>
GHookList *hook_list,GHook *hook,gboolean may_be_in_call
</FUNCTION>
<FUNCTION>
<NAME>g_hook_compare_ids</NAME>
<RETURNS>gint </RETURNS>
GHook *new_hook,GHook *sibling
</FUNCTION>
<MACRO>
<NAME>g_hook_append</NAME>
#define g_hook_append( hook_list, hook ) \
g_hook_insert_before ((hook_list), NULL, (hook))
</MACRO>
<FUNCTION>
<NAME>g_hook_list_invoke</NAME>
<RETURNS>void </RETURNS>
GHookList *hook_list,gboolean may_recurse
</FUNCTION>
<FUNCTION>
<NAME>g_hook_list_invoke_check</NAME>
<RETURNS>void </RETURNS>
GHookList *hook_list,gboolean may_recurse
</FUNCTION>
<FUNCTION>
<NAME>g_hook_list_marshal</NAME>
<RETURNS>void </RETURNS>
GHookList *hook_list,gboolean may_recurse,GHookMarshaller marshaller,gpointer data
</FUNCTION>
<FUNCTION>
<NAME>g_hook_list_marshal_check</NAME>
<RETURNS>void </RETURNS>
GHookList *hook_list,gboolean may_recurse,GHookCheckMarshaller marshaller,gpointer data
</FUNCTION>
<FUNCTION>
<NAME>g_on_error_query</NAME>
<RETURNS>void </RETURNS>
const gchar *prg_name
</FUNCTION>
<FUNCTION>
<NAME>g_on_error_stack_trace</NAME>
<RETURNS>void </RETURNS>
const gchar *prg_name
</FUNCTION>
<VARIABLE>
<NAME>g_log_domain_glib</NAME>
extern const gchar *g_log_domain_glib;
</VARIABLE>
<FUNCTION>
<NAME>g_log_set_handler</NAME>
<RETURNS>guint </RETURNS>
const gchar *log_domain,GLogLevelFlags log_levels,GLogFunc log_func,gpointer user_data
</FUNCTION>
<FUNCTION>
<NAME>g_log_remove_handler</NAME>
<RETURNS>void </RETURNS>
const gchar *log_domain,guint handler_id
</FUNCTION>
<FUNCTION>
<NAME>g_log_default_handler</NAME>
<RETURNS>void </RETURNS>
const gchar *log_domain,GLogLevelFlags log_level,const gchar *message,gpointer unused_data
</FUNCTION>
<FUNCTION>
<NAME>g_log</NAME>
<RETURNS>void </RETURNS>
const gchar *log_domain,GLogLevelFlags log_level,const gchar *format,...
</FUNCTION>
<FUNCTION>
<NAME>g_logv</NAME>
<RETURNS>void </RETURNS>
const gchar *log_domain,GLogLevelFlags log_level,const gchar *format,va_list args
</FUNCTION>
<FUNCTION>
<NAME>g_log_set_fatal_mask</NAME>
<RETURNS>GLogLevelFlags </RETURNS>
const gchar *log_domain,GLogLevelFlags fatal_mask
</FUNCTION>
<FUNCTION>
<NAME>g_log_set_always_fatal</NAME>
<RETURNS>GLogLevelFlags </RETURNS>
GLogLevelFlags fatal_mask
</FUNCTION>
<MACRO>
<NAME>G_LOG_DOMAIN</NAME>
#define G_LOG_DOMAIN ((gchar*) 0)
</MACRO>
<MACRO>
<NAME>g_error</NAME>
#define g_error(format, args...) g_log (G_LOG_DOMAIN, \
G_LOG_LEVEL_ERROR, \
format, ##args)
</MACRO>
<MACRO>
<NAME>g_message</NAME>
#define g_message(format, args...) g_log (G_LOG_DOMAIN, \
G_LOG_LEVEL_MESSAGE, \
format, ##args)
</MACRO>
<MACRO>
<NAME>g_warning</NAME>
#define g_warning(format, args...) g_log (G_LOG_DOMAIN, \
G_LOG_LEVEL_WARNING, \
format, ##args)
</MACRO>
<USER_FUNCTION>
<NAME>GPrintFunc</NAME>
<RETURNS>void </RETURNS>
const gchar *string
</USER_FUNCTION>
<FUNCTION>
<NAME>g_print</NAME>
<RETURNS>void </RETURNS>
const gchar *format,...
</FUNCTION>
<FUNCTION>
<NAME>g_set_print_handler</NAME>
<RETURNS>GPrintFunc </RETURNS>
GPrintFunc func
</FUNCTION>
<FUNCTION>
<NAME>g_printerr</NAME>
<RETURNS>void </RETURNS>
const gchar *format,...
</FUNCTION>
<FUNCTION>
<NAME>g_set_printerr_handler</NAME>
<RETURNS>GPrintFunc </RETURNS>
GPrintFunc func
</FUNCTION>
<USER_FUNCTION>
<NAME>GErrorFunc</NAME>
<RETURNS>void </RETURNS>
const gchar *str
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GWarningFunc</NAME>
<RETURNS>void </RETURNS>
const gchar *str
</USER_FUNCTION>
<FUNCTION>
<NAME>g_set_error_handler</NAME>
<RETURNS>GErrorFunc </RETURNS>
GErrorFunc func
</FUNCTION>
<FUNCTION>
<NAME>g_set_warning_handler</NAME>
<RETURNS>GWarningFunc </RETURNS>
GWarningFunc func
</FUNCTION>
<FUNCTION>
<NAME>g_set_message_handler</NAME>
<RETURNS>GPrintFunc </RETURNS>
GPrintFunc func
</FUNCTION>
<MACRO>
<NAME>g_malloc</NAME>
#define g_malloc(size) ((gpointer) MALLOC (size))
</MACRO>
<MACRO>
<NAME>g_malloc0</NAME>
#define g_malloc0(size) ((gpointer) CALLOC (char, size))
</MACRO>
<MACRO>
<NAME>g_realloc</NAME>
#define g_realloc(mem,size) ((gpointer) REALLOC (mem, char, size))
</MACRO>
<MACRO>
<NAME>g_free</NAME>
#define g_free(mem) FREE (mem)
</MACRO>
<FUNCTION>
<NAME>g_malloc</NAME>
<RETURNS>gpointer </RETURNS>
gulong size
</FUNCTION>
<FUNCTION>
<NAME>g_malloc0</NAME>
<RETURNS>gpointer </RETURNS>
gulong size
</FUNCTION>
<FUNCTION>
<NAME>g_realloc</NAME>
<RETURNS>gpointer </RETURNS>
gpointer mem,gulong size
</FUNCTION>
<FUNCTION>
<NAME>g_free</NAME>
<RETURNS>void </RETURNS>
gpointer mem
</FUNCTION>
<FUNCTION>
<NAME>g_mem_profile</NAME>
<RETURNS>void </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>g_mem_check</NAME>
<RETURNS>void </RETURNS>
gpointer mem
</FUNCTION>
<FUNCTION>
<NAME>g_allocator_new</NAME>
<RETURNS>GAllocator *</RETURNS>
const gchar *name,guint n_preallocs
</FUNCTION>
<FUNCTION>
<NAME>g_allocator_free</NAME>
<RETURNS>void </RETURNS>
GAllocator *allocator
</FUNCTION>
<MACRO>
<NAME>G_ALLOCATOR_LIST</NAME>
#define G_ALLOCATOR_LIST (1)
</MACRO>
<MACRO>
<NAME>G_ALLOCATOR_SLIST</NAME>
#define G_ALLOCATOR_SLIST (2)
</MACRO>
<MACRO>
<NAME>G_ALLOCATOR_NODE</NAME>
#define G_ALLOCATOR_NODE (3)
</MACRO>
<MACRO>
<NAME>G_ALLOC_ONLY</NAME>
#define G_ALLOC_ONLY 1
</MACRO>
<MACRO>
<NAME>G_ALLOC_AND_FREE</NAME>
#define G_ALLOC_AND_FREE 2
</MACRO>
<FUNCTION>
<NAME>g_mem_chunk_new</NAME>
<RETURNS>GMemChunk *</RETURNS>
gchar *name,gint atom_size,gulong area_size,gint type
</FUNCTION>
<FUNCTION>
<NAME>g_mem_chunk_destroy</NAME>
<RETURNS>void </RETURNS>
GMemChunk *mem_chunk
</FUNCTION>
<FUNCTION>
<NAME>g_mem_chunk_alloc</NAME>
<RETURNS>gpointer </RETURNS>
GMemChunk *mem_chunk
</FUNCTION>
<FUNCTION>
<NAME>g_mem_chunk_alloc0</NAME>
<RETURNS>gpointer </RETURNS>
GMemChunk *mem_chunk
</FUNCTION>
<FUNCTION>
<NAME>g_mem_chunk_free</NAME>
<RETURNS>void </RETURNS>
GMemChunk *mem_chunk,gpointer mem
</FUNCTION>
<FUNCTION>
<NAME>g_mem_chunk_clean</NAME>
<RETURNS>void </RETURNS>
GMemChunk *mem_chunk
</FUNCTION>
<FUNCTION>
<NAME>g_mem_chunk_reset</NAME>
<RETURNS>void </RETURNS>
GMemChunk *mem_chunk
</FUNCTION>
<FUNCTION>
<NAME>g_mem_chunk_print</NAME>
<RETURNS>void </RETURNS>
GMemChunk *mem_chunk
</FUNCTION>
<FUNCTION>
<NAME>g_mem_chunk_info</NAME>
<RETURNS>void </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>g_blow_chunks</NAME>
<RETURNS>void </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>g_timer_new</NAME>
<RETURNS>GTimer *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>g_timer_destroy</NAME>
<RETURNS>void </RETURNS>
GTimer *timer
</FUNCTION>
<FUNCTION>
<NAME>g_timer_start</NAME>
<RETURNS>void </RETURNS>
GTimer *timer
</FUNCTION>
<FUNCTION>
<NAME>g_timer_stop</NAME>
<RETURNS>void </RETURNS>
GTimer *timer
</FUNCTION>
<FUNCTION>
<NAME>g_timer_reset</NAME>
<RETURNS>void </RETURNS>
GTimer *timer
</FUNCTION>
<FUNCTION>
<NAME>g_timer_elapsed</NAME>
<RETURNS>gdouble </RETURNS>
GTimer *timer,gulong *microseconds
</FUNCTION>
<MACRO>
<NAME>G_STR_DELIMITERS</NAME>
#define G_STR_DELIMITERS "_-|> <."
</MACRO>
<FUNCTION>
<NAME>g_strdelimit</NAME>
<RETURNS>gchar *</RETURNS>
gchar *string,const gchar *delimiters,gchar new_delimiter
</FUNCTION>
<FUNCTION>
<NAME>g_strtod</NAME>
<RETURNS>gdouble </RETURNS>
const gchar *nptr,gchar **endptr
</FUNCTION>
<FUNCTION>
<NAME>g_strerror</NAME>
<RETURNS>gchar *</RETURNS>
gint errnum
</FUNCTION>
<FUNCTION>
<NAME>g_strsignal</NAME>
<RETURNS>gchar *</RETURNS>
gint signum
</FUNCTION>
<FUNCTION>
<NAME>g_strcasecmp</NAME>
<RETURNS>gint </RETURNS>
const gchar *s1,const gchar *s2
</FUNCTION>
<FUNCTION>
<NAME>g_strncasecmp</NAME>
<RETURNS>gint </RETURNS>
const gchar *s1,const gchar *s2,guint n
</FUNCTION>
<FUNCTION>
<NAME>g_strdown</NAME>
<RETURNS>void </RETURNS>
gchar *string
</FUNCTION>
<FUNCTION>
<NAME>g_strup</NAME>
<RETURNS>void </RETURNS>
gchar *string
</FUNCTION>
<FUNCTION>
<NAME>g_strreverse</NAME>
<RETURNS>void </RETURNS>
gchar *string
</FUNCTION>
<FUNCTION>
<NAME>g_strchug</NAME>
<RETURNS>gchar *</RETURNS>
gchar *string
</FUNCTION>
<FUNCTION>
<NAME>g_strchomp</NAME>
<RETURNS>gchar *</RETURNS>
gchar *string
</FUNCTION>
<MACRO>
<NAME>g_strstrip</NAME>
#define g_strstrip( string ) g_strchomp (g_strchug (string))
</MACRO>
<FUNCTION>
<NAME>g_strdup</NAME>
<RETURNS>gchar *</RETURNS>
const gchar *str
</FUNCTION>
<FUNCTION>
<NAME>g_strdup_printf</NAME>
<RETURNS>gchar *</RETURNS>
const gchar *format,...
</FUNCTION>
<FUNCTION>
<NAME>g_strdup_vprintf</NAME>
<RETURNS>gchar *</RETURNS>
const gchar *format,va_list args
</FUNCTION>
<FUNCTION>
<NAME>g_strndup</NAME>
<RETURNS>gchar *</RETURNS>
const gchar *str,guint n
</FUNCTION>
<FUNCTION>
<NAME>g_strnfill</NAME>
<RETURNS>gchar *</RETURNS>
guint length,gchar fill_char
</FUNCTION>
<FUNCTION>
<NAME>g_strconcat</NAME>
<RETURNS>gchar *</RETURNS>
const gchar *string1,...
</FUNCTION>
<FUNCTION>
<NAME>g_strjoin</NAME>
<RETURNS>gchar *</RETURNS>
const gchar *separator,...
</FUNCTION>
<FUNCTION>
<NAME>g_strescape</NAME>
<RETURNS>gchar *</RETURNS>
gchar *string
</FUNCTION>
<FUNCTION>
<NAME>g_memdup</NAME>
<RETURNS>gpointer </RETURNS>
gconstpointer mem,guint byte_size
</FUNCTION>
<FUNCTION>
<NAME>g_strsplit</NAME>
<RETURNS>gchar **</RETURNS>
const gchar *string,const gchar *delimiter,gint max_tokens
</FUNCTION>
<FUNCTION>
<NAME>g_strjoinv</NAME>
<RETURNS>gchar *</RETURNS>
const gchar *separator,gchar **str_array
</FUNCTION>
<FUNCTION>
<NAME>g_strfreev</NAME>
<RETURNS>void </RETURNS>
gchar **str_array
</FUNCTION>
<FUNCTION>
<NAME>g_printf_string_upper_bound</NAME>
<RETURNS>guint </RETURNS>
const gchar* format,va_list args
</FUNCTION>
<FUNCTION>
<NAME>g_get_user_name</NAME>
<RETURNS>gchar *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>g_get_real_name</NAME>
<RETURNS>gchar *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>g_get_home_dir</NAME>
<RETURNS>gchar *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>g_get_tmp_dir</NAME>
<RETURNS>gchar *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>g_get_prgname</NAME>
<RETURNS>gchar *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>g_set_prgname</NAME>
<RETURNS>void </RETURNS>
const gchar *prgname
</FUNCTION>
<FUNCTION>
<NAME>g_parse_debug_string</NAME>
<RETURNS>guint </RETURNS>
const gchar *string,GDebugKey *keys,guint nkeys
</FUNCTION>
<FUNCTION>
<NAME>g_snprintf</NAME>
<RETURNS>gint </RETURNS>
gchar *string,gulong n,gchar const *format,...
</FUNCTION>
<FUNCTION>
<NAME>g_vsnprintf</NAME>
<RETURNS>gint </RETURNS>
gchar *string,gulong n,gchar const *format,va_list args
</FUNCTION>
<FUNCTION>
<NAME>g_basename</NAME>
<RETURNS>gchar *</RETURNS>
const gchar *file_name
</FUNCTION>
<FUNCTION>
<NAME>g_path_is_absolute</NAME>
<RETURNS>gboolean </RETURNS>
const gchar *file_name
</FUNCTION>
<FUNCTION>
<NAME>g_path_skip_root</NAME>
<RETURNS>gchar *</RETURNS>
gchar *file_name
</FUNCTION>
<FUNCTION>
<NAME>g_dirname</NAME>
<RETURNS>gchar *</RETURNS>
const gchar *file_name
</FUNCTION>
<FUNCTION>
<NAME>g_get_current_dir</NAME>
<RETURNS>gchar *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>g_getenv</NAME>
<RETURNS>gchar *</RETURNS>
const gchar *variable
</FUNCTION>
<FUNCTION>
<NAME>g_atexit</NAME>
<RETURNS>void </RETURNS>
GVoidFunc func
</FUNCTION>
<FUNCTION>
<NAME>g_bit_nth_lsf</NAME>
<RETURNS>gint </RETURNS>
guint32 mask,gint nth_bit
</FUNCTION>
<FUNCTION>
<NAME>g_bit_nth_msf</NAME>
<RETURNS>gint </RETURNS>
guint32 mask,gint nth_bit
</FUNCTION>
<FUNCTION>
<NAME>g_bit_storage</NAME>
<RETURNS>guint </RETURNS>
guint number
</FUNCTION>
<FUNCTION>
<NAME>g_string_chunk_new</NAME>
<RETURNS>GStringChunk *</RETURNS>
gint size
</FUNCTION>
<FUNCTION>
<NAME>g_string_chunk_free</NAME>
<RETURNS>void </RETURNS>
GStringChunk *chunk
</FUNCTION>
<FUNCTION>
<NAME>g_string_chunk_insert</NAME>
<RETURNS>gchar *</RETURNS>
GStringChunk *chunk,const gchar *string
</FUNCTION>
<FUNCTION>
<NAME>g_string_chunk_insert_const</NAME>
<RETURNS>gchar *</RETURNS>
GStringChunk *chunk,const gchar *string
</FUNCTION>
<FUNCTION>
<NAME>g_string_new</NAME>
<RETURNS>GString *</RETURNS>
const gchar *init
</FUNCTION>
<FUNCTION>
<NAME>g_string_sized_new</NAME>
<RETURNS>GString *</RETURNS>
guint dfl_size
</FUNCTION>
<FUNCTION>
<NAME>g_string_free</NAME>
<RETURNS>void </RETURNS>
GString *string,gint free_segment
</FUNCTION>
<FUNCTION>
<NAME>g_string_assign</NAME>
<RETURNS>GString *</RETURNS>
GString *lval,const gchar *rval
</FUNCTION>
<FUNCTION>
<NAME>g_string_truncate</NAME>
<RETURNS>GString *</RETURNS>
GString *string,gint len
</FUNCTION>
<FUNCTION>
<NAME>g_string_append</NAME>
<RETURNS>GString *</RETURNS>
GString *string,const gchar *val
</FUNCTION>
<FUNCTION>
<NAME>g_string_append_c</NAME>
<RETURNS>GString *</RETURNS>
GString *string,gchar c
</FUNCTION>
<FUNCTION>
<NAME>g_string_prepend</NAME>
<RETURNS>GString *</RETURNS>
GString *string,const gchar *val
</FUNCTION>
<FUNCTION>
<NAME>g_string_prepend_c</NAME>
<RETURNS>GString *</RETURNS>
GString *string,gchar c
</FUNCTION>
<FUNCTION>
<NAME>g_string_insert</NAME>
<RETURNS>GString *</RETURNS>
GString *string,gint pos,const gchar *val
</FUNCTION>
<FUNCTION>
<NAME>g_string_insert_c</NAME>
<RETURNS>GString *</RETURNS>
GString *string,gint pos,gchar c
</FUNCTION>
<FUNCTION>
<NAME>g_string_erase</NAME>
<RETURNS>GString *</RETURNS>
GString *string,gint pos,gint len
</FUNCTION>
<FUNCTION>
<NAME>g_string_down</NAME>
<RETURNS>GString *</RETURNS>
GString *string
</FUNCTION>
<FUNCTION>
<NAME>g_string_up</NAME>
<RETURNS>GString *</RETURNS>
GString *string
</FUNCTION>
<FUNCTION>
<NAME>g_string_sprintf</NAME>
<RETURNS>void </RETURNS>
GString *string,const gchar *format,...
</FUNCTION>
<FUNCTION>
<NAME>g_string_sprintfa</NAME>
<RETURNS>void </RETURNS>
GString *string,const gchar *format,...
</FUNCTION>
<MACRO>
<NAME>g_array_append_val</NAME>
#define g_array_append_val(a,v) g_array_append_vals (a, &v, 1)
</MACRO>
<MACRO>
<NAME>g_array_prepend_val</NAME>
#define g_array_prepend_val(a,v) g_array_prepend_vals (a, &v, 1)
</MACRO>
<MACRO>
<NAME>g_array_insert_val</NAME>
#define g_array_insert_val(a,i,v) g_array_insert_vals (a, i, &v, 1)
</MACRO>
<MACRO>
<NAME>g_array_index</NAME>
#define g_array_index(a,t,i) (((t*) (a)->data) [(i)])
</MACRO>
<FUNCTION>
<NAME>g_array_new</NAME>
<RETURNS>GArray *</RETURNS>
gboolean zero_terminated,gboolean clear,guint element_size
</FUNCTION>
<FUNCTION>
<NAME>g_array_free</NAME>
<RETURNS>void </RETURNS>
GArray *array,gboolean free_segment
</FUNCTION>
<FUNCTION>
<NAME>g_array_append_vals</NAME>
<RETURNS>GArray *</RETURNS>
GArray *array,gconstpointer data,guint len
</FUNCTION>
<FUNCTION>
<NAME>g_array_prepend_vals</NAME>
<RETURNS>GArray *</RETURNS>
GArray *array,gconstpointer data,guint len
</FUNCTION>
<FUNCTION>
<NAME>g_array_insert_vals</NAME>
<RETURNS>GArray *</RETURNS>
GArray *array,guint index,gconstpointer data,guint len
</FUNCTION>
<FUNCTION>
<NAME>g_array_set_size</NAME>
<RETURNS>GArray *</RETURNS>
GArray *array,guint length
</FUNCTION>
<FUNCTION>
<NAME>g_array_remove_index</NAME>
<RETURNS>GArray *</RETURNS>
GArray *array,guint index
</FUNCTION>
<FUNCTION>
<NAME>g_array_remove_index_fast</NAME>
<RETURNS>GArray *</RETURNS>
GArray *array,guint index
</FUNCTION>
<MACRO>
<NAME>g_ptr_array_index</NAME>
#define g_ptr_array_index(array,index) (array->pdata)[index]
</MACRO>
<FUNCTION>
<NAME>g_ptr_array_new</NAME>
<RETURNS>GPtrArray *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>g_ptr_array_free</NAME>
<RETURNS>void </RETURNS>
GPtrArray *array,gboolean free_seg
</FUNCTION>
<FUNCTION>
<NAME>g_ptr_array_set_size</NAME>
<RETURNS>void </RETURNS>
GPtrArray *array,gint length
</FUNCTION>
<FUNCTION>
<NAME>g_ptr_array_remove_index</NAME>
<RETURNS>gpointer </RETURNS>
GPtrArray *array,guint index
</FUNCTION>
<FUNCTION>
<NAME>g_ptr_array_remove_index_fast</NAME>
<RETURNS>gpointer </RETURNS>
GPtrArray *array,guint index
</FUNCTION>
<FUNCTION>
<NAME>g_ptr_array_remove</NAME>
<RETURNS>gboolean </RETURNS>
GPtrArray *array,gpointer data
</FUNCTION>
<FUNCTION>
<NAME>g_ptr_array_remove_fast</NAME>
<RETURNS>gboolean </RETURNS>
GPtrArray *array,gpointer data
</FUNCTION>
<FUNCTION>
<NAME>g_ptr_array_add</NAME>
<RETURNS>void </RETURNS>
GPtrArray *array,gpointer data
</FUNCTION>
<FUNCTION>
<NAME>g_byte_array_new</NAME>
<RETURNS>GByteArray *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>g_byte_array_free</NAME>
<RETURNS>void </RETURNS>
GByteArray *array,gboolean free_segment
</FUNCTION>
<FUNCTION>
<NAME>g_byte_array_append</NAME>
<RETURNS>GByteArray *</RETURNS>
GByteArray *array,const guint8 *data,guint len
</FUNCTION>
<FUNCTION>
<NAME>g_byte_array_prepend</NAME>
<RETURNS>GByteArray *</RETURNS>
GByteArray *array,const guint8 *data,guint len
</FUNCTION>
<FUNCTION>
<NAME>g_byte_array_set_size</NAME>
<RETURNS>GByteArray *</RETURNS>
GByteArray *array,guint length
</FUNCTION>
<FUNCTION>
<NAME>g_byte_array_remove_index</NAME>
<RETURNS>GByteArray *</RETURNS>
GByteArray *array,guint index
</FUNCTION>
<FUNCTION>
<NAME>g_byte_array_remove_index_fast</NAME>
<RETURNS>GByteArray *</RETURNS>
GByteArray *array,guint index
</FUNCTION>
<FUNCTION>
<NAME>g_str_equal</NAME>
<RETURNS>gint </RETURNS>
gconstpointer v,gconstpointer v2
</FUNCTION>
<FUNCTION>
<NAME>g_str_hash</NAME>
<RETURNS>guint </RETURNS>
gconstpointer v
</FUNCTION>
<FUNCTION>
<NAME>g_int_equal</NAME>
<RETURNS>gint </RETURNS>
gconstpointer v,gconstpointer v2
</FUNCTION>
<FUNCTION>
<NAME>g_int_hash</NAME>
<RETURNS>guint </RETURNS>
gconstpointer v
</FUNCTION>
<FUNCTION>
<NAME>g_direct_hash</NAME>
<RETURNS>guint </RETURNS>
gconstpointer v
</FUNCTION>
<FUNCTION>
<NAME>g_direct_equal</NAME>
<RETURNS>gint </RETURNS>
gconstpointer v,gconstpointer v2
</FUNCTION>
<FUNCTION>
<NAME>g_quark_try_string</NAME>
<RETURNS>GQuark </RETURNS>
const gchar *string
</FUNCTION>
<FUNCTION>
<NAME>g_quark_from_static_string</NAME>
<RETURNS>GQuark </RETURNS>
const gchar *string
</FUNCTION>
<FUNCTION>
<NAME>g_quark_from_string</NAME>
<RETURNS>GQuark </RETURNS>
const gchar *string
</FUNCTION>
<FUNCTION>
<NAME>g_quark_to_string</NAME>
<RETURNS>gchar *</RETURNS>
GQuark quark
</FUNCTION>
<FUNCTION>
<NAME>g_datalist_init</NAME>
<RETURNS>void </RETURNS>
GData **datalist
</FUNCTION>
<FUNCTION>
<NAME>g_datalist_clear</NAME>
<RETURNS>void </RETURNS>
GData **datalist
</FUNCTION>
<FUNCTION>
<NAME>g_datalist_id_get_data</NAME>
<RETURNS>gpointer </RETURNS>
GData **datalist,GQuark key_id
</FUNCTION>
<FUNCTION>
<NAME>g_datalist_id_set_data_full</NAME>
<RETURNS>void </RETURNS>
GData **datalist,GQuark key_id,gpointer data,GDestroyNotify destroy_func
</FUNCTION>
<FUNCTION>
<NAME>g_datalist_id_remove_no_notify</NAME>
<RETURNS>void </RETURNS>
GData **datalist,GQuark key_id
</FUNCTION>
<FUNCTION>
<NAME>g_datalist_foreach</NAME>
<RETURNS>void </RETURNS>
GData **datalist,GDataForeachFunc func,gpointer user_data
</FUNCTION>
<MACRO>
<NAME>g_datalist_id_set_data</NAME>
#define g_datalist_id_set_data(dl, q, d) \
g_datalist_id_set_data_full ((dl), (q), (d), NULL)
</MACRO>
<MACRO>
<NAME>g_datalist_id_remove_data</NAME>
#define g_datalist_id_remove_data(dl, q) \
g_datalist_id_set_data ((dl), (q), NULL)
</MACRO>
<MACRO>
<NAME>g_datalist_get_data</NAME>
#define g_datalist_get_data(dl, k) \
(g_datalist_id_get_data ((dl), g_quark_try_string (k)))
</MACRO>
<MACRO>
<NAME>g_datalist_set_data_full</NAME>
#define g_datalist_set_data_full(dl, k, d, f) \
g_datalist_id_set_data_full ((dl), g_quark_from_string (k), (d), (f))
</MACRO>
<MACRO>
<NAME>g_datalist_remove_no_notify</NAME>
#define g_datalist_remove_no_notify(dl, k) \
g_datalist_id_remove_no_notify ((dl), g_quark_try_string (k))
</MACRO>
<MACRO>
<NAME>g_datalist_set_data</NAME>
#define g_datalist_set_data(dl, k, d) \
g_datalist_set_data_full ((dl), (k), (d), NULL)
</MACRO>
<MACRO>
<NAME>g_datalist_remove_data</NAME>
#define g_datalist_remove_data(dl, k) \
g_datalist_id_set_data ((dl), g_quark_try_string (k), NULL)
</MACRO>
<FUNCTION>
<NAME>g_dataset_destroy</NAME>
<RETURNS>void </RETURNS>
gconstpointer dataset_location
</FUNCTION>
<FUNCTION>
<NAME>g_dataset_id_get_data</NAME>
<RETURNS>gpointer </RETURNS>
gconstpointer dataset_location,GQuark key_id
</FUNCTION>
<FUNCTION>
<NAME>g_dataset_id_set_data_full</NAME>
<RETURNS>void </RETURNS>
gconstpointer dataset_location,GQuark key_id,gpointer data,GDestroyNotify destroy_func
</FUNCTION>
<FUNCTION>
<NAME>g_dataset_id_remove_no_notify</NAME>
<RETURNS>void </RETURNS>
gconstpointer dataset_location,GQuark key_id
</FUNCTION>
<FUNCTION>
<NAME>g_dataset_foreach</NAME>
<RETURNS>void </RETURNS>
gconstpointer dataset_location,GDataForeachFunc func,gpointer user_data
</FUNCTION>
<MACRO>
<NAME>g_dataset_id_set_data</NAME>
#define g_dataset_id_set_data(l, k, d) \
g_dataset_id_set_data_full ((l), (k), (d), NULL)
</MACRO>
<MACRO>
<NAME>g_dataset_id_remove_data</NAME>
#define g_dataset_id_remove_data(l, k) \
g_dataset_id_set_data ((l), (k), NULL)
</MACRO>
<MACRO>
<NAME>g_dataset_get_data</NAME>
#define g_dataset_get_data(l, k) \
(g_dataset_id_get_data ((l), g_quark_try_string (k)))
</MACRO>
<MACRO>
<NAME>g_dataset_set_data_full</NAME>
#define g_dataset_set_data_full(l, k, d, f) \
g_dataset_id_set_data_full ((l), g_quark_from_string (k), (d), (f))
</MACRO>
<MACRO>
<NAME>g_dataset_remove_no_notify</NAME>
#define g_dataset_remove_no_notify(l, k) \
g_dataset_id_remove_no_notify ((l), g_quark_try_string (k))
</MACRO>
<MACRO>
<NAME>g_dataset_set_data</NAME>
#define g_dataset_set_data(l, k, d) \
g_dataset_set_data_full ((l), (k), (d), NULL)
</MACRO>
<MACRO>
<NAME>g_dataset_remove_data</NAME>
#define g_dataset_remove_data(l, k) \
g_dataset_id_set_data ((l), g_quark_try_string (k), NULL)
</MACRO>
<MACRO>
<NAME>G_CSET_A_2_Z</NAME>
#define G_CSET_A_2_Z "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
</MACRO>
<MACRO>
<NAME>G_CSET_a_2_z</NAME>
#define G_CSET_a_2_z "abcdefghijklmnopqrstuvwxyz"
</MACRO>
<MACRO>
<NAME>G_CSET_LATINC</NAME>
#define G_CSET_LATINC "\300\301\302\303\304\305\306"\
"\307\310\311\312\313\314\315\316\317\320"\
"\321\322\323\324\325\326"\
"\330\331\332\333\334\335\336"
</MACRO>
<MACRO>
<NAME>G_CSET_LATINS</NAME>
#define G_CSET_LATINS "\337\340\341\342\343\344\345\346"\
"\347\350\351\352\353\354\355\356\357\360"\
"\361\362\363\364\365\366"\
"\370\371\372\373\374\375\376\377"
</MACRO>
<ENUM>
<NAME>GErrorType</NAME>
typedef enum
{
G_ERR_UNKNOWN,
G_ERR_UNEXP_EOF,
G_ERR_UNEXP_EOF_IN_STRING,
G_ERR_UNEXP_EOF_IN_COMMENT,
G_ERR_NON_DIGIT_IN_CONST,
G_ERR_DIGIT_RADIX,
G_ERR_FLOAT_RADIX,
G_ERR_FLOAT_MALFORMED
} GErrorType;
</ENUM>
<ENUM>
<NAME>GTokenType</NAME>
typedef enum
{
G_TOKEN_EOF = 0,
G_TOKEN_LEFT_PAREN = '(',
G_TOKEN_RIGHT_PAREN = ')',
G_TOKEN_LEFT_CURLY = '{',
G_TOKEN_RIGHT_CURLY = '}',
G_TOKEN_LEFT_BRACE = '[',
G_TOKEN_RIGHT_BRACE = ']',
G_TOKEN_EQUAL_SIGN = '=',
G_TOKEN_COMMA = ',',
G_TOKEN_NONE = 256,
G_TOKEN_ERROR,
G_TOKEN_CHAR,
G_TOKEN_BINARY,
G_TOKEN_OCTAL,
G_TOKEN_INT,
G_TOKEN_HEX,
G_TOKEN_FLOAT,
G_TOKEN_STRING,
G_TOKEN_SYMBOL,
G_TOKEN_IDENTIFIER,
G_TOKEN_IDENTIFIER_NULL,
G_TOKEN_COMMENT_SINGLE,
G_TOKEN_COMMENT_MULTI,
G_TOKEN_LAST
} GTokenType;
</ENUM>
<UNION>
<NAME>GTokenValue</NAME>
union GTokenValue
{
gpointer v_symbol;
gchar *v_identifier;
gulong v_binary;
gulong v_octal;
gulong v_int;
gdouble v_float;
gulong v_hex;
gchar *v_string;
gchar *v_comment;
guchar v_char;
guint v_error;
};
</UNION>
<STRUCT>
<NAME>GScannerConfig</NAME>
struct GScannerConfig
{
/* Character sets
*/
gchar *cset_skip_characters; /* default: " \t\n" */
gchar *cset_identifier_first;
gchar *cset_identifier_nth;
gchar *cpair_comment_single; /* default: "#\n" */
/* Should symbol lookup work case sensitive?
*/
guint case_sensitive : 1;
/* Boolean values to be adjusted "on the fly"
* to configure scanning behaviour.
*/
guint skip_comment_multi : 1; /* C like comment */
guint skip_comment_single : 1; /* single line comment */
guint scan_comment_multi : 1; /* scan multi line comments? */
guint scan_identifier : 1;
guint scan_identifier_1char : 1;
guint scan_identifier_NULL : 1;
guint scan_symbols : 1;
guint scan_binary : 1;
guint scan_octal : 1;
guint scan_float : 1;
guint scan_hex : 1; /* `0x0ff0' */
guint scan_hex_dollar : 1; /* `$0ff0' */
guint scan_string_sq : 1; /* string: 'anything' */
guint scan_string_dq : 1; /* string: "\\-escapes!\n" */
guint numbers_2_int : 1; /* bin, octal, hex => int */
guint int_2_float : 1; /* int => G_TOKEN_FLOAT? */
guint identifier_2_string : 1;
guint char_2_token : 1; /* return G_TOKEN_CHAR? */
guint symbol_2_token : 1;
guint scope_0_fallback : 1; /* try scope 0 on lookups? */
};
</STRUCT>
<STRUCT>
<NAME>GScanner</NAME>
struct GScanner
{
/* unused fields */
gpointer user_data;
guint max_parse_errors;
/* g_scanner_error() increments this field */
guint parse_errors;
/* name of input stream, featured by the default message handler */
const gchar *input_name;
/* data pointer for derived structures */
gpointer derived_data;
/* link into the scanner configuration */
GScannerConfig *config;
/* fields filled in after g_scanner_get_next_token() */
GTokenType token;
GTokenValue value;
guint line;
guint position;
/* fields filled in after g_scanner_peek_next_token() */
GTokenType next_token;
GTokenValue next_value;
guint next_line;
guint next_position;
/* to be considered private */
GHashTable *symbol_table;
gint input_fd;
const gchar *text;
const gchar *text_end;
gchar *buffer;
guint scope_id;
/* handler function for _warn and _error */
GScannerMsgFunc msg_handler;
};
</STRUCT>
<FUNCTION>
<NAME>g_scanner_new</NAME>
<RETURNS>GScanner *</RETURNS>
GScannerConfig *config_templ
</FUNCTION>
<FUNCTION>
<NAME>g_scanner_destroy</NAME>
<RETURNS>void </RETURNS>
GScanner *scanner
</FUNCTION>
<FUNCTION>
<NAME>g_scanner_input_file</NAME>
<RETURNS>void </RETURNS>
GScanner *scanner,gint input_fd
</FUNCTION>
<FUNCTION>
<NAME>g_scanner_sync_file_offset</NAME>
<RETURNS>void </RETURNS>
GScanner *scanner
</FUNCTION>
<FUNCTION>
<NAME>g_scanner_input_text</NAME>
<RETURNS>void </RETURNS>
GScanner *scanner,const gchar *text,guint text_len
</FUNCTION>
<FUNCTION>
<NAME>g_scanner_get_next_token</NAME>
<RETURNS>GTokenType </RETURNS>
GScanner *scanner
</FUNCTION>
<FUNCTION>
<NAME>g_scanner_peek_next_token</NAME>
<RETURNS>GTokenType </RETURNS>
GScanner *scanner
</FUNCTION>
<FUNCTION>
<NAME>g_scanner_cur_token</NAME>
<RETURNS>GTokenType </RETURNS>
GScanner *scanner
</FUNCTION>
<FUNCTION>
<NAME>g_scanner_cur_value</NAME>
<RETURNS>GTokenValue </RETURNS>
GScanner *scanner
</FUNCTION>
<FUNCTION>
<NAME>g_scanner_cur_line</NAME>
<RETURNS>guint </RETURNS>
GScanner *scanner
</FUNCTION>
<FUNCTION>
<NAME>g_scanner_cur_position</NAME>
<RETURNS>guint </RETURNS>
GScanner *scanner
</FUNCTION>
<FUNCTION>
<NAME>g_scanner_eof</NAME>
<RETURNS>gboolean </RETURNS>
GScanner *scanner
</FUNCTION>
<FUNCTION>
<NAME>g_scanner_set_scope</NAME>
<RETURNS>guint </RETURNS>
GScanner *scanner,guint scope_id
</FUNCTION>
<FUNCTION>
<NAME>g_scanner_scope_add_symbol</NAME>
<RETURNS>void </RETURNS>
GScanner *scanner,guint scope_id,const gchar *symbol,gpointer value
</FUNCTION>
<FUNCTION>
<NAME>g_scanner_scope_remove_symbol</NAME>
<RETURNS>void </RETURNS>
GScanner *scanner,guint scope_id,const gchar *symbol
</FUNCTION>
<FUNCTION>
<NAME>g_scanner_scope_lookup_symbol</NAME>
<RETURNS>gpointer </RETURNS>
GScanner *scanner,guint scope_id,const gchar *symbol
</FUNCTION>
<FUNCTION>
<NAME>g_scanner_scope_foreach_symbol</NAME>
<RETURNS>void </RETURNS>
GScanner *scanner,guint scope_id,GHFunc func,gpointer user_data
</FUNCTION>
<FUNCTION>
<NAME>g_scanner_lookup_symbol</NAME>
<RETURNS>gpointer </RETURNS>
GScanner *scanner,const gchar *symbol
</FUNCTION>
<FUNCTION>
<NAME>g_scanner_freeze_symbol_table</NAME>
<RETURNS>void </RETURNS>
GScanner *scanner
</FUNCTION>
<FUNCTION>
<NAME>g_scanner_thaw_symbol_table</NAME>
<RETURNS>void </RETURNS>
GScanner *scanner
</FUNCTION>
<FUNCTION>
<NAME>g_scanner_unexp_token</NAME>
<RETURNS>void </RETURNS>
GScanner *scanner,GTokenType expected_token,const gchar *identifier_spec,const gchar *symbol_spec,const gchar *symbol_name,const gchar *message,gint is_error
</FUNCTION>
<FUNCTION>
<NAME>g_scanner_error</NAME>
<RETURNS>void </RETURNS>
GScanner *scanner,const gchar *format,...
</FUNCTION>
<FUNCTION>
<NAME>g_scanner_warn</NAME>
<RETURNS>void </RETURNS>
GScanner *scanner,const gchar *format,...
</FUNCTION>
<FUNCTION>
<NAME>g_scanner_stat_mode</NAME>
<RETURNS>gint </RETURNS>
const gchar *filename
</FUNCTION>
<MACRO>
<NAME>g_scanner_add_symbol</NAME>
#define g_scanner_add_symbol( scanner, symbol, value ) G_STMT_START { \
g_scanner_scope_add_symbol ((scanner), 0, (symbol), (value)); \
} G_STMT_END
</MACRO>
<MACRO>
<NAME>g_scanner_remove_symbol</NAME>
#define g_scanner_remove_symbol( scanner, symbol ) G_STMT_START { \
g_scanner_scope_remove_symbol ((scanner), 0, (symbol)); \
} G_STMT_END
</MACRO>
<MACRO>
<NAME>g_scanner_foreach_symbol</NAME>
#define g_scanner_foreach_symbol( scanner, func, data ) G_STMT_START { \
g_scanner_scope_foreach_symbol ((scanner), 0, (func), (data)); \
} G_STMT_END
</MACRO>
<STRUCT>
<NAME>GCompletion</NAME>
struct GCompletion
{
GList* items;
GCompletionFunc func;
gchar* prefix;
GList* cache;
};
</STRUCT>
<FUNCTION>
<NAME>g_completion_new</NAME>
<RETURNS>GCompletion *</RETURNS>
GCompletionFunc func
</FUNCTION>
<FUNCTION>
<NAME>g_completion_add_items</NAME>
<RETURNS>void </RETURNS>
GCompletion* cmp,GList* items
</FUNCTION>
<FUNCTION>
<NAME>g_completion_remove_items</NAME>
<RETURNS>void </RETURNS>
GCompletion* cmp,GList* items
</FUNCTION>
<FUNCTION>
<NAME>g_completion_clear_items</NAME>
<RETURNS>void </RETURNS>
GCompletion* cmp
</FUNCTION>
<FUNCTION>
<NAME>g_completion_complete</NAME>
<RETURNS>GList *</RETURNS>
GCompletion* cmp,gchar* prefix,gchar** new_prefix
</FUNCTION>
<FUNCTION>
<NAME>g_completion_free</NAME>
<RETURNS>void </RETURNS>
GCompletion* cmp
</FUNCTION>
<TYPEDEF>
<NAME>GDateYear</NAME>
typedef guint16 GDateYear;
</TYPEDEF>
<TYPEDEF>
<NAME>GDateDay</NAME>
typedef guint8 GDateDay; /* day of the month */
</TYPEDEF>
<STRUCT>
<NAME>GDate</NAME>
</STRUCT>
<ENUM>
<NAME>GDateDMY</NAME>
typedef enum
{
G_DATE_DAY = 0,
G_DATE_MONTH = 1,
G_DATE_YEAR = 2
} GDateDMY;
</ENUM>
<ENUM>
<NAME>GDateWeekday</NAME>
typedef enum
{
G_DATE_BAD_WEEKDAY = 0,
G_DATE_MONDAY = 1,
G_DATE_TUESDAY = 2,
G_DATE_WEDNESDAY = 3,
G_DATE_THURSDAY = 4,
G_DATE_FRIDAY = 5,
G_DATE_SATURDAY = 6,
G_DATE_SUNDAY = 7
} GDateWeekday;
</ENUM>
<ENUM>
<NAME>GDateMonth</NAME>
typedef enum
{
G_DATE_BAD_MONTH = 0,
G_DATE_JANUARY = 1,
G_DATE_FEBRUARY = 2,
G_DATE_MARCH = 3,
G_DATE_APRIL = 4,
G_DATE_MAY = 5,
G_DATE_JUNE = 6,
G_DATE_JULY = 7,
G_DATE_AUGUST = 8,
G_DATE_SEPTEMBER = 9,
G_DATE_OCTOBER = 10,
G_DATE_NOVEMBER = 11,
G_DATE_DECEMBER = 12
} GDateMonth;
</ENUM>
<MACRO>
<NAME>G_DATE_BAD_JULIAN</NAME>
#define G_DATE_BAD_JULIAN 0U
</MACRO>
<MACRO>
<NAME>G_DATE_BAD_DAY</NAME>
#define G_DATE_BAD_DAY 0U
</MACRO>
<MACRO>
<NAME>G_DATE_BAD_YEAR</NAME>
#define G_DATE_BAD_YEAR 0U
</MACRO>
<STRUCT>
<NAME>GDate</NAME>
struct GDate
{
guint julian_days : 32; /* julian days representation - we use a
* bitfield hoping that 64 bit platforms
* will pack this whole struct in one big
* int
*/
guint julian : 1; /* julian is valid */
guint dmy : 1; /* dmy is valid */
/* DMY representation */
guint day : 6;
guint month : 4;
guint year : 16;
};
</STRUCT>
<FUNCTION>
<NAME>g_date_new</NAME>
<RETURNS>GDate *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>g_date_new_dmy</NAME>
<RETURNS>GDate *</RETURNS>
GDateDay day,GDateMonth month,GDateYear year
</FUNCTION>
<FUNCTION>
<NAME>g_date_new_julian</NAME>
<RETURNS>GDate *</RETURNS>
guint32 julian_day
</FUNCTION>
<FUNCTION>
<NAME>g_date_free</NAME>
<RETURNS>void </RETURNS>
GDate *date
</FUNCTION>
<FUNCTION>
<NAME>g_date_valid</NAME>
<RETURNS>gboolean </RETURNS>
GDate *date
</FUNCTION>
<FUNCTION>
<NAME>g_date_valid_day</NAME>
<RETURNS>gboolean </RETURNS>
GDateDay day
</FUNCTION>
<FUNCTION>
<NAME>g_date_valid_month</NAME>
<RETURNS>gboolean </RETURNS>
GDateMonth month
</FUNCTION>
<FUNCTION>
<NAME>g_date_valid_year</NAME>
<RETURNS>gboolean </RETURNS>
GDateYear year
</FUNCTION>
<FUNCTION>
<NAME>g_date_valid_weekday</NAME>
<RETURNS>gboolean </RETURNS>
GDateWeekday weekday
</FUNCTION>
<FUNCTION>
<NAME>g_date_valid_julian</NAME>
<RETURNS>gboolean </RETURNS>
guint32 julian_date
</FUNCTION>
<FUNCTION>
<NAME>g_date_valid_dmy</NAME>
<RETURNS>gboolean </RETURNS>
GDateDay day,GDateMonth month,GDateYear year
</FUNCTION>
<FUNCTION>
<NAME>g_date_weekday</NAME>
<RETURNS>GDateWeekday </RETURNS>
GDate *date
</FUNCTION>
<FUNCTION>
<NAME>g_date_month</NAME>
<RETURNS>GDateMonth </RETURNS>
GDate *date
</FUNCTION>
<FUNCTION>
<NAME>g_date_year</NAME>
<RETURNS>GDateYear </RETURNS>
GDate *date
</FUNCTION>
<FUNCTION>
<NAME>g_date_day</NAME>
<RETURNS>GDateDay </RETURNS>
GDate *date
</FUNCTION>
<FUNCTION>
<NAME>g_date_julian</NAME>
<RETURNS>guint32 </RETURNS>
GDate *date
</FUNCTION>
<FUNCTION>
<NAME>g_date_day_of_year</NAME>
<RETURNS>guint </RETURNS>
GDate *date
</FUNCTION>
<FUNCTION>
<NAME>g_date_monday_week_of_year</NAME>
<RETURNS>guint </RETURNS>
GDate *date
</FUNCTION>
<FUNCTION>
<NAME>g_date_sunday_week_of_year</NAME>
<RETURNS>guint </RETURNS>
GDate *date
</FUNCTION>
<FUNCTION>
<NAME>g_date_clear</NAME>
<RETURNS>void </RETURNS>
GDate *date,guint n_dates
</FUNCTION>
<FUNCTION>
<NAME>g_date_set_parse</NAME>
<RETURNS>void </RETURNS>
GDate *date,const gchar *str
</FUNCTION>
<FUNCTION>
<NAME>g_date_set_time</NAME>
<RETURNS>void </RETURNS>
GDate *date,GTime time
</FUNCTION>
<FUNCTION>
<NAME>g_date_set_month</NAME>
<RETURNS>void </RETURNS>
GDate *date,GDateMonth month
</FUNCTION>
<FUNCTION>
<NAME>g_date_set_day</NAME>
<RETURNS>void </RETURNS>
GDate *date,GDateDay day
</FUNCTION>
<FUNCTION>
<NAME>g_date_set_year</NAME>
<RETURNS>void </RETURNS>
GDate *date,GDateYear year
</FUNCTION>
<FUNCTION>
<NAME>g_date_set_dmy</NAME>
<RETURNS>void </RETURNS>
GDate *date,GDateDay day,GDateMonth month,GDateYear y
</FUNCTION>
<FUNCTION>
<NAME>g_date_set_julian</NAME>
<RETURNS>void </RETURNS>
GDate *date,guint32 julian_date
</FUNCTION>
<FUNCTION>
<NAME>g_date_is_first_of_month</NAME>
<RETURNS>gboolean </RETURNS>
GDate *date
</FUNCTION>
<FUNCTION>
<NAME>g_date_is_last_of_month</NAME>
<RETURNS>gboolean </RETURNS>
GDate *date
</FUNCTION>
<FUNCTION>
<NAME>g_date_add_days</NAME>
<RETURNS>void </RETURNS>
GDate *date,guint n_days
</FUNCTION>
<FUNCTION>
<NAME>g_date_subtract_days</NAME>
<RETURNS>void </RETURNS>
GDate *date,guint n_days
</FUNCTION>
<FUNCTION>
<NAME>g_date_add_months</NAME>
<RETURNS>void </RETURNS>
GDate *date,guint n_months
</FUNCTION>
<FUNCTION>
<NAME>g_date_subtract_months</NAME>
<RETURNS>void </RETURNS>
GDate *date,guint n_months
</FUNCTION>
<FUNCTION>
<NAME>g_date_add_years</NAME>
<RETURNS>void </RETURNS>
GDate *date,guint n_years
</FUNCTION>
<FUNCTION>
<NAME>g_date_subtract_years</NAME>
<RETURNS>void </RETURNS>
GDate *date,guint n_years
</FUNCTION>
<FUNCTION>
<NAME>g_date_is_leap_year</NAME>
<RETURNS>gboolean </RETURNS>
GDateYear year
</FUNCTION>
<FUNCTION>
<NAME>g_date_days_in_month</NAME>
<RETURNS>guint8 </RETURNS>
GDateMonth month,GDateYear year
</FUNCTION>
<FUNCTION>
<NAME>g_date_monday_weeks_in_year</NAME>
<RETURNS>guint8 </RETURNS>
GDateYear year
</FUNCTION>
<FUNCTION>
<NAME>g_date_sunday_weeks_in_year</NAME>
<RETURNS>guint8 </RETURNS>
GDateYear year
</FUNCTION>
<FUNCTION>
<NAME>g_date_compare</NAME>
<RETURNS>gint </RETURNS>
GDate *lhs,GDate *rhs
</FUNCTION>
<FUNCTION>
<NAME>g_date_to_struct_tm</NAME>
<RETURNS>void </RETURNS>
GDate *date,struct tm *tm
</FUNCTION>
<FUNCTION>
<NAME>g_date_strftime</NAME>
<RETURNS>gsize </RETURNS>
gchar *s,gsize slen,const gchar *format,GDate *date
</FUNCTION>
<FUNCTION>
<NAME>g_relation_new</NAME>
<RETURNS>GRelation *</RETURNS>
gint fields
</FUNCTION>
<FUNCTION>
<NAME>g_relation_destroy</NAME>
<RETURNS>void </RETURNS>
GRelation *relation
</FUNCTION>
<FUNCTION>
<NAME>g_relation_index</NAME>
<RETURNS>void </RETURNS>
GRelation *relation,gint field,GHashFunc hash_func,GCompareFunc key_compare_func
</FUNCTION>
<FUNCTION>
<NAME>g_relation_insert</NAME>
<RETURNS>void </RETURNS>
GRelation *relation,...
</FUNCTION>
<FUNCTION>
<NAME>g_relation_delete</NAME>
<RETURNS>gint </RETURNS>
GRelation *relation,gconstpointer key,gint field
</FUNCTION>
<FUNCTION>
<NAME>g_relation_select</NAME>
<RETURNS>GTuples *</RETURNS>
GRelation *relation,gconstpointer key,gint field
</FUNCTION>
<FUNCTION>
<NAME>g_relation_count</NAME>
<RETURNS>gint </RETURNS>
GRelation *relation,gconstpointer key,gint field
</FUNCTION>
<FUNCTION>
<NAME>g_relation_exists</NAME>
<RETURNS>gboolean </RETURNS>
GRelation *relation,...
</FUNCTION>
<FUNCTION>
<NAME>g_relation_print</NAME>
<RETURNS>void </RETURNS>
GRelation *relation
</FUNCTION>
<FUNCTION>
<NAME>g_tuples_destroy</NAME>
<RETURNS>void </RETURNS>
GTuples *tuples
</FUNCTION>
<FUNCTION>
<NAME>g_tuples_index</NAME>
<RETURNS>gpointer </RETURNS>
GTuples *tuples,gint index,gint field
</FUNCTION>
<FUNCTION>
<NAME>g_spaced_primes_closest</NAME>
<RETURNS>guint </RETURNS>
guint num
</FUNCTION>
<STRUCT>
<NAME>GIOFuncs</NAME>
</STRUCT>
<ENUM>
<NAME>GIOError</NAME>
typedef enum
{
G_IO_ERROR_NONE,
G_IO_ERROR_AGAIN,
G_IO_ERROR_INVAL,
G_IO_ERROR_UNKNOWN
} GIOError;
</ENUM>
<ENUM>
<NAME>GSeekType</NAME>
typedef enum
{
G_SEEK_CUR,
G_SEEK_SET,
G_SEEK_END
} GSeekType;
</ENUM>
<ENUM>
<NAME>GIOCondition</NAME>
typedef enum
{
G_IO_IN GLIB_SYSDEF_POLLIN,
G_IO_OUT GLIB_SYSDEF_POLLOUT,
G_IO_PRI GLIB_SYSDEF_POLLPRI,
G_IO_ERR GLIB_SYSDEF_POLLERR,
G_IO_HUP GLIB_SYSDEF_POLLHUP,
G_IO_NVAL GLIB_SYSDEF_POLLNVAL
} GIOCondition;
</ENUM>
<STRUCT>
<NAME>GIOChannel</NAME>
struct GIOChannel
{
guint channel_flags;
guint ref_count;
GIOFuncs *funcs;
};
</STRUCT>
<USER_FUNCTION>
<NAME>GIOFunc</NAME>
<RETURNS>gboolean </RETURNS>
GIOChannel *source,
GIOCondition condition,
gpointer data
</USER_FUNCTION>
<STRUCT>
<NAME>GIOFuncs</NAME>
struct GIOFuncs
{
GIOError (*io_read) (GIOChannel *channel,
gchar *buf,
guint count,
guint *bytes_read);
GIOError (*io_write) (GIOChannel *channel,
gchar *buf,
guint count,
guint *bytes_written);
GIOError (*io_seek) (GIOChannel *channel,
gint offset,
GSeekType type);
void (*io_close) (GIOChannel *channel);
guint (*io_add_watch) (GIOChannel *channel,
gint priority,
GIOCondition condition,
GIOFunc func,
gpointer user_data,
GDestroyNotify notify);
void (*io_free) (GIOChannel *channel);
};
</STRUCT>
<FUNCTION>
<NAME>g_io_channel_init</NAME>
<RETURNS>void </RETURNS>
GIOChannel *channel
</FUNCTION>
<FUNCTION>
<NAME>g_io_channel_ref</NAME>
<RETURNS>void </RETURNS>
GIOChannel *channel
</FUNCTION>
<FUNCTION>
<NAME>g_io_channel_unref</NAME>
<RETURNS>void </RETURNS>
GIOChannel *channel
</FUNCTION>
<FUNCTION>
<NAME>g_io_channel_read</NAME>
<RETURNS>GIOError </RETURNS>
GIOChannel *channel,gchar *buf,guint count,guint *bytes_read
</FUNCTION>
<FUNCTION>
<NAME>g_io_channel_write</NAME>
<RETURNS>GIOError </RETURNS>
GIOChannel *channel,gchar *buf,guint count,guint *bytes_written
</FUNCTION>
<FUNCTION>
<NAME>g_io_channel_seek</NAME>
<RETURNS>GIOError </RETURNS>
GIOChannel *channel,gint offset,GSeekType type
</FUNCTION>
<FUNCTION>
<NAME>g_io_channel_close</NAME>
<RETURNS>void </RETURNS>
GIOChannel *channel
</FUNCTION>
<FUNCTION>
<NAME>g_io_add_watch_full</NAME>
<RETURNS>guint </RETURNS>
GIOChannel *channel,gint priority,GIOCondition condition,GIOFunc func,gpointer user_data,GDestroyNotify notify
</FUNCTION>
<FUNCTION>
<NAME>g_io_add_watch</NAME>
<RETURNS>guint </RETURNS>
GIOChannel *channel,GIOCondition condition,GIOFunc func,gpointer user_data
</FUNCTION>
<STRUCT>
<NAME>GTimeVal</NAME>
</STRUCT>
<STRUCT>
<NAME>GSourceFuncs</NAME>
</STRUCT>
<STRUCT>
<NAME>GMainLoop</NAME>
</STRUCT>
<STRUCT>
<NAME>GTimeVal</NAME>
struct GTimeVal
{
glong tv_sec;
glong tv_usec;
};
</STRUCT>
<STRUCT>
<NAME>GSourceFuncs</NAME>
struct GSourceFuncs
{
gboolean (*prepare) (gpointer source_data,
GTimeVal *current_time,
gint *timeout,
gpointer user_data);
gboolean (*check) (gpointer source_data,
GTimeVal *current_time,
gpointer user_data);
gboolean (*dispatch) (gpointer source_data,
GTimeVal *current_time,
gpointer user_data);
GDestroyNotify destroy;
};
</STRUCT>
<MACRO>
<NAME>G_PRIORITY_HIGH</NAME>
#define G_PRIORITY_HIGH -100
</MACRO>
<MACRO>
<NAME>G_PRIORITY_DEFAULT</NAME>
#define G_PRIORITY_DEFAULT 0
</MACRO>
<MACRO>
<NAME>G_PRIORITY_HIGH_IDLE</NAME>
#define G_PRIORITY_HIGH_IDLE 100
</MACRO>
<MACRO>
<NAME>G_PRIORITY_DEFAULT_IDLE</NAME>
#define G_PRIORITY_DEFAULT_IDLE 200
</MACRO>
<MACRO>
<NAME>G_PRIORITY_LOW</NAME>
#define G_PRIORITY_LOW 300
</MACRO>
<USER_FUNCTION>
<NAME>GSourceFunc</NAME>
<RETURNS>gboolean </RETURNS>
gpointer data
</USER_FUNCTION>
<FUNCTION>
<NAME>g_source_add</NAME>
<RETURNS>guint </RETURNS>
gint priority,gboolean can_recurse,GSourceFuncs *funcs,gpointer source_data,gpointer user_data,GDestroyNotify notify
</FUNCTION>
<FUNCTION>
<NAME>g_source_remove</NAME>
<RETURNS>gboolean </RETURNS>
guint tag
</FUNCTION>
<FUNCTION>
<NAME>g_source_remove_by_user_data</NAME>
<RETURNS>gboolean </RETURNS>
gpointer user_data
</FUNCTION>
<FUNCTION>
<NAME>g_source_remove_by_source_data</NAME>
<RETURNS>gboolean </RETURNS>
gpointer source_data
</FUNCTION>
<FUNCTION>
<NAME>g_source_remove_by_funcs_user_data</NAME>
<RETURNS>gboolean </RETURNS>
GSourceFuncs *funcs,gpointer user_data
</FUNCTION>
<FUNCTION>
<NAME>g_get_current_time</NAME>
<RETURNS>void </RETURNS>
GTimeVal *result
</FUNCTION>
<FUNCTION>
<NAME>g_main_new</NAME>
<RETURNS>GMainLoop *</RETURNS>
gboolean is_running
</FUNCTION>
<FUNCTION>
<NAME>g_main_run</NAME>
<RETURNS>void </RETURNS>
GMainLoop *loop
</FUNCTION>
<FUNCTION>
<NAME>g_main_quit</NAME>
<RETURNS>void </RETURNS>
GMainLoop *loop
</FUNCTION>
<FUNCTION>
<NAME>g_main_destroy</NAME>
<RETURNS>void </RETURNS>
GMainLoop *loop
</FUNCTION>
<FUNCTION>
<NAME>g_main_is_running</NAME>
<RETURNS>gboolean </RETURNS>
GMainLoop *loop
</FUNCTION>
<FUNCTION>
<NAME>g_main_iteration</NAME>
<RETURNS>gboolean </RETURNS>
gboolean may_block
</FUNCTION>
<FUNCTION>
<NAME>g_main_pending</NAME>
<RETURNS>gboolean </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>g_timeout_add_full</NAME>
<RETURNS>guint </RETURNS>
gint priority,guint interval,GSourceFunc function,gpointer data,GDestroyNotify notify
</FUNCTION>
<FUNCTION>
<NAME>g_timeout_add</NAME>
<RETURNS>guint </RETURNS>
guint interval,GSourceFunc function,gpointer data
</FUNCTION>
<FUNCTION>
<NAME>g_idle_add</NAME>
<RETURNS>guint </RETURNS>
GSourceFunc function,gpointer data
</FUNCTION>
<FUNCTION>
<NAME>g_idle_add_full</NAME>
<RETURNS>guint </RETURNS>
gint priority,GSourceFunc function,gpointer data,GDestroyNotify destroy
</FUNCTION>
<FUNCTION>
<NAME>g_idle_remove_by_data</NAME>
<RETURNS>gboolean </RETURNS>
gpointer data
</FUNCTION>
<STRUCT>
<NAME>GPollFD</NAME>
</STRUCT>
<USER_FUNCTION>
<NAME>GPollFunc</NAME>
<RETURNS>gint </RETURNS>
GPollFD *ufds,
guint nfsd,
gint timeout
</USER_FUNCTION>
<STRUCT>
<NAME>GPollFD</NAME>
struct GPollFD
{
gint fd;
gushort events;
gushort revents;
};
</STRUCT>
<FUNCTION>
<NAME>g_main_add_poll</NAME>
<RETURNS>void </RETURNS>
GPollFD *fd,gint priority
</FUNCTION>
<FUNCTION>
<NAME>g_main_remove_poll</NAME>
<RETURNS>void </RETURNS>
GPollFD *fd
</FUNCTION>
<FUNCTION>
<NAME>g_main_set_poll_func</NAME>
<RETURNS>void </RETURNS>
GPollFunc func
</FUNCTION>
<FUNCTION>
<NAME>g_io_channel_unix_new</NAME>
<RETURNS>GIOChannel *</RETURNS>
int fd
</FUNCTION>
<FUNCTION>
<NAME>g_io_channel_unix_get_fd</NAME>
<RETURNS>gint </RETURNS>
GIOChannel *channel
</FUNCTION>
<MACRO>
<NAME>G_WIN32_MSG_HANDLE</NAME>
#define G_WIN32_MSG_HANDLE 19981206
</MACRO>
<FUNCTION>
<NAME>g_main_poll_win32_msg_add</NAME>
<RETURNS>void </RETURNS>
gint priority,GPollFD *fd,guint hwnd
</FUNCTION>
<FUNCTION>
<NAME>g_io_channel_win32_new_messages</NAME>
<RETURNS>GIOChannel *</RETURNS>
guint hwnd
</FUNCTION>
<FUNCTION>
<NAME>g_io_channel_win32_new_pipe</NAME>
<RETURNS>GIOChannel *</RETURNS>
int fd
</FUNCTION>
<FUNCTION>
<NAME>g_io_channel_win32_new_pipe_with_wakeups</NAME>
<RETURNS>GIOChannel *</RETURNS>
int fd,guint peer,int peer_fd
</FUNCTION>
<FUNCTION>
<NAME>g_io_channel_win32_pipe_request_wakeups</NAME>
<RETURNS>void </RETURNS>
GIOChannel *channel,guint peer,int peer_fd
</FUNCTION>
<FUNCTION>
<NAME>g_io_channel_win32_pipe_readable</NAME>
<RETURNS>void </RETURNS>
int fd,guint offset
</FUNCTION>
<FUNCTION>
<NAME>g_io_channel_win32_get_fd</NAME>
<RETURNS>gint </RETURNS>
GIOChannel *channel
</FUNCTION>
<FUNCTION>
<NAME>g_io_channel_win32_new_stream_socket</NAME>
<RETURNS>GIOChannel *</RETURNS>
int socket
</FUNCTION>
<MACRO>
<NAME>MAXPATHLEN</NAME>
# define MAXPATHLEN 1024
</MACRO>
<TYPEDEF>
<NAME>pid_t</NAME>
typedef int pid_t;
</TYPEDEF>
<MACRO>
<NAME>getcwd</NAME>
# define getcwd _getcwd
</MACRO>
<MACRO>
<NAME>getpid</NAME>
# define getpid _getpid
</MACRO>
<MACRO>
<NAME>access</NAME>
# define access _access
</MACRO>
<MACRO>
<NAME>open</NAME>
# define open _open
</MACRO>
<MACRO>
<NAME>read</NAME>
# define read _read
</MACRO>
<MACRO>
<NAME>write</NAME>
# define write _write
</MACRO>
<MACRO>
<NAME>lseek</NAME>
# define lseek _lseek
</MACRO>
<MACRO>
<NAME>close</NAME>
# define close _close
</MACRO>
<MACRO>
<NAME>pipe</NAME>
# define pipe(phandles) _pipe (phandles, 4096, _O_BINARY)
</MACRO>
<MACRO>
<NAME>popen</NAME>
# define popen _popen
</MACRO>
<MACRO>
<NAME>pclose</NAME>
# define pclose _pclose
</MACRO>
<MACRO>
<NAME>fdopen</NAME>
# define fdopen _fdopen
</MACRO>
<MACRO>
<NAME>ftruncate</NAME>
# define ftruncate(fd, size) gwin_ftruncate (fd, size)
</MACRO>
<MACRO>
<NAME>opendir</NAME>
# define opendir gwin_opendir
</MACRO>
<MACRO>
<NAME>readdir</NAME>
# define readdir gwin_readdir
</MACRO>
<MACRO>
<NAME>rewinddir</NAME>
# define rewinddir gwin_rewinddir
</MACRO>
<MACRO>
<NAME>closedir</NAME>
# define closedir gwin_closedir
</MACRO>
<MACRO>
<NAME>NAME_MAX</NAME>
# define NAME_MAX 255
</MACRO>
<FUNCTION>
<NAME>gwin_ftruncate</NAME>
<RETURNS>int </RETURNS>
gint f,guint size
</FUNCTION>
<FUNCTION>
<NAME>gwin_opendir</NAME>
<RETURNS>DIR *</RETURNS>
const gchar *dirname
</FUNCTION>
<FUNCTION>
<NAME>gwin_rewinddir</NAME>
<RETURNS>void </RETURNS>
DIR *dir
</FUNCTION>
<FUNCTION>
<NAME>gwin_closedir</NAME>
<RETURNS>gint </RETURNS>
DIR *dir
</FUNCTION>
<STRUCT>
<NAME>GMutex</NAME>
</STRUCT>
<STRUCT>
<NAME>GCond</NAME>
</STRUCT>
<STRUCT>
<NAME>GPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GStaticPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GThreadFunctions</NAME>
</STRUCT>
<STRUCT>
<NAME>GThreadFunctions</NAME>
struct GThreadFunctions
{
GMutex* (*mutex_new) (void);
void (*mutex_lock) (GMutex *mutex);
gboolean (*mutex_trylock) (GMutex *mutex);
void (*mutex_unlock) (GMutex *mutex);
void (*mutex_free) (GMutex *mutex);
GCond* (*cond_new) (void);
void (*cond_signal) (GCond *cond);
void (*cond_broadcast) (GCond *cond);
void (*cond_wait) (GCond *cond,
GMutex *mutex);
gboolean (*cond_timed_wait) (GCond *cond,
GMutex *mutex,
GTimeVal *end_time);
void (*cond_free) (GCond *cond);
GPrivate* (*private_new) (GDestroyNotify destructor);
gpointer (*private_get) (GPrivate *private_key);
void (*private_set) (GPrivate *private_key,
gpointer data);
};
</STRUCT>
<FUNCTION>
<NAME>g_thread_init</NAME>
<RETURNS>void </RETURNS>
GThreadFunctions *vtable
</FUNCTION>
<FUNCTION>
<NAME>g_static_mutex_get_mutex_impl</NAME>
<RETURNS>GMutex *</RETURNS>
GMutex **mutex
</FUNCTION>
<MACRO>
<NAME>G_THREAD_UF</NAME>
#define G_THREAD_UF(name, arglist) \
(*g_thread_functions_for_glib_use . name) arglist
</MACRO>
<MACRO>
<NAME>G_THREAD_CF</NAME>
#define G_THREAD_CF(name, fail, arg) \
(g_thread_supported () ? G_THREAD_UF (name, arg) : (fail))
</MACRO>
<MACRO>
<NAME>g_thread_supported</NAME>
#define g_thread_supported() (g_threads_got_initialized)
</MACRO>
<MACRO>
<NAME>g_mutex_new</NAME>
#define g_mutex_new() G_THREAD_UF (mutex_new, ())
</MACRO>
<MACRO>
<NAME>g_mutex_lock</NAME>
#define g_mutex_lock(mutex) G_THREAD_CF (mutex_lock, (void)0, (mutex))
</MACRO>
<MACRO>
<NAME>g_mutex_trylock</NAME>
#define g_mutex_trylock(mutex) G_THREAD_CF (mutex_trylock, TRUE, (mutex))
</MACRO>
<MACRO>
<NAME>g_mutex_unlock</NAME>
#define g_mutex_unlock(mutex) G_THREAD_CF (mutex_unlock, (void)0, (mutex))
</MACRO>
<MACRO>
<NAME>g_mutex_free</NAME>
#define g_mutex_free(mutex) G_THREAD_CF (mutex_free, (void)0, (mutex))
</MACRO>
<MACRO>
<NAME>g_cond_new</NAME>
#define g_cond_new() G_THREAD_UF (cond_new, ())
</MACRO>
<MACRO>
<NAME>g_cond_signal</NAME>
#define g_cond_signal(cond) G_THREAD_CF (cond_signal, (void)0, (cond))
</MACRO>
<MACRO>
<NAME>g_cond_broadcast</NAME>
#define g_cond_broadcast(cond) G_THREAD_CF (cond_broadcast, (void)0, (cond))
</MACRO>
<MACRO>
<NAME>g_cond_wait</NAME>
#define g_cond_wait(cond, mutex) G_THREAD_CF (cond_wait, (void)0, (cond, \
mutex))
</MACRO>
<MACRO>
<NAME>g_cond_free</NAME>
#define g_cond_free(cond) G_THREAD_CF (cond_free, (void)0, (cond))
</MACRO>
<MACRO>
<NAME>g_cond_timed_wait</NAME>
#define g_cond_timed_wait(cond, mutex, abs_time) G_THREAD_CF (cond_timed_wait, \
TRUE, \
(cond, mutex, \
abs_time))
</MACRO>
<MACRO>
<NAME>g_private_new</NAME>
#define g_private_new(destructor) G_THREAD_UF (private_new, (destructor))
</MACRO>
<MACRO>
<NAME>g_private_get</NAME>
#define g_private_get(private_key) G_THREAD_CF (private_get, \
((gpointer)private_key), \
(private_key))
</MACRO>
<MACRO>
<NAME>g_private_set</NAME>
#define g_private_set(private_key, value) G_THREAD_CF (private_set, \
(void) (private_key = \
(GPrivate*) (value)), \
(private_key, value))
</MACRO>
<MACRO>
<NAME>g_static_mutex_lock</NAME>
#define g_static_mutex_lock(mutex) \
g_mutex_lock (g_static_mutex_get_mutex (mutex))
</MACRO>
<MACRO>
<NAME>g_static_mutex_trylock</NAME>
#define g_static_mutex_trylock(mutex) \
g_mutex_trylock (g_static_mutex_get_mutex (mutex))
</MACRO>
<MACRO>
<NAME>g_static_mutex_unlock</NAME>
#define g_static_mutex_unlock(mutex) \
g_mutex_unlock (g_static_mutex_get_mutex (mutex))
</MACRO>
<STRUCT>
<NAME>GStaticPrivate</NAME>
struct GStaticPrivate
{
guint index;
};
</STRUCT>
<MACRO>
<NAME>G_STATIC_PRIVATE_INIT</NAME>
#define G_STATIC_PRIVATE_INIT { 0 }
</MACRO>
<FUNCTION>
<NAME>g_static_private_get</NAME>
<RETURNS>gpointer </RETURNS>
GStaticPrivate *private_key
</FUNCTION>
<FUNCTION>
<NAME>g_static_private_set</NAME>
<RETURNS>void </RETURNS>
GStaticPrivate *private_key,gpointer data,GDestroyNotify notify
</FUNCTION>
<FUNCTION>
<NAME>glib_dummy_decl</NAME>
<RETURNS>void </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>G_LOCK_NAME</NAME>
#define G_LOCK_NAME(name) (g__ ## name ## _lock)
</MACRO>
<MACRO>
<NAME>G_LOCK_DEFINE_STATIC</NAME>
# define G_LOCK_DEFINE_STATIC(name) static G_LOCK_DEFINE (name)
</MACRO>
<MACRO>
<NAME>G_LOCK_DEFINE</NAME>
# define G_LOCK_DEFINE(name) \
GStaticMutex G_LOCK_NAME (name) = G_STATIC_MUTEX_INIT
</MACRO>
<MACRO>
<NAME>G_LOCK_EXTERN</NAME>
# define G_LOCK_EXTERN(name) extern GStaticMutex G_LOCK_NAME (name)
</MACRO>
<MACRO>
<NAME>G_LOCK</NAME>
# define G_LOCK(name) G_STMT_START{ \
g_log (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, \
"file %s: line %d (%s): locking: %s ", \
__FILE__, __LINE__, G_GNUC_PRETTY_FUNCTION, \
#name); \
g_static_mutex_lock (&G_LOCK_NAME (name)); \
}G_STMT_END
</MACRO>
<MACRO>
<NAME>G_UNLOCK</NAME>
# define G_UNLOCK(name) G_STMT_START{ \
g_log (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, \
"file %s: line %d (%s): unlocking: %s ", \
__FILE__, __LINE__, G_GNUC_PRETTY_FUNCTION, \
#name); \
g_static_mutex_unlock (&G_LOCK_NAME (name)); \
}G_STMT_END
</MACRO>
<MACRO>
<NAME>G_TRYLOCK</NAME>
# define G_TRYLOCK(name) G_STMT_START{ \
g_log (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, \
"file %s: line %d (%s): try locking: %s ", \
__FILE__, __LINE__, G_GNUC_PRETTY_FUNCTION, \
#name); \
}G_STMT_END, g_static_mutex_trylock (&G_LOCK_NAME (name))
</MACRO>
<MACRO>
<NAME>G_LOCK</NAME>
# define G_LOCK(name) g_static_mutex_lock (&G_LOCK_NAME (name))
</MACRO>
<MACRO>
<NAME>G_UNLOCK</NAME>
# define G_UNLOCK(name) g_static_mutex_unlock (&G_LOCK_NAME (name))
</MACRO>
<MACRO>
<NAME>G_TRYLOCK</NAME>
# define G_TRYLOCK(name) g_static_mutex_trylock (&G_LOCK_NAME (name))
</MACRO>
<MACRO>
<NAME>G_LOCK_DEFINE_STATIC</NAME>
# define G_LOCK_DEFINE_STATIC(name) extern void glib_dummy_decl (void)
</MACRO>
<MACRO>
<NAME>G_LOCK_DEFINE</NAME>
# define G_LOCK_DEFINE(name) extern void glib_dummy_decl (void)
</MACRO>
<MACRO>
<NAME>G_LOCK_EXTERN</NAME>
# define G_LOCK_EXTERN(name) extern void glib_dummy_decl (void)
</MACRO>
<MACRO>
<NAME>G_LOCK</NAME>
# define G_LOCK(name)
</MACRO>
<MACRO>
<NAME>G_UNLOCK</NAME>
# define G_UNLOCK(name)
</MACRO>
<MACRO>
<NAME>G_TRYLOCK</NAME>
# define G_TRYLOCK(name) (FALSE)
</MACRO>
<VARIABLE>
<NAME>g_log_domain_gmodule</NAME>
extern const char *g_log_domain_gmodule;
</VARIABLE>
<MACRO>
<NAME>G_MODULE_IMPORT</NAME>
#define G_MODULE_IMPORT extern
</MACRO>
<MACRO>
<NAME>G_MODULE_EXPORT</NAME>
# define G_MODULE_EXPORT __declspec(dllexport)
</MACRO>
<MACRO>
<NAME>G_MODULE_EXPORT</NAME>
# define G_MODULE_EXPORT
</MACRO>
<ENUM>
<NAME>GModuleFlags</NAME>
typedef enum
{
G_MODULE_BIND_LAZY = 1 << 0,
G_MODULE_BIND_MASK = 0x01
} GModuleFlags;
</ENUM>
<STRUCT>
<NAME>GModule</NAME>
</STRUCT>
<USER_FUNCTION>
<NAME>GModuleCheckInit</NAME>
<RETURNS>const gchar *</RETURNS>
GModule *module
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GModuleUnload</NAME>
<RETURNS>void </RETURNS>
GModule *module
</USER_FUNCTION>
<FUNCTION>
<NAME>g_module_supported</NAME>
<RETURNS>gboolean </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>g_module_open</NAME>
<RETURNS>GModule *</RETURNS>
const gchar *file_name,GModuleFlags flags
</FUNCTION>
<FUNCTION>
<NAME>g_module_close</NAME>
<RETURNS>gboolean </RETURNS>
GModule *module
</FUNCTION>
<FUNCTION>
<NAME>g_module_make_resident</NAME>
<RETURNS>void </RETURNS>
GModule *module
</FUNCTION>
<FUNCTION>
<NAME>g_module_error</NAME>
<RETURNS>gchar *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>g_module_symbol</NAME>
<RETURNS>gboolean </RETURNS>
GModule *module,const gchar *symbol_name,gpointer *symbol
</FUNCTION>
<FUNCTION>
<NAME>g_module_name</NAME>
<RETURNS>gchar *</RETURNS>
GModule *module
</FUNCTION>
<FUNCTION>
<NAME>g_module_build_path</NAME>
<RETURNS>gchar *</RETURNS>
const gchar *directory,const gchar *module_name
</FUNCTION>
<MACRO>
<NAME>GLIB_HAVE_SYS_POLL_H</NAME>
#define GLIB_HAVE_SYS_POLL_H
</MACRO>
<MACRO>
<NAME>G_MINFLOAT</NAME>
#define G_MINFLOAT FLT_MIN
</MACRO>
<MACRO>
<NAME>G_MAXFLOAT</NAME>
#define G_MAXFLOAT FLT_MAX
</MACRO>
<MACRO>
<NAME>G_MINDOUBLE</NAME>
#define G_MINDOUBLE DBL_MIN
</MACRO>
<MACRO>
<NAME>G_MAXDOUBLE</NAME>
#define G_MAXDOUBLE DBL_MAX
</MACRO>
<MACRO>
<NAME>G_MINSHORT</NAME>
#define G_MINSHORT SHRT_MIN
</MACRO>
<MACRO>
<NAME>G_MAXSHORT</NAME>
#define G_MAXSHORT SHRT_MAX
</MACRO>
<MACRO>
<NAME>G_MININT</NAME>
#define G_MININT INT_MIN
</MACRO>
<MACRO>
<NAME>G_MAXINT</NAME>
#define G_MAXINT INT_MAX
</MACRO>
<MACRO>
<NAME>G_MINLONG</NAME>
#define G_MINLONG LONG_MIN
</MACRO>
<MACRO>
<NAME>G_MAXLONG</NAME>
#define G_MAXLONG LONG_MAX
</MACRO>
<TYPEDEF>
<NAME>gint8</NAME>
typedef signed char gint8;
</TYPEDEF>
<TYPEDEF>
<NAME>guint8</NAME>
typedef unsigned char guint8;
</TYPEDEF>
<TYPEDEF>
<NAME>gint16</NAME>
typedef signed short gint16;
</TYPEDEF>
<TYPEDEF>
<NAME>guint16</NAME>
typedef unsigned short guint16;
</TYPEDEF>
<TYPEDEF>
<NAME>gint32</NAME>
typedef signed int gint32;
</TYPEDEF>
<TYPEDEF>
<NAME>guint32</NAME>
typedef unsigned int guint32;
</TYPEDEF>
<MACRO>
<NAME>G_GNUC_EXTENSION</NAME>
# define G_GNUC_EXTENSION __extension__
</MACRO>
<MACRO>
<NAME>G_GNUC_EXTENSION</NAME>
# define G_GNUC_EXTENSION
</MACRO>
<MACRO>
<NAME>G_HAVE_GINT64</NAME>
#define G_HAVE_GINT64 1
</MACRO>
<TYPEDEF>
<NAME>gint64</NAME>
G_GNUC_EXTENSION typedef signed long long gint64;
</TYPEDEF>
<TYPEDEF>
<NAME>guint64</NAME>
G_GNUC_EXTENSION typedef unsigned long long guint64;
</TYPEDEF>
<MACRO>
<NAME>G_GINT64_CONSTANT</NAME>
#define G_GINT64_CONSTANT(val) (G_GNUC_EXTENSION (val##LL))
</MACRO>
<MACRO>
<NAME>GPOINTER_TO_INT</NAME>
#define GPOINTER_TO_INT(p) ((gint) (p))
</MACRO>
<MACRO>
<NAME>GPOINTER_TO_UINT</NAME>
#define GPOINTER_TO_UINT(p) ((guint) (p))
</MACRO>
<MACRO>
<NAME>GINT_TO_POINTER</NAME>
#define GINT_TO_POINTER(i) ((gpointer) (i))
</MACRO>
<MACRO>
<NAME>GUINT_TO_POINTER</NAME>
#define GUINT_TO_POINTER(u) ((gpointer) (u))
</MACRO>
<MACRO>
<NAME>g_ATEXIT</NAME>
# define g_ATEXIT(proc) (!atexit (proc))
</MACRO>
<MACRO>
<NAME>g_ATEXIT</NAME>
# define g_ATEXIT(proc) (atexit (proc))
</MACRO>
<MACRO>
<NAME>g_memmove</NAME>
#define g_memmove(d,s,n) G_STMT_START { memmove ((d), (s), (n)); } G_STMT_END
</MACRO>
<MACRO>
<NAME>GLIB_MAJOR_VERSION</NAME>
#define GLIB_MAJOR_VERSION 1
</MACRO>
<MACRO>
<NAME>GLIB_MINOR_VERSION</NAME>
#define GLIB_MINOR_VERSION 2
</MACRO>
<MACRO>
<NAME>GLIB_MICRO_VERSION</NAME>
#define GLIB_MICRO_VERSION 3
</MACRO>
<MACRO>
<NAME>G_HAVE_INLINE</NAME>
#define G_HAVE_INLINE 1
</MACRO>
<MACRO>
<NAME>G_HAVE_INLINE</NAME>
#define G_HAVE_INLINE 1
</MACRO>
<MACRO>
<NAME>G_HAVE___INLINE</NAME>
#define G_HAVE___INLINE 1
</MACRO>
<MACRO>
<NAME>G_HAVE___INLINE__</NAME>
#define G_HAVE___INLINE__ 1
</MACRO>
<MACRO>
<NAME>G_THREADS_ENABLED</NAME>
#define G_THREADS_ENABLED
</MACRO>
<MACRO>
<NAME>G_THREADS_IMPL_POSIX</NAME>
#define G_THREADS_IMPL_POSIX
</MACRO>
<STRUCT>
<NAME>GStaticMutex</NAME>
</STRUCT>
<STRUCT>
<NAME>GStaticMutex</NAME>
struct GStaticMutex
{
struct _GMutex *runtime_mutex;
union {
char pad[24];
double dummy_double;
void *dummy_pointer;
long dummy_long;
} aligned_pad_u;
};
</STRUCT>
<MACRO>
<NAME>G_STATIC_MUTEX_INIT</NAME>
#define G_STATIC_MUTEX_INIT { NULL, { { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0} } }
</MACRO>
<MACRO>
<NAME>g_static_mutex_get_mutex</NAME>
#define g_static_mutex_get_mutex(mutex) (g_thread_use_default_impl ? ((GMutex*) &((mutex)->aligned_pad_u)) : g_static_mutex_get_mutex_impl (&((mutex)->runtime_mutex)))
</MACRO>
<MACRO>
<NAME>GINT16_TO_LE</NAME>
#define GINT16_TO_LE(val) ((gint16) (val))
</MACRO>
<MACRO>
<NAME>GUINT16_TO_LE</NAME>
#define GUINT16_TO_LE(val) ((guint16) (val))
</MACRO>
<MACRO>
<NAME>GINT16_TO_BE</NAME>
#define GINT16_TO_BE(val) ((gint16) GUINT16_SWAP_LE_BE (val))
</MACRO>
<MACRO>
<NAME>GUINT16_TO_BE</NAME>
#define GUINT16_TO_BE(val) (GUINT16_SWAP_LE_BE (val))
</MACRO>
<MACRO>
<NAME>GINT32_TO_LE</NAME>
#define GINT32_TO_LE(val) ((gint32) (val))
</MACRO>
<MACRO>
<NAME>GUINT32_TO_LE</NAME>
#define GUINT32_TO_LE(val) ((guint32) (val))
</MACRO>
<MACRO>
<NAME>GINT32_TO_BE</NAME>
#define GINT32_TO_BE(val) ((gint32) GUINT32_SWAP_LE_BE (val))
</MACRO>
<MACRO>
<NAME>GUINT32_TO_BE</NAME>
#define GUINT32_TO_BE(val) (GUINT32_SWAP_LE_BE (val))
</MACRO>
<MACRO>
<NAME>GINT64_TO_LE</NAME>
#define GINT64_TO_LE(val) ((gint64) (val))
</MACRO>
<MACRO>
<NAME>GUINT64_TO_LE</NAME>
#define GUINT64_TO_LE(val) ((guint64) (val))
</MACRO>
<MACRO>
<NAME>GINT64_TO_BE</NAME>
#define GINT64_TO_BE(val) ((gint64) GUINT64_SWAP_LE_BE (val))
</MACRO>
<MACRO>
<NAME>GUINT64_TO_BE</NAME>
#define GUINT64_TO_BE(val) (GUINT64_SWAP_LE_BE (val))
</MACRO>
<MACRO>
<NAME>GLONG_TO_LE</NAME>
#define GLONG_TO_LE(val) ((glong) GINT32_TO_LE (val))
</MACRO>
<MACRO>
<NAME>GULONG_TO_LE</NAME>
#define GULONG_TO_LE(val) ((gulong) GUINT32_TO_LE (val))
</MACRO>
<MACRO>
<NAME>GLONG_TO_BE</NAME>
#define GLONG_TO_BE(val) ((glong) GINT32_TO_BE (val))
</MACRO>
<MACRO>
<NAME>GULONG_TO_BE</NAME>
#define GULONG_TO_BE(val) ((gulong) GUINT32_TO_BE (val))
</MACRO>
<MACRO>
<NAME>GINT_TO_LE</NAME>
#define GINT_TO_LE(val) ((gint) GINT32_TO_LE (val))
</MACRO>
<MACRO>
<NAME>GUINT_TO_LE</NAME>
#define GUINT_TO_LE(val) ((guint) GUINT32_TO_LE (val))
</MACRO>
<MACRO>
<NAME>GINT_TO_BE</NAME>
#define GINT_TO_BE(val) ((gint) GINT32_TO_BE (val))
</MACRO>
<MACRO>
<NAME>GUINT_TO_BE</NAME>
#define GUINT_TO_BE(val) ((guint) GUINT32_TO_BE (val))
</MACRO>
<MACRO>
<NAME>G_BYTE_ORDER</NAME>
#define G_BYTE_ORDER G_LITTLE_ENDIAN
</MACRO>
<MACRO>
<NAME>GLIB_SYSDEF_POLLIN</NAME>
#define GLIB_SYSDEF_POLLIN =1
</MACRO>
<MACRO>
<NAME>GLIB_SYSDEF_POLLOUT</NAME>
#define GLIB_SYSDEF_POLLOUT =4
</MACRO>
<MACRO>
<NAME>GLIB_SYSDEF_POLLPRI</NAME>
#define GLIB_SYSDEF_POLLPRI =2
</MACRO>
<MACRO>
<NAME>GLIB_SYSDEF_POLLERR</NAME>
#define GLIB_SYSDEF_POLLERR =8
</MACRO>
<MACRO>
<NAME>GLIB_SYSDEF_POLLHUP</NAME>
#define GLIB_SYSDEF_POLLHUP =16
</MACRO>
<MACRO>
<NAME>GLIB_SYSDEF_POLLNVAL</NAME>
#define GLIB_SYSDEF_POLLNVAL =32
</MACRO>
<MACRO>
<NAME>G_HAVE_WCHAR_H</NAME>
#define G_HAVE_WCHAR_H 1
</MACRO>
<MACRO>
<NAME>G_HAVE_WCTYPE_H</NAME>
#define G_HAVE_WCTYPE_H 1
</MACRO>
Reference in New Issue View Git Blame Copy Permalink