callisto-debian/gtk3
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

new file for GScanner: Flexible lexical scanner for general purpose. added

Browse Source 
* gscanner.c: new file for GScanner: Flexible lexical scanner for
        general purpose.
        * glib_pre2.h: added GScanner includes. added g_strconcat and g_strtod.
        gutils.c (g_strconcat): new function for string concatenation of NULL
        terminated parameter list.
        (g_strtod): new function to perform best string to double conversion
        with or without consideration of the current locale.
-timj
This commit is contained in:
Tim Janik
1997-12-23 02:09:34 +00:00
parent b44565f3e4
commit e3956c289a
5 changed files with 1600 additions and 205 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
glib/ChangeLog
View File

@ -1,3 +1,13 @@
Tue Dec 23 02:49:51 1997 Tim Janik <timj@psynet.net>
* gscanner.c: new file for GScanner: Flexible lexical scanner for
general purpose.
* glib_pre2.h: added GScanner includes. added g_strconcat and g_strtod.
gutils.c (g_strconcat): new function for string concatenation of NULL
terminated parameter list.
(g_strtod): new function to perform best string to double conversion
with or without consideration of the current locale.
Mon Dec 15 19:33:58 1997 Tim Janik <timj@psynet.net> Mon Dec 15 19:33:58 1997 Tim Janik <timj@psynet.net>
* glist.c: minor optimizations: * glist.c: minor optimizations:

5
glib/Makefile.am
View File

@ -13,8 +13,9 @@ libglib_la_SOURCES = \
gslist.c \ gslist.c \
gtimer.c \ gtimer.c \
gtree.c \ gtree.c \
gutils.c \ gstring.c \
gstring.c gscanner.c \
gutils.c
include_HEADERS = \ include_HEADERS = \
glib.h glib.h

571
glib/glib_pre2.h
View File

@ -96,7 +96,7 @@
#endif /* MIN */ #endif /* MIN */
#ifndef ABS #ifndef ABS
#define ABS(a) (((a) < 0) ? -(a) : (a)) #define ABS(a) (((a) < 0) ? -(a) : (a))
#endif /* ABS */ #endif /* ABS */
#ifndef CLAMP #ifndef CLAMP
@ -115,14 +115,14 @@
#ifdef __DMALLOC_H__ #ifdef __DMALLOC_H__
#define g_new(type,count) ALLOC(type,count) #define g_new(type,count) ALLOC(type,count)
#define g_new0(type,count) CALLOC(type,count) #define g_new0(type,count) CALLOC(type,count)
#else /* __DMALLOC_H__ */ #else /* __DMALLOC_H__ */
#define g_new(type, count) \ #define g_new(type, count) \
((type *) g_malloc ((unsigned) sizeof (type) * (count))) ((type *) g_malloc ((unsigned) sizeof (type) * (count)))
#define g_new0(type, count) \ #define g_new0(type, count) \
((type *) g_malloc0 ((unsigned) sizeof (type) * (count))) ((type *) g_malloc0 ((unsigned) sizeof (type) * (count)))
#endif /* __DMALLOC_H__ */ #endif /* __DMALLOC_H__ */
@ -167,73 +167,73 @@
#ifdef __GNUC__ #ifdef __GNUC__
#define g_assert(expr) G_STMT_START{\ #define g_assert(expr) G_STMT_START{\
if (!(expr)) \ if (!(expr)) \
g_error ("file %s: line %d (%s): \"%s\"", \ g_error ("file %s: line %d (%s): \"%s\"", \
__FILE__, \ __FILE__, \
__LINE__, \ __LINE__, \
__PRETTY_FUNCTION__, \ __PRETTY_FUNCTION__, \
#expr); }G_STMT_END #expr); }G_STMT_END
#define g_assert_not_reached() G_STMT_START{ \ #define g_assert_not_reached() G_STMT_START{ \
g_error ("file %s: line %d (%s): \"should not be reached\"", \ g_error ("file %s: line %d (%s): \"should not be reached\"", \
__FILE__, \ __FILE__, \
__LINE__, \ __LINE__, \
__PRETTY_FUNCTION__); }G_STMT_END __PRETTY_FUNCTION__); }G_STMT_END
#define g_return_if_fail(expr) G_STMT_START{ \ #define g_return_if_fail(expr) G_STMT_START{ \
if (!(expr)) \ if (!(expr)) \
{ \ { \
g_warning ("file %s: line %d (%s): \"%s\"", \ g_warning ("file %s: line %d (%s): \"%s\"", \
__FILE__, \ __FILE__, \
__LINE__, \ __LINE__, \
__PRETTY_FUNCTION__, \ __PRETTY_FUNCTION__, \
#expr); \ #expr); \
return; \ return; \
}; }G_STMT_END }; }G_STMT_END
#define g_return_val_if_fail(expr,val) G_STMT_START{ \ #define g_return_val_if_fail(expr,val) G_STMT_START{ \
if (!(expr)) \ if (!(expr)) \
{ \ { \
g_warning ("file %s: line %d (%s): \"%s\"", \ g_warning ("file %s: line %d (%s): \"%s\"", \
__FILE__, \ __FILE__, \
__LINE__, \ __LINE__, \
__PRETTY_FUNCTION__, \ __PRETTY_FUNCTION__, \
#expr); \ #expr); \
return val; \ return val; \
}; }G_STMT_END }; }G_STMT_END
#else /* __GNUC__ */ #else /* __GNUC__ */
#define g_assert(expr) G_STMT_START{\ #define g_assert(expr) G_STMT_START{\
if (!(expr)) \ if (!(expr)) \
g_error ("file %s: line %d: \"%s\"", \ g_error ("file %s: line %d: \"%s\"", \
__FILE__, \ __FILE__, \
__LINE__, \ __LINE__, \
#expr); }G_STMT_END #expr); }G_STMT_END
#define g_assert_not_reached() G_STMT_START{ \ #define g_assert_not_reached() G_STMT_START{ \
g_error ("file %s: line %d: \"should not be reached\"", \ g_error ("file %s: line %d: \"should not be reached\"", \
__FILE__, \ __FILE__, \
__LINE__); }G_STMT_END __LINE__); }G_STMT_END
#define g_return_if_fail(expr) G_STMT_START{ \ #define g_return_if_fail(expr) G_STMT_START{ \
if (!(expr)) \ if (!(expr)) \
{ \ { \
g_warning ("file %s: line %d: \"%s\"", \ g_warning ("file %s: line %d: \"%s\"", \
__FILE__, \ __FILE__, \
__LINE__, \ __LINE__, \
#expr); \ #expr); \
return; \ return; \
}; }G_STMT_END }; }G_STMT_END
#define g_return_val_if_fail(expr, val) G_STMT_START{ \ #define g_return_val_if_fail(expr, val) G_STMT_START{ \
if (!(expr)) \ if (!(expr)) \
{ \ { \
g_warning ("file %s: line %d: \"%s\"", \ g_warning ("file %s: line %d: \"%s\"", \
__FILE__, \ __FILE__, \
__LINE__, \ __LINE__, \
#expr); \ #expr); \
return val; \ return val; \
}; }G_STMT_END }; }G_STMT_END
#endif /* __GNUC__ */ #endif /* __GNUC__ */
@ -256,13 +256,13 @@ typedef long glong;
typedef int gint; typedef int gint;
typedef char gboolean; typedef char gboolean;
typedef unsigned char guchar; typedef unsigned char guchar;
typedef unsigned short gushort; typedef unsigned short gushort;
typedef unsigned long gulong; typedef unsigned long gulong;
typedef unsigned int guint; typedef unsigned int guint;
typedef float gfloat; typedef float gfloat;
typedef double gdouble; typedef double gdouble;
/* HAVE_LONG_DOUBLE doesn't work correctly on all platforms. /* HAVE_LONG_DOUBLE doesn't work correctly on all platforms.
* Since gldouble isn't used anywhere, just disable it for now */ * Since gldouble isn't used anywhere, just disable it for now */
@ -278,37 +278,37 @@ typedef double gldouble;
typedef void* gpointer; typedef void* gpointer;
#if (SIZEOF_CHAR == 1) #if (SIZEOF_CHAR == 1)
typedef signed char gint8; typedef signed char gint8;
typedef unsigned char guint8; typedef unsigned char guint8;
#endif /* SIZEOF_CHAR */ #endif /* SIZEOF_CHAR */
#if (SIZEOF_SHORT == 2) #if (SIZEOF_SHORT == 2)
typedef signed short gint16; typedef signed short gint16;
typedef unsigned short guint16; typedef unsigned short guint16;
#endif /* SIZEOF_SHORT */ #endif /* SIZEOF_SHORT */
#if (SIZEOF_INT == 4) #if (SIZEOF_INT == 4)
typedef signed int gint32; typedef signed int gint32;
typedef unsigned int guint32; typedef unsigned int guint32;
#elif (SIZEOF_LONG == 4) #elif (SIZEOF_LONG == 4)
typedef signed long gint32; typedef signed long gint32;
typedef unsigned long guint32; typedef unsigned long guint32;
#endif /* SIZEOF_INT */ #endif /* SIZEOF_INT */
typedef struct _GList GList; typedef struct _GList GList;
typedef struct _GSList GSList; typedef struct _GSList GSList;
typedef struct _GHashTable GHashTable; typedef struct _GHashTable GHashTable;
typedef struct _GCache GCache; typedef struct _GCache GCache;
typedef struct _GTree GTree; typedef struct _GTree GTree;
typedef struct _GTimer GTimer; typedef struct _GTimer GTimer;
typedef struct _GMemChunk GMemChunk; typedef struct _GMemChunk GMemChunk;
typedef struct _GListAllocator GListAllocator; typedef struct _GListAllocator GListAllocator;
typedef struct _GStringChunk GStringChunk; typedef struct _GStringChunk GStringChunk;
typedef struct _GString GString; typedef struct _GString GString;
typedef struct _GArray GArray; typedef struct _GArray GArray;
typedef void (*GFunc) (gpointer data, gpointer user_data); typedef void (*GFunc) (gpointer data, gpointer user_data);
typedef void (*GHFunc) (gpointer key, gpointer value, gpointer user_data); typedef void (*GHFunc) (gpointer key, gpointer value, gpointer user_data);
@ -369,61 +369,61 @@ typedef enum
/* Doubly linked lists /* Doubly linked lists
*/ */
GList* g_list_alloc (void); GList* g_list_alloc (void);
void g_list_free (GList *list); void g_list_free (GList *list);
void g_list_free_1 (GList *list); void g_list_free_1 (GList *list);
GList* g_list_append (GList *list, GList* g_list_append (GList *list,
gpointer data); gpointer data);
GList* g_list_prepend (GList *list, GList* g_list_prepend (GList *list,
gpointer data); gpointer data);
GList* g_list_insert (GList *list, GList* g_list_insert (GList *list,
gpointer data, gpointer data,
gint position); gint position);
GList* g_list_concat (GList *list1, GList* g_list_concat (GList *list1,
GList *list2); GList *list2);
GList* g_list_remove (GList *list, GList* g_list_remove (GList *list,
gpointer data); gpointer data);
GList* g_list_remove_link (GList *list, GList* g_list_remove_link (GList *list,
GList *link); GList *link);
GList* g_list_reverse (GList *list); GList* g_list_reverse (GList *list);
GList* g_list_nth (GList *list, GList* g_list_nth (GList *list,
gint n); gint n);
GList* g_list_find (GList *list, GList* g_list_find (GList *list,
gpointer data); gpointer data);
GList* g_list_last (GList *list); GList* g_list_last (GList *list);
GList* g_list_first (GList *list); GList* g_list_first (GList *list);
gint g_list_length (GList *list); gint g_list_length (GList *list);
void g_list_foreach (GList *list, void g_list_foreach (GList *list,
GFunc func, GFunc func,
gpointer user_data); gpointer user_data);
/* Singly linked lists /* Singly linked lists
*/ */
GSList* g_slist_alloc (void); GSList* g_slist_alloc (void);
void g_slist_free (GSList *list); void g_slist_free (GSList *list);
void g_slist_free_1 (GSList *list); void g_slist_free_1 (GSList *list);
GSList* g_slist_append (GSList *list, GSList* g_slist_append (GSList *list,
gpointer data); gpointer data);
GSList* g_slist_prepend (GSList *list, GSList* g_slist_prepend (GSList *list,
gpointer data); gpointer data);
GSList* g_slist_insert (GSList *list, GSList* g_slist_insert (GSList *list,
gpointer data, gpointer data,
gint position); gint position);
GSList* g_slist_concat (GSList *list1, GSList* g_slist_concat (GSList *list1,
GSList *list2); GSList *list2);
GSList* g_slist_remove (GSList *list, GSList* g_slist_remove (GSList *list,
gpointer data); gpointer data);
GSList* g_slist_remove_link (GSList *list, GSList* g_slist_remove_link (GSList *list,
GSList *link); GSList *link);
GSList* g_slist_reverse (GSList *list); GSList* g_slist_reverse (GSList *list);
GSList* g_slist_nth (GSList *list, GSList* g_slist_nth (GSList *list,
gint n); gint n);
GSList* g_slist_find (GSList *list, GSList* g_slist_find (GSList *list,
gpointer data); gpointer data);
GSList* g_slist_last (GSList *list); GSList* g_slist_last (GSList *list);
gint g_slist_length (GSList *list); gint g_slist_length (GSList *list);
void g_slist_foreach (GSList *list, void g_slist_foreach (GSList *list,
GFunc func, GFunc func,
gpointer user_data); gpointer user_data);
@ -431,72 +431,72 @@ void g_slist_foreach (GSList *list,
/* List Allocators /* List Allocators
*/ */
GListAllocator* g_list_allocator_new (void); GListAllocator* g_list_allocator_new (void);
void g_list_allocator_free (GListAllocator* allocator); void g_list_allocator_free (GListAllocator* allocator);
GListAllocator* g_slist_set_allocator (GListAllocator* allocator); GListAllocator* g_slist_set_allocator (GListAllocator* allocator);
GListAllocator* g_list_set_allocator (GListAllocator* allocator); GListAllocator* g_list_set_allocator (GListAllocator* allocator);
/* Hash tables /* Hash tables
*/ */
GHashTable* g_hash_table_new (GHashFunc hash_func, GHashTable* g_hash_table_new (GHashFunc hash_func,
GCompareFunc key_compare_func); GCompareFunc key_compare_func);
void g_hash_table_destroy (GHashTable *hash_table); void g_hash_table_destroy (GHashTable *hash_table);
void g_hash_table_insert (GHashTable *hash_table, void g_hash_table_insert (GHashTable *hash_table,
gpointer key, gpointer key,
gpointer value); gpointer value);
void g_hash_table_remove (GHashTable *hash_table, void g_hash_table_remove (GHashTable *hash_table,
gpointer key); gpointer key);
gpointer g_hash_table_lookup (GHashTable *hash_table, gpointer g_hash_table_lookup (GHashTable *hash_table,
const gpointer key); const gpointer key);
void g_hash_table_freeze (GHashTable *hash_table); void g_hash_table_freeze (GHashTable *hash_table);
void g_hash_table_thaw (GHashTable *hash_table); void g_hash_table_thaw (GHashTable *hash_table);
void g_hash_table_foreach (GHashTable *hash_table, void g_hash_table_foreach (GHashTable *hash_table,
GHFunc func, GHFunc func,
gpointer user_data); gpointer user_data);
/* Caches /* Caches
*/ */
GCache* g_cache_new (GCacheNewFunc value_new_func, GCache* g_cache_new (GCacheNewFunc value_new_func,
GCacheDestroyFunc value_destroy_func, GCacheDestroyFunc value_destroy_func,
GCacheDupFunc key_dup_func, GCacheDupFunc key_dup_func,
GCacheDestroyFunc key_destroy_func, GCacheDestroyFunc key_destroy_func,
GHashFunc hash_key_func, GHashFunc hash_key_func,
GHashFunc hash_value_func, GHashFunc hash_value_func,
GCompareFunc key_compare_func); GCompareFunc key_compare_func);
void g_cache_destroy (GCache *cache); void g_cache_destroy (GCache *cache);
gpointer g_cache_insert (GCache *cache, gpointer g_cache_insert (GCache *cache,
gpointer key); gpointer key);
void g_cache_remove (GCache *cache, void g_cache_remove (GCache *cache,
gpointer value); gpointer value);
void g_cache_key_foreach (GCache *cache, void g_cache_key_foreach (GCache *cache,
GHFunc func, GHFunc func,
gpointer user_data); gpointer user_data);
void g_cache_value_foreach (GCache *cache, void g_cache_value_foreach (GCache *cache,
GHFunc func, GHFunc func,
gpointer user_data); gpointer user_data);
/* Trees /* Trees
*/ */
GTree* g_tree_new (GCompareFunc key_compare_func); GTree* g_tree_new (GCompareFunc key_compare_func);
void g_tree_destroy (GTree *tree); void g_tree_destroy (GTree *tree);
void g_tree_insert (GTree *tree, void g_tree_insert (GTree *tree,
gpointer key, gpointer key,
gpointer value); gpointer value);
void g_tree_remove (GTree *tree, void g_tree_remove (GTree *tree,
gpointer key); gpointer key);
gpointer g_tree_lookup (GTree *tree, gpointer g_tree_lookup (GTree *tree,
gpointer key); gpointer key);
void g_tree_traverse (GTree *tree, void g_tree_traverse (GTree *tree,
GTraverseFunc traverse_func, GTraverseFunc traverse_func,
GTraverseType traverse_type, GTraverseType traverse_type,
gpointer data); gpointer data);
gpointer g_tree_search (GTree *tree, gpointer g_tree_search (GTree *tree,
GSearchFunc search_func, GSearchFunc search_func,
gpointer data); gpointer data);
gint g_tree_height (GTree *tree); gint g_tree_height (GTree *tree);
gint g_tree_nnodes (GTree *tree); gint g_tree_nnodes (GTree *tree);
/* Memory /* Memory
@ -504,23 +504,23 @@ gint g_tree_nnodes (GTree *tree);
#ifdef USE_DMALLOC #ifdef USE_DMALLOC
#define g_malloc(size) (gpointer) MALLOC(size) #define g_malloc(size) (gpointer) MALLOC(size)
#define g_malloc0(size) (gpointer) CALLOC(char,size) #define g_malloc0(size) (gpointer) CALLOC(char,size)
#define g_realloc(mem,size) (gpointer) REALLOC(mem,char,size) #define g_realloc(mem,size) (gpointer) REALLOC(mem,char,size)
#define g_free(mem) FREE(mem) #define g_free(mem) FREE(mem)
#else /* USE_DMALLOC */ #else /* USE_DMALLOC */
gpointer g_malloc (gulong size); gpointer g_malloc (gulong size);
gpointer g_malloc0 (gulong size); gpointer g_malloc0 (gulong size);
gpointer g_realloc (gpointer mem, gpointer g_realloc (gpointer mem,
gulong size); gulong size);
void g_free (gpointer mem); void g_free (gpointer mem);
#endif /* USE_DMALLOC */ #endif /* USE_DMALLOC */
void g_mem_profile (void); void g_mem_profile (void);
void g_mem_check (gpointer mem); void g_mem_check (gpointer mem);
/* "g_mem_chunk_new" creates a new memory chunk. /* "g_mem_chunk_new" creates a new memory chunk.
@ -542,21 +542,21 @@ void g_mem_check (gpointer mem);
* ALLOC_AND_FREE MemChunk's can allocate and free memory. * ALLOC_AND_FREE MemChunk's can allocate and free memory.
*/ */
#define G_ALLOC_ONLY 1 #define G_ALLOC_ONLY 1
#define G_ALLOC_AND_FREE 2 #define G_ALLOC_AND_FREE 2
GMemChunk* g_mem_chunk_new (gchar *name, GMemChunk* g_mem_chunk_new (gchar *name,
gint atom_size, gint atom_size,
gulong area_size, gulong area_size,
gint type); gint type);
void g_mem_chunk_destroy (GMemChunk *mem_chunk); void g_mem_chunk_destroy (GMemChunk *mem_chunk);
gpointer g_mem_chunk_alloc (GMemChunk *mem_chunk); gpointer g_mem_chunk_alloc (GMemChunk *mem_chunk);
void g_mem_chunk_free (GMemChunk *mem_chunk, void g_mem_chunk_free (GMemChunk *mem_chunk,
gpointer mem); gpointer mem);
void g_mem_chunk_clean (GMemChunk *mem_chunk); void g_mem_chunk_clean (GMemChunk *mem_chunk);
void g_mem_chunk_reset (GMemChunk *mem_chunk); void g_mem_chunk_reset (GMemChunk *mem_chunk);
void g_mem_chunk_print (GMemChunk *mem_chunk); void g_mem_chunk_print (GMemChunk *mem_chunk);
void g_mem_chunk_info (void); void g_mem_chunk_info (void);
/* Ah yes...we have a "g_blow_chunks" function. /* Ah yes...we have a "g_blow_chunks" function.
* "g_blow_chunks" simply compresses all the chunks. This operation * "g_blow_chunks" simply compresses all the chunks. This operation
@ -571,13 +571,13 @@ void g_blow_chunks (void);
/* Timer /* Timer
*/ */
GTimer* g_timer_new (void); GTimer* g_timer_new (void);
void g_timer_destroy (GTimer *timer); void g_timer_destroy (GTimer *timer);
void g_timer_start (GTimer *timer); void g_timer_start (GTimer *timer);
void g_timer_stop (GTimer *timer); void g_timer_stop (GTimer *timer);
void g_timer_reset (GTimer *timer); void g_timer_reset (GTimer *timer);
gdouble g_timer_elapsed (GTimer *timer, gdouble g_timer_elapsed (GTimer *timer,
gulong *microseconds); gulong *microseconds);
/* Output /* Output
@ -596,9 +596,11 @@ void g_print (gchar *format, ...);
/* Utility functions /* Utility functions
*/ */
gchar* g_strdup (const gchar *str); gchar* g_strdup (const gchar *str);
gchar* g_strerror (gint errnum); gchar* g_strconcat (const gchar *string1, ...); /* NULL terminated */
gchar* g_strsignal (gint signum); gdouble g_strtod (const gchar *nptr, gchar **endptr);
gchar* g_strerror (gint errnum);
gchar* g_strsignal (gint signum);
/* We make the assumption that if memmove isn't available, then /* We make the assumption that if memmove isn't available, then
* bcopy will do the job. This isn't safe everywhere. (bcopy can't * bcopy will do the job. This isn't safe everywhere. (bcopy can't
@ -611,29 +613,29 @@ gchar* g_strsignal (gint signum);
/* Errors /* Errors
*/ */
GErrorFunc g_set_error_handler (GErrorFunc func); GErrorFunc g_set_error_handler (GErrorFunc func);
GWarningFunc g_set_warning_handler (GWarningFunc func); GWarningFunc g_set_warning_handler (GWarningFunc func);
GPrintFunc g_set_message_handler (GPrintFunc func); GPrintFunc g_set_message_handler (GPrintFunc func);
GPrintFunc g_set_print_handler (GPrintFunc func); GPrintFunc g_set_print_handler (GPrintFunc func);
void g_debug (char *progname); void g_debug (char *progname);
void g_attach_process (char *progname, int query); void g_attach_process (char *progname, int query);
void g_stack_trace (char *progname, int query); void g_stack_trace (char *progname, int query);
/* String Chunks /* String Chunks
*/ */
GStringChunk* g_string_chunk_new (gint size); GStringChunk* g_string_chunk_new (gint size);
void g_string_chunk_free (GStringChunk *chunk); void g_string_chunk_free (GStringChunk *chunk);
gchar* g_string_chunk_insert (GStringChunk *chunk, gchar* g_string_chunk_insert (GStringChunk *chunk,
gchar* string); gchar* string);
gchar* g_string_chunk_insert_const (GStringChunk *chunk, gchar* g_string_chunk_insert_const (GStringChunk *chunk,
gchar* string); gchar* string);
/* Strings /* Strings
*/ */
GString* g_string_new (gchar *init); GString* g_string_new (gchar *init);
void g_string_free (GString *string, void g_string_free (GString *string,
gint free_segment); gint free_segment);
GString* g_string_assign (GString *lval, GString* g_string_assign (GString *lval,
gchar *rval); gchar *rval);
@ -647,10 +649,10 @@ GString* g_string_prepend (GString *string,
gchar *val); gchar *val);
GString* g_string_prepend_c (GString *string, GString* g_string_prepend_c (GString *string,
gchar c); gchar c);
void g_string_sprintf (GString *string, void g_string_sprintf (GString *string,
gchar *fmt, gchar *fmt,
...); ...);
void g_string_sprintfa (GString *string, void g_string_sprintfa (GString *string,
gchar *fmt, gchar *fmt,
...); ...);
@ -669,19 +671,18 @@ void g_string_sprintfa (GString *string,
#define g_array_index(array,type,index) \ #define g_array_index(array,type,index) \
((type*) array->data)[index] ((type*) array->data)[index]
GArray* g_array_new (gint zero_terminated); GArray* g_array_new (gint zero_terminated);
void g_array_free (GArray *array, void g_array_free (GArray *array,
gint free_segment); gint free_segment);
GArray* g_rarray_append (GArray *array, GArray* g_rarray_append (GArray *array,
gpointer data, gpointer data,
gint size); gint size);
GArray* g_rarray_prepend (GArray *array, GArray* g_rarray_prepend (GArray *array,
gpointer data, gpointer data,
gint size); gint size);
GArray* g_rarray_truncate (GArray *array, GArray* g_rarray_truncate (GArray *array,
gint length, gint length,
gint size); gint size);
/* Hash Functions /* Hash Functions
*/ */
@ -690,6 +691,178 @@ gint g_string_equal (gpointer v,
guint g_string_hash (gpointer v); guint g_string_hash (gpointer v);
/* GScanner: Flexible lexical scanner for general purpose.
* Copyright (C) 1997 Tim Janik
*/
/* 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"
typedef union _GValue GValue;
typedef struct _GScannerConfig GScannerConfig;
typedef struct _GScanner GScanner;
/* 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?
*/
guint32 case_sensitive : 1;
/* Boolean values to be adjusted "on the fly"
* to configure scanning behaviour.
*/
guint32 skip_comment_multi : 1; /* C like comment */
guint32 skip_comment_single : 1; /* single line comment */
guint32 scan_comment_multi : 1; /* scan multi line comments? */
guint32 scan_identifier : 1;
guint32 scan_identifier_1char : 1;
guint32 scan_identifier_NULL : 1;
guint32 scan_symbols : 1;
guint32 scan_binary : 1;
guint32 scan_octal : 1;
guint32 scan_float : 1;
guint32 scan_hex : 1; /* `0x0ff0' */
guint32 scan_hex_dollar : 1; /* `$0ff0' */
guint32 scan_string_sq : 1; /* string: 'anything' */
guint32 scan_string_dq : 1; /* string: "\\-escapes!\n" */
guint32 numbers_2_int : 1; /* bin, octal, hex => int */
guint32 int_2_float : 1; /* int => G_TOKEN_FLOAT? */
guint32 identifier_2_string : 1;
guint32 char_2_token : 1; /* return G_TOKEN_CHAR? */
guint32 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;
};
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_remove_symbol (GScanner *scanner,
const gchar *symbol);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif /* __cplusplus */ #endif /* __cplusplus */

1134
glib/gscanner.c Normal file
View File

File diff suppressed because it is too large Load Diff

79
glib/gutils.c
View File

@ -8,7 +8,7 @@
* *
* This library is distributed in the hope that it will be useful, * This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details. * Library 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 Library General Public
@ -17,7 +17,9 @@
*/ */
#include <stdarg.h> #include <stdarg.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h>
#include <string.h> #include <string.h>
#include <locale.h>
#include "glib.h" #include "glib.h"
@ -43,6 +45,81 @@ g_strdup (const gchar *str)
return new_str; return new_str;
} }
gchar*
g_strconcat (const gchar *string1, ...)
{
guint l;
va_list args;
gchar *s;
gchar *concat;
g_return_val_if_fail (string1 != NULL, NULL);
l = 1 + strlen (string1);
va_start (args, string1);
s = va_arg (args, gchar*);
while (s)
{
l += strlen (s);
s = va_arg (args, gchar*);
}
va_end (args);
concat = g_new (gchar, l);
concat[0] = 0;
strcat (concat, string1);
va_start (args, string1);
s = va_arg (args, gchar*);
while (s)
{
strcat (concat, s);
s = va_arg (args, gchar*);
}
va_end (args);
return concat;
}
gdouble
g_strtod (const gchar *nptr,
gchar **endptr)
{
gchar *fail_pos_1;
gchar *fail_pos_2;
gdouble val_1;
gdouble val_2 = 0;
g_return_val_if_fail (nptr != NULL, 0);
fail_pos_1 = NULL;
fail_pos_2 = NULL;
val_1 = strtod (nptr, &fail_pos_1);
if (fail_pos_1 && fail_pos_1[0] != 0)
{
gchar *old_locale;
old_locale = setlocale (LC_NUMERIC, "C");
val_2 = strtod (nptr, &fail_pos_2);
setlocale (LC_NUMERIC, old_locale);
}
if (!fail_pos_1 || fail_pos_1[0] == 0 || fail_pos_1 >= fail_pos_2)
{
if (endptr)
*endptr = fail_pos_1;
return val_1;
}
else
{
if (endptr)
*endptr = fail_pos_2;
return val_2;
}
}
gchar* gchar*
g_strerror (gint errnum) g_strerror (gint errnum)
{ {