X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=glib%2Fglib.h;h=c2f32feccf581f44bbf306d3bd1fc6fecc92c2da;hb=349eaa6a256ac3ab33f3b8b98c4942dcdfa0df7f;hp=b2a289a4a30dfc14eff515b57ebd42f1f1501e52;hpb=66034865b17cde557bfba6d456eaaf2641c35bb5;p=platform%2Fupstream%2Fglib.git diff --git a/glib/glib.h b/glib/glib.h index b2a289a..c2f32fe 100644 --- a/glib/glib.h +++ b/glib/glib.h @@ -2,23 +2,23 @@ * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald * * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Library General Public + * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Library General Public License for more details. + * Lesser General Public License for more details. * - * You should have received a copy of the GNU Library General Public + * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the * Free Software Foundation, Inc., 59 Temple Place - Suite 330, * Boston, MA 02111-1307, USA. */ /* - * Modified by the GLib Team and others 1997-1999. See the AUTHORS + * Modified by the GLib Team and others 1997-2000. 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/. @@ -55,6 +55,7 @@ * gint16, guint16 * gint32, guint32 * gint64, guint64 + * gssize, gsize * * It defines the G_BYTE_ORDER symbol to one of G_*_ENDIAN (see later in * this file). @@ -74,6 +75,17 @@ */ #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 @@ -147,6 +159,14 @@ extern "C" { #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. @@ -158,11 +178,11 @@ extern "C" { */ #if !defined (G_VA_COPY) # if defined (__GNUC__) && defined (__PPC__) && (defined (_CALL_SYSV) || defined (_WIN32)) -# define G_VA_COPY(ap1, ap2) (*(ap1) = *(ap2)) +# define G_VA_COPY(ap1, ap2) (*(ap1) = *(ap2)) # elif defined (G_VA_COPY_AS_ARRAY) -# define G_VA_COPY(ap1, ap2) g_memmove ((ap1), (ap2), sizeof (va_list)) +# define G_VA_COPY(ap1, ap2) g_memmove ((ap1), (ap2), sizeof (va_list)) # else /* va_list is a pointer */ -# define G_VA_COPY(ap1, ap2) ((ap1) = (ap2)) +# define G_VA_COPY(ap1, ap2) ((ap1) = (ap2)) # endif /* va_list is a pointer */ #endif /* !G_VA_COPY */ @@ -171,9 +191,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))) @@ -185,47 +205,42 @@ extern "C" { * *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 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. + * inline function bodies have to be special cased with G_CAN_INLINE and a + * .c file specific macro to allow one compiled instance with extern linkage + * of the functions by defining G_IMPLEMENT_INLINES and the .c file macro. */ +#ifdef G_IMPLEMENT_INLINES +# define G_INLINE_FUNC extern +# undef G_CAN_INLINE +#endif #ifndef G_INLINE_FUNC # define G_CAN_INLINE 1 #endif -#ifdef G_HAVE_INLINE -# if defined (__GNUC__) && defined (__STRICT_ANSI__) -# undef inline -# define inline __inline__ -# endif -#else /* !G_HAVE_INLINE */ +#if defined (G_HAVE_INLINE) && defined (__GNUC__) && defined (__STRICT_ANSI__) +# undef inline +# define inline __inline__ +#elif !defined (G_HAVE_INLINE) # undef inline # if defined (G_HAVE___INLINE__) # define inline __inline__ -# else /* !inline && !__inline__ */ -# if defined (G_HAVE___INLINE) -# define inline __inline -# else /* !inline && !__inline__ && !__inline */ -# define inline /* don't inline, then */ -# ifndef G_INLINE_FUNC -# undef G_CAN_INLINE -# endif +# elif defined (G_HAVE___INLINE) +# define inline __inline +# else /* !inline && !__inline__ && !__inline */ +# define inline /* don't inline, then */ +# ifndef G_INLINE_FUNC +# undef G_CAN_INLINE # endif # endif #endif #ifndef G_INLINE_FUNC -# ifdef __GNUC__ -# ifdef __OPTIMIZE__ -# define G_INLINE_FUNC extern inline -# else -# undef G_CAN_INLINE -# define G_INLINE_FUNC extern -# endif -# else /* !__GNUC__ */ -# ifdef G_CAN_INLINE -# define G_INLINE_FUNC static inline -# else -# define G_INLINE_FUNC extern -# endif -# endif /* !__GNUC__ */ +# if defined (__GNUC__) && (__OPTIMIZE__) +# define G_INLINE_FUNC extern inline +# elif defined (G_CAN_INLINE) && !defined (__GNUC__) +# define G_INLINE_FUNC static inline +# else /* can't inline */ +# define G_INLINE_FUNC extern +# undef G_CAN_INLINE +# endif #endif /* !G_INLINE_FUNC */ @@ -256,6 +271,13 @@ extern "C" { /* Provide macros to feature the GCC function attribute. */ +#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 96) +#define G_GNUC_PURE \ + __attribute__((pure)) +#else +#define G_GNUC_PURE +#endif + #if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ > 4) #define G_GNUC_PRINTF( format_idx, arg_idx ) \ __attribute__((format (printf, format_idx, arg_idx))) @@ -303,13 +325,41 @@ extern "C" { * Actual use is strongly deprecated of course ;) */ #if defined (__i386__) && defined (__GNUC__) && __GNUC__ >= 2 -#define G_BREAKPOINT() G_STMT_START{ __asm__ __volatile__ ("int $03"); }G_STMT_END +# define G_BREAKPOINT() G_STMT_START{ __asm__ __volatile__ ("int $03"); }G_STMT_END #elif defined (__alpha__) && defined (__GNUC__) && __GNUC__ >= 2 -#define G_BREAKPOINT() G_STMT_START{ __asm__ __volatile__ ("bpt"); }G_STMT_END +# define G_BREAKPOINT() G_STMT_START{ __asm__ __volatile__ ("bpt"); }G_STMT_END #else /* !__i386__ && !__alpha__ */ -#define G_BREAKPOINT() +# define G_BREAKPOINT() G_STMT_START{ raise (5 /* SIGTRAP */); }G_STMT_END #endif /* __i386__ */ +/* g_alloca handling */ +#ifdef GLIB_HAVE_ALLOCA_H +#include +#endif + +#include +#ifdef __GNUC__ +/* glibc already does this for us */ +#ifndef alloca +# define alloca(size) __builtin_alloca (size) +#endif +#else +# ifdef _MSC_VER +# include +# define alloca _alloca +# else +# ifdef _AIX + #pragma alloca +# else +# ifndef alloca /* predefined by HP cc +Olibcalls */ +char *alloca (); +# endif +# endif +# endif +#endif + +#define g_alloca(size) alloca (size) +/* End g_alloca handling */ /* Provide macros for easily allocating memory. The macros * will cast the allocated memory to the specified type @@ -407,6 +457,8 @@ extern "C" { #define g_return_if_fail(expr) #define g_return_val_if_fail(expr,val) +#define g_return_if_reached() return +#define g_return_val_if_reached(val) return (val) #else /* !G_DISABLE_CHECKS */ @@ -417,7 +469,7 @@ extern "C" { { \ g_log (G_LOG_DOMAIN, \ G_LOG_LEVEL_CRITICAL, \ - "file %s: line %d (%s): assertion `%s' failed.", \ + "file %s: line %d (%s): assertion `%s' failed", \ __FILE__, \ __LINE__, \ __PRETTY_FUNCTION__, \ @@ -430,14 +482,32 @@ extern "C" { { \ g_log (G_LOG_DOMAIN, \ G_LOG_LEVEL_CRITICAL, \ - "file %s: line %d (%s): assertion `%s' failed.", \ + "file %s: line %d (%s): assertion `%s' failed", \ __FILE__, \ __LINE__, \ __PRETTY_FUNCTION__, \ #expr); \ - return val; \ + return (val); \ }; }G_STMT_END +#define g_return_if_reached() G_STMT_START{ \ + g_log (G_LOG_DOMAIN, \ + G_LOG_LEVEL_CRITICAL, \ + "file %s: line %d (%s): should not be reached", \ + __FILE__, \ + __LINE__, \ + __PRETTY_FUNCTION__); \ + return; }G_STMT_END + +#define g_return_val_if_reached(val) G_STMT_START{ \ + g_log (G_LOG_DOMAIN, \ + G_LOG_LEVEL_CRITICAL, \ + "file %s: line %d (%s): should not be reached", \ + __FILE__, \ + __LINE__, \ + __PRETTY_FUNCTION__); \ + return (val); }G_STMT_END + #else /* !__GNUC__ */ #define g_return_if_fail(expr) G_STMT_START{ \ @@ -445,7 +515,7 @@ extern "C" { { \ g_log (G_LOG_DOMAIN, \ G_LOG_LEVEL_CRITICAL, \ - "file %s: line %d: assertion `%s' failed.", \ + "file %s: line %d: assertion `%s' failed", \ __FILE__, \ __LINE__, \ #expr); \ @@ -457,13 +527,29 @@ extern "C" { { \ g_log (G_LOG_DOMAIN, \ G_LOG_LEVEL_CRITICAL, \ - "file %s: line %d: assertion `%s' failed.", \ + "file %s: line %d: assertion `%s' failed", \ __FILE__, \ __LINE__, \ #expr); \ - return val; \ + return (val); \ }; }G_STMT_END +#define g_return_if_reached() G_STMT_START{ \ + g_log (G_LOG_DOMAIN, \ + G_LOG_LEVEL_CRITICAL, \ + "file %s: line %d: should not be reached", \ + __FILE__, \ + __LINE__); \ + return; }G_STMT_END + +#define g_return_val_if_reached(val) G_STMT_START{ \ + g_log (G_LOG_DOMAIN, \ + G_LOG_LEVEL_CRITICAL, \ + "file %s: line %d: should not be reached", \ + __FILE__, \ + __LINE__); \ + return (val); }G_STMT_END + #endif /* !__GNUC__ */ #endif /* !G_DISABLE_CHECKS */ @@ -481,19 +567,13 @@ typedef short gshort; typedef long glong; typedef int gint; typedef gint gboolean; +typedef gchar* gstring; typedef unsigned char guchar; 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; @@ -512,8 +592,6 @@ typedef void* gpointer; typedef const void *gconstpointer; -typedef gint32 gssize; -typedef guint32 gsize; typedef guint32 GQuark; typedef gint32 GTime; @@ -678,19 +756,19 @@ typedef gint32 GTime; */ #ifdef G_OS_WIN32 # ifdef GLIB_COMPILATION -# define GUTILS_C_VAR __declspec(dllexport) +# define GLIB_VAR __declspec(dllexport) # else /* !GLIB_COMPILATION */ -# define GUTILS_C_VAR extern __declspec(dllimport) +# define GLIB_VAR extern __declspec(dllimport) # endif /* !GLIB_COMPILATION */ #else /* !G_OS_WIN32 */ -# define GUTILS_C_VAR extern +# define GLIB_VAR extern #endif /* !G_OS_WIN32 */ -GUTILS_C_VAR const guint glib_major_version; -GUTILS_C_VAR const guint glib_minor_version; -GUTILS_C_VAR const guint glib_micro_version; -GUTILS_C_VAR const guint glib_interface_age; -GUTILS_C_VAR const guint glib_binary_age; +GLIB_VAR const guint glib_major_version; +GLIB_VAR const guint glib_minor_version; +GLIB_VAR const guint glib_micro_version; +GLIB_VAR const guint glib_interface_age; +GLIB_VAR const guint glib_binary_age; #define GLIB_CHECK_VERSION(major,minor,micro) \ (GLIB_MAJOR_VERSION > (major) || \ @@ -817,8 +895,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); @@ -888,6 +964,15 @@ struct _GTuples guint len; }; +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +#include + +#ifdef __cplusplus +extern "C" { +#endif /* __cplusplus */ /* IEEE Standard 754 Single Precision Storage Format (gfloat): * @@ -975,7 +1060,7 @@ GList* g_list_insert_sorted (GList *list, GList* g_list_concat (GList *list1, GList *list2); 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, @@ -985,14 +1070,14 @@ 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); @@ -1024,10 +1109,13 @@ 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 *link); GSList* g_slist_delete_link (GSList *list, @@ -1037,14 +1125,14 @@ 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, @@ -1059,7 +1147,7 @@ gpointer g_slist_nth_data (GSList *list, /* Queues */ -GQueue* g_queue_create (void); +GQueue* g_queue_new (void); void g_queue_free (GQueue *queue); void g_queue_push_head (GQueue *queue, gpointer data); @@ -1077,7 +1165,6 @@ void g_queue_push_tail_link (GQueue *queue, GList* g_queue_pop_head_link (GQueue *queue); GList* g_queue_pop_tail_link (GQueue *queue); - /* Hash tables */ GHashTable* g_hash_table_new (GHashFunc hash_func, @@ -1094,8 +1181,6 @@ gboolean g_hash_table_lookup_extended(GHashTable *hash_table, gconstpointer lookup_key, gpointer *orig_key, gpointer *value); -void g_hash_table_freeze (GHashTable *hash_table); -void g_hash_table_thaw (GHashTable *hash_table); void g_hash_table_foreach (GHashTable *hash_table, GHFunc func, gpointer user_data); @@ -1104,6 +1189,10 @@ guint g_hash_table_foreach_remove (GHashTable *hash_table, gpointer user_data); guint g_hash_table_size (GHashTable *hash_table); +/* The following two functions are deprecated and will be removed in + * the next major release. They do no good. */ +void g_hash_table_freeze (GHashTable *hash_table); +void g_hash_table_thaw (GHashTable *hash_table); /* Caches */ @@ -1118,7 +1207,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); @@ -1135,16 +1224,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); @@ -1413,16 +1502,32 @@ GLogLevelFlags g_log_set_always_fatal (GLogLevelFlags fatal_mask); #ifndef G_LOG_DOMAIN #define G_LOG_DOMAIN ((gchar*) 0) #endif /* G_LOG_DOMAIN */ -#ifdef __GNUC__ -#define g_error(format, args...) g_log (G_LOG_DOMAIN, \ - G_LOG_LEVEL_ERROR, \ - format, ##args) -#define g_message(format, args...) g_log (G_LOG_DOMAIN, \ - G_LOG_LEVEL_MESSAGE, \ - format, ##args) -#define g_warning(format, args...) g_log (G_LOG_DOMAIN, \ - G_LOG_LEVEL_WARNING, \ - format, ##args) +#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L +#define g_error(...) g_log (G_LOG_DOMAIN, \ + G_LOG_LEVEL_ERROR, \ + __VA_ARGS__) +#define g_message(...) g_log (G_LOG_DOMAIN, \ + G_LOG_LEVEL_MESSAGE, \ + __VA_ARGS__) +#define g_critical(...) g_log (G_LOG_DOMAIN, \ + G_LOG_LEVEL_CRITICAL, \ + __VA_ARGS__) +#define g_warning(...) g_log (G_LOG_DOMAIN, \ + G_LOG_LEVEL_WARNING, \ + __VA_ARGS__) +#elif __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 4) +#define g_error(format...) g_log (G_LOG_DOMAIN, \ + G_LOG_LEVEL_ERROR, \ + format) +#define g_message(format...) g_log (G_LOG_DOMAIN, \ + G_LOG_LEVEL_MESSAGE, \ + format) +#define g_critical(format...) g_log (G_LOG_DOMAIN, \ + G_LOG_LEVEL_CRITICAL, \ + format) +#define g_warning(format...) g_log (G_LOG_DOMAIN, \ + G_LOG_LEVEL_WARNING, \ + format) #else /* !__GNUC__ */ static void g_error (const gchar *format, @@ -1443,6 +1548,15 @@ g_message (const gchar *format, va_end (args); } static void +g_critical (const gchar *format, + ...) +{ + va_list args; + va_start (args, format); + g_logv (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, format, args); + va_end (args); +} +static void g_warning (const gchar *format, ...) { @@ -1552,7 +1666,8 @@ void g_blow_chunks (void); /* Timer */ -#define G_MICROSEC 1000000 +/* microseconds per second */ +#define G_USEC_PER_SEC 1000000 GTimer* g_timer_new (void); void g_timer_destroy (GTimer *timer); @@ -1570,18 +1685,27 @@ void g_usleep (gulong microseconds); 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); -gchar* g_strsignal (gint signum); +gchar* g_strerror (gint errnum) G_GNUC_CONST; +gchar* g_strsignal (gint signum) G_GNUC_CONST; gint g_strcasecmp (const gchar *s1, const gchar *s2); 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); +gsize g_strlcpy (gchar *dest, + const gchar *src, + gsize dest_size); +gsize g_strlcat (gchar *dest, + const gchar *src, + gsize dest_size); /* removes leading spaces */ gchar* g_strchug (gchar *string); /* removes trailing spaces */ @@ -1676,17 +1800,29 @@ gint g_vsnprintf (gchar *string, gulong n, gchar const *format, va_list args); -gchar* g_basename (const gchar *file_name); /* Check if a file name is an absolute path */ gboolean g_path_is_absolute (const gchar *file_name); /* In case of absolute paths, skip the root part */ gchar* g_path_skip_root (gchar *file_name); -/* strings are newly allocated with g_malloc() */ +/* These two functions are deprecated and will be removed in the next + * major release of GLib. Use g_path_get_dirname/g_path_get_basename + * instead. Whatch out! The string returned by g_path_get_basename + * must be g_freed, while the string returned by g_basename must not.*/ +gchar* g_basename (const gchar *file_name); gchar* g_dirname (const gchar *file_name); + +/* The returned strings are newly allocated with g_malloc() */ gchar* g_get_current_dir (void); -gchar* g_getenv (const gchar *variable); +gchar* g_path_get_basename (const gchar *file_name); +gchar* g_path_get_dirname (const gchar *file_name); +/* 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 @@ -1700,7 +1836,24 @@ void g_atexit (GVoidFunc func); */ G_INLINE_FUNC gint g_bit_nth_lsf (guint32 mask, gint nth_bit); -#ifdef G_CAN_INLINE +G_INLINE_FUNC gint g_bit_nth_msf (guint32 mask, + gint nth_bit); +G_INLINE_FUNC guint g_bit_storage (guint number); + + +/* Trash Stacks + * elements need to be >= sizeof (gpointer) + */ +G_INLINE_FUNC void g_trash_stack_push (GTrashStack **stack_p, + gpointer data_p); +G_INLINE_FUNC gpointer g_trash_stack_pop (GTrashStack **stack_p); +G_INLINE_FUNC gpointer g_trash_stack_peek (GTrashStack **stack_p); +G_INLINE_FUNC guint g_trash_stack_height (GTrashStack **stack_p); + + +/* inline function implementations + */ +#if defined (G_CAN_INLINE) || defined (__G_UTILS_C__) G_INLINE_FUNC gint g_bit_nth_lsf (guint32 mask, gint nth_bit) @@ -1714,11 +1867,6 @@ g_bit_nth_lsf (guint32 mask, while (nth_bit < 32); return -1; } -#endif /* G_CAN_INLINE */ - -G_INLINE_FUNC gint g_bit_nth_msf (guint32 mask, - gint nth_bit); -#ifdef G_CAN_INLINE G_INLINE_FUNC gint g_bit_nth_msf (guint32 mask, gint nth_bit) @@ -1734,10 +1882,6 @@ g_bit_nth_msf (guint32 mask, while (nth_bit > 0); return -1; } -#endif /* G_CAN_INLINE */ - -G_INLINE_FUNC guint g_bit_storage (guint number); -#ifdef G_CAN_INLINE G_INLINE_FUNC guint g_bit_storage (guint number) { @@ -1751,15 +1895,6 @@ g_bit_storage (guint number) while (number); return n_bits; } -#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) @@ -1769,10 +1904,6 @@ g_trash_stack_push (GTrashStack **stack_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) { @@ -1790,10 +1921,6 @@ g_trash_stack_pop (GTrashStack **stack_p) 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) { @@ -1803,10 +1930,6 @@ g_trash_stack_peek (GTrashStack **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) { @@ -1818,7 +1941,7 @@ g_trash_stack_height (GTrashStack **stack_p) return i; } -#endif /* G_CAN_INLINE */ +#endif /* G_CAN_INLINE || __G_UTILS_C__ */ /* String Chunks @@ -1835,12 +1958,15 @@ gchar* g_string_chunk_insert_const (GStringChunk *chunk, */ GString* g_string_new (const gchar *init); GString* g_string_sized_new (guint dfl_size); -void g_string_free (GString *string, +gchar* 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, - gint len); + guint len); GString* g_string_insert_len (GString *string, gint pos, const gchar *val, @@ -1891,7 +2017,11 @@ void g_string_sprintfa (GString *string, GArray* g_array_new (gboolean zero_terminated, gboolean clear, guint element_size); -void g_array_free (GArray *array, +GArray* g_array_sized_new (gboolean zero_terminated, + gboolean clear, + guint element_size, + guint reserved_size); +gchar* g_array_free (GArray *array, gboolean free_segment); GArray* g_array_append_vals (GArray *array, gconstpointer data, @@ -1917,7 +2047,8 @@ GArray* g_array_remove_index_fast (GArray *array, */ #define g_ptr_array_index(array,index) (array->pdata)[index] GPtrArray* g_ptr_array_new (void); -void g_ptr_array_free (GPtrArray *array, +GPtrArray* g_ptr_array_sized_new (guint reserved_size); +gpointer* g_ptr_array_free (GPtrArray *array, gboolean free_seg); void g_ptr_array_set_size (GPtrArray *array, gint length); @@ -1937,7 +2068,8 @@ void g_ptr_array_add (GPtrArray *array, */ GByteArray* g_byte_array_new (void); -void g_byte_array_free (GByteArray *array, +GByteArray* g_byte_array_sized_new (guint reserved_size); +guint8* g_byte_array_free (GByteArray *array, gboolean free_segment); GByteArray* g_byte_array_append (GByteArray *array, const guint8 *data, @@ -1955,13 +2087,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) G_GNUC_CONST; +guint g_int_hash (gconstpointer v) G_GNUC_CONST; /* This "hash" function will just return the key's adress as an * unsigned integer. Useful for hashing on plain adresses or @@ -1969,9 +2101,9 @@ guint g_int_hash (gconstpointer v); * passing NULL into g_hash_table_new() as GHashFunc has the * same effect as passing g_direct_hash(). */ -guint g_direct_hash (gconstpointer v); +guint g_direct_hash (gconstpointer v) G_GNUC_CONST; gint g_direct_equal (gconstpointer v, - gconstpointer v2); + gconstpointer v2) G_GNUC_CONST; /* Quarks (string<->id association) @@ -1979,7 +2111,7 @@ gint g_direct_equal (gconstpointer v, GQuark g_quark_try_string (const gchar *string); GQuark g_quark_from_static_string (const gchar *string); GQuark g_quark_from_string (const gchar *string); -gchar* g_quark_to_string (GQuark quark); +gchar* g_quark_to_string (GQuark quark) G_GNUC_CONST; /* Keyed Data List @@ -2049,6 +2181,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"\ @@ -2234,8 +2367,6 @@ void g_scanner_scope_foreach_symbol (GScanner *scanner, gpointer user_data); gpointer g_scanner_lookup_symbol (GScanner *scanner, const gchar *symbol); -void g_scanner_freeze_symbol_table (GScanner *scanner); -void g_scanner_thaw_symbol_table (GScanner *scanner); void g_scanner_unexp_token (GScanner *scanner, GTokenType expected_token, const gchar *identifier_spec, @@ -2261,6 +2392,10 @@ gint g_scanner_stat_mode (const gchar *filename); g_scanner_scope_foreach_symbol ((scanner), 0, (func), (data)); \ } G_STMT_END +/* The following two functions are deprecated and will be removed in + * the next major release. They do no good. */ +void g_scanner_freeze_symbol_table (GScanner *scanner); +void g_scanner_thaw_symbol_table (GScanner *scanner); /* GCompletion */ @@ -2381,14 +2516,14 @@ void g_date_free (GDate *date); * 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_day (GDateDay day) G_GNUC_CONST; +gboolean g_date_valid_month (GDateMonth month) G_GNUC_CONST; +gboolean g_date_valid_year (GDateYear year) G_GNUC_CONST; +gboolean g_date_valid_weekday (GDateWeekday weekday) G_GNUC_CONST; +gboolean g_date_valid_julian (guint32 julian_date) G_GNUC_CONST; gboolean g_date_valid_dmy (GDateDay day, GDateMonth month, - GDateYear year); + GDateYear year) G_GNUC_CONST; GDateWeekday g_date_weekday (GDate *date); GDateMonth g_date_month (GDate *date); @@ -2453,11 +2588,11 @@ 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); +gboolean g_date_is_leap_year (GDateYear year) G_GNUC_CONST; 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); + GDateYear year) G_GNUC_CONST; +guint8 g_date_monday_weeks_in_year (GDateYear year) G_GNUC_CONST; +guint8 g_date_sunday_weeks_in_year (GDateYear year) G_GNUC_CONST; /* qsort-friendly (with a cast...) */ gint g_date_compare (GDate *lhs, @@ -2566,7 +2701,7 @@ gdouble g_random_double_range (gdouble min, * next largest prime, or the highest it knows about which is about * MAXINT/4. */ -guint g_spaced_primes_closest (guint num); +guint g_spaced_primes_closest (guint num) G_GNUC_CONST; /* GIOChannel @@ -2779,71 +2914,74 @@ void g_main_add_poll (GPollFD *fd, void g_main_remove_poll (GPollFD *fd); void g_main_set_poll_func (GPollFunc func); +#ifdef G_OS_WIN32 + +/* Useful on other platforms, too? */ + +GPollFunc g_main_win32_get_poll_func (void); + +#endif + /* 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. + * On Win32, use this only for files opened with the MSVCRT (the + * Microsoft run-time C library) _open() or _pipe, including file + * descriptors 0, 1 and 2 (corresponding to stdin, stdout and stderr). * * The term file descriptor as used in the context of Win32 refers to - * the emulated Unix-like file descriptors MSVCRT provides. + * the emulated Unix-like file descriptors MSVCRT provides. The native + * corresponding concept is file HANDLE. There isn't as of yet a way to + * get GIOChannels for file HANDLEs. */ 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. +/* Use this to get a GPollFD from a GIOChannel, so that you can call + * g_io_channel_win32_poll(). After calling this you should only use + * g_io_channel_read() to read from the GIOChannel, i.e. never read() + * or recv() from the underlying file descriptor or SOCKET. */ -void g_main_poll_win32_msg_add(gint priority, - GPollFD *fd, - guint hwnd); +void g_io_channel_win32_make_pollfd (GIOChannel *channel, + GIOCondition condition, + GPollFD *fd); -/* 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. +/* This can be used to wait a until at least one of the channels is readable. + * On Unix you would do a select() on the file descriptors of the channels. + * This should probably be available for all platforms? */ -GIOChannel *g_io_channel_win32_new_pipe (int fd); +gint g_io_channel_win32_poll (GPollFD *fds, + gint n_fds, + gint timeout); -/* 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. +/* This is used to add polling for Windows messages. GDK (GTk+) programs + * should *not* use this. */ -GIOChannel *g_io_channel_win32_new_pipe_with_wakeups (int fd, - guint peer, - int peer_fd); +void g_main_poll_win32_msg_add (gint priority, + GPollFD *fd, + guint hwnd); -void g_io_channel_win32_pipe_request_wakeups (GIOChannel *channel, - guint peer, - int peer_fd); +/* An IO channel for Windows messages for window handle hwnd. */ +GIOChannel *g_io_channel_win32_new_messages (guint hwnd); -void g_io_channel_win32_pipe_readable (int fd, - guint offset); +/* An IO channel for C runtime (emulated Unix-like) file + * descriptors. Identical to g_io_channel_unix_new above. + * After calling g_io_add_watch() on a IO channel returned + * by this function, you shouldn't call read() on the file + * descriptor. + */ +GIOChannel* g_io_channel_win32_new_fd (int fd); /* 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. +/* An IO channel for a SOCK_STREAM winsock socket. The parameter + * should be a SOCKET. After calling g_io_add_watch() on a IO channel + * returned by this function, you shouldn't call recv() on the SOCKET. */ GIOChannel *g_io_channel_win32_new_stream_socket (int socket); @@ -2929,14 +3067,22 @@ gchar * g_win32_error_message (gint error); /* GLib Thread support */ +extern GQuark g_thread_error_quark(); +#define G_THREAD_ERROR g_thread_error_quark() + +typedef enum +{ + G_THREAD_ERROR_AGAIN /* Resource temporarily unavailable */ +} GThreadError; + typedef void (*GThreadFunc) (gpointer value); typedef enum { - G_THREAD_PRIORITY_LOW, - G_THREAD_PRIORITY_NORMAL, - G_THREAD_PRIORITY_HIGH, - G_THREAD_PRIORITY_URGENT + G_THREAD_PRIORITY_LOW, + G_THREAD_PRIORITY_NORMAL, + G_THREAD_PRIORITY_HIGH, + G_THREAD_PRIORITY_URGENT } GThreadPriority; typedef struct _GThread GThread; @@ -2951,6 +3097,8 @@ 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 @@ -2979,7 +3127,8 @@ struct _GThreadFunctions gboolean joinable, gboolean bound, GThreadPriority priority, - gpointer thread); + gpointer thread, + GError **error); void (*thread_yield) (void); void (*thread_join) (gpointer thread); void (*thread_exit) (void); @@ -2988,9 +3137,9 @@ struct _GThreadFunctions void (*thread_self) (gpointer thread); }; -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; +GLIB_VAR GThreadFunctions g_thread_functions_for_glib_use; +GLIB_VAR gboolean g_thread_use_default_impl; +GLIB_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 @@ -3041,11 +3190,12 @@ GThread* g_thread_create (GThreadFunc thread_func, gulong stack_size, gboolean joinable, gboolean bound, - GThreadPriority priority); + GThreadPriority priority, + GError **error); GThread* g_thread_self (); -void g_thread_join (GThread* thread); -void g_thread_set_priority (GThread* thread, - GThreadPriority priority); +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 @@ -3122,7 +3272,7 @@ void g_static_rw_lock_free (GStaticRWLock* lock); * 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) \ @@ -3144,12 +3294,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)) @@ -3164,9 +3313,161 @@ extern void glib_dummy_decl (void); # 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, + GError **error); + +/* 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, + GError **error); + +/* 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, + GError **error); +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); + +typedef enum +{ + G_CONVERT_ERROR_NO_CONVERSION, + G_CONVERT_ERROR_ILLEGAL_SEQUENCE, + G_CONVERT_ERROR_FAILED +} GConvertError; + +#define G_CONVERT_ERROR g_convert_error_quark() +GQuark g_convert_error_quark(); + +gchar* g_convert (const gchar *str, + gint len, + const gchar *to_codeset, + const gchar *from_codeset, + gint *bytes_read, + gint *bytes_written, + GError **error); +gchar* g_convert_with_fallback (const gchar *str, + gint len, + const gchar *to_codeset, + const gchar *from_codeset, + gchar *fallback, + gint *bytes_read, + gint *bytes_written, + GError **error); + #ifdef __cplusplus } #endif /* __cplusplus */ +#include #endif /* __G_LIB_H__ */