X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=glib.h;h=0a6d646e354fdcf49d51a3eb1adfad7c361cef7f;hb=c22cf34e923b81962da554c8edeb9366f044ae8c;hp=9f6c517a79795bd095ef72af91fd86687f353d70;hpb=11376df686533f658cac985344f45d6132a87076;p=platform%2Fupstream%2Fglib.git diff --git a/glib.h b/glib.h index 9f6c517..0a6d646 100644 --- a/glib.h +++ b/glib.h @@ -16,6 +16,14 @@ * Free Software Foundation, Inc., 59 Temple Place - Suite 330, * Boston, MA 02111-1307, USA. */ + +/* + * Modified by the GLib Team and others 1997-1999. See the AUTHORS + * file for a list of people on the GLib Team. See the ChangeLog + * files for a list of changes. These files are distributed with + * GLib at ftp://ftp.gtk.org/pub/gtk/. + */ + #ifndef __G_LIB_H__ #define __G_LIB_H__ @@ -41,16 +49,12 @@ * And it provides a way to store and retrieve a `gint' in/from a `gpointer'. * This is useful to pass an integer instead of a pointer to a callback. * - * GINT_TO_POINTER(i), GUINT_TO_POINTER(i) - * GPOINTER_TO_INT(p), GPOINTER_TO_UINT(p) - * - * Finally, it provide the following wrappers to STDC functions: + * GINT_TO_POINTER (i), GUINT_TO_POINTER (i) + * GPOINTER_TO_INT (p), GPOINTER_TO_UINT (p) * - * g_ATEXIT - * To register hooks which are executed on exit(). - * Usually a wrapper for STDC atexit. + * Finally, it provides the following wrappers to STDC functions: * - * void *g_memmove(void *dest, const void *src, guint count); + * void g_memmove (gpointer dest, gconstpointer void *src, gulong count); * A wrapper for STDC memmove, or an implementation, if memmove doesn't * exist. The prototype looks like the above, give or take a const, * or size_t. @@ -68,7 +72,7 @@ #endif -#ifdef NATIVE_WIN32 +#ifdef G_OS_WIN32 /* On native Win32, directory separator is the backslash, and search path * separator is the semicolon. @@ -78,7 +82,7 @@ #define G_SEARCHPATH_SEPARATOR ';' #define G_SEARCHPATH_SEPARATOR_S ";" -#else /* !NATIVE_WIN32 */ +#else /* !G_OS_WIN32 */ /* Unix */ @@ -87,34 +91,7 @@ #define G_SEARCHPATH_SEPARATOR ':' #define G_SEARCHPATH_SEPARATOR_S ":" -#endif /* !NATIVE_WIN32 */ - -#ifdef _MSC_VER -/* Make MSVC more pedantic, this is a recommended pragma list - * from _Win32_Programming_ by Rector and Newcomer. - */ -#pragma warning(error:4002) -#pragma warning(error:4003) -#pragma warning(1:4010) -#pragma warning(error:4013) -#pragma warning(1:4016) -#pragma warning(error:4020) -#pragma warning(error:4021) -#pragma warning(error:4027) -#pragma warning(error:4029) -#pragma warning(error:4033) -#pragma warning(error:4035) -#pragma warning(error:4045) -#pragma warning(error:4047) -#pragma warning(error:4049) -#pragma warning(error:4053) -#pragma warning(error:4071) -#pragma warning(disable:4101) -#pragma warning(error:4150) - -#pragma warning(disable:4244) /* No possible loss of data warnings, please */ -#endif /* _MSC_VER */ - +#endif /* !G_OS_WIN32 */ #ifdef __cplusplus extern "C" { @@ -126,8 +103,12 @@ extern "C" { * been defined. It is assumed that if they are already * defined then the current definition is correct. */ -#ifndef NULL -#define NULL ((void*) 0) +#ifndef NULL +# ifdef __cplusplus +# define NULL (0L) +# else /* !__cplusplus */ +# define NULL ((void*) 0) +# endif /* !__cplusplus */ #endif #ifndef FALSE @@ -150,6 +131,14 @@ extern "C" { #undef CLAMP #define CLAMP(x, low, high) (((x) > (high)) ? (high) : (((x) < (low)) ? (low) : (x))) +#define G_STRINGIFY(macro_or_string) G_STRINGIFY_ARG (macro_or_string) +#define G_STRINGIFY_ARG(contents) #contents + +/* Count the number of elements in an array. The array must be defined + * as such; using this with a dynamically allocated array will give + * incorrect results. + */ +#define G_N_ELEMENTS(arr) (sizeof (arr) / sizeof ((arr)[0])) /* Define G_VA_COPY() to do the right thing for copying va_list variables. * glibconfig.h may have already defined G_VA_COPY as va_copy or __va_copy. @@ -182,7 +171,7 @@ extern "C" { * we define G_CAN_INLINE, if the compiler seems to be actually * *capable* to do function inlining, in which case inline function bodys * do make sense. we also define G_INLINE_FUNC to properly export the - * function prototypes if no inlinig can be performed. + * function prototypes if no inlining can be performed. * we special case most of the stuff, so inline functions can have a normal * implementation by defining G_INLINE_FUNC to extern and G_CAN_INLINE to 1. */ @@ -281,11 +270,11 @@ extern "C" { * macros, so we can refer to them as strings unconditionally. */ #ifdef __GNUC__ -#define G_GNUC_FUNCTION (__FUNCTION__) -#define G_GNUC_PRETTY_FUNCTION (__PRETTY_FUNCTION__) +#define G_GNUC_FUNCTION __FUNCTION__ +#define G_GNUC_PRETTY_FUNCTION __PRETTY_FUNCTION__ #else /* !__GNUC__ */ -#define G_GNUC_FUNCTION ("") -#define G_GNUC_PRETTY_FUNCTION ("") +#define G_GNUC_FUNCTION "" +#define G_GNUC_PRETTY_FUNCTION "" #endif /* !__GNUC__ */ /* we try to provide a usefull equivalent for ATEXIT if it is @@ -298,7 +287,7 @@ extern "C" { # define G_NATIVE_ATEXIT #endif /* ATEXIT */ -/* Hacker macro to place breakpoints for x86 machines. +/* Hacker macro to place breakpoints for elected machines. * Actual use is strongly deprecated of course ;) */ #if defined (__i386__) && defined (__GNUC__) && __GNUC__ >= 2 @@ -345,9 +334,6 @@ extern "C" { } G_STMT_END -#define g_string(x) #x - - /* Provide macros for error handling. The "assert" macros will * exit on failure. The "return" macros will exit the current * function. Two different definitions are given for the macros @@ -489,6 +475,13 @@ typedef unsigned short gushort; typedef unsigned long gulong; typedef unsigned int guint; +#define G_GSHORT_FORMAT "hi" +#define G_GUSHORT_FORMAT "hu" +#define G_GINT_FORMAT "i" +#define G_GUINT_FORMAT "u" +#define G_GLONG_FORMAT "li" +#define G_GULONG_FORMAT "lu" + typedef float gfloat; typedef double gdouble; @@ -514,12 +507,15 @@ typedef gint32 GTime; /* Portable endian checks and conversions + * + * glibconfig.h defines G_BYTE_ORDER which expands to one of + * the below macros. */ - #define G_LITTLE_ENDIAN 1234 #define G_BIG_ENDIAN 4321 #define G_PDP_ENDIAN 3412 /* unused, need specific PDP check */ + /* Basic bit swapping functions */ #define GUINT16_SWAP_LE_BE_CONSTANT(val) ((guint16) ( \ @@ -534,7 +530,6 @@ typedef gint32 GTime; /* Intel specific stuff for speed */ #if defined (__i386__) && defined (__GNUC__) && __GNUC__ >= 2 - # define GUINT16_SWAP_LE_BE_X86(val) \ (__extension__ \ ({ register guint16 __v; \ @@ -545,9 +540,7 @@ typedef gint32 GTime; : "=r" (__v) \ : "0" ((guint16) (val))); \ __v; })) - # define GUINT16_SWAP_LE_BE(val) (GUINT16_SWAP_LE_BE_X86 (val)) - # if !defined(__i486__) && !defined(__i586__) \ && !defined(__pentium__) && !defined(__i686__) && !defined(__pentiumpro__) # define GUINT32_SWAP_LE_BE_X86(val) \ @@ -562,7 +555,6 @@ typedef gint32 GTime; : "=r" (__v) \ : "0" ((guint32) (val))); \ __v; })) - # else /* 486 and higher has bswap */ # define GUINT32_SWAP_LE_BE_X86(val) \ (__extension__ \ @@ -575,9 +567,7 @@ typedef gint32 GTime; : "0" ((guint32) (val))); \ __v; })) # endif /* processor specific 32-bit stuff */ - # define GUINT32_SWAP_LE_BE(val) (GUINT32_SWAP_LE_BE_X86 (val)) - #else /* !__i386__ */ # define GUINT16_SWAP_LE_BE(val) (GUINT16_SWAP_LE_BE_CONSTANT (val)) # define GUINT32_SWAP_LE_BE(val) (GUINT32_SWAP_LE_BE_CONSTANT (val)) @@ -601,7 +591,6 @@ typedef gint32 GTime; (guint64) G_GINT64_CONSTANT(0x00ff000000000000U)) >> 40) | \ (((guint64) (val) & \ (guint64) G_GINT64_CONSTANT(0xff00000000000000U)) >> 56))) - # if defined (__i386__) && defined (__GNUC__) && __GNUC__ >= 2 # define GUINT64_SWAP_LE_BE_X86(val) \ (__extension__ \ @@ -618,9 +607,7 @@ typedef gint32 GTime; __r.__l[1] = GUINT32_SWAP_LE_BE (__w.__l[0]); \ } \ __r.__ll; })) - # define GUINT64_SWAP_LE_BE(val) (GUINT64_SWAP_LE_BE_X86 (val)) - # else /* !__i386__ */ # define GUINT64_SWAP_LE_BE(val) (GUINT64_SWAP_LE_BE_CONSTANT(val)) # endif @@ -635,8 +622,8 @@ typedef gint32 GTime; (((guint32) (val) & (guint32) 0x00ff00ffU) << 8) | \ (((guint32) (val) & (guint32) 0xff00ff00U) >> 8))) -/* The TO_?E stuff is defined in glibconfig.h. The transformation is symmetric, - so the FROM just maps to the TO. +/* The G*_TO_?E() macros are defined in glibconfig.h. + * The transformation is symmetric, so the FROM just maps to the TO. */ #define GINT16_FROM_LE(val) (GINT16_TO_LE (val)) #define GUINT16_FROM_LE(val) (GUINT16_TO_LE (val)) @@ -648,10 +635,10 @@ typedef gint32 GTime; #define GUINT32_FROM_BE(val) (GUINT32_TO_BE (val)) #ifdef G_HAVE_GINT64 -#define GINT64_FROM_LE(val) (GINT32_TO_LE (val)) -#define GUINT64_FROM_LE(val) (GUINT32_TO_LE (val)) -#define GINT64_FROM_BE(val) (GINT32_TO_BE (val)) -#define GUINT64_FROM_BE(val) (GUINT32_TO_BE (val)) +#define GINT64_FROM_LE(val) (GINT64_TO_LE (val)) +#define GUINT64_FROM_LE(val) (GUINT64_TO_LE (val)) +#define GINT64_FROM_BE(val) (GINT64_TO_BE (val)) +#define GUINT64_FROM_BE(val) (GUINT64_TO_BE (val)) #endif #define GLONG_FROM_LE(val) (GLONG_TO_LE (val)) @@ -664,6 +651,7 @@ typedef gint32 GTime; #define GINT_FROM_BE(val) (GINT_TO_BE (val)) #define GUINT_FROM_BE(val) (GUINT_TO_BE (val)) + /* Portable versions of host-network order stuff */ #define g_ntohl(val) (GUINT32_FROM_BE (val)) @@ -676,15 +664,15 @@ typedef gint32 GTime; * we prefix variable declarations so they can * properly get exported in windows dlls. */ -#ifdef NATIVE_WIN32 +#ifdef G_OS_WIN32 # ifdef GLIB_COMPILATION # define GUTILS_C_VAR __declspec(dllexport) # else /* !GLIB_COMPILATION */ -# define GUTILS_C_VAR __declspec(dllimport) +# define GUTILS_C_VAR extern __declspec(dllimport) # endif /* !GLIB_COMPILATION */ -#else /* !NATIVE_WIN32 */ +#else /* !G_OS_WIN32 */ # define GUTILS_C_VAR extern -#endif /* !NATIVE_WIN32 */ +#endif /* !G_OS_WIN32 */ GUTILS_C_VAR const guint glib_major_version; GUTILS_C_VAR const guint glib_minor_version; @@ -692,23 +680,32 @@ GUTILS_C_VAR const guint glib_micro_version; GUTILS_C_VAR const guint glib_interface_age; GUTILS_C_VAR const guint glib_binary_age; +#define GLIB_CHECK_VERSION(major,minor,micro) \ + (GLIB_MAJOR_VERSION > (major) || \ + (GLIB_MAJOR_VERSION == (major) && GLIB_MINOR_VERSION > (minor)) || \ + (GLIB_MAJOR_VERSION == (major) && GLIB_MINOR_VERSION == (minor) && \ + GLIB_MICRO_VERSION >= (micro))) + /* Forward declarations of glib types. */ - +typedef struct _GAllocator GAllocator; typedef struct _GArray GArray; typedef struct _GByteArray GByteArray; typedef struct _GCache GCache; typedef struct _GCompletion GCompletion; typedef struct _GData GData; typedef struct _GDebugKey GDebugKey; +typedef union _GDoubleIEEE754 GDoubleIEEE754; +typedef union _GFloatIEEE754 GFloatIEEE754; typedef struct _GHashTable GHashTable; typedef struct _GHook GHook; typedef struct _GHookList GHookList; typedef struct _GList GList; -typedef struct _GListAllocator GListAllocator; typedef struct _GMemChunk GMemChunk; typedef struct _GNode GNode; typedef struct _GPtrArray GPtrArray; +typedef struct _GQueue GQueue; +typedef struct _GRand GRand; typedef struct _GRelation GRelation; typedef struct _GScanner GScanner; typedef struct _GScannerConfig GScannerConfig; @@ -716,12 +713,13 @@ typedef struct _GSList GSList; typedef struct _GString GString; typedef struct _GStringChunk GStringChunk; typedef struct _GTimer GTimer; +typedef struct _GTrashStack GTrashStack; typedef struct _GTree GTree; typedef struct _GTuples GTuples; typedef union _GTokenValue GTokenValue; typedef struct _GIOChannel GIOChannel; - +/* Tree traverse flags */ typedef enum { G_TRAVERSE_LEAFS = 1 << 0, @@ -730,6 +728,7 @@ typedef enum G_TRAVERSE_MASK = 0x03 } GTraverseFlags; +/* Tree traverse orders */ typedef enum { G_IN_ORDER, @@ -779,6 +778,7 @@ typedef void (*GDataForeachFunc) (GQuark key_id, typedef void (*GFunc) (gpointer data, gpointer user_data); typedef guint (*GHashFunc) (gconstpointer key); +typedef void (*GFreeFunc) (gpointer data); typedef void (*GHFunc) (gpointer key, gpointer value, gpointer user_data); @@ -791,6 +791,8 @@ typedef gboolean (*GHookFindFunc) (GHook *hook, gpointer data); typedef void (*GHookMarshaller) (GHook *hook, gpointer data); +typedef gboolean (*GHookCheckMarshaller) (GHook *hook, + gpointer data); typedef void (*GHookFunc) (gpointer data); typedef gboolean (*GHookCheckFunc) (gpointer data); typedef void (*GHookFreeFunc) (GHookList *hook_list, @@ -814,6 +816,24 @@ typedef gint (*GTraverseFunc) (gpointer key, typedef void (*GVoidFunc) (void); +struct _GArray +{ + gchar *data; + guint len; +}; + +struct _GByteArray +{ + guint8 *data; + guint len; +}; + +struct _GDebugKey +{ + gchar *key; + guint value; +}; + struct _GList { gpointer data; @@ -821,6 +841,19 @@ struct _GList GList *prev; }; +struct _GPtrArray +{ + gpointer *pdata; + guint len; +}; + +struct _GQueue +{ + GList *head; + GList *tail; + guint length; +}; + struct _GSList { gpointer data; @@ -833,38 +866,87 @@ struct _GString gint len; }; -struct _GArray +struct _GTrashStack { - gchar *data; - guint len; + GTrashStack *next; }; -struct _GByteArray +struct _GTuples { - guint8 *data; - guint len; + guint len; }; -struct _GPtrArray + +/* IEEE Standard 754 Single Precision Storage Format (gfloat): + * + * 31 30 23 22 0 + * +--------+---------------+---------------+ + * | s 1bit | e[30:23] 8bit | f[22:0] 23bit | + * +--------+---------------+---------------+ + * B0------------------->B1------->B2-->B3--> + * + * IEEE Standard 754 Double Precision Storage Format (gdouble): + * + * 63 62 52 51 32 31 0 + * +--------+----------------+----------------+ +---------------+ + * | s 1bit | e[62:52] 11bit | f[51:32] 20bit | | f[31:0] 32bit | + * +--------+----------------+----------------+ +---------------+ + * B0--------------->B1---------->B2--->B3----> B4->B5->B6->B7-> + */ +/* subtract from biased_exponent to form base2 exponent (normal numbers) */ +#define G_IEEE754_FLOAT_BIAS (127) +#define G_IEEE754_DOUBLE_BIAS (1023) +/* multiply with base2 exponent to get base10 exponent (nomal numbers) */ +#define G_LOG_2_BASE_10 (0.30102999566398119521) +#if G_BYTE_ORDER == G_LITTLE_ENDIAN +union _GFloatIEEE754 { - gpointer *pdata; - guint len; + gfloat v_float; + struct { + guint mantissa : 23; + guint biased_exponent : 8; + guint sign : 1; + } mpn; }; - -struct _GTuples +union _GDoubleIEEE754 { - guint len; + gdouble v_double; + struct { + guint mantissa_low : 32; + guint mantissa_high : 20; + guint biased_exponent : 11; + guint sign : 1; + } mpn; }; - -struct _GDebugKey +#elif G_BYTE_ORDER == G_BIG_ENDIAN +union _GFloatIEEE754 { - gchar *key; - guint value; + gfloat v_float; + struct { + guint sign : 1; + guint biased_exponent : 8; + guint mantissa : 23; + } mpn; +}; +union _GDoubleIEEE754 +{ + gdouble v_double; + struct { + guint sign : 1; + guint biased_exponent : 11; + guint mantissa_high : 20; + guint mantissa_low : 32; + } mpn; }; +#else /* !G_LITTLE_ENDIAN && !G_BIG_ENDIAN */ +#error unknown ENDIAN type +#endif /* !G_LITTLE_ENDIAN && !G_BIG_ENDIAN */ /* Doubly linked lists */ +void g_list_push_allocator (GAllocator *allocator); +void g_list_pop_allocator (void); GList* g_list_alloc (void); void g_list_free (GList *list); void g_list_free_1 (GList *list); @@ -884,7 +966,10 @@ GList* g_list_remove (GList *list, gpointer data); GList* g_list_remove_link (GList *list, GList *llink); +GList* g_list_delete_link (GList *list, + GList *link); GList* g_list_reverse (GList *list); +GList* g_list_copy (GList *list); GList* g_list_nth (GList *list, guint n); GList* g_list_find (GList *list, @@ -902,6 +987,8 @@ guint g_list_length (GList *list); void g_list_foreach (GList *list, GFunc func, gpointer user_data); +GList* g_list_sort (GList *list, + GCompareFunc compare_func); gpointer g_list_nth_data (GList *list, guint n); #define g_list_previous(list) ((list) ? (((GList *)(list))->prev) : NULL) @@ -910,6 +997,8 @@ gpointer g_list_nth_data (GList *list, /* Singly linked lists */ +void g_slist_push_allocator (GAllocator *allocator); +void g_slist_pop_allocator (void); GSList* g_slist_alloc (void); void g_slist_free (GSList *list); void g_slist_free_1 (GSList *list); @@ -928,8 +1017,11 @@ GSList* g_slist_concat (GSList *list1, GSList* g_slist_remove (GSList *list, gpointer data); GSList* g_slist_remove_link (GSList *list, - GSList *llink); + GSList *link); +GSList* g_slist_delete_link (GSList *list, + GSList *link); GSList* g_slist_reverse (GSList *list); +GSList* g_slist_copy (GSList *list); GSList* g_slist_nth (GSList *list, guint n); GSList* g_slist_find (GSList *list, @@ -946,17 +1038,32 @@ guint g_slist_length (GSList *list); void g_slist_foreach (GSList *list, GFunc func, gpointer user_data); +GSList* g_slist_sort (GSList *list, + GCompareFunc compare_func); gpointer g_slist_nth_data (GSList *list, guint n); -#define g_slist_next(slist) ((slist) ? (((GSList *)(slist))->next) : NULL) - - -/* List Allocators - */ -GListAllocator* g_list_allocator_new (void); -void g_list_allocator_free (GListAllocator* allocator); -GListAllocator* g_slist_set_allocator (GListAllocator* allocator); -GListAllocator* g_list_set_allocator (GListAllocator* allocator); +#define g_slist_next(slist) ((slist) ? (((GSList *)(slist))->next) : NULL) + + +/* Queues + */ +GQueue* g_queue_create (void); +void g_queue_free (GQueue *queue); +void g_queue_push_head (GQueue *queue, + gpointer data); +void g_queue_push_tail (GQueue *queue, + gpointer data); +gpointer g_queue_pop_head (GQueue *queue); +gpointer g_queue_pop_tail (GQueue *queue); +gboolean g_queue_is_empty (GQueue *queue); +gpointer g_queue_peek_head (GQueue *queue); +gpointer g_queue_peek_tail (GQueue *queue); +void g_queue_push_head_link (GQueue *queue, + GList *link); +void g_queue_push_tail_link (GQueue *queue, + GList *link); +GList* g_queue_pop_head_link (GQueue *queue); +GList* g_queue_pop_tail_link (GQueue *queue); /* Hash tables @@ -980,10 +1087,10 @@ void g_hash_table_thaw (GHashTable *hash_table); void g_hash_table_foreach (GHashTable *hash_table, GHFunc func, gpointer user_data); -gint g_hash_table_foreach_remove (GHashTable *hash_table, +guint g_hash_table_foreach_remove (GHashTable *hash_table, GHRFunc func, gpointer user_data); -gint g_hash_table_size (GHashTable *hash_table); +guint g_hash_table_size (GHashTable *hash_table); /* Caches @@ -1047,6 +1154,8 @@ struct _GNode ((GNode*) (node))->next == NULL) #define G_NODE_IS_LEAF(node) (((GNode*) (node))->children == NULL) +void g_node_push_allocator (GAllocator *allocator); +void g_node_pop_allocator (void); GNode* g_node_new (gpointer data); void g_node_destroy (GNode *root); void g_node_unlink (GNode *node); @@ -1138,6 +1247,8 @@ typedef enum G_HOOK_FLAG_MASK = 0x0f } GHookFlagMask; +#define G_HOOK_DEFERRED_DESTROY ((GHookFreeFunc) 0x01) + struct _GHookList { guint seq_id; @@ -1146,6 +1257,7 @@ struct _GHookList GHook *hooks; GMemChunk *hook_memchunk; GHookFreeFunc hook_free; /* virtual function */ + GHookFreeFunc hook_destroy; /* virtual function */ }; struct _GHook @@ -1209,9 +1321,14 @@ GHook* g_hook_find_func_data (GHookList *hook_list, gboolean need_valids, gpointer func, gpointer data); +/* return the first valid hook, and increment its reference count */ GHook* g_hook_first_valid (GHookList *hook_list, gboolean may_be_in_call); -GHook* g_hook_next_valid (GHook *hook, +/* return the next valid hook with incremented reference count, and + * decrement the reference count of the original hook + */ +GHook* g_hook_next_valid (GHookList *hook_list, + GHook *hook, gboolean may_be_in_call); /* GHookCompareFunc implementation to insert hooks sorted by their id */ @@ -1237,6 +1354,10 @@ void g_hook_list_marshal (GHookList *hook_list, gboolean may_recurse, GHookMarshaller marshaller, gpointer data); +void g_hook_list_marshal_check (GHookList *hook_list, + gboolean may_recurse, + GHookCheckMarshaller marshaller, + gpointer data); /* Fatal error handlers. @@ -1277,7 +1398,7 @@ GLogLevelFlags g_log_set_fatal_mask (const gchar *log_domain, GLogLevelFlags fatal_mask); GLogLevelFlags g_log_set_always_fatal (GLogLevelFlags fatal_mask); #ifndef G_LOG_DOMAIN -#define G_LOG_DOMAIN (NULL) +#define G_LOG_DOMAIN ((gchar*) 0) #endif /* G_LOG_DOMAIN */ #ifdef __GNUC__ #define g_error(format, args...) g_log (G_LOG_DOMAIN, \ @@ -1290,7 +1411,7 @@ GLogLevelFlags g_log_set_always_fatal (GLogLevelFlags fatal_mask); G_LOG_LEVEL_WARNING, \ format, ##args) #else /* !__GNUC__ */ -static inline void +static void g_error (const gchar *format, ...) { @@ -1299,7 +1420,7 @@ g_error (const gchar *format, g_logv (G_LOG_DOMAIN, G_LOG_LEVEL_ERROR, format, args); va_end (args); } -static inline void +static void g_message (const gchar *format, ...) { @@ -1308,7 +1429,7 @@ g_message (const gchar *format, g_logv (G_LOG_DOMAIN, G_LOG_LEVEL_MESSAGE, format, args); va_end (args); } -static inline void +static void g_warning (const gchar *format, ...) { @@ -1357,6 +1478,16 @@ void g_free (gpointer mem); void g_mem_profile (void); void g_mem_check (gpointer mem); +/* Generic allocators + */ +GAllocator* g_allocator_new (const gchar *name, + guint n_preallocs); +void g_allocator_free (GAllocator *allocator); + +#define G_ALLOCATOR_LIST (1) +#define G_ALLOCATOR_SLIST (2) +#define G_ALLOCATOR_NODE (3) + /* "g_mem_chunk_new" creates a new memory chunk. * Memory chunks are used to allocate pieces of memory which are @@ -1407,6 +1538,9 @@ void g_blow_chunks (void); /* Timer */ + +#define G_MICROSEC 1000000 + GTimer* g_timer_new (void); void g_timer_destroy (GTimer *timer); void g_timer_start (GTimer *timer); @@ -1414,7 +1548,7 @@ void g_timer_stop (GTimer *timer); void g_timer_reset (GTimer *timer); gdouble g_timer_elapsed (GTimer *timer, gulong *microseconds); - +void g_usleep (gulong microseconds); /* String utility functions that modify a string argument or * return a constant string that must not be freed. @@ -1443,7 +1577,7 @@ gchar* g_strchomp (gchar *string); #define g_strstrip( string ) g_strchomp (g_strchug (string)) /* String utility functions that return a newly allocated string which - * ought to be freed from the caller at some point. + * ought to be freed with g_free from the caller at some point. */ gchar* g_strdup (const gchar *str); gchar* g_strdup_printf (const gchar *format, @@ -1458,7 +1592,31 @@ gchar* g_strconcat (const gchar *string1, ...); /* NULL terminated */ gchar* g_strjoin (const gchar *separator, ...); /* NULL terminated */ -gchar* g_strescape (gchar *string); +/* Make a copy of a string interpreting C string -style escape + * sequences. Inverse of g_strescape. The recognized sequences are \b + * \f \n \r \t \\ \" and the octal format. + */ +gchar* g_strcompress (const gchar *source); + +/* Copy a string escaping nonprintable characters like in C strings. + * Inverse of g_strcompress. The exceptions parameter, if non-NULL, points + * to a string containing characters that are not to be escaped. + */ +gchar* g_strescape (const gchar *source, + const gchar *exceptions); +/* + * Convert between the operating system (or C runtime) + * representation of file names and UTF-8. + */ +gchar* g_filename_to_utf8 (const gchar *opsysstring); +gchar* g_filename_from_utf8 (const gchar *utf8string); + +/* Deprecated API: + * gchar* g_strescape (const gchar *source); + * Luckily this function wasn't much used. + * Add a second NULL parameter in calls for mostly identical semantics. + */ + gpointer g_memdup (gconstpointer mem, guint byte_size); @@ -1555,7 +1713,7 @@ g_bit_nth_msf (guint32 mask, gint nth_bit) { if (nth_bit < 0) - nth_bit = 33; + nth_bit = 32; do { nth_bit--; @@ -1584,6 +1742,74 @@ g_bit_storage (guint number) } #endif /* G_CAN_INLINE */ + +/* Trash Stacks + * elements need to be >= sizeof (gpointer) + */ +G_INLINE_FUNC void g_trash_stack_push (GTrashStack **stack_p, + gpointer data_p); +#ifdef G_CAN_INLINE +G_INLINE_FUNC void +g_trash_stack_push (GTrashStack **stack_p, + gpointer data_p) +{ + GTrashStack *data = (GTrashStack *) data_p; + + data->next = *stack_p; + *stack_p = data; +} +#endif /* G_CAN_INLINE */ + +G_INLINE_FUNC gpointer g_trash_stack_pop (GTrashStack **stack_p); +#ifdef G_CAN_INLINE +G_INLINE_FUNC gpointer +g_trash_stack_pop (GTrashStack **stack_p) +{ + GTrashStack *data; + + data = *stack_p; + if (data) + { + *stack_p = data->next; + /* NULLify private pointer here, most platforms store NULL as + * subsequent 0 bytes + */ + data->next = NULL; + } + + return data; +} +#endif /* G_CAN_INLINE */ + +G_INLINE_FUNC gpointer g_trash_stack_peek (GTrashStack **stack_p); +#ifdef G_CAN_INLINE +G_INLINE_FUNC gpointer +g_trash_stack_peek (GTrashStack **stack_p) +{ + GTrashStack *data; + + data = *stack_p; + + return data; +} +#endif /* G_CAN_INLINE */ + +G_INLINE_FUNC guint g_trash_stack_height (GTrashStack **stack_p); +#ifdef G_CAN_INLINE +G_INLINE_FUNC guint +g_trash_stack_height (GTrashStack **stack_p) +{ + GTrashStack *data; + guint i = 0; + + for (data = *stack_p; data; data = data->next) + i++; + + return i; +} +#endif /* G_CAN_INLINE */ + + /* String Chunks */ GStringChunk* g_string_chunk_new (gint size); @@ -1596,39 +1822,39 @@ gchar* g_string_chunk_insert_const (GStringChunk *chunk, /* Strings */ -GString* g_string_new (const gchar *init); -GString* g_string_sized_new (guint dfl_size); -void g_string_free (GString *string, - gint free_segment); -GString* g_string_assign (GString *lval, - const gchar *rval); -GString* g_string_truncate (GString *string, - gint len); -GString* g_string_append (GString *string, - const gchar *val); -GString* g_string_append_c (GString *string, - gchar c); -GString* g_string_prepend (GString *string, - const gchar *val); -GString* g_string_prepend_c (GString *string, - gchar c); -GString* g_string_insert (GString *string, - gint pos, - const gchar *val); -GString* g_string_insert_c (GString *string, - gint pos, - gchar c); -GString* g_string_erase (GString *string, - gint pos, - gint len); -GString* g_string_down (GString *string); -GString* g_string_up (GString *string); -void g_string_sprintf (GString *string, - const gchar *format, - ...) G_GNUC_PRINTF (2, 3); -void g_string_sprintfa (GString *string, - const gchar *format, - ...) G_GNUC_PRINTF (2, 3); +GString* g_string_new (const gchar *init); +GString* g_string_sized_new (guint dfl_size); +void g_string_free (GString *string, + gint free_segment); +GString* g_string_assign (GString *lval, + const gchar *rval); +GString* g_string_truncate (GString *string, + gint len); +GString* g_string_append (GString *string, + const gchar *val); +GString* g_string_append_c (GString *string, + gchar c); +GString* g_string_prepend (GString *string, + const gchar *val); +GString* g_string_prepend_c (GString *string, + gchar c); +GString* g_string_insert (GString *string, + gint pos, + const gchar *val); +GString* g_string_insert_c (GString *string, + gint pos, + gchar c); +GString* g_string_erase (GString *string, + gint pos, + gint len); +GString* g_string_down (GString *string); +GString* g_string_up (GString *string); +void g_string_sprintf (GString *string, + const gchar *format, + ...) G_GNUC_PRINTF (2, 3); +void g_string_sprintfa (GString *string, + const gchar *format, + ...) G_GNUC_PRINTF (2, 3); /* Resizable arrays, remove fills any cleared spot and shortens the @@ -1636,9 +1862,10 @@ void g_string_sprintfa (GString *string, * order by moving the last element to the position of the removed */ -#define g_array_append_val(a,v) g_array_append_vals(a,&v,1) -#define g_array_prepend_val(a,v) g_array_prepend_vals(a,&v,1) -#define g_array_index(a,t,i) (((t*)a->data)[i]) +#define g_array_append_val(a,v) g_array_append_vals (a, &v, 1) +#define g_array_prepend_val(a,v) g_array_prepend_vals (a, &v, 1) +#define g_array_insert_val(a,i,v) g_array_insert_vals (a, i, &v, 1) +#define g_array_index(a,t,i) (((t*) (a)->data) [(i)]) GArray* g_array_new (gboolean zero_terminated, gboolean clear, @@ -1651,6 +1878,10 @@ GArray* g_array_append_vals (GArray *array, GArray* g_array_prepend_vals (GArray *array, gconstpointer data, guint len); +GArray* g_array_insert_vals (GArray *array, + guint index, + gconstpointer data, + guint len); GArray* g_array_set_size (GArray *array, guint length); GArray* g_array_remove_index (GArray *array, @@ -1714,6 +1945,8 @@ guint g_int_hash (gconstpointer v); /* This "hash" function will just return the key's adress as an * unsigned integer. Useful for hashing on plain adresses or * simple integer values. + * passing NULL into g_hash_table_new() as GHashFunc has the + * same effect as passing g_direct_hash(). */ guint g_direct_hash (gconstpointer v); gint g_direct_equal (gconstpointer v, @@ -1977,7 +2210,7 @@ gpointer g_scanner_scope_lookup_symbol (GScanner *scanner, void g_scanner_scope_foreach_symbol (GScanner *scanner, guint scope_id, GHFunc func, - gpointer func_data); + gpointer user_data); gpointer g_scanner_lookup_symbol (GScanner *scanner, const gchar *symbol); void g_scanner_freeze_symbol_table (GScanner *scanner); @@ -2008,7 +2241,8 @@ gint g_scanner_stat_mode (const gchar *filename); } G_STMT_END -/* Completion */ +/* GCompletion + */ struct _GCompletion { @@ -2031,7 +2265,197 @@ GList* g_completion_complete (GCompletion* cmp, void g_completion_free (GCompletion* cmp); -/* GRelation: Indexed Relations. Imagine a really simple table in a +/* GDate + * + * Date calculations (not time for now, to be resolved). These are a + * mutant combination of Steffen Beyer's DateCalc routines + * (http://www.perl.com/CPAN/authors/id/STBEY/) and Jon Trowbridge's + * date routines (written for in-house software). Written by Havoc + * Pennington + */ + +typedef guint16 GDateYear; +typedef guint8 GDateDay; /* day of the month */ +typedef struct _GDate GDate; +/* make struct tm known without having to include time.h */ +struct tm; + +/* enum used to specify order of appearance in parsed date strings */ +typedef enum +{ + G_DATE_DAY = 0, + G_DATE_MONTH = 1, + G_DATE_YEAR = 2 +} GDateDMY; + +/* actual week and month values */ +typedef enum +{ + G_DATE_BAD_WEEKDAY = 0, + G_DATE_MONDAY = 1, + G_DATE_TUESDAY = 2, + G_DATE_WEDNESDAY = 3, + G_DATE_THURSDAY = 4, + G_DATE_FRIDAY = 5, + G_DATE_SATURDAY = 6, + G_DATE_SUNDAY = 7 +} GDateWeekday; +typedef enum +{ + G_DATE_BAD_MONTH = 0, + G_DATE_JANUARY = 1, + G_DATE_FEBRUARY = 2, + G_DATE_MARCH = 3, + G_DATE_APRIL = 4, + G_DATE_MAY = 5, + G_DATE_JUNE = 6, + G_DATE_JULY = 7, + G_DATE_AUGUST = 8, + G_DATE_SEPTEMBER = 9, + G_DATE_OCTOBER = 10, + G_DATE_NOVEMBER = 11, + G_DATE_DECEMBER = 12 +} GDateMonth; + +#define G_DATE_BAD_JULIAN 0U +#define G_DATE_BAD_DAY 0U +#define G_DATE_BAD_YEAR 0U + +/* Note: directly manipulating structs is generally a bad idea, but + * in this case it's an *incredibly* bad idea, because all or part + * of this struct can be invalid at any given time. Use the functions, + * or you will get hosed, I promise. + */ +struct _GDate +{ + guint julian_days : 32; /* julian days representation - we use a + * bitfield hoping that 64 bit platforms + * will pack this whole struct in one big + * int + */ + + guint julian : 1; /* julian is valid */ + guint dmy : 1; /* dmy is valid */ + + /* DMY representation */ + guint day : 6; + guint month : 4; + guint year : 16; +}; + +/* g_date_new() returns an invalid date, you then have to _set() stuff + * to get a usable object. You can also allocate a GDate statically, + * then call g_date_clear() to initialize. + */ +GDate* g_date_new (void); +GDate* g_date_new_dmy (GDateDay day, + GDateMonth month, + GDateYear year); +GDate* g_date_new_julian (guint32 julian_day); +void g_date_free (GDate *date); + +/* check g_date_valid() after doing an operation that might fail, like + * _parse. Almost all g_date operations are undefined on invalid + * dates (the exceptions are the mutators, since you need those to + * return to validity). + */ +gboolean g_date_valid (GDate *date); +gboolean g_date_valid_day (GDateDay day); +gboolean g_date_valid_month (GDateMonth month); +gboolean g_date_valid_year (GDateYear year); +gboolean g_date_valid_weekday (GDateWeekday weekday); +gboolean g_date_valid_julian (guint32 julian_date); +gboolean g_date_valid_dmy (GDateDay day, + GDateMonth month, + GDateYear year); + +GDateWeekday g_date_weekday (GDate *date); +GDateMonth g_date_month (GDate *date); +GDateYear g_date_year (GDate *date); +GDateDay g_date_day (GDate *date); +guint32 g_date_julian (GDate *date); +guint g_date_day_of_year (GDate *date); + +/* First monday/sunday is the start of week 1; if we haven't reached + * that day, return 0. These are not ISO weeks of the year; that + * routine needs to be added. + * these functions return the number of weeks, starting on the + * corrsponding day + */ +guint g_date_monday_week_of_year (GDate *date); +guint g_date_sunday_week_of_year (GDate *date); + +/* If you create a static date struct you need to clear it to get it + * in a sane state before use. You can clear a whole array at + * once with the ndates argument. + */ +void g_date_clear (GDate *date, + guint n_dates); + +/* The parse routine is meant for dates typed in by a user, so it + * permits many formats but tries to catch common typos. If your data + * needs to be strictly validated, it is not an appropriate function. + */ +void g_date_set_parse (GDate *date, + const gchar *str); +void g_date_set_time (GDate *date, + GTime time); +void g_date_set_month (GDate *date, + GDateMonth month); +void g_date_set_day (GDate *date, + GDateDay day); +void g_date_set_year (GDate *date, + GDateYear year); +void g_date_set_dmy (GDate *date, + GDateDay day, + GDateMonth month, + GDateYear y); +void g_date_set_julian (GDate *date, + guint32 julian_date); +gboolean g_date_is_first_of_month (GDate *date); +gboolean g_date_is_last_of_month (GDate *date); + +/* To go forward by some number of weeks just go forward weeks*7 days */ +void g_date_add_days (GDate *date, + guint n_days); +void g_date_subtract_days (GDate *date, + guint n_days); + +/* If you add/sub months while day > 28, the day might change */ +void g_date_add_months (GDate *date, + guint n_months); +void g_date_subtract_months (GDate *date, + guint n_months); + +/* If it's feb 29, changing years can move you to the 28th */ +void g_date_add_years (GDate *date, + guint n_years); +void g_date_subtract_years (GDate *date, + guint n_years); +gboolean g_date_is_leap_year (GDateYear year); +guint8 g_date_days_in_month (GDateMonth month, + GDateYear year); +guint8 g_date_monday_weeks_in_year (GDateYear year); +guint8 g_date_sunday_weeks_in_year (GDateYear year); + +/* qsort-friendly (with a cast...) */ +gint g_date_compare (GDate *lhs, + GDate *rhs); +void g_date_to_struct_tm (GDate *date, + struct tm *tm); + +/* Just like strftime() except you can only use date-related formats. + * Using a time format is undefined. + */ +gsize g_date_strftime (gchar *s, + gsize slen, + const gchar *format, + GDate *date); + + +/* GRelation + * + * Indexed Relations. Imagine a really simple table in a * database. Relations are not ordered. This data type is meant for * maintaining a N-way mapping. * @@ -2079,6 +2503,39 @@ gpointer g_tuples_index (GTuples *tuples, gint field); +/* GRand - a good and fast random number generator: Mersenne Twister + * see http://www.math.keio.ac.jp/~matumoto/emt.html for more info. + * The range functions return a value in the intervall [min,max). + * int -> [0..2^32-1] + * int_range -> [min..max-1] + * double -> [0..1) + * double_range -> [min..max) + */ + +GRand* g_rand_new_with_seed (guint32 seed); +GRand* g_rand_new (void); +void g_rand_free (GRand *rand); + +void g_rand_set_seed (GRand *rand, + guint32 seed); +guint32 g_rand_int (GRand *rand); +gint32 g_rand_int_range (GRand *rand, + gint32 min, + gint32 max); +gdouble g_rand_double (GRand *rand); +gdouble g_rand_double_range (GRand *rand, + gdouble min, + gdouble max); + +void g_random_set_seed (guint32 seed); +guint32 g_random_int (void); +gint32 g_random_int_range (gint32 min, + gint32 max); +gdouble g_random_double (void); +gdouble g_random_double_range (gdouble min, + gdouble max); + + /* Prime numbers. */ @@ -2091,83 +2548,329 @@ gpointer g_tuples_index (GTuples *tuples, guint g_spaced_primes_closest (guint num); -/* IO Channels. - * These are used for plug-in communication in the GIMP, for instance. - * On Unix, it's simply an encapsulated file descriptor (a pipe). - * On Windows, it's a handle to an anonymouos pipe, *and* (in the case - * of the writable end) a thread id to post a message to when you have written - * stuff. +/* GIOChannel */ + +typedef struct _GIOFuncs GIOFuncs; +typedef enum +{ + G_IO_ERROR_NONE, + G_IO_ERROR_AGAIN, + G_IO_ERROR_INVAL, + G_IO_ERROR_UNKNOWN +} GIOError; +typedef enum +{ + G_SEEK_CUR, + G_SEEK_SET, + G_SEEK_END +} GSeekType; +typedef enum +{ + G_IO_IN GLIB_SYSDEF_POLLIN, + G_IO_OUT GLIB_SYSDEF_POLLOUT, + G_IO_PRI GLIB_SYSDEF_POLLPRI, + G_IO_ERR GLIB_SYSDEF_POLLERR, + G_IO_HUP GLIB_SYSDEF_POLLHUP, + G_IO_NVAL GLIB_SYSDEF_POLLNVAL +} GIOCondition; + struct _GIOChannel { - gint fd; /* file handle (pseudo such in Win32) */ -#ifdef NATIVE_WIN32 - guint peer; /* thread to post message to */ - guint peer_fd; /* read handle (in the other process) */ - guint offset; /* counter of accumulated bytes, to - * be included in the message posted - * so we keep in sync. - */ - guint peer_offset; /* in input channels where the writer's - * offset is, so we don't try to read too much - */ -#endif + guint channel_flags; + guint ref_count; + GIOFuncs *funcs; }; -GIOChannel *g_iochannel_new (gint fd); -void g_iochannel_free (GIOChannel *channel); -void g_iochannel_close_and_free (GIOChannel *channel); -void g_iochannel_wakeup_peer (GIOChannel *channel); -#ifndef NATIVE_WIN32 -# define g_iochannel_wakeup_peer(channel) G_STMT_START { } G_STMT_END -#endif +typedef gboolean (*GIOFunc) (GIOChannel *source, + GIOCondition condition, + gpointer data); +struct _GIOFuncs +{ + GIOError (*io_read) (GIOChannel *channel, + gchar *buf, + guint count, + guint *bytes_read); + GIOError (*io_write) (GIOChannel *channel, + gchar *buf, + guint count, + guint *bytes_written); + GIOError (*io_seek) (GIOChannel *channel, + gint offset, + GSeekType type); + void (*io_close) (GIOChannel *channel); + guint (*io_add_watch) (GIOChannel *channel, + gint priority, + GIOCondition condition, + GIOFunc func, + gpointer user_data, + GDestroyNotify notify); + void (*io_free) (GIOChannel *channel); +}; +void g_io_channel_init (GIOChannel *channel); +void g_io_channel_ref (GIOChannel *channel); +void g_io_channel_unref (GIOChannel *channel); +GIOError g_io_channel_read (GIOChannel *channel, + gchar *buf, + guint count, + guint *bytes_read); +GIOError g_io_channel_write (GIOChannel *channel, + gchar *buf, + guint count, + guint *bytes_written); +GIOError g_io_channel_seek (GIOChannel *channel, + gint offset, + GSeekType type); +void g_io_channel_close (GIOChannel *channel); +guint g_io_add_watch_full (GIOChannel *channel, + gint priority, + GIOCondition condition, + GIOFunc func, + gpointer user_data, + GDestroyNotify notify); +guint g_io_add_watch (GIOChannel *channel, + GIOCondition condition, + GIOFunc func, + gpointer user_data); + + +/* Main loop + */ +typedef struct _GTimeVal GTimeVal; +typedef struct _GSourceFuncs GSourceFuncs; +typedef struct _GMainLoop GMainLoop; /* Opaque */ + +struct _GTimeVal +{ + glong tv_sec; + glong tv_usec; +}; +struct _GSourceFuncs +{ + gboolean (*prepare) (gpointer source_data, + GTimeVal *current_time, + gint *timeout, + gpointer user_data); + gboolean (*check) (gpointer source_data, + GTimeVal *current_time, + gpointer user_data); + gboolean (*dispatch) (gpointer source_data, + GTimeVal *dispatch_time, + gpointer user_data); + GDestroyNotify destroy; +}; -/* Windows emulation stubs for common unix functions +/* Standard priorities */ + +#define G_PRIORITY_HIGH -100 +#define G_PRIORITY_DEFAULT 0 +#define G_PRIORITY_HIGH_IDLE 100 +#define G_PRIORITY_DEFAULT_IDLE 200 +#define G_PRIORITY_LOW 300 + +typedef gboolean (*GSourceFunc) (gpointer data); + +/* Hooks for adding to the main loop */ +guint g_source_add (gint priority, + gboolean can_recurse, + GSourceFuncs *funcs, + gpointer source_data, + gpointer user_data, + GDestroyNotify notify); +gboolean g_source_remove (guint tag); +gboolean g_source_remove_by_user_data (gpointer user_data); +gboolean g_source_remove_by_source_data (gpointer source_data); +gboolean g_source_remove_by_funcs_user_data (GSourceFuncs *funcs, + gpointer user_data); + +void g_get_current_time (GTimeVal *result); + +/* Running the main loop */ +GMainLoop* g_main_new (gboolean is_running); +void g_main_run (GMainLoop *loop); +void g_main_quit (GMainLoop *loop); +void g_main_destroy (GMainLoop *loop); +gboolean g_main_is_running (GMainLoop *loop); + +/* Run a single iteration of the mainloop. If block is FALSE, + * will never block + */ +gboolean g_main_iteration (gboolean may_block); + +/* See if any events are pending */ +gboolean g_main_pending (void); + +/* Idles and timeouts */ +guint g_timeout_add_full (gint priority, + guint interval, + GSourceFunc function, + gpointer data, + GDestroyNotify notify); +guint g_timeout_add (guint interval, + GSourceFunc function, + gpointer data); +guint g_idle_add (GSourceFunc function, + gpointer data); +guint g_idle_add_full (gint priority, + GSourceFunc function, + gpointer data, + GDestroyNotify destroy); +gboolean g_idle_remove_by_data (gpointer data); + +/* GPollFD + * + * System-specific IO and main loop calls + * + * On Win32, the fd in a GPollFD should be Win32 HANDLE (*not* a file + * descriptor as provided by the C runtime) that can be used by + * MsgWaitForMultipleObjects. This does *not* include file handles + * from CreateFile, SOCKETs, nor pipe handles. (But you can use + * WSAEventSelect to signal events when a SOCKET is readable). + * + * On Win32, fd can also be the special value G_WIN32_MSG_HANDLE to + * indicate polling for messages. These message queue GPollFDs should + * be added with the g_main_poll_win32_msg_add function. + * + * But note that G_WIN32_MSG_HANDLE GPollFDs should not be used by GDK + * (GTK) programs, as GDK itself wants to read messages and convert them + * to GDK events. + * + * So, unless you really know what you are doing, it's best not to try + * to use the main loop polling stuff for your own needs on + * Win32. It's really only written for the GIMP's needs so + * far. */ -#ifdef NATIVE_WIN32 -#define MAXPATHLEN 1024 +typedef struct _GPollFD GPollFD; +typedef gint (*GPollFunc) (GPollFD *ufds, + guint nfsd, + gint timeout); +struct _GPollFD +{ + gint fd; + gushort events; + gushort revents; +}; + +void g_main_add_poll (GPollFD *fd, + gint priority); +void g_main_remove_poll (GPollFD *fd); +void g_main_set_poll_func (GPollFunc func); + +/* On Unix, IO channels created with this function for any file + * descriptor or socket. + * + * On Win32, use this only for plain files opened with the MSVCRT (the + * Microsoft run-time C library) _open(), including file descriptors + * 0, 1 and 2 (corresponding to stdin, stdout and stderr). + * Actually, don't do even that, this code isn't done yet. + * + * The term file descriptor as used in the context of Win32 refers to + * the emulated Unix-like file descriptors MSVCRT provides. + */ +GIOChannel* g_io_channel_unix_new (int fd); +gint g_io_channel_unix_get_fd (GIOChannel *channel); + +#ifdef G_OS_WIN32 + +GUTILS_C_VAR guint g_pipe_readable_msg; + +#define G_WIN32_MSG_HANDLE 19981206 + +/* This is used to add polling for Windows messages. GDK (GTk+) programs + * should *not* use this. (In fact, I can't think of any program that + * would want to use this, but it's here just for completeness's sake. + */ +void g_main_poll_win32_msg_add(gint priority, + GPollFD *fd, + guint hwnd); + +/* An IO channel for Windows messages for window handle hwnd. */ +GIOChannel *g_io_channel_win32_new_messages (guint hwnd); + +/* An IO channel for an anonymous pipe as returned from the MSVCRT + * _pipe(), with no mechanism for the writer to tell the reader when + * there is data in the pipe. + * + * This is not really implemented yet. + */ +GIOChannel *g_io_channel_win32_new_pipe (int fd); + +/* An IO channel for a pipe as returned from the MSVCRT _pipe(), with + * Windows user messages used to signal data in the pipe for the + * reader. + * + * fd is the file descriptor. For the write end, peer is the thread id + * of the reader, and peer_fd is his file descriptor for the read end + * of the pipe. + * + * This is used by the GIMP, and works. + */ +GIOChannel *g_io_channel_win32_new_pipe_with_wakeups (int fd, + guint peer, + int peer_fd); + +void g_io_channel_win32_pipe_request_wakeups (GIOChannel *channel, + guint peer, + int peer_fd); + +void g_io_channel_win32_pipe_readable (int fd, + guint offset); + +/* Get the C runtime file descriptor of a channel. */ +gint g_io_channel_win32_get_fd (GIOChannel *channel); + +/* An IO channel for a SOCK_STREAM winsock socket. The parameter is + * actually a SOCKET. + */ +GIOChannel *g_io_channel_win32_new_stream_socket (int socket); + +#endif + +/* Windows emulation stubs for common Unix functions + */ +#ifdef G_OS_WIN32 +# define MAXPATHLEN 1024 #ifdef _MSC_VER typedef int pid_t; +#endif -/* These POSIXish functions are available in the Microsoft C library - * prefixed with underscore (which of course technically speaking is - * the Right Thing, as they are non-ANSI. Not that being non-ANSI - * prevents Microsoft from practically requiring you to include - * every now and then...). - * - * You still need to include the appropriate headers to get the - * prototypes, or . +/* + * To get prototypes for the following POSIXish functions, you have to + * include the indicated non-POSIX headers. The functions are defined + * in OLDNAMES.LIB (MSVC) or -lmoldname-msvc (mingw32). * - * For some functions, we provide emulators in glib, which are prefixed - * with gwin_. - */ -#define getcwd _getcwd -#define getpid _getpid -#define access _access -#define open _open -#define read _read -#define write _write -#define lseek _lseek -#define close _close -#define pipe(phandles) _pipe (phandles, 4096, _O_BINARY) -#define popen _popen -#define pclose _pclose -#define fdopen _fdopen -#define ftruncate(fd, size) gwin_ftruncate (fd, size) -#define opendir gwin_opendir -#define readdir gwin_readdir -#define rewinddir gwin_rewinddir -#define closedir gwin_closedir - -#define NAME_MAX 255 + * getcwd: (MSVC), (mingw32) + * getpid: + * access: + * unlink: or + * open, read, write, lseek, close: + * rmdir: + * pipe: + */ + +/* pipe is not in OLDNAMES.LIB or -lmoldname-msvc. */ +#define pipe(phandles) _pipe (phandles, 4096, _O_BINARY) + +/* For some POSIX functions that are not provided by the MS runtime, + * we provide emulators in glib, which are prefixed with g_win32_. + */ +# define ftruncate(fd, size) g_win32_ftruncate (fd, size) + +/* -lmingw32 also has emulations for these, but we need our own + * for MSVC anyhow, so we might aswell use them always. + */ +# define opendir g_win32_opendir +# define readdir g_win32_readdir +# define rewinddir g_win32_rewinddir +# define closedir g_win32_closedir +# define NAME_MAX 255 struct DIR { gchar *dir_name; - gboolean just_opened; guint find_file_handle; gpointer find_file_data; @@ -2177,19 +2880,264 @@ struct dirent { gchar d_name[NAME_MAX + 1]; }; - /* emulation functions */ -extern int gwin_ftruncate (gint f, - guint size); -DIR* gwin_opendir (const gchar *dirname); -struct dirent* gwin_readdir (DIR *dir); -void gwin_rewinddir (DIR *dir); -gint gwin_closedir (DIR *dir); +extern int g_win32_ftruncate (gint f, + guint size); +DIR* g_win32_opendir (const gchar *dirname); +struct dirent* g_win32_readdir (DIR *dir); +void g_win32_rewinddir (DIR *dir); +gint g_win32_closedir (DIR *dir); + +/* The MS setlocale uses locale names of the form "English_United + * States.1252" etc. We want the Unixish standard form "en", "zh_TW" + * etc. This function gets the current thread locale from Windows and + * returns it as a string of the above form for use in forming file + * names etc. The returned string should be deallocated with g_free(). + */ +gchar * g_win32_getlocale (void); + +#endif /* G_OS_WIN32 */ + + +/* GLib Thread support + */ + +typedef void (*GThreadFunc) (gpointer value); -#endif /* _MSC_VER */ +typedef enum +{ + G_THREAD_PRIORITY_LOW, + G_THREAD_PRIORITY_NORMAL, + G_THREAD_PRIORITY_HIGH, + G_THREAD_PRIORITY_URGENT +} GThreadPriority; + +typedef struct _GThread GThread; +struct _GThread +{ + GThreadPriority priority; + gboolean bound; + gboolean joinable; +}; + +typedef struct _GMutex GMutex; +typedef struct _GCond GCond; +typedef struct _GPrivate GPrivate; +typedef struct _GStaticPrivate GStaticPrivate; + +typedef struct _GThreadFunctions GThreadFunctions; +struct _GThreadFunctions +{ + GMutex* (*mutex_new) (void); + void (*mutex_lock) (GMutex *mutex); + gboolean (*mutex_trylock) (GMutex *mutex); + void (*mutex_unlock) (GMutex *mutex); + void (*mutex_free) (GMutex *mutex); + GCond* (*cond_new) (void); + void (*cond_signal) (GCond *cond); + void (*cond_broadcast) (GCond *cond); + void (*cond_wait) (GCond *cond, + GMutex *mutex); + gboolean (*cond_timed_wait) (GCond *cond, + GMutex *mutex, + GTimeVal *end_time); + void (*cond_free) (GCond *cond); + GPrivate* (*private_new) (GDestroyNotify destructor); + gpointer (*private_get) (GPrivate *private_key); + void (*private_set) (GPrivate *private_key, + gpointer data); + void (*thread_create) (GThreadFunc thread_func, + gpointer arg, + gulong stack_size, + gboolean joinable, + gboolean bound, + GThreadPriority priority, + gpointer thread); + void (*thread_yield) (void); + void (*thread_join) (gpointer thread); + void (*thread_exit) (void); + void (*thread_set_priority)(gpointer thread, + GThreadPriority priority); + void (*thread_self) (gpointer thread); +}; -#endif /* NATIVE_WIN32 */ +GUTILS_C_VAR GThreadFunctions g_thread_functions_for_glib_use; +GUTILS_C_VAR gboolean g_thread_use_default_impl; +GUTILS_C_VAR gboolean g_threads_got_initialized; + +/* initializes the mutex/cond/private implementation for glib, might + * only be called once, and must not be called directly or indirectly + * from another glib-function, e.g. as a callback. + */ +void g_thread_init (GThreadFunctions *vtable); + +/* internal function for fallback static mutex implementation */ +GMutex* g_static_mutex_get_mutex_impl (GMutex **mutex); + +/* shorthands for conditional and unconditional function calls */ +#define G_THREAD_UF(name, arglist) \ + (*g_thread_functions_for_glib_use . name) arglist +#define G_THREAD_CF(name, fail, arg) \ + (g_thread_supported () ? G_THREAD_UF (name, arg) : (fail)) +/* keep in mind, all those mutexes and static mutexes are not + * recursive in general, don't rely on that + */ +#define g_thread_supported() (g_threads_got_initialized) +#define g_mutex_new() G_THREAD_UF (mutex_new, ()) +#define g_mutex_lock(mutex) G_THREAD_CF (mutex_lock, (void)0, (mutex)) +#define g_mutex_trylock(mutex) G_THREAD_CF (mutex_trylock, TRUE, (mutex)) +#define g_mutex_unlock(mutex) G_THREAD_CF (mutex_unlock, (void)0, (mutex)) +#define g_mutex_free(mutex) G_THREAD_CF (mutex_free, (void)0, (mutex)) +#define g_cond_new() G_THREAD_UF (cond_new, ()) +#define g_cond_signal(cond) G_THREAD_CF (cond_signal, (void)0, (cond)) +#define g_cond_broadcast(cond) G_THREAD_CF (cond_broadcast, (void)0, (cond)) +#define g_cond_wait(cond, mutex) G_THREAD_CF (cond_wait, (void)0, (cond, \ + mutex)) +#define g_cond_free(cond) G_THREAD_CF (cond_free, (void)0, (cond)) +#define g_cond_timed_wait(cond, mutex, abs_time) G_THREAD_CF (cond_timed_wait, \ + TRUE, \ + (cond, mutex, \ + abs_time)) +#define g_private_new(destructor) G_THREAD_UF (private_new, (destructor)) +#define g_private_get(private_key) G_THREAD_CF (private_get, \ + ((gpointer)private_key), \ + (private_key)) +#define g_private_set(private_key, value) G_THREAD_CF (private_set, \ + (void) (private_key = \ + (GPrivate*) (value)), \ + (private_key, value)) +#define g_thread_yield() G_THREAD_CF (thread_yield, (void)0, ()) +#define g_thread_exit() G_THREAD_CF (thread_exit, (void)0, ()) + +GThread* g_thread_create (GThreadFunc thread_func, + gpointer arg, + gulong stack_size, + gboolean joinable, + gboolean bound, + GThreadPriority priority); +GThread* g_thread_self (); +void g_thread_join (GThread* thread); +void g_thread_set_priority (GThread* thread, + GThreadPriority priority); + +/* GStaticMutexes can be statically initialized with the value + * G_STATIC_MUTEX_INIT, and then they can directly be used, that is + * much easier, than having to explicitly allocate the mutex before + * use + */ +#define g_static_mutex_lock(mutex) \ + g_mutex_lock (g_static_mutex_get_mutex (mutex)) +#define g_static_mutex_trylock(mutex) \ + g_mutex_trylock (g_static_mutex_get_mutex (mutex)) +#define g_static_mutex_unlock(mutex) \ + g_mutex_unlock (g_static_mutex_get_mutex (mutex)) + +struct _GStaticPrivate +{ + guint index; +}; +#define G_STATIC_PRIVATE_INIT { 0 } +gpointer g_static_private_get (GStaticPrivate *private_key); +void g_static_private_set (GStaticPrivate *private_key, + gpointer data, + GDestroyNotify notify); +gpointer g_static_private_get_for_thread (GStaticPrivate *private_key, + GThread *thread); +void g_static_private_set_for_thread (GStaticPrivate *private_key, + GThread *thread, + gpointer data, + GDestroyNotify notify); +#ifndef G_STATIC_REC_MUTEX_INIT +/* if GStaticRecMutex is not just a differently initialized GStaticMutex, + * the following is done: + * This can't be done in glibconfig.h, as GStaticPrivate and gboolean + * are not yet known there + */ +typedef struct _GStaticRecMutex GStaticRecMutex; +struct _GStaticRecMutex +{ + GStaticMutex mutex; + GStaticPrivate counter; +}; +#define G_STATIC_REC_MUTEX_INIT { G_STATIC_MUTEX_INIT, G_STATIC_PRIVATE_INIT } +void g_static_rec_mutex_lock (GStaticRecMutex* mutex); +gboolean g_static_rec_mutex_trylock (GStaticRecMutex* mutex); +void g_static_rec_mutex_unlock (GStaticRecMutex* mutex); +#define g_static_rec_mutex_get_mutex(mutex) ((mutex)->mutex) +#endif /* G_STATIC_REC_MUTEX_INIT */ + +typedef struct _GStaticRWLock GStaticRWLock; +struct _GStaticRWLock +{ + GStaticMutex mutex; + GCond *read_cond; + GCond *write_cond; + guint read_counter; + gboolean write; + guint want_to_write; +}; +#define G_STATIC_RW_LOCK_INIT { G_STATIC_MUTEX_INIT, NULL, NULL, 0, FALSE, FALSE } + +void g_static_rw_lock_reader_lock (GStaticRWLock* lock); +gboolean g_static_rw_lock_reader_trylock (GStaticRWLock* lock); +void g_static_rw_lock_reader_unlock (GStaticRWLock* lock); +void g_static_rw_lock_writer_lock (GStaticRWLock* lock); +gboolean g_static_rw_lock_writer_trylock (GStaticRWLock* lock); +void g_static_rw_lock_writer_unlock (GStaticRWLock* lock); +void g_static_rw_lock_free (GStaticRWLock* lock); + +/* these are some convenience macros that expand to nothing if GLib + * was configured with --disable-threads. for using StaticMutexes, + * you define them with G_LOCK_DEFINE_STATIC (name) or G_LOCK_DEFINE (name) + * if you need to export the mutex. With G_LOCK_EXTERN (name) you can + * declare such an globally defined lock. name is a unique identifier + * for the protected varibale or code portion. locking, testing and + * unlocking of such mutexes can be done with G_LOCK(), G_UNLOCK() and + * G_TRYLOCK() respectively. + */ +extern void glib_dummy_decl (void); +#define G_LOCK_NAME(name) (g__ ## name ## _lock) +#ifdef G_THREADS_ENABLED +# define G_LOCK_DEFINE_STATIC(name) static G_LOCK_DEFINE (name) +# define G_LOCK_DEFINE(name) \ + GStaticMutex G_LOCK_NAME (name) = G_STATIC_MUTEX_INIT +# define G_LOCK_EXTERN(name) extern GStaticMutex G_LOCK_NAME (name) + +# ifdef G_DEBUG_LOCKS +# define G_LOCK(name) G_STMT_START{ \ + g_log (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, \ + "file %s: line %d (%s): locking: %s ", \ + __FILE__, __LINE__, G_GNUC_PRETTY_FUNCTION, \ + #name); \ + g_static_mutex_lock (&G_LOCK_NAME (name)); \ + }G_STMT_END +# define G_UNLOCK(name) G_STMT_START{ \ + g_log (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, \ + "file %s: line %d (%s): unlocking: %s ", \ + __FILE__, __LINE__, G_GNUC_PRETTY_FUNCTION, \ + #name); \ + g_static_mutex_unlock (&G_LOCK_NAME (name)); \ + }G_STMT_END +# define G_TRYLOCK(name) G_STMT_START{ \ + g_log (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, \ + "file %s: line %d (%s): try locking: %s ", \ + __FILE__, __LINE__, G_GNUC_PRETTY_FUNCTION, \ + #name); \ + }G_STMT_END, g_static_mutex_trylock (&G_LOCK_NAME (name)) +# else /* !G_DEBUG_LOCKS */ +# define G_LOCK(name) g_static_mutex_lock (&G_LOCK_NAME (name)) +# define G_UNLOCK(name) g_static_mutex_unlock (&G_LOCK_NAME (name)) +# define G_TRYLOCK(name) g_static_mutex_trylock (&G_LOCK_NAME (name)) +# endif /* !G_DEBUG_LOCKS */ +#else /* !G_THREADS_ENABLED */ +# define G_LOCK_DEFINE_STATIC(name) extern void glib_dummy_decl (void) +# define G_LOCK_DEFINE(name) extern void glib_dummy_decl (void) +# define G_LOCK_EXTERN(name) extern void glib_dummy_decl (void) +# define G_LOCK(name) +# define G_UNLOCK(name) +# define G_TRYLOCK(name) (TRUE) +#endif /* !G_THREADS_ENABLED */ #ifdef __cplusplus }