From 375b23836d1c9d80c3081486d87ebea086b67f50 Mon Sep 17 00:00:00 2001 From: Owen Taylor Date: Wed, 10 Jun 1998 23:28:29 +0000 Subject: [PATCH] Added glib.h which was mistakenly in .cvsignore --- ChangeLog | 6 + ChangeLog.pre-2-0 | 6 + ChangeLog.pre-2-10 | 6 + ChangeLog.pre-2-12 | 6 + ChangeLog.pre-2-2 | 6 + ChangeLog.pre-2-4 | 6 + ChangeLog.pre-2-6 | 6 + ChangeLog.pre-2-8 | 6 + glib.h | 1154 ++++++++++++++++++++++++++++++++++++++++++++++++++++ glib/glib.h | 1154 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 10 files changed, 2356 insertions(+) create mode 100644 glib.h create mode 100644 glib/glib.h diff --git a/ChangeLog b/ChangeLog index 4b21235..c21990f 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,9 @@ +Wed Jun 10 19:29:51 1998 Owen Taylor + + * Makefile.am glib.m4 configure.in: + + Moved out from GTK+; added AM_PATH_GLIB macro. + Wed Jun 10 12:56:07 1998 Owen Taylor * glib.h: renamed g_const_pointer => gconstpointer diff --git a/ChangeLog.pre-2-0 b/ChangeLog.pre-2-0 index 4b21235..c21990f 100644 --- a/ChangeLog.pre-2-0 +++ b/ChangeLog.pre-2-0 @@ -1,3 +1,9 @@ +Wed Jun 10 19:29:51 1998 Owen Taylor + + * Makefile.am glib.m4 configure.in: + + Moved out from GTK+; added AM_PATH_GLIB macro. + Wed Jun 10 12:56:07 1998 Owen Taylor * glib.h: renamed g_const_pointer => gconstpointer diff --git a/ChangeLog.pre-2-10 b/ChangeLog.pre-2-10 index 4b21235..c21990f 100644 --- a/ChangeLog.pre-2-10 +++ b/ChangeLog.pre-2-10 @@ -1,3 +1,9 @@ +Wed Jun 10 19:29:51 1998 Owen Taylor + + * Makefile.am glib.m4 configure.in: + + Moved out from GTK+; added AM_PATH_GLIB macro. + Wed Jun 10 12:56:07 1998 Owen Taylor * glib.h: renamed g_const_pointer => gconstpointer diff --git a/ChangeLog.pre-2-12 b/ChangeLog.pre-2-12 index 4b21235..c21990f 100644 --- a/ChangeLog.pre-2-12 +++ b/ChangeLog.pre-2-12 @@ -1,3 +1,9 @@ +Wed Jun 10 19:29:51 1998 Owen Taylor + + * Makefile.am glib.m4 configure.in: + + Moved out from GTK+; added AM_PATH_GLIB macro. + Wed Jun 10 12:56:07 1998 Owen Taylor * glib.h: renamed g_const_pointer => gconstpointer diff --git a/ChangeLog.pre-2-2 b/ChangeLog.pre-2-2 index 4b21235..c21990f 100644 --- a/ChangeLog.pre-2-2 +++ b/ChangeLog.pre-2-2 @@ -1,3 +1,9 @@ +Wed Jun 10 19:29:51 1998 Owen Taylor + + * Makefile.am glib.m4 configure.in: + + Moved out from GTK+; added AM_PATH_GLIB macro. + Wed Jun 10 12:56:07 1998 Owen Taylor * glib.h: renamed g_const_pointer => gconstpointer diff --git a/ChangeLog.pre-2-4 b/ChangeLog.pre-2-4 index 4b21235..c21990f 100644 --- a/ChangeLog.pre-2-4 +++ b/ChangeLog.pre-2-4 @@ -1,3 +1,9 @@ +Wed Jun 10 19:29:51 1998 Owen Taylor + + * Makefile.am glib.m4 configure.in: + + Moved out from GTK+; added AM_PATH_GLIB macro. + Wed Jun 10 12:56:07 1998 Owen Taylor * glib.h: renamed g_const_pointer => gconstpointer diff --git a/ChangeLog.pre-2-6 b/ChangeLog.pre-2-6 index 4b21235..c21990f 100644 --- a/ChangeLog.pre-2-6 +++ b/ChangeLog.pre-2-6 @@ -1,3 +1,9 @@ +Wed Jun 10 19:29:51 1998 Owen Taylor + + * Makefile.am glib.m4 configure.in: + + Moved out from GTK+; added AM_PATH_GLIB macro. + Wed Jun 10 12:56:07 1998 Owen Taylor * glib.h: renamed g_const_pointer => gconstpointer diff --git a/ChangeLog.pre-2-8 b/ChangeLog.pre-2-8 index 4b21235..c21990f 100644 --- a/ChangeLog.pre-2-8 +++ b/ChangeLog.pre-2-8 @@ -1,3 +1,9 @@ +Wed Jun 10 19:29:51 1998 Owen Taylor + + * Makefile.am glib.m4 configure.in: + + Moved out from GTK+; added AM_PATH_GLIB macro. + Wed Jun 10 12:56:07 1998 Owen Taylor * glib.h: renamed g_const_pointer => gconstpointer diff --git a/glib.h b/glib.h new file mode 100644 index 0000000..021d747 --- /dev/null +++ b/glib.h @@ -0,0 +1,1154 @@ +/* GLIB - Library of useful routines for C programming + * 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 + * 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. + * + * You should have received a copy of the GNU Library 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. + */ +#ifndef __G_LIB_H__ +#define __G_LIB_H__ + +#include + +#ifdef USE_DMALLOC +#include "dmalloc.h" +#endif + + +/* glib provides definitions for the extrema of many + * of the standard types. These are: + * G_MINFLOAT + * G_MAXFLOAT + * G_MINDOUBLE + * G_MAXDOUBLE + * G_MINSHORT + * G_MAXSHORT + * G_MININT + * G_MAXINT + * G_MINLONG + * G_MAXLONG + */ + +#ifdef HAVE_FLOAT_H + +#include + +#define G_MINFLOAT FLT_MIN +#define G_MAXFLOAT FLT_MAX +#define G_MINDOUBLE DBL_MIN +#define G_MAXDOUBLE DBL_MAX + +#elif HAVE_VALUES_H + +#include + +#define G_MINFLOAT MINFLOAT +#define G_MAXFLOAT MAXFLOAT +#define G_MINDOUBLE MINDOUBLE +#define G_MAXDOUBLE MAXDOUBLE + +#endif /* HAVE_VALUES_H */ + + +#ifdef HAVE_LIMITS_H + +#include + +#define G_MINSHORT SHRT_MIN +#define G_MAXSHORT SHRT_MAX +#define G_MININT INT_MIN +#define G_MAXINT INT_MAX +#define G_MINLONG LONG_MIN +#define G_MAXLONG LONG_MAX + +#elif HAVE_VALUES_H + +#ifdef HAVE_FLOAT_H +#include +#endif /* HAVE_FLOAT_H */ + +#define G_MINSHORT MINSHORT +#define G_MAXSHORT MAXSHORT +#define G_MININT MININT +#define G_MAXINT MAXINT +#define G_MINLONG MINLONG +#define G_MAXLONG MAXLONG + +#endif /* HAVE_VALUES_H */ + + +/* Provide definitions for some commonly used macros. + * Some of them are only provided if they haven't already + * been defined. It is assumed that if they are already + * defined then the current definition is correct. + */ +#ifndef NULL +#define NULL ((void*) 0) +#endif + +#ifndef FALSE +#define FALSE (0) +#endif + +#ifndef TRUE +#define TRUE (!FALSE) +#endif + +#undef MAX +#define MAX(a, b) (((a) > (b)) ? (a) : (b)) + +#undef MIN +#define MIN(a, b) (((a) < (b)) ? (a) : (b)) + +#undef ABS +#define ABS(a) (((a) < 0) ? -(a) : (a)) + +#undef CLAMP +#define CLAMP(x, low, high) (((x) > (high)) ? (high) : (((x) < (low)) ? (low) : (x))) + + +/* Provide simple enum value macro wrappers that ease automated enum value + * stringification code. + */ +#if !defined (G_CODE_GENERATION) +#define G_ENUM( EnumerationName ) EnumerationName +#define G_FLAGS( EnumerationName ) EnumerationName +#define G_NV( VALUE_NAME , value_nick, VALUE) VALUE_NAME = (VALUE) +#define G_SV( VALUE_NAME, value_nick ) VALUE_NAME +#else /* G_CODE_GENERATION */ +#define G_ENUM( EnumerationName ) G_ENUM_E + EnumerationName + +#define G_FLAGS( EnumerationName ) G_ENUM_F + EnumerationName + +#define G_NV( VALUE_NAME , value_nick, VALUE) G_ENUM_V + VALUE_NAME + value_nick + +#define G_SV( VALUE_NAME, value_nick ) G_ENUM_V + VALUE_NAME + value_nick + +#endif /* G_CODE_GENERATION */ + + +/* Provide simple macro statement wrappers (adapted from Pearl): + * G_STMT_START { statements; } G_STMT_END; + * can be used as a single statement, as in + * if (x) G_STMT_START { ... } G_STMT_END; else ... + * + * For gcc we will wrap the statements within `({' and `})' braces. + * For SunOS they will be wrapped within `if (1)' and `else (void) 0', + * and otherwise within `do' and `while (0)'. + */ +#if !(defined (G_STMT_START) && defined (G_STMT_END)) +# if defined (__GNUC__) && !defined (__STRICT_ANSI__) && !defined (__cplusplus) +# define G_STMT_START (void)( +# define G_STMT_END ) +# else +# if (defined (sun) || defined (__sun__)) +# define G_STMT_START if (1) +# define G_STMT_END else (void)0 +# else +# define G_STMT_START do +# define G_STMT_END while (0) +# endif +# endif +#endif + +/* Provide macros to feature the GCC function attribute. + */ +#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ > 4) +#define G_GNUC_PRINTF( format_idx, arg_idx ) \ + __attribute__((format (printf, format_idx, arg_idx))) +#define G_GNUC_SCANF( format_idx, arg_idx ) \ + __attribute__((format (scanf, format_idx, arg_idx))) +#define G_GNUC_FORMAT( arg_idx ) \ + __attribute__((format_arg (arg_idx))) +#define G_GNUC_NORETURN \ + __attribute__((noreturn)) +#define G_GNUC_CONST \ + __attribute__((const)) +#else /* !__GNUC__ */ +#define G_GNUC_PRINTF( format_idx, arg_idx ) +#define G_GNUC_SCANF( format_idx, arg_idx ) +#define G_GNUC_FORMAT( arg_idx ) +#define G_GNUC_NORETURN +#define G_GNUC_CONST +#endif /* !__GNUC__ */ + +/* Hacker macro to place breakpoints for x86 machines. + * Actuall use is strongly deprecated of course ;) + */ +#if defined (__i386__) +#define G_BREAKPOINT() G_STMT_START{ __asm__ ("int $03"); }G_STMT_END +#else /* !__i386__ */ +#define G_BREAKPOINT() +#endif /* __i386__ */ + +/* Wrap the __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__) +#else /* !__GNUC__ */ +#define G_GNUC_FUNCTION ("") +#define G_GNUC_PRETTY_FUNCTION ("") +#endif /* !__GNUC__ */ + + +#ifndef ATEXIT +# ifdef HAVE_ATEXIT +# define ATEXIT(proc) (atexit (proc)) +# elif defined (HAVE_ON_EXIT) +# define ATEXIT(proc) (on_exit ((void (*)(int, void *))(proc), NULL)) +# endif +#endif /* ATEXIT */ + + +/* Provide macros for easily allocating memory. The macros + * will cast the allocated memory to the specified type + * in order to avoid compiler warnings. (Makes the code neater). + */ + +#ifdef __DMALLOC_H__ + +#define g_new(type,count) ALLOC(type,count) +#define g_new0(type,count) CALLOC(type,count) + +#else /* __DMALLOC_H__ */ + +#define g_new(type, count) \ + ((type *) g_malloc ((unsigned) sizeof (type) * (count))) +#define g_new0(type, count) \ + ((type *) g_malloc0 ((unsigned) sizeof (type) * (count))) +#endif /* __DMALLOC_H__ */ + +#define g_mem_chunk_create(type, pre_alloc, alloc_type) ( \ + g_mem_chunk_new (#type " mem chunks (" #pre_alloc ")", \ + sizeof (type), \ + sizeof (type) * (pre_alloc), \ + (alloc_type)) \ +) +#define g_chunk_new(type, chunk) ( \ + (type *) g_mem_chunk_alloc (chunk) \ +) +#define g_chunk_new0(type, chunk) ( \ + (type *) memset (g_mem_chunk_alloc (chunk), 0, sizeof (type)) \ +) +#define g_chunk_free(mem, mem_chunk) G_STMT_START { \ + g_mem_chunk_free ((mem_chunk), (mem)); \ +} 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 + * in order to support gcc's __PRETTY_FUNCTION__ capability. + */ + +#ifdef G_DISABLE_ASSERT + +#define g_assert(expr) +#define g_assert_not_reached() + +#else /* !G_DISABLE_ASSERT */ + +#ifdef __GNUC__ + +#define g_assert(expr) G_STMT_START{\ + if (!(expr)) \ + g_error ("file %s: line %d (%s): \"%s\"", \ + __FILE__, \ + __LINE__, \ + __PRETTY_FUNCTION__, \ + #expr); }G_STMT_END + +#define g_assert_not_reached() G_STMT_START{ \ + g_error ("file %s: line %d (%s): \"should not be reached\"", \ + __FILE__, \ + __LINE__, \ + __PRETTY_FUNCTION__); }G_STMT_END + +#else /* !__GNUC__ */ + +#define g_assert(expr) G_STMT_START{\ + if (!(expr)) \ + g_error ("file %s: line %d: \"%s\"", \ + __FILE__, \ + __LINE__, \ + #expr); }G_STMT_END + +#define g_assert_not_reached() G_STMT_START{ \ + g_error ("file %s: line %d: \"should not be reached\"", \ + __FILE__, \ + __LINE__); }G_STMT_END + +#endif /* __GNUC__ */ + +#endif /* G_DISABLE_ASSERT */ + +#ifdef G_DISABLE_CHECKS + +#define g_return_if_fail(expr) +#define g_return_val_if_fail(expr,val) + +#else /* !G_DISABLE_CHECKS */ + +#ifdef __GNUC__ + +#define g_return_if_fail(expr) G_STMT_START{ \ + if (!(expr)) \ + { \ + g_warning ("file %s: line %d (%s): \"%s\"", \ + __FILE__, \ + __LINE__, \ + __PRETTY_FUNCTION__, \ + #expr); \ + return; \ + }; }G_STMT_END + +#define g_return_val_if_fail(expr,val) G_STMT_START{ \ + if (!(expr)) \ + { \ + g_warning ("file %s: line %d (%s): \"%s\"", \ + __FILE__, \ + __LINE__, \ + __PRETTY_FUNCTION__, \ + #expr); \ + return val; \ + }; }G_STMT_END + +#else /* !__GNUC__ */ + +#define g_return_if_fail(expr) G_STMT_START{ \ + if (!(expr)) \ + { \ + g_warning ("file %s: line %d: \"%s\"", \ + __FILE__, \ + __LINE__, \ + #expr); \ + return; \ + }; }G_STMT_END + +#define g_return_val_if_fail(expr, val) G_STMT_START{ \ + if (!(expr)) \ + { \ + g_warning ("file %s: line %d: \"%s\"", \ + __FILE__, \ + __LINE__, \ + #expr); \ + return val; \ + }; }G_STMT_END + +#endif /* !__GNUC__ */ + +#endif /* G_DISABLE_CHECKS */ + + +#ifdef __cplusplus +extern "C" { +#pragma } +#endif /* __cplusplus */ + +/* Provide type definitions for commonly used types. + * These are useful because a "gint8" can be adjusted + * to be 1 byte (8 bits) on all platforms. Similarly and + * more importantly, "gint32" can be adjusted to be + * 4 bytes (32 bits) on all platforms. + */ + +typedef char gchar; +typedef short gshort; +typedef long glong; +typedef int gint; +typedef gint gboolean; + +typedef unsigned char guchar; +typedef unsigned short gushort; +typedef unsigned long gulong; +typedef unsigned int guint; + +typedef float gfloat; +typedef double gdouble; + +/* HAVE_LONG_DOUBLE doesn't work correctly on all platforms. + * Since gldouble isn't used anywhere, just disable it for now */ + +#if 0 +#ifdef HAVE_LONG_DOUBLE +typedef long double gldouble; +#else /* HAVE_LONG_DOUBLE */ +typedef double gldouble; +#endif /* HAVE_LONG_DOUBLE */ +#endif /* 0 */ + +typedef void* gpointer; +typedef const void *gconstpointer; + +#if (SIZEOF_CHAR == 1) +typedef signed char gint8; +typedef unsigned char guint8; +#endif /* SIZEOF_CHAR */ + + +#if (SIZEOF_SHORT == 2) +typedef signed short gint16; +typedef unsigned short guint16; +#endif /* SIZEOF_SHORT */ + + +#if (SIZEOF_INT == 4) +typedef signed int gint32; +typedef unsigned int guint32; +#elif (SIZEOF_LONG == 4) +typedef signed long gint32; +typedef unsigned long guint32; +#endif /* SIZEOF_INT */ + +/* Define macros for storing integers inside pointers */ + +#if (SIZEOF_INT == SIZEOF_VOID_P) + +#define GPOINTER_TO_INT(p) ((gint)(p)) +#define GPOINTER_TO_UINT(p) ((guint)(p)) + +#define GINT_TO_POINTER(i) ((gpointer)(i)) +#define GUINT_TO_POINTER(u) ((gpointer)(u)) + +#elif (SIZEOF_LONG == SIZEOF_VOID_P) + +#define GPOINTER_TO_INT(p) ((gint)(glong)(p)) +#define GPOINTER_TO_UINT(p) ((guint)(gulong)(p)) + +#define GINT_TO_POINTER(i) ((gpointer)(glong)(i)) +#define GUINT_TO_POINTER(u) ((gpointer)(gulong)(u)) + +#else +/* This should never happen */ +#endif + + +typedef struct _GList GList; +typedef struct _GSList GSList; +typedef struct _GHashTable GHashTable; +typedef struct _GCache GCache; +typedef struct _GTree GTree; +typedef struct _GTimer GTimer; +typedef struct _GMemChunk GMemChunk; +typedef struct _GListAllocator GListAllocator; +typedef struct _GStringChunk GStringChunk; +typedef struct _GString GString; +typedef struct _GArray GArray; +typedef struct _GDebugKey GDebugKey; +typedef struct _GScannerConfig GScannerConfig; +typedef struct _GScanner GScanner; +typedef union _GValue GValue; + + +typedef void (*GFunc) (gpointer data, + gpointer user_data); +typedef void (*GHFunc) (gpointer key, + gpointer value, + gpointer user_data); +typedef gpointer (*GCacheNewFunc) (gpointer key); +typedef gpointer (*GCacheDupFunc) (gpointer value); +typedef void (*GCacheDestroyFunc) (gpointer value); +typedef gint (*GTraverseFunc) (gpointer key, + gpointer value, + gpointer data); +typedef gint (*GSearchFunc) (gpointer key, + gpointer data); +typedef void (*GErrorFunc) (gchar *str); +typedef void (*GWarningFunc) (gchar *str); +typedef void (*GPrintFunc) (gchar *str); +typedef void (*GScannerMsgFunc) (GScanner *scanner, + gchar *message, + gint error); +typedef void (*GDestroyNotify) (gpointer data); + +typedef guint (*GHashFunc) (gconstpointer key); +typedef gint (*GCompareFunc) (gconstpointer a, + gconstpointer b); + +struct _GList +{ + gpointer data; + GList *next; + GList *prev; +}; + +struct _GSList +{ + gpointer data; + GSList *next; +}; + +struct _GString +{ + gchar *str; + gint len; +}; + +struct _GArray +{ + gchar *data; + guint len; +}; + +struct _GDebugKey +{ + gchar *key; + guint value; +}; + +struct _GHashTable { gint dummy; }; +struct _GCache { gint dummy; }; +struct _GTree { gint dummy; }; +struct _GTimer { gint dummy; }; +struct _GMemChunk { gint dummy; }; +struct _GListAllocator { gint dummy; }; +struct _GStringChunk { gint dummy; }; + +typedef enum +{ + G_IN_ORDER, + G_PRE_ORDER, + G_POST_ORDER +} GTraverseType; + +/* Doubly linked lists + */ +GList* g_list_alloc (void); +void g_list_free (GList *list); +void g_list_free_1 (GList *list); +GList* g_list_append (GList *list, + gpointer data); +GList* g_list_prepend (GList *list, + gpointer data); +GList* g_list_insert (GList *list, + gpointer data, + gint position); +GList* g_list_insert_sorted (GList *list, + gpointer data, + GCompareFunc func); +GList* g_list_concat (GList *list1, + GList *list2); +GList* g_list_remove (GList *list, + gpointer data); +GList* g_list_remove_link (GList *list, + GList *link); +GList* g_list_reverse (GList *list); +GList* g_list_nth (GList *list, + guint n); +GList* g_list_find (GList *list, + gpointer data); +GList* g_list_find_custom (GList *list, + gpointer data, + GCompareFunc func); +gint g_list_position (GList *list, + GList *link); +gint g_list_index (GList *list, + gpointer data); +GList* g_list_last (GList *list); +GList* g_list_first (GList *list); +guint g_list_length (GList *list); +void g_list_foreach (GList *list, + GFunc func, + gpointer user_data); +gpointer g_list_nth_data (GList *list, + guint n); + +#define g_list_previous(list) ((list) ? (((GList *)(list))->prev) : NULL) +#define g_list_next(list) ((list) ? (((GList *)(list))->next) : NULL) + +/* Singly linked lists + */ +GSList* g_slist_alloc (void); +void g_slist_free (GSList *list); +void g_slist_free_1 (GSList *list); +GSList* g_slist_append (GSList *list, + gpointer data); +GSList* g_slist_prepend (GSList *list, + gpointer data); +GSList* g_slist_insert (GSList *list, + gpointer data, + gint position); +GSList* g_slist_insert_sorted (GSList *list, + gpointer data, + GCompareFunc func); +GSList* g_slist_concat (GSList *list1, + GSList *list2); +GSList* g_slist_remove (GSList *list, + gpointer data); +GSList* g_slist_remove_link (GSList *list, + GSList *link); +GSList* g_slist_reverse (GSList *list); +GSList* g_slist_nth (GSList *list, + guint n); +GSList* g_slist_find (GSList *list, + gpointer data); +GSList* g_slist_find_custom (GSList *list, + gpointer data, + GCompareFunc func); +gint g_slist_position (GSList *list, + GSList *link); +gint g_slist_index (GSList *list, + gpointer data); +GSList* g_slist_last (GSList *list); +guint g_slist_length (GSList *list); +void g_slist_foreach (GSList *list, + GFunc func, + gpointer user_data); +gpointer g_slist_nth_data (GSList *list, + guint n); + +#define g_slist_next(slist) ((slist) ? (((GSList *)(slist))->next) : NULL) + +/* List Allocators + */ +GListAllocator* g_list_allocator_new (void); +void g_list_allocator_free (GListAllocator* allocator); +GListAllocator* g_slist_set_allocator (GListAllocator* allocator); +GListAllocator* g_list_set_allocator (GListAllocator* allocator); + + +/* Hash tables + */ +GHashTable* g_hash_table_new (GHashFunc hash_func, + GCompareFunc key_compare_func); +void g_hash_table_destroy (GHashTable *hash_table); +void g_hash_table_insert (GHashTable *hash_table, + gpointer key, + gpointer value); +void g_hash_table_remove (GHashTable *hash_table, + gconstpointer key); +gpointer g_hash_table_lookup (GHashTable *hash_table, + gconstpointer key); +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); + + +/* Caches + */ +GCache* g_cache_new (GCacheNewFunc value_new_func, + GCacheDestroyFunc value_destroy_func, + GCacheDupFunc key_dup_func, + GCacheDestroyFunc key_destroy_func, + GHashFunc hash_key_func, + GHashFunc hash_value_func, + GCompareFunc key_compare_func); +void g_cache_destroy (GCache *cache); +gpointer g_cache_insert (GCache *cache, + gpointer key); +void g_cache_remove (GCache *cache, + gpointer value); +void g_cache_key_foreach (GCache *cache, + GHFunc func, + gpointer user_data); +void g_cache_value_foreach (GCache *cache, + GHFunc func, + gpointer user_data); + + +/* Trees + */ +GTree* g_tree_new (GCompareFunc key_compare_func); +void g_tree_destroy (GTree *tree); +void g_tree_insert (GTree *tree, + gpointer key, + gpointer value); +void g_tree_remove (GTree *tree, + gpointer key); +gpointer g_tree_lookup (GTree *tree, + gpointer 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); +gint g_tree_height (GTree *tree); +gint g_tree_nnodes (GTree *tree); + + +/* Memory + */ + +#ifdef USE_DMALLOC + +#define g_malloc(size) (gpointer) MALLOC(size) +#define g_malloc0(size) (gpointer) CALLOC(char,size) +#define g_realloc(mem,size) (gpointer) REALLOC(mem,char,size) +#define g_free(mem) FREE(mem) + +#else /* USE_DMALLOC */ + +gpointer g_malloc (gulong size); +gpointer g_malloc0 (gulong size); +gpointer g_realloc (gpointer mem, + gulong size); +void g_free (gpointer mem); + +#endif /* USE_DMALLOC */ + +void g_mem_profile (void); +void g_mem_check (gpointer mem); + + +/* "g_mem_chunk_new" creates a new memory chunk. + * Memory chunks are used to allocate pieces of memory which are + * always the same size. Lists are a good example of such a data type. + * The memory chunk allocates and frees blocks of memory as needed. + * Just be sure to call "g_mem_chunk_free" and not "g_free" on data + * allocated in a mem chunk. ("g_free" will most likely cause a seg + * fault...somewhere). + * + * Oh yeah, GMemChunk is an opaque data type. (You don't really + * want to know what's going on inside do you?) + */ + +/* ALLOC_ONLY MemChunk's can only allocate memory. The free operation + * is interpreted as a no op. ALLOC_ONLY MemChunk's save 4 bytes per + * atom. (They are also useful for lists which use MemChunk to allocate + * memory but are also part of the MemChunk implementation). + * ALLOC_AND_FREE MemChunk's can allocate and free memory. + */ + +#define G_ALLOC_ONLY 1 +#define G_ALLOC_AND_FREE 2 + +GMemChunk* g_mem_chunk_new (gchar *name, + gint atom_size, + gulong area_size, + gint type); +void g_mem_chunk_destroy (GMemChunk *mem_chunk); +gpointer g_mem_chunk_alloc (GMemChunk *mem_chunk); +void g_mem_chunk_free (GMemChunk *mem_chunk, + gpointer mem); +void g_mem_chunk_clean (GMemChunk *mem_chunk); +void g_mem_chunk_reset (GMemChunk *mem_chunk); +void g_mem_chunk_print (GMemChunk *mem_chunk); +void g_mem_chunk_info (void); + +/* Ah yes...we have a "g_blow_chunks" function. + * "g_blow_chunks" simply compresses all the chunks. This operation + * consists of freeing every memory area that should be freed (but + * which we haven't gotten around to doing yet). And, no, + * "g_blow_chunks" doesn't follow the naming scheme, but it is a + * much better name than "g_mem_chunk_clean_all" or something + * similar. + */ +void g_blow_chunks (void); + + +/* Timer + */ +GTimer* g_timer_new (void); +void g_timer_destroy (GTimer *timer); +void g_timer_start (GTimer *timer); +void g_timer_stop (GTimer *timer); +void g_timer_reset (GTimer *timer); +gdouble g_timer_elapsed (GTimer *timer, + gulong *microseconds); + + +/* Output + */ +void g_error (const gchar *format, ...) G_GNUC_PRINTF (1, 2); +void g_warning (const gchar *format, ...) G_GNUC_PRINTF (1, 2); +void g_message (const gchar *format, ...) G_GNUC_PRINTF (1, 2); +void g_print (const gchar *format, ...) G_GNUC_PRINTF (1, 2); + +/* Utility functions + */ +#define G_STR_DELIMITERS "_-|> <." +void g_strdelimit (gchar *string, + const gchar *delimiters, + gchar new_delimiter); +gchar* g_strdup (const gchar *str); +gchar* g_strconcat (const gchar *string1, + ...); /* NULL terminated */ +gdouble g_strtod (const gchar *nptr, + gchar **endptr); +gchar* g_strerror (gint errnum); +gchar* g_strsignal (gint signum); +gint g_strcasecmp (const gchar *s1, + const gchar *s2); +void g_strdown (gchar *string); +void g_strup (gchar *string); +void g_strreverse (gchar *string); +guint g_parse_debug_string (const gchar *string, + GDebugKey *keys, + guint nkeys); +gint g_snprintf (gchar *string, + gulong n, + gchar const *format, + ...) G_GNUC_PRINTF (3, 4); + +/* We make the assumption that if memmove isn't available, then + * bcopy will do the job. This isn't safe everywhere. (bcopy can't + * necessarily handle overlapping copies) */ +#ifdef HAVE_MEMMOVE +#define g_memmove memmove +#else +#define g_memmove(a,b,c) bcopy(b,a,c) +#endif + +/* Errors + */ +GErrorFunc g_set_error_handler (GErrorFunc func); +GWarningFunc g_set_warning_handler (GWarningFunc func); +GPrintFunc g_set_message_handler (GPrintFunc func); +GPrintFunc g_set_print_handler (GPrintFunc func); + +void g_debug (const gchar *progname); +void g_attach_process (const gchar *progname, + gint query); +void g_stack_trace (const gchar *progname, + gint query); + + +/* String Chunks + */ +GStringChunk* g_string_chunk_new (gint size); +void g_string_chunk_free (GStringChunk *chunk); +gchar* g_string_chunk_insert (GStringChunk *chunk, + const gchar *string); +gchar* g_string_chunk_insert_const (GStringChunk *chunk, + const gchar *string); + +/* 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); + +/* Resizable arrays + */ +#define g_array_append_val(array,type,val) \ + g_rarray_append (array, (gpointer) &val, sizeof (type)) +#define g_array_append_vals(array,type,vals,nvals) \ + g_rarray_append (array, (gpointer) vals, sizeof (type) * nvals) +#define g_array_prepend_val(array,type,val) \ + g_rarray_prepend (array, (gpointer) &val, sizeof (type)) +#define g_array_prepend_vals(array,type,vals,nvals) \ + g_rarray_prepend (array, (gpointer) vals, sizeof (type) * nvals) +#define g_array_truncate(array,type,length) \ + g_rarray_truncate (array, length, sizeof (type)) +#define g_array_index(array,type,index) \ + ((type*) array->data)[index] + +GArray* g_array_new (gint zero_terminated); +void g_array_free (GArray *array, + gint free_segment); +GArray* g_rarray_append (GArray *array, + gpointer data, + gint size); +GArray* g_rarray_prepend (GArray *array, + gpointer data, + gint size); +GArray* g_rarray_truncate (GArray *array, + gint length, + gint size); + +/* Hash Functions + */ +gint g_str_equal (gconstpointer v, + gconstpointer v2); +guint g_str_hash (gconstpointer v); + +/* This "hash" function will just return the key's adress as an + * unsigned integer. Useful for hashing on plain adresses or + * simple integer values. + */ +guint g_direct_hash (gconstpointer key); + + +/* Location Associated Data + */ +void g_dataset_destroy (gconstpointer dataset_location); +guint g_dataset_try_key (const gchar *key); +guint g_dataset_force_id (const gchar *key); +gpointer g_dataset_id_get_data (gconstpointer dataset_location, + guint key_id); +void g_dataset_id_set_data_full (gconstpointer dataset_location, + guint key_id, + gpointer data, + GDestroyNotify destroy_func); +void g_dataset_id_set_destroy (gconstpointer dataset_location, + guint key_id, + GDestroyNotify destroy_func); + +#define g_dataset_id_set_data(l,k,d) G_STMT_START{g_dataset_id_set_data_full((l),(k),(d),NULL);}G_STMT_END +#define g_dataset_id_remove_data(l,k) G_STMT_START{g_dataset_id_set_data((l),(k),NULL);}G_STMT_END +#define g_dataset_get_data(l,k) (g_dataset_id_get_data((l),g_dataset_try_key(k))) +#define g_dataset_set_data_full(l,k,d,f) G_STMT_START{g_dataset_id_set_data_full((l),g_dataset_force_id(k),(d),(f));}G_STMT_END +#define g_dataset_set_destroy(l,k,f) G_STMT_START{g_dataset_id_set_destroy((l),g_dataset_force_id(k),(f));}G_STMT_END +#define g_dataset_set_data(l,k,d) G_STMT_START{g_dataset_set_data_full((l),(k),(d),NULL);}G_STMT_END +#define g_dataset_remove_data(l,k) G_STMT_START{g_dataset_set_data((l),(k),NULL);}G_STMT_END + + +/* GScanner: Flexible lexical scanner for general purpose. + */ + +/* Character sets */ +#define G_CSET_A_2_Z "ABCDEFGHIJKLMNOPQRSTUVWXYZ" +#define G_CSET_a_2_z "abcdefghijklmnopqrstuvwxyz" +#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"\ + "\330\331\332\333\334\335\336" +#define G_CSET_LATINS "\337\340\341\342\343\344\345\346"\ + "\347\350\351\352\353\354\355\356\357\360"\ + "\361\362\363\364\365\366"\ + "\370\371\372\373\374\375\376\377" + +/* Error types */ +typedef enum +{ + G_ERR_UNKNOWN, + G_ERR_UNEXP_EOF, + G_ERR_UNEXP_EOF_IN_STRING, + G_ERR_UNEXP_EOF_IN_COMMENT, + G_ERR_NON_DIGIT_IN_CONST, + G_ERR_DIGIT_RADIX, + G_ERR_FLOAT_RADIX, + G_ERR_FLOAT_MALFORMED +} GErrorType; + +/* Token types */ +typedef enum +{ + G_TOKEN_EOF = 0, + + G_TOKEN_LEFT_PAREN = '(', + G_TOKEN_RIGHT_PAREN = ')', + G_TOKEN_LEFT_CURLY = '{', + G_TOKEN_RIGHT_CURLY = '}', + G_TOKEN_LEFT_BRACE = '[', + G_TOKEN_RIGHT_BRACE = ']', + G_TOKEN_EQUAL_SIGN = '=', + G_TOKEN_COMMA = ',', + + G_TOKEN_NONE = 256, + + G_TOKEN_ERROR, + + G_TOKEN_CHAR, + G_TOKEN_BINARY, + G_TOKEN_OCTAL, + G_TOKEN_INT, + G_TOKEN_HEX, + G_TOKEN_FLOAT, + G_TOKEN_STRING, + + G_TOKEN_SYMBOL, + G_TOKEN_IDENTIFIER, + G_TOKEN_IDENTIFIER_NULL, + + G_TOKEN_COMMENT_SINGLE, + G_TOKEN_COMMENT_MULTI, + G_TOKEN_LAST +} GTokenType; + +union _GValue +{ + gpointer v_symbol; + gchar *v_identifier; + gulong v_binary; + gulong v_octal; + gulong v_int; + gdouble v_float; + gulong v_hex; + gchar *v_string; + gchar *v_comment; + guchar v_char; + guint v_error; +}; + +struct _GScannerConfig +{ + /* Character sets + */ + gchar *cset_skip_characters; /* default: " \t\n" */ + gchar *cset_identifier_first; + gchar *cset_identifier_nth; + gchar *cpair_comment_single; /* default: "#\n" */ + + /* Should symbol lookup work case sensitive? + */ + guint case_sensitive : 1; + + /* Boolean values to be adjusted "on the fly" + * to configure scanning behaviour. + */ + guint skip_comment_multi : 1; /* C like comment */ + guint skip_comment_single : 1; /* single line comment */ + guint scan_comment_multi : 1; /* scan multi line comments? */ + guint scan_identifier : 1; + guint scan_identifier_1char : 1; + guint scan_identifier_NULL : 1; + guint scan_symbols : 1; + guint scan_binary : 1; + guint scan_octal : 1; + guint scan_float : 1; + guint scan_hex : 1; /* `0x0ff0' */ + guint scan_hex_dollar : 1; /* `$0ff0' */ + guint scan_string_sq : 1; /* string: 'anything' */ + guint scan_string_dq : 1; /* string: "\\-escapes!\n" */ + guint numbers_2_int : 1; /* bin, octal, hex => int */ + guint int_2_float : 1; /* int => G_TOKEN_FLOAT? */ + guint identifier_2_string : 1; + guint char_2_token : 1; /* return G_TOKEN_CHAR? */ + guint symbol_2_token : 1; +}; + +struct _GScanner +{ + /* unused portions */ + gpointer user_data; + const gchar *input_name; + guint parse_errors; + guint max_parse_errors; + + /* maintained/used by the g_scanner_*() functions */ + GScannerConfig *config; + GTokenType token; + GValue value; + guint line; + guint position; + + /* to be considered private */ + GTokenType next_token; + GValue next_value; + guint next_line; + guint next_position; + GHashTable *symbol_table; + const gchar *text; + guint text_len; + gint input_fd; + gint peeked_char; + + GScannerMsgFunc msg_handler; +}; + +GScanner* g_scanner_new (GScannerConfig *config_templ); +void g_scanner_destroy (GScanner *scanner); +void g_scanner_input_file (GScanner *scanner, + gint input_fd); +void g_scanner_input_text (GScanner *scanner, + const gchar *text, + guint text_len); +GTokenType g_scanner_get_next_token (GScanner *scanner); +GTokenType g_scanner_peek_next_token (GScanner *scanner); +GTokenType g_scanner_cur_token (GScanner *scanner); +GValue g_scanner_cur_value (GScanner *scanner); +guint g_scanner_cur_line (GScanner *scanner); +guint g_scanner_cur_position (GScanner *scanner); +gboolean g_scanner_eof (GScanner *scanner); +void g_scanner_add_symbol (GScanner *scanner, + const gchar *symbol, + gpointer value); +gpointer g_scanner_lookup_symbol (GScanner *scanner, + const gchar *symbol); +void g_scanner_foreach_symbol (GScanner *scanner, + GHFunc func, + gpointer func_data); +void g_scanner_remove_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, + const gchar *symbol_spec, + const gchar *symbol_name, + const gchar *message, + gint is_error); +void g_scanner_error (GScanner *scanner, + const gchar *format, + ...) G_GNUC_PRINTF (2,3); +void g_scanner_warn (GScanner *scanner, + const gchar *format, + ...) G_GNUC_PRINTF (2,3); +gint g_scanner_stat_mode (const gchar *filename); + + +/* Completion */ + +typedef gchar* (*GCompletionFunc)(gpointer); + +typedef struct _GCompletion GCompletion; + +struct _GCompletion { + GList* items; + GCompletionFunc func; + + gchar* prefix; + GList* cache; + +}; + +GCompletion* g_completion_new (GCompletionFunc func); +void g_completion_add_items (GCompletion* cmp, + GList* items); +void g_completion_remove_items (GCompletion* cmp, + GList* items); +void g_completion_clear_items (GCompletion* cmp); +GList* g_completion_complete (GCompletion* cmp, + gchar* prefix, + gchar** new_prefix); +void g_completion_free (GCompletion* cmp); + +/* Glib version. + */ +extern const guint glib_major_version; +extern const guint glib_minor_version; +extern const guint glib_micro_version; + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + + +#endif /* __G_LIB_H__ */ diff --git a/glib/glib.h b/glib/glib.h new file mode 100644 index 0000000..021d747 --- /dev/null +++ b/glib/glib.h @@ -0,0 +1,1154 @@ +/* GLIB - Library of useful routines for C programming + * 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 + * 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. + * + * You should have received a copy of the GNU Library 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. + */ +#ifndef __G_LIB_H__ +#define __G_LIB_H__ + +#include + +#ifdef USE_DMALLOC +#include "dmalloc.h" +#endif + + +/* glib provides definitions for the extrema of many + * of the standard types. These are: + * G_MINFLOAT + * G_MAXFLOAT + * G_MINDOUBLE + * G_MAXDOUBLE + * G_MINSHORT + * G_MAXSHORT + * G_MININT + * G_MAXINT + * G_MINLONG + * G_MAXLONG + */ + +#ifdef HAVE_FLOAT_H + +#include + +#define G_MINFLOAT FLT_MIN +#define G_MAXFLOAT FLT_MAX +#define G_MINDOUBLE DBL_MIN +#define G_MAXDOUBLE DBL_MAX + +#elif HAVE_VALUES_H + +#include + +#define G_MINFLOAT MINFLOAT +#define G_MAXFLOAT MAXFLOAT +#define G_MINDOUBLE MINDOUBLE +#define G_MAXDOUBLE MAXDOUBLE + +#endif /* HAVE_VALUES_H */ + + +#ifdef HAVE_LIMITS_H + +#include + +#define G_MINSHORT SHRT_MIN +#define G_MAXSHORT SHRT_MAX +#define G_MININT INT_MIN +#define G_MAXINT INT_MAX +#define G_MINLONG LONG_MIN +#define G_MAXLONG LONG_MAX + +#elif HAVE_VALUES_H + +#ifdef HAVE_FLOAT_H +#include +#endif /* HAVE_FLOAT_H */ + +#define G_MINSHORT MINSHORT +#define G_MAXSHORT MAXSHORT +#define G_MININT MININT +#define G_MAXINT MAXINT +#define G_MINLONG MINLONG +#define G_MAXLONG MAXLONG + +#endif /* HAVE_VALUES_H */ + + +/* Provide definitions for some commonly used macros. + * Some of them are only provided if they haven't already + * been defined. It is assumed that if they are already + * defined then the current definition is correct. + */ +#ifndef NULL +#define NULL ((void*) 0) +#endif + +#ifndef FALSE +#define FALSE (0) +#endif + +#ifndef TRUE +#define TRUE (!FALSE) +#endif + +#undef MAX +#define MAX(a, b) (((a) > (b)) ? (a) : (b)) + +#undef MIN +#define MIN(a, b) (((a) < (b)) ? (a) : (b)) + +#undef ABS +#define ABS(a) (((a) < 0) ? -(a) : (a)) + +#undef CLAMP +#define CLAMP(x, low, high) (((x) > (high)) ? (high) : (((x) < (low)) ? (low) : (x))) + + +/* Provide simple enum value macro wrappers that ease automated enum value + * stringification code. + */ +#if !defined (G_CODE_GENERATION) +#define G_ENUM( EnumerationName ) EnumerationName +#define G_FLAGS( EnumerationName ) EnumerationName +#define G_NV( VALUE_NAME , value_nick, VALUE) VALUE_NAME = (VALUE) +#define G_SV( VALUE_NAME, value_nick ) VALUE_NAME +#else /* G_CODE_GENERATION */ +#define G_ENUM( EnumerationName ) G_ENUM_E + EnumerationName + +#define G_FLAGS( EnumerationName ) G_ENUM_F + EnumerationName + +#define G_NV( VALUE_NAME , value_nick, VALUE) G_ENUM_V + VALUE_NAME + value_nick + +#define G_SV( VALUE_NAME, value_nick ) G_ENUM_V + VALUE_NAME + value_nick + +#endif /* G_CODE_GENERATION */ + + +/* Provide simple macro statement wrappers (adapted from Pearl): + * G_STMT_START { statements; } G_STMT_END; + * can be used as a single statement, as in + * if (x) G_STMT_START { ... } G_STMT_END; else ... + * + * For gcc we will wrap the statements within `({' and `})' braces. + * For SunOS they will be wrapped within `if (1)' and `else (void) 0', + * and otherwise within `do' and `while (0)'. + */ +#if !(defined (G_STMT_START) && defined (G_STMT_END)) +# if defined (__GNUC__) && !defined (__STRICT_ANSI__) && !defined (__cplusplus) +# define G_STMT_START (void)( +# define G_STMT_END ) +# else +# if (defined (sun) || defined (__sun__)) +# define G_STMT_START if (1) +# define G_STMT_END else (void)0 +# else +# define G_STMT_START do +# define G_STMT_END while (0) +# endif +# endif +#endif + +/* Provide macros to feature the GCC function attribute. + */ +#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ > 4) +#define G_GNUC_PRINTF( format_idx, arg_idx ) \ + __attribute__((format (printf, format_idx, arg_idx))) +#define G_GNUC_SCANF( format_idx, arg_idx ) \ + __attribute__((format (scanf, format_idx, arg_idx))) +#define G_GNUC_FORMAT( arg_idx ) \ + __attribute__((format_arg (arg_idx))) +#define G_GNUC_NORETURN \ + __attribute__((noreturn)) +#define G_GNUC_CONST \ + __attribute__((const)) +#else /* !__GNUC__ */ +#define G_GNUC_PRINTF( format_idx, arg_idx ) +#define G_GNUC_SCANF( format_idx, arg_idx ) +#define G_GNUC_FORMAT( arg_idx ) +#define G_GNUC_NORETURN +#define G_GNUC_CONST +#endif /* !__GNUC__ */ + +/* Hacker macro to place breakpoints for x86 machines. + * Actuall use is strongly deprecated of course ;) + */ +#if defined (__i386__) +#define G_BREAKPOINT() G_STMT_START{ __asm__ ("int $03"); }G_STMT_END +#else /* !__i386__ */ +#define G_BREAKPOINT() +#endif /* __i386__ */ + +/* Wrap the __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__) +#else /* !__GNUC__ */ +#define G_GNUC_FUNCTION ("") +#define G_GNUC_PRETTY_FUNCTION ("") +#endif /* !__GNUC__ */ + + +#ifndef ATEXIT +# ifdef HAVE_ATEXIT +# define ATEXIT(proc) (atexit (proc)) +# elif defined (HAVE_ON_EXIT) +# define ATEXIT(proc) (on_exit ((void (*)(int, void *))(proc), NULL)) +# endif +#endif /* ATEXIT */ + + +/* Provide macros for easily allocating memory. The macros + * will cast the allocated memory to the specified type + * in order to avoid compiler warnings. (Makes the code neater). + */ + +#ifdef __DMALLOC_H__ + +#define g_new(type,count) ALLOC(type,count) +#define g_new0(type,count) CALLOC(type,count) + +#else /* __DMALLOC_H__ */ + +#define g_new(type, count) \ + ((type *) g_malloc ((unsigned) sizeof (type) * (count))) +#define g_new0(type, count) \ + ((type *) g_malloc0 ((unsigned) sizeof (type) * (count))) +#endif /* __DMALLOC_H__ */ + +#define g_mem_chunk_create(type, pre_alloc, alloc_type) ( \ + g_mem_chunk_new (#type " mem chunks (" #pre_alloc ")", \ + sizeof (type), \ + sizeof (type) * (pre_alloc), \ + (alloc_type)) \ +) +#define g_chunk_new(type, chunk) ( \ + (type *) g_mem_chunk_alloc (chunk) \ +) +#define g_chunk_new0(type, chunk) ( \ + (type *) memset (g_mem_chunk_alloc (chunk), 0, sizeof (type)) \ +) +#define g_chunk_free(mem, mem_chunk) G_STMT_START { \ + g_mem_chunk_free ((mem_chunk), (mem)); \ +} 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 + * in order to support gcc's __PRETTY_FUNCTION__ capability. + */ + +#ifdef G_DISABLE_ASSERT + +#define g_assert(expr) +#define g_assert_not_reached() + +#else /* !G_DISABLE_ASSERT */ + +#ifdef __GNUC__ + +#define g_assert(expr) G_STMT_START{\ + if (!(expr)) \ + g_error ("file %s: line %d (%s): \"%s\"", \ + __FILE__, \ + __LINE__, \ + __PRETTY_FUNCTION__, \ + #expr); }G_STMT_END + +#define g_assert_not_reached() G_STMT_START{ \ + g_error ("file %s: line %d (%s): \"should not be reached\"", \ + __FILE__, \ + __LINE__, \ + __PRETTY_FUNCTION__); }G_STMT_END + +#else /* !__GNUC__ */ + +#define g_assert(expr) G_STMT_START{\ + if (!(expr)) \ + g_error ("file %s: line %d: \"%s\"", \ + __FILE__, \ + __LINE__, \ + #expr); }G_STMT_END + +#define g_assert_not_reached() G_STMT_START{ \ + g_error ("file %s: line %d: \"should not be reached\"", \ + __FILE__, \ + __LINE__); }G_STMT_END + +#endif /* __GNUC__ */ + +#endif /* G_DISABLE_ASSERT */ + +#ifdef G_DISABLE_CHECKS + +#define g_return_if_fail(expr) +#define g_return_val_if_fail(expr,val) + +#else /* !G_DISABLE_CHECKS */ + +#ifdef __GNUC__ + +#define g_return_if_fail(expr) G_STMT_START{ \ + if (!(expr)) \ + { \ + g_warning ("file %s: line %d (%s): \"%s\"", \ + __FILE__, \ + __LINE__, \ + __PRETTY_FUNCTION__, \ + #expr); \ + return; \ + }; }G_STMT_END + +#define g_return_val_if_fail(expr,val) G_STMT_START{ \ + if (!(expr)) \ + { \ + g_warning ("file %s: line %d (%s): \"%s\"", \ + __FILE__, \ + __LINE__, \ + __PRETTY_FUNCTION__, \ + #expr); \ + return val; \ + }; }G_STMT_END + +#else /* !__GNUC__ */ + +#define g_return_if_fail(expr) G_STMT_START{ \ + if (!(expr)) \ + { \ + g_warning ("file %s: line %d: \"%s\"", \ + __FILE__, \ + __LINE__, \ + #expr); \ + return; \ + }; }G_STMT_END + +#define g_return_val_if_fail(expr, val) G_STMT_START{ \ + if (!(expr)) \ + { \ + g_warning ("file %s: line %d: \"%s\"", \ + __FILE__, \ + __LINE__, \ + #expr); \ + return val; \ + }; }G_STMT_END + +#endif /* !__GNUC__ */ + +#endif /* G_DISABLE_CHECKS */ + + +#ifdef __cplusplus +extern "C" { +#pragma } +#endif /* __cplusplus */ + +/* Provide type definitions for commonly used types. + * These are useful because a "gint8" can be adjusted + * to be 1 byte (8 bits) on all platforms. Similarly and + * more importantly, "gint32" can be adjusted to be + * 4 bytes (32 bits) on all platforms. + */ + +typedef char gchar; +typedef short gshort; +typedef long glong; +typedef int gint; +typedef gint gboolean; + +typedef unsigned char guchar; +typedef unsigned short gushort; +typedef unsigned long gulong; +typedef unsigned int guint; + +typedef float gfloat; +typedef double gdouble; + +/* HAVE_LONG_DOUBLE doesn't work correctly on all platforms. + * Since gldouble isn't used anywhere, just disable it for now */ + +#if 0 +#ifdef HAVE_LONG_DOUBLE +typedef long double gldouble; +#else /* HAVE_LONG_DOUBLE */ +typedef double gldouble; +#endif /* HAVE_LONG_DOUBLE */ +#endif /* 0 */ + +typedef void* gpointer; +typedef const void *gconstpointer; + +#if (SIZEOF_CHAR == 1) +typedef signed char gint8; +typedef unsigned char guint8; +#endif /* SIZEOF_CHAR */ + + +#if (SIZEOF_SHORT == 2) +typedef signed short gint16; +typedef unsigned short guint16; +#endif /* SIZEOF_SHORT */ + + +#if (SIZEOF_INT == 4) +typedef signed int gint32; +typedef unsigned int guint32; +#elif (SIZEOF_LONG == 4) +typedef signed long gint32; +typedef unsigned long guint32; +#endif /* SIZEOF_INT */ + +/* Define macros for storing integers inside pointers */ + +#if (SIZEOF_INT == SIZEOF_VOID_P) + +#define GPOINTER_TO_INT(p) ((gint)(p)) +#define GPOINTER_TO_UINT(p) ((guint)(p)) + +#define GINT_TO_POINTER(i) ((gpointer)(i)) +#define GUINT_TO_POINTER(u) ((gpointer)(u)) + +#elif (SIZEOF_LONG == SIZEOF_VOID_P) + +#define GPOINTER_TO_INT(p) ((gint)(glong)(p)) +#define GPOINTER_TO_UINT(p) ((guint)(gulong)(p)) + +#define GINT_TO_POINTER(i) ((gpointer)(glong)(i)) +#define GUINT_TO_POINTER(u) ((gpointer)(gulong)(u)) + +#else +/* This should never happen */ +#endif + + +typedef struct _GList GList; +typedef struct _GSList GSList; +typedef struct _GHashTable GHashTable; +typedef struct _GCache GCache; +typedef struct _GTree GTree; +typedef struct _GTimer GTimer; +typedef struct _GMemChunk GMemChunk; +typedef struct _GListAllocator GListAllocator; +typedef struct _GStringChunk GStringChunk; +typedef struct _GString GString; +typedef struct _GArray GArray; +typedef struct _GDebugKey GDebugKey; +typedef struct _GScannerConfig GScannerConfig; +typedef struct _GScanner GScanner; +typedef union _GValue GValue; + + +typedef void (*GFunc) (gpointer data, + gpointer user_data); +typedef void (*GHFunc) (gpointer key, + gpointer value, + gpointer user_data); +typedef gpointer (*GCacheNewFunc) (gpointer key); +typedef gpointer (*GCacheDupFunc) (gpointer value); +typedef void (*GCacheDestroyFunc) (gpointer value); +typedef gint (*GTraverseFunc) (gpointer key, + gpointer value, + gpointer data); +typedef gint (*GSearchFunc) (gpointer key, + gpointer data); +typedef void (*GErrorFunc) (gchar *str); +typedef void (*GWarningFunc) (gchar *str); +typedef void (*GPrintFunc) (gchar *str); +typedef void (*GScannerMsgFunc) (GScanner *scanner, + gchar *message, + gint error); +typedef void (*GDestroyNotify) (gpointer data); + +typedef guint (*GHashFunc) (gconstpointer key); +typedef gint (*GCompareFunc) (gconstpointer a, + gconstpointer b); + +struct _GList +{ + gpointer data; + GList *next; + GList *prev; +}; + +struct _GSList +{ + gpointer data; + GSList *next; +}; + +struct _GString +{ + gchar *str; + gint len; +}; + +struct _GArray +{ + gchar *data; + guint len; +}; + +struct _GDebugKey +{ + gchar *key; + guint value; +}; + +struct _GHashTable { gint dummy; }; +struct _GCache { gint dummy; }; +struct _GTree { gint dummy; }; +struct _GTimer { gint dummy; }; +struct _GMemChunk { gint dummy; }; +struct _GListAllocator { gint dummy; }; +struct _GStringChunk { gint dummy; }; + +typedef enum +{ + G_IN_ORDER, + G_PRE_ORDER, + G_POST_ORDER +} GTraverseType; + +/* Doubly linked lists + */ +GList* g_list_alloc (void); +void g_list_free (GList *list); +void g_list_free_1 (GList *list); +GList* g_list_append (GList *list, + gpointer data); +GList* g_list_prepend (GList *list, + gpointer data); +GList* g_list_insert (GList *list, + gpointer data, + gint position); +GList* g_list_insert_sorted (GList *list, + gpointer data, + GCompareFunc func); +GList* g_list_concat (GList *list1, + GList *list2); +GList* g_list_remove (GList *list, + gpointer data); +GList* g_list_remove_link (GList *list, + GList *link); +GList* g_list_reverse (GList *list); +GList* g_list_nth (GList *list, + guint n); +GList* g_list_find (GList *list, + gpointer data); +GList* g_list_find_custom (GList *list, + gpointer data, + GCompareFunc func); +gint g_list_position (GList *list, + GList *link); +gint g_list_index (GList *list, + gpointer data); +GList* g_list_last (GList *list); +GList* g_list_first (GList *list); +guint g_list_length (GList *list); +void g_list_foreach (GList *list, + GFunc func, + gpointer user_data); +gpointer g_list_nth_data (GList *list, + guint n); + +#define g_list_previous(list) ((list) ? (((GList *)(list))->prev) : NULL) +#define g_list_next(list) ((list) ? (((GList *)(list))->next) : NULL) + +/* Singly linked lists + */ +GSList* g_slist_alloc (void); +void g_slist_free (GSList *list); +void g_slist_free_1 (GSList *list); +GSList* g_slist_append (GSList *list, + gpointer data); +GSList* g_slist_prepend (GSList *list, + gpointer data); +GSList* g_slist_insert (GSList *list, + gpointer data, + gint position); +GSList* g_slist_insert_sorted (GSList *list, + gpointer data, + GCompareFunc func); +GSList* g_slist_concat (GSList *list1, + GSList *list2); +GSList* g_slist_remove (GSList *list, + gpointer data); +GSList* g_slist_remove_link (GSList *list, + GSList *link); +GSList* g_slist_reverse (GSList *list); +GSList* g_slist_nth (GSList *list, + guint n); +GSList* g_slist_find (GSList *list, + gpointer data); +GSList* g_slist_find_custom (GSList *list, + gpointer data, + GCompareFunc func); +gint g_slist_position (GSList *list, + GSList *link); +gint g_slist_index (GSList *list, + gpointer data); +GSList* g_slist_last (GSList *list); +guint g_slist_length (GSList *list); +void g_slist_foreach (GSList *list, + GFunc func, + gpointer user_data); +gpointer g_slist_nth_data (GSList *list, + guint n); + +#define g_slist_next(slist) ((slist) ? (((GSList *)(slist))->next) : NULL) + +/* List Allocators + */ +GListAllocator* g_list_allocator_new (void); +void g_list_allocator_free (GListAllocator* allocator); +GListAllocator* g_slist_set_allocator (GListAllocator* allocator); +GListAllocator* g_list_set_allocator (GListAllocator* allocator); + + +/* Hash tables + */ +GHashTable* g_hash_table_new (GHashFunc hash_func, + GCompareFunc key_compare_func); +void g_hash_table_destroy (GHashTable *hash_table); +void g_hash_table_insert (GHashTable *hash_table, + gpointer key, + gpointer value); +void g_hash_table_remove (GHashTable *hash_table, + gconstpointer key); +gpointer g_hash_table_lookup (GHashTable *hash_table, + gconstpointer key); +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); + + +/* Caches + */ +GCache* g_cache_new (GCacheNewFunc value_new_func, + GCacheDestroyFunc value_destroy_func, + GCacheDupFunc key_dup_func, + GCacheDestroyFunc key_destroy_func, + GHashFunc hash_key_func, + GHashFunc hash_value_func, + GCompareFunc key_compare_func); +void g_cache_destroy (GCache *cache); +gpointer g_cache_insert (GCache *cache, + gpointer key); +void g_cache_remove (GCache *cache, + gpointer value); +void g_cache_key_foreach (GCache *cache, + GHFunc func, + gpointer user_data); +void g_cache_value_foreach (GCache *cache, + GHFunc func, + gpointer user_data); + + +/* Trees + */ +GTree* g_tree_new (GCompareFunc key_compare_func); +void g_tree_destroy (GTree *tree); +void g_tree_insert (GTree *tree, + gpointer key, + gpointer value); +void g_tree_remove (GTree *tree, + gpointer key); +gpointer g_tree_lookup (GTree *tree, + gpointer 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); +gint g_tree_height (GTree *tree); +gint g_tree_nnodes (GTree *tree); + + +/* Memory + */ + +#ifdef USE_DMALLOC + +#define g_malloc(size) (gpointer) MALLOC(size) +#define g_malloc0(size) (gpointer) CALLOC(char,size) +#define g_realloc(mem,size) (gpointer) REALLOC(mem,char,size) +#define g_free(mem) FREE(mem) + +#else /* USE_DMALLOC */ + +gpointer g_malloc (gulong size); +gpointer g_malloc0 (gulong size); +gpointer g_realloc (gpointer mem, + gulong size); +void g_free (gpointer mem); + +#endif /* USE_DMALLOC */ + +void g_mem_profile (void); +void g_mem_check (gpointer mem); + + +/* "g_mem_chunk_new" creates a new memory chunk. + * Memory chunks are used to allocate pieces of memory which are + * always the same size. Lists are a good example of such a data type. + * The memory chunk allocates and frees blocks of memory as needed. + * Just be sure to call "g_mem_chunk_free" and not "g_free" on data + * allocated in a mem chunk. ("g_free" will most likely cause a seg + * fault...somewhere). + * + * Oh yeah, GMemChunk is an opaque data type. (You don't really + * want to know what's going on inside do you?) + */ + +/* ALLOC_ONLY MemChunk's can only allocate memory. The free operation + * is interpreted as a no op. ALLOC_ONLY MemChunk's save 4 bytes per + * atom. (They are also useful for lists which use MemChunk to allocate + * memory but are also part of the MemChunk implementation). + * ALLOC_AND_FREE MemChunk's can allocate and free memory. + */ + +#define G_ALLOC_ONLY 1 +#define G_ALLOC_AND_FREE 2 + +GMemChunk* g_mem_chunk_new (gchar *name, + gint atom_size, + gulong area_size, + gint type); +void g_mem_chunk_destroy (GMemChunk *mem_chunk); +gpointer g_mem_chunk_alloc (GMemChunk *mem_chunk); +void g_mem_chunk_free (GMemChunk *mem_chunk, + gpointer mem); +void g_mem_chunk_clean (GMemChunk *mem_chunk); +void g_mem_chunk_reset (GMemChunk *mem_chunk); +void g_mem_chunk_print (GMemChunk *mem_chunk); +void g_mem_chunk_info (void); + +/* Ah yes...we have a "g_blow_chunks" function. + * "g_blow_chunks" simply compresses all the chunks. This operation + * consists of freeing every memory area that should be freed (but + * which we haven't gotten around to doing yet). And, no, + * "g_blow_chunks" doesn't follow the naming scheme, but it is a + * much better name than "g_mem_chunk_clean_all" or something + * similar. + */ +void g_blow_chunks (void); + + +/* Timer + */ +GTimer* g_timer_new (void); +void g_timer_destroy (GTimer *timer); +void g_timer_start (GTimer *timer); +void g_timer_stop (GTimer *timer); +void g_timer_reset (GTimer *timer); +gdouble g_timer_elapsed (GTimer *timer, + gulong *microseconds); + + +/* Output + */ +void g_error (const gchar *format, ...) G_GNUC_PRINTF (1, 2); +void g_warning (const gchar *format, ...) G_GNUC_PRINTF (1, 2); +void g_message (const gchar *format, ...) G_GNUC_PRINTF (1, 2); +void g_print (const gchar *format, ...) G_GNUC_PRINTF (1, 2); + +/* Utility functions + */ +#define G_STR_DELIMITERS "_-|> <." +void g_strdelimit (gchar *string, + const gchar *delimiters, + gchar new_delimiter); +gchar* g_strdup (const gchar *str); +gchar* g_strconcat (const gchar *string1, + ...); /* NULL terminated */ +gdouble g_strtod (const gchar *nptr, + gchar **endptr); +gchar* g_strerror (gint errnum); +gchar* g_strsignal (gint signum); +gint g_strcasecmp (const gchar *s1, + const gchar *s2); +void g_strdown (gchar *string); +void g_strup (gchar *string); +void g_strreverse (gchar *string); +guint g_parse_debug_string (const gchar *string, + GDebugKey *keys, + guint nkeys); +gint g_snprintf (gchar *string, + gulong n, + gchar const *format, + ...) G_GNUC_PRINTF (3, 4); + +/* We make the assumption that if memmove isn't available, then + * bcopy will do the job. This isn't safe everywhere. (bcopy can't + * necessarily handle overlapping copies) */ +#ifdef HAVE_MEMMOVE +#define g_memmove memmove +#else +#define g_memmove(a,b,c) bcopy(b,a,c) +#endif + +/* Errors + */ +GErrorFunc g_set_error_handler (GErrorFunc func); +GWarningFunc g_set_warning_handler (GWarningFunc func); +GPrintFunc g_set_message_handler (GPrintFunc func); +GPrintFunc g_set_print_handler (GPrintFunc func); + +void g_debug (const gchar *progname); +void g_attach_process (const gchar *progname, + gint query); +void g_stack_trace (const gchar *progname, + gint query); + + +/* String Chunks + */ +GStringChunk* g_string_chunk_new (gint size); +void g_string_chunk_free (GStringChunk *chunk); +gchar* g_string_chunk_insert (GStringChunk *chunk, + const gchar *string); +gchar* g_string_chunk_insert_const (GStringChunk *chunk, + const gchar *string); + +/* 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); + +/* Resizable arrays + */ +#define g_array_append_val(array,type,val) \ + g_rarray_append (array, (gpointer) &val, sizeof (type)) +#define g_array_append_vals(array,type,vals,nvals) \ + g_rarray_append (array, (gpointer) vals, sizeof (type) * nvals) +#define g_array_prepend_val(array,type,val) \ + g_rarray_prepend (array, (gpointer) &val, sizeof (type)) +#define g_array_prepend_vals(array,type,vals,nvals) \ + g_rarray_prepend (array, (gpointer) vals, sizeof (type) * nvals) +#define g_array_truncate(array,type,length) \ + g_rarray_truncate (array, length, sizeof (type)) +#define g_array_index(array,type,index) \ + ((type*) array->data)[index] + +GArray* g_array_new (gint zero_terminated); +void g_array_free (GArray *array, + gint free_segment); +GArray* g_rarray_append (GArray *array, + gpointer data, + gint size); +GArray* g_rarray_prepend (GArray *array, + gpointer data, + gint size); +GArray* g_rarray_truncate (GArray *array, + gint length, + gint size); + +/* Hash Functions + */ +gint g_str_equal (gconstpointer v, + gconstpointer v2); +guint g_str_hash (gconstpointer v); + +/* This "hash" function will just return the key's adress as an + * unsigned integer. Useful for hashing on plain adresses or + * simple integer values. + */ +guint g_direct_hash (gconstpointer key); + + +/* Location Associated Data + */ +void g_dataset_destroy (gconstpointer dataset_location); +guint g_dataset_try_key (const gchar *key); +guint g_dataset_force_id (const gchar *key); +gpointer g_dataset_id_get_data (gconstpointer dataset_location, + guint key_id); +void g_dataset_id_set_data_full (gconstpointer dataset_location, + guint key_id, + gpointer data, + GDestroyNotify destroy_func); +void g_dataset_id_set_destroy (gconstpointer dataset_location, + guint key_id, + GDestroyNotify destroy_func); + +#define g_dataset_id_set_data(l,k,d) G_STMT_START{g_dataset_id_set_data_full((l),(k),(d),NULL);}G_STMT_END +#define g_dataset_id_remove_data(l,k) G_STMT_START{g_dataset_id_set_data((l),(k),NULL);}G_STMT_END +#define g_dataset_get_data(l,k) (g_dataset_id_get_data((l),g_dataset_try_key(k))) +#define g_dataset_set_data_full(l,k,d,f) G_STMT_START{g_dataset_id_set_data_full((l),g_dataset_force_id(k),(d),(f));}G_STMT_END +#define g_dataset_set_destroy(l,k,f) G_STMT_START{g_dataset_id_set_destroy((l),g_dataset_force_id(k),(f));}G_STMT_END +#define g_dataset_set_data(l,k,d) G_STMT_START{g_dataset_set_data_full((l),(k),(d),NULL);}G_STMT_END +#define g_dataset_remove_data(l,k) G_STMT_START{g_dataset_set_data((l),(k),NULL);}G_STMT_END + + +/* GScanner: Flexible lexical scanner for general purpose. + */ + +/* Character sets */ +#define G_CSET_A_2_Z "ABCDEFGHIJKLMNOPQRSTUVWXYZ" +#define G_CSET_a_2_z "abcdefghijklmnopqrstuvwxyz" +#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"\ + "\330\331\332\333\334\335\336" +#define G_CSET_LATINS "\337\340\341\342\343\344\345\346"\ + "\347\350\351\352\353\354\355\356\357\360"\ + "\361\362\363\364\365\366"\ + "\370\371\372\373\374\375\376\377" + +/* Error types */ +typedef enum +{ + G_ERR_UNKNOWN, + G_ERR_UNEXP_EOF, + G_ERR_UNEXP_EOF_IN_STRING, + G_ERR_UNEXP_EOF_IN_COMMENT, + G_ERR_NON_DIGIT_IN_CONST, + G_ERR_DIGIT_RADIX, + G_ERR_FLOAT_RADIX, + G_ERR_FLOAT_MALFORMED +} GErrorType; + +/* Token types */ +typedef enum +{ + G_TOKEN_EOF = 0, + + G_TOKEN_LEFT_PAREN = '(', + G_TOKEN_RIGHT_PAREN = ')', + G_TOKEN_LEFT_CURLY = '{', + G_TOKEN_RIGHT_CURLY = '}', + G_TOKEN_LEFT_BRACE = '[', + G_TOKEN_RIGHT_BRACE = ']', + G_TOKEN_EQUAL_SIGN = '=', + G_TOKEN_COMMA = ',', + + G_TOKEN_NONE = 256, + + G_TOKEN_ERROR, + + G_TOKEN_CHAR, + G_TOKEN_BINARY, + G_TOKEN_OCTAL, + G_TOKEN_INT, + G_TOKEN_HEX, + G_TOKEN_FLOAT, + G_TOKEN_STRING, + + G_TOKEN_SYMBOL, + G_TOKEN_IDENTIFIER, + G_TOKEN_IDENTIFIER_NULL, + + G_TOKEN_COMMENT_SINGLE, + G_TOKEN_COMMENT_MULTI, + G_TOKEN_LAST +} GTokenType; + +union _GValue +{ + gpointer v_symbol; + gchar *v_identifier; + gulong v_binary; + gulong v_octal; + gulong v_int; + gdouble v_float; + gulong v_hex; + gchar *v_string; + gchar *v_comment; + guchar v_char; + guint v_error; +}; + +struct _GScannerConfig +{ + /* Character sets + */ + gchar *cset_skip_characters; /* default: " \t\n" */ + gchar *cset_identifier_first; + gchar *cset_identifier_nth; + gchar *cpair_comment_single; /* default: "#\n" */ + + /* Should symbol lookup work case sensitive? + */ + guint case_sensitive : 1; + + /* Boolean values to be adjusted "on the fly" + * to configure scanning behaviour. + */ + guint skip_comment_multi : 1; /* C like comment */ + guint skip_comment_single : 1; /* single line comment */ + guint scan_comment_multi : 1; /* scan multi line comments? */ + guint scan_identifier : 1; + guint scan_identifier_1char : 1; + guint scan_identifier_NULL : 1; + guint scan_symbols : 1; + guint scan_binary : 1; + guint scan_octal : 1; + guint scan_float : 1; + guint scan_hex : 1; /* `0x0ff0' */ + guint scan_hex_dollar : 1; /* `$0ff0' */ + guint scan_string_sq : 1; /* string: 'anything' */ + guint scan_string_dq : 1; /* string: "\\-escapes!\n" */ + guint numbers_2_int : 1; /* bin, octal, hex => int */ + guint int_2_float : 1; /* int => G_TOKEN_FLOAT? */ + guint identifier_2_string : 1; + guint char_2_token : 1; /* return G_TOKEN_CHAR? */ + guint symbol_2_token : 1; +}; + +struct _GScanner +{ + /* unused portions */ + gpointer user_data; + const gchar *input_name; + guint parse_errors; + guint max_parse_errors; + + /* maintained/used by the g_scanner_*() functions */ + GScannerConfig *config; + GTokenType token; + GValue value; + guint line; + guint position; + + /* to be considered private */ + GTokenType next_token; + GValue next_value; + guint next_line; + guint next_position; + GHashTable *symbol_table; + const gchar *text; + guint text_len; + gint input_fd; + gint peeked_char; + + GScannerMsgFunc msg_handler; +}; + +GScanner* g_scanner_new (GScannerConfig *config_templ); +void g_scanner_destroy (GScanner *scanner); +void g_scanner_input_file (GScanner *scanner, + gint input_fd); +void g_scanner_input_text (GScanner *scanner, + const gchar *text, + guint text_len); +GTokenType g_scanner_get_next_token (GScanner *scanner); +GTokenType g_scanner_peek_next_token (GScanner *scanner); +GTokenType g_scanner_cur_token (GScanner *scanner); +GValue g_scanner_cur_value (GScanner *scanner); +guint g_scanner_cur_line (GScanner *scanner); +guint g_scanner_cur_position (GScanner *scanner); +gboolean g_scanner_eof (GScanner *scanner); +void g_scanner_add_symbol (GScanner *scanner, + const gchar *symbol, + gpointer value); +gpointer g_scanner_lookup_symbol (GScanner *scanner, + const gchar *symbol); +void g_scanner_foreach_symbol (GScanner *scanner, + GHFunc func, + gpointer func_data); +void g_scanner_remove_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, + const gchar *symbol_spec, + const gchar *symbol_name, + const gchar *message, + gint is_error); +void g_scanner_error (GScanner *scanner, + const gchar *format, + ...) G_GNUC_PRINTF (2,3); +void g_scanner_warn (GScanner *scanner, + const gchar *format, + ...) G_GNUC_PRINTF (2,3); +gint g_scanner_stat_mode (const gchar *filename); + + +/* Completion */ + +typedef gchar* (*GCompletionFunc)(gpointer); + +typedef struct _GCompletion GCompletion; + +struct _GCompletion { + GList* items; + GCompletionFunc func; + + gchar* prefix; + GList* cache; + +}; + +GCompletion* g_completion_new (GCompletionFunc func); +void g_completion_add_items (GCompletion* cmp, + GList* items); +void g_completion_remove_items (GCompletion* cmp, + GList* items); +void g_completion_clear_items (GCompletion* cmp); +GList* g_completion_complete (GCompletion* cmp, + gchar* prefix, + gchar** new_prefix); +void g_completion_free (GCompletion* cmp); + +/* Glib version. + */ +extern const guint glib_major_version; +extern const guint glib_minor_version; +extern const guint glib_micro_version; + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + + +#endif /* __G_LIB_H__ */ -- 2.7.4