X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=glib.h;h=dd9fa5a69599da681d26febad064a36557e6d8df;hb=8384a1342edda081d962f934838d1a4dc347a72c;hp=bfd1f49bf2ced58df8220c837de66bbf2944405a;hpb=3aa65d30eb2dfeb63956a38ec9c5296477712888;p=platform%2Fupstream%2Fglib.git diff --git a/glib.h b/glib.h index bfd1f49..dd9fa5a 100644 --- a/glib.h +++ b/glib.h @@ -27,6 +27,19 @@ #ifndef __G_LIB_H__ #define __G_LIB_H__ +/* Here we provide G_GNUC_EXTENSION as an alias for __extension__, + * where this is valid. This allows for warningless compilation of + * "long long" types even in the presence of '-ansi -pedantic'. This + * of course should be with the other GCC-isms below, but then + * glibconfig.h wouldn't load cleanly and it is better to have that + * here, than in glibconfig.h. + */ +#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 8) +# define G_GNUC_EXTENSION __extension__ +#else +# define G_GNUC_EXTENSION +#endif + /* system specific config file glibconfig.h provides definitions for * the extrema of many of the standard types. These are: * @@ -49,22 +62,29 @@ * 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) + * 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: + * Finally, it provides the following wrappers to STDC functions: * - * g_ATEXIT - * To register hooks which are executed on exit(). - * Usually a wrapper for STDC atexit. - * - * 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. */ #include +/* Define some mathematical constants that aren't available + * symbolically in some strict ISO C implementations. + */ +#define G_E 2.7182818284590452354E0 +#define G_LN2 6.9314718055994530942E-1 +#define G_LN10 2.3025850929940456840E0 +#define G_PI 3.14159265358979323846E0 +#define G_PI_2 1.57079632679489661923E0 +#define G_PI_4 0.78539816339744830962E0 +#define G_SQRT2 1.4142135623730950488E0 + /* include varargs functions for assertment macros */ #include @@ -76,7 +96,7 @@ #endif -#ifdef NATIVE_WIN32 +#ifdef G_OS_WIN32 /* On native Win32, directory separator is the backslash, and search path * separator is the semicolon. @@ -86,7 +106,7 @@ #define G_SEARCHPATH_SEPARATOR ';' #define G_SEARCHPATH_SEPARATOR_S ";" -#else /* !NATIVE_WIN32 */ +#else /* !G_OS_WIN32 */ /* Unix */ @@ -95,7 +115,7 @@ #define G_SEARCHPATH_SEPARATOR ':' #define G_SEARCHPATH_SEPARATOR_S ":" -#endif /* !NATIVE_WIN32 */ +#endif /* !G_OS_WIN32 */ #ifdef __cplusplus extern "C" { @@ -107,8 +127,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 @@ -131,6 +155,22 @@ 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 + +/* provide a string identifying the current code position */ +#ifdef __GNUC__ +# define G_STRLOC __FILE__ ":" G_STRINGIFY (__LINE__) ":" __PRETTY_FUNCTION__ "()" +#else +# define G_STRLOC __FILE__ ":" G_STRINGIFY (__LINE__) +#endif + + +/* 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. @@ -150,9 +190,9 @@ extern "C" { * fields through their offsets. */ #define G_STRUCT_OFFSET(struct_type, member) \ - ((gulong) ((gchar*) &((struct_type*) 0)->member)) + ((glong) ((guint8*) &((struct_type*) 0)->member)) #define G_STRUCT_MEMBER_P(struct_p, struct_offset) \ - ((gpointer) ((gchar*) (struct_p) + (gulong) (struct_offset))) + ((gpointer) ((guint8*) (struct_p) + (glong) (struct_offset))) #define G_STRUCT_MEMBER(member_type, struct_p, struct_offset) \ (*(member_type*) G_STRUCT_MEMBER_P ((struct_p), (struct_offset))) @@ -257,16 +297,15 @@ extern "C" { #define G_GNUC_UNUSED #endif /* !__GNUC__ */ - /* Wrap the gcc __PRETTY_FUNCTION__ and __FUNCTION__ variables with * 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 @@ -326,9 +365,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 @@ -464,6 +500,7 @@ typedef short gshort; typedef long glong; typedef int gint; typedef gint gboolean; +typedef gchar* gstring; typedef unsigned char guchar; typedef unsigned short gushort; @@ -659,15 +696,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 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; @@ -690,6 +727,8 @@ 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; @@ -703,15 +742,16 @@ typedef struct _GRelation GRelation; typedef struct _GScanner GScanner; typedef struct _GScannerConfig GScannerConfig; typedef struct _GSList GSList; -typedef struct _GStack GStack; 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, @@ -720,6 +760,7 @@ typedef enum G_TRAVERSE_MASK = 0x03 } GTraverseFlags; +/* Tree traverse orders */ typedef enum { G_IN_ORDER, @@ -796,8 +837,6 @@ typedef gboolean (*GNodeTraverseFunc) (GNode *node, gpointer data); typedef void (*GNodeForeachFunc) (GNode *node, gpointer data); -typedef gint (*GSearchFunc) (gpointer key, - gpointer data); typedef void (*GScannerMsgFunc) (GScanner *scanner, gchar *message, gint error); @@ -807,6 +846,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; @@ -814,22 +871,23 @@ struct _GList GList *prev; }; -struct _GSList +struct _GPtrArray { - gpointer data; - GSList *next; + gpointer *pdata; + guint len; }; -struct _GStack +struct _GQueue { - GList *list; + GList *head; + GList *tail; + guint length; }; -struct _GQueue +struct _GSList { - GList *list; - GList *list_end; - guint list_size; + gpointer data; + GSList *next; }; struct _GString @@ -838,34 +896,81 @@ 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 @@ -887,25 +992,25 @@ GList* g_list_insert_sorted (GList *list, GCompareFunc func); GList* g_list_concat (GList *list1, GList *list2); -GList* g_list_delete (GList *list, - GList *link); GList* g_list_remove (GList *list, - gpointer data); + gconstpointer 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, - gpointer data); + gconstpointer data); GList* g_list_find_custom (GList *list, - gpointer data, + gconstpointer data, GCompareFunc func); gint g_list_position (GList *list, GList *llink); gint g_list_index (GList *list, - gpointer data); + gconstpointer data); GList* g_list_last (GList *list); GList* g_list_first (GList *list); guint g_list_length (GList *list); @@ -937,25 +1042,30 @@ GSList* g_slist_insert (GSList *list, GSList* g_slist_insert_sorted (GSList *list, gpointer data, GCompareFunc func); +GSList* g_slist_insert_before (GSList *slist, + GSList *sibling, + gpointer data); GSList* g_slist_concat (GSList *list1, GSList *list2); GSList* g_slist_remove (GSList *list, - gpointer data); + gconstpointer 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, - gpointer data); + gconstpointer data); GSList* g_slist_find_custom (GSList *list, - gpointer data, + gconstpointer data, GCompareFunc func); gint g_slist_position (GSList *list, GSList *llink); gint g_slist_index (GSList *list, - gpointer data); + gconstpointer data); GSList* g_slist_last (GSList *list); guint g_slist_length (GSList *list); void g_slist_foreach (GSList *list, @@ -965,68 +1075,28 @@ 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) - - -/* Stacks - */ - -GStack * g_stack_new (void); -void g_stack_free (GStack *stack); -gpointer g_stack_pop (GStack *stack); - -#define g_stack_empty(stack) \ - ((((GStack *)(stack)) && ((GStack *)(stack))->list) ? FALSE : TRUE) - -#define g_stack_peek(stack) \ - ((((GStack *)(stack)) && ((GStack *)(stack))->list) ? \ - ((GStack *)(stack))->list->data : NULL) - -#define g_stack_index(stack,ptr) \ - ((((GStack *)(stack)) && ((GStack *)(stack))->list) ? \ - g_list_index (((GStack *)(stack))->list, (ptr)) : -1) - -#define g_stack_push(stack,data) G_STMT_START { \ - if ((GStack *)(stack)) \ - ((GStack *)(stack))->list = \ - g_list_prepend (((GStack *)(stack))->list, (data)); \ - } G_STMT_END - +#define g_slist_next(slist) ((slist) ? (((GSList *)(slist))->next) : NULL) /* Queues */ - -GQueue * g_queue_new (void); -void g_queue_free (GQueue *q); -guint g_queue_get_size (GQueue *q); -void g_queue_push_front (GQueue *q, gpointer data); -void g_queue_push_back (GQueue *q, gpointer data); -gpointer g_queue_pop_front (GQueue *q); -gpointer g_queue_pop_back (GQueue *q); - -#define g_queue_empty(queue) \ - ((((GQueue *)(queue)) && ((GQueue *)(queue))->list) ? FALSE : TRUE) - -#define g_queue_peek_front(queue) \ - ((((GQueue *)(queue)) && ((GQueue *)(queue))->list) ? \ - ((GQueue *)(queue))->list->data : NULL) - -#define g_queue_peek_back(queue) \ - ((((GQueue *)(queue)) && ((GQueue *)(queue))->list_end) ? \ - ((GQueue *)(queue))->list_end->data : NULL) - -#define g_queue_index(queue,ptr) \ - ((((GQueue *)(queue)) && ((GQueue *)(queue))->list) ? \ - g_list_index (((GQueue *)(queue))->list, (ptr)) : -1) - -#define g_queue_push g_queue_push_back -#define g_queue_pop g_queue_pop_front -#define g_queue_peek g_queue_peek_front - - - - +GQueue* g_queue_new (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 */ @@ -1068,7 +1138,7 @@ void g_cache_destroy (GCache *cache); gpointer g_cache_insert (GCache *cache, gpointer key); void g_cache_remove (GCache *cache, - gpointer value); + gconstpointer value); void g_cache_key_foreach (GCache *cache, GHFunc func, gpointer user_data); @@ -1085,16 +1155,16 @@ void g_tree_insert (GTree *tree, gpointer key, gpointer value); void g_tree_remove (GTree *tree, - gpointer key); + gconstpointer key); gpointer g_tree_lookup (GTree *tree, - gpointer key); + gconstpointer key); void g_tree_traverse (GTree *tree, GTraverseFunc traverse_func, GTraverseType traverse_type, gpointer data); gpointer g_tree_search (GTree *tree, - GSearchFunc search_func, - gpointer data); + GCompareFunc search_func, + gconstpointer data); gint g_tree_height (GTree *tree); gint g_tree_nnodes (GTree *tree); @@ -1121,6 +1191,7 @@ void g_node_pop_allocator (void); GNode* g_node_new (gpointer data); void g_node_destroy (GNode *root); void g_node_unlink (GNode *node); +GNode* g_node_copy (GNode *node); GNode* g_node_insert (GNode *parent, gint position, GNode *node); @@ -1500,6 +1571,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); @@ -1507,7 +1581,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. @@ -1516,6 +1590,9 @@ gdouble g_timer_elapsed (GTimer *timer, gchar* g_strdelimit (gchar *string, const gchar *delimiters, gchar new_delimiter); +gchar* g_strcanon (gchar *string, + const gchar *valid_chars, + gchar subsitutor); gdouble g_strtod (const gchar *nptr, gchar **endptr); gchar* g_strerror (gint errnum); @@ -1525,9 +1602,9 @@ gint g_strcasecmp (const gchar *s1, gint g_strncasecmp (const gchar *s1, const gchar *s2, guint n); -void g_strdown (gchar *string); -void g_strup (gchar *string); -void g_strreverse (gchar *string); +gchar* g_strdown (gchar *string); +gchar* g_strup (gchar *string); +gchar* g_strreverse (gchar *string); /* removes leading spaces */ gchar* g_strchug (gchar *string); /* removes trailing spaces */ @@ -1536,7 +1613,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, @@ -1551,7 +1628,29 @@ 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); + +/* 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); + +/* 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. + * + * Deprecated API: gchar* g_strescape (const gchar *source); + * Luckily this function wasn't used much, using NULL as second parameter + * provides mostly identical semantics. + */ +gchar* g_strescape (const gchar *source, + const gchar *exceptions); + gpointer g_memdup (gconstpointer mem, guint byte_size); @@ -1609,8 +1708,13 @@ gchar* g_path_skip_root (gchar *file_name); /* strings are newly allocated with g_malloc() */ gchar* g_dirname (const gchar *file_name); gchar* g_get_current_dir (void); -gchar* g_getenv (const gchar *variable); +/* Get the codeset for the current locale */ +/* gchar * g_get_codeset (void); */ + +/* return the environment string for the variable. The returned memory + * must not be freed. */ +gchar* g_getenv (const gchar *variable); /* we use a GLib function as a replacement for ATEXIT, so * the programmer is not required to check the return value @@ -1677,6 +1781,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); @@ -1689,39 +1861,52 @@ 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, + gboolean free_segment); +gboolean g_string_equal (const GString *v, + const GString *v2); +guint g_string_hash (const GString *str); +GString* g_string_assign (GString *string, + const gchar *rval); +GString* g_string_truncate (GString *string, + guint len); +GString* g_string_insert_len (GString *string, + gint pos, + const gchar *val, + gint len); +GString* g_string_append (GString *string, + const gchar *val); +GString* g_string_append_len (GString *string, + const gchar *val, + gint len); +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_prepend_len (GString *string, + const gchar *val, + gint len); +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 @@ -1737,6 +1922,10 @@ void g_string_sprintfa (GString *string, GArray* g_array_new (gboolean zero_terminated, gboolean clear, guint element_size); +GArray* g_array_sized_new (gboolean zero_terminated, + gboolean clear, + guint element_size, + guint reserved_size); void g_array_free (GArray *array, gboolean free_segment); GArray* g_array_append_vals (GArray *array, @@ -1763,6 +1952,7 @@ GArray* g_array_remove_index_fast (GArray *array, */ #define g_ptr_array_index(array,index) (array->pdata)[index] GPtrArray* g_ptr_array_new (void); +GPtrArray* g_ptr_array_sized_new (guint reserved_size); void g_ptr_array_free (GPtrArray *array, gboolean free_seg); void g_ptr_array_set_size (GPtrArray *array, @@ -1783,6 +1973,7 @@ void g_ptr_array_add (GPtrArray *array, */ GByteArray* g_byte_array_new (void); +GByteArray* g_byte_array_sized_new (guint reserved_size); void g_byte_array_free (GByteArray *array, gboolean free_segment); GByteArray* g_byte_array_append (GByteArray *array, @@ -1801,13 +1992,13 @@ GByteArray* g_byte_array_remove_index_fast (GByteArray *array, /* Hash Functions */ -gint g_str_equal (gconstpointer v, - gconstpointer v2); -guint g_str_hash (gconstpointer v); +gboolean g_str_equal (gconstpointer v, + gconstpointer v2); +guint g_str_hash (gconstpointer v); -gint g_int_equal (gconstpointer v, - gconstpointer v2); -guint g_int_hash (gconstpointer v); +gint g_int_equal (gconstpointer v, + gconstpointer v2); +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 @@ -1838,7 +2029,7 @@ void g_datalist_id_set_data_full (GData **datalist, GQuark key_id, gpointer data, GDestroyNotify destroy_func); -void g_datalist_id_remove_no_notify (GData **datalist, +gpointer g_datalist_id_remove_no_notify (GData **datalist, GQuark key_id); void g_datalist_foreach (GData **datalist, GDataForeachFunc func, @@ -1868,7 +2059,7 @@ void g_dataset_id_set_data_full (gconstpointer dataset_location, GQuark key_id, gpointer data, GDestroyNotify destroy_func); -void g_dataset_id_remove_no_notify (gconstpointer dataset_location, +gpointer g_dataset_id_remove_no_notify (gconstpointer dataset_location, GQuark key_id); void g_dataset_foreach (gconstpointer dataset_location, GDataForeachFunc func, @@ -1895,6 +2086,7 @@ void g_dataset_foreach (gconstpointer dataset_location, /* Character sets */ #define G_CSET_A_2_Z "ABCDEFGHIJKLMNOPQRSTUVWXYZ" #define G_CSET_a_2_z "abcdefghijklmnopqrstuvwxyz" +#define G_CSET_DIGITS "0123456789" #define G_CSET_LATINC "\300\301\302\303\304\305\306"\ "\307\310\311\312\313\314\315\316\317\320"\ "\321\322\323\324\325\326"\ @@ -2393,11 +2585,6 @@ gdouble g_rand_double (GRand *rand); gdouble g_rand_double_range (GRand *rand, gdouble min, gdouble max); -/* This might go in, if -lm is no problem for you guys -gdouble g_rand_normal (GRand *rand, - gdouble mean, - gdouble standard_deviation); -*/ void g_random_set_seed (guint32 seed); guint32 g_random_int (void); @@ -2406,10 +2593,6 @@ gint32 g_random_int_range (gint32 min, gdouble g_random_double (void); gdouble g_random_double_range (gdouble min, gdouble max); -/* dito -gdouble g_random_normal (gdouble mean, - gdouble standard_deviation); -*/ /* Prime numbers. @@ -2526,12 +2709,14 @@ struct _GSourceFuncs { gboolean (*prepare) (gpointer source_data, GTimeVal *current_time, - gint *timeout); + gint *timeout, + gpointer user_data); gboolean (*check) (gpointer source_data, - GTimeVal *current_time); - gboolean (*dispatch) (gpointer source_data, GTimeVal *current_time, gpointer user_data); + gboolean (*dispatch) (gpointer source_data, + GTimeVal *dispatch_time, + gpointer user_data); GDestroyNotify destroy; }; @@ -2558,7 +2743,7 @@ 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); +void g_get_current_time (GTimeVal *result); /* Running the main loop */ GMainLoop* g_main_new (gboolean is_running); @@ -2646,7 +2831,7 @@ void g_main_set_poll_func (GPollFunc func); GIOChannel* g_io_channel_unix_new (int fd); gint g_io_channel_unix_get_fd (GIOChannel *channel); -#ifdef NATIVE_WIN32 +#ifdef G_OS_WIN32 GUTILS_C_VAR guint g_pipe_readable_msg; @@ -2704,41 +2889,44 @@ GIOChannel *g_io_channel_win32_new_stream_socket (int socket); /* Windows emulation stubs for common Unix functions */ -#ifdef NATIVE_WIN32 +#ifdef G_OS_WIN32 # define MAXPATHLEN 1024 -# ifdef _MSC_VER + +#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 + * 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; @@ -2752,43 +2940,92 @@ 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); -# endif /* _MSC_VER */ -#endif /* NATIVE_WIN32 */ +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); + +/* Translate a Win32 error code (as returned by GetLastError()) into + * the corresponding message. The returned string should be deallocated + * with g_free(). + */ +gchar * g_win32_error_message (gint error); + +#endif /* G_OS_WIN32 */ /* GLib Thread support */ + +typedef void (*GThreadFunc) (gpointer value); + +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 _GAsyncQueue GAsyncQueue; +typedef struct _GThreadPool GThreadPool; + 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); + 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); }; GUTILS_C_VAR GThreadFunctions g_thread_functions_for_glib_use; @@ -2836,6 +3073,20 @@ GMutex* g_static_mutex_get_mutex_impl (GMutex **mutex); (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 @@ -2847,6 +3098,7 @@ GMutex* g_static_mutex_get_mutex_impl (GMutex **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; @@ -2856,6 +3108,49 @@ 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); + +typedef struct _GStaticRecMutex GStaticRecMutex; +struct _GStaticRecMutex +{ + GStaticMutex mutex; + unsigned int depth; + GSystemThread owner; +}; + +#define G_STATIC_REC_MUTEX_INIT { G_STATIC_MUTEX_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); +void g_static_rec_mutex_lock_full (GStaticRecMutex *mutex, + guint depth); +guint g_static_rec_mutex_unlock_full (GStaticRecMutex *mutex); + +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, @@ -2867,7 +3162,7 @@ void g_static_private_set (GStaticPrivate *private_key, * G_TRYLOCK() respectively. */ extern void glib_dummy_decl (void); -#define G_LOCK_NAME(name) (g__ ## name ## _lock) +#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) \ @@ -2889,12 +3184,11 @@ extern void glib_dummy_decl (void); #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, \ +# define G_TRYLOCK(name) \ + (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)) + #name), 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)) @@ -2906,12 +3200,135 @@ 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) (FALSE) +# define G_TRYLOCK(name) (TRUE) #endif /* !G_THREADS_ENABLED */ +/* Asyncronous Queues, can be used to communicate between threads + */ + +/* Get a new GAsyncQueue with the ref_count 1 */ +GAsyncQueue* g_async_queue_new (void); + +/* Lock and unlock an GAsyncQueue, all functions lock the queue for + * themselves, but in certain cirumstances you want to hold the lock longer, + * thus you lock the queue, call the *_unlocked functions and unlock it again + */ +void g_async_queue_lock (GAsyncQueue *queue); +void g_async_queue_unlock (GAsyncQueue *queue); + +/* Ref and unref the GAsyncQueue. g_async_queue_unref_unlocked makes + * no sense, as after the unreffing the Queue might be gone and can't + * be unlocked. So you have a function to call, if you don't hold the + * lock (g_async_queue_unref) and one to call, when you already hold + * the lock (g_async_queue_unref_and_unlock). After that however, you + * don't hold the lock anymore and the Queue might in fact be + * destroyed, if you unrefed to zero */ +void g_async_queue_ref (GAsyncQueue *queue); +void g_async_queue_ref_unlocked (GAsyncQueue *queue); +void g_async_queue_unref (GAsyncQueue *queue); +void g_async_queue_unref_and_unlock (GAsyncQueue *queue); + +/* Push data into the async queue. Must not be NULL */ +void g_async_queue_push (GAsyncQueue *queue, + gpointer data); +void g_async_queue_push_unlocked (GAsyncQueue *queue, + gpointer data); + +/* Pop data from the async queue, when no data is there, the thread is blocked + * until data arrives */ +gpointer g_async_queue_pop (GAsyncQueue *queue); +gpointer g_async_queue_pop_unlocked (GAsyncQueue *queue); + +/* Try to pop data, NULL is returned in case of empty queue */ +gpointer g_async_queue_try_pop (GAsyncQueue *queue); +gpointer g_async_queue_try_pop_unlocked (GAsyncQueue *queue); + +/* Wait for data until at maximum until end_time is reached, NULL is returned + * in case of empty queue*/ +gpointer g_async_queue_timed_pop (GAsyncQueue *queue, + GTimeVal *end_time); +gpointer g_async_queue_timed_pop_unlocked (GAsyncQueue *queue, + GTimeVal *end_time); + +/* Return the length of the queue, negative values mean, that threads + * are waiting, positve values mean, that there are entries in the + * queue. Actually this function returns the length of the queue minus + * the number of waiting threads, g_async_queue_length == 0 could also + * mean 'n' entries in the queue and 'n' thread waiting, such can + * happen due to locking of the queue or due to scheduling. */ +gint g_async_queue_length (GAsyncQueue *queue); +gint g_async_queue_length_unlocked (GAsyncQueue *queue); + +/* Thread Pools + */ + +/* The real GThreadPool is bigger, so you may only create a thread + * pool with the constructor function */ +struct _GThreadPool +{ + GFunc thread_func; + gulong stack_size; + gboolean bound; + GThreadPriority priority; + gboolean exclusive; + gpointer user_data; +}; + +/* Get a thread pool with the function thread_func, at most max_threads may + * run at a time (max_threads == -1 means no limit), stack_size, bound, + * priority like in g_thread_create, exclusive == TRUE means, that the threads + * shouldn't be shared and that they will be prestarted (otherwise they are + * started, as needed) user_data is the 2nd argument to the thread_func */ +GThreadPool* g_thread_pool_new (GFunc thread_func, + gint max_threads, + gulong stack_size, + gboolean bound, + GThreadPriority priority, + gboolean exclusive, + gpointer user_data); + +/* Push new data into the thread pool. This task is assigned to a thread later + * (when the maximal number of threads is reached for that pool) or now + * (otherwise). If necessary a new thread will be started. The function + * returns immediatly */ +void g_thread_pool_push (GThreadPool *pool, + gpointer data); + +/* Set the number of threads, which can run concurrently for that pool, -1 + * means no limit. 0 means has the effect, that the pool won't process + * requests until the limit is set higher again */ +void g_thread_pool_set_max_threads (GThreadPool *pool, + gint max_threads); +gint g_thread_pool_get_max_threads (GThreadPool *pool); + +/* Get the number of threads assigned to that pool. This number doesn't + * necessarily represent the number of working threads in that pool */ +guint g_thread_pool_get_num_threads (GThreadPool *pool); + +/* Get the number of unprocessed items in the pool */ +guint g_thread_pool_unprocessed (GThreadPool *pool); + +/* Free the pool, immediate means, that all unprocessed items in the queue + * wont be processed, wait means, that the function doesn't return immediatly, + * but after all threads in the pool are ready processing items. immediate + * does however not mean, that threads are killed. */ +void g_thread_pool_free (GThreadPool *pool, + gboolean immediate, + gboolean wait); + +/* Set the maximal number of unused threads before threads will be stopped by + * GLib, -1 means no limit */ +void g_thread_pool_set_max_unused_threads (gint max_threads); +gint g_thread_pool_get_max_unused_threads (void); +guint g_thread_pool_get_num_unused_threads (void); + +/* Stop all currently unused threads, but leave the limit untouched */ +void g_thread_pool_stop_unused_threads (void); + +#include + #ifdef __cplusplus } #endif /* __cplusplus */ - #endif /* __G_LIB_H__ */