* 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/.
* 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).
*/
#include <glibconfig.h>
+/* 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 <stdarg.h>
#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.
*/
#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 */
* 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)))
* *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 */
* 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__ */
#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 */
{ \
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__, \
{ \
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{ \
{ \
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); \
{ \
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 */
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;
typedef const void *gconstpointer;
-typedef gint32 gssize;
-typedef guint32 gsize;
typedef guint32 GQuark;
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) || \
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);
guint len;
};
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#include <gerror.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
/* IEEE Standard 754 Single Precision Storage Format (gfloat):
*
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,
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,
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);
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
*/
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);
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);
#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 defined (__GNUC__)
+#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,
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,
...)
{
/* 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);
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);
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 */
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_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. */
*/
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)
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)
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)
{
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)
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)
{
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)
{
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)
{
return i;
}
-#endif /* G_CAN_INLINE */
+#endif /* G_CAN_INLINE || __G_UTILS_C__ */
/* String Chunks
*/
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,
gboolean clear,
guint element_size,
guint reserved_size);
-void g_array_free (GArray *array,
+gchar* g_array_free (GArray *array,
gboolean free_segment);
GArray* g_array_append_vals (GArray *array,
gconstpointer data,
#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,
+gpointer* g_ptr_array_free (GPtrArray *array,
gboolean free_seg);
void g_ptr_array_set_size (GPtrArray *array,
gint length);
GByteArray* g_byte_array_new (void);
GByteArray* g_byte_array_sized_new (guint reserved_size);
-void g_byte_array_free (GByteArray *array,
+guint8* g_byte_array_free (GByteArray *array,
gboolean free_segment);
GByteArray* g_byte_array_append (GByteArray *array,
const guint8 *data,
/* 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
* 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)
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
/* 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"\
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,
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
*/
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,
* 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
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);
/* 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
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
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);
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
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
* 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) \
#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))
# 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_OTHER
+} 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 <gunicode.h>
#endif /* __G_LIB_H__ */
projects / platform / upstream / glib.git / blobdiff