WebSVN – Kolibri OS – Blame – /programs/develop/libraries/menuetlibc/include/glib/glib.h

Rev	Author	Line No.	Line
4973	right-hear	1	/* GLIB - Library of useful routines for C programming
		2	* Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
		3	*
		4	* This library is free software; you can redistribute it and/or
		5	* modify it under the terms of the GNU Library General Public
		6	* License as published by the Free Software Foundation; either
		7	* version 2 of the License, or (at your option) any later version.
		8	*
		9	* This library is distributed in the hope that it will be useful,
		10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
		11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
		12	* Library General Public License for more details.
		13	*
		14	* You should have received a copy of the GNU Library General Public
		15	* License along with this library; if not, write to the
		16	* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
		17	* Boston, MA 02111-1307, USA.
		18	*/
		19
		20	/*
		21	* Modified by the GLib Team and others 1997-1999. See the AUTHORS
		22	* file for a list of people on the GLib Team. See the ChangeLog
		23	* files for a list of changes. These files are distributed with
		24	* GLib at ftp://ftp.gtk.org/pub/gtk/.
		25	*/
		26
		27	#ifndef __G_LIB_H__
		28	#define __G_LIB_H__
		29
		30	/* system specific config file glibconfig.h provides definitions for
		31	* the extrema of many of the standard types. These are:
		32	*
		33	* G_MINSHORT, G_MAXSHORT
		34	* G_MININT, G_MAXINT
		35	* G_MINLONG, G_MAXLONG
		36	* G_MINFLOAT, G_MAXFLOAT
		37	* G_MINDOUBLE, G_MAXDOUBLE
		38	*
		39	* It also provides the following typedefs:
		40	*
		41	* gint8, guint8
		42	* gint16, guint16
		43	* gint32, guint32
		44	* gint64, guint64
		45	*
		46	* It defines the G_BYTE_ORDER symbol to one of G_*_ENDIAN (see later in
		47	* this file).
		48	*
		49	* And it provides a way to store and retrieve a `gint' in/from a `gpointer'.
		50	* This is useful to pass an integer instead of a pointer to a callback.
		51	*
		52	* GINT_TO_POINTER(i), GUINT_TO_POINTER(i)
		53	* GPOINTER_TO_INT(p), GPOINTER_TO_UINT(p)
		54	*
		55	* Finally, it provide the following wrappers to STDC functions:
		56	*
		57	* g_ATEXIT
		58	* To register hooks which are executed on exit().
		59	* Usually a wrapper for STDC atexit.
		60	*
		61	* void g_memmove(void dest, const void *src, guint count);
		62	* A wrapper for STDC memmove, or an implementation, if memmove doesn't
		63	* exist. The prototype looks like the above, give or take a const,
		64	* or size_t.
		65	*/
		66	#include
		67
		68	/* include varargs functions for assertment macros
		69	*/
		70	#include
		71
		72	/* optionally feature DMALLOC memory allocation debugger
		73	*/
		74	#ifdef USE_DMALLOC
		75	#include "dmalloc.h"
		76	#endif
		77
		78
		79	#ifdef NATIVE_WIN32
		80
		81	/* On native Win32, directory separator is the backslash, and search path
		82	* separator is the semicolon.
		83	*/
		84	#define G_DIR_SEPARATOR '\\'
		85	#define G_DIR_SEPARATOR_S "\\"
		86	#define G_SEARCHPATH_SEPARATOR ';'
		87	#define G_SEARCHPATH_SEPARATOR_S ";"
		88
		89	#else /* !NATIVE_WIN32 */
		90
		91	#ifndef __EMX__
		92	/* Unix */
		93
		94	#define G_DIR_SEPARATOR '/'
		95	#define G_DIR_SEPARATOR_S "/"
		96	#define G_SEARCHPATH_SEPARATOR ':'
		97	#define G_SEARCHPATH_SEPARATOR_S ":"
		98
		99	#else
		100	/* EMX/OS2 */
		101
		102	#define G_DIR_SEPARATOR '/'
		103	#define G_DIR_SEPARATOR_S "/"
		104	#define G_SEARCHPATH_SEPARATOR ';'
		105	#define G_SEARCHPATH_SEPARATOR_S ";"
		106
		107	#endif
		108
		109	#endif /* !NATIVE_WIN32 */
		110
		111	#ifdef __cplusplus
		112	extern "C" {
		113	#endif /* __cplusplus */
		114
		115
		116	/* Provide definitions for some commonly used macros.
		117	* Some of them are only provided if they haven't already
		118	* been defined. It is assumed that if they are already
		119	* defined then the current definition is correct.
		120	*/
		121	#ifndef NULL
		122	#define NULL ((void*) 0)
		123	#endif
		124
		125	#ifndef FALSE
		126	#define FALSE (0)
		127	#endif
		128
		129	#ifndef TRUE
		130	#define TRUE (!FALSE)
		131	#endif
		132
		133	#undef MAX
		134	#define MAX(a, b) (((a) > (b)) ? (a) : (b))
		135
		136	#undef MIN
		137	#define MIN(a, b) (((a) < (b)) ? (a) : (b))
		138
		139	#undef ABS
		140	#define ABS(a) (((a) < 0) ? -(a) : (a))
		141
		142	#undef CLAMP
		143	#define CLAMP(x, low, high) (((x) > (high)) ? (high) : (((x) < (low)) ? (low) : (x)))
		144
		145
		146	/* Define G_VA_COPY() to do the right thing for copying va_list variables.
		147	* glibconfig.h may have already defined G_VA_COPY as va_copy or __va_copy.
		148	*/
		149	#if !defined (G_VA_COPY)
		150	# if defined (__GNUC__) && defined (__PPC__) && (defined (_CALL_SYSV) \|\| defined (_WIN32))
		151	# define G_VA_COPY(ap1, ap2) ((ap1) = (ap2))
		152	# elif defined (G_VA_COPY_AS_ARRAY)
		153	# define G_VA_COPY(ap1, ap2) g_memmove ((ap1), (ap2), sizeof (va_list))
		154	# else /* va_list is a pointer */
		155	# define G_VA_COPY(ap1, ap2) ((ap1) = (ap2))
		156	# endif /* va_list is a pointer */
		157	#endif /* !G_VA_COPY */
		158
		159
		160	/* Provide convenience macros for handling structure
		161	* fields through their offsets.
		162	*/
		163	#define G_STRUCT_OFFSET(struct_type, member) \
		164	((gulong) ((gchar) &((struct_type) 0)->member))
		165	#define G_STRUCT_MEMBER_P(struct_p, struct_offset) \
		166	((gpointer) ((gchar*) (struct_p) + (gulong) (struct_offset)))
		167	#define G_STRUCT_MEMBER(member_type, struct_p, struct_offset) \
		168	((member_type) G_STRUCT_MEMBER_P ((struct_p), (struct_offset)))
		169
		170
		171	/* inlining hassle. for compilers that don't allow the `inline' keyword,
		172	* mostly because of strict ANSI C compliance or dumbness, we try to fall
		173	* back to either `__inline__' or `__inline'.
		174	* we define G_CAN_INLINE, if the compiler seems to be actually
		175	* capable to do function inlining, in which case inline function bodys
		176	* do make sense. we also define G_INLINE_FUNC to properly export the
		177	* function prototypes if no inlining can be performed.
		178	* we special case most of the stuff, so inline functions can have a normal
		179	* implementation by defining G_INLINE_FUNC to extern and G_CAN_INLINE to 1.
		180	*/
		181	#ifndef G_INLINE_FUNC
		182	# define G_CAN_INLINE 1
		183	#endif
		184	#ifdef G_HAVE_INLINE
		185	# if defined (__GNUC__) && defined (__STRICT_ANSI__)
		186	# undef inline
		187	# define inline __inline__
		188	# endif
		189	#else /* !G_HAVE_INLINE */
		190	# undef inline
		191	# if defined (G_HAVE___INLINE__)
		192	# define inline __inline__
		193	# else /* !inline && !__inline__ */
		194	# if defined (G_HAVE___INLINE)
		195	# define inline __inline
		196	# else /* !inline && !__inline__ && !__inline */
		197	# define inline /* don't inline, then */
		198	# ifndef G_INLINE_FUNC
		199	# undef G_CAN_INLINE
		200	# endif
		201	# endif
		202	# endif
		203	#endif
		204	#ifndef G_INLINE_FUNC
		205	# ifdef __GNUC__
		206	# ifdef __OPTIMIZE__
		207	# define G_INLINE_FUNC extern inline
		208	# else
		209	# undef G_CAN_INLINE
		210	# define G_INLINE_FUNC extern
		211	# endif
		212	# else /* !__GNUC__ */
		213	# ifdef G_CAN_INLINE
		214	# define G_INLINE_FUNC static inline
		215	# else
		216	# define G_INLINE_FUNC extern
		217	# endif
		218	# endif /* !__GNUC__ */
		219	#endif /* !G_INLINE_FUNC */
		220
		221
		222	/* Provide simple macro statement wrappers (adapted from Perl):
		223	* G_STMT_START { statements; } G_STMT_END;
		224	* can be used as a single statement, as in
		225	* if (x) G_STMT_START { ... } G_STMT_END; else ...
		226	*
		227	* For gcc we will wrap the statements within `({' and `})' braces.
		228	* For SunOS they will be wrapped within `if (1)' and `else (void) 0',
		229	* and otherwise within `do' and `while (0)'.
		230	*/
		231	#if !(defined (G_STMT_START) && defined (G_STMT_END))
		232	# if defined (__GNUC__) && !defined (__STRICT_ANSI__) && !defined (__cplusplus)
		233	# define G_STMT_START (void)(
		234	# define G_STMT_END )
		235	# else
		236	# if (defined (sun) \|\| defined (__sun__))
		237	# define G_STMT_START if (1)
		238	# define G_STMT_END else (void)0
		239	# else
		240	# define G_STMT_START do
		241	# define G_STMT_END while (0)
		242	# endif
		243	# endif
		244	#endif
		245
		246
		247	/* Provide macros to feature the GCC function attribute.
		248	*/
		249	#if __GNUC__ > 2 \|\| (__GNUC__ == 2 && __GNUC_MINOR__ > 4)
		250	#define G_GNUC_PRINTF( format_idx, arg_idx ) \
		251	__attribute__((format (printf, format_idx, arg_idx)))
		252	#define G_GNUC_SCANF( format_idx, arg_idx ) \
		253	__attribute__((format (scanf, format_idx, arg_idx)))
		254	#define G_GNUC_FORMAT( arg_idx ) \
		255	__attribute__((format_arg (arg_idx)))
		256	#define G_GNUC_NORETURN \
		257	__attribute__((noreturn))
		258	#define G_GNUC_CONST \
		259	__attribute__((const))
		260	#define G_GNUC_UNUSED \
		261	__attribute__((unused))
		262	#else /* !__GNUC__ */
		263	#define G_GNUC_PRINTF( format_idx, arg_idx )
		264	#define G_GNUC_SCANF( format_idx, arg_idx )
		265	#define G_GNUC_FORMAT( arg_idx )
		266	#define G_GNUC_NORETURN
		267	#define G_GNUC_CONST
		268	#define G_GNUC_UNUSED
		269	#endif /* !__GNUC__ */
		270
		271
		272	/* Wrap the gcc __PRETTY_FUNCTION__ and __FUNCTION__ variables with
		273	* macros, so we can refer to them as strings unconditionally.
		274	*/
		275	#ifdef __GNUC__
		276	#define G_GNUC_FUNCTION __FUNCTION__
		277	#define G_GNUC_PRETTY_FUNCTION __PRETTY_FUNCTION__
		278	#else /* !__GNUC__ */
		279	#define G_GNUC_FUNCTION ""
		280	#define G_GNUC_PRETTY_FUNCTION ""
		281	#endif /* !__GNUC__ */
		282
		283	/* we try to provide a usefull equivalent for ATEXIT if it is
		284	* not defined, but use is actually abandoned. people should
		285	* use g_atexit() instead.
		286	*/
		287	#ifndef ATEXIT
		288	# define ATEXIT(proc) g_ATEXIT(proc)
		289	#else
		290	# define G_NATIVE_ATEXIT
		291	#endif /* ATEXIT */
		292
		293	/* Hacker macro to place breakpoints for elected machines.
		294	* Actual use is strongly deprecated of course ;)
		295	*/
		296	#if defined (__i386__) && defined (__GNUC__) && __GNUC__ >= 2
		297	#define G_BREAKPOINT() G_STMT_START{ __asm__ __volatile__ ("int $03"); }G_STMT_END
		298	#elif defined (__alpha__) && defined (__GNUC__) && __GNUC__ >= 2
		299	#define G_BREAKPOINT() G_STMT_START{ __asm__ __volatile__ ("bpt"); }G_STMT_END
		300	#else /* !__i386__ && !__alpha__ */
		301	#define G_BREAKPOINT()
		302	#endif /* __i386__ */
		303
		304
		305	/* Provide macros for easily allocating memory. The macros
		306	* will cast the allocated memory to the specified type
		307	* in order to avoid compiler warnings. (Makes the code neater).
		308	*/
		309
		310	#ifdef __DMALLOC_H__
		311	# define g_new(type, count) (ALLOC (type, count))
		312	# define g_new0(type, count) (CALLOC (type, count))
		313	# define g_renew(type, mem, count) (REALLOC (mem, type, count))
		314	#else /* __DMALLOC_H__ */
		315	# define g_new(type, count) \
		316	((type ) g_malloc ((unsigned) sizeof (type) (count)))
		317	# define g_new0(type, count) \
		318	((type ) g_malloc0 ((unsigned) sizeof (type) (count)))
		319	# define g_renew(type, mem, count) \
		320	((type ) g_realloc (mem, (unsigned) sizeof (type) (count)))
		321	#endif /* __DMALLOC_H__ */
		322
		323	#define g_mem_chunk_create(type, pre_alloc, alloc_type) ( \
		324	g_mem_chunk_new (#type " mem chunks (" #pre_alloc ")", \
		325	sizeof (type), \
		326	sizeof (type) * (pre_alloc), \
		327	(alloc_type)) \
		328	)
		329	#define g_chunk_new(type, chunk) ( \
		330	(type *) g_mem_chunk_alloc (chunk) \
		331	)
		332	#define g_chunk_new0(type, chunk) ( \
		333	(type *) g_mem_chunk_alloc0 (chunk) \
		334	)
		335	#define g_chunk_free(mem, mem_chunk) G_STMT_START { \
		336	g_mem_chunk_free ((mem_chunk), (mem)); \
		337	} G_STMT_END
		338
		339
		340	#define g_string(x) #x
		341
		342
		343	/* Provide macros for error handling. The "assert" macros will
		344	* exit on failure. The "return" macros will exit the current
		345	* function. Two different definitions are given for the macros
		346	* if G_DISABLE_ASSERT is not defined, in order to support gcc's
		347	* __PRETTY_FUNCTION__ capability.
		348	*/
		349
		350	#ifdef G_DISABLE_ASSERT
		351
		352	#define g_assert(expr)
		353	#define g_assert_not_reached()
		354
		355	#else /* !G_DISABLE_ASSERT */
		356
		357	#ifdef __GNUC__
		358
		359	#define g_assert(expr) G_STMT_START{ \
		360	if (!(expr)) \
		361	g_log (G_LOG_DOMAIN, \
		362	G_LOG_LEVEL_ERROR, \
		363	"file %s: line %d (%s): assertion failed: (%s)", \
		364	__FILE__, \
		365	__LINE__, \
		366	__PRETTY_FUNCTION__, \
		367	#expr); }G_STMT_END
		368
		369	#define g_assert_not_reached() G_STMT_START{ \
		370	g_log (G_LOG_DOMAIN, \
		371	G_LOG_LEVEL_ERROR, \
		372	"file %s: line %d (%s): should not be reached", \
		373	__FILE__, \
		374	__LINE__, \
		375	__PRETTY_FUNCTION__); }G_STMT_END
		376
		377	#else /* !__GNUC__ */
		378
		379	#define g_assert(expr) G_STMT_START{ \
		380	if (!(expr)) \
		381	g_log (G_LOG_DOMAIN, \
		382	G_LOG_LEVEL_ERROR, \
		383	"file %s: line %d: assertion failed: (%s)", \
		384	__FILE__, \
		385	__LINE__, \
		386	#expr); }G_STMT_END
		387
		388	#define g_assert_not_reached() G_STMT_START{ \
		389	g_log (G_LOG_DOMAIN, \
		390	G_LOG_LEVEL_ERROR, \
		391	"file %s: line %d: should not be reached", \
		392	__FILE__, \
		393	__LINE__); }G_STMT_END
		394
		395	#endif /* __GNUC__ */
		396
		397	#endif /* !G_DISABLE_ASSERT */
		398
		399
		400	#ifdef G_DISABLE_CHECKS
		401
		402	#define g_return_if_fail(expr)
		403	#define g_return_val_if_fail(expr,val)
		404
		405	#else /* !G_DISABLE_CHECKS */
		406
		407	#ifdef __GNUC__
		408
		409	#define g_return_if_fail(expr) G_STMT_START{ \
		410	if (!(expr)) \
		411	{ \
		412	g_log (G_LOG_DOMAIN, \
		413	G_LOG_LEVEL_CRITICAL, \
		414	"file %s: line %d (%s): assertion `%s' failed.", \
		415	__FILE__, \
		416	__LINE__, \
		417	__PRETTY_FUNCTION__, \
		418	#expr); \
		419	return; \
		420	}; }G_STMT_END
		421
		422	#define g_return_val_if_fail(expr,val) G_STMT_START{ \
		423	if (!(expr)) \
		424	{ \
		425	g_log (G_LOG_DOMAIN, \
		426	G_LOG_LEVEL_CRITICAL, \
		427	"file %s: line %d (%s): assertion `%s' failed.", \
		428	__FILE__, \
		429	__LINE__, \
		430	__PRETTY_FUNCTION__, \
		431	#expr); \
		432	return val; \
		433	}; }G_STMT_END
		434
		435	#else /* !__GNUC__ */
		436
		437	#define g_return_if_fail(expr) G_STMT_START{ \
		438	if (!(expr)) \
		439	{ \
		440	g_log (G_LOG_DOMAIN, \
		441	G_LOG_LEVEL_CRITICAL, \
		442	"file %s: line %d: assertion `%s' failed.", \
		443	__FILE__, \
		444	__LINE__, \
		445	#expr); \
		446	return; \
		447	}; }G_STMT_END
		448
		449	#define g_return_val_if_fail(expr, val) G_STMT_START{ \
		450	if (!(expr)) \
		451	{ \
		452	g_log (G_LOG_DOMAIN, \
		453	G_LOG_LEVEL_CRITICAL, \
		454	"file %s: line %d: assertion `%s' failed.", \
		455	__FILE__, \
		456	__LINE__, \
		457	#expr); \
		458	return val; \
		459	}; }G_STMT_END
		460
		461	#endif /* !__GNUC__ */
		462
		463	#endif /* !G_DISABLE_CHECKS */
		464
		465
		466	/* Provide type definitions for commonly used types.
		467	* These are useful because a "gint8" can be adjusted
		468	* to be 1 byte (8 bits) on all platforms. Similarly and
		469	* more importantly, "gint32" can be adjusted to be
		470	* 4 bytes (32 bits) on all platforms.
		471	*/
		472
		473	typedef char gchar;
		474	typedef short gshort;
		475	typedef long glong;
		476	typedef int gint;
		477	typedef gint gboolean;
		478
		479	typedef unsigned char guchar;
		480	typedef unsigned short gushort;
		481	typedef unsigned long gulong;
		482	typedef unsigned int guint;
		483
		484	typedef float gfloat;
		485	typedef double gdouble;
		486
		487	/* HAVE_LONG_DOUBLE doesn't work correctly on all platforms.
		488	* Since gldouble isn't used anywhere, just disable it for now */
		489
		490	#if 0
		491	#ifdef HAVE_LONG_DOUBLE
		492	typedef long double gldouble;
		493	#else /* HAVE_LONG_DOUBLE */
		494	typedef double gldouble;
		495	#endif /* HAVE_LONG_DOUBLE */
		496	#endif /* 0 */
		497
		498	typedef void* gpointer;
		499	typedef const void *gconstpointer;
		500
		501
		502	typedef gint32 gssize;
		503	typedef guint32 gsize;
		504	typedef guint32 GQuark;
		505	typedef gint32 GTime;
		506
		507
		508	/* Portable endian checks and conversions
		509	*
		510	* glibconfig.h defines G_BYTE_ORDER which expands to one of
		511	* the below macros.
		512	*/
		513	#define G_LITTLE_ENDIAN 1234
		514	#define G_BIG_ENDIAN 4321
		515	#define G_PDP_ENDIAN 3412 /* unused, need specific PDP check */
		516
		517
		518	/* Basic bit swapping functions
		519	*/
		520	#define GUINT16_SWAP_LE_BE_CONSTANT(val) ((guint16) ( \
		521	(((guint16) (val) & (guint16) 0x00ffU) << 8) \| \
		522	(((guint16) (val) & (guint16) 0xff00U) >> 8)))
		523	#define GUINT32_SWAP_LE_BE_CONSTANT(val) ((guint32) ( \
		524	(((guint32) (val) & (guint32) 0x000000ffU) << 24) \| \
		525	(((guint32) (val) & (guint32) 0x0000ff00U) << 8) \| \
		526	(((guint32) (val) & (guint32) 0x00ff0000U) >> 8) \| \
		527	(((guint32) (val) & (guint32) 0xff000000U) >> 24)))
		528
		529	/* Intel specific stuff for speed
		530	*/
		531	#if defined (__i386__) && defined (__GNUC__) && __GNUC__ >= 2
		532	# define GUINT16_SWAP_LE_BE_X86(val) \
		533	(__extension__ \
		534	({ register guint16 __v; \
		535	if (__builtin_constant_p (val)) \
		536	__v = GUINT16_SWAP_LE_BE_CONSTANT (val); \
		537	else \
		538	__asm__ __const__ ("rorw $8, %w0" \
		539	: "=r" (__v) \
		540	: "0" ((guint16) (val))); \
		541	__v; }))
		542	# define GUINT16_SWAP_LE_BE(val) (GUINT16_SWAP_LE_BE_X86 (val))
		543	# if !defined(__i486__) && !defined(__i586__) \
		544	&& !defined(__pentium__) && !defined(__i686__) && !defined(__pentiumpro__)
		545	# define GUINT32_SWAP_LE_BE_X86(val) \
		546	(__extension__ \
		547	({ register guint32 __v; \
		548	if (__builtin_constant_p (val)) \
		549	__v = GUINT32_SWAP_LE_BE_CONSTANT (val); \
		550	else \
		551	__asm__ __const__ ("rorw $8, %w0\n\t" \
		552	"rorl $16, %0\n\t" \
		553	"rorw $8, %w0" \
		554	: "=r" (__v) \
		555	: "0" ((guint32) (val))); \
		556	__v; }))
		557	# else /* 486 and higher has bswap */
		558	# define GUINT32_SWAP_LE_BE_X86(val) \
		559	(__extension__ \
		560	({ register guint32 __v; \
		561	if (__builtin_constant_p (val)) \
		562	__v = GUINT32_SWAP_LE_BE_CONSTANT (val); \
		563	else \
		564	__asm__ __const__ ("bswap %0" \
		565	: "=r" (__v) \
		566	: "0" ((guint32) (val))); \
		567	__v; }))
		568	# endif /* processor specific 32-bit stuff */
		569	# define GUINT32_SWAP_LE_BE(val) (GUINT32_SWAP_LE_BE_X86 (val))
		570	#else /* !__i386__ */
		571	# define GUINT16_SWAP_LE_BE(val) (GUINT16_SWAP_LE_BE_CONSTANT (val))
		572	# define GUINT32_SWAP_LE_BE(val) (GUINT32_SWAP_LE_BE_CONSTANT (val))
		573	#endif /* __i386__ */
		574
		575	#ifdef G_HAVE_GINT64
		576	# define GUINT64_SWAP_LE_BE_CONSTANT(val) ((guint64) ( \
		577	(((guint64) (val) & \
		578	(guint64) G_GINT64_CONSTANT(0x00000000000000ffU)) << 56) \| \
		579	(((guint64) (val) & \
		580	(guint64) G_GINT64_CONSTANT(0x000000000000ff00U)) << 40) \| \
		581	(((guint64) (val) & \
		582	(guint64) G_GINT64_CONSTANT(0x0000000000ff0000U)) << 24) \| \
		583	(((guint64) (val) & \
		584	(guint64) G_GINT64_CONSTANT(0x00000000ff000000U)) << 8) \| \
		585	(((guint64) (val) & \
		586	(guint64) G_GINT64_CONSTANT(0x000000ff00000000U)) >> 8) \| \
		587	(((guint64) (val) & \
		588	(guint64) G_GINT64_CONSTANT(0x0000ff0000000000U)) >> 24) \| \
		589	(((guint64) (val) & \
		590	(guint64) G_GINT64_CONSTANT(0x00ff000000000000U)) >> 40) \| \
		591	(((guint64) (val) & \
		592	(guint64) G_GINT64_CONSTANT(0xff00000000000000U)) >> 56)))
		593	# if defined (__i386__) && defined (__GNUC__) && __GNUC__ >= 2
		594	# define GUINT64_SWAP_LE_BE_X86(val) \
		595	(__extension__ \
		596	({ union { guint64 __ll; \
		597	guint32 __l[2]; } __r; \
		598	if (__builtin_constant_p (val)) \
		599	__r.__ll = GUINT64_SWAP_LE_BE_CONSTANT (val); \
		600	else \
		601	{ \
		602	union { guint64 __ll; \
		603	guint32 __l[2]; } __w; \
		604	__w.__ll = ((guint64) val); \
		605	__r.__l[0] = GUINT32_SWAP_LE_BE (__w.__l[1]); \
		606	__r.__l[1] = GUINT32_SWAP_LE_BE (__w.__l[0]); \
		607	} \
		608	__r.__ll; }))
		609	# define GUINT64_SWAP_LE_BE(val) (GUINT64_SWAP_LE_BE_X86 (val))
		610	# else /* !__i386__ */
		611	# define GUINT64_SWAP_LE_BE(val) (GUINT64_SWAP_LE_BE_CONSTANT(val))
		612	# endif
		613	#endif
		614
		615	#define GUINT16_SWAP_LE_PDP(val) ((guint16) (val))
		616	#define GUINT16_SWAP_BE_PDP(val) (GUINT16_SWAP_LE_BE (val))
		617	#define GUINT32_SWAP_LE_PDP(val) ((guint32) ( \
		618	(((guint32) (val) & (guint32) 0x0000ffffU) << 16) \| \
		619	(((guint32) (val) & (guint32) 0xffff0000U) >> 16)))
		620	#define GUINT32_SWAP_BE_PDP(val) ((guint32) ( \
		621	(((guint32) (val) & (guint32) 0x00ff00ffU) << 8) \| \
		622	(((guint32) (val) & (guint32) 0xff00ff00U) >> 8)))
		623
		624	/* The G*_TO_?E() macros are defined in glibconfig.h.
		625	* The transformation is symmetric, so the FROM just maps to the TO.
		626	*/
		627	#define GINT16_FROM_LE(val) (GINT16_TO_LE (val))
		628	#define GUINT16_FROM_LE(val) (GUINT16_TO_LE (val))
		629	#define GINT16_FROM_BE(val) (GINT16_TO_BE (val))
		630	#define GUINT16_FROM_BE(val) (GUINT16_TO_BE (val))
		631	#define GINT32_FROM_LE(val) (GINT32_TO_LE (val))
		632	#define GUINT32_FROM_LE(val) (GUINT32_TO_LE (val))
		633	#define GINT32_FROM_BE(val) (GINT32_TO_BE (val))
		634	#define GUINT32_FROM_BE(val) (GUINT32_TO_BE (val))
		635
		636	#ifdef G_HAVE_GINT64
		637	#define GINT64_FROM_LE(val) (GINT64_TO_LE (val))
		638	#define GUINT64_FROM_LE(val) (GUINT64_TO_LE (val))
		639	#define GINT64_FROM_BE(val) (GINT64_TO_BE (val))
		640	#define GUINT64_FROM_BE(val) (GUINT64_TO_BE (val))
		641	#endif
		642
		643	#define GLONG_FROM_LE(val) (GLONG_TO_LE (val))
		644	#define GULONG_FROM_LE(val) (GULONG_TO_LE (val))
		645	#define GLONG_FROM_BE(val) (GLONG_TO_BE (val))
		646	#define GULONG_FROM_BE(val) (GULONG_TO_BE (val))
		647
		648	#define GINT_FROM_LE(val) (GINT_TO_LE (val))
		649	#define GUINT_FROM_LE(val) (GUINT_TO_LE (val))
		650	#define GINT_FROM_BE(val) (GINT_TO_BE (val))
		651	#define GUINT_FROM_BE(val) (GUINT_TO_BE (val))
		652
		653
		654	/* Portable versions of host-network order stuff
		655	*/
		656	#define g_ntohl(val) (GUINT32_FROM_BE (val))
		657	#define g_ntohs(val) (GUINT16_FROM_BE (val))
		658	#define g_htonl(val) (GUINT32_TO_BE (val))
		659	#define g_htons(val) (GUINT16_TO_BE (val))
		660
		661
		662	/* Glib version.
		663	* we prefix variable declarations so they can
		664	* properly get exported in windows dlls.
		665	*/
		666	#ifdef NATIVE_WIN32
		667	# ifdef GLIB_COMPILATION
		668	# define GUTILS_C_VAR __declspec(dllexport)
		669	# else /* !GLIB_COMPILATION */
		670	# define GUTILS_C_VAR extern __declspec(dllimport)
		671	# endif /* !GLIB_COMPILATION */
		672	#else /* !NATIVE_WIN32 */
		673	# define GUTILS_C_VAR extern
		674	#endif /* !NATIVE_WIN32 */
		675
		676	GUTILS_C_VAR const guint glib_major_version;
		677	GUTILS_C_VAR const guint glib_minor_version;
		678	GUTILS_C_VAR const guint glib_micro_version;
		679	GUTILS_C_VAR const guint glib_interface_age;
		680	GUTILS_C_VAR const guint glib_binary_age;
		681
		682	#define GLIB_CHECK_VERSION(major,minor,micro) \
		683	(GLIB_MAJOR_VERSION > (major) \|\| \
		684	(GLIB_MAJOR_VERSION == (major) && GLIB_MINOR_VERSION > (minor)) \|\| \
		685	(GLIB_MAJOR_VERSION == (major) && GLIB_MINOR_VERSION == (minor) && \
		686	GLIB_MICRO_VERSION >= (micro)))
		687
		688	/* Forward declarations of glib types.
		689	*/
		690	typedef struct _GAllocator GAllocator;
		691	typedef struct _GArray GArray;
		692	typedef struct _GByteArray GByteArray;
		693	typedef struct _GCache GCache;
		694	typedef struct _GCompletion GCompletion;
		695	typedef struct _GData GData;
		696	typedef struct _GDebugKey GDebugKey;
		697	typedef struct _GHashTable GHashTable;
		698	typedef struct _GHook GHook;
		699	typedef struct _GHookList GHookList;
		700	typedef struct _GList GList;
		701	typedef struct _GMemChunk GMemChunk;
		702	typedef struct _GNode GNode;
		703	typedef struct _GPtrArray GPtrArray;
		704	typedef struct _GRelation GRelation;
		705	typedef struct _GScanner GScanner;
		706	typedef struct _GScannerConfig GScannerConfig;
		707	typedef struct _GSList GSList;
		708	typedef struct _GString GString;
		709	typedef struct _GStringChunk GStringChunk;
		710	typedef struct _GTimer GTimer;
		711	typedef struct _GTree GTree;
		712	typedef struct _GTuples GTuples;
		713	typedef union _GTokenValue GTokenValue;
		714	typedef struct _GIOChannel GIOChannel;
		715
		716	/* Tree traverse flags */
		717	typedef enum
		718	{
		719	G_TRAVERSE_LEAFS = 1 << 0,
		720	G_TRAVERSE_NON_LEAFS = 1 << 1,
		721	G_TRAVERSE_ALL = G_TRAVERSE_LEAFS \| G_TRAVERSE_NON_LEAFS,
		722	G_TRAVERSE_MASK = 0x03
		723	} GTraverseFlags;
		724
		725	/* Tree traverse orders */
		726	typedef enum
		727	{
		728	G_IN_ORDER,
		729	G_PRE_ORDER,
		730	G_POST_ORDER,
		731	G_LEVEL_ORDER
		732	} GTraverseType;
		733
		734	/* Log level shift offset for user defined
		735	* log levels (0-7 are used by GLib).
		736	*/
		737	#define G_LOG_LEVEL_USER_SHIFT (8)
		738
		739	/* Glib log levels and flags.
		740	*/
		741	typedef enum
		742	{
		743	/* log flags */
		744	G_LOG_FLAG_RECURSION = 1 << 0,
		745	G_LOG_FLAG_FATAL = 1 << 1,
		746
		747	/* GLib log levels */
		748	G_LOG_LEVEL_ERROR = 1 << 2, /* always fatal */
		749	G_LOG_LEVEL_CRITICAL = 1 << 3,
		750	G_LOG_LEVEL_WARNING = 1 << 4,
		751	G_LOG_LEVEL_MESSAGE = 1 << 5,
		752	G_LOG_LEVEL_INFO = 1 << 6,
		753	G_LOG_LEVEL_DEBUG = 1 << 7,
		754
		755	G_LOG_LEVEL_MASK = ~(G_LOG_FLAG_RECURSION \| G_LOG_FLAG_FATAL)
		756	} GLogLevelFlags;
		757
		758	/* GLib log levels that are considered fatal by default */
		759	#define G_LOG_FATAL_MASK (G_LOG_FLAG_RECURSION \| G_LOG_LEVEL_ERROR)
		760
		761
		762	typedef gpointer (*GCacheNewFunc) (gpointer key);
		763	typedef gpointer (*GCacheDupFunc) (gpointer value);
		764	typedef void (*GCacheDestroyFunc) (gpointer value);
		765	typedef gint (*GCompareFunc) (gconstpointer a,
		766	gconstpointer b);
		767	typedef gchar* (*GCompletionFunc) (gpointer);
		768	typedef void (*GDestroyNotify) (gpointer data);
		769	typedef void (*GDataForeachFunc) (GQuark key_id,
		770	gpointer data,
		771	gpointer user_data);
		772	typedef void (*GFunc) (gpointer data,
		773	gpointer user_data);
		774	typedef guint (*GHashFunc) (gconstpointer key);
		775	typedef void (*GFreeFunc) (gpointer data);
		776	typedef void (*GHFunc) (gpointer key,
		777	gpointer value,
		778	gpointer user_data);
		779	typedef gboolean (*GHRFunc) (gpointer key,
		780	gpointer value,
		781	gpointer user_data);
		782	typedef gint (GHookCompareFunc) (GHook new_hook,
		783	GHook *sibling);
		784	typedef gboolean (GHookFindFunc) (GHook hook,
		785	gpointer data);
		786	typedef void (GHookMarshaller) (GHook hook,
		787	gpointer data);
		788	typedef gboolean (GHookCheckMarshaller) (GHook hook,
		789	gpointer data);
		790	typedef void (*GHookFunc) (gpointer data);
		791	typedef gboolean (*GHookCheckFunc) (gpointer data);
		792	typedef void (GHookFreeFunc) (GHookList hook_list,
		793	GHook *hook);
		794	typedef void (GLogFunc) (const gchar log_domain,
		795	GLogLevelFlags log_level,
		796	const gchar *message,
		797	gpointer user_data);
		798	typedef gboolean (GNodeTraverseFunc) (GNode node,
		799	gpointer data);
		800	typedef void (GNodeForeachFunc) (GNode node,
		801	gpointer data);
		802	typedef gint (*GSearchFunc) (gpointer key,
		803	gpointer data);
		804	typedef void (GScannerMsgFunc) (GScanner scanner,
		805	gchar *message,
		806	gint error);
		807	typedef gint (*GTraverseFunc) (gpointer key,
		808	gpointer value,
		809	gpointer data);
		810	typedef void (*GVoidFunc) (void);
		811
		812
		813	struct _GList
		814	{
		815	gpointer data;
		816	GList *next;
		817	GList *prev;
		818	};
		819
		820	struct _GSList
		821	{
		822	gpointer data;
		823	GSList *next;
		824	};
		825
		826	struct _GString
		827	{
		828	gchar *str;
		829	gint len;
		830	};
		831
		832	struct _GArray
		833	{
		834	gchar *data;
		835	guint len;
		836	};
		837
		838	struct _GByteArray
		839	{
		840	guint8 *data;
		841	guint len;
		842	};
		843
		844	struct _GPtrArray
		845	{
		846	gpointer *pdata;
		847	guint len;
		848	};
		849
		850	struct _GTuples
		851	{
		852	guint len;
		853	};
		854
		855	struct _GDebugKey
		856	{
		857	gchar *key;
		858	guint value;
		859	};
		860
		861
		862	/* Doubly linked lists
		863	*/
		864	void g_list_push_allocator (GAllocator *allocator);
		865	void g_list_pop_allocator (void);
		866	GList* g_list_alloc (void);
		867	void g_list_free (GList *list);
		868	void g_list_free_1 (GList *list);
		869	GList* g_list_append (GList *list,
		870	gpointer data);
		871	GList* g_list_prepend (GList *list,
		872	gpointer data);
		873	GList* g_list_insert (GList *list,
		874	gpointer data,
		875	gint position);
		876	GList* g_list_insert_sorted (GList *list,
		877	gpointer data,
		878	GCompareFunc func);
		879	GList* g_list_concat (GList *list1,
		880	GList *list2);
		881	GList* g_list_remove (GList *list,
		882	gpointer data);
		883	GList* g_list_remove_link (GList *list,
		884	GList *llink);
		885	GList* g_list_reverse (GList *list);
		886	GList* g_list_copy (GList *list);
		887	GList* g_list_nth (GList *list,
		888	guint n);
		889	GList* g_list_find (GList *list,
		890	gpointer data);
		891	GList* g_list_find_custom (GList *list,
		892	gpointer data,
		893	GCompareFunc func);
		894	gint g_list_position (GList *list,
		895	GList *llink);
		896	gint g_list_index (GList *list,
		897	gpointer data);
		898	GList* g_list_last (GList *list);
		899	GList* g_list_first (GList *list);
		900	guint g_list_length (GList *list);
		901	void g_list_foreach (GList *list,
		902	GFunc func,
		903	gpointer user_data);
		904	GList* g_list_sort (GList *list,
		905	GCompareFunc compare_func);
		906	gpointer g_list_nth_data (GList *list,
		907	guint n);
		908	#define g_list_previous(list) ((list) ? (((GList *)(list))->prev) : NULL)
		909	#define g_list_next(list) ((list) ? (((GList *)(list))->next) : NULL)
		910
		911
		912	/* Singly linked lists
		913	*/
		914	void g_slist_push_allocator (GAllocator *allocator);
		915	void g_slist_pop_allocator (void);
		916	GSList* g_slist_alloc (void);
		917	void g_slist_free (GSList *list);
		918	void g_slist_free_1 (GSList *list);
		919	GSList* g_slist_append (GSList *list,
		920	gpointer data);
		921	GSList* g_slist_prepend (GSList *list,
		922	gpointer data);
		923	GSList* g_slist_insert (GSList *list,
		924	gpointer data,
		925	gint position);
		926	GSList* g_slist_insert_sorted (GSList *list,
		927	gpointer data,
		928	GCompareFunc func);
		929	GSList* g_slist_concat (GSList *list1,
		930	GSList *list2);
		931	GSList* g_slist_remove (GSList *list,
		932	gpointer data);
		933	GSList* g_slist_remove_link (GSList *list,
		934	GSList *llink);
		935	GSList* g_slist_reverse (GSList *list);
		936	GSList* g_slist_copy (GSList *list);
		937	GSList* g_slist_nth (GSList *list,
		938	guint n);
		939	GSList* g_slist_find (GSList *list,
		940	gpointer data);
		941	GSList* g_slist_find_custom (GSList *list,
		942	gpointer data,
		943	GCompareFunc func);
		944	gint g_slist_position (GSList *list,
		945	GSList *llink);
		946	gint g_slist_index (GSList *list,
		947	gpointer data);
		948	GSList* g_slist_last (GSList *list);
		949	guint g_slist_length (GSList *list);
		950	void g_slist_foreach (GSList *list,
		951	GFunc func,
		952	gpointer user_data);
		953	GSList* g_slist_sort (GSList *list,
		954	GCompareFunc compare_func);
		955	gpointer g_slist_nth_data (GSList *list,
		956	guint n);
		957	#define g_slist_next(slist) ((slist) ? (((GSList *)(slist))->next) : NULL)
		958
		959
		960	/* Hash tables
		961	*/
		962	GHashTable* g_hash_table_new (GHashFunc hash_func,
		963	GCompareFunc key_compare_func);
		964	void g_hash_table_destroy (GHashTable *hash_table);
		965	void g_hash_table_insert (GHashTable *hash_table,
		966	gpointer key,
		967	gpointer value);
		968	void g_hash_table_remove (GHashTable *hash_table,
		969	gconstpointer key);
		970	gpointer g_hash_table_lookup (GHashTable *hash_table,
		971	gconstpointer key);
		972	gboolean g_hash_table_lookup_extended(GHashTable *hash_table,
		973	gconstpointer lookup_key,
		974	gpointer *orig_key,
		975	gpointer *value);
		976	void g_hash_table_freeze (GHashTable *hash_table);
		977	void g_hash_table_thaw (GHashTable *hash_table);
		978	void g_hash_table_foreach (GHashTable *hash_table,
		979	GHFunc func,
		980	gpointer user_data);
		981	guint g_hash_table_foreach_remove (GHashTable *hash_table,
		982	GHRFunc func,
		983	gpointer user_data);
		984	guint g_hash_table_size (GHashTable *hash_table);
		985
		986
		987	/* Caches
		988	*/
		989	GCache* g_cache_new (GCacheNewFunc value_new_func,
		990	GCacheDestroyFunc value_destroy_func,
		991	GCacheDupFunc key_dup_func,
		992	GCacheDestroyFunc key_destroy_func,
		993	GHashFunc hash_key_func,
		994	GHashFunc hash_value_func,
		995	GCompareFunc key_compare_func);
		996	void g_cache_destroy (GCache *cache);
		997	gpointer g_cache_insert (GCache *cache,
		998	gpointer key);
		999	void g_cache_remove (GCache *cache,
		1000	gpointer value);
		1001	void g_cache_key_foreach (GCache *cache,
		1002	GHFunc func,
		1003	gpointer user_data);
		1004	void g_cache_value_foreach (GCache *cache,
		1005	GHFunc func,
		1006	gpointer user_data);
		1007
		1008
		1009	/* Balanced binary trees
		1010	*/
		1011	GTree* g_tree_new (GCompareFunc key_compare_func);
		1012	void g_tree_destroy (GTree *tree);
		1013	void g_tree_insert (GTree *tree,
		1014	gpointer key,
		1015	gpointer value);
		1016	void g_tree_remove (GTree *tree,
		1017	gpointer key);
		1018	gpointer g_tree_lookup (GTree *tree,
		1019	gpointer key);
		1020	void g_tree_traverse (GTree *tree,
		1021	GTraverseFunc traverse_func,
		1022	GTraverseType traverse_type,
		1023	gpointer data);
		1024	gpointer g_tree_search (GTree *tree,
		1025	GSearchFunc search_func,
		1026	gpointer data);
		1027	gint g_tree_height (GTree *tree);
		1028	gint g_tree_nnodes (GTree *tree);
		1029
		1030
		1031
		1032	/* N-way tree implementation
		1033	*/
		1034	struct _GNode
		1035	{
		1036	gpointer data;
		1037	GNode *next;
		1038	GNode *prev;
		1039	GNode *parent;
		1040	GNode *children;
		1041	};
		1042
		1043	#define G_NODE_IS_ROOT(node) (((GNode*) (node))->parent == NULL && \
		1044	((GNode*) (node))->prev == NULL && \
		1045	((GNode*) (node))->next == NULL)
		1046	#define G_NODE_IS_LEAF(node) (((GNode*) (node))->children == NULL)
		1047
		1048	void g_node_push_allocator (GAllocator *allocator);
		1049	void g_node_pop_allocator (void);
		1050	GNode* g_node_new (gpointer data);
		1051	void g_node_destroy (GNode *root);
		1052	void g_node_unlink (GNode *node);
		1053	GNode* g_node_insert (GNode *parent,
		1054	gint position,
		1055	GNode *node);
		1056	GNode* g_node_insert_before (GNode *parent,
		1057	GNode *sibling,
		1058	GNode *node);
		1059	GNode* g_node_prepend (GNode *parent,
		1060	GNode *node);
		1061	guint g_node_n_nodes (GNode *root,
		1062	GTraverseFlags flags);
		1063	GNode* g_node_get_root (GNode *node);
		1064	gboolean g_node_is_ancestor (GNode *node,
		1065	GNode *descendant);
		1066	guint g_node_depth (GNode *node);
		1067	GNode* g_node_find (GNode *root,
		1068	GTraverseType order,
		1069	GTraverseFlags flags,
		1070	gpointer data);
		1071
		1072	/* convenience macros */
		1073	#define g_node_append(parent, node) \
		1074	g_node_insert_before ((parent), NULL, (node))
		1075	#define g_node_insert_data(parent, position, data) \
		1076	g_node_insert ((parent), (position), g_node_new (data))
		1077	#define g_node_insert_data_before(parent, sibling, data) \
		1078	g_node_insert_before ((parent), (sibling), g_node_new (data))
		1079	#define g_node_prepend_data(parent, data) \
		1080	g_node_prepend ((parent), g_node_new (data))
		1081	#define g_node_append_data(parent, data) \
		1082	g_node_insert_before ((parent), NULL, g_node_new (data))
		1083
		1084	/* traversal function, assumes that `node' is root
		1085	* (only traverses `node' and its subtree).
		1086	* this function is just a high level interface to
		1087	* low level traversal functions, optimized for speed.
		1088	*/
		1089	void g_node_traverse (GNode *root,
		1090	GTraverseType order,
		1091	GTraverseFlags flags,
		1092	gint max_depth,
		1093	GNodeTraverseFunc func,
		1094	gpointer data);
		1095
		1096	/* return the maximum tree height starting with `node', this is an expensive
		1097	* operation, since we need to visit all nodes. this could be shortened by
		1098	* adding `guint height' to struct _GNode, but then again, this is not very
		1099	* often needed, and would make g_node_insert() more time consuming.
		1100	*/
		1101	guint g_node_max_height (GNode *root);
		1102
		1103	void g_node_children_foreach (GNode *node,
		1104	GTraverseFlags flags,
		1105	GNodeForeachFunc func,
		1106	gpointer data);
		1107	void g_node_reverse_children (GNode *node);
		1108	guint g_node_n_children (GNode *node);
		1109	GNode* g_node_nth_child (GNode *node,
		1110	guint n);
		1111	GNode* g_node_last_child (GNode *node);
		1112	GNode* g_node_find_child (GNode *node,
		1113	GTraverseFlags flags,
		1114	gpointer data);
		1115	gint g_node_child_position (GNode *node,
		1116	GNode *child);
		1117	gint g_node_child_index (GNode *node,
		1118	gpointer data);
		1119
		1120	GNode* g_node_first_sibling (GNode *node);
		1121	GNode* g_node_last_sibling (GNode *node);
		1122
		1123	#define g_node_prev_sibling(node) ((node) ? \
		1124	((GNode*) (node))->prev : NULL)
		1125	#define g_node_next_sibling(node) ((node) ? \
		1126	((GNode*) (node))->next : NULL)
		1127	#define g_node_first_child(node) ((node) ? \
		1128	((GNode*) (node))->children : NULL)
		1129
		1130
		1131	/* Callback maintenance functions
		1132	*/
		1133	#define G_HOOK_FLAG_USER_SHIFT (4)
		1134	typedef enum
		1135	{
		1136	G_HOOK_FLAG_ACTIVE = 1 << 0,
		1137	G_HOOK_FLAG_IN_CALL = 1 << 1,
		1138	G_HOOK_FLAG_MASK = 0x0f
		1139	} GHookFlagMask;
		1140
		1141	#define G_HOOK_DEFERRED_DESTROY ((GHookFreeFunc) 0x01)
		1142
		1143	struct _GHookList
		1144	{
		1145	guint seq_id;
		1146	guint hook_size;
		1147	guint is_setup : 1;
		1148	GHook *hooks;
		1149	GMemChunk *hook_memchunk;
		1150	GHookFreeFunc hook_free; /* virtual function */
		1151	GHookFreeFunc hook_destroy; /* virtual function */
		1152	};
		1153
		1154	struct _GHook
		1155	{
		1156	gpointer data;
		1157	GHook *next;
		1158	GHook *prev;
		1159	guint ref_count;
		1160	guint hook_id;
		1161	guint flags;
		1162	gpointer func;
		1163	GDestroyNotify destroy;
		1164	};
		1165
		1166	#define G_HOOK_ACTIVE(hook) ((((GHook*) hook)->flags & \
		1167	G_HOOK_FLAG_ACTIVE) != 0)
		1168	#define G_HOOK_IN_CALL(hook) ((((GHook*) hook)->flags & \
		1169	G_HOOK_FLAG_IN_CALL) != 0)
		1170	#define G_HOOK_IS_VALID(hook) (((GHook*) hook)->hook_id != 0 && \
		1171	G_HOOK_ACTIVE (hook))
		1172	#define G_HOOK_IS_UNLINKED(hook) (((GHook*) hook)->next == NULL && \
		1173	((GHook*) hook)->prev == NULL && \
		1174	((GHook*) hook)->hook_id == 0 && \
		1175	((GHook*) hook)->ref_count == 0)
		1176
		1177	void g_hook_list_init (GHookList *hook_list,
		1178	guint hook_size);
		1179	void g_hook_list_clear (GHookList *hook_list);
		1180	GHook* g_hook_alloc (GHookList *hook_list);
		1181	void g_hook_free (GHookList *hook_list,
		1182	GHook *hook);
		1183	void g_hook_ref (GHookList *hook_list,
		1184	GHook *hook);
		1185	void g_hook_unref (GHookList *hook_list,
		1186	GHook *hook);
		1187	gboolean g_hook_destroy (GHookList *hook_list,
		1188	guint hook_id);
		1189	void g_hook_destroy_link (GHookList *hook_list,
		1190	GHook *hook);
		1191	void g_hook_prepend (GHookList *hook_list,
		1192	GHook *hook);
		1193	void g_hook_insert_before (GHookList *hook_list,
		1194	GHook *sibling,
		1195	GHook *hook);
		1196	void g_hook_insert_sorted (GHookList *hook_list,
		1197	GHook *hook,
		1198	GHookCompareFunc func);
		1199	GHook* g_hook_get (GHookList *hook_list,
		1200	guint hook_id);
		1201	GHook* g_hook_find (GHookList *hook_list,
		1202	gboolean need_valids,
		1203	GHookFindFunc func,
		1204	gpointer data);
		1205	GHook* g_hook_find_data (GHookList *hook_list,
		1206	gboolean need_valids,
		1207	gpointer data);
		1208	GHook* g_hook_find_func (GHookList *hook_list,
		1209	gboolean need_valids,
		1210	gpointer func);
		1211	GHook* g_hook_find_func_data (GHookList *hook_list,
		1212	gboolean need_valids,
		1213	gpointer func,
		1214	gpointer data);
		1215	/* return the first valid hook, and increment its reference count */
		1216	GHook* g_hook_first_valid (GHookList *hook_list,
		1217	gboolean may_be_in_call);
		1218	/* return the next valid hook with incremented reference count, and
		1219	* decrement the reference count of the original hook
		1220	*/
		1221	GHook* g_hook_next_valid (GHookList *hook_list,
		1222	GHook *hook,
		1223	gboolean may_be_in_call);
		1224
		1225	/* GHookCompareFunc implementation to insert hooks sorted by their id */
		1226	gint g_hook_compare_ids (GHook *new_hook,
		1227	GHook *sibling);
		1228
		1229	/* convenience macros */
		1230	#define g_hook_append( hook_list, hook ) \
		1231	g_hook_insert_before ((hook_list), NULL, (hook))
		1232
		1233	/* invoke all valid hooks with the (*GHookFunc) signature.
		1234	*/
		1235	void g_hook_list_invoke (GHookList *hook_list,
		1236	gboolean may_recurse);
		1237	/* invoke all valid hooks with the (*GHookCheckFunc) signature,
		1238	* and destroy the hook if FALSE is returned.
		1239	*/
		1240	void g_hook_list_invoke_check (GHookList *hook_list,
		1241	gboolean may_recurse);
		1242	/* invoke a marshaller on all valid hooks.
		1243	*/
		1244	void g_hook_list_marshal (GHookList *hook_list,
		1245	gboolean may_recurse,
		1246	GHookMarshaller marshaller,
		1247	gpointer data);
		1248	void g_hook_list_marshal_check (GHookList *hook_list,
		1249	gboolean may_recurse,
		1250	GHookCheckMarshaller marshaller,
		1251	gpointer data);
		1252
		1253
		1254	/* Fatal error handlers.
		1255	* g_on_error_query() will prompt the user to either
		1256	* [E]xit, [H]alt, [P]roceed or show [S]tack trace.
		1257	* g_on_error_stack_trace() invokes gdb, which attaches to the current
		1258	* process and shows a stack trace.
		1259	* These function may cause different actions on non-unix platforms.
		1260	* The prg_name arg is required by gdb to find the executable, if it is
		1261	* passed as NULL, g_on_error_query() will try g_get_prgname().
		1262	*/
		1263	void g_on_error_query (const gchar *prg_name);
		1264	void g_on_error_stack_trace (const gchar *prg_name);
		1265
		1266
		1267	/* Logging mechanism
		1268	*/
		1269	extern const gchar *g_log_domain_glib;
		1270	guint g_log_set_handler (const gchar *log_domain,
		1271	GLogLevelFlags log_levels,
		1272	GLogFunc log_func,
		1273	gpointer user_data);
		1274	void g_log_remove_handler (const gchar *log_domain,
		1275	guint handler_id);
		1276	void g_log_default_handler (const gchar *log_domain,
		1277	GLogLevelFlags log_level,
		1278	const gchar *message,
		1279	gpointer unused_data);
		1280	void g_log (const gchar *log_domain,
		1281	GLogLevelFlags log_level,
		1282	const gchar *format,
		1283	...) G_GNUC_PRINTF (3, 4);
		1284	void g_logv (const gchar *log_domain,
		1285	GLogLevelFlags log_level,
		1286	const gchar *format,
		1287	va_list args);
		1288	GLogLevelFlags g_log_set_fatal_mask (const gchar *log_domain,
		1289	GLogLevelFlags fatal_mask);
		1290	GLogLevelFlags g_log_set_always_fatal (GLogLevelFlags fatal_mask);
		1291	#ifndef G_LOG_DOMAIN
		1292	#define G_LOG_DOMAIN ((gchar*) 0)
		1293	#endif /* G_LOG_DOMAIN */
		1294	#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
		1295	#define g_error(...) g_log (G_LOG_DOMAIN, \
		1296	G_LOG_LEVEL_ERROR, \
		1297	__VA_ARGS__)
		1298	#define g_message(...) g_log (G_LOG_DOMAIN, \
		1299	G_LOG_LEVEL_MESSAGE, \
		1300	__VA_ARGS__)
		1301	#define g_critical(...) g_log (G_LOG_DOMAIN, \
		1302	G_LOG_LEVEL_CRITICAL, \
		1303	__VA_ARGS__)
		1304	#define g_warning(...) g_log (G_LOG_DOMAIN, \
		1305	G_LOG_LEVEL_WARNING, \
		1306	__VA_ARGS__)
		1307	#elif defined (__GNUC__)
		1308	#define g_error(format...) g_log (G_LOG_DOMAIN, \
		1309	G_LOG_LEVEL_ERROR, \
		1310	format)
		1311	#define g_message(format...) g_log (G_LOG_DOMAIN, \
		1312	G_LOG_LEVEL_MESSAGE, \
		1313	format)
		1314	#define g_critical(format...) g_log (G_LOG_DOMAIN, \
		1315	G_LOG_LEVEL_CRITICAL, \
		1316	format)
		1317	#define g_warning(format...) g_log (G_LOG_DOMAIN, \
		1318	G_LOG_LEVEL_WARNING, \
		1319	format)
		1320	#else /* !__GNUC__ */
		1321	static void
		1322	g_error (const gchar *format,
		1323	...)
		1324	{
		1325	va_list args;
		1326	va_start (args, format);
		1327	g_logv (G_LOG_DOMAIN, G_LOG_LEVEL_ERROR, format, args);
		1328	va_end (args);
		1329	}
		1330	static void
		1331	g_message (const gchar *format,
		1332	...)
		1333	{
		1334	va_list args;
		1335	va_start (args, format);
		1336	g_logv (G_LOG_DOMAIN, G_LOG_LEVEL_MESSAGE, format, args);
		1337	va_end (args);
		1338	}
		1339	static void
		1340	g_warning (const gchar *format,
		1341	...)
		1342	{
		1343	va_list args;
		1344	va_start (args, format);
		1345	g_logv (G_LOG_DOMAIN, G_LOG_LEVEL_WARNING, format, args);
		1346	va_end (args);
		1347	}
		1348	#endif /* !__GNUC__ */
		1349
		1350	typedef void (GPrintFunc) (const gchar string);
		1351	void g_print (const gchar *format,
		1352	...) G_GNUC_PRINTF (1, 2);
		1353	GPrintFunc g_set_print_handler (GPrintFunc func);
		1354	void g_printerr (const gchar *format,
		1355	...) G_GNUC_PRINTF (1, 2);
		1356	GPrintFunc g_set_printerr_handler (GPrintFunc func);
		1357
		1358	/* deprecated compatibility functions, use g_log_set_handler() instead */
		1359	typedef void (GErrorFunc) (const gchar str);
		1360	typedef void (GWarningFunc) (const gchar str);
		1361	GErrorFunc g_set_error_handler (GErrorFunc func);
		1362	GWarningFunc g_set_warning_handler (GWarningFunc func);
		1363	GPrintFunc g_set_message_handler (GPrintFunc func);
		1364
		1365
		1366	/* Memory allocation and debugging
		1367	*/
		1368	#ifdef USE_DMALLOC
		1369
		1370	#define g_malloc(size) ((gpointer) MALLOC (size))
		1371	#define g_malloc0(size) ((gpointer) CALLOC (char, size))
		1372	#define g_realloc(mem,size) ((gpointer) REALLOC (mem, char, size))
		1373	#define g_free(mem) FREE (mem)
		1374
		1375	#else /* !USE_DMALLOC */
		1376
		1377	gpointer g_malloc (gulong size);
		1378	gpointer g_malloc0 (gulong size);
		1379	gpointer g_realloc (gpointer mem,
		1380	gulong size);
		1381	void g_free (gpointer mem);
		1382
		1383	#endif /* !USE_DMALLOC */
		1384
		1385	void g_mem_profile (void);
		1386	void g_mem_check (gpointer mem);
		1387
		1388	/* Generic allocators
		1389	*/
		1390	GAllocator* g_allocator_new (const gchar *name,
		1391	guint n_preallocs);
		1392	void g_allocator_free (GAllocator *allocator);
		1393
		1394	#define G_ALLOCATOR_LIST (1)
		1395	#define G_ALLOCATOR_SLIST (2)
		1396	#define G_ALLOCATOR_NODE (3)
		1397
		1398
		1399	/* "g_mem_chunk_new" creates a new memory chunk.
		1400	* Memory chunks are used to allocate pieces of memory which are
		1401	* always the same size. Lists are a good example of such a data type.
		1402	* The memory chunk allocates and frees blocks of memory as needed.
		1403	* Just be sure to call "g_mem_chunk_free" and not "g_free" on data
		1404	* allocated in a mem chunk. ("g_free" will most likely cause a seg
		1405	* fault...somewhere).
		1406	*
		1407	* Oh yeah, GMemChunk is an opaque data type. (You don't really
		1408	* want to know what's going on inside do you?)
		1409	*/
		1410
		1411	/* ALLOC_ONLY MemChunk's can only allocate memory. The free operation
		1412	* is interpreted as a no op. ALLOC_ONLY MemChunk's save 4 bytes per
		1413	* atom. (They are also useful for lists which use MemChunk to allocate
		1414	* memory but are also part of the MemChunk implementation).
		1415	* ALLOC_AND_FREE MemChunk's can allocate and free memory.
		1416	*/
		1417
		1418	#define G_ALLOC_ONLY 1
		1419	#define G_ALLOC_AND_FREE 2
		1420
		1421	GMemChunk* g_mem_chunk_new (gchar *name,
		1422	gint atom_size,
		1423	gulong area_size,
		1424	gint type);
		1425	void g_mem_chunk_destroy (GMemChunk *mem_chunk);
		1426	gpointer g_mem_chunk_alloc (GMemChunk *mem_chunk);
		1427	gpointer g_mem_chunk_alloc0 (GMemChunk *mem_chunk);
		1428	void g_mem_chunk_free (GMemChunk *mem_chunk,
		1429	gpointer mem);
		1430	void g_mem_chunk_clean (GMemChunk *mem_chunk);
		1431	void g_mem_chunk_reset (GMemChunk *mem_chunk);
		1432	void g_mem_chunk_print (GMemChunk *mem_chunk);
		1433	void g_mem_chunk_info (void);
		1434
		1435	/* Ah yes...we have a "g_blow_chunks" function.
		1436	* "g_blow_chunks" simply compresses all the chunks. This operation
		1437	* consists of freeing every memory area that should be freed (but
		1438	* which we haven't gotten around to doing yet). And, no,
		1439	* "g_blow_chunks" doesn't follow the naming scheme, but it is a
		1440	* much better name than "g_mem_chunk_clean_all" or something
		1441	* similar.
		1442	*/
		1443	void g_blow_chunks (void);
		1444
		1445
		1446	/* Timer
		1447	*/
		1448	GTimer* g_timer_new (void);
		1449	void g_timer_destroy (GTimer *timer);
		1450	void g_timer_start (GTimer *timer);
		1451	void g_timer_stop (GTimer *timer);
		1452	void g_timer_reset (GTimer *timer);
		1453	gdouble g_timer_elapsed (GTimer *timer,
		1454	gulong *microseconds);
		1455
		1456
		1457	/* String utility functions that modify a string argument or
		1458	* return a constant string that must not be freed.
		1459	*/
		1460	#define G_STR_DELIMITERS "_-\|> <."
		1461	gchar* g_strdelimit (gchar *string,
		1462	const gchar *delimiters,
		1463	gchar new_delimiter);
		1464	gdouble g_strtod (const gchar *nptr,
		1465	gchar **endptr);
		1466	gchar* g_strerror (gint errnum);
		1467	gchar* g_strsignal (gint signum);
		1468	gint g_strcasecmp (const gchar *s1,
		1469	const gchar *s2);
		1470	gint g_strncasecmp (const gchar *s1,
		1471	const gchar *s2,
		1472	guint n);
		1473	void g_strdown (gchar *string);
		1474	void g_strup (gchar *string);
		1475	void g_strreverse (gchar *string);
		1476	/* removes leading spaces */
		1477	gchar* g_strchug (gchar *string);
		1478	/* removes trailing spaces */
		1479	gchar* g_strchomp (gchar *string);
		1480	/* removes leading & trailing spaces */
		1481	#define g_strstrip( string ) g_strchomp (g_strchug (string))
		1482
		1483	/* String utility functions that return a newly allocated string which
		1484	* ought to be freed from the caller at some point.
		1485	*/
		1486	gchar* g_strdup (const gchar *str);
		1487	gchar* g_strdup_printf (const gchar *format,
		1488	...) G_GNUC_PRINTF (1, 2);
		1489	gchar* g_strdup_vprintf (const gchar *format,
		1490	va_list args);
		1491	gchar* g_strndup (const gchar *str,
		1492	guint n);
		1493	gchar* g_strnfill (guint length,
		1494	gchar fill_char);
		1495	gchar* g_strconcat (const gchar *string1,
		1496	...); /* NULL terminated */
		1497	gchar* g_strjoin (const gchar *separator,
		1498	...); /* NULL terminated */
		1499	gchar* g_strescape (gchar *string);
		1500	gpointer g_memdup (gconstpointer mem,
		1501	guint byte_size);
		1502
		1503	/* NULL terminated string arrays.
		1504	* g_strsplit() splits up string into max_tokens tokens at delim and
		1505	* returns a newly allocated string array.
		1506	* g_strjoinv() concatenates all of str_array's strings, sliding in an
		1507	* optional separator, the returned string is newly allocated.
		1508	* g_strfreev() frees the array itself and all of its strings.
		1509	*/
		1510	gchar** g_strsplit (const gchar *string,
		1511	const gchar *delimiter,
		1512	gint max_tokens);
		1513	gchar* g_strjoinv (const gchar *separator,
		1514	gchar **str_array);
		1515	void g_strfreev (gchar **str_array);
		1516
		1517
		1518
		1519	/* calculate a string size, guarranteed to fit format + args.
		1520	*/
		1521	guint g_printf_string_upper_bound (const gchar* format,
		1522	va_list args);
		1523
		1524
		1525	/* Retrive static string info
		1526	*/
		1527	gchar* g_get_user_name (void);
		1528	gchar* g_get_real_name (void);
		1529	gchar* g_get_home_dir (void);
		1530	gchar* g_get_tmp_dir (void);
		1531	gchar* g_get_prgname (void);
		1532	void g_set_prgname (const gchar *prgname);
		1533
		1534
		1535	/* Miscellaneous utility functions
		1536	*/
		1537	guint g_parse_debug_string (const gchar *string,
		1538	GDebugKey *keys,
		1539	guint nkeys);
		1540	gint g_snprintf (gchar *string,
		1541	gulong n,
		1542	gchar const *format,
		1543	...) G_GNUC_PRINTF (3, 4);
		1544	gint g_vsnprintf (gchar *string,
		1545	gulong n,
		1546	gchar const *format,
		1547	va_list args);
		1548	gchar* g_basename (const gchar *file_name);
		1549	/* Check if a file name is an absolute path */
		1550	gboolean g_path_is_absolute (const gchar *file_name);
		1551	/* In case of absolute paths, skip the root part */
		1552	gchar* g_path_skip_root (gchar *file_name);
		1553
		1554	/* strings are newly allocated with g_malloc() */
		1555	gchar* g_dirname (const gchar *file_name);
		1556	gchar* g_get_current_dir (void);
		1557
		1558	/* return the environment string for the variable. The returned memory
		1559	* must not be freed. */
		1560	gchar* g_getenv (const gchar *variable);
		1561
		1562
		1563	/* we use a GLib function as a replacement for ATEXIT, so
		1564	* the programmer is not required to check the return value
		1565	* (if there is any in the implementation) and doesn't encounter
		1566	* missing include files.
		1567	*/
		1568	void g_atexit (GVoidFunc func);
		1569
		1570
		1571	/* Bit tests
		1572	*/
		1573	G_INLINE_FUNC gint g_bit_nth_lsf (guint32 mask,
		1574	gint nth_bit);
		1575	#ifdef G_CAN_INLINE
		1576	G_INLINE_FUNC gint
		1577	g_bit_nth_lsf (guint32 mask,
		1578	gint nth_bit)
		1579	{
		1580	do
		1581	{
		1582	nth_bit++;
		1583	if (mask & (1 << (guint) nth_bit))
		1584	return nth_bit;
		1585	}
		1586	while (nth_bit < 32);
		1587	return -1;
		1588	}
		1589	#endif /* G_CAN_INLINE */
		1590
		1591	G_INLINE_FUNC gint g_bit_nth_msf (guint32 mask,
		1592	gint nth_bit);
		1593	#ifdef G_CAN_INLINE
		1594	G_INLINE_FUNC gint
		1595	g_bit_nth_msf (guint32 mask,
		1596	gint nth_bit)
		1597	{
		1598	if (nth_bit < 0)
		1599	nth_bit = 32;
		1600	do
		1601	{
		1602	nth_bit--;
		1603	if (mask & (1 << (guint) nth_bit))
		1604	return nth_bit;
		1605	}
		1606	while (nth_bit > 0);
		1607	return -1;
		1608	}
		1609	#endif /* G_CAN_INLINE */
		1610
		1611	G_INLINE_FUNC guint g_bit_storage (guint number);
		1612	#ifdef G_CAN_INLINE
		1613	G_INLINE_FUNC guint
		1614	g_bit_storage (guint number)
		1615	{
		1616	register guint n_bits = 0;
		1617
		1618	do
		1619	{
		1620	n_bits++;
		1621	number >>= 1;
		1622	}
		1623	while (number);
		1624	return n_bits;
		1625	}
		1626	#endif /* G_CAN_INLINE */
		1627
		1628	/* String Chunks
		1629	*/
		1630	GStringChunk* g_string_chunk_new (gint size);
		1631	void g_string_chunk_free (GStringChunk *chunk);
		1632	gchar* g_string_chunk_insert (GStringChunk *chunk,
		1633	const gchar *string);
		1634	gchar* g_string_chunk_insert_const (GStringChunk *chunk,
		1635	const gchar *string);
		1636
		1637
		1638	/* Strings
		1639	*/
		1640	GString* g_string_new (const gchar *init);
		1641	GString* g_string_sized_new (guint dfl_size);
		1642	void g_string_free (GString *string,
		1643	gint free_segment);
		1644	GString* g_string_assign (GString *lval,
		1645	const gchar *rval);
		1646	GString* g_string_truncate (GString *string,
		1647	gint len);
		1648	GString* g_string_append (GString *string,
		1649	const gchar *val);
		1650	GString* g_string_append_c (GString *string,
		1651	gchar c);
		1652	GString* g_string_prepend (GString *string,
		1653	const gchar *val);
		1654	GString* g_string_prepend_c (GString *string,
		1655	gchar c);
		1656	GString* g_string_insert (GString *string,
		1657	gint pos,
		1658	const gchar *val);
		1659	GString* g_string_insert_c (GString *string,
		1660	gint pos,
		1661	gchar c);
		1662	GString* g_string_erase (GString *string,
		1663	gint pos,
		1664	gint len);
		1665	GString* g_string_down (GString *string);
		1666	GString* g_string_up (GString *string);
		1667	void g_string_sprintf (GString *string,
		1668	const gchar *format,
		1669	...) G_GNUC_PRINTF (2, 3);
		1670	void g_string_sprintfa (GString *string,
		1671	const gchar *format,
		1672	...) G_GNUC_PRINTF (2, 3);
		1673
		1674
		1675	/* Resizable arrays, remove fills any cleared spot and shortens the
		1676	* array, while preserving the order. remove_fast will distort the
		1677	* order by moving the last element to the position of the removed
		1678	*/
		1679
		1680	#define g_array_append_val(a,v) g_array_append_vals (a, &(v), 1)
		1681	#define g_array_prepend_val(a,v) g_array_prepend_vals (a, &(v), 1)
		1682	#define g_array_insert_val(a,i,v) g_array_insert_vals (a, i, &(v), 1)
		1683	#define g_array_index(a,t,i) (((t*) (a)->data) [(i)])
		1684
		1685	GArray* g_array_new (gboolean zero_terminated,
		1686	gboolean clear,
		1687	guint element_size);
		1688	void g_array_free (GArray *array,
		1689	gboolean free_segment);
		1690	GArray* g_array_append_vals (GArray *array,
		1691	gconstpointer data,
		1692	guint len);
		1693	GArray* g_array_prepend_vals (GArray *array,
		1694	gconstpointer data,
		1695	guint len);
		1696	GArray* g_array_insert_vals (GArray *array,
		1697	guint index,
		1698	gconstpointer data,
		1699	guint len);
		1700	GArray* g_array_set_size (GArray *array,
		1701	guint length);
		1702	GArray* g_array_remove_index (GArray *array,
		1703	guint index);
		1704	GArray* g_array_remove_index_fast (GArray *array,
		1705	guint index);
		1706
		1707	/* Resizable pointer array. This interface is much less complicated
		1708	* than the above. Add appends appends a pointer. Remove fills any
		1709	* cleared spot and shortens the array. remove_fast will again distort
		1710	* order.
		1711	*/
		1712	#define g_ptr_array_index(array,index) (array->pdata)[index]
		1713	GPtrArray* g_ptr_array_new (void);
		1714	void g_ptr_array_free (GPtrArray *array,
		1715	gboolean free_seg);
		1716	void g_ptr_array_set_size (GPtrArray *array,
		1717	gint length);
		1718	gpointer g_ptr_array_remove_index (GPtrArray *array,
		1719	guint index);
		1720	gpointer g_ptr_array_remove_index_fast (GPtrArray *array,
		1721	guint index);
		1722	gboolean g_ptr_array_remove (GPtrArray *array,
		1723	gpointer data);
		1724	gboolean g_ptr_array_remove_fast (GPtrArray *array,
		1725	gpointer data);
		1726	void g_ptr_array_add (GPtrArray *array,
		1727	gpointer data);
		1728
		1729	/* Byte arrays, an array of guint8. Implemented as a GArray,
		1730	* but type-safe.
		1731	*/
		1732
		1733	GByteArray* g_byte_array_new (void);
		1734	void g_byte_array_free (GByteArray *array,
		1735	gboolean free_segment);
		1736	GByteArray* g_byte_array_append (GByteArray *array,
		1737	const guint8 *data,
		1738	guint len);
		1739	GByteArray* g_byte_array_prepend (GByteArray *array,
		1740	const guint8 *data,
		1741	guint len);
		1742	GByteArray* g_byte_array_set_size (GByteArray *array,
		1743	guint length);
		1744	GByteArray* g_byte_array_remove_index (GByteArray *array,
		1745	guint index);
		1746	GByteArray* g_byte_array_remove_index_fast (GByteArray *array,
		1747	guint index);
		1748
		1749
		1750	/* Hash Functions
		1751	*/
		1752	gint g_str_equal (gconstpointer v,
		1753	gconstpointer v2);
		1754	guint g_str_hash (gconstpointer v);
		1755
		1756	gint g_int_equal (gconstpointer v,
		1757	gconstpointer v2);
		1758	guint g_int_hash (gconstpointer v);
		1759
		1760	/* This "hash" function will just return the key's adress as an
		1761	* unsigned integer. Useful for hashing on plain adresses or
		1762	* simple integer values.
		1763	* passing NULL into g_hash_table_new() as GHashFunc has the
		1764	* same effect as passing g_direct_hash().
		1765	*/
		1766	guint g_direct_hash (gconstpointer v);
		1767	gint g_direct_equal (gconstpointer v,
		1768	gconstpointer v2);
		1769
		1770
		1771	/* Quarks (string<->id association)
		1772	*/
		1773	GQuark g_quark_try_string (const gchar *string);
		1774	GQuark g_quark_from_static_string (const gchar *string);
		1775	GQuark g_quark_from_string (const gchar *string);
		1776	gchar* g_quark_to_string (GQuark quark);
		1777
		1778
		1779	/* Keyed Data List
		1780	* NOTE: these functions are scheduled for a rename in GLib 1.3
		1781	*/
		1782	void g_datalist_init (GData **datalist);
		1783	void g_datalist_clear (GData **datalist);
		1784	gpointer g_datalist_id_get_data (GData **datalist,
		1785	GQuark key_id);
		1786	void g_datalist_id_set_data_full (GData **datalist,
		1787	GQuark key_id,
		1788	gpointer data,
		1789	GDestroyNotify destroy_func);
		1790	void g_datalist_id_remove_no_notify (GData **datalist,
		1791	GQuark key_id);
		1792	void g_datalist_foreach (GData **datalist,
		1793	GDataForeachFunc func,
		1794	gpointer user_data);
		1795	#define g_datalist_id_set_data(dl, q, d) \
		1796	g_datalist_id_set_data_full ((dl), (q), (d), NULL)
		1797	#define g_datalist_id_remove_data(dl, q) \
		1798	g_datalist_id_set_data ((dl), (q), NULL)
		1799	#define g_datalist_get_data(dl, k) \
		1800	(g_datalist_id_get_data ((dl), g_quark_try_string (k)))
		1801	#define g_datalist_set_data_full(dl, k, d, f) \
		1802	g_datalist_id_set_data_full ((dl), g_quark_from_string (k), (d), (f))
		1803	#define g_datalist_remove_no_notify(dl, k) \
		1804	g_datalist_id_remove_no_notify ((dl), g_quark_try_string (k))
		1805	#define g_datalist_set_data(dl, k, d) \
		1806	g_datalist_set_data_full ((dl), (k), (d), NULL)
		1807	#define g_datalist_remove_data(dl, k) \
		1808	g_datalist_id_set_data ((dl), g_quark_try_string (k), NULL)
		1809
		1810
		1811	/* Location Associated Keyed Data
		1812	* NOTE: these functions are scheduled for a rename in GLib 1.3
		1813	*/
		1814	void g_dataset_destroy (gconstpointer dataset_location);
		1815	gpointer g_dataset_id_get_data (gconstpointer dataset_location,
		1816	GQuark key_id);
		1817	void g_dataset_id_set_data_full (gconstpointer dataset_location,
		1818	GQuark key_id,
		1819	gpointer data,
		1820	GDestroyNotify destroy_func);
		1821	void g_dataset_id_remove_no_notify (gconstpointer dataset_location,
		1822	GQuark key_id);
		1823	void g_dataset_foreach (gconstpointer dataset_location,
		1824	GDataForeachFunc func,
		1825	gpointer user_data);
		1826	#define g_dataset_id_set_data(l, k, d) \
		1827	g_dataset_id_set_data_full ((l), (k), (d), NULL)
		1828	#define g_dataset_id_remove_data(l, k) \
		1829	g_dataset_id_set_data ((l), (k), NULL)
		1830	#define g_dataset_get_data(l, k) \
		1831	(g_dataset_id_get_data ((l), g_quark_try_string (k)))
		1832	#define g_dataset_set_data_full(l, k, d, f) \
		1833	g_dataset_id_set_data_full ((l), g_quark_from_string (k), (d), (f))
		1834	#define g_dataset_remove_no_notify(l, k) \
		1835	g_dataset_id_remove_no_notify ((l), g_quark_try_string (k))
		1836	#define g_dataset_set_data(l, k, d) \
		1837	g_dataset_set_data_full ((l), (k), (d), NULL)
		1838	#define g_dataset_remove_data(l, k) \
		1839	g_dataset_id_set_data ((l), g_quark_try_string (k), NULL)
		1840
		1841
		1842	/* GScanner: Flexible lexical scanner for general purpose.
		1843	*/
		1844
		1845	/* Character sets */
		1846	#define G_CSET_A_2_Z "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
		1847	#define G_CSET_a_2_z "abcdefghijklmnopqrstuvwxyz"
		1848	#define G_CSET_LATINC "\300\301\302\303\304\305\306"\
		1849	"\307\310\311\312\313\314\315\316\317\320"\
		1850	"\321\322\323\324\325\326"\
		1851	"\330\331\332\333\334\335\336"
		1852	#define G_CSET_LATINS "\337\340\341\342\343\344\345\346"\
		1853	"\347\350\351\352\353\354\355\356\357\360"\
		1854	"\361\362\363\364\365\366"\
		1855	"\370\371\372\373\374\375\376\377"
		1856
		1857	/* Error types */
		1858	typedef enum
		1859	{
		1860	G_ERR_UNKNOWN,
		1861	G_ERR_UNEXP_EOF,
		1862	G_ERR_UNEXP_EOF_IN_STRING,
		1863	G_ERR_UNEXP_EOF_IN_COMMENT,
		1864	G_ERR_NON_DIGIT_IN_CONST,
		1865	G_ERR_DIGIT_RADIX,
		1866	G_ERR_FLOAT_RADIX,
		1867	G_ERR_FLOAT_MALFORMED
		1868	} GErrorType;
		1869
		1870	/* Token types */
		1871	typedef enum
		1872	{
		1873	G_TOKEN_EOF = 0,
		1874
		1875	G_TOKEN_LEFT_PAREN = '(',
		1876	G_TOKEN_RIGHT_PAREN = ')',
		1877	G_TOKEN_LEFT_CURLY = '{',
		1878	G_TOKEN_RIGHT_CURLY = '}',
		1879	G_TOKEN_LEFT_BRACE = '[',
		1880	G_TOKEN_RIGHT_BRACE = ']',
		1881	G_TOKEN_EQUAL_SIGN = '=',
		1882	G_TOKEN_COMMA = ',',
		1883
		1884	G_TOKEN_NONE = 256,
		1885
		1886	G_TOKEN_ERROR,
		1887
		1888	G_TOKEN_CHAR,
		1889	G_TOKEN_BINARY,
		1890	G_TOKEN_OCTAL,
		1891	G_TOKEN_INT,
		1892	G_TOKEN_HEX,
		1893	G_TOKEN_FLOAT,
		1894	G_TOKEN_STRING,
		1895
		1896	G_TOKEN_SYMBOL,
		1897	G_TOKEN_IDENTIFIER,
		1898	G_TOKEN_IDENTIFIER_NULL,
		1899
		1900	G_TOKEN_COMMENT_SINGLE,
		1901	G_TOKEN_COMMENT_MULTI,
		1902	G_TOKEN_LAST
		1903	} GTokenType;
		1904
		1905	union _GTokenValue
		1906	{
		1907	gpointer v_symbol;
		1908	gchar *v_identifier;
		1909	gulong v_binary;
		1910	gulong v_octal;
		1911	gulong v_int;
		1912	gdouble v_float;
		1913	gulong v_hex;
		1914	gchar *v_string;
		1915	gchar *v_comment;
		1916	guchar v_char;
		1917	guint v_error;
		1918	};
		1919
		1920	struct _GScannerConfig
		1921	{
		1922	/* Character sets
		1923	*/
		1924	gchar cset_skip_characters; / default: " \t\n" */
		1925	gchar *cset_identifier_first;
		1926	gchar *cset_identifier_nth;
		1927	gchar cpair_comment_single; / default: "#\n" */
		1928
		1929	/* Should symbol lookup work case sensitive?
		1930	*/
		1931	guint case_sensitive : 1;
		1932
		1933	/* Boolean values to be adjusted "on the fly"
		1934	* to configure scanning behaviour.
		1935	*/
		1936	guint skip_comment_multi : 1; /* C like comment */
		1937	guint skip_comment_single : 1; /* single line comment */
		1938	guint scan_comment_multi : 1; /* scan multi line comments? */
		1939	guint scan_identifier : 1;
		1940	guint scan_identifier_1char : 1;
		1941	guint scan_identifier_NULL : 1;
		1942	guint scan_symbols : 1;
		1943	guint scan_binary : 1;
		1944	guint scan_octal : 1;
		1945	guint scan_float : 1;
		1946	guint scan_hex : 1; /* `0x0ff0' */
		1947	guint scan_hex_dollar : 1; /* `$0ff0' */
		1948	guint scan_string_sq : 1; /* string: 'anything' */
		1949	guint scan_string_dq : 1; /* string: "\\-escapes!\n" */
		1950	guint numbers_2_int : 1; /* bin, octal, hex => int */
		1951	guint int_2_float : 1; /* int => G_TOKEN_FLOAT? */
		1952	guint identifier_2_string : 1;
		1953	guint char_2_token : 1; /* return G_TOKEN_CHAR? */
		1954	guint symbol_2_token : 1;
		1955	guint scope_0_fallback : 1; /* try scope 0 on lookups? */
		1956	};
		1957
		1958	struct _GScanner
		1959	{
		1960	/* unused fields */
		1961	gpointer user_data;
		1962	guint max_parse_errors;
		1963
		1964	/* g_scanner_error() increments this field */
		1965	guint parse_errors;
		1966
		1967	/* name of input stream, featured by the default message handler */
		1968	const gchar *input_name;
		1969
		1970	/* data pointer for derived structures */
		1971	gpointer derived_data;
		1972
		1973	/* link into the scanner configuration */
		1974	GScannerConfig *config;
		1975
		1976	/* fields filled in after g_scanner_get_next_token() */
		1977	GTokenType token;
		1978	GTokenValue value;
		1979	guint line;
		1980	guint position;
		1981
		1982	/* fields filled in after g_scanner_peek_next_token() */
		1983	GTokenType next_token;
		1984	GTokenValue next_value;
		1985	guint next_line;
		1986	guint next_position;
		1987
		1988	/* to be considered private */
		1989	GHashTable *symbol_table;
		1990	gint input_fd;
		1991	const gchar *text;
		1992	const gchar *text_end;
		1993	gchar *buffer;
		1994	guint scope_id;
		1995
		1996	/* handler function for _warn and _error */
		1997	GScannerMsgFunc msg_handler;
		1998	};
		1999
		2000	GScanner* g_scanner_new (GScannerConfig *config_templ);
		2001	void g_scanner_destroy (GScanner *scanner);
		2002	void g_scanner_input_file (GScanner *scanner,
		2003	gint input_fd);
		2004	void g_scanner_sync_file_offset (GScanner *scanner);
		2005	void g_scanner_input_text (GScanner *scanner,
		2006	const gchar *text,
		2007	guint text_len);
		2008	GTokenType g_scanner_get_next_token (GScanner *scanner);
		2009	GTokenType g_scanner_peek_next_token (GScanner *scanner);
		2010	GTokenType g_scanner_cur_token (GScanner *scanner);
		2011	GTokenValue g_scanner_cur_value (GScanner *scanner);
		2012	guint g_scanner_cur_line (GScanner *scanner);
		2013	guint g_scanner_cur_position (GScanner *scanner);
		2014	gboolean g_scanner_eof (GScanner *scanner);
		2015	guint g_scanner_set_scope (GScanner *scanner,
		2016	guint scope_id);
		2017	void g_scanner_scope_add_symbol (GScanner *scanner,
		2018	guint scope_id,
		2019	const gchar *symbol,
		2020	gpointer value);
		2021	void g_scanner_scope_remove_symbol (GScanner *scanner,
		2022	guint scope_id,
		2023	const gchar *symbol);
		2024	gpointer g_scanner_scope_lookup_symbol (GScanner *scanner,
		2025	guint scope_id,
		2026	const gchar *symbol);
		2027	void g_scanner_scope_foreach_symbol (GScanner *scanner,
		2028	guint scope_id,
		2029	GHFunc func,
		2030	gpointer user_data);
		2031	gpointer g_scanner_lookup_symbol (GScanner *scanner,
		2032	const gchar *symbol);
		2033	void g_scanner_freeze_symbol_table (GScanner *scanner);
		2034	void g_scanner_thaw_symbol_table (GScanner *scanner);
		2035	void g_scanner_unexp_token (GScanner *scanner,
		2036	GTokenType expected_token,
		2037	const gchar *identifier_spec,
		2038	const gchar *symbol_spec,
		2039	const gchar *symbol_name,
		2040	const gchar *message,
		2041	gint is_error);
		2042	void g_scanner_error (GScanner *scanner,
		2043	const gchar *format,
		2044	...) G_GNUC_PRINTF (2,3);
		2045	void g_scanner_warn (GScanner *scanner,
		2046	const gchar *format,
		2047	...) G_GNUC_PRINTF (2,3);
		2048	gint g_scanner_stat_mode (const gchar *filename);
		2049	/* keep downward source compatibility */
		2050	#define g_scanner_add_symbol( scanner, symbol, value ) G_STMT_START { \
		2051	g_scanner_scope_add_symbol ((scanner), 0, (symbol), (value)); \
		2052	} G_STMT_END
		2053	#define g_scanner_remove_symbol( scanner, symbol ) G_STMT_START { \
		2054	g_scanner_scope_remove_symbol ((scanner), 0, (symbol)); \
		2055	} G_STMT_END
		2056	#define g_scanner_foreach_symbol( scanner, func, data ) G_STMT_START { \
		2057	g_scanner_scope_foreach_symbol ((scanner), 0, (func), (data)); \
		2058	} G_STMT_END
		2059
		2060
		2061	/* GCompletion
		2062	*/
		2063
		2064	struct _GCompletion
		2065	{
		2066	GList* items;
		2067	GCompletionFunc func;
		2068
		2069	gchar* prefix;
		2070	GList* cache;
		2071	};
		2072
		2073	GCompletion* g_completion_new (GCompletionFunc func);
		2074	void g_completion_add_items (GCompletion* cmp,
		2075	GList* items);
		2076	void g_completion_remove_items (GCompletion* cmp,
		2077	GList* items);
		2078	void g_completion_clear_items (GCompletion* cmp);
		2079	GList* g_completion_complete (GCompletion* cmp,
		2080	gchar* prefix,
		2081	gchar** new_prefix);
		2082	void g_completion_free (GCompletion* cmp);
		2083
		2084
		2085	/* GDate
		2086	*
		2087	* Date calculations (not time for now, to be resolved). These are a
		2088	* mutant combination of Steffen Beyer's DateCalc routines
		2089	* (http://www.perl.com/CPAN/authors/id/STBEY/) and Jon Trowbridge's
		2090	* date routines (written for in-house software). Written by Havoc
		2091	* Pennington
		2092	*/
		2093
		2094	typedef guint16 GDateYear;
		2095	typedef guint8 GDateDay; /* day of the month */
		2096	typedef struct _GDate GDate;
		2097	/* make struct tm known without having to include time.h */
		2098	struct tm;
		2099
		2100	/* enum used to specify order of appearance in parsed date strings */
		2101	typedef enum
		2102	{
		2103	G_DATE_DAY = 0,
		2104	G_DATE_MONTH = 1,
		2105	G_DATE_YEAR = 2
		2106	} GDateDMY;
		2107
		2108	/* actual week and month values */
		2109	typedef enum
		2110	{
		2111	G_DATE_BAD_WEEKDAY = 0,
		2112	G_DATE_MONDAY = 1,
		2113	G_DATE_TUESDAY = 2,
		2114	G_DATE_WEDNESDAY = 3,
		2115	G_DATE_THURSDAY = 4,
		2116	G_DATE_FRIDAY = 5,
		2117	G_DATE_SATURDAY = 6,
		2118	G_DATE_SUNDAY = 7
		2119	} GDateWeekday;
		2120	typedef enum
		2121	{
		2122	G_DATE_BAD_MONTH = 0,
		2123	G_DATE_JANUARY = 1,
		2124	G_DATE_FEBRUARY = 2,
		2125	G_DATE_MARCH = 3,
		2126	G_DATE_APRIL = 4,
		2127	G_DATE_MAY = 5,
		2128	G_DATE_JUNE = 6,
		2129	G_DATE_JULY = 7,
		2130	G_DATE_AUGUST = 8,
		2131	G_DATE_SEPTEMBER = 9,
		2132	G_DATE_OCTOBER = 10,
		2133	G_DATE_NOVEMBER = 11,
		2134	G_DATE_DECEMBER = 12
		2135	} GDateMonth;
		2136
		2137	#define G_DATE_BAD_JULIAN 0U
		2138	#define G_DATE_BAD_DAY 0U
		2139	#define G_DATE_BAD_YEAR 0U
		2140
		2141	/* Note: directly manipulating structs is generally a bad idea, but
		2142	* in this case it's an incredibly bad idea, because all or part
		2143	* of this struct can be invalid at any given time. Use the functions,
		2144	* or you will get hosed, I promise.
		2145	*/
		2146	struct _GDate
		2147	{
		2148	guint julian_days : 32; /* julian days representation - we use a
		2149	* bitfield hoping that 64 bit platforms
		2150	* will pack this whole struct in one big
		2151	* int
		2152	*/
		2153
		2154	guint julian : 1; /* julian is valid */
		2155	guint dmy : 1; /* dmy is valid */
		2156
		2157	/* DMY representation */
		2158	guint day : 6;
		2159	guint month : 4;
		2160	guint year : 16;
		2161	};
		2162
		2163	/* g_date_new() returns an invalid date, you then have to _set() stuff
		2164	* to get a usable object. You can also allocate a GDate statically,
		2165	* then call g_date_clear() to initialize.
		2166	*/
		2167	GDate* g_date_new (void);
		2168	GDate* g_date_new_dmy (GDateDay day,
		2169	GDateMonth month,
		2170	GDateYear year);
		2171	GDate* g_date_new_julian (guint32 julian_day);
		2172	void g_date_free (GDate *date);
		2173
		2174	/* check g_date_valid() after doing an operation that might fail, like
		2175	* _parse. Almost all g_date operations are undefined on invalid
		2176	* dates (the exceptions are the mutators, since you need those to
		2177	* return to validity).
		2178	*/
		2179	gboolean g_date_valid (GDate *date);
		2180	gboolean g_date_valid_day (GDateDay day);
		2181	gboolean g_date_valid_month (GDateMonth month);
		2182	gboolean g_date_valid_year (GDateYear year);
		2183	gboolean g_date_valid_weekday (GDateWeekday weekday);
		2184	gboolean g_date_valid_julian (guint32 julian_date);
		2185	gboolean g_date_valid_dmy (GDateDay day,
		2186	GDateMonth month,
		2187	GDateYear year);
		2188
		2189	GDateWeekday g_date_weekday (GDate *date);
		2190	GDateMonth g_date_month (GDate *date);
		2191	GDateYear g_date_year (GDate *date);
		2192	GDateDay g_date_day (GDate *date);
		2193	guint32 g_date_julian (GDate *date);
		2194	guint g_date_day_of_year (GDate *date);
		2195
		2196	/* First monday/sunday is the start of week 1; if we haven't reached
		2197	* that day, return 0. These are not ISO weeks of the year; that
		2198	* routine needs to be added.
		2199	* these functions return the number of weeks, starting on the
		2200	* corrsponding day
		2201	*/
		2202	guint g_date_monday_week_of_year (GDate *date);
		2203	guint g_date_sunday_week_of_year (GDate *date);
		2204
		2205	/* If you create a static date struct you need to clear it to get it
		2206	* in a sane state before use. You can clear a whole array at
		2207	* once with the ndates argument.
		2208	*/
		2209	void g_date_clear (GDate *date,
		2210	guint n_dates);
		2211
		2212	/* The parse routine is meant for dates typed in by a user, so it
		2213	* permits many formats but tries to catch common typos. If your data
		2214	* needs to be strictly validated, it is not an appropriate function.
		2215	*/
		2216	void g_date_set_parse (GDate *date,
		2217	const gchar *str);
		2218	void g_date_set_time (GDate *date,
		2219	GTime time);
		2220	void g_date_set_month (GDate *date,
		2221	GDateMonth month);
		2222	void g_date_set_day (GDate *date,
		2223	GDateDay day);
		2224	void g_date_set_year (GDate *date,
		2225	GDateYear year);
		2226	void g_date_set_dmy (GDate *date,
		2227	GDateDay day,
		2228	GDateMonth month,
		2229	GDateYear y);
		2230	void g_date_set_julian (GDate *date,
		2231	guint32 julian_date);
		2232	gboolean g_date_is_first_of_month (GDate *date);
		2233	gboolean g_date_is_last_of_month (GDate *date);
		2234
		2235	/* To go forward by some number of weeks just go forward weeks7 days /
		2236	void g_date_add_days (GDate *date,
		2237	guint n_days);
		2238	void g_date_subtract_days (GDate *date,
		2239	guint n_days);
		2240
		2241	/* If you add/sub months while day > 28, the day might change */
		2242	void g_date_add_months (GDate *date,
		2243	guint n_months);
		2244	void g_date_subtract_months (GDate *date,
		2245	guint n_months);
		2246
		2247	/* If it's feb 29, changing years can move you to the 28th */
		2248	void g_date_add_years (GDate *date,
		2249	guint n_years);
		2250	void g_date_subtract_years (GDate *date,
		2251	guint n_years);
		2252	gboolean g_date_is_leap_year (GDateYear year);
		2253	guint8 g_date_days_in_month (GDateMonth month,
		2254	GDateYear year);
		2255	guint8 g_date_monday_weeks_in_year (GDateYear year);
		2256	guint8 g_date_sunday_weeks_in_year (GDateYear year);
		2257
		2258	/* qsort-friendly (with a cast...) */
		2259	gint g_date_compare (GDate *lhs,
		2260	GDate *rhs);
		2261	void g_date_to_struct_tm (GDate *date,
		2262	struct tm *tm);
		2263
		2264	/* Just like strftime() except you can only use date-related formats.
		2265	* Using a time format is undefined.
		2266	*/
		2267	gsize g_date_strftime (gchar *s,
		2268	gsize slen,
		2269	const gchar *format,
		2270	GDate *date);
		2271
		2272
		2273	/* GRelation
		2274	*
		2275	* Indexed Relations. Imagine a really simple table in a
		2276	* database. Relations are not ordered. This data type is meant for
		2277	* maintaining a N-way mapping.
		2278	*
		2279	* g_relation_new() creates a relation with FIELDS fields
		2280	*
		2281	* g_relation_destroy() frees all resources
		2282	* g_tuples_destroy() frees the result of g_relation_select()
		2283	*
		2284	* g_relation_index() indexes relation FIELD with the provided
		2285	* equality and hash functions. this must be done before any
		2286	* calls to insert are made.
		2287	*
		2288	* g_relation_insert() inserts a new tuple. you are expected to
		2289	* provide the right number of fields.
		2290	*
		2291	* g_relation_delete() deletes all relations with KEY in FIELD
		2292	* g_relation_select() returns ...
		2293	* g_relation_count() counts ...
		2294	*/
		2295
		2296	GRelation* g_relation_new (gint fields);
		2297	void g_relation_destroy (GRelation *relation);
		2298	void g_relation_index (GRelation *relation,
		2299	gint field,
		2300	GHashFunc hash_func,
		2301	GCompareFunc key_compare_func);
		2302	void g_relation_insert (GRelation *relation,
		2303	...);
		2304	gint g_relation_delete (GRelation *relation,
		2305	gconstpointer key,
		2306	gint field);
		2307	GTuples* g_relation_select (GRelation *relation,
		2308	gconstpointer key,
		2309	gint field);
		2310	gint g_relation_count (GRelation *relation,
		2311	gconstpointer key,
		2312	gint field);
		2313	gboolean g_relation_exists (GRelation *relation,
		2314	...);
		2315	void g_relation_print (GRelation *relation);
		2316
		2317	void g_tuples_destroy (GTuples *tuples);
		2318	gpointer g_tuples_index (GTuples *tuples,
		2319	gint index,
		2320	gint field);
		2321
		2322
		2323	/* Prime numbers.
		2324	*/
		2325
		2326	/* This function returns prime numbers spaced by approximately 1.5-2.0
		2327	* and is for use in resizing data structures which prefer
		2328	* prime-valued sizes. The closest spaced prime function returns the
		2329	* next largest prime, or the highest it knows about which is about
		2330	* MAXINT/4.
		2331	*/
		2332	guint g_spaced_primes_closest (guint num);
		2333
		2334
		2335	/* GIOChannel
		2336	*/
		2337
		2338	typedef struct _GIOFuncs GIOFuncs;
		2339	typedef enum
		2340	{
		2341	G_IO_ERROR_NONE,
		2342	G_IO_ERROR_AGAIN,
		2343	G_IO_ERROR_INVAL,
		2344	G_IO_ERROR_UNKNOWN
		2345	} GIOError;
		2346	typedef enum
		2347	{
		2348	G_SEEK_CUR,
		2349	G_SEEK_SET,
		2350	G_SEEK_END
		2351	} GSeekType;
		2352	typedef enum
		2353	{
		2354	G_IO_IN GLIB_SYSDEF_POLLIN,
		2355	G_IO_OUT GLIB_SYSDEF_POLLOUT,
		2356	G_IO_PRI GLIB_SYSDEF_POLLPRI,
		2357	G_IO_ERR GLIB_SYSDEF_POLLERR,
		2358	G_IO_HUP GLIB_SYSDEF_POLLHUP,
		2359	G_IO_NVAL GLIB_SYSDEF_POLLNVAL
		2360	} GIOCondition;
		2361
		2362	struct _GIOChannel
		2363	{
		2364	guint channel_flags;
		2365	guint ref_count;
		2366	GIOFuncs *funcs;
		2367	};
		2368
		2369	typedef gboolean (GIOFunc) (GIOChannel source,
		2370	GIOCondition condition,
		2371	gpointer data);
		2372	struct _GIOFuncs
		2373	{
		2374	GIOError (io_read) (GIOChannel channel,
		2375	gchar *buf,
		2376	guint count,
		2377	guint *bytes_read);
		2378	GIOError (io_write) (GIOChannel channel,
		2379	gchar *buf,
		2380	guint count,
		2381	guint *bytes_written);
		2382	GIOError (io_seek) (GIOChannel channel,
		2383	gint offset,
		2384	GSeekType type);
		2385	void (io_close) (GIOChannel channel);
		2386	guint (io_add_watch) (GIOChannel channel,
		2387	gint priority,
		2388	GIOCondition condition,
		2389	GIOFunc func,
		2390	gpointer user_data,
		2391	GDestroyNotify notify);
		2392	void (io_free) (GIOChannel channel);
		2393	};
		2394
		2395	void g_io_channel_init (GIOChannel *channel);
		2396	void g_io_channel_ref (GIOChannel *channel);
		2397	void g_io_channel_unref (GIOChannel *channel);
		2398	GIOError g_io_channel_read (GIOChannel *channel,
		2399	gchar *buf,
		2400	guint count,
		2401	guint *bytes_read);
		2402	GIOError g_io_channel_write (GIOChannel *channel,
		2403	gchar *buf,
		2404	guint count,
		2405	guint *bytes_written);
		2406	GIOError g_io_channel_seek (GIOChannel *channel,
		2407	gint offset,
		2408	GSeekType type);
		2409	void g_io_channel_close (GIOChannel *channel);
		2410	guint g_io_add_watch_full (GIOChannel *channel,
		2411	gint priority,
		2412	GIOCondition condition,
		2413	GIOFunc func,
		2414	gpointer user_data,
		2415	GDestroyNotify notify);
		2416	guint g_io_add_watch (GIOChannel *channel,
		2417	GIOCondition condition,
		2418	GIOFunc func,
		2419	gpointer user_data);
		2420
		2421
		2422	/* Main loop
		2423	*/
		2424	typedef struct _GTimeVal GTimeVal;
		2425	typedef struct _GSourceFuncs GSourceFuncs;
		2426	typedef struct _GMainLoop GMainLoop; /* Opaque */
		2427
		2428	struct _GTimeVal
		2429	{
		2430	glong tv_sec;
		2431	glong tv_usec;
		2432	};
		2433	struct _GSourceFuncs
		2434	{
		2435	gboolean (*prepare) (gpointer source_data,
		2436	GTimeVal *current_time,
		2437	gint *timeout,
		2438	gpointer user_data);
		2439	gboolean (*check) (gpointer source_data,
		2440	GTimeVal *current_time,
		2441	gpointer user_data);
		2442	gboolean (*dispatch) (gpointer source_data,
		2443	GTimeVal *dispatch_time,
		2444	gpointer user_data);
		2445	GDestroyNotify destroy;
		2446	};
		2447
		2448	/* Standard priorities */
		2449
		2450	#define G_PRIORITY_HIGH -100
		2451	#define G_PRIORITY_DEFAULT 0
		2452	#define G_PRIORITY_HIGH_IDLE 100
		2453	#define G_PRIORITY_DEFAULT_IDLE 200
		2454	#define G_PRIORITY_LOW 300
		2455
		2456	typedef gboolean (*GSourceFunc) (gpointer data);
		2457
		2458	/* Hooks for adding to the main loop */
		2459	guint g_source_add (gint priority,
		2460	gboolean can_recurse,
		2461	GSourceFuncs *funcs,
		2462	gpointer source_data,
		2463	gpointer user_data,
		2464	GDestroyNotify notify);
		2465	gboolean g_source_remove (guint tag);
		2466	gboolean g_source_remove_by_user_data (gpointer user_data);
		2467	gboolean g_source_remove_by_source_data (gpointer source_data);
		2468	gboolean g_source_remove_by_funcs_user_data (GSourceFuncs *funcs,
		2469	gpointer user_data);
		2470
		2471	void g_get_current_time (GTimeVal *result);
		2472
		2473	/* Running the main loop */
		2474	GMainLoop* g_main_new (gboolean is_running);
		2475	void g_main_run (GMainLoop *loop);
		2476	void g_main_quit (GMainLoop *loop);
		2477	void g_main_destroy (GMainLoop *loop);
		2478	gboolean g_main_is_running (GMainLoop *loop);
		2479
		2480	/* Run a single iteration of the mainloop. If block is FALSE,
		2481	* will never block
		2482	*/
		2483	gboolean g_main_iteration (gboolean may_block);
		2484
		2485	/* See if any events are pending */
		2486	gboolean g_main_pending (void);
		2487
		2488	/* Idles and timeouts */
		2489	guint g_timeout_add_full (gint priority,
		2490	guint interval,
		2491	GSourceFunc function,
		2492	gpointer data,
		2493	GDestroyNotify notify);
		2494	guint g_timeout_add (guint interval,
		2495	GSourceFunc function,
		2496	gpointer data);
		2497	guint g_idle_add (GSourceFunc function,
		2498	gpointer data);
		2499	guint g_idle_add_full (gint priority,
		2500	GSourceFunc function,
		2501	gpointer data,
		2502	GDestroyNotify destroy);
		2503	gboolean g_idle_remove_by_data (gpointer data);
		2504
		2505	/* GPollFD
		2506	*
		2507	* System-specific IO and main loop calls
		2508	*
		2509	* On Win32, the fd in a GPollFD should be Win32 HANDLE (not a file
		2510	* descriptor as provided by the C runtime) that can be used by
		2511	* MsgWaitForMultipleObjects. This does not include file handles
		2512	* from CreateFile, SOCKETs, nor pipe handles. (But you can use
		2513	* WSAEventSelect to signal events when a SOCKET is readable).
		2514	*
		2515	* On Win32, fd can also be the special value G_WIN32_MSG_HANDLE to
		2516	* indicate polling for messages. These message queue GPollFDs should
		2517	* be added with the g_main_poll_win32_msg_add function.
		2518	*
		2519	* But note that G_WIN32_MSG_HANDLE GPollFDs should not be used by GDK
		2520	* (GTK) programs, as GDK itself wants to read messages and convert them
		2521	* to GDK events.
		2522	*
		2523	* So, unless you really know what you are doing, it's best not to try
		2524	* to use the main loop polling stuff for your own needs on
		2525	* Win32. It's really only written for the GIMP's needs so
		2526	* far.
		2527	*/
		2528
		2529	typedef struct _GPollFD GPollFD;
		2530	typedef gint (GPollFunc) (GPollFD ufds,
		2531	guint nfsd,
		2532	gint timeout);
		2533	struct _GPollFD
		2534	{
		2535	gint fd;
		2536	gushort events;
		2537	gushort revents;
		2538	};
		2539
		2540	void g_main_add_poll (GPollFD *fd,
		2541	gint priority);
		2542	void g_main_remove_poll (GPollFD *fd);
		2543	void g_main_set_poll_func (GPollFunc func);
		2544
		2545	/* On Unix, IO channels created with this function for any file
		2546	* descriptor or socket.
		2547	*
		2548	* On Win32, use this only for plain files opened with the MSVCRT (the
		2549	* Microsoft run-time C library) _open(), including file descriptors
		2550	* 0, 1 and 2 (corresponding to stdin, stdout and stderr).
		2551	* Actually, don't do even that, this code isn't done yet.
		2552	*
		2553	* The term file descriptor as used in the context of Win32 refers to
		2554	* the emulated Unix-like file descriptors MSVCRT provides.
		2555	*/
		2556	GIOChannel* g_io_channel_unix_new (int fd);
		2557	gint g_io_channel_unix_get_fd (GIOChannel *channel);
		2558
		2559	#ifdef NATIVE_WIN32
		2560
		2561	GUTILS_C_VAR guint g_pipe_readable_msg;
		2562
		2563	#define G_WIN32_MSG_HANDLE 19981206
		2564
		2565	/* This is used to add polling for Windows messages. GDK (GTk+) programs
		2566	* should not use this. (In fact, I can't think of any program that
		2567	* would want to use this, but it's here just for completeness's sake.
		2568	*/
		2569	void g_main_poll_win32_msg_add(gint priority,
		2570	GPollFD *fd,
		2571	guint hwnd);
		2572
		2573	/* An IO channel for Windows messages for window handle hwnd. */
		2574	GIOChannel *g_io_channel_win32_new_messages (guint hwnd);
		2575
		2576	/* An IO channel for an anonymous pipe as returned from the MSVCRT
		2577	* _pipe(), with no mechanism for the writer to tell the reader when
		2578	* there is data in the pipe.
		2579	*
		2580	* This is not really implemented yet.
		2581	*/
		2582	GIOChannel *g_io_channel_win32_new_pipe (int fd);
		2583
		2584	/* An IO channel for a pipe as returned from the MSVCRT _pipe(), with
		2585	* Windows user messages used to signal data in the pipe for the
		2586	* reader.
		2587	*
		2588	* fd is the file descriptor. For the write end, peer is the thread id
		2589	* of the reader, and peer_fd is his file descriptor for the read end
		2590	* of the pipe.
		2591	*
		2592	* This is used by the GIMP, and works.
		2593	*/
		2594	GIOChannel *g_io_channel_win32_new_pipe_with_wakeups (int fd,
		2595	guint peer,
		2596	int peer_fd);
		2597
		2598	void g_io_channel_win32_pipe_request_wakeups (GIOChannel *channel,
		2599	guint peer,
		2600	int peer_fd);
		2601
		2602	void g_io_channel_win32_pipe_readable (int fd,
		2603	guint offset);
		2604
		2605	/* Get the C runtime file descriptor of a channel. */
		2606	gint g_io_channel_win32_get_fd (GIOChannel *channel);
		2607
		2608	/* An IO channel for a SOCK_STREAM winsock socket. The parameter is
		2609	* actually a SOCKET.
		2610	*/
		2611	GIOChannel *g_io_channel_win32_new_stream_socket (int socket);
		2612
		2613	#endif
		2614
		2615	/* Windows emulation stubs for common Unix functions
		2616	*/
		2617	#ifdef NATIVE_WIN32
		2618	# define MAXPATHLEN 1024
		2619	# ifdef _MSC_VER
		2620	typedef int pid_t;
		2621
		2622	/* These POSIXish functions are available in the Microsoft C library
		2623	* prefixed with underscore (which of course technically speaking is
		2624	* the Right Thing, as they are non-ANSI. Not that being non-ANSI
		2625	* prevents Microsoft from practically requiring you to include
		2626	* every now and then...).
		2627	*
		2628	* You still need to include the appropriate headers to get the
		2629	* prototypes, or .
		2630	*
		2631	* For some functions, we provide emulators in glib, which are prefixed
		2632	* with gwin_.
		2633	*/
		2634	# define getcwd _getcwd
		2635	# define getpid _getpid
		2636	# define access _access
		2637	# define open _open
		2638	# define read _read
		2639	# define write _write
		2640	# define lseek _lseek
		2641	# define close _close
		2642	# define pipe(phandles) _pipe (phandles, 4096, _O_BINARY)
		2643	# define popen _popen
		2644	# define pclose _pclose
		2645	# define fdopen _fdopen
		2646	# define ftruncate(fd, size) gwin_ftruncate (fd, size)
		2647	# define opendir gwin_opendir
		2648	# define readdir gwin_readdir
		2649	# define rewinddir gwin_rewinddir
		2650	# define closedir gwin_closedir
		2651	# define NAME_MAX 255
		2652	struct DIR
		2653	{
		2654	gchar *dir_name;
		2655	gboolean just_opened;
		2656	guint find_file_handle;
		2657	gpointer find_file_data;
		2658	};
		2659	typedef struct DIR DIR;
		2660	struct dirent
		2661	{
		2662	gchar d_name[NAME_MAX + 1];
		2663	};
		2664	/* emulation functions */
		2665	extern int gwin_ftruncate (gint f,
		2666	guint size);
		2667	DIR* gwin_opendir (const gchar *dirname);
		2668	struct dirent* gwin_readdir (DIR *dir);
		2669	void gwin_rewinddir (DIR *dir);
		2670	gint gwin_closedir (DIR *dir);
		2671	# endif /* _MSC_VER */
		2672	#endif /* NATIVE_WIN32 */
		2673
		2674
		2675	/* GLib Thread support
		2676	*/
		2677	typedef struct _GMutex GMutex;
		2678	typedef struct _GCond GCond;
		2679	typedef struct _GPrivate GPrivate;
		2680	typedef struct _GStaticPrivate GStaticPrivate;
		2681	typedef struct _GThreadFunctions GThreadFunctions;
		2682	struct _GThreadFunctions
		2683	{
		2684	GMutex* (*mutex_new) (void);
		2685	void (mutex_lock) (GMutex mutex);
		2686	gboolean (mutex_trylock) (GMutex mutex);
		2687	void (mutex_unlock) (GMutex mutex);
		2688	void (mutex_free) (GMutex mutex);
		2689	GCond* (*cond_new) (void);
		2690	void (cond_signal) (GCond cond);
		2691	void (cond_broadcast) (GCond cond);
		2692	void (cond_wait) (GCond cond,
		2693	GMutex *mutex);
		2694	gboolean (cond_timed_wait) (GCond cond,
		2695	GMutex *mutex,
		2696	GTimeVal *end_time);
		2697	void (cond_free) (GCond cond);
		2698	GPrivate* (*private_new) (GDestroyNotify destructor);
		2699	gpointer (private_get) (GPrivate private_key);
		2700	void (private_set) (GPrivate private_key,
		2701	gpointer data);
		2702	};
		2703
		2704	GUTILS_C_VAR GThreadFunctions g_thread_functions_for_glib_use;
		2705	GUTILS_C_VAR gboolean g_thread_use_default_impl;
		2706	GUTILS_C_VAR gboolean g_threads_got_initialized;
		2707
		2708	/* initializes the mutex/cond/private implementation for glib, might
		2709	* only be called once, and must not be called directly or indirectly
		2710	* from another glib-function, e.g. as a callback.
		2711	*/
		2712	void g_thread_init (GThreadFunctions *vtable);
		2713
		2714	/* internal function for fallback static mutex implementation */
		2715	GMutex* g_static_mutex_get_mutex_impl (GMutex **mutex);
		2716
		2717	/* shorthands for conditional and unconditional function calls */
		2718	#define G_THREAD_UF(name, arglist) \
		2719	(*g_thread_functions_for_glib_use . name) arglist
		2720	#define G_THREAD_CF(name, fail, arg) \
		2721	(g_thread_supported () ? G_THREAD_UF (name, arg) : (fail))
		2722	/* keep in mind, all those mutexes and static mutexes are not
		2723	* recursive in general, don't rely on that
		2724	*/
		2725	#define g_thread_supported() (g_threads_got_initialized)
		2726	#define g_mutex_new() G_THREAD_UF (mutex_new, ())
		2727	#define g_mutex_lock(mutex) G_THREAD_CF (mutex_lock, (void)0, (mutex))
		2728	#define g_mutex_trylock(mutex) G_THREAD_CF (mutex_trylock, TRUE, (mutex))
		2729	#define g_mutex_unlock(mutex) G_THREAD_CF (mutex_unlock, (void)0, (mutex))
		2730	#define g_mutex_free(mutex) G_THREAD_CF (mutex_free, (void)0, (mutex))
		2731	#define g_cond_new() G_THREAD_UF (cond_new, ())
		2732	#define g_cond_signal(cond) G_THREAD_CF (cond_signal, (void)0, (cond))
		2733	#define g_cond_broadcast(cond) G_THREAD_CF (cond_broadcast, (void)0, (cond))
		2734	#define g_cond_wait(cond, mutex) G_THREAD_CF (cond_wait, (void)0, (cond, \
		2735	mutex))
		2736	#define g_cond_free(cond) G_THREAD_CF (cond_free, (void)0, (cond))
		2737	#define g_cond_timed_wait(cond, mutex, abs_time) G_THREAD_CF (cond_timed_wait, \
		2738	TRUE, \
		2739	(cond, mutex, \
		2740	abs_time))
		2741	#define g_private_new(destructor) G_THREAD_UF (private_new, (destructor))
		2742	#define g_private_get(private_key) G_THREAD_CF (private_get, \
		2743	((gpointer)private_key), \
		2744	(private_key))
		2745	#define g_private_set(private_key, value) G_THREAD_CF (private_set, \
		2746	(void) (private_key = \
		2747	(GPrivate*) (value)), \
		2748	(private_key, value))
		2749	/* GStaticMutexes can be statically initialized with the value
		2750	* G_STATIC_MUTEX_INIT, and then they can directly be used, that is
		2751	* much easier, than having to explicitly allocate the mutex before
		2752	* use
		2753	*/
		2754	#define g_static_mutex_lock(mutex) \
		2755	g_mutex_lock (g_static_mutex_get_mutex (mutex))
		2756	#define g_static_mutex_trylock(mutex) \
		2757	g_mutex_trylock (g_static_mutex_get_mutex (mutex))
		2758	#define g_static_mutex_unlock(mutex) \
		2759	g_mutex_unlock (g_static_mutex_get_mutex (mutex))
		2760	struct _GStaticPrivate
		2761	{
		2762	guint index;
		2763	};
		2764	#define G_STATIC_PRIVATE_INIT { 0 }
		2765	gpointer g_static_private_get (GStaticPrivate *private_key);
		2766	void g_static_private_set (GStaticPrivate *private_key,
		2767	gpointer data,
		2768	GDestroyNotify notify);
		2769
		2770	/* these are some convenience macros that expand to nothing if GLib
		2771	* was configured with --disable-threads. for using StaticMutexes,
		2772	* you define them with G_LOCK_DEFINE_STATIC (name) or G_LOCK_DEFINE (name)
		2773	* if you need to export the mutex. With G_LOCK_EXTERN (name) you can
		2774	* declare such an globally defined lock. name is a unique identifier
		2775	* for the protected varibale or code portion. locking, testing and
		2776	* unlocking of such mutexes can be done with G_LOCK(), G_UNLOCK() and
		2777	* G_TRYLOCK() respectively.
		2778	*/
		2779	extern void glib_dummy_decl (void);
		2780	#define G_LOCK_NAME(name) (g__ ## name ## _lock)
		2781	#ifdef G_THREADS_ENABLED
		2782	# define G_LOCK_DEFINE_STATIC(name) static G_LOCK_DEFINE (name)
		2783	# define G_LOCK_DEFINE(name) \
		2784	GStaticMutex G_LOCK_NAME (name) = G_STATIC_MUTEX_INIT
		2785	# define G_LOCK_EXTERN(name) extern GStaticMutex G_LOCK_NAME (name)
		2786
		2787	# ifdef G_DEBUG_LOCKS
		2788	# define G_LOCK(name) G_STMT_START{ \
		2789	g_log (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, \
		2790	"file %s: line %d (%s): locking: %s ", \
		2791	__FILE__, __LINE__, G_GNUC_PRETTY_FUNCTION, \
		2792	#name); \
		2793	g_static_mutex_lock (&G_LOCK_NAME (name)); \
		2794	}G_STMT_END
		2795	# define G_UNLOCK(name) G_STMT_START{ \
		2796	g_log (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, \
		2797	"file %s: line %d (%s): unlocking: %s ", \
		2798	__FILE__, __LINE__, G_GNUC_PRETTY_FUNCTION, \
		2799	#name); \
		2800	g_static_mutex_unlock (&G_LOCK_NAME (name)); \
		2801	}G_STMT_END
		2802	# define G_TRYLOCK(name) G_STMT_START{ \
		2803	g_log (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, \
		2804	"file %s: line %d (%s): try locking: %s ", \
		2805	__FILE__, __LINE__, G_GNUC_PRETTY_FUNCTION, \
		2806	#name); \
		2807	}G_STMT_END, g_static_mutex_trylock (&G_LOCK_NAME (name))
		2808	# else /* !G_DEBUG_LOCKS */
		2809	# define G_LOCK(name) g_static_mutex_lock (&G_LOCK_NAME (name))
		2810	# define G_UNLOCK(name) g_static_mutex_unlock (&G_LOCK_NAME (name))
		2811	# define G_TRYLOCK(name) g_static_mutex_trylock (&G_LOCK_NAME (name))
		2812	# endif /* !G_DEBUG_LOCKS */
		2813	#else /* !G_THREADS_ENABLED */
		2814	# define G_LOCK_DEFINE_STATIC(name) extern void glib_dummy_decl (void)
		2815	# define G_LOCK_DEFINE(name) extern void glib_dummy_decl (void)
		2816	# define G_LOCK_EXTERN(name) extern void glib_dummy_decl (void)
		2817	# define G_LOCK(name)
		2818	# define G_UNLOCK(name)
		2819	# define G_TRYLOCK(name) (FALSE)
		2820	#endif /* !G_THREADS_ENABLED */
		2821
		2822	#ifdef __cplusplus
		2823	}
		2824	#endif /* __cplusplus */
		2825
		2826
		2827	#endif /* __G_LIB_H__ */

Subversion Repositories Kolibri OS

(root)/programs/develop/libraries/menuetlibc/include/glib/glib.h – Rev 4973